diff --git a/generator/feature_builder.cpp b/generator/feature_builder.cpp
index a43b3f4b80..ad83c002ff 100644
--- a/generator/feature_builder.cpp
+++ b/generator/feature_builder.cpp
@@ -27,12 +27,12 @@ using namespace feature;
 FeatureBuilder1::FeatureBuilder1()
 : m_coastCell(-1)
 {
-  m_polygons.push_back(points_t());
+  m_polygons.push_back(TPointSeq());
 }
 
 bool FeatureBuilder1::IsGeometryClosed() const
 {
-  points_t const & poly = GetFrontGeometry();
+  TPointSeq const & poly = GetOuterGeometry();
   return (poly.size() > 2 && poly.front() == poly.back());
 }
 
@@ -42,7 +42,7 @@ m2::PointD FeatureBuilder1::GetGeometryCenter() const
   //ASSERT ( IsGeometryClosed(), () );
   m2::PointD ret(0.0, 0.0);
 
-  points_t const & poly = GetFrontGeometry();
+  TPointSeq const & poly = GetOuterGeometry();
   size_t const count = poly.size();
   for (size_t i = 0; i < count; ++i)
     ret += poly[i];
@@ -89,42 +89,44 @@ void FeatureBuilder1::SetLinear(bool reverseGeometry)
   }
 }
 
-void FeatureBuilder1::SetAreaAddHoles(list<points_t> const & holes)
+void FeatureBuilder1::SetAreaAddHoles(FeatureBuilder1::TGeometry const & holes)
 {
   m_params.SetGeomType(GEOM_AREA);
   m_polygons.resize(1);
 
   if (holes.empty()) return;
 
-  points_t const & poly = GetFrontGeometry();
+  TPointSeq const & poly = GetOuterGeometry();
   m2::Region<m2::PointD> rgn(poly.begin(), poly.end());
 
-  for (list<points_t>::const_iterator i = holes.begin(); i != holes.end(); ++i)
+  for (TPointSeq const & points : holes)
   {
-    ASSERT ( !i->empty(), (*this) );
+    ASSERT ( !points.empty(), (*this) );
 
     size_t j = 0;
-    size_t const count = i->size();
+    size_t const count = points.size();
     for (; j < count; ++j)
-      if (!rgn.Contains((*i)[j]))
+      if (!rgn.Contains(points[j]))
         break;
 
     if (j == count)
-      m_polygons.push_back(*i);
+      m_polygons.push_back(points);
   }
 }
 
 void FeatureBuilder1::AddPolygon(vector<m2::PointD> & poly)
 {
   // check for closing
-  if (poly.size() < 3) return;
+  if (poly.size() < 3)
+    return;
+
   if (poly.front() != poly.back())
     poly.push_back(poly.front());
 
   CalcRect(poly, m_limitRect);
 
   if (!m_polygons.back().empty())
-    m_polygons.push_back(points_t());
+    m_polygons.push_back(TPointSeq());
 
   m_polygons.back().swap(poly);
 }
@@ -283,37 +285,28 @@ void FeatureBuilder1::RemoveNameIfInvisible(int minS, int maxS)
 
 bool FeatureBuilder1::operator == (FeatureBuilder1 const & fb) const
 {
-  if (!(m_params == fb.m_params)) return false;
-
-  if (m_coastCell != fb.m_coastCell) return false;
-
-  if (m_params.GetGeomType() == GEOM_POINT &&
-      !is_equal(m_center, fb.m_center))
-  {
+  if (!(m_params == fb.m_params))
+    return false;
+
+  if (m_coastCell != fb.m_coastCell)
+    return false;
+
+  if (m_params.GetGeomType() == GEOM_POINT && !is_equal(m_center, fb.m_center))
     return false;
-  }
 
   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;
 
-  list<points_t>::const_iterator i = m_polygons.begin();
-  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;
-    }
-
   if (m_osmIds != fb.m_osmIds)
     return false;
 
+  for (auto i = m_polygons.cbegin(), j = fb.m_polygons.cbegin(); i != m_polygons.cend(); ++i, ++j)
+    if (!is_equal(*i, *j))
+      return false;
+
   return true;
 }
 
@@ -323,16 +316,12 @@ bool FeatureBuilder1::CheckValid() const
 
   EGeomType const type = m_params.GetGeomType();
 
