contrek 1.3.3 → 1.3.5

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/reducers/DouglasPeuckerReducer.cpp

@@ -0,0 +1,177 @@
+/*
+ * DouglasPeuckerReducer.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 "DouglasPeuckerReducer.h"
+#include <cstdint>
+#include <limits>
+#include <vector>
+
+DouglasPeuckerReducer::DouglasPeuckerReducer(std::vector<Point>& list_of_points)
+  : Reducer(list_of_points) {
+}
+
+void DouglasPeuckerReducer::reduce() {
+  const std::size_t count = points.size();
+  if (count < 4) {
+    return;
+  }
+  const std::size_t first_index = extremeIndexByX();
+  const std::size_t second_index = farthestIndexFrom(first_index);
+  if (second_index == first_index) {
+    return;
+  }
+  std::vector<bool> keep(count, false);
+  keep[first_index] = true;
+  keep[second_index] = true;
+  simplifyArc(first_index, second_index, keep);
+  simplifyArc(second_index, first_index, keep);
+  compactRing(keep);
+}
+
+std::size_t DouglasPeuckerReducer::extremeIndexByX() const {
+  std::size_t best = 0;
+  int best_x = points[0].x;
+  for (std::size_t index = 1; index < points.size(); ++index) {
+    const int x = points[index].x;
+    if (x < best_x) {
+      best_x = x;
+      best = index;
+    }
+  }
+  return best;
+}
+
+std::size_t DouglasPeuckerReducer::farthestIndexFrom(std::size_t origin_index) const {
+  const Point& origin = points[origin_index];
+  std::size_t best_index = origin_index;
+  std::int64_t best_distance = -1;
+  for (std::size_t index = 0; index < points.size(); ++index) {
+    const std::int64_t dx = static_cast<std::int64_t>(points[index].x) - origin.x;
+    const std::int64_t dy = static_cast<std::int64_t>(points[index].y) - origin.y;
+    const std::int64_t distance = dx * dx + dy * dy;
+    if (distance > best_distance) {
+      best_distance = distance;
+      best_index = index;
+    }
+  }
+  return best_index;
+}
+
+void DouglasPeuckerReducer::simplifyArc(std::size_t first_index, std::size_t last_index, std::vector<bool>& keep) const {
+  const std::size_t count = points.size();
+  std::vector<Arc> stack;
+  stack.push_back({first_index, last_index});
+  while (!stack.empty()) {
+    const Arc arc = stack.back();
+    stack.pop_back();
+    std::size_t split_index = 0;
+    if (!farthestOnArc(
+          arc.first,
+          arc.last,
+          count,
+          split_index)) {
+      continue;
+    }
+    keep[split_index] = true;
+    if (nextIndex(arc.first, count) != split_index) {
+      stack.push_back({arc.first, split_index});
+    }
+    if (nextIndex(split_index, count) != arc.last) {
+      stack.push_back({split_index, arc.last});
+    }
+  }
+}
+
+bool DouglasPeuckerReducer::farthestOnArc(std::size_t first_index, std::size_t last_index,
+                                          std::size_t count, std::size_t& split_index) const {
+  const Point& first = points[first_index];
+  const Point& last = points[last_index];
+  const double ax = static_cast<double>(first.x);
+  const double ay = static_cast<double>(first.y);
+  const double bx = static_cast<double>(last.x);
+  const double by = static_cast<double>(last.y);
+  const double abx = bx - ax;
+  const double aby = by - ay;
+  const double length_squared = abx * abx + aby * aby;
+  double max_distance = TOLERANCE_SQUARED;
+  bool found = false;
+  std::size_t index = nextIndex(first_index, count);
+
+  while (index != last_index) {
+    const Point& point = points[index];
+    double distance;
+    if (length_squared == 0.0) {
+      const double dx = static_cast<double>(point.x) - ax;
+      const double dy = static_cast<double>(point.y) - ay;
+      distance = dx * dx + dy * dy;
+    } else {
+      distance = pointSegmentDistanceSquared(
+        static_cast<double>(point.x),
+        static_cast<double>(point.y),
+        ax,
+        ay,
+        bx,
+        by,
+        abx,
+        aby,
+        length_squared);
+    }
+    if (distance > max_distance) {
+      max_distance = distance;
+      split_index = index;
+      found = true;
+    }
+    index = nextIndex(index, count);
+  }
+  return found;
+}
+
+double DouglasPeuckerReducer::pointSegmentDistanceSquared(
+  double px,
+  double py,
+  double ax,
+  double ay,
+  double bx,
+  double by,
+  double abx,
+  double aby,
+  double length_squared) {
+  const double apx = px - ax;
+  const double apy = py - ay;
+  const double dot = apx * abx + apy * aby;
+  if (dot <= 0.0) {
+    return apx * apx + apy * apy;
+  }
+  if (dot >= length_squared) {
+    const double bpx = px - bx;
+    const double bpy = py - by;
+    return bpx * bpx + bpy * bpy;
+  }
+  const double cross = apx * aby - apy * abx;
+  return (cross * cross) / length_squared;
+}
+
+std::size_t DouglasPeuckerReducer::nextIndex(std::size_t index, std::size_t count) {
+  return index + 1 == count ? 0 : index + 1;
+}
+
+void DouglasPeuckerReducer::compactRing(const std::vector<bool>& keep) {
+  std::size_t write_index = 0;
+  for (
+    std::size_t read_index = 0;
+    read_index < points.size();
+    ++read_index
+  ) {
+    if (keep[read_index]) {
+      points[write_index] = points[read_index];
+      ++write_index;
+    }
+  }
+  points.resize(write_index);
+}

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/reducers/DouglasPeuckerReducer.h

@@ -0,0 +1,52 @@
+/*
+ * DouglasPeuckerReducer.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 <cstddef>
+#include <vector>
+#include "Reducer.h"
+
+struct Point;
+
+class DouglasPeuckerReducer : public Reducer {
+ public:
+  explicit DouglasPeuckerReducer(std::vector<Point>& list_of_points);
+  void reduce() override;
+
+ private:
+  static constexpr double TOLERANCE_SQUARED = 1.0;
+  struct Arc {
+    std::size_t first;
+    std::size_t last;
+  };
+  std::size_t extremeIndexByX() const;
+  std::size_t farthestIndexFrom(
+    std::size_t origin_index) const;
+  void simplifyArc(
+    std::size_t first_index,
+    std::size_t last_index,
+    std::vector<bool>& keep) const;
+  bool farthestOnArc(
+    std::size_t first_index,
+    std::size_t last_index,
+    std::size_t count,
+    std::size_t& split_index) const;
+  static double pointSegmentDistanceSquared(
+    double px,
+    double py,
+    double ax,
+    double ay,
+    double bx,
+    double by,
+    double abx,
+    double aby,
+    double length_squared);
+  static std::size_t nextIndex(std::size_t index, std::size_t count);
+  void compactRing(const std::vector<bool>& keep);
+};

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/reducers/RasterReducer.cpp

@@ -0,0 +1,109 @@
+/*
+ * RasterReducer.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 "RasterReducer.h"
+#include <stdexcept>
+#include <string>
+
+RasterReducer::RasterReducer(std::vector<Point>& points, int versus)
+  : Reducer(points),
+    versus_(versus) {
+}
+
+void RasterReducer::reduce() {
+  toRasterPolygon(points, versus_);
+}
+
+void RasterReducer::toRasterPolygon(std::vector<Point>& points, int versus) {
+  const std::size_t n = points.size();
+
+  if (n == 0) {
+      return;
+  }
+
+  const bool outer = versus == Node::O;
+  const int firstX = points.front().x;
+  const int firstY = points.front().y;
+  int previousX = points.back().x;
+  int previousY = points.back().y;
+
+  for (std::size_t i = 0; i < n; ++i) {
+    const int currentX = points[i].x;
+    const int currentY = points[i].y;
+    int nextX;
+    int nextY;
+    if (i + 1 < n) {
+      nextX = points[i + 1].x;
+      nextY = points[i + 1].y;
+    } else {
+      nextX = firstX;
+      nextY = firstY;
+    }
+    const Pole incomingSide = segmentPole(
+      currentX - previousX,
+      currentY - previousY,
+      outer);
+    const Pole outgoingSide = segmentPole(
+      nextX - currentX,
+      nextY - currentY,
+      outer);
+    int x = currentX;
+    int y = currentY;
+    const auto applySide = [&x, &y](Pole side) {
+      switch (side) {
+        case Pole::South:
+          --y;
+          break;
+
+        case Pole::East:
+          --x;
+          break;
+
+        case Pole::North:
+        case Pole::West:
+          break;
+      }
+    };
+    applySide(incomingSide);
+    if (outgoingSide != incomingSide) {
+      applySide(outgoingSide);
+    }
+    points[i].x = x;
+    points[i].y = y;
+    previousX = currentX;
+    previousY = currentY;
+  }
+}
+
+RasterReducer::Pole RasterReducer::segmentPole(int dx, int dy, bool clockwise) {
+  const int sx = sign(dx);
+  const int sy = sign(dy);
+  if (sx == 0 && sy == 1) {
+    return clockwise ? Pole::East : Pole::West;
+  }
+  if (sx == 1 && sy == 0) {
+    return clockwise ? Pole::North : Pole::South;
+  }
+  if (sx == 0 && sy == -1) {
+    return clockwise ? Pole::West : Pole::East;
+  }
+  if (sx == -1 && sy == 0) {
+    return clockwise ? Pole::South : Pole::North;
+  }
+  throw std::invalid_argument(
+    "Non-axial segment dx=" +
+    std::to_string(dx) +
+    " dy=" +
+    std::to_string(dy) +
+    "!");
+}
+
+int RasterReducer::sign(int value) {
+  return (value > 0) - (value < 0);
+}

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/reducers/RasterReducer.h

@@ -0,0 +1,32 @@
+/*
+ * RasterReducer.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 "Reducer.h"
+
+struct Point;
+
+class RasterReducer : public Reducer {
+ public:
+  RasterReducer(std::vector<Point>& points, int versus);
+  void reduce() override;
+
+ private:
+  enum class Pole {
+    North,
+    South,
+    East,
+    West
+  };
+  int versus_;
+  void toRasterPolygon(std::vector<Point>& points, int versus);
+  static Pole segmentPole(int dx, int dy, bool clockwise);
+  static int sign(int value);
+};

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/reducers/VisvalingamReducer.h

@@ -25,7 +25,12 @@ class VisvalingamReducer : public Reducer {
   class Triangle {
    public:
     static int area(const Point& a, const Point& b, const Point& c) {
-      return std::abs(((c.x - a.x) * (b.y - a.y) - (b.x - a.x) * (c.y - a.y)) / 2);
+      const int cross = (c.x - a.x) * (b.y - a.y) - (b.x - a.x) * (c.y - a.y);
+      int half = cross / 2;
+      if (cross < 0 && cross % 2 != 0) {
+        --half;
+      }
+      return std::abs(half);
     }
   };
 

data/ext/cpp_polygon_finder/cpp_polygon_finder.cpp

@@ -52,6 +52,10 @@
 #include "PolygonFinder/src/polygon/reducers/LinearReducer.h"
 #include "PolygonFinder/src/polygon/reducers/VisvalingamReducer.cpp"
 #include "PolygonFinder/src/polygon/reducers/VisvalingamReducer.h"
+#include "PolygonFinder/src/polygon/reducers/RasterReducer.cpp"
+#include "PolygonFinder/src/polygon/reducers/RasterReducer.h"
+#include "PolygonFinder/src/polygon/reducers/DouglasPeuckerReducer.cpp"
+#include "PolygonFinder/src/polygon/reducers/DouglasPeuckerReducer.h"
 #include "PolygonFinder/src/polygon/finder/concurrent/Finder.h"
 #include "PolygonFinder/src/polygon/finder/concurrent/Finder.cpp"
 #include "PolygonFinder/src/polygon/finder/concurrent/Poolable.h"

data/lib/contrek/bitmaps/painting.rb

@@ -21,23 +21,40 @@ module Contrek
         colors.sort_by { |color, count| -color }
       end
 
-      def self.direct_draw_polygons(polygons, png_image)
+      def self.direct_draw_polygons(polygons, png_image, zoom: 1)
         polygons.compact.each do |poly|
-          color = ChunkyPNG::Color("red @ 1.0")
-          poly[:outer].each_cons(2) do |coords|
-            png_image.draw_line(coords[0][:x], coords[0][:y], coords[1][:x], coords[1][:y], color)
+          if (bounds = poly[:bounds])
+            b_factor = 3.to_f / zoom
+            bounds_polygon = [
+              {x: bounds[:min_x] - b_factor, y: bounds[:min_y] - b_factor},
+              {x: bounds[:max_x] + b_factor, y: bounds[:min_y] - b_factor},
+              {x: (bounds[:max_x] + b_factor), y: bounds[:max_y] + b_factor},
+              {x: (bounds[:min_x] - b_factor), y: bounds[:max_y] + b_factor}
+            ]
+            draw_polygon(bounds_polygon, png_image, ChunkyPNG::Color("blue @ 1.0"), zoom)
           end
-          png_image.draw_line(poly[:outer][0][:x], poly[:outer][0][:y], poly[:outer][-1][:x], poly[:outer][-1][:y], color)
+          color = ChunkyPNG::Color("red @ 1.0")
+          draw_polygon(poly[:outer], png_image, color, zoom)
           color = ChunkyPNG::Color("green @ 1.0")
           poly[:inner].each do |sequence|
-            next if sequence.empty?
-            sequence.each_cons(2) do |coords|
-              png_image.draw_line(coords[0][:x], coords[0][:y], coords[1][:x], coords[1][:y], color)
-            end
-            png_image.draw_line(sequence[0][:x], sequence[0][:y], sequence[-1][:x], sequence[-1][:y], color)
+            draw_polygon(sequence, png_image, color, zoom)
           end
         end
       end
+
+      def self.draw_polygon(sequence, png_image, color, zoom, margin = 0)
+        return if sequence.empty?
+        sequence.each_cons(2) do |coords|
+          png_image.draw_line(coords[0][:x] * zoom,
+            coords[0][:y] * zoom,
+            coords[1][:x] * zoom,
+            coords[1][:y] * zoom, color)
+        end
+        png_image.draw_line(sequence[0][:x] * zoom,
+          sequence[0][:y] * zoom,
+          sequence[-1][:x] * zoom,
+          sequence[-1][:y] * zoom, color)
+      end
     end
   end
 end

data/lib/contrek/bitmaps/png_bitmap.rb

@@ -5,6 +5,9 @@ require "chunky_png"
 module Contrek
   module Bitmaps
     class PngBitmap < Bitmap
+      include Rendering
+
+      attr_reader :image
       def initialize(file_path)
         @image = ChunkyPNG::Image.from_file(file_path)
       end

data/lib/contrek/bitmaps/rendering.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Contrek
+  module Bitmaps
+    module Rendering
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def to_window(result, zoom: 100, coords: true, window_w: 2000, window_h: 1200, font_h: 20)
+          require "ruby2d"
+          ubuntu_purple = ChunkyPNG::Color.from_hex("#77216F")
+          bm = RawBitmap.new(w: window_w, h: window_h, color: ubuntu_purple)
+          # grid
+          light_purple = ChunkyPNG::Color.from_hex("#95338B")
+          (window_w / zoom).times { |x| bm.draw_line(x * zoom, 0, x * zoom, window_h, light_purple) }
+          (window_h / zoom).times { |y| bm.draw_line(0, y * zoom, window_w, y * zoom, light_purple) }
+          # polygons
+          Painting.direct_draw_polygons(result.points, bm, zoom: zoom)
+          # windowing
+          Tempfile.create do |temp_file|
+            bm.image.save(temp_file.path, color_mode: ChunkyPNG::COLOR_TRUECOLOR_ALPHA)
+            Window.clear
+            Window.set(
+              title: "Rendering #{result[:metadata][:groups]} polygons",
+              width: window_w,
+              height: window_h,
+              resizable: true
+            )
+            Image.new(
+              temp_file.path,
+              x: 0, y: 0,
+              width: window_w,
+              height: window_h
+            )
+            draw_labels(result.points, zoom: zoom, draw_coords: coords, font_h:)
+            Window.on :key_down do |event|
+              if event.key == "escape"
+                Window.close
+              end
+              if event.key == "s"
+                Window.screenshot("window_content.png")
+              end
+            end
+            Window.show
+          end
+        end
+
+        private
+
+        def draw_labels(polygons, font_h:, zoom: 1.0, draw_coords: true)
+          positions = []
+          polygons.compact.each do |poly|
+            ([poly[:outer]] + poly[:inner]).each do |seq|
+              seq.each_with_index do |coords, n|
+                x = coords[:x] * zoom
+                y = coords[:y] * zoom
+                y += font_h + 2 if positions.index([x, y])
+                t = (n + 1).to_s
+                t += " - [#{coords[:x]},#{coords[:y]}]" if draw_coords
+                draw_text(x, y, t, font_h) unless draw_coords.nil?
+                positions << [x, y]
+              end
+            end
+          end
+        end
+
+        def draw_text(x, y, text, font_h)
+          Text.new(text, x:, y:, size: font_h, color: "white", z: 10)
+        end
+      end
+    end
+  end
+end