Fix FeatureBuilder1 limit rect routine. Add tests for geometry coding routing.

generator/feature_builder.cpp

@@ -9,6 +9,8 @@
 
 #include "../coding/byte_stream.hpp"
 
+#include "../base/logging.hpp"
+
 
 using namespace feature;
 
@@ -56,7 +58,15 @@ void FeatureBuilder1::SetAreaAddHoles(list<points_t> const & holes)
     ASSERT ( !i->empty(), (*this) );
 
     if (rgn.Contains(i->front()))
+    {
+#ifdef DEBUG
+    m2::RectD r;
+    CalcRect(*i, r);
+    ASSERT ( m_LimitRect.IsRectInside(r), (m_LimitRect, r) );
+#endif
+
       m_Polygons.push_back(*i);
+    }
   }
 }
 
@@ -199,7 +209,10 @@ bool FeatureBuilder1::operator == (FeatureBuilder1 const & fb) const
   }
 
   if (!is_equal(m_LimitRect, fb.m_LimitRect))
+  {
+    //LOG(LERROR, ("Different rects: ", m_LimitRect, fb.m_LimitRect));
     return false;
+  }
 
   if (m_Polygons.size() != fb.m_Polygons.size())
     return false;
@@ -208,7 +221,10 @@ bool FeatureBuilder1::operator == (FeatureBuilder1 const & fb) const
   list<points_t>::const_iterator j = fb.m_Polygons.begin();
   for (; i != m_Polygons.end(); ++i, ++j)
     if (!is_equal(*i, *j))
+    {
+      //LOG(LERROR, ("Different points: ", *i, *j));
       return false;
+    }
 
   return true;
 }
@@ -272,7 +288,7 @@ void FeatureBuilder1::Serialize(buffer_t & data) const
   buffer_t tmp(data);
   FeatureBuilder1 fb;
   fb.Deserialize(tmp);
-  ASSERT ( fb == *this, (*this) );
+  ASSERT ( fb == *this, ("Source feature: ", *this, "Deserialized feature: ", fb) );
 #endif
 }
 
@@ -283,8 +299,9 @@ void FeatureBuilder1::Deserialize(buffer_t & data)
   ArrayByteSource source(&data[0]);
   m_Params.Read(source);
 
-  EGeomType const type = m_Params.GetGeomType();
+  m_LimitRect.MakeEmpty();
 
+  EGeomType const type = m_Params.GetGeomType();
   if (type == GEOM_POINT)
   {
     CoordPointT const center = PointU2PointD(
@@ -333,12 +350,16 @@ string debug_print(FeatureBuilder1 const & f)
   switch (f.GetGeomType())
   {
   case GEOM_POINT: out << "(" << f.m_Center << ")"; break;
-  case GEOM_LINE: out << "line with " << f.GetPointsCount() << "points"; break;
-  case GEOM_AREA: out << "area with " << f.GetPointsCount() << "points"; break;
+  case GEOM_LINE: out << "line with " << f.GetPointsCount() << " points"; break;
+  case GEOM_AREA: out << "area with " << f.GetPointsCount() << " points"; break;
   default:
     out << "ERROR: unknown geometry type"; break;
   }
-  return out.str();
+
+  return (out.str() + " " +
+          debug_print(f.m_LimitRect) + " " +
+          debug_print(f.m_Params) + " " +
+          debug_print(f.m_Polygons));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////

generator/feature_merger.cpp

@@ -1,5 +1,6 @@
 #include "feature_merger.hpp"
 
+#include "../indexer/feature.hpp"
 #include "../indexer/point_to_int64.hpp"
 #include "../indexer/classificator.hpp"
 
@@ -41,22 +42,33 @@ void MergedFeatureBuilder1::AppendFeature(MergedFeatureBuilder1 const & fb, bool
 
   m_isRound = false;
 
-  for (size_t i = 0; i < fbG.size(); ++i)
-    m_LimitRect.Add(fbG[i]);
+  using namespace feature;
 
   if (fromBegin)
   {
     if (toBack)
+    {
       thisG.insert(thisG.end(), fbG.begin() + 1, fbG.end());
+      CalcRect(fbG.begin() + 1, fbG.end(), m_LimitRect);
+    }
     else
+    {
       thisG.insert(thisG.begin(), fbG.begin(), fbG.end() - 1);
+      CalcRect(fbG.begin(), fbG.end() - 1, m_LimitRect);
+    }
   }
   else
   {
     if (toBack)
+    {
       thisG.insert(thisG.end(), fbG.rbegin() + 1, fbG.rend());
+      CalcRect(fbG.rbegin() + 1, fbG.rend(), m_LimitRect);
+    }
     else
+    {
       thisG.insert(thisG.begin(), fbG.rbegin(), fbG.rend() - 1);
+      CalcRect(fbG.rbegin(), fbG.rend() - 1, m_LimitRect);
+    }
   }
 }
 

indexer/coding_params.cpp

@@ -7,7 +7,7 @@
 namespace serial
 {
   CodingParams::CodingParams()
-    : m_BasePointUint64(0), m_CoordBits(30)
+    : m_BasePointUint64(0), m_CoordBits(POINT_COORD_BITS)
   {
      m_BasePoint = m2::Uint64ToPointU(m_BasePointUint64);
   }

indexer/feature.hpp

@@ -281,10 +281,16 @@ private:
 
 namespace feature
 {
+  template <class IterT>
+  void CalcRect(IterT b, IterT e, m2::RectD & rect)
+  {
+    while (b != e)
+      rect.Add(*b++);
+  }
+
   template <class TCont>
   void CalcRect(TCont const & points, m2::RectD & rect)
   {
-    for (size_t i = 0; i < points.size(); ++i)
-      rect.Add(points[i]);
+    CalcRect(points.begin(), points.end(), rect);
   }
 }

indexer/feature_data.cpp

@@ -143,3 +143,14 @@ uint8_t FeatureParams::GetHeader() const
 
   return header;
 }
+
+string debug_print(FeatureParams const & p)
+{
+  ostringstream out;
+
+  out << "Types: ";
+  for (size_t i = 0; i < p.m_Types.size(); ++i)
+    out << p.m_Types[i] << "; ";
+
+  return out.str();
+}

indexer/feature_data.hpp

@@ -210,3 +210,5 @@ public:
     BaseT::Read(src, header, GetGeomType());
   }
 };
