contrek 1.3.3 → 1.3.5

data/lib/contrek/finder/node_cluster.rb

@@ -32,7 +32,9 @@ module Contrek
         path_sequences do |seq|
           Contrek::Reducers::UniqReducer.new(points: seq).reduce! if @options[:compress].has_key?(:uniq)
           Contrek::Reducers::LinearReducer.new(points: seq, options: @options[:compress][:linear]).reduce! if @options[:compress].has_key?(:linear)
+          Contrek::Reducers::RasterReducer.new(points: seq, options: @options).reduce! if @options[:compress].has_key?(:raster)
           Contrek::Reducers::VisvalingamReducer.new(points: seq, options: @options[:compress][:visvalingam]).reduce! if @options[:compress].has_key?(:visvalingam)
+          Contrek::Reducers::DouglasPeuckerReducer.new(points: seq).reduce! if @options[:compress].has_key?(:douglas_peucker)
         end
       end
 
@@ -70,16 +72,44 @@ module Contrek
           else
             root_node.get_tangent_node_by_virtual_index(root_node.tangs_sequence.first)
           end
-          if !next_node.nil?
+
+          if next_node
+            beginning_point = (versus == :a) ? root_node.nw_point : root_node.ne_point
+            @sequence_coords << beginning_point
+            bounds.expand(**beginning_point)
+
             coord = next_node.coords_entering_to(root_node, VERSUS_INVERTER[versus], Contrek::Finder::Node::OUTER)
             @sequence_coords << coord
-            bounds.expand(x: coord[:x], y: coord[:y])
+            bounds.expand(**coord)
+          end
+
+          plot_node(next_node, root_node, bounds, versus) if @nodes > 0 && !next_node.nil?
+
+          if next_node.nil?
+            if versus == :a
+              nw_point = root_node.nw_point
+              @sequence_coords << nw_point
+              bounds.expand(**nw_point)
+              @sequence_coords << root_node.sw_point
+              se_point = root_node.se_point
+              @sequence_coords << se_point
+              bounds.expand(**se_point)
+              @sequence_coords << root_node.ne_point
+            else
+              ne_point = root_node.ne_point
+              @sequence_coords << ne_point
+              bounds.expand(**ne_point)
+              @sequence_coords << root_node.se_point
+              sw_point = root_node.sw_point
+              @sequence_coords << sw_point
+              bounds.expand(**sw_point)
+              @sequence_coords << root_node.nw_point
+            end
           end
-          plot_node(next_node, root_node, bounds, versus, @options[:strict_bounds]) if @nodes > 0 && !next_node.nil?
 
           draw_sequence(bitmap, "X") unless bitmap.nil?
 
-          if @sequence_coords.size >= 2
+          if @sequence_coords.any?
             @polygons << {outer: @sequence_coords, inner: [], bounds: (bounds.to_h if @options[:bounds])}.compact
             @sequences << @plot_sequence
 
@@ -117,10 +147,11 @@ module Contrek
 
               if !next_node.nil?
                 @sequence_coords << next_node.coords_entering_to(first, inner_v, Contrek::Finder::Node::INNER)
+                last_node = plot_inner_node(next_node, inner_v, first, root_node)
+                last_coord = last_node.coords_entering_to(first, VERSUS_INVERTER[inner_v], Contrek::Finder::Node::INNER)
+                @sequence_coords << last_coord if @sequence_coords.last != last_coord
               end
 
-              plot_inner_node(next_node, inner_v, first, root_node, options[:strict_bounds]) if !next_node.nil?
-
               draw_sequence(bitmap, "+") unless bitmap.nil?
 
               @polygons.last[:inner] << @sequence_coords
@@ -194,7 +225,7 @@ module Contrek
       # inner way
       # nodes in @plot_sequence
       # coordinates in @sequence_coords
