contrek 1.1.7 → 1.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d1025551133df8cf6974f60a7376965a4d0f05aa67e3056d7fdc80d9238c0b15
-  data.tar.gz: 340f67ea51692d68c66c8c50d95c85b424dfa3da556e886a778139b9e15163c6
+  metadata.gz: 87e8665985a5c9b3818f5f405609c8bf0f9d81dfaa197054e0801acdc60dc56c
+  data.tar.gz: 450c56eda5bd65ab936fcd52b37e3f8edbc2ec0ac852aa0cc4c052ee6d81ab7e
 SHA512:
-  metadata.gz: '08df976898407e0db4decf010da33a337b6a405232154676ae4d740c7872812e48c5f9f5943b3040b2d4dd0015e8d77b729c4c3ba332497a2c3aba4f642ab0d0'
-  data.tar.gz: dac48e9cf23557b132301481a262f4a536301aa3bcc5c86796ff7b7061a629e7fd4588ceb19b6bc962bfbee4fbd2e2414c7620bafd424b770ca1c265fc077d64
+  metadata.gz: e4cc2ea0d61819436e922eacdcad551658deceac1b5a907cea03d306de65fa2f71b96018acf6fcc6f88163775cabf0ba9b8d6ded3e9067dfcf3cc3e70d3e3e6d
+  data.tar.gz: ca933647465baca8a294176a1fbbc336bf1956c8eebab2cf48dd45ac4e55ba55ea84b00d38cbdd9ee0cf012b332684b8902c5e98a8cbaaafbfc846b374a12801

data/CHANGELOG.md

@@ -18,7 +18,7 @@ All notable changes to this project will be documented in this file.
 ### Added
 - Added C++ multithreading supports
 - Optimized old just present C++ code
-- Removed Png++ dependency in place of libspn
+- Removed Png++ dependency in place of libspng
 
 ## [1.0.7] - 2026-01-10
 ### Added
@@ -68,3 +68,15 @@ All notable changes to this project will be documented in this file.
 ### Changed
 - Added strict_bounds tracing mode: enables more accurate shape tracing by strictly adhering to pixel boundaries.
 - Topological Consistency Fixes: improved the Topologically Consistent Merging algorithm to support progressive polygon tracing during sequential data streaming.
+
+## [1.1.7] - 2026-03-23
+### Changed
+- Removed docs directory from gem.
+
+## [1.1.8] - 2026-04-19
+### Changed
+- Treemap now available on multiprocessing side too.
+
+## [1.1.9] - 2026-04-24
+### Changed
+- Improved the internal parts joining algorithm, which was imprecise in some circumstances.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    contrek (1.1.6)
+    contrek (1.1.9)
       chunky_png (~> 1.4)
       concurrent-ruby (~> 1.3.5)
       rice (= 4.5.0)

data/README.md

@@ -29,24 +29,24 @@ The core strength of Contrek is its **Topologically Consistent Merging** algorit
 
 <table>
   <tr>
-    <td><img src="docs/images/stripes/whole_0.png" alt="Contour tracing stripe 0" width="50%"></td>
-    <td rowspan="4" align="center">
-      <img src="docs/images/stripes/whole.png" alt="Contour tracing stripe 0" width="50%">
+    <td width="50%" style="padding: 0; background-color: white;">
+      <img src="docs/images/stripes/whole_0.png" width="100%"><br>
+      <img src="docs/images/stripes/whole_256.png" width="100%"><br>
+      <img src="docs/images/stripes/whole_512.png" width="100%"><br>
+      <img src="docs/images/stripes/whole_768.png" width="100%">
+    </td>
+    <td width="50%" align="center" style="vertical-align: middle; background-color: white;">
+      <strong>Full Topological Reconstruction</strong><br><br>
+      <img src="docs/images/stripes/whole.png" width="90%">
     </td>
   </tr>
   <tr>