+
+string debug_print(FeatureParams const & p);

indexer/indexer_tests/geometry_coding_test.cpp

@@ -1,20 +1,21 @@
-#include "../geometry_coding.hpp"
 #include "../../testing/testing.hpp"
 
-//#include "../../indexer/mercator.hpp"
-//#include "../../indexer/point_to_int64.hpp"
+#include "../geometry_coding.hpp"
+#include "../point_to_int64.hpp"
+#include "../mercator.hpp"
+#include "../coding_params.hpp"
+
+#include "test_polylines.hpp"
 
 #include "../../geometry/geometry_tests/large_polygon.hpp"
 #include "../../geometry/distance.hpp"
 #include "../../geometry/simplification.hpp"
-//#include "../../geometry/pointu_to_uint64.hpp"
 
 #include "../../coding/byte_stream.hpp"
 #include "../../coding/varint.hpp"
 #include "../../coding/writer.hpp"
 
 #include "../../base/logging.hpp"
-//#include "../../base/array_adapters.hpp"
 
 
 typedef m2::PointU PU;
@@ -95,7 +96,7 @@ void TestPolylineEncode(string testName,
   size_t const count = points.size();
   if (count == 0) return;
 
-  m2::PointU const basePoint = points[count / 2];
+  m2::PointU const basePoint = serial::CodingParams().GetBasePoint();
 
   vector<uint64_t> deltas;
   deltas.resize(count);
@@ -171,3 +172,28 @@ UNIT_TEST(EncodePolyline)
 }
 
 // see 476c1d1d125f0c2deb8c commit for special decode test
+
+namespace
+{
+  inline m2::PointU D2U(m2::PointD const & p)
+  {
+    return PointD2PointU(p, POINT_COORD_BITS);
+  }
+
+  inline m2::PointU GetMaxPoint()
+  {
+    return D2U(m2::PointD(MercatorBounds::maxX, MercatorBounds::maxY));
+  }
+}
+
+UNIT_TEST(DecodeEncodePolyline_DataSet1)
+{
+  size_t const count = ARRAY_SIZE(index_test::arr1);
+  vector<m2::PointU> points;
+  points.reserve(count);
+  for (size_t i = 0; i < count; ++i)
+    points.push_back(D2U(index_test::arr1[i]));
+
+  TestPolylineEncode("DataSet1", points, GetMaxPoint(),
+                     &geo_coding::EncodePolyline, &geo_coding::DecodePolyline);
+}

indexer/indexer_tests/geometry_serialization_test.cpp