-      def plot_inner_node(node, versus, stop_at, start_node, strict_bounds = false)
+      def plot_inner_node(node, versus, stop_at, start_node)
         node.outer_index = start_node.outer_index
         @root_nodes.delete(node)
         @inner_plot.delete(node)
@@ -214,16 +245,25 @@ module Contrek
           virtual_index = node.tangs_sequence.send((versus == :a) ? :first : :last)
           plot = (node.get_tangent_node_by_virtual_index(virtual_index) == next_node)
         end
+
         if plot
-          @sequence_coords << last_node.coords_entering_to(node, VERSUS_INVERTER[versus], Contrek::Finder::Node::INNER)
-          if node != start_node
-            if last_node.y == next_node.y
-              @sequence_coords << next_node.coords_entering_to(node, versus, Contrek::Finder::Node::INNER)
+          first_point = last_node.coords_entering_to(node, VERSUS_INVERTER[versus], Contrek::Finder::Node::INNER)
+          @sequence_coords << first_point if @sequence_coords.last != first_point
+          if next_node.y == last_node.y
+            if next_node.y < node.y
+              pt_a, pt_b = node.sw_point, node.se_point
+            else
+              pt_a, pt_b = node.ne_point, node.nw_point
+            end
+            if versus == :o
+              @sequence_coords << pt_a
+              @sequence_coords << pt_b
+            else
+              @sequence_coords << pt_b
+              @sequence_coords << pt_a
             end
           end
-        elsif strict_bounds
-          @sequence_coords << {y: node.y, x: (first_is_max ? last_node.max_x : last_node.min_x)}
-          @sequence_coords << {y: node.y, x: (first_is_max ? next_node.min_x : next_node.max_x)}
+          @sequence_coords << next_node.coords_entering_to(node, versus, Contrek::Finder::Node::INNER)
         end
 
         if node.track_uncomplete
@@ -232,12 +272,12 @@ module Contrek
           @inner_new.delete(node)
         end
 
-        return if next_node == stop_at
-        plot_inner_node(next_node, versus, stop_at, start_node, strict_bounds)
+        return node if next_node == stop_at
+        plot_inner_node(next_node, versus, stop_at, start_node)
       end
 
       # contour tracing core logic loop
-      def plot_node(node, start_node, bounds, versus = :a, strict_bounds = false)
+      def plot_node(node, start_node, bounds, versus = :a)
         @root_nodes.delete(node)
 
         node.outer_index = start_node.outer_index
@@ -252,32 +292,47 @@ module Contrek
           plot = (node.get_tangent_node_by_virtual_index(virtual_index) == next_node)
         end
 
-        # coord
         if plot
-          c = last_node.coords_entering_to(node, versus, Contrek::Finder::Node::OUTER)
-          @sequence_coords << c
-          bounds.expand(x: c[:x], y: c[:y])
+          start_coord = last_node.coords_entering_to(node, versus, Contrek::Finder::Node::OUTER)
+          if @sequence_coords.last != start_coord
+            @sequence_coords << start_coord
+            bounds.expand(**start_coord)
+          end
+
+          final_step = node == start_node && node.track_complete
+          if next_node.y == last_node.y
+            if next_node.y < node.y
+              pt_a, pt_b = node.se_point, node.sw_point
+            else
+              pt_a, pt_b = node.nw_point, node.ne_point
+            end
+            first = (versus == :o) ? pt_a : pt_b
+            second = (versus == :o) ? pt_b : pt_a
+            @sequence_coords << first
+            bounds.expand(**first)
+            unless final_step
+              @sequence_coords << second
+              bounds.expand(**second)
+            end
+          end
+
+          unless final_step
+            end_coord = next_node.coords_entering_to(node, VERSUS_INVERTER[versus], Contrek::Finder::Node::OUTER)
+            @sequence_coords << end_coord
+            bounds.expand(**end_coord)
+          end
+
           if node != start_node
             @inner_plot.contains(node) ? @inner_plot.delete(node) : @inner_plot << node
             if last_node.y == next_node.y