-    <td><img src="docs/images/stripes/whole_256.png" alt="Contour tracing stripe 0" width="50%"></td>
-  </tr>
-  <tr>
-    <td><img src="docs/images/stripes/whole_512.png" alt="Contour tracing stripe 0" width="50%"></td>
-  </tr>
-  <tr>
-    <td><img src="docs/images/stripes/whole_768.png" alt="Contour tracing stripe 0" width="50%"></td>
+    <td colspan="2" align="center" style="background-color: white;">
+      <em><b>Left:</b> Image split into 4 independent memory buffers (stripes).</em><br>
+      <em><b>Right:</b> Contrek ensures <b>perfect topological continuity</b> during merging.</em><br>
+      🔴 <b>Red:</b> Outer contours &nbsp;&nbsp; | &nbsp;&nbsp; 🟢 <b>Green:</b> Inner zones
+    </td>
   </tr>
-  <tr><td colspan="2"><em><b>Left:</b> The image is split into 4 independent memory buffers (stripes).
-  <br><b>Right:</b> Contrek ensures <b>perfect topological continuity</b> during merging.</em>
-    <br><span style="color: #d32f2f;">■</span> <b>Red:</b> Outer contours |
-    <span style="color: #2e7d32;">■</span> <b>Dark Green:</b> Inner zones</td></tr>
 </table>
 
 ## Prerequisites
@@ -167,8 +167,6 @@ 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.
 
-- The treemap option is currently ignored (multithreaded treemap support will be introduced in upcoming revisions).
-
 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 1.2 secs with image load).
 
 ```ruby
@@ -290,7 +288,7 @@ result.metadata
 
 ## Treemap
 
-The treemap is a data structure that represents the containment hierarchy of polygons. For each polygon, it defines the parent polygon in which it is contained and its relative position among siblings. This structure allows reconstruction of the inclusion tree and determination of nesting relationships between geometries. Consider the above image
+The treemap is a data structure that represents the containment hierarchy of polygons. For each polygon, it defines the parent polygon in which it is contained and the index of the parent inner sequence in which is placed. This structure allows reconstruction of the inclusion tree and determination of nesting relationships between geometries. The treemap indexes are referred to positions inside the array of polygons returned by result.points. Consider the above image traced clockwise (o). 
 
 ```ruby
  "AAAAAAAAAAAAAAAAAAAAAA" \
@@ -311,8 +309,8 @@ result.metadata[:treemap]
 
 [[-1, -1],  # A
  [0, 0],    # B
- [1, 0],    # C
- [1, 1]]    # D
+ [1, 1],    # C
+ [1, 0]]    # D
 ```
 
 There are four polygons (`A`, `B`, `C`, and `D`).  
@@ -321,13 +319,42 @@ The order matches the one provided in `result.polygons`.
 Each entry has the structure:
 
 ```