-  points_t const & poly = GetFrontGeometry();
-
   if (type == GEOM_LINE)
-    CHECK(poly.size() >= 2, (*this));
+    CHECK(GetOuterGeometry().size() >= 2, (*this));
 
   if (type == GEOM_AREA)
-  {
-    for (list<points_t>::const_iterator i = m_polygons.begin(); i != m_polygons.end(); ++i)
-      CHECK(i->size() >= 3, (*this));
-  }
+    for (TPointSeq const & points : m_polygons)
+      CHECK(points.size() >= 3, (*this));
 
   return true;
 }
@@ -363,8 +352,8 @@ void FeatureBuilder1::Serialize(buffer_t & data) const
   {
     WriteVarUint(sink, static_cast<uint32_t>(m_polygons.size()));
 
-    for (list<points_t>::const_iterator i = m_polygons.begin(); i != m_polygons.end(); ++i)
-      serial::SaveOuterPath(*i, cp, sink);
+    for (TPointSeq const & points : m_polygons)
+      serial::SaveOuterPath(points, cp, sink);
 
     WriteVarInt(sink, m_coastCell);
   }
@@ -404,7 +393,7 @@ void FeatureBuilder1::Deserialize(buffer_t & data)
 
     for (uint32_t i = 0; i < count; ++i)
     {
-      m_polygons.push_back(points_t());
+      m_polygons.push_back(TPointSeq());
       serial::LoadOuterPath(source, cp, m_polygons.back());
       CalcRect(m_polygons.back(), m_limitRect);
     }
@@ -435,16 +424,13 @@ osm::Id FeatureBuilder1::GetLastOsmId() const
 
 string FeatureBuilder1::GetOsmIdsString() const
 {
-  size_t const size = m_osmIds.size();
-  if (size)
-  {
-    ostringstream out;
-    for (size_t i = 0; i < size; ++i)
-      out << m_osmIds[i].Type() << " id=" << m_osmIds[i].OsmId() << " ";
-    return out.str();
-  }
-  else
+  if (m_osmIds.empty())
     return "(NOT AN OSM FEATURE)";
+
+  ostringstream out;
+  for (auto const & id : m_osmIds)
+    out << id.Type() << " id=" << id.OsmId() << " ";
+  return out.str();
 }
 
 int FeatureBuilder1::GetMinFeatureDrawScale() const
@@ -487,30 +473,32 @@ string DebugPrint(FeatureBuilder1 const & f)
   default: out << "ERROR: unknown geometry type"; break;
   }
 
-  return (out.str() + " " +
-          DebugPrint(f.m_limitRect) + " " +
-          DebugPrint(f.m_params) + " " +
-          DebugPrint(f.m_osmIds));
+  out << " " << DebugPrint(f.m_limitRect) << " " << DebugPrint(f.m_params) << " " << DebugPrint(f.m_osmIds);
+  return out.str();
 }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// FeatureBuilderGeomRef implementation
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-bool FeatureBuilder2::IsDrawableInRange(int lowS, int highS) const
+bool FeatureBuilder1::IsDrawableInRange(int lowScale, int highScale) const
 {
-  if (!GetFrontGeometry().empty())
+  if (!GetOuterGeometry().empty())
   {
     FeatureBase const fb = GetFeatureBase();
 
-    while (lowS <= highS)
-      if (feature::IsDrawableForIndex(fb, lowS++))
+    while (lowScale <= highScale)
+      if (feature::IsDrawableForIndex(fb, lowScale++))
         return true;
   }
 
   return false;
 }
 
+uint64_t FeatureBuilder1::GetWayIDForRouting() const
+{
+  if (m_osmIds.size() == 1 && m_osmIds[0].IsWay() && IsLine() && IsRoad())
+    return m_osmIds[0].OsmId();
+  return 0;
+}
+
+
 bool FeatureBuilder2::PreSerialize(buffers_holder_t const & data)
 {
   // make flags actual before header serialization
@@ -620,10 +608,10 @@ void FeatureBuilder2::Serialize(buffers_holder_t & data, serial::CodingParams co
     }
     else
     {
-      ASSERT_GREATER ( GetFrontGeometry().size(), 2, () );
+      ASSERT_GREATER ( GetOuterGeometry().size(), 2, () );
 
       // Store first point once for outer linear features.
-      serial::SavePoint(sink, GetFrontGeometry()[0], params);
+      serial::SavePoint(sink, GetOuterGeometry()[0], params);
 
       // offsets was pushed from high scale index to low
       reverse(data.m_ptsOffset.begin(), data.m_ptsOffset.end());
@@ -642,11 +630,3 @@ void FeatureBuilder2::Serialize(buffers_holder_t & data, serial::CodingParams co
     }
   }
 }