-              c = next_node.coords_entering_to(node, VERSUS_INVERTER[versus], Contrek::Finder::Node::OUTER)
-              @sequence_coords << c
-              bounds.expand(x: c[:x], y: c[:y])
               @inner_plot.contains(node) ? @inner_plot.delete(node) : @inner_plot << node
             end
           end
-        elsif strict_bounds
-          is_down = node.y > last_node.y
-          is_a = (versus == :a)
-          @sequence_coords << {y: node.y, x: ((is_down == is_a) ? last_node.min_x : last_node.max_x)}
-          @sequence_coords << {y: node.y, x: ((is_down == is_a) ? next_node.max_x : next_node.min_x)}
         end
         # exit if root_node
+        return if node == start_node && node.track_complete
 
-        if node == start_node
-          return if node.track_complete
-        end
-        plot_node(next_node, start_node, bounds, versus, strict_bounds)
+        plot_node(next_node, start_node, bounds, versus)
       end
 
       def add_node(node, offset)
@@ -295,15 +350,15 @@ module Contrek
             index = 0
             loop do
               up_node = up_nodes[index]
-              if (up_node.max_x + offset) >= node.min_x
-                if (up_node.min_x - offset) <= node.max_x
+              if ((up_node.max_x - 1) + offset) >= node.min_x
+                if (up_node.min_x - offset) <= (node.max_x - 1)
                   node.add_intersection(up_node, index)
                   up_node.add_intersection(node, node.abs_x_index)
                 end
                 return if (index += 1) == up_nodes_count
                 loop do
                   up_node = up_nodes[index]
-                  if (up_node.min_x - offset) <= node.max_x
+                  if (up_node.min_x - offset) <= (node.max_x - 1)
                     node.add_intersection(up_node, index)
                     up_node.add_intersection(node, node.abs_x_index)
                   else
@@ -316,7 +371,6 @@ module Contrek
               break if (index += 1) == up_nodes_count
             end
           end
-
         end
       end
     end

data/lib/contrek/finder/polygon_finder.rb

@@ -6,7 +6,7 @@ module Contrek
   module Finder
     class PolygonFinder
       def initialize(bitmap, matcher, test_bitmap = nil, options = {})
-        @options = {versus: :a, strict_bounds: false}.merge(options)
+        @options = {versus: :a}.merge(options)
         sanitize_options
         @source_bitmap = bitmap
         @matcher = matcher

