contrek 1.4.5 → 1.4.7

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

@@ -0,0 +1,104 @@
+/*
+ * MergerValidator.cpp
+ *
+ * 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.
+ */
+
+#include "MergerValidator.h"
+#include "Merger.h"
+#include <algorithm>
+#include <stdexcept>
+#include <vector>
+#include <list>
+#include <utility>
+
+MergerValidator::MergerValidator(const Merger& merger)
+  : merger_(merger) {}
+
+void MergerValidator::validate_metadata(const ProcessResult& result) const {
+  if (result.width <= 0) {
+    throw std::invalid_argument("Invalid result metadata: width must be a positive integer");
+  }
+  if (result.height <= 0) {
+    throw std::invalid_argument("Invalid result metadata: height must be a positive integer");
+  }
+  if (result.versus != Node::A && result.versus != Node::O) {
+    throw std::invalid_argument("Invalid result metadata: unsupported versus option");
+  }
+}
+
+void MergerValidator::validate(const ProcessResult& result, int start_x, int end_x) {
+  validate_bounds(result.polygons);
+  validate_polygon_order(result.polygons);
+  validate_boundary(result, start_x);
+
+  previous_boundary_ = boundary_coordinates(result.polygons, end_x);
+  has_previous_boundary_ = true;
+}
+
+void MergerValidator::validate_bounds(const std::list<Polygon>& polygons) const {
+  for (const auto& polygon : polygons) {
+    if (polygon.outer.empty()) {
+      throw std::invalid_argument("Invalid polygon: empty outer contour");
+    }
+    RectBounds actual = RectBounds::empty();
+
+    for (const auto& point : polygon.outer) {
+      actual.expand(point.x, point.y);
+    }
+
+    const auto& bounds = polygon.bounds;
+    if (bounds.min_x != actual.min_x ||
+        bounds.max_x != actual.max_x ||
+        bounds.min_y != actual.min_y ||
+        bounds.max_y != actual.max_y) {
+      throw std::invalid_argument("Invalid polygon bounds: bounding box does not match outer contour");
+    }
+  }
+}
+
+void MergerValidator::validate_polygon_order(const std::list<Polygon>& polygons) const {
+  bool has_previous = false;
+  std::pair<int, int> previous;
+
+  for (const auto& polygon : polygons) {
+    const auto& bounds = polygon.bounds;
+
+    const std::pair<int, int> current = merger_.transpose()
+      ? std::make_pair(bounds.min_x, bounds.min_y)
+      : std::make_pair(bounds.min_y, bounds.min_x);
+
+    if (has_previous && current < previous) {
+      throw std::invalid_argument("Invalid polygon order: polygons are not in raster scan order");
+    }
+    previous = current;
+    has_previous = true;
+  }
+}
+
+void MergerValidator::validate_boundary(const ProcessResult& result, int start_x) const {
+  if (!has_previous_boundary_) return;
+
+  const auto current = boundary_coordinates(result.polygons, start_x);
+  if (previous_boundary_ != current) {
+    throw std::invalid_argument("Tile boundary mismatch: adjacent tiles have different edge coordinates");
+  }
+}
+
+std::vector<int> MergerValidator::boundary_coordinates(const std::list<Polygon>& polygons, int boundary_x) {
+  std::vector<int> coordinates;
+
+  for (const auto& polygon : polygons) {
+    for (const auto& point : polygon.outer) {
+      if (point.x == boundary_x) {
+        coordinates.push_back(point.y);
+      }
+    }
+  }
+
+  std::sort(coordinates.begin(), coordinates.end());
+  return coordinates;
+}

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