-
-uint64_t FeatureBuilder2::GetWayIDForRouting() const
-{
-  if (m_osmIds.size() == 1 && m_osmIds[0].IsWay() && IsLine() && IsRoad())
-    return m_osmIds[0].OsmId();
-  else
-    return 0;
-}
diff --git a/generator/feature_builder.hpp b/generator/feature_builder.hpp
index e7a506def5..74f9e53aa7 100644
--- a/generator/feature_builder.hpp
+++ b/generator/feature_builder.hpp
@@ -39,11 +39,15 @@ public:
   void SetAreaAddHoles(list<vector<m2::PointD> > const & holes);
   inline void SetArea() { m_params.SetGeomType(feature::GEOM_AREA); }
 
+  inline bool IsLine() const { return (GetGeomType() == feature::GEOM_LINE); }
+  inline bool IsArea() const { return (GetGeomType() == feature::GEOM_AREA); }
+
   void AddPolygon(vector<m2::PointD> & poly);
   //@}
 
   inline feature::Metadata const & GetMetadata() const { return m_params.GetMetadata(); }
   inline TGeometry const & GetGeometry() const { return m_polygons; }
+  inline TPointSeq const & GetOuterGeometry() const { return m_polygons.front(); }
   inline feature::EGeomType GetGeomType() const { return m_params.GetGeomType(); }
 
   inline void AddType(uint32_t type) { m_params.AddType(type); }
@@ -91,7 +95,7 @@ public:
   m2::PointD GetGeometryCenter() const;
   m2::PointD GetKeyPoint() const;
 
-  inline size_t GetPointsCount() const { return GetFrontGeometry().size(); }
+  inline size_t GetPointsCount() const { return GetOuterGeometry().size(); }
   inline size_t GetPolygonsCount() const { return m_polygons.size(); }
   inline size_t GetTypesCount() const { return m_params.m_Types.size(); }
   //@}
@@ -117,10 +121,10 @@ public:
       toDo(m_center);
     else
     {
-      for (list<points_t>::const_iterator i = m_polygons.begin(); i != m_polygons.end(); ++i)
+      for (TPointSeq const & points : m_polygons)
       {
-        for (points_t::const_iterator j = i->begin(); j != i->end(); ++j)
-          if (!toDo(*j))
+        for (auto const & pt : points)
+          if (!toDo(pt))
             return;
         toDo.EndRegion();
       }
@@ -149,10 +153,15 @@ public:
   string GetOsmIdsString() const;
   //@}
 
+  uint64_t GetWayIDForRouting() const;
+
+
   bool AddName(string const & lang, string const & name);
 
   int GetMinFeatureDrawScale() const;
 
+  bool IsDrawableInRange(int lowScale, int highScale) const;
+
   void SetCoastCell(int64_t iCell, string const & strCell);
   inline bool IsCoastCell() const { return (m_coastCell != -1); }
   inline bool GetCoastCell(int64_t & cell) const
@@ -191,12 +200,8 @@ protected:
   /// - origin point of text or symbol in area-feature
   m2::PointD m_center;    // Check  HEADER_HAS_POINT
 
-  typedef vector<m2::PointD> points_t;
-
-  inline points_t const & GetFrontGeometry() const { return m_polygons.front(); }
-
   /// List of geometry polygons.
-  list<points_t> m_polygons; // Check HEADER_IS_AREA
+  TGeometry m_polygons; // Check HEADER_IS_AREA
 
   /// Not used in GEOM_POINTs
   int64_t m_coastCell;
@@ -222,7 +227,7 @@ public:
 
     uint32_t m_ptsSimpMask;
 
-    points_t m_innerPts, m_innerTrg;
+    TPointSeq m_innerPts, m_innerTrg;
     //@}
 
     /// @name output
@@ -231,20 +236,12 @@ public:
     buffers_holder_t() : m_ptsMask(0), m_trgMask(0), m_ptsSimpMask(0) {}
   };
 
