[search] Replace natural distance criteria with viewport distance.

search/intermediate_result.cpp

@@ -31,6 +31,7 @@ IntermediateResult::IntermediateResult(m2::RectD const & viewportRect,
   m_distance = ResultDistance(viewportRect.Center(), m_rect.Center());
   m_direction = ResultDirection(viewportRect.Center(), m_rect.Center());
   m_searchRank = feature::GetSearchRank(f);
+  m_viewportDistance = ViewportDistance(viewportRect, m_rect.Center());
 }
 
 IntermediateResult::IntermediateResult(m2::RectD const & viewportRect, string const & regionName,
@@ -43,11 +44,13 @@ IntermediateResult::IntermediateResult(m2::RectD const & viewportRect, string co
 {
   m_distance = ResultDistance(viewportRect.Center(), m_rect.Center());
   m_direction = ResultDirection(viewportRect.Center(), m_rect.Center());
+  m_viewportDistance = ViewportDistance(viewportRect, m_rect.Center());
 }
 
 IntermediateResult::IntermediateResult(string const & name, int penalty)
   : m_str(name), m_completionString(name + " "),
-    m_distance(0), m_direction(0),
+    /// @todo ??? Maybe we should initialize here by maximum value ???
+    m_distance(0), m_direction(0), m_viewportDistance(0),
     m_resultType(RESULT_CATEGORY),
     m_searchRank(0)
 {
@@ -74,7 +77,18 @@ bool IntermediateResult::LessRank(IntermediateResult const & r1, IntermediateRes
 
 bool IntermediateResult::LessDistance(IntermediateResult const & r1, IntermediateResult const & r2)
 {
-  return (r1.m_distance < r2.m_distance);
+  if (r1.m_distance != r2.m_distance)
+    return (r1.m_distance < r2.m_distance);
+  else
+    return LessRank(r1, r2);
+}
+
+bool IntermediateResult::LessViewportDistance(IntermediateResult const & r1, IntermediateResult const & r2)
+{
+  if (r1.m_viewportDistance != r2.m_viewportDistance)
+    return (r1.m_viewportDistance < r2.m_viewportDistance);
+  else
+    return LessRank(r1, r2);
 }
 
 Result IntermediateResult::GenerateFinalResult() const
@@ -108,6 +122,24 @@ double IntermediateResult::ResultDirection(m2::PointD const & a, m2::PointD cons
   return ang::AngleTo(a, b);
 }
 
+int IntermediateResult::ViewportDistance(m2::RectD const & viewport, m2::PointD const & p)
+{
+  if (viewport.IsPointInside(p))
+    return 0;
+
+  m2::RectD r = viewport;
+  r.Scale(3);
+  if (r.IsPointInside(p))
+    return 1;
+
+  r = viewport;
+  r.Scale(5);
+  if (r.IsPointInside(p))
+    return 2;
+
+  return 3;
+}
+
 bool IntermediateResult::StrictEqualF::operator()(IntermediateResult const & r) const
 {
   if (m_r.m_resultType == r.m_resultType && m_r.m_resultType == RESULT_FEATURE)
@@ -198,7 +230,8 @@ string IntermediateResult::DebugPrint() const
   string res("IntermediateResult: ");
   res += "Name: " + m_str;
   res += "; Type: " + ::DebugPrint(m_type);
-  res += "; Result type: " + ::DebugPrint(m_resultType);
+  res += "; Rank: " + ::DebugPrint(m_searchRank);
+  res += "; Distance: " + ::DebugPrint(m_viewportDistance);
   return res;
 }
 

search/intermediate_result.hpp

@@ -41,6 +41,7 @@ public:
 
   static bool LessRank(IntermediateResult const & r1, IntermediateResult const & r2);
   static bool LessDistance(IntermediateResult const & r1, IntermediateResult const & r2);
+  static bool LessViewportDistance(IntermediateResult const & r1, IntermediateResult const & r2);
 
   /// Filter equal features for different mwm's.
   class StrictEqualF
@@ -71,12 +72,17 @@ private:
                                m2::PointD const & featureCenter);
   static double ResultDirection(m2::PointD const & viewportCenter,
                                 m2::PointD const & featureCenter);
+  static int ViewportDistance(m2::RectD const & viewport, m2::PointD const & p);
 
   string m_str, m_completionString, m_region;
+
   m2::RectD m_rect;
   uint32_t m_type;
+
   double m_distance;
   double m_direction;
+  int m_viewportDistance;
+
   ResultType m_resultType;
   uint8_t m_searchRank;
 };
@@ -88,3 +94,11 @@ inline string DebugPrint(IntermediateResult const & t)
 
 }  // namespace search::impl
 }  // namespace search
+
+namespace boost
+{
+  inline string DebugPrint(shared_ptr<search::impl::IntermediateResult> const & p)
+  {
+    return DebugPrint(*p);
+  }
+}

search/search_query.cpp

@@ -132,7 +132,7 @@ namespace
   CompareFunctionT g_arrCompare[] =
   {
     &impl::IntermediateResult::LessRank,
-    &impl::IntermediateResult::LessDistance
+    &impl::IntermediateResult::LessViewportDistance
   };
 }
 
@@ -288,6 +288,8 @@ void Query::FlushResults(function<void (Result const &)> const & f)
 
     // sort in rank order
     sort(v[i].begin(), v[i].end(), CompareT(g_arrCompare[i]));
+
+    //LOG(LDEBUG, (v[i]));
   }
 
   vector<IndexedValue> indV;
@@ -295,8 +297,15 @@ void Query::FlushResults(function<void (Result const &)> const & f)
   // fill results vector with indexed values (keys - indexes for each criteria)
   for (size_t i = 0; i < m_qCount; ++i)
   {
+    CompareT comp(g_arrCompare[i]);
+    size_t rank = 0;
+
     for (size_t j = 0; j < v[i].size(); ++j)
     {
+      // increment rank only if previous element is really less than current
+      if (j > 0 && comp(v[i][j-1], v[i][j]))
+        ++rank;
+
       IndexedValue * p = 0;
       for (size_t k = 0; k < indV.size(); ++k)
       {
@@ -314,7 +323,7 @@ void Query::FlushResults(function<void (Result const &)> const & f)
         p = &(indV.back());
       }
 
-      p->SetIndex(i, j);
+      p->SetIndex(i, rank);
     }
   }