@@ -0,0 +1,69 @@
+#include "../../testing/testing.hpp"
+
+#include "test_polylines.hpp"
+
+#include "../geometry_serialization.hpp"
+#include "../coding_params.hpp"
+#include "../mercator.hpp"
+
+#include "../../coding/reader.hpp"
+#include "../../coding/byte_stream.hpp"
+
+#include "../../base/logging.hpp"
+
+
+// Copy-Paste from feature_builder.cpp
+namespace
+{
+  bool is_equal(double d1, double d2)
+  {
+    //return my::AlmostEqual(d1, d2, 100000000);
+    return (fabs(d1 - d2) < MercatorBounds::GetCellID2PointAbsEpsilon());
+  }
+
+  bool is_equal(m2::PointD const & p1, m2::PointD const & p2)
+  {
+    return p1.EqualDxDy(p2, MercatorBounds::GetCellID2PointAbsEpsilon());
+  }
+
+  bool is_equal(m2::RectD const & r1, m2::RectD const & r2)
+  {
+    return (is_equal(r1.minX(), r2.minX()) &&
+            is_equal(r1.minY(), r2.minY()) &&
+            is_equal(r1.maxX(), r2.maxX()) &&
+            is_equal(r1.maxY(), r2.maxY()));
+  }
+}
+
+
+UNIT_TEST(SaveLoadPolyline_DataSet1)
+{
+  using namespace index_test;
+
+  vector<m2::PointD> data1(arr1, arr1 + ARRAY_SIZE(arr1));
+
+  vector<char> buffer;
+  PushBackByteSink<vector<char> > w(buffer);
+
+  serial::CodingParams cp;
+  serial::SaveOuterPath(data1, cp, w);
+
+  vector<m2::PointD> data2;
+  ArrayByteSource r(&buffer[0]);
+  serial::LoadOuterPath(r, cp, data2);
+
+  TEST_EQUAL(data1.size(), data2.size(), ());
+
+  m2::RectD r1, r2;
+  for (size_t i = 0; i < data1.size(); ++i)
+  {
+    r1.Add(data1[i]);
+    r2.Add(data2[i]);
+
+    TEST(is_equal(data1[i], data2[i]), (data1[i], data2[i]));
+  }
+
+  LOG(LINFO, (data2));
+
+  TEST(is_equal(r1, r2), (r1, r2));
+}

indexer/indexer_tests/indexer_tests.pro

@@ -14,6 +14,7 @@ win32:LIBS += -lopengl32 -lShell32
 win32-g++:LIBS += -lpthread
 
 HEADERS += \
+    test_polylines.hpp
 
 
 SOURCES += \
@@ -31,3 +32,8 @@ SOURCES += \
     geometry_coding_test.cpp \
     triangles_tree_coding_test.cpp \
     scales_test.cpp \
+    test_polylines.cpp \
+    geometry_serialization_test.cpp \
+
+
+

indexer/indexer_tests/point_to_int64_test.cpp

@@ -1,12 +1,16 @@
 #include "../../testing/testing.hpp"
+
+#include "test_polylines.hpp"
+
 #include "../cell_id.hpp"
+
 #include "../../std/cmath.hpp"
 
 
 namespace
 {
   double const eps = MercatorBounds::GetCellID2PointAbsEpsilon();
-  uint32_t const coordBits = 30;
+  uint32_t const coordBits = POINT_COORD_BITS;
 
   void CheckEqualPoints(CoordPointT const & p1, CoordPointT const & p2)
   {
@@ -42,29 +46,6 @@ UNIT_TEST(PointToInt64_Smoke)
   }
 }
 
-/*
-UNIT_TEST(PointToInt64_908175295886057813)
-{
-  int64_t const id1 = 908175295886057813LL;
-  CoordPointT const pt1 = Int64ToPoint(id1);
-  int64_t const id2 = PointToInt64(pt1);
-  TEST_EQUAL(id1, id2, (pt1));
-}
-*/
-
-/*
-UNIT_TEST(PointToInt64_Values)
-{
-  CoordPointT const p = PointU2PointD(m2::PointU(3225901878, 23488265));
-
-  TEST_GREATER_OR_EQUAL(p.first, -180.0, ());
-  TEST_GREATER_OR_EQUAL(p.second, -180.0, ());
-
-  TEST_LESS_OR_EQUAL(p.first, 180.0, ());
-  TEST_LESS_OR_EQUAL(p.second, 180.0, ());
-}
-*/
-
 UNIT_TEST(PointToInt64_Grid)
 {
   int const delta = 5;
@@ -102,3 +83,18 @@ UNIT_TEST(PointToInt64_Bounds)
              fabs(pt.second - pt1.second) <= (fabs(arrEps[iY]) + eps), (pt, pt1));
       }
 }
+
+UNIT_TEST(PointToInt64_DataSet1)
+{
+  for(size_t i = 0; i < ARRAY_SIZE(index_test::arr1); ++i)
+  {
+    CoordPointT const pt(index_test::arr1[i].x, index_test::arr1[i].y);
+    int64_t const id = PointToInt64(pt, coordBits);
+    CoordPointT const pt1 = Int64ToPoint(id, coordBits);
+
+    CheckEqualPoints(pt, pt1);
+
+    int64_t const id1 = PointToInt64(pt1, coordBits);
+    TEST_EQUAL(id, id1, (pt, pt1));
+  }
+}

indexer/indexer_tests/test_polylines.hpp

@@ -0,0 +1,9 @@
+#pragma once
+
+#include "../../geometry/point2d.hpp"
+
+namespace index_test
+{
+  typedef m2::PointD P;
+  extern P arr1[376];
+}