-  inline bool IsLine() const { return (GetGeomType() == feature::GEOM_LINE); }
-  inline bool IsArea() const { return (GetGeomType() == feature::GEOM_AREA); }
-  bool IsDrawableInRange(int lowS, int highS) const;
-
-  inline points_t const & GetOuterPoly() const { return GetFrontGeometry(); }
-  inline list<points_t> const & GetPolygons() const { return m_polygons; }
-
   /// @name Overwrite from base_type.
   //@{
   bool PreSerialize(buffers_holder_t const & data);
   void Serialize(buffers_holder_t & data, serial::CodingParams const & params);
   //@}
 
-  uint64_t GetWayIDForRouting() const;
 };
 
 namespace feature
diff --git a/generator/feature_generator.cpp b/generator/feature_generator.cpp
index 5eb1e9c17a..94f69bb213 100644
--- a/generator/feature_generator.cpp
+++ b/generator/feature_generator.cpp
@@ -19,21 +19,15 @@
 #include "std/unordered_map.hpp"
 #include "std/target_os.hpp"
 
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // FeaturesCollector implementation
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-namespace feature {
-
-FeaturesCollector::FeaturesCollector(string const & fName, string const &dumpFileName)
-: m_datFile(fName)
-, m_dumpFileName(dumpFileName)
+namespace feature
+{
+FeaturesCollector::FeaturesCollector(string const & fName)
+    : m_datFile(fName)
 {
   CHECK_EQUAL(GetFileSize(m_datFile), 0, ());
-  if (!m_dumpFileName.empty())
-  {
-    m_dumpFileStream.open(m_dumpFileName.c_str(), ios::binary | ios::trunc | ios::out);
-  }
 }
 
 FeaturesCollector::~FeaturesCollector()
@@ -41,13 +35,6 @@ FeaturesCollector::~FeaturesCollector()
   FlushBuffer();
   /// Check file size
   (void)GetFileSize(m_datFile);
-  if (!m_dumpFileName.empty())
-  {
-    uint64_t terminator = 0;
-    m_dumpFileStream.write(reinterpret_cast<char *>(&terminator), sizeof(terminator));
-    m_dumpFileStream.close();
-    LOG(LINFO, ("Dumped", m_featureCounter, "features into", m_dumpFileName));
-  }
 }
 
 uint32_t FeaturesCollector::GetFileSize(FileWriter const & f)
@@ -60,7 +47,7 @@ uint32_t FeaturesCollector::GetFileSize(FileWriter const & f)
   return ret;
 }
 
-template <typename ValueT, size_t ValueSizeT = sizeof(ValueT)+1>
+template <typename ValueT, size_t ValueSizeT = sizeof(ValueT) + 1>
 pair<char[ValueSizeT], uint8_t> PackValue(ValueT v)
 {
   static_assert(is_integral<ValueT>::value, "Non integral value");
@@ -90,7 +77,7 @@ void FeaturesCollector::Flush()
   m_datFile.Flush();
 }
 
-void FeaturesCollector::Write(char const *src, size_t size)
+void FeaturesCollector::Write(char const * src, size_t size)
 {
   do
   {
@@ -101,10 +88,9 @@ void FeaturesCollector::Write(char const *src, size_t size)
     m_writePosition += part_size;
     size -= part_size;
     src += part_size;
-  } while(size > 0);
+  } while (size > 0);
 }
 