-[parent_index, position]
+[parent_index, index_of_parent_inner_sequence]
 ```
 
 - Polygon **A** (index `0`) has no parent and is represented as `[-1, -1]`
-- Polygon **B** is contained in **A** and is its first child → `[0, 0]`
-- Polygon **C** is contained in **B** and is its first child → `[1, 0]`
-- Polygon **D** is also contained in **B** and is its second child → `[1, 1]`
+- Polygon **B** is contained in **A** in the first (0) and unique inner sequence of A → `[0, 0]`
+- Polygon **C** is contained in **B** and inside its second (1) inner sequence → `[1, 1]`
+- Polygon **D** is also contained in **B** but in the first (0) of its inner sequences → `[1, 0]`
+
+**C** is inside the **second** B inner sequence and **D** is inside the **first** B inner sequence because when the contour is traced clockwise the inner sequences are listed from right to left (left to right when anti-clockwise).
+
+Consider this sequence
+```ruby
+  "AAAAAAAAAAAAAAA       " \
+  "A             A       " \
+  "A BBBBBBBBBBB A       " \
+  "A B         B A       " \
+  "A B CC DD E B A       " \
+  "A B         B A       " \
+  "A BBBBBBBBBBB A       " \
+  "A             A       " \
+  "AAAAAAAAAAAAAAA       "
+ ``` 
+
+will get 
+
+```ruby
+result.metadata[:treemap]
+
+[[-1, -1],  # A
+ [0, 0],    # B
+ [1, 0],    # C
+ [1, 0],    # D
+ [1, 0]]    # E
+```
+C, D and E will get the same pair (**[1, 0]**) because are all placed inside the first (0) inner sequence of B.
+
 
 ## Multithreaded approach
 

data/ext/cpp_polygon_finder/PolygonFinder/CMakeLists.txt

@@ -3,20 +3,28 @@ project(ContrekCore C CXX)
 
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_C_STANDARD 11)
-
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pthread -march=native -DNDEBUG -Ofast -flto")
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O3 -march=native -fPIC -DNDEBUG")
-set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -pthread -flto=auto -Wl,--no-as-needed")
-
-find_package(ZLIB REQUIRED)
-find_library(TCMALLOC_LIB tcmalloc) # <--- Cerca tcmalloc nel sistema
-
-if(TCMALLOC_LIB)
-    message(STATUS "Contrek: tcmalloc found in ${TCMALLOC_LIB}")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    message(STATUS "Contrek: debuginning mode (ASan + GDB)")
+    set(CMAKE_CXX_FLAGS_DEBUG "-g -O0 -fsanitize=address -fno-omit-frame-pointer")
+    set(CMAKE_C_FLAGS_DEBUG "-g -O0 -fsanitize=address -fno-omit-frame-pointer")
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=address")
+    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fsanitize=address")
+    list(FILTER CMAKE_CXX_FLAGS EXCLUDE REGEX "-DNDEBUG")
+    list(FILTER CMAKE_C_FLAGS EXCLUDE REGEX "-DNDEBUG")
 else()
-    message(WARNING "Contrek: tcmalloc not found; standard one will be used.")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pthread -march=native -DNDEBUG -Ofast -flto")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O3 -march=native -fPIC -DNDEBUG")
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -pthread -flto=auto -Wl,--no-as-needed")
+    find_library(TCMALLOC_LIB tcmalloc)
+    if(TCMALLOC_LIB)
+        message(STATUS "Contrek: tcmalloc found in ${TCMALLOC_LIB}")
+    else()
+        message(WARNING "Contrek: tcmalloc not found; standard one will be used.")
+    endif()
 endif()
 
+find_package(ZLIB REQUIRED)
+
 file(GLOB_RECURSE CPP_SOURCES "*.cpp")
 file(GLOB_RECURSE C_SOURCES "*.c")
 

data/ext/cpp_polygon_finder/PolygonFinder/clean.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+
+# Get the script's directory (the project root)
+ROOT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
+BUILD_DIR="$ROOT_DIR/build"
+
+echo "--- Surgical cleanup initiated in: $BUILD_DIR ---"
+
+# Check if the build directory exists
+if [ ! -d "$BUILD_DIR" ]; then
+    echo "Build directory does not exist. Nothing to clean."
+    exit 0
+fi
+
+# Enter the build directory to operate safely
+cd "$BUILD_DIR" || exit
+
+# Remove critical CMake files and object files without deleting the build folder itself
+echo "Removing cache files and build artifacts..."
+rm -rf CMakeCache.txt CMakeFiles/ cmake_install.cmake Makefile bin/ lib/ examples/
+
+# Optional: Recursively remove all .o, .a, and .so files if present
+find . -name "*.o" -delete
+find . -name "*.a" -delete
+find . -name "*.so" -delete
+
+echo "--- Cleanup complete. The build directory is now pristine. ---"
+echo "You can now run: cmake -DBUILD_EXAMPLES=ON .."

data/ext/cpp_polygon_finder/PolygonFinder/examples/example.cpp

@@ -24,7 +24,7 @@ void run_test() {
   // test_suite.test_f();
   // test_suite.test_g();
   // test_suite.test_h();
-  test_suite.test_i();
+  // test_suite.test_i();
   std::cout << "compute time =" << cpu_timer.stop() << std::endl;
 }
 
@@ -33,11 +33,13 @@ int main() {
   cfg.threads = 4;
   cfg.tiles = 4;
   cfg.compress_unique = true;
-  cfg.connectivity_mode = Contrek::Connectivity::OMNIDIRECTIONAL;
+  // cfg.treemap = true;
+  // cfg.connectivity_mode = Contrek::Connectivity::OMNIDIRECTIONAL;
 
   CpuTimer cpu_timer;
   cpu_timer.start();
   std::cout << "--- Start Native Benchmark ---" << std::endl;
+  // auto result = Contrek::trace("../images/graphs_1024x1024.png", cfg);
   auto result = Contrek::trace("../images/sample_10240x10240.png", cfg);
   result->print_info();
   std::cout << "Found polygons: " << result->groups << std::endl;

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

@@ -155,7 +155,7 @@ void Tests::test_d()
   std::cout << "color =" << color << std::endl;
   RGBNotMatcher not_matcher(color);
 
-  std::vector<std::string> arguments = {"--versus=a", "--compress_uniq"};
+  std::vector<std::string> arguments = {"--versus=a", "--compress_uniq", "--treemap"};
   PolygonFinder pl(&png_bitmap, &not_matcher, nullptr, &arguments);
   ProcessResult *o = pl.process_info();
   o->print_info();

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

@@ -74,4 +74,6 @@ class Node : public  Listable {
   Node(int min_x, int max_x, int y, NodeCluster* cluster, char name);
   void precalc_tangs_sequences(NodeCluster& cluster);
   bool processed = false;
+  int inner_left_index = -1;
+  int inner_right_index = -1;
 };

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

@@ -129,86 +129,89 @@ void NodeCluster::plot(int versus) {
       if ((this->nodes > 0) && (next_node != nullptr))
       { plot_node(poly.outer, next_node, root_node, versus, poly.bounds);
       }
-      this->sequences.push_back(std::move(this->plot_sequence));
-      this->plot_sequence.clear();
 
-      if (poly.outer.size() > 2)
+      if (poly.outer.size() >= 2)
       { this->polygons.push_back(poly);
-      }
-
-      int index_inner = 0;
-      while (inner_plot->size() > 0)
-      { this->plot_sequence.clear();
-        std::vector<Point*> inner_sequence;
-        std::list<Node*>::iterator first_i;
-        Node *first = nullptr;
-
-        Listable *act = inner_plot->first();
-        do
-        { if ((reinterpret_cast<Node*>(act))->tangs_count <= 2)
-          { first = reinterpret_cast<Node*>(act);
-            break;
-          }
-        }while((act = act->data_pointer[inner_plot->get_id()].next) != nullptr);
-
-        if (first == nullptr) first = reinterpret_cast<Node*>(inner_plot->first());
-
-        plot_sequence.push_back(first);
-        inner_plot->remove(first);
-        root_nodes->remove(first);
-
-        first->inner_index = index_inner;
-
-        Node* next_node = nullptr;
-
-        if (first->get_trackmax()) {
-          if (inner_v == Node::A) {
-            if (first->upper_end >= 0) next_node = &this->vert_nodes[first->y + Node::T_UP][first->upper_start];
+        this->sequences.push_back(std::move(this->plot_sequence));
+
+        int index_inner = 0;
+        while (inner_plot->size() > 0)
+        { this->plot_sequence.clear();
+          std::vector<Point*> inner_sequence;
+          std::list<Node*>::iterator first_i;
+          Node *first = nullptr;
+
+          Listable *act = inner_plot->first();
+          do
+          { if ((reinterpret_cast<Node*>(act))->tangs_count <= 2)
+            { first = reinterpret_cast<Node*>(act);
+              break;
+            }
+          }while((act = act->data_pointer[inner_plot->get_id()].next) != nullptr);
+
+          if (first == nullptr) first = reinterpret_cast<Node*>(inner_plot->first());
+
+          plot_sequence.push_back(first);
+          inner_plot->remove(first);
+          root_nodes->remove(first);
+
+          first->inner_index = index_inner;
+
+          Node* next_node = nullptr;
+
+          if (first->get_trackmax()) {
+            if (inner_v == Node::A) {
+              if (first->upper_end >= 0) next_node = &this->vert_nodes[first->y + Node::T_UP][first->upper_start];
+            } else {
+              if (first->lower_end >= 0) next_node = &this->vert_nodes[first->y + Node::T_DOWN][first->lower_start];
+            }
           } else {
-            if (first->lower_end >= 0) next_node = &this->vert_nodes[first->y + Node::T_DOWN][first->lower_start];
+            if (inner_v == Node::A) {
+              if (first->lower_end >= 0) next_node = &this->vert_nodes[first->y + Node::T_DOWN][first->lower_end];
+            } else {
+              if (first->upper_end >= 0) next_node = &this->vert_nodes[first->y + Node::T_UP][first->upper_end];
+            }
           }
-        } else {
-          if (inner_v == Node::A) {
-            if (first->lower_end >= 0) next_node = &this->vert_nodes[first->y + Node::T_DOWN][first->lower_end];
-          } else {
-            if (first->upper_end >= 0) next_node = &this->vert_nodes[first->y + Node::T_UP][first->upper_end];
-          }
-        }
 
-        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);
+          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);
+          }
+          this->polygons.back().inner.push_back(inner_sequence);
+          this->inner_plot->grab(this->inner_new);
+          index_inner++;
         }
-        this->polygons.back().inner.push_back(inner_sequence);
-        this->inner_plot->grab(this->inner_new);
-        index_inner++;
+      } else {
+        this->plot_sequence.clear();
+      }
+      if (this->options->treemap)
+      { 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->sequences.push_back(std::move(this->plot_sequence));
       this->plot_sequence.clear();
     }
-    // tree
-    if (this->options->treemap)
-    { this->treemap.push_back(versus == Node::A ? this->test_in_hole_a(root_node) : this->test_in_hole_o(root_node));
-    }
-    index_order++;
   }
 }
 
 std::pair<int, int> NodeCluster::test_in_hole_a(Node* node)
 { if (node->outer_index > 0)
   { int start_left = node->abs_x_index - 1;
+    auto& row = this->vert_nodes[node->y];
+    int row_size = static_cast<int>(row.size());
+    if (start_left < 0 && row_size > 0) {
+      start_left = row_size - 1;
+    }
     do {
       Node* prev = &this->vert_nodes[node->y][start_left];
       int cindex = prev->outer_index;
-
       if ((cindex < node->outer_index) && (prev->track & Node::IMAX))
       { unsigned int start_right = node->abs_x_index;
         unsigned int line_size = this->vert_nodes[node->y].size();
         while (++start_right != line_size)
         { Node* tnext = &this->vert_nodes[node->y][start_right];
           if (tnext->outer_index == cindex) {
-            if (tnext->track & Node::IMIN) return {cindex, prev->inner_index};
+            if (tnext->track & Node::IMIN) return {cindex, prev->inner_right_index == -1 ? prev->inner_left_index : prev->inner_right_index};
             else                           return {-1, -1};
           }
         }
@@ -222,18 +225,16 @@ std::pair<int, int> NodeCluster::test_in_hole_o(Node* node)
 { auto& line = this->vert_nodes[node->y];
   const unsigned int line_size = line.size();
   if (node->outer_index == 0 || &line.back() == node) return {-1, -1};
-
   unsigned int start_left = node->abs_x_index + 1;
   do {
     Node* prev = &line[start_left];
     int cindex = prev->outer_index;
-
     if (cindex < node->outer_index && (prev->track & Node::IMIN))
     { int start_right = node->abs_x_index;
       while (--start_right >= 0) {
         Node* tnext = &line[start_right];
         if (tnext->outer_index == cindex) {
-          if (tnext->track & Node::IMAX) return {cindex, prev->inner_index};
+          if (tnext->track & Node::IMAX) return {cindex, prev->inner_left_index == -1 ? prev->inner_right_index : prev->inner_left_index};
           else                           return {-1, -1};
         }
       }
@@ -247,15 +248,20 @@ void NodeCluster::plot_inner_node(std::vector<Point*>& sequence_coords, Node *no
   bool strict_bounds = this->options->strict_bounds;
   while (current_node != nullptr) {
     current_node->outer_index = start_node->outer_index;
-    current_node->inner_index = stop_at->inner_index;
     root_nodes->remove(current_node);
     inner_plot->remove(current_node);
 
     Node *last_node = plot_sequence.back();
     Node *next_node = current_node->my_next_inner(last_node, versus);
-
     plot_sequence.push_back(current_node);
 
+    bool first_is_max = ((current_node->y > last_node->y) == (versus == Node::A));
+    if (first_is_max) {
+      if (current_node->inner_right_index == -1) current_node->inner_right_index = stop_at->inner_index;
+    } else {
+      if (current_node->inner_left_index == -1) current_node->inner_left_index = stop_at->inner_index;
+    }
+
     bool plot = true;
     if (next_node->y == last_node->y) {
       Node *n;
@@ -273,7 +279,6 @@ void NodeCluster::plot_inner_node(std::vector<Point*>& sequence_coords, Node *no
         }
       }
     } else if (strict_bounds) {
-        bool first_is_max = ((current_node->y > last_node->y) == (versus == Node::A));
         sequence_coords.push_back(this->points_pool.acquire((first_is_max ? last_node->max_x : last_node->min_x), current_node->y));
         sequence_coords.push_back(this->points_pool.acquire((first_is_max ? next_node->min_x : next_node->max_x), current_node->y));
       }

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

@@ -0,0 +1,14 @@
+/*
+ * Primitives.h
+ *
+ * Copyright (c) 2025-2026 Emanuele Cesaroni
+ *
+ * Licensed under the GNU Affero General Public License v3 (AGPLv3).
+ * See the LICENSE file in this directory for the full license text.
+ */
+#pragma once
+
+struct Bounds {
+  int min;
+  int max;
+};

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

@@ -14,5 +14,5 @@
 
 class ClippedPolygonFinder : public PolygonFinder {
  public:
-  ClippedPolygonFinder(Bitmap *bitmap, Matcher *matcher, int bm_start_x, int bm_end_x, std::vector<std::string> *options = nullptr);
+  ClippedPolygonFinder(Bitmap *bitmap, Matcher *matcher, int bm_start_x, int bm_end_x, std::vector<std::string>* options = nullptr);
 };

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

@@ -49,17 +49,20 @@ void Cluster::list_to_string(std::vector<Point*> list)
 }
 
 Tile* Cluster::merge_tiles() {
+  bool treemap = this->finder->options().treemap;
   double tot_inner = 0;
   double tot_outer = 0;
   CpuTimer timer;
-  std::list<Shape*> shapes;
+
+  std::list<Shape*> new_shapes;
+  std::vector<InnerPolyline*> all_new_inner_polylines;
 
   timer.start();
   for (Tile* tile : tiles_) {
     for (Shape *shape : tile->shapes()) {
       if (shape->outer_polyline->is_on(Polyline::TRACKED_OUTER) || shape->outer_polyline->width() == 0) continue;
-      if (shape->outer_polyline->boundary())
-      { shape->outer_polyline->partition();
+      if (shape->outer_polyline->boundary()) {
+        shape->outer_polyline->partition();
         shape->outer_polyline->precalc();
       }
     }
@@ -68,51 +71,111 @@ Tile* Cluster::merge_tiles() {
 
   for (Tile* tile : tiles_) {
     std::list<Shape*>& src = tile->shapes();
-    for (auto it = src.begin(); it != src.end(); )
-    { Shape* shape = *it;
-      if (shape->outer_polyline->is_on(Polyline::TRACKED_OUTER) || shape->outer_polyline->width() == 0)
-      { it++;
+
+    for (Shape* shape : src) {
+      if (shape->outer_polyline->is_on(Polyline::TRACKED_OUTER) || shape->outer_polyline->width() == 0) {
         continue;
       }
 
       if (shape->outer_polyline->boundary() && !shape->outer_polyline->next_tile_eligible_shapes().empty()) {
-        Sequence* new_outer = nullptr;
-        std::list<std::vector<Point*>> new_inners = shape->inner_polylines;
         Cursor cursor(*this, shape);
+        Sequence* new_outer = nullptr;
+
         timer.start();
         new_outer = cursor.join_outers();
         tot_outer += timer.stop();
 
         timer.start();
-        std::vector<Sequence*> new_inner_sequences = cursor.join_inners(new_outer);
+        std::vector<InnerPolyline*> new_inners = shape->inner_polylines;
+        std::vector<InnerPolyline*> new_inner_polylines = cursor.join_inners(new_outer);
         tot_inner += timer.stop();
 
-        for (Sequence* s : new_inner_sequences) {
-          new_inners.push_back(s->to_vector());
-          delete s;
+        for (InnerPolyline* inner_polyline : new_inner_polylines) {
+          new_inners.push_back(inner_polyline);
+          if (treemap) {
+            inner_polyline->sequence()->compute_vertical_bounds();
+            all_new_inner_polylines.push_back(inner_polyline);
+            for (const auto orphan_inner : cursor.orphan_inners()) {
+              if (orphan_inner->recombined()) {
+                all_new_inner_polylines.push_back(orphan_inner);
+              }
+            }
+          }
         }
+
         for (auto s : cursor.orphan_inners()) {
           new_inners.push_back(s);
         }
-        Polyline* polyline = new Polyline(tile, new_outer->to_vector());
-        Shape* shape = new Shape(polyline, new_inners);
-        shapes.push_back(shape);
-        polyline->shape = shape;
-        it++;
+
+        Polyline* polyline = tile->shapes_pool->acquire_polyline(tile, new_outer->to_vector(), std::nullopt);
+        Shape* inserting_new_shape = tile->shapes_pool->acquire_shape(polyline, new_inners);
+
+        new_shapes.push_back(inserting_new_shape);
+        polyline->shape = inserting_new_shape;
+        inserting_new_shape->set_parent_shape(shape->parent_shape());
+
+        for (InnerPolyline* inner_polyline : new_inner_polylines) {
+          inner_polyline->sequence()->shape = inserting_new_shape;
+        }
+
+        if (treemap) {
+          for (const auto merged_shape : cursor.shapes_sequence()) {
+            merged_shape->merged_to_shape = inserting_new_shape;
+          }
+          this->assign_ancestry(inserting_new_shape, all_new_inner_polylines);
+        }
+
       } else {
-        shapes.push_back(shape);
-        it = src.erase(it);
+        if (treemap && !shape->reassociation_skip && shape->parent_shape() == nullptr) {
+          this->assign_ancestry(shape, all_new_inner_polylines);
+        }
+        new_shapes.push_back(shape);
+      }
+    }
+  }
+
+  if (treemap) {
+    for (Tile* tile : tiles_) {
+      for (Shape* shape : tile->shapes()) {
+        Shape* parent = shape->parent_shape();
+        while (parent && parent->merged_to_shape != nullptr) {
+          parent = parent->merged_to_shape;
+        }
+        if (parent != shape->parent_shape()) {
+          shape->set_parent_shape(parent);
+        }
       }
     }
   }
+
   double past_tot_outer = tiles_.front()->benchmarks.outer + tiles_.back()->benchmarks.outer;
   double past_tot_inner = tiles_.front()->benchmarks.inner + tiles_.back()->benchmarks.inner;
+
   Benchmarks b{
     tot_outer + past_tot_outer,
     tot_inner + past_tot_inner
   };
-  Tile* tile = new Tile(this->finder, tiles_.front()->start_x(), tiles_.back()->end_x(), tiles_.front()->name() + tiles_.back()->name(), b);
-  tile->assign_shapes(shapes);
-  return(tile);
+
+  Tile* tile = new Tile(
+    this->finder, tiles_.front()->start_x(), tiles_.back()->end_x(), tiles_.front()->name() + tiles_.back()->name(), b);
+
+  tile->assign_shapes(new_shapes);
+  for (Tile* old_tile : tiles_) {
+    tile->adopt(old_tile);
+  }
+  return tile;
 }
 
+void Cluster::assign_ancestry(Shape *shape, std::vector<InnerPolyline*>& inner_polylines)
+{ for (auto* inner_polyline : inner_polylines) {
+    if (shape->outer_polyline->vert_bounds_intersect(inner_polyline->vertical_bounds())) {
+      if (shape->outer_polyline->within(inner_polyline->raw())) {
+        shape->set_parent_shape(inner_polyline->shape());
+        shape->parent_inner_polyline = inner_polyline;
+        for (auto* children_shape : shape->children_shapes) {
+          children_shape->reassociation_skip = true;
+        }
+      }
+    }
+  }
+}