contrek 1.3.3 → 1.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14fceba0577a0e8bf3ce358d23099eb7d359dfdaafdbfac3489f853001be47b3
-  data.tar.gz: 4097a012082df7a8c59dd873c2bac9556b0ac5f40699183cb3de1410a9f34a5c
+  metadata.gz: ea7475a8d469db6be267562a802b7b8f09480774e6d3085a35a428f569d2f113
+  data.tar.gz: 20370119576e765342797caad9778b7d808f9b6be154eca4e5a744f988d532f6
 SHA512:
-  metadata.gz: ed0bf7cbf8f90b6327b8ad2ca990e0f05a59e664a9ea04a20a164f51ad0640a85275c80ff34b21e66c2611226448c0c9c7fbc7effeb1c4f51c02c3550267fbdd
-  data.tar.gz: 9e9677f9fddbd0746a594a26315eb93773f078ed78035cb2b3b36030036079382e7bea31fc4cbc040d7e7d21f1e8fd158a7609f11d1a71aa257592a963af4eb6
+  metadata.gz: b09fddc2bc46bb644f3024de98aa2db5155856981aaf3ce3a5dfaf5a8ef5449f36ad4fb784654bb12368fc8d2b2c0741a492c1f70ec4e620b4282d28268d770e
+  data.tar.gz: 6240cd18e6145a3f47504decfab3d74decce51c0ddc91084d7ac7cf95e020cc7165bfca4d8d7831c760ca3ee3aaa63ae3b50fa1c75b5ed60ed13ae87544b9d36

data/CHANGELOG.md

@@ -135,3 +135,6 @@ All notable changes to this project will be documented in this file.
 
 ## [1.3.3] - 2026-06-28
 - **GeoJsonStreamingMerger:** Fixes both Ruby and CPP side.
+
+## [1.3.4] - 2026-07-19
+- Refactored core topology from a top-left point model to a 4-vertex pixel-cell model, natively eliminating diagonal ambiguities and rewriting part of the stripe-merging algorithm to ensure perfect geometric stitching on shared nodes. Removed Strict Bounds mode. Added a Douglas-Peucker and a custom raster-compression algorithm that shifts top/right pixel boundaries by 1px to ensure flawless surface rendering as bitmap image.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    contrek (1.3.3)
+    contrek (1.3.4)
       chunky_png (~> 1.4)
       concurrent-ruby (~> 1.3.5)
       rice (= 4.5.0)
@@ -61,6 +61,7 @@ GEM
     ruby-prof (1.7.2)
       base64
     ruby-progressbar (1.13.0)
+    ruby2d (0.12.1)
     standard (1.51.1)
       language_server-protocol (~> 3.17.0.2)
       lint_roller (~> 1.0)
@@ -86,6 +87,7 @@ DEPENDENCIES
   curses (~> 1.5, >= 1.5.3)
   rspec (~> 3.12)
   ruby-prof (~> 1.7, >= 1.7.2)
+  ruby2d (~> 0.12)
   standard (~> 1.51)
 
 BUNDLED WITH

data/README.md

@@ -155,7 +155,7 @@ You can process from a raw stream
   result = CPPPolygonFinder.new(raw_bitmap, not_matcher, nil,{compress: {uniq: true, linear: true}}).process_info
   puts result.points.inspect
   =>