-
 uint32_t FeaturesCollector::WriteFeatureBase(vector<char> const & bytes, FeatureBuilder1 const & fb)
 {
   size_t const sz = bytes.size();
@@ -121,32 +107,44 @@ uint32_t FeaturesCollector::WriteFeatureBase(vector<char> const & bytes, Feature
   return static_cast<uint32_t>(offset);
 }
 
-void FeaturesCollector::DumpFeatureGeometry(FeatureBuilder1 const & fb)
-{
-  FeatureBuilder1::TGeometry const & geom = fb.GetGeometry();
-  if (geom.empty())
-    return;
-
-  ++m_featureCounter;
-
-  uint64_t numGeometries = geom.size();
-  m_dumpFileStream.write(reinterpret_cast<char *>(&numGeometries), sizeof(numGeometries));
-  for (FeatureBuilder1::TPointSeq const & points : geom)
-  {
-    uint64_t numPoints = points.size();
-    m_dumpFileStream.write(reinterpret_cast<char *>(&numPoints), sizeof(numPoints));
-    m_dumpFileStream.write(reinterpret_cast<char const *>(points.data()), sizeof(FeatureBuilder1::TPointSeq::value_type) * points.size());
-  }
-}
-
-void FeaturesCollector::operator() (FeatureBuilder1 const & fb)
+void FeaturesCollector::operator()(FeatureBuilder1 const & fb)
 {
   FeatureBuilder1::buffer_t bytes;
   fb.Serialize(bytes);
   (void)WriteFeatureBase(bytes, fb);
-
-  if (!m_dumpFileName.empty())
-    DumpFeatureGeometry(fb);
 }
 
+FeaturesAndRawGeometryCollector::FeaturesAndRawGeometryCollector(string const & featuresFileName,
+                                                                 string const & rawGeometryFileName)
+    : FeaturesCollector(featuresFileName), m_rawGeometryFileStream(rawGeometryFileName)
+{
+  CHECK_EQUAL(GetFileSize(m_rawGeometryFileStream), 0, ());
+}
+
+FeaturesAndRawGeometryCollector::~FeaturesAndRawGeometryCollector()
+{
+  uint64_t terminator = 0;
+  m_rawGeometryFileStream.Write(&terminator, sizeof(terminator));
+  LOG(LINFO, ("Write", m_rawGeometryCounter, "geometries into", m_rawGeometryFileStream.GetName()));
+}
+
+void FeaturesAndRawGeometryCollector::operator()(FeatureBuilder1 const & fb)
+{
+  FeaturesCollector::operator()(fb);
+  FeatureBuilder1::TGeometry const & geom = fb.GetGeometry();
+  if (geom.empty())
+    return;
+
+  ++m_rawGeometryCounter;
+
+  uint64_t numGeometries = geom.size();
+  m_rawGeometryFileStream.Write(&numGeometries, sizeof(numGeometries));
+  for (FeatureBuilder1::TPointSeq const & points : geom)
+  {
+    uint64_t numPoints = points.size();
+    m_rawGeometryFileStream.Write(&numPoints, sizeof(numPoints));
+    m_rawGeometryFileStream.Write(points.data(),
+                                  sizeof(FeatureBuilder1::TPointSeq::value_type) * points.size());
+  }
+}
 }
diff --git a/generator/feature_generator.hpp b/generator/feature_generator.hpp
index a85a7c94fb..9b2e0728cb 100644
--- a/generator/feature_generator.hpp
+++ b/generator/feature_generator.hpp
@@ -4,45 +4,53 @@
 
 #include "coding/file_writer.hpp"
 
-#include "std/vector.hpp"
 #include "std/string.hpp"