data/lib/contrek/reducers/douglas_peucker_reducer.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module Contrek
+  module Reducers
+    class DouglasPeuckerReducer < Reducer
+      TOLERANCE_SQUARED = 1.0
+
+      def reduce!
+        count = @points.length
+        return @points if count < 4
+
+        first_index = extreme_index_by_x
+        second_index = farthest_index_from(first_index)
+
+        return @points if second_index == first_index
+
+        keep = Array.new(count, false)
+        keep[first_index] = true
+        keep[second_index] = true
+
+        simplify_arc!(first_index, second_index, keep)
+        simplify_arc!(second_index, first_index, keep)
+
+        compact_ring!(keep)
+      end
+
+      private
+
+      def extreme_index_by_x
+        points = @points
+        index = 0
+        best = 0
+        best_x = points[0][:x]
+
+        while (index += 1) < points.length
+          x = points[index][:x]
+
+          if x < best_x
+            best_x = x
+            best = index
+          end
+        end
+
+        best
+      end
+
+      def farthest_index_from(origin_index)
+        points = @points
+        origin = points[origin_index]
+
+        ox = origin[:x]
+        oy = origin[:y]
+
+        best_index = origin_index
+        best_distance = -1
+
+        index = 0
+
+        while index < points.length
+          dx = points[index][:x] - ox
+          dy = points[index][:y] - oy
+          distance = dx * dx + dy * dy
+
+          if distance > best_distance
+            best_distance = distance
+            best_index = index
+          end
+
+          index += 1
+        end
+
+        best_index
+      end
+
+      def simplify_arc!(first_index, last_index, keep)
+        count = @points.length
+        stack = [first_index, last_index]
+
+        until stack.empty?
+          last = stack.pop
+          first = stack.pop
+
+          split = farthest_on_arc(first, last, count)
+          next unless split
+
+          keep[split] = true
+
+          stack << first << split if next_index(first, count) != split
+          stack << split << last if next_index(split, count) != last
+        end
+      end
+
+      def farthest_on_arc(first_index, last_index, count)
+        points = @points
+
+        first = points[first_index]
+        last = points[last_index]
+
+        ax = first[:x]
+        ay = first[:y]
+        bx = last[:x]
+        by = last[:y]
+
+        abx = bx - ax
+        aby = by - ay
+        length_squared = abx * abx + aby * aby
+
+        max_distance = TOLERANCE_SQUARED
+        split_index = nil
+        index = next_index(first_index, count)
+
+        while index != last_index
+          point = points[index]
+
+          distance = if length_squared.zero?
+            dx = point[:x] - ax
+            dy = point[:y] - ay
+            dx * dx + dy * dy
+          else
+            point_segment_distance_squared(
+              point[:x],
+              point[:y],
+              ax,
+              ay,
+              bx,
+              by,
+              abx,
+              aby,
+              length_squared
+            )
+          end
+
+          if distance > max_distance
+            max_distance = distance
+            split_index = index
+          end
+
+          index = next_index(index, count)
+        end
+
+        split_index
+      end
+
+      def point_segment_distance_squared(
+        px, py,
+        ax, ay,
+        bx, by,
+        abx, aby,
+        length_squared
+      )
+        apx = px - ax
+        apy = py - ay
+
+        dot = apx * abx + apy * aby
+
+        if dot <= 0
+          apx * apx + apy * apy
+        elsif dot >= length_squared
+          bpx = px - bx
+          bpy = py - by
+          bpx * bpx + bpy * bpy
+        else
+          cross = apx * aby - apy * abx
+          (cross * cross).fdiv(length_squared)
+        end
+      end
+
+      def next_index(index, count)
+        (index + 1 == count) ? 0 : index + 1
+      end
+
+      def compact_ring!(keep)
+        points = @points
+        read_index = 0
+        write_index = 0
+
+        while read_index < points.length
+          if keep[read_index]
+            points[write_index] = points[read_index]
+            write_index += 1
+          end
+
+          read_index += 1
+        end
+
+        points.slice!(write_index, points.length - write_index)
+        points
+      end
+    end
+  end
+end

data/lib/contrek/reducers/raster_reducer.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Contrek
+  module Reducers
+    class RasterReducer < Reducer
+      def reduce!
+        versus = @opts[:versus]
+        to_raster_polygon!(@points, versus)
+      end
+
+      private
+
+      def to_raster_polygon!(points, versus)
+        n = points.size
+        return points if n.zero?
+
+        outer = versus == :o
+        first_x = points[0][:x]
+        first_y = points[0][:y]
+        prev_x = points[-1][:x]
+        prev_y = points[-1][:y]
+        points.each_index do |i|
+          curr_x = points[i][:x]
+          curr_y = points[i][:y]
+          if i + 1 < n
+            next_x = points[i + 1][:x]
+            next_y = points[i + 1][:y]
+          else
+            next_x = first_x
+            next_y = first_y
+          end
+          in_side = segment_pole(
+            curr_x - prev_x,
+            curr_y - prev_y,
+            outer
+          )
+          out_side = segment_pole(
+            next_x - curr_x,
+            next_y - curr_y,
+            outer
+          )
+          x = curr_x
+          y = curr_y
+          [in_side, out_side].uniq.each do |side|
+            case side
+            when :south then y -= 1
+            when :east then x -= 1
+            end
+          end
+          points[i][:x] = x
+          points[i][:y] = y
+          prev_x = curr_x
+          prev_y = curr_y
+        end
+        points
+      end
+
+      def segment_pole(dx, dy, clockwise)
+        sx = dx <=> 0
+        sy = dy <=> 0
+        case [sx, sy]
+        when [0, 1] then clockwise ? :east : :west
+        when [1, 0] then clockwise ? :north : :south
+        when [0, -1] then clockwise ? :west : :east
+        when [-1, 0] then clockwise ? :south : :north
+        else
+          raise ArgumentError, "Non-axial segment dx=#{dx} dy=#{dy}!"
+        end
+      end
+    end
+  end
+end

