Fix viewport rect covering for drawing.

@TODO Make special "ForEachInRect" function with RectId.

indexer/covering.cpp

@@ -89,14 +89,16 @@ vector<int64_t> CoverFeature(FeatureType const & f, uint64_t cellPenaltyArea)
   return res;
 }
 
-vector<pair<int64_t, int64_t> > SortAndMergeIntervals(vector<pair<int64_t, int64_t> > v)
+IntervalsT SortAndMergeIntervals(IntervalsT v)
 {
 #ifdef DEBUG
   for (size_t i = 0; i < v.size(); ++i)
     ASSERT_LESS(v[i].first, v[i].second, (i));
 #endif
+
   sort(v.begin(), v.end());
-  vector<pair<int64_t, int64_t> > res;
+
+  IntervalsT res;
   res.reserve(v.size());
   for (size_t i = 0; i < v.size(); ++i)
   {
@@ -105,48 +107,45 @@ vector<pair<int64_t, int64_t> > SortAndMergeIntervals(vector<pair<int64_t, int64
     else
       res.back().second = max(res.back().second, v[i].second);
   }
+
   return res;
 }
 
-namespace
+void AppendLowerLevels(RectId id, IntervalsT & intervals)
 {
-  vector<pair<int64_t, int64_t> > AppendLowerLevels(vector<RectId> const & ids)
+  int64_t idInt64 = id.ToInt64();
+  intervals.push_back(make_pair(idInt64, idInt64 + id.SubTreeSize()));
+  while (id.Level() > 0)
   {
-    vector<pair<int64_t, int64_t> > intervals;
-    intervals.reserve(ids.size() * 4);
-
-    for (vector<RectId>::const_iterator it = ids.begin(); it != ids.end(); ++it)
-    {
-      RectId id = *it;
-      int64_t idInt64 = id.ToInt64();
-      intervals.push_back(pair<int64_t, int64_t>(idInt64, idInt64 + id.SubTreeSize()));
-      while (id.Level() > 0)
-      {
-        id = id.Parent();
-        idInt64 = id.ToInt64();
-        intervals.push_back(pair<int64_t, int64_t>(idInt64, idInt64 + 1));
-      }
-    }
-
-    return SortAndMergeIntervals(intervals);
+    id = id.Parent();
+    idInt64 = id.ToInt64();
+    intervals.push_back(make_pair(idInt64, idInt64 + 1));
   }
 }
 
-vector<pair<int64_t, int64_t> > CoverViewportAndAppendLowerLevels(m2::RectD const & r)
+IntervalsT CoverViewportAndAppendLowerLevels(m2::RectD const & r)
 {
   vector<RectId> ids;
   CoverRect<MercatorBounds, RectId>(r.minX(), r.minY(), r.maxX(), r.maxY(), 8, ids);
 
-  return AppendLowerLevels(ids);
+  IntervalsT intervals;
+  intervals.reserve(ids.size() * 4);
+
+  for (size_t i = 0; i < ids.size(); ++i)
+    AppendLowerLevels(ids[i], intervals);
+
+  return SortAndMergeIntervals(intervals);
 }
 
-vector<pair<int64_t, int64_t> > CoverLowerLevelsOnly(m2::RectD const & r)
+RectId GetRectIdAsIs(m2::RectD const & r)
 {
-  vector<RectId> ids;
-  ids.push_back(CellIdConverter<MercatorBounds, RectId>::Cover2PointsWithCell(
-        r.minX(), r.minY(), r.maxX(), r.maxY()));
+  double const eps = MercatorBounds::GetCellID2PointAbsEpsilon();
 
-  return AppendLowerLevels(ids);
+  return CellIdConverter<MercatorBounds, RectId>::Cover2PointsWithCell(
+    MercatorBounds::ClampX(r.minX() + eps),
+    MercatorBounds::ClampY(r.minY() + eps),
+    MercatorBounds::ClampX(r.maxX() - eps),
+    MercatorBounds::ClampY(r.maxY() - eps));
 }
 
 }

indexer/covering.hpp

@@ -1,4 +1,5 @@
 #pragma once
+#include "point_to_int64.hpp"
 
 #include "../geometry/rect2d.hpp"
 
@@ -11,15 +12,19 @@ class FeatureType;
 
 namespace covering
 {
+  typedef vector<pair<int64_t, int64_t> > IntervalsT;
+
   // Cover feature with RectIds and return their integer representations.
   vector<int64_t> CoverFeature(FeatureType const & feature,
                                uint64_t cellPenaltyArea);
 
-  // Cover viewport with RectIds and append their RectIds as well.
-  vector<pair<int64_t, int64_t> > CoverViewportAndAppendLowerLevels(m2::RectD const & rect);
+  void AppendLowerLevels(RectId id, IntervalsT & intervals);
 
-  vector<pair<int64_t, int64_t> > CoverLowerLevelsOnly(m2::RectD const & rect);
+  // Cover viewport with RectIds and append their RectIds as well.
+  IntervalsT CoverViewportAndAppendLowerLevels(m2::RectD const & rect);
 
   // Given a vector of intervals [a, b), sort them and merge overlapping intervals.
-  vector<pair<int64_t, int64_t> > SortAndMergeIntervals(vector<pair<int64_t, int64_t> > intervals);
+  IntervalsT SortAndMergeIntervals(IntervalsT intervals);
+
+  RectId GetRectIdAsIs(m2::RectD const & r);
 }

indexer/index.hpp

@@ -38,10 +38,18 @@ public:
   template <typename F>
   void ForEachInRect(F const & f, m2::RectD const & rect, uint32_t scale, Query & query) const
   {
-    vector<pair<int64_t, int64_t> > intervals = covering::CoverViewportAndAppendLowerLevels(rect);
+    using namespace covering;
+
+    //IntervalsT const intervals = CoverViewportAndAppendLowerLevels(rect);
+
+    IntervalsT intervals;
+    AppendLowerLevels(GetRectIdAsIs(rect), intervals);
+
     for (size_t i = 0; i < intervals.size(); ++i)
-      BaseT::ForEachInIntervalAndScale(f, intervals[i].first, intervals[i].second, scale,
-                                       rect, query);
+    {
+      BaseT::ForEachInIntervalAndScale(f, intervals[i].first, intervals[i].second,
+                                       scale, rect, query);
+    }
   }
 
   template <typename F>

map/render_queue_routine.cpp

@@ -173,9 +173,10 @@ void RenderQueueRoutine::Do()
 
     m2::RectD selectionRect;
 
-    double inflationSize = 24 * m_visualScale;
+    double const inflationSize = 24 * m_visualScale;
 
-    frameScreen.PtoG(m2::Inflate(m2::RectD(renderRect), inflationSize, inflationSize), selectionRect);
+    //frameScreen.PtoG(m2::Inflate(m2::RectD(renderRect), inflationSize, inflationSize), selectionRect);
+    frameScreen.PtoG(m2::RectD(renderRect), selectionRect);
 
     m_currentCommand->m_renderFn(
         m_currentCommand->m_paintEvent,