-#include "std/fstream.hpp"
-
+#include "std/vector.hpp"
 
 class FeatureBuilder1;
 
 namespace feature
 {
-  // Writes features to dat file.
-  class FeaturesCollector
-  {
-    char m_writeBuffer[48000];
-    size_t m_writePosition = 0;
-    uint32_t m_baseOffset = 0;
-    size_t m_featureCounter = 0;
+// Writes features to dat file.
+class FeaturesCollector
+{
+  char m_writeBuffer[48000];
+  size_t m_writePosition = 0;
+  uint32_t m_baseOffset = 0;
 
-  protected:
-    FileWriter m_datFile;
-    ofstream m_dumpFileStream;
-    string m_dumpFileName;
-    m2::RectD m_bounds;
+protected:
+  FileWriter m_datFile;
+  m2::RectD m_bounds;
 
-  private:
-    void Write(char const * src, size_t size);
-    void FlushBuffer();
+private:
+  void Write(char const * src, size_t size);
+  void FlushBuffer();
 
-  protected:
-    static uint32_t GetFileSize(FileWriter const & f);
+protected:
+  static uint32_t GetFileSize(FileWriter const & f);
 
-    /// @return feature offset in the file, which is used as an ID later
-    uint32_t WriteFeatureBase(vector<char> const & bytes, FeatureBuilder1 const & fb);
-    void DumpFeatureGeometry(FeatureBuilder1 const & fb);
-    void Flush();
+  /// @return feature offset in the file, which is used as an ID later
+  uint32_t WriteFeatureBase(vector<char> const & bytes, FeatureBuilder1 const & fb);
+  void WriteRawFeatureGeometry(FeatureBuilder1 const & fb);
+  void Flush();
 
-  public:
-    FeaturesCollector(string const & fName, string const &dumpFileName = string());
-    ~FeaturesCollector();
+public:
+  FeaturesCollector(string const & fName);
+  virtual ~FeaturesCollector();
 
-    void operator() (FeatureBuilder1 const & f);
-  };
+  virtual void operator()(FeatureBuilder1 const & f);
+};
+
+class FeaturesAndRawGeometryCollector : public FeaturesCollector
+{
+  FileWriter m_rawGeometryFileStream;
+  size_t m_rawGeometryCounter = 0;
+
+public:
+  FeaturesAndRawGeometryCollector(string const & featuresFileName,
+                                  string const & rawGeometryFileName);
+  ~FeaturesAndRawGeometryCollector();
+
+  void operator()(FeatureBuilder1 const & f) override;
+};
 }
diff --git a/generator/feature_merger.cpp b/generator/feature_merger.cpp
index 1d84ce51a9..4b571cc986 100644
--- a/generator/feature_merger.cpp
+++ b/generator/feature_merger.cpp
@@ -16,7 +16,7 @@ void MergedFeatureBuilder1::SetRound()
 {
   m_isRound = true;
 
-  m_roundBounds[0] = m_roundBounds[1] = GetFrontGeometry();
+  m_roundBounds[0] = m_roundBounds[1] = GetOuterGeometry();
 }
 
 void MergedFeatureBuilder1::AppendFeature(MergedFeatureBuilder1 const & fb, bool fromBegin, bool toBack)