@@ -0,0 +1,35 @@
+/*
+ * MergerValidator.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
+
+#include <vector>
+#include <list>
+#include "../PolygonFinder.h"
+
+class Merger;
+
+class MergerValidator {
+ public:
+  explicit MergerValidator(const Merger& merger);
+
+  void validate_metadata(const ProcessResult& result) const;
+  void validate(const ProcessResult& result, int start_x, int end_x);
+
+ private:
+  const Merger& merger_;
+  std::vector<int> previous_boundary_;
+  bool has_previous_boundary_ = false;
+
+  void validate_bounds(const std::list<Polygon>& polygons) const;
+  void validate_polygon_order(const std::list<Polygon>& polygons) const;
+  void validate_boundary(const ProcessResult& result, int start_x) const;
+
+  static std::vector<int> boundary_coordinates(const std::list<Polygon>& polygons, int boundary_x);
+};

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

@@ -17,10 +17,11 @@
 #include "Tile.h"
 #include "Shape.h"
 
-Polyline::Polyline(ShapePool* shape_pool, Tile* tile, std::vector<Point> polygon, const std::optional<RectBounds>& bounds)
+Polyline::Polyline(ShapePool* shape_pool, Tile* tile, std::vector<Point> polygon, const std::optional<RectBounds>& bounds, unsigned int class_id)
 : tile(tile),
   shape_pool(shape_pool),
-  raw_(std::move(polygon))
+  raw_(std::move(polygon)),
+  class_id_(class_id)
 { if (bounds.has_value()) {
     min_x =  bounds->min_x;
     max_x_ = bounds->max_x;

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

@@ -29,7 +29,7 @@ class InnerPolyline;
 class Polyline : public Partitionable {
  public:
   using Partitionable::Partitionable;
-  Polyline(ShapePool* shape_pool, Tile* tile, std::vector<Point> polygon, const std::optional<RectBounds>& bounds = std::nullopt);
+  Polyline(ShapePool* shape_pool, Tile* tile, std::vector<Point> polygon, const std::optional<RectBounds>& bounds = std::nullopt, unsigned int class_id = 0);
   enum Flags : uint32_t {
     TRACKED_OUTER = 1 << 0
   };
@@ -47,6 +47,7 @@ class Polyline : public Partitionable {
   int max_y() const { return max_y_; }
   int min_y() const { return min_y_; }
   int max_x() const { return max_x_; }
+  unsigned int class_id() const { return class_id_; }
   void clear();
   bool is_empty();
   bool any_ancients = false;
@@ -63,5 +64,6 @@ class Polyline : public Partitionable {
   void find_boundary();
   uint32_t flags_ = 0;
   int name;
+  unsigned int class_id_;
   std::string named_;
 };

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

@@ -49,6 +49,7 @@ std::string Shape::name() {
 Polygon Shape::to_raw_polygon(bool bounds) {
   Polygon poly;
   poly.outer = this->outer_polyline->raw();
+  poly.class_id = this->outer_polyline->class_id();
   if (bounds) {
     this->outer_polyline->fill_bounds(poly.bounds);
   }

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

@@ -19,8 +19,8 @@ Shape* ShapePool::acquire_shape(Polyline* outer_polyline, const std::vector<Inne
   return shape;
 }
 
-Polyline* ShapePool::acquire_polyline(Tile* tile, std::vector<Point> polygon, const std::optional<RectBounds>& bounds = std::nullopt) {
-  return this->polylines.acquire(this, tile, std::move(polygon), bounds);
+Polyline* ShapePool::acquire_polyline(Tile* tile, std::vector<Point> polygon, unsigned int class_id, const std::optional<RectBounds>& bounds = std::nullopt) {
+  return this->polylines.acquire(this, tile, std::move(polygon), bounds, class_id);
 }
 
 InnerPolyline* ShapePool::acquire_inner_polyline(std::vector<Point> coords, Shape* shape) {

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

@@ -29,7 +29,7 @@ class ShapePool {
   Shape* acquire_shape(Polyline* outer_polyline, const std::vector<InnerPolyline*>& inner_polylines);
   InnerPolyline* acquire_inner_polyline(std::vector<Point> coords, Shape* s);
   InnerPolyline* acquire_inner_polyline(Sequence* seq);
-  Polyline* acquire_polyline(Tile* tile, std::vector<Point> polygon, const std::optional<RectBounds>& bounds);
+  Polyline* acquire_polyline(Tile* tile, std::vector<Point> polygon, unsigned int class_id, const std::optional<RectBounds>& bounds);
   void set_owner(Tile* tile);
   void detach_shape();
   void detach_polyline();

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

@@ -60,27 +60,25 @@ void Tile::assign_raw_polygons(const std::list<Polygon>& raw_polylines, const st
   std::unordered_map<int, Shape*> shapes_map;
   int polyline_index = 0;
   for (const auto& raw_polyline : raw_polylines)
-  { if (raw_polyline.bounds.width() > 0)
-    { Polyline* polyline = this->shapes_pool->acquire_polyline(this, raw_polyline.outer, raw_polyline.bounds);
-      std::vector<InnerPolyline*> inner_polylines_list;
-      for (auto& raw_points : raw_polyline.inner) {
-        inner_polylines_list.push_back(this->shapes_pool->acquire_inner_polyline(raw_points, nullptr));
-      }
-      Shape* shape = this->shapes_pool->acquire_shape(polyline, inner_polylines_list);
-      polyline->shape = shape;
-      this->shapes_.push_back(shape);
-
-      if (treemap.size() > 0)
-      { auto treemap_entry = treemap[polyline_index];
-        shapes_map[polyline_index] = shape;
-        if (treemap_entry.first != -1 && treemap_entry.second != -1) {
-          auto it = shapes_map.find(treemap_entry.first);
-          if (it != shapes_map.end()) {
-            Shape* parent = it->second;
-            shape->set_parent_shape(parent);
-            shape->fixed = true;
-            shape->parent_inner_polyline = parent->inner_polylines[treemap_entry.second];
-          }
+  { Polyline* polyline = this->shapes_pool->acquire_polyline(this, raw_polyline.outer, raw_polyline.class_id, raw_polyline.bounds);
+    std::vector<InnerPolyline*> inner_polylines_list;
+    for (auto& raw_points : raw_polyline.inner) {
+      inner_polylines_list.push_back(this->shapes_pool->acquire_inner_polyline(raw_points, nullptr));
+    }
+    Shape* shape = this->shapes_pool->acquire_shape(polyline, inner_polylines_list);
+    polyline->shape = shape;
+    this->shapes_.push_back(shape);
+
+    if (treemap.size() > 0)
+    { auto treemap_entry = treemap[polyline_index];
+      shapes_map[polyline_index] = shape;
+      if (treemap_entry.first != -1 && treemap_entry.second != -1) {
+        auto it = shapes_map.find(treemap_entry.first);
+        if (it != shapes_map.end()) {
+          Shape* parent = it->second;
+          shape->set_parent_shape(parent);
+          shape->fixed = true;
+          shape->parent_inner_polyline = parent->inner_polylines[treemap_entry.second];
         }
       }
     }

data/ext/cpp_polygon_finder/cpp_polygon_finder.cpp

@@ -106,6 +106,8 @@
 #include "PolygonFinder/src/polygon/finder/concurrent/PartPool.cpp"
 #include "PolygonFinder/src/polygon/finder/concurrent/Merger.h"
 #include "PolygonFinder/src/polygon/finder/concurrent/Merger.cpp"
+#include "PolygonFinder/src/polygon/finder/concurrent/MergerValidator.h"
+#include "PolygonFinder/src/polygon/finder/concurrent/MergerValidator.cpp"
 #include "PolygonFinder/src/polygon/finder/concurrent/HorizontalMerger.h"
 #include "PolygonFinder/src/polygon/finder/concurrent/HorizontalMerger.cpp"
 #include "PolygonFinder/src/polygon/finder/concurrent/VerticalMerger.h"
@@ -275,6 +277,9 @@ class To_Ruby<ProcessResult*>
         poly_hash[Symbol("bounds")] = bounds_hash;
       }
 
+      if(pr->options.contains("multiclass")) {
+        poly_hash[Symbol("class")] = x.class_id;
+      }
       out.push(poly_hash);
     }
     rr->polygons = out;
@@ -315,6 +320,10 @@ ProcessResult ruby_result_to_process_result(Rice::Object rb_result) {
   for (size_t i = 0; i < rb_polygons.size(); ++i) {
     Rice::Hash rb_poly = (Rice::Hash)rb_polygons[i];
     Polygon poly;
+    Rice::Object rb_class = rb_poly[Symbol("class")];
+    if (!rb_class.is_nil()) {
+      poly.class_id = detail::From_Ruby<unsigned int>().convert(rb_class.value());
+    }
     // BOUNDS
     Rice::Object rb_bounds_obj = rb_poly[Symbol("bounds")];
     if (!rb_bounds_obj.is_nil()) {
@@ -380,10 +389,9 @@ SvgStreamingMerger* create_svg_streaming_merger(Object self,
 GeoJsonStreamingMerger* create_geo_json_streaming_merger(Object self,
                                          int number_of_threads,
                                          Options options,
-                                         Object stream_obj,
-                                         int pixel_val) {
+                                         Object stream_obj) {
   OfstreamWrapper* wrapper = Rice::detail::From_Ruby<OfstreamWrapper*>().convert(stream_obj.value());
-  return new GeoJsonStreamingMerger(number_of_threads, options, &wrapper->get_stream(), pixel_val);
+  return new GeoJsonStreamingMerger(number_of_threads, options, &wrapper->get_stream());
 }
 
 OfstreamWrapper* create_ofstream(Object self, std::string path) {

data/lib/contrek/cpp/cpp_geo_json_concurrent_streaming_merger.rb

@@ -3,8 +3,8 @@
 module Contrek
   module Cpp
     class CPPGeoJsonConcurrentStreamingMerger < CPPGeoJsonStreamingMerger
-      def self.new(stream_to:, number_of_threads: 0, options: nil, pixel_val: 0)
-        super(number_of_threads, options, stream_to, pixel_val)
+      def self.new(stream_to:, number_of_threads: 0, options: nil)
+        super(number_of_threads, options, stream_to)
       end
     end
   end

data/lib/contrek/cpp/cpp_result.rb

@@ -23,7 +23,8 @@ module Contrek
         @to_points ||= raw_list.map do |polygon|
           {bounds: (polygon[:bounds] if polygon.key?(:bounds)),
            outer: self.class.to_points(polygon[:outer]),
-           inner: polygon[:inner].map { |s| self.class.to_points(s) }}.compact
+           inner: polygon[:inner].map { |s| self.class.to_points(s) },
+           class: (polygon[:class] if polygon.key?(:class))}.compact
         end
       end
 

data/lib/contrek/finder/concurrent/cluster.rb

@@ -69,7 +69,7 @@ module Contrek
               end.real
               shape.clear_inner!
 
-              polyline = Polyline.new(tile: tile, polygon: new_outer.to_a)
+              polyline = Polyline.new(tile: tile, polygon: new_outer.to_a, class_id: shape.outer_polyline.class_id)
               inserting_new_shape = Shape.init_by(polyline, new_inners)
               new_shapes << inserting_new_shape
               polyline.shape = inserting_new_shape

data/lib/contrek/finder/concurrent/cursor.rb

@@ -91,7 +91,9 @@ module Contrek
               new_position.end_point.tracked_outer = true
               versus = act_part.versus
               part = new_position.end_point.queues.find do |p|
-                (p.versus == -versus) && p.polyline.tile != act_part.polyline.tile
+                (p.versus == -versus) &&
+                  p.polyline.tile != act_part.polyline.tile &&
+                  p.polyline.class_id == act_part.polyline.class_id
               end
               if part
                 if all_parts[-2] != part

data/lib/contrek/finder/concurrent/finder.rb

@@ -55,7 +55,8 @@ module Contrek
                   versus: current_versus,
                   bounds: true,
                   treemap: @options[:treemap],
-                  connectivity: @options[:connectivity]
+                  connectivity: @options[:connectivity],
+                  multiclass: @options[:multiclass]
                 }.compact,
                 start_x: payload[:tile_start_x],
                 end_x: payload[:tile_end_x]

data/lib/contrek/finder/concurrent/geo_json_streaming_merger.rb

@@ -3,11 +3,10 @@
 module Contrek
   module Concurrent
     class GeoJsonStreamingMerger < StreamingMerger
-      def initialize(stream_to:, pixel_val:, options: {})
-        @pixel_val = pixel_val
+      def initialize(stream_to:, options: {})
         @point_converter = self.class.coordinates_converter(options[:geo_localization])
 
-        super(stream_to:, options:)
+        super
       end
 
       def write_header
@@ -35,7 +34,7 @@ module Contrek
         end
         feature_hash = {
           type: "Feature",
-          properties: {PixelVal: @pixel_val},
+          properties: {PixelVal: polygon[:class]},
           geometry: {
             type: "Polygon",
             coordinates: polygon_coordinates

data/lib/contrek/finder/concurrent/merger.rb

@@ -13,18 +13,21 @@ module Contrek
         @current_x = 0
         @tiles = Queue.new
         @whole_tile = nil
-        @previous_boundary = nil
         @user_options = options
         if (warn_options = @user_options.keys & IGNORE_OPTIONS).any?
           warn "[Contrek WARNING] The given options '#{warn_options.join(",")}' will be ignored."
         end
         @options = {unsafe_mode: false}.merge(@user_options).except(*IGNORE_OPTIONS)
-        unless safe?
+        if safe?
+          @validator = MergerValidator.new(self)
+        else
           warn "[Contrek WARNING] Processing tile with 'unsafe_mode: true'. Incompatible result options might lead to unexpected vector geometry."
         end
       end
 
       def add_tile(result)
+        @validator&.validate_metadata(result)
+
         @height ||= result.metadata[:height]
         raise ArgumentError, "All results must have the same height" if @height != result.metadata[:height] && safe?
         @options[:versus] ||= result.metadata[:versus]
@@ -35,8 +38,8 @@ module Contrek
           end
         end
 
-        validate(result) if safe?
         end_x = @current_x + result.metadata[:width]
+        @validator&.validate(result, @current_x, end_x)
 
         tile = Tile.new(
           finder: self,
@@ -47,9 +50,6 @@ module Contrek
         tile.assign_raw_polygons!(result[:polygons])
 
         @tiles << tile
-
-        @previous_boundary = boundary_coordinates(result.polygons, end_x) if safe?
-
         @maximum_width = end_x
         @current_x = end_x - 1
       end
@@ -65,25 +65,6 @@ module Contrek
 
       private
 
-      def validate(result)
-        return unless @previous_boundary
-
-        current = boundary_coordinates(result.polygons, @current_x)
-        unless @previous_boundary == current
-          raise ArgumentError, "Tile boundary mismatch: adjacent tiles have different edge coordinates"
-        end
-      end
-
-      def boundary_coordinates(polygons, boundary_x)
-        coordinates = []
-        polygons.each do |polygon|
-          polygon[:outer].each do |point|
-            coordinates << point[:y] if point[:x] == boundary_x
-          end
-        end
-        coordinates.sort!
-      end
-
       def translate(result, offset)
         result.polygons.each do |polygon|
           polygon[:outer].each { |p| p[:x] += offset }

data/lib/contrek/finder/concurrent/merger_validator.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Contrek
+  module Concurrent
+    class MergerValidator
+      def initialize(merger)
+        @merger = merger
+      end
+
+      def validate(result, start_x, end_x)
+        validate_bounds(result.polygons)
+        validate_polygon_order(result.polygons)
+        validate_boundary(result, start_x)
+
+        @previous_boundary = boundary_coordinates(result.polygons, end_x)
+      end
+
+      def validate_metadata(result)
+        metadata = result.metadata
+        [:width, :height, :versus].each do |key|
+          raise ArgumentError, "Missing result metadata: #{key}" unless metadata.key?(key)
+        end
+        [:width, :height].each do |key|
+          value = metadata[key]
+          unless value.is_a?(Integer) && value.positive?
+            raise ArgumentError, "Invalid result metadata: #{key} must be a positive integer"
+          end
+        end
+        unless [:a, :o].include?(metadata[:versus])
+          raise ArgumentError, "Invalid result metadata: unsupported versus option"
+        end
+      end
+
+      private
+
+      def validate_polygon_order(polygons)
+        previous = nil
+        polygons.each do |polygon|
+          bounds = polygon[:bounds]
+          current = if @merger.transpose?
+            [bounds[:min_x], bounds[:min_y]]
+          else
+            [bounds[:min_y], bounds[:min_x]]
+          end
+          if previous && (current <=> previous) < 0
+            raise ArgumentError, "Invalid polygon order: polygons are not in raster scan order"
+          end
+          previous = current
+        end
+      end
+
+      def validate_boundary(result, start_x)
+        return unless @previous_boundary
+
+        current = boundary_coordinates(result.polygons, start_x)
+        unless @previous_boundary == current
+          raise ArgumentError, "Tile boundary mismatch: adjacent tiles have different edge coordinates"
+        end
+      end
+
+      def boundary_coordinates(polygons, boundary_x)
+        coordinates = []
+        polygons.each do |polygon|
+          polygon[:outer].each do |point|
+            coordinates << point[:y] if point[:x] == boundary_x
+          end
+        end
+        coordinates.sort!
+      end
+
+      def validate_bounds(polygons)
+        polygons.each do |polygon|
+          outer = polygon[:outer]
+          raise ArgumentError, "Invalid polygon: empty outer contour" if outer.empty?
+          bounds = polygon[:bounds]
+          min_x = max_x = outer[0][:x]
+          min_y = max_y = outer[0][:y]
+          outer.each do |point|
+            x = point[:x]
+            y = point[:y]
+            min_x = x if x < min_x
+            max_x = x if x > max_x
+            min_y = y if y < min_y
+            max_y = y if y > max_y
+          end
+          unless bounds[:min_x] == min_x &&
+              bounds[:max_x] == max_x &&
+              bounds[:min_y] == min_y &&
+              bounds[:max_y] == max_y
+            raise ArgumentError, "Invalid polygon bounds: bounding box does not match outer contour"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/contrek/finder/concurrent/polyline.rb

@@ -7,10 +7,10 @@ module Contrek
 
       TRACKED_OUTER = 1 << 0
 
-      attr_reader :raw, :name, :min_y, :max_y
+      attr_reader :raw, :name, :min_y, :max_y, :class_id
       attr_accessor :shape, :tile, :any_ancients, :inside_inner_polyline
 
-      def initialize(tile:, polygon:, shape: nil, bounds: nil, force_named: nil)
+      def initialize(tile:, polygon:, shape: nil, bounds: nil, force_named: nil, class_id: 0)
         @tile = tile
         @name = tile.shapes.count
         @named = force_named
@@ -19,6 +19,7 @@ module Contrek
         @flags = 0
         @any_ancients = false
         @inside_inner_polyline = nil
+        @class_id = class_id
 
         if bounds.nil?
           find_boundary

data/lib/contrek/finder/concurrent/shape.rb

@@ -40,8 +40,9 @@ module Contrek
         "Shape (outer_polyline = #{outer_polyline.named}, children count = #{@children_shapes.size}"
       end
 
-      def to_raw_polygon(bounds: false)
+      def to_raw_polygon(bounds: false, multiclass: false)
         {bounds: (outer_polyline.get_bounds if bounds),
+         class: (outer_polyline.class_id if multiclass),
          outer: outer_polyline.raw,
          inner: inner_polylines.map(&:raw)}.compact
       end

data/lib/contrek/finder/concurrent/streaming_merger.rb

@@ -37,7 +37,7 @@ module Contrek
           bounds = shape.outer_polyline.get_bounds
           if flush || bounds[:max_x] < safe_boundary_x
             @moved += 1
-            polygon = shape.to_raw_polygon
+            polygon = shape.to_raw_polygon(multiclass: true)
             polygons_to_stream << polygon
             false
           else

data/lib/contrek/finder/concurrent/tile.rb

@@ -57,7 +57,8 @@ module Contrek
 
       def to_raw_polygons
         bounds = @finder.options[:bounds]
-        @shapes.map { |s| s.to_raw_polygon(bounds:) }
+        multiclass = @finder.options[:multiclass]
+        @shapes.map { |s| s.to_raw_polygon(bounds:, multiclass:) }
       end
 
       def compute_treemap
@@ -92,9 +93,14 @@ module Contrek
         @shapes = []
         shapes_map = {}
         raw_polylines.each_with_index do |raw_polyline, polyline_index|
-          next if raw_polyline[:bounds][:max_x] - raw_polyline[:bounds][:min_x] == 0
           shape = Shape.new.tap do |shape|
-            shape.outer_polyline = Polyline.new(tile: self, polygon: raw_polyline[:outer], shape: shape, bounds: raw_polyline[:bounds])
+            shape.outer_polyline = Polyline.new(
+              tile: self,
+              polygon: raw_polyline[:outer],
+              shape: shape,
+              bounds: raw_polyline[:bounds],
+              class_id: raw_polyline[:class] || 0
+            )
             shape.inner_polylines = raw_polyline[:inner].map { |raw| InnerPolyline.new(shape: shape, raw_coordinates: raw) }
           end
           @shapes << shape