-  [{:outer=>[{:x=>5, :y=>4}, {:x=>5, :y=>5}, {:x=>8, :y=>5}, {:x=>8, :y=>4}], :inner=>[]}]
+  [{:outer=>[{x: 5, y: 4}, {x: 5, y: 6}, {x: 9, y: 6}, {x: 9, y: 4}], :inner=>[]}]
 ```
 
 Multithreaded contour processing is supported by both the native C++ and pure Ruby implementations. When using the C++ engine (default), multithreading works as expected and fully utilizes all available cores.
@@ -183,7 +183,7 @@ Regarding multithreading:
 
 - The algorithm splits the contour-detection workflow into multiple phases that can be executed in parallel. The initial contour extraction on each band and the subsequent merging of coordinates between adjacent bands—performed pairwise, recursively, and in a non-deterministic order—results in a final output that is not idempotent. Idempotence is guaranteed only when the exact same merging sequence is repeated.
 
-By not declaring native option CPP Multithreading optimized code is used. In the above example a [105 MP image](spec/files/images/sample_10240x10240.png) is examined by 4 threads working on 4 tiles (total compute time about 0.816 secs with image load (0.37 secs)).
+By not declaring native option CPP Multithreading optimized code is used. In the above example a [105 MP image](spec/files/images/sample_10240x10240.png) is examined by 4 threads working on 4 tiles (total compute time about 0.328 secs with image load).
 
 ```ruby
 result = Contrek.contour!(
@@ -197,15 +197,36 @@ result = Contrek.contour!(
 )
 puts result.metadata[:benchmarks].inspect
 
-{ compress: 23.83,
-  init: 313.179,
-  inner: 6.16,
-  outer: 78.791,
-  total: 337.013
+{ compress: 5.3933,
+  init: 322.749,
+  inner: 4.795,
+  outer: 81.546,
+  total: 328.142
 }
 
 ```
 
+## Tracking & Topology Schema
+
+Contrek utilizes a **Dual-Grid / Cell-Based Topology** instead of a classic point-pixel model. Each pixel is treated as a solid 2D cell defined by **4 distinct vertices** (nodes). 
+
+
+### Pixel-Cell Geometry
+
+```text
+    (x, y)          Top Edge         (x+1, y)
+       O--------------------------------O
+       |                                |
+       |                                |
+  Left |             PIXEL              | Right
+  Edge |            (x, y)              | Edge
+       |                                |
+       |                                |
+       O--------------------------------O
+   (x, y+1)        Bottom Edge       (x+1, y+1)
+
+```
+
 ### Connectivity Modes
 
 Contrek supports different pixel connectivity rules to define how polygons are traced and merged. This is controlled by the `:connectivity` option.
@@ -233,27 +254,6 @@ result = Contrek.contour!(
 )
 ```
 
-## Tracing Modes
-
-Contrek provides two levels of precision for polygon generation to balance data density and topological accuracy.
-
-### **Standard Mode** (Default)
-Optimized for **speed** and **lightweight** output.
-* **Behavior:** Traces outer boundaries while simplifying collinear segments.
-* **Result:** Fewer vertices and smaller memory footprint.
-
-### **Strict Mode** (`strict_bounds: true`)
-Engineered for **Pixel-Perfect** precision.
-* **Behavior:** Preserves every junction and internal connectivity change.
-* **Result:** 100% topologically faithful geometry with no micro-gaps between adjacent polygons.
-
-Below are two images illustrating the difference in tracing modes. In the first case, with **strict_bounds ON**, the anti-clockwise sequence includes two additional points, **H** and **I**, which trace the shape more accurately. In the second case, the transition between **G** and **H** is approximated, omitting the indentation.
-
-| Strict Bounds ON | Strict Bounds OFF |
-|:---:|:---:|
-| <img src="./docs/images/strict_bounds_on.png" alt="Originale" width="60%"/> | <img src="./docs/images/strict_bounds_off.png" alt="Poligoni" width="60%"/> |
-
-
 ## Result
 
 The result structure contains polygon coordinates and a set of metadata. Polygon coordinates can be accessed via:

data/contrek.gemspec

@@ -29,6 +29,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency "standard", "~> 1.51"
   s.add_development_dependency "curses", "~> 1.5", ">= 1.5.3"
   s.add_development_dependency "ruby-prof", "~> 1.7", ">= 1.7.2"
+  s.add_development_dependency "ruby2d", "~> 0.12"
 
   s.add_dependency "chunky_png", "~> 1.4"
   s.add_dependency "concurrent-ruby", "~> 1.3.5"

data/ext/cpp_polygon_finder/PolygonFinder/src/ContrekApi.h

@@ -37,6 +37,8 @@ struct Config {
   int tiles = 2;
   bool compress_unique = false;
   bool compress_linear = false;
+  bool compress_raster = false;
+  bool compress_douglas_peucker = false;
   bool compress_visvalingam = false;
   bool treemap = false;
   int32_t target_color = -1;

data/ext/cpp_polygon_finder/PolygonFinder/src/Tests.cpp

@@ -342,7 +342,6 @@ void stream_png_image(const std::string& filepath, uint32_t stripe_height, bool
       // stripe contour tracing
       std::vector<std::string> finder_arguments = {
         "--versus=a",
-        "--strict_bounds"  // <- this option is strictly needed when working with vertical merger
       };
       PolygonFinder polygon_finder(&stripe_bitmap, &not_matcher, nullptr, &finder_arguments);
       ProcessResult *result = polygon_finder.process_info();
@@ -470,7 +469,6 @@ void stream_progressive_png_image(const std::string& filepath, uint32_t stripe_h
         std::vector<std::string> finder_arguments = {
           "--versus=a",
           "--bounds",
-          "--strict_bounds",  // <- this option is strictly needed when working with vertical merger
           "--compress_uniq",
           "--compress_linear"
         };

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/FinderUtils.cpp

@@ -24,18 +24,19 @@ void FinderUtils::sanitize_options(pf_Options& options, std::vector<std::string>
 
   enum  optionIndex { COMPRESS_UNIQ, VERSUS, COMPRESS_VISVALINGAM, COMPRESS_LINEAR, NUMBER_OF_TILES,
                       COMPRESS_VISVALINGAM_TOLERANCE, TREEMAP, NAMED_SEQUENCES, BOUNDS, CONNECTIVITY,
-                      STRICT_BOUNDS };
+                      COMPRESS_RASTER, COMPRESS_DOUGLAS_PEUCKER };
   const option::Descriptor usage[] = {
      //  {UNKNOWN, 0,"" , ""    ,option::Arg::None, 0},
      {COMPRESS_VISVALINGAM, 0, "" , "compress_visvalingam", option::Arg::None, 0},
      {COMPRESS_LINEAR, 0, "" , "compress_linear", option::Arg::None, 0},
      {COMPRESS_VISVALINGAM_TOLERANCE, 0, "" , "compress_visvalingam_tolerance", option::Arg::Optional, 0},
      {COMPRESS_UNIQ, 0, "", "compress_uniq", option::Arg::None, 0},
+     {COMPRESS_RASTER, 0, "", "compress_raster", option::Arg::None, 0},
+     {COMPRESS_DOUGLAS_PEUCKER, 0, "", "compress_douglas_peucker", option::Arg::None, 0},
      {NUMBER_OF_TILES, 0, "", "number_of_tiles", option::Arg::Optional, 0},
      {TREEMAP, 0, "", "treemap", option::Arg::None, 0},
      {NAMED_SEQUENCES, 0, "", "named_sequences", option::Arg::None, 0},
      {BOUNDS, 0, "", "bounds", option::Arg::None, 0},
-     {STRICT_BOUNDS, 0, "", "strict_bounds", option::Arg::None, 0},
      {VERSUS, 0, "v", "versus", option::Arg::Optional, 0},
      {CONNECTIVITY, 0, "c", "connectivity", option::Arg::Optional, 0},
      {0, 0, 0, 0, 0, 0}
@@ -89,9 +90,6 @@ void FinderUtils::sanitize_options(pf_Options& options, std::vector<std::string>
   if (ioptions[BOUNDS].count() > 0)
   { options.bounds = true;
   }
-  if (ioptions[STRICT_BOUNDS].count() > 0)
-  { options.strict_bounds = true;
-  }
   // COMPRESS LINEAR
   if (ioptions[COMPRESS_LINEAR].count() > 0)
   { options.compress_linear = true;
@@ -108,6 +106,14 @@ void FinderUtils::sanitize_options(pf_Options& options, std::vector<std::string>
       break;
     }
   }
+  // COMPRESS RASTER
+  if (ioptions[COMPRESS_RASTER].count() > 0)
+  { options.compress_raster = true;
+  }
+  // COMPRESS DOUGLAS PEUCKER
+  if (ioptions[COMPRESS_DOUGLAS_PEUCKER].count() > 0)
+  { options.compress_douglas_peucker = true;
+  }
   /* std::cout << "-----------" << std::endl;
   std::cout << "versus " << options.versus << std::endl;
   std::cout << "bounds " << options.bounds << std::endl;

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/Node.cpp

@@ -20,13 +20,11 @@
 static const int TURNER[2][2] = {{Node::OMAX, Node::OMIN}, {Node::TURN_MAX, Node::TURN_MIN}};
 
 Node::Node(int min_x, int max_x, int y, NodeCluster* cluster, char name)
-: start_point(min_x, y),
-  end_point(max_x, y),
-  cluster(cluster) {
-  this->name = name;
-  this->min_x = min_x;
-  this->max_x = max_x;
+: cluster(cluster),
+  min_x(min_x),
+  max_x(max_x + 1) {
   this->y = y;
+  this->name = name;
   this->tangs_count = 0;
   this->abs_x_index = 0;
   this->down_indexer = 0;
@@ -110,19 +108,19 @@ Point Node::coords_entering_to(Node *enter_to, int mode, int tracking) {
     Node& node_up = cluster->vert_nodes[y + T_UP][-(tg_index + 1)];
     if (mode == Node::A) {
       enter_to->track |= TURNER[tracking][OMAX - 1];
-      return node_up.end_point;
+      return node_up.se_point();
     } else {
       enter_to->track |= TURNER[tracking][OMIN - 1];
-      return node_up.start_point;
+      return node_up.sw_point();
     }
   } else {
     Node& node_down = cluster->vert_nodes[y + T_DOWN][tg_index];
     if (mode == Node::A) {
       enter_to->track |= TURNER[tracking][OMIN - 1];
-      return node_down.start_point;
+      return node_down.nw_point();
     } else {
       enter_to->track |= TURNER[tracking][OMAX - 1];
-      return node_down.end_point;
+      return node_down.ne_point();
     }
   }
 }

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/Node.h

@@ -94,7 +94,6 @@ class Node : public  Listable {
   int upper_end   = -1;
   int lower_start = std::numeric_limits<int>::max();
   int lower_end   = -1;
-  Point start_point, end_point;
   NodeCluster* cluster;
   void add_intersection(Node& other_node, int other_node_index);
   SmallVec tangs_sequence;
@@ -105,6 +104,10 @@ class Node : public  Listable {
   bool track_uncomplete();
   bool track_complete();
   bool get_trackmax();
+  Point nw_point() { return {min_x, y}; }
+  Point ne_point() { return {max_x, y}; }
+  Point se_point() { return {max_x, y + 1}; }
+  Point sw_point() { return {min_x, y + 1}; }
 
  public:
   int min_x, max_x;

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/NodeCluster.cpp

@@ -20,6 +20,8 @@
 #include "RectBounds.h"
 #include "../reducers/UniqReducer.h"
 #include "../reducers/LinearReducer.h"
+#include "../reducers/RasterReducer.h"
+#include "../reducers/DouglasPeuckerReducer.h"
 #include "../reducers/VisvalingamReducer.h"
 
 NodeCluster::NodeCluster(int h, int w, pf_Options *options) {
@@ -41,7 +43,8 @@ NodeCluster::~NodeCluster() {
 }
 
 void NodeCluster::compress_coords(std::list<Polygon>& polygons, pf_Options options) {
-  if (!(options.compress_linear || options.compress_uniq || options.compress_visvalingam)) return;
+  if (!(options.compress_linear || options.compress_uniq || options.compress_raster ||
+        options.compress_douglas_peucker || options.compress_visvalingam)) return;
 
   auto compress_sequence = [&](std::vector<Point>& points_vec) {
     if (points_vec.empty()) return;
@@ -54,10 +57,18 @@ void NodeCluster::compress_coords(std::list<Polygon>& polygons, pf_Options optio
       LinearReducer linear_reducer(points_vec);
       linear_reducer.reduce();
     }
+    if (options.compress_raster) {
+      RasterReducer raster_reducer(points_vec, this->options->versus);
+      raster_reducer.reduce();
+    }
     if (options.compress_visvalingam) {
       VisvalingamReducer vis_reducer(points_vec, options.compress_visvalingam_tolerance);
       vis_reducer.reduce();
     }
+    if (options.compress_douglas_peucker) {
+      DouglasPeuckerReducer douglas_peucker_reducer(points_vec);
+      douglas_peucker_reducer.reduce();
+    }
   };
   for (auto &poly : polygons) {
     compress_sequence(poly.outer);
@@ -68,7 +79,7 @@ void NodeCluster::compress_coords(std::list<Polygon>& polygons, pf_Options optio
 }
 
 void NodeCluster::build_tangs_sequence() {
-  for (int y = 0; y < (int)vert_nodes.size(); y++) {
+  for (int y = 0; y < static_cast<int>(vert_nodes.size()); y++) {
     for (Node& node : vert_nodes[y]) {
       node.precalc_tangs_sequences(*this);
     }
@@ -89,11 +100,11 @@ Node* NodeCluster::add_node(int min_x, int max_x, int y, char name, int offset)
     if (!up_nodes.empty()) {
       auto it = std::lower_bound(up_nodes.begin(), up_nodes.end(), node.min_x,
         [&](const Node& a, int val) {
-          return ((a.max_x + offset) < val);
+          return ((a.max_x - 1 + offset) < val);
         });
 
       while (it != up_nodes.end()) {
-        if ((it->min_x - offset) > node.max_x) break;
+        if ((it->min_x - offset) > (node.max_x - 1)) break;
         node.add_intersection(*it, it->abs_x_index);
         it->add_intersection(node, node.abs_x_index);
         ++it;
@@ -106,7 +117,6 @@ Node* NodeCluster::add_node(int min_x, int max_x, int y, char name, int offset)
 void NodeCluster::plot(int versus) {
   int inner_v = versus_inverter[versus];
   int index_order = 0;
-  Node *next_node;
 
   while (root_nodes->size() > 0)
   { Node *root_node = reinterpret_cast<Node*>(root_nodes->shift());
@@ -114,22 +124,50 @@ void NodeCluster::plot(int versus) {
     this->plot_sequence.clear();
     this->plot_sequence.push_back(root_node);
     Polygon poly;
-
-    if ((root_node)->tangs_sequence.size() > 0)  // front() or back() on empty list is undefined
-    { versus == Node::A ?
-        next_node = root_node->get_tangent_node_by_virtual_index(root_node->tangs_sequence.back()) :
-        next_node = root_node->get_tangent_node_by_virtual_index(root_node->tangs_sequence.front());
-
+      Node *next_node = nullptr;
+      if ((root_node)->tangs_sequence.size() > 0)  // front() or back() on empty list is undefined
+      { versus == Node::A ?
+          next_node = root_node->get_tangent_node_by_virtual_index(root_node->tangs_sequence.back()) :
+          next_node = root_node->get_tangent_node_by_virtual_index(root_node->tangs_sequence.front());
+      }
       if (next_node != nullptr)
-      { Point p = next_node->coords_entering_to(root_node, versus_inverter[versus], Node::OUTER);
+      { Point beginning_point;
+        beginning_point = versus == Node::A ? root_node->nw_point() : root_node->ne_point();
+        poly.bounds.expand(beginning_point.x, beginning_point.y);
+        poly.outer.push_back(beginning_point);
+
+        Point p = next_node->coords_entering_to(root_node, versus_inverter[versus], Node::OUTER);
         poly.bounds.expand(p.x, p.y);
         poly.outer.push_back(p);
       }
+
       if ((this->nodes > 0) && (next_node != nullptr))
       { plot_node(poly.outer, next_node, root_node, versus, poly.bounds);
       }
 
-      if (poly.outer.size() >= 2)
+      if (next_node == nullptr) {
+        if (versus == Node::A) {
+          Point nw_point = root_node->nw_point();
+          poly.bounds.expand(nw_point.x, nw_point.y);
+          poly.outer.push_back(nw_point);
+          poly.outer.push_back(root_node->sw_point());
+          Point se_point = root_node->se_point();
+          poly.bounds.expand(se_point.x, se_point.y);
+          poly.outer.push_back(se_point);
+          poly.outer.push_back(root_node->ne_point());
+        } else {
+          Point ne_point = root_node->ne_point();
+          poly.bounds.expand(ne_point.x, ne_point.y);
+          poly.outer.push_back(ne_point);
+          poly.outer.push_back(root_node->se_point());
+          Point sw_point = root_node->sw_point();
+          poly.bounds.expand(sw_point.x, sw_point.y);
+          poly.outer.push_back(sw_point);
+          poly.outer.push_back(root_node->nw_point());
+        }
+      }
+
+      if (poly.outer.size() > 0)
       { this->polygons.push_back(poly);
         this->sequences.push_back(std::move(this->plot_sequence));
 
@@ -174,7 +212,11 @@ void NodeCluster::plot(int versus) {
 
           if (next_node != nullptr)
           { inner_sequence.push_back(next_node->coords_entering_to(first, inner_v, Node::INNER));
-            plot_inner_node(inner_sequence, next_node, inner_v, first, root_node);
+            Node* last_node = plot_inner_node(inner_sequence, next_node, inner_v, first, root_node);
+            Point last_coord = last_node->coords_entering_to(first, versus_inverter[inner_v], Node::INNER);
+            if (inner_sequence.back() != last_coord) {
+              inner_sequence.push_back(last_coord);
+            }
           }
           this->polygons.back().inner.push_back(inner_sequence);
           this->inner_plot->grab(this->inner_new);
@@ -187,9 +229,6 @@ void NodeCluster::plot(int versus) {
       { this->treemap.push_back(versus == Node::A ? this->test_in_hole_a(root_node) : this->test_in_hole_o(root_node));
       }
       index_order++;
-    } else {
-      this->plot_sequence.clear();
-    }
   }
 }
 
@@ -242,9 +281,9 @@ std::pair<int, int> NodeCluster::test_in_hole_o(Node* node)
   return {-1, -1};
 }
 
-void NodeCluster::plot_inner_node(std::vector<Point>& sequence_coords, Node *node, int versus, Node *stop_at, Node *start_node) {
+Node* NodeCluster::plot_inner_node(std::vector<Point>& sequence_coords, Node *node, int versus, Node *stop_at, Node *start_node) {
   Node *current_node = node;
-  bool strict_bounds = this->options->strict_bounds;
+
   while (current_node != nullptr) {
     current_node->outer_index = start_node->outer_index;
     root_nodes->remove(current_node);
@@ -271,16 +310,29 @@ void NodeCluster::plot_inner_node(std::vector<Point>& sequence_coords, Node *nod
       plot = (n == next_node);
     }
     if (plot) {
-      sequence_coords.push_back(last_node->coords_entering_to(current_node, versus_inverter[versus], Node::INNER));
-      if (current_node != start_node) {
-        if (last_node->y == next_node->y) {
-          sequence_coords.push_back(next_node->coords_entering_to(current_node, versus, Node::INNER));
-        }
+      Point first_point = last_node->coords_entering_to(current_node, versus_inverter[versus], Node::INNER);
+      if (sequence_coords.back() != first_point) {
+        sequence_coords.push_back(first_point);
       }
-    } else if (strict_bounds) {
-        sequence_coords.push_back(Point{(first_is_max ? last_node->max_x : last_node->min_x), current_node->y});
-        sequence_coords.push_back(Point{(first_is_max ? next_node->min_x : next_node->max_x), current_node->y});
+      if (next_node->y == last_node->y) {
+        Point pt_a, pt_b;
+        if (next_node->y < current_node->y) {
+          pt_a = current_node->sw_point();
+          pt_b = current_node->se_point();
+        } else {
+          pt_a = current_node->ne_point();
+          pt_b = current_node->nw_point();
+        }
+        if (versus == Node::O) {
+          sequence_coords.push_back(pt_a);
+          sequence_coords.push_back(pt_b);
+        } else {
+          sequence_coords.push_back(pt_b);
+          sequence_coords.push_back(pt_a);
+        }
       }
+      sequence_coords.push_back(next_node->coords_entering_to(current_node, versus, Node::INNER));
+    }
 
     if (current_node->track_uncomplete()) {
       this->inner_new->push_back(current_node);
@@ -290,11 +342,11 @@ void NodeCluster::plot_inner_node(std::vector<Point>& sequence_coords, Node *nod
     if (next_node == stop_at) break;
     current_node = next_node;
   }
+  return current_node;
 }
 
 void NodeCluster::plot_node(std::vector<Point>& sequence_coords, Node *node, Node *start_node, int versus, RectBounds& bounds) {
   Node *current_node = node;
-  bool strict_bounds = this->options->strict_bounds;
 
   while (current_node != nullptr) {
     root_nodes->remove(current_node);
@@ -314,27 +366,47 @@ void NodeCluster::plot_node(std::vector<Point>& sequence_coords, Node *node, Nod
       plot = (n == next_node);
     }
     if (plot) {
-      Point p = last_node->coords_entering_to(current_node, versus, Node::OUTER);
-      bounds.expand(p.x, p.y);
-      sequence_coords.push_back(p);
+      Point start_coord = last_node->coords_entering_to(current_node, versus, Node::OUTER);
+      if (sequence_coords.back() != start_coord) {
+        bounds.expand(start_coord.x, start_coord.y);
+        sequence_coords.push_back(start_coord);
+      }
+      bool final_step = current_node == start_node && current_node->track_complete();
+      if (next_node->y == last_node->y) {
+        Point pt_a, pt_b;
+        if (next_node->y < current_node->y) {
+          pt_a = current_node->se_point();
+          pt_b = current_node->sw_point();
+        } else {
+          pt_a = current_node->nw_point();
+          pt_b = current_node->ne_point();
+        }
+        Point first = (versus == Node::O) ? pt_a : pt_b;
+        Point second = (versus == Node::O) ? pt_b : pt_a;
+        sequence_coords.push_back(first);
+        bounds.expand(first.x, first.y);
+        if (!final_step) {
+          sequence_coords.push_back(second);
+          bounds.expand(second.x, second.y);
+        }
+      }
+
+      if (!final_step) {
+        Point end_coord = next_node->coords_entering_to(current_node, versus_inverter[versus], Node::OUTER);
+        sequence_coords.push_back(end_coord);
+        bounds.expand(end_coord.x, end_coord.y);
+      }
+
       if (current_node != start_node) {
         inner_plot->contains(current_node) ? inner_plot->remove(current_node) : inner_plot->push_back(current_node);
         if (last_node->y == next_node->y) {
-          Point p1 = next_node->coords_entering_to(current_node, versus_inverter[versus], Node::OUTER);
-          bounds.expand(p1.x, p1.y);
-          sequence_coords.push_back(p1);
           inner_plot->contains(current_node) ? inner_plot->remove(current_node) : inner_plot->push_back(current_node);
         }
       }
-    } else if (strict_bounds) {
-        bool is_down = current_node->y > last_node->y;
-        bool is_a = (versus == Node::A);
-        sequence_coords.push_back(Point{(is_down == is_a ? last_node->min_x : last_node->max_x), current_node->y});
-        sequence_coords.push_back(Point{(is_down == is_a ? next_node->max_x : next_node->min_x), current_node->y});
-      }
+    }
 
-    if (current_node == start_node) {
-      if (current_node->track_complete()) break;
+    if (current_node == start_node && current_node->track_complete()) {
+      break;
     }
     current_node = next_node;
   }

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/NodeCluster.h

@@ -25,7 +25,7 @@ struct pf_Options;
 class NodeCluster {
  private:
   void plot_node(std::vector<Point>& sequence_coords, Node *node, Node *start_node, int versus, RectBounds& bounds);
-  void plot_inner_node(std::vector<Point>& sequence_coords, Node *node, int versus, Node *stop_at, Node *start_node);
+  Node* plot_inner_node(std::vector<Point>& sequence_coords, Node *node, int versus, Node *stop_at, Node *start_node);
   std::vector<Node*> plot_sequence;
   List *inner_plot;
   List *inner_new;

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/PolygonFinder.h

@@ -47,9 +47,10 @@ struct pf_Options {
   bool compress_uniq = false;
   bool compress_linear = false;
   bool compress_visvalingam = false;
+  bool compress_raster = false;
+  bool compress_douglas_peucker = false;
   bool named_sequences = false;
   bool bounds = false;
-  bool strict_bounds = false;
   int connectivity_offset = 0;
   float compress_visvalingam_tolerance = 10.0;
   int number_of_tiles = 1;

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/Cluster.cpp

@@ -20,7 +20,7 @@
 Cluster::Cluster(Finder *finder, int height)
   : finder_(finder)
 { tiles_.reserve(2);  // only two (left|right)
-  this->hub_ = new Hub(height);
+  this->hub_ = new Hub(height + 1);
 }
 
 Cluster::~Cluster() {