@@ -24,8 +24,8 @@ void MergedFeatureBuilder1::AppendFeature(MergedFeatureBuilder1 const & fb, bool
   // Also merge Osm IDs for debugging
   m_osmIds.insert(m_osmIds.end(), fb.m_osmIds.begin(), fb.m_osmIds.end());
 
-  points_t & thisG = m_polygons.front();
-  points_t const & fbG = fb.GetFrontGeometry();
+  TPointSeq & thisG = m_polygons.front();
+  TPointSeq const & fbG = fb.GetOuterGeometry();
 
   if (fb.m_isRound)
   {
@@ -75,7 +75,7 @@ void MergedFeatureBuilder1::AppendFeature(MergedFeatureBuilder1 const & fb, bool
 
 bool MergedFeatureBuilder1::EqualGeometry(MergedFeatureBuilder1 const & fb) const
 {
-  return (GetFrontGeometry() == fb.GetFrontGeometry());
+  return (GetOuterGeometry() == fb.GetOuterGeometry());
 }
 
 pair<m2::PointD, bool> MergedFeatureBuilder1::GetKeyPoint(size_t i) const
@@ -106,7 +106,7 @@ size_t MergedFeatureBuilder1::GetKeyPointsCount() const
 
 double MergedFeatureBuilder1::GetPriority() const
 {
-  points_t const & poly = GetFrontGeometry();
+  TPointSeq const & poly = GetOuterGeometry();
 
   double pr = 0.0;
   for (size_t i = 1; i < poly.size(); ++i)
diff --git a/generator/feature_merger.hpp b/generator/feature_merger.hpp
index d30b770835..65082019cf 100644
--- a/generator/feature_merger.hpp
+++ b/generator/feature_merger.hpp
@@ -11,7 +11,7 @@ class MergedFeatureBuilder1 : public FeatureBuilder1
 {
   bool m_isRound;
 
-  points_t m_roundBounds[2];
+  TPointSeq m_roundBounds[2];
 
 public:
   MergedFeatureBuilder1() : m_isRound(false) {}
@@ -26,10 +26,10 @@ public:
 
   bool EqualGeometry(MergedFeatureBuilder1 const & fb) const;
 
-  inline bool NotEmpty() const { return !GetFrontGeometry().empty(); }
+  inline bool NotEmpty() const { return !GetOuterGeometry().empty(); }
 
-  inline m2::PointD FirstPoint() const { return GetFrontGeometry().front(); }
-  inline m2::PointD LastPoint() const { return GetFrontGeometry().back(); }
+  inline m2::PointD FirstPoint() const { return GetOuterGeometry().front(); }
+  inline m2::PointD LastPoint() const { return GetOuterGeometry().back(); }
 
   inline bool PopAnyType(uint32_t & type) { return m_params.PopAnyType(type); }
 
@@ -41,7 +41,7 @@ public:
 
   template <class ToDo> void ForEachMiddlePoints(ToDo toDo) const
   {
-    points_t const & poly = GetFrontGeometry();
+    TPointSeq const & poly = GetOuterGeometry();
     for (size_t i = 1; i < poly.size()-1; ++i)
       toDo(poly[i]);
   }
diff --git a/generator/feature_sorter.cpp b/generator/feature_sorter.cpp
index a37115401d..e197969d92 100644
--- a/generator/feature_sorter.cpp
+++ b/generator/feature_sorter.cpp
@@ -303,7 +303,7 @@ namespace feature
 
       points_t const & GetSourcePoints()
       {
-        return (!m_current.empty() ? m_current : m_rFB.GetOuterPoly());
+        return (!m_current.empty() ? m_current : m_rFB.GetOuterGeometry());
       }
 
       void AddPoints(points_t const & points, int scaleIndex)
@@ -457,7 +457,7 @@ namespace feature
             // At this point we don't need last point equal to first.
             points.pop_back();
 
-            polygons_t const & polys = fb.GetPolygons();
+            polygons_t const & polys = fb.GetGeometry();
             if (polys.size() == 1 && good && holder.TryToMakeStrip(points))
               continue;
 
diff --git a/generator/generator_tests/coasts_test.cpp b/generator/generator_tests/coasts_test.cpp
index a727efe2f6..8e4e65bea9 100644
--- a/generator/generator_tests/coasts_test.cpp
+++ b/generator/generator_tests/coasts_test.cpp
@@ -128,7 +128,7 @@ namespace
         TEST(fb2.IsDrawableInRange(0, upperScale), ());
 
         m2::RectD const rect = fb2.GetLimitRect();
-        LOG(LINFO, ("ID = ", fb1.GetName(), "Rect = ", rect, "Polygons = ", fb2.GetPolygons()));
+        LOG(LINFO, ("ID = ", fb1.GetName(), "Rect = ", rect, "Polygons = ", fb2.GetGeometry()));
 
         // Make bound rect inflated a little.
         feature::BoundsDistance dist(rect);
@@ -137,7 +137,7 @@ namespace
         typedef vector<m2::PointD> PointsT;
         typedef list<PointsT> PolygonsT;
 
-        PolygonsT const & poly = fb2.GetPolygons();
+        PolygonsT const & poly = fb2.GetGeometry();
 
         // Check that all simplifications are inside bound rect.
         for (int level = 0; level <= upperScale; ++level)
diff --git a/generator/osm_source.cpp b/generator/osm_source.cpp
index 28c11d029c..28bd03e797 100644
--- a/generator/osm_source.cpp
+++ b/generator/osm_source.cpp
@@ -247,7 +247,7 @@ namespace
         // 20000 - max points count per feature
         m_coasts.reset(new CoastlineFeaturesGenerator(Type(NATURAL_COASTLINE), 4, 10, 20000));
 
-        m_coastsHolder.reset(new feature::FeaturesCollector(m_srcCoastsFile, srcCoastsFileDump));
+        m_coastsHolder.reset(new feature::FeaturesAndRawGeometryCollector(m_srcCoastsFile, srcCoastsFileDump));
       }
 
       if (info.m_createWorld)
@@ -325,7 +325,7 @@ namespace
             totalPolygons += vecFb[j].GetPolygonsCount();
           }
         }
-        LOG(LINFO, ("Total regions:", totalRegions, "total points:", totalPoints, "totalPolygons:", totalPolygons));
+        LOG(LINFO, ("Total regions:", totalRegions, "total points:", totalPoints, "total polygons:", totalPolygons));
       }
       else if (m_coastsHolder)
       {