[map] move the track stats calc logic from ElevationInfo to the Track…

…Statistics

Signed-off-by: Kiryl Kaveryn <[email protected]>

iphone/CoreApi/CoreApi/Bookmarks/TrackInfo+Core.h

@@ -1,14 +1,10 @@
 #import "TrackInfo.h"
 
 #include <CoreApi/Framework.h>
-#include "map/gps_track_collection.hpp"
-#include "map/elevation_info.hpp"
+#include "map/track_statistics.hpp"
 
 @interface TrackInfo (Core)
 
-- (instancetype)initWithGpsTrackInfo:(GpsTrackInfo const &)info;
-- (instancetype)initWithDistance:(double)distance duration:(double)duration;
-
-- (void)setElevationInfo:(ElevationInfo const &)elevationInfo;
+- (instancetype)initWithTrackStatistics:(TrackStatistics const &)statistics;
 
 @end

iphone/CoreApi/CoreApi/Bookmarks/TrackInfo.mm

@@ -3,8 +3,6 @@
 #import "DistanceFormatter.h"
 #import "DurationFormatter.h"
 
-#include "map/elevation_info.hpp"
-
 @implementation TrackInfo
 
 - (BOOL)hasElevationInfo {
@@ -19,31 +17,16 @@ + (TrackInfo *)emptyInfo {
 
 @implementation TrackInfo (Core)
 
-- (instancetype)initWithGpsTrackInfo:(GpsTrackInfo const &)trackInfo {
-  if (self = [super init]) {
-    _distance = trackInfo.m_length;
-    _duration = trackInfo.m_duration;
-    _ascent = trackInfo.m_ascent;
-    _descent = trackInfo.m_descent;
-    _maxElevation = trackInfo.m_maxElevation;
-    _minElevation = trackInfo.m_minElevation;
-  }
-  return self;
-}
-
-- (instancetype)initWithDistance:(double)distance duration:(double)duration {
+- (instancetype)initWithTrackStatistics:(TrackStatistics const &)statistics {
   if (self = [super init]) {
-    _distance = distance;
-    _duration = duration;
+    _distance = statistics.m_length;
+    _duration = statistics.m_duration;
+    _ascent = statistics.m_ascent;
+    _descent = statistics.m_descent;
+    _maxElevation = statistics.m_maxElevation;
+    _minElevation = statistics.m_minElevation;
   }
   return self;
 }
 
-- (void)setElevationInfo:(ElevationInfo const &)elevationInfo {
-  _ascent = elevationInfo.GetAscent();
-  _descent = elevationInfo.GetDescent();
-  _maxElevation = elevationInfo.GetMaxAltitude();
-  _minElevation = elevationInfo.GetMinAltitude();
-}
-
 @end

iphone/CoreApi/CoreApi/Framework/MWMFrameworkHelper.mm

@@ -224,8 +224,8 @@ + (void)setTrackRecordingUpdateHandler:(TrackRecordingUpdatedHandler _Nullable)t
     GetFramework().SetTrackRecordingUpdateHandler(nullptr);
     return;
   }
-  GetFramework().SetTrackRecordingUpdateHandler([trackRecordingDidUpdate](GpsTrackInfo const & gpsTrackInfo) {
-    TrackInfo * info = [[TrackInfo alloc] initWithGpsTrackInfo:gpsTrackInfo];
+  GetFramework().SetTrackRecordingUpdateHandler([trackRecordingDidUpdate](TrackStatistics const & statistics) {
+    TrackInfo * info = [[TrackInfo alloc] initWithTrackStatistics:statistics];
     trackRecordingDidUpdate(info);
   });
 }

iphone/CoreApi/CoreApi/PlacePageData/Common/PlacePageTrackData.mm

@@ -12,11 +12,9 @@ - (instancetype)initWithTrack:(Track const &)track {
   self = [super init];
   if (self) {
     _trackId = track.GetData().m_id;
-    _trackInfo = [[TrackInfo alloc] initWithDistance:track.GetLengthMeters()
-                                                     duration:track.GetDurationInSeconds()];
+    _trackInfo = [[TrackInfo alloc] initWithTrackStatistics:track.GetStatistics()];
     auto const & elevationInfo = track.GetElevationInfo();
     if (track.HasAltitudes() && elevationInfo.has_value()) {
-      [_trackInfo setElevationInfo:elevationInfo.value()];
       auto const & bm = GetFramework().GetBookmarkManager();
       _elevationProfileData = [[ElevationProfileData alloc] initWithTrackId:_trackId
                                                               elevationInfo:elevationInfo.value()

map/CMakeLists.txt

@@ -57,6 +57,8 @@ set(SRC
   search_product_info.hpp
   track.cpp
   track.hpp
+  track_statistics.cpp
+  track_statistics.hpp
   track_mark.cpp
   track_mark.hpp
   traffic_manager.cpp

map/elevation_info.cpp

@@ -4,54 +4,60 @@
 
 #include "geometry/mercator.hpp"
 
-ElevationInfo::ElevationInfo(kml::MultiGeometry const & geometry)
+using namespace geometry;
+using namespace mercator;
+
+ElevationInfo::ElevationInfo(std::vector<GeometryLine> const & lines)
 {
-  double distance = 0;
   // Concatenate all segments.
-  for (size_t lineIndex = 0; lineIndex < geometry.m_lines.size(); ++lineIndex)
+  for (size_t lineIndex = 0; lineIndex < lines.size(); ++lineIndex)
   {
-    auto const & line = geometry.m_lines[lineIndex];
+    auto const & line = lines[lineIndex];
     if (line.empty())
-    {
-      LOG(LWARNING, ("Empty line in elevation info"));
       continue;
-    }
 
-    if (lineIndex == 0)
+    if (lineIndex > 0)
+      m_segmentsDistances.emplace_back(m_points.back().m_distance);
+
+    AddPoints(line, true /* new segment */);
+  }
+  /// @todo(KK) Implement difficulty calculation.
+  m_difficulty = Difficulty::Unknown;
+}
+
+void ElevationInfo::AddGpsPoints(GpsPoints const & points)
+{
+  GeometryLine line;
+  line.reserve(points.size());
+  for (auto const & point : points)
+    line.emplace_back(FromLatLon(point.m_latitude, point.m_longitude), point.m_altitude);
+  AddPoints(line);
+}
+
+void ElevationInfo::AddPoints(GeometryLine const & line, bool isNewSegment)
+{
+  if (line.empty())
+    return;
+
+  double distance = m_points.empty() ? 0 : m_points.back().m_distance;
+  for (size_t pointIndex = 0; pointIndex < line.size(); ++pointIndex)
+  {
+    auto const & point = line[pointIndex];
+
+    if (m_points.empty())
     {
-      m_minAltitude = line.front().GetAltitude();
-      m_maxAltitude = m_minAltitude;
+      m_points.emplace_back(point, distance);
+      continue;
     }
 
-    if (lineIndex > 0)
-      m_segmentsDistances.emplace_back(distance);
-
-    for (size_t pointIndex = 0; pointIndex < line.size(); ++pointIndex)
+    if (isNewSegment && pointIndex == 0)
     {
-      auto const & currentPoint = line[pointIndex];
-      auto const & currentPointAltitude = currentPoint.GetAltitude();
-      if (currentPointAltitude < m_minAltitude)
-        m_minAltitude = currentPointAltitude;
-      if (currentPointAltitude > m_maxAltitude)
-        m_maxAltitude = currentPointAltitude;
-
-      if (pointIndex == 0)
-      {
-        m_points.emplace_back(currentPoint, distance);
-        continue;
-      }
-
-      auto const & previousPoint = line[pointIndex - 1];
-      distance += mercator::DistanceOnEarth(previousPoint.GetPoint(), currentPoint.GetPoint());
-      m_points.emplace_back(currentPoint, distance);
-
-      auto const deltaAltitude = currentPointAltitude - previousPoint.GetAltitude();
-      if (deltaAltitude > 0)
-        m_ascent += deltaAltitude;
-      else
-        m_descent -= deltaAltitude;
+      m_points.emplace_back(point, distance);
+      continue;
     }
+
+    auto const & previousPoint = m_points.back().m_point;
+    distance += mercator::DistanceOnEarth(previousPoint.GetPoint(), point.GetPoint());
+    m_points.emplace_back(point, distance);
   }
-  /// @todo(KK) Implement difficulty calculation.
-  m_difficulty = Difficulty::Unknown;
 }

map/elevation_info.hpp

@@ -5,6 +5,8 @@
 #include "geometry/point_with_altitude.hpp"
 #include "geometry/latlon.hpp"
 
+#include "platform/location.hpp"
+
 #include <cstdint>
 #include <string>
 #include <vector>
@@ -22,6 +24,8 @@ struct ElevationInfo
   };
 
   using Points = std::vector<Point>;
+  using GpsPoints = std::vector<location::GpsInfo>;
+  using GeometryLine = kml::MultiGeometry::LineT;
   using SegmentsDistances = std::vector<double>;
 
   enum Difficulty : uint8_t
@@ -33,31 +37,23 @@ struct ElevationInfo
   };
 
   ElevationInfo() = default;
-  explicit ElevationInfo(kml::MultiGeometry const & geometry);
+  explicit ElevationInfo(std::vector<GeometryLine> const & lines);
+
+  void AddGpsPoints(GpsPoints const & points);
 
   size_t GetSize() const { return m_points.size(); };
   Points const & GetPoints() const { return m_points; };
-  uint32_t GetAscent() const { return m_ascent; }
-  uint32_t GetDescent() const { return m_descent; }
-  geometry::Altitude GetMinAltitude() const { return m_minAltitude; }
-  geometry::Altitude GetMaxAltitude() const { return m_maxAltitude; }
   uint8_t GetDifficulty() const { return m_difficulty; }
   SegmentsDistances const & GetSegmentsDistances() const { return m_segmentsDistances; };
 
 private:
   // Points with distance from start of the track and altitude.
   Points m_points;
-  // Ascent in meters.
-  uint32_t m_ascent = 0;
-  // Descent in meters.
-  uint32_t m_descent = 0;
-  // Altitude in meters.
-  geometry::Altitude m_minAltitude = 0;
-  // Altitude in meters.
-  geometry::Altitude m_maxAltitude = 0;
   // Some digital difficulty level with value in range [0-kMaxDifficulty]
   // or kInvalidDifficulty when difficulty is not found or incorrect.
   Difficulty m_difficulty = Difficulty::Unknown;
   // Distances to the start of each segment.
   SegmentsDistances m_segmentsDistances;
+
+  void AddPoints(GeometryLine const & line, bool isNewSegment = false);
 };

map/framework.cpp

@@ -1736,7 +1736,7 @@ void Framework::SetTrackRecordingUpdateHandler(TrackRecordingUpdateHandler && tr
 {
   m_trackRecordingUpdateHandler = std::move(trackRecordingDidUpdate);
   if (m_trackRecordingUpdateHandler)
-    m_trackRecordingUpdateHandler(GpsTracker::Instance().GetTrackInfo());
+    m_trackRecordingUpdateHandler(GpsTracker::Instance().GetTrackStatistics());
 }
 
 void Framework::StopTrackRecording()
@@ -1768,7 +1768,7 @@ bool Framework::IsTrackRecordingEnabled() const
 
 void Framework::OnUpdateGpsTrackPointsCallback(vector<pair<size_t, location::GpsInfo>> && toAdd,
                                                pair<size_t, size_t> const & toRemove,
-                                               GpsTrackInfo const & trackInfo)
+                                               TrackStatistics const & trackStatistics)
 {
   ASSERT(m_drapeEngine.get() != nullptr, ());
 
@@ -1797,7 +1797,7 @@ void Framework::OnUpdateGpsTrackPointsCallback(vector<pair<size_t, location::Gps
   m_drapeEngine->UpdateGpsTrackPoints(std::move(pointsAdd), std::move(indicesRemove));
 
   if (m_trackRecordingUpdateHandler)
-    m_trackRecordingUpdateHandler(trackInfo);
+    m_trackRecordingUpdateHandler(trackStatistics);
 }
 
 void Framework::MarkMapStyle(MapStyle mapStyle)

map/framework.hpp

@@ -15,9 +15,9 @@
 #include "map/search_api.hpp"
 #include "map/search_mark.hpp"
 #include "map/track.hpp"
+#include "map/track_statistics.hpp"
 #include "map/traffic_manager.hpp"
 #include "map/transit/transit_reader.hpp"
-#include "map/gps_track_collection.hpp"
 
 #include "drape_frontend/gui/skin.hpp"
 #include "drape_frontend/drape_api.hpp"
@@ -437,7 +437,7 @@ class Framework : public PositionProvider,
   void ConnectToGpsTracker();
   void DisconnectFromGpsTracker();
 
-  using TrackRecordingUpdateHandler = platform::SafeCallback<void(GpsTrackInfo const & trackInfo)>;
+  using TrackRecordingUpdateHandler = platform::SafeCallback<void(TrackStatistics const & trackStatistics)>;
   void StartTrackRecording();
   void SetTrackRecordingUpdateHandler(TrackRecordingUpdateHandler && trackRecordingDidUpdate);
   void StopTrackRecording();
@@ -468,7 +468,7 @@ class Framework : public PositionProvider,
 
   void OnUpdateGpsTrackPointsCallback(std::vector<std::pair<size_t, location::GpsInfo>> && toAdd,
                                       std::pair<size_t, size_t> const & toRemove,
-                                      GpsTrackInfo const & trackInfo);
+                                      TrackStatistics const & trackStatistics);
 
   TrackRecordingUpdateHandler m_trackRecordingUpdateHandler;
 

map/gps_track.cpp

@@ -79,9 +79,9 @@ void GpsTrack::AddPoints(vector<location::GpsInfo> const & points)
   ScheduleTask();
 }
 
-GpsTrackInfo GpsTrack::GetTrackInfo() const
+TrackStatistics GpsTrack::GetTrackStatistics() const
 {
-  return m_collection ? m_collection->GetTrackInfo() : GpsTrackInfo();
+  return m_collection ? m_collection->GetTrackStatistics() : TrackStatistics();
 }
 
 void GpsTrack::Clear()
@@ -303,7 +303,7 @@ void GpsTrack::NotifyCallback(pair<size_t, size_t> const & addedIds, pair<size_t
     if (toAdd.empty())
       return; // nothing to send
 
-    m_callback(std::move(toAdd), make_pair(kInvalidId, kInvalidId), m_collection->GetTrackInfo());
+    m_callback(std::move(toAdd), make_pair(kInvalidId, kInvalidId), m_collection->GetTrackStatistics());
   }
   else
   {
@@ -324,6 +324,6 @@ void GpsTrack::NotifyCallback(pair<size_t, size_t> const & addedIds, pair<size_t
     if (toAdd.empty() && evictedIds.first == kInvalidId)
       return; // nothing to send
 
-    m_callback(std::move(toAdd), evictedIds, m_collection->GetTrackInfo());
+    m_callback(std::move(toAdd), evictedIds, m_collection->GetTrackStatistics());
   }
 }

map/gps_track.hpp

@@ -31,7 +31,7 @@ class GpsTrack final
   void AddPoints(std::vector<location::GpsInfo> const & points);
 
   /// Returns track statistics
-  GpsTrackInfo GetTrackInfo() const;
+  TrackStatistics GetTrackStatistics() const;
 
   /// Clears any previous tracking info
   /// @note Callback is called with 'toRemove' points, if some points were removed.
@@ -47,7 +47,7 @@ class GpsTrack final
   using TGpsTrackDiffCallback =
       std::function<void(std::vector<std::pair<size_t, location::GpsInfo>> && toAdd,
                          std::pair<size_t, size_t> const & toRemove,
-                         GpsTrackInfo const & trackInfo)>;
+                         TrackStatistics const & trackStatistics)>;
 
   /// Sets callback on change of gps track.
   /// @param callback - callback callable object