data/lib/contrek/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Contrek
-  VERSION = "1.3.3"
+  VERSION = "1.3.5"
 end

data/lib/contrek.rb

@@ -2,6 +2,7 @@
 
 require "contrek/version"
 require "contrek/bitmaps/painting"
+require "contrek/bitmaps/rendering"
 require "contrek/bitmaps/bitmap"
 require "contrek/bitmaps/chunky_bitmap"
 require "contrek/bitmaps/png_bitmap"
@@ -51,6 +52,8 @@ require "contrek/reducers/reducer"
 require "contrek/reducers/linear_reducer"
 require "contrek/reducers/uniq_reducer"
 require "contrek/reducers/visvalingam_reducer"
+require "contrek/reducers/douglas_peucker_reducer"
+require "contrek/reducers/raster_reducer"
 require "cpp_polygon_finder"
 require "contrek/cpp/cpp_concurrent_finder"
 require "contrek/cpp/cpp_concurrent_merger"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: contrek
 version: !ruby/object:Gem::Version
-  version: 1.3.3
+  version: 1.3.5
 platform: ruby
 authors:
 - Emanuele Cesaroni
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-06-28 00:00:00.000000000 Z
+date: 2026-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -78,6 +78,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.7.2
+- !ruby/object:Gem::Dependency
+  name: ruby2d
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
 - !ruby/object:Gem::Dependency
   name: chunky_png
   requirement: !ruby/object:Gem::Requirement
@@ -234,8 +248,12 @@ files:
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/matchers/RGBNotMatcher.h
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/matchers/ValueNotMatcher.cpp
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/matchers/ValueNotMatcher.h
+- ext/cpp_polygon_finder/PolygonFinder/src/polygon/reducers/DouglasPeuckerReducer.cpp
+- ext/cpp_polygon_finder/PolygonFinder/src/polygon/reducers/DouglasPeuckerReducer.h
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/reducers/LinearReducer.cpp
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/reducers/LinearReducer.h
+- ext/cpp_polygon_finder/PolygonFinder/src/polygon/reducers/RasterReducer.cpp
+- ext/cpp_polygon_finder/PolygonFinder/src/polygon/reducers/RasterReducer.h
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/reducers/Reducer.cpp
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/reducers/Reducer.h
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/reducers/UniqReducer.cpp
@@ -251,6 +269,7 @@ files:
 - lib/contrek/bitmaps/painting.rb
 - lib/contrek/bitmaps/png_bitmap.rb
 - lib/contrek/bitmaps/raw_bitmap.rb
+- lib/contrek/bitmaps/rendering.rb
 - lib/contrek/bitmaps/rgb_color.rb
 - lib/contrek/bitmaps/rgb_cpp_color.rb
 - lib/contrek/bitmaps/sample_generator.rb
@@ -299,7 +318,9 @@ files:
 - lib/contrek/matchers/matcher.rb
 - lib/contrek/matchers/matcher_hsb.rb
 - lib/contrek/matchers/value_not_matcher.rb
+- lib/contrek/reducers/douglas_peucker_reducer.rb
 - lib/contrek/reducers/linear_reducer.rb
+- lib/contrek/reducers/raster_reducer.rb
 - lib/contrek/reducers/reducer.rb
 - lib/contrek/reducers/uniq_reducer.rb
 - lib/contrek/reducers/visvalingam_reducer.rb