contrek 1.0.0

data/ext/cpp_polygon_finder/cpp_polygon_finder.cpp

@@ -0,0 +1,260 @@
+/*
+ * cpp_polygon_finder.cpp
+ *
+ *  Created on: 25 apr 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+// https://github.com/mapnik/Ruby-Mapnik/blob/master/ext/ruby_mapnik/_mapnik_map.rb.cpp
+
+#include <iostream>
+#include <list>
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+#include <vector>
+#include <map>
+#include <string>
+
+#include "PolygonFinder/src/polygon/finder/PolygonFinder.h"
+#include "PolygonFinder/src/polygon/finder/PolygonFinder.cpp"
+#include "PolygonFinder/src/polygon/finder/NodeCluster.cpp"
+#include "PolygonFinder/src/polygon/finder/NodeCluster.h"
+#include "PolygonFinder/src/polygon/finder/Node.cpp"
+#include "PolygonFinder/src/polygon/finder/Node.h"
+#include "PolygonFinder/src/polygon/finder/List.cpp"
+#include "PolygonFinder/src/polygon/finder/List.h"
+#include "PolygonFinder/src/polygon/finder/Lists.cpp"
+#include "PolygonFinder/src/polygon/finder/Lists.h"
+#include "PolygonFinder/src/polygon/bitmaps/Bitmap.h"
+#include "PolygonFinder/src/polygon/bitmaps/Bitmap.cpp"
+#include "PolygonFinder/src/polygon/bitmaps/PngBitmap.h"
+#include "PolygonFinder/src/polygon/bitmaps/PngBitmap.cpp"
+#include "PolygonFinder/src/polygon/bitmaps/FastPngBitmap.h"
+#include "PolygonFinder/src/polygon/bitmaps/FastPngBitmap.cpp"
+#include "PolygonFinder/src/polygon/bitmaps/RemoteFastPngBitmap.h"
+#include "PolygonFinder/src/polygon/bitmaps/RemoteFastPngBitmap.cpp"
+#include "PolygonFinder/src/polygon/matchers/Matcher.h"
+#include "PolygonFinder/src/polygon/matchers/Matcher.cpp"
+#include "PolygonFinder/src/polygon/matchers/ValueNotMatcher.h"
+#include "PolygonFinder/src/polygon/matchers/ValueNotMatcher.cpp"
+#include "PolygonFinder/src/polygon/matchers/RGBMatcher.h"
+#include "PolygonFinder/src/polygon/matchers/RGBMatcher.cpp"
+#include "PolygonFinder/src/polygon/matchers/RGBNotMatcher.h"
+#include "PolygonFinder/src/polygon/matchers/RGBNotMatcher.cpp"
+#include "PolygonFinder/src/polygon/reducers/Reducer.cpp"
+#include "PolygonFinder/src/polygon/reducers/Reducer.h"
+#include "PolygonFinder/src/polygon/reducers/UniqReducer.cpp"
+#include "PolygonFinder/src/polygon/reducers/UniqReducer.h"
+#include "PolygonFinder/src/polygon/reducers/LinearReducer.cpp"
+#include "PolygonFinder/src/polygon/reducers/LinearReducer.h"
+#include "PolygonFinder/src/polygon/reducers/VisvalingamReducer.cpp"
+#include "PolygonFinder/src/polygon/reducers/VisvalingamReducer.h"
+#include "png++/png.hpp"
+
+using namespace Rice;
+
+namespace Rice::detail
+{ template<>
+  class To_Ruby<std::list<Point*> >
+  { public:
+      VALUE convert(std::list<Point*> const & x)
+      { return Rice::Array(x.begin(), x.end());
+      }
+  };
+
+  template<>
+  class To_Ruby<std::list<std::list<Point*>>>
+  { public:
+      VALUE convert(std::list<std::list<Point*>> const & x)
+      { return Rice::Array(x.begin(), x.end());
+      }
+  };
+
+  template<>
+  class To_Ruby<std::list<Point*>*>
+  { public:
+      VALUE convert(std::list<Point*>* const & x)
+      { return Rice::Array(x->begin(), x->end());
+      }
+  };
+
+  template<>
+  class To_Ruby<std::list<std::list<Point*>*>>
+  { public:
+      VALUE convert(std::list<std::list<Point*>*> const & x)
+      { return Rice::Array(x.begin(), x.end());
+      }
+  };
+
+  template<>
+  class To_Ruby<Point*>
+  { public:
+      VALUE convert(Point* const & x)
+      {  Rice::Hash h = Rice::Hash();
+         h[Symbol("x")] = x->x;
+         h[Symbol("y")] = x->y;
+         return(h);
+      }
+  };
+
+  template<>
+  class To_Ruby<std::map<std::string, double>*>
+  { public:
+      VALUE convert(std::map<std::string, double>* const & x)
+      { Rice::Hash return_me = Rice::Hash();
+        std::map<std::string, double>::iterator it;
+        for ( it = x->begin(); it != x->end(); it++ )
+        {  return_me[String(it->first)] = it->second;
+        }
+        return return_me;
+      }
+  };
+
+  template<>
+  class From_Ruby<std::vector<std::string>*>
+  { public:
+    Convertible is_convertible(VALUE value)
+    { switch (rb_type(value))
+      { case RUBY_T_HASH:
+          return Convertible::Cast;
+          break;
+        default:
+          return Convertible::None;
+      }
+    }
+    std::vector<std::string>* convert(VALUE value)
+    { std::vector<std::string> *arguments = new std::vector<std::string>();
+      if (rb_type(value) == RUBY_T_NIL) return(arguments);
+      Rice::Hash hash = (Rice::Hash) value;
+      for (Rice::Hash::iterator it = hash.begin(); it != hash.end(); ++it) {
+        Rice::String keyString = it->key.to_s();
+        Rice::Object value = it->value;
+        switch (value.rb_type()) {
+          case T_STRING:
+            arguments->push_back("--" + keyString.str()+"="+((Rice::String) value).str());
+            break;
+          case T_SYMBOL:
+            arguments->push_back("--" + keyString.str()+"="+((Rice::Symbol) value).str());
+            break;
+          case T_FLOAT:
+            arguments->push_back("--" + keyString.str()+"="+std::to_string(NUM2DBL(value.value())));
+            break;
+          case T_FIXNUM:
+            arguments->push_back("--" + keyString.str()+"="+std::to_string(NUM2INT(value.value())));
+            break;
+          case T_TRUE:
+            arguments->push_back("--" + keyString.str()+"=true");
+            break;
+          case T_FALSE:
+            arguments->push_back("--" + keyString.str()+"=false");
+            break;
+          case T_HASH:
+            std::vector<std::string>* iv = From_Ruby<std::vector<std::string>*>::convert(value);
+            for (std::vector<std::string>::iterator it_iv = iv->begin() ; it_iv != iv->end(); ++it_iv)
+            { (*it_iv).replace(0, 2, "_");
+              arguments->push_back("--" + keyString.str() + *it_iv);
+            }
+            break;
+         }
+      }
+      return arguments;
+    }
+  };
+
+  template<>
+  struct Type<ProcessResult>
+  { static bool verify()
+    { return true;
+    }
+  };
+
+  template<>
+  class To_Ruby<ProcessResult*>
+  { public:
+    VALUE convert(ProcessResult* const & pr)
+    { Rice::Hash return_me = Rice::Hash();
+      return_me[Symbol("benchmarks")] = &pr->benchmarks;
+      return_me[Symbol("groups")] = pr->groups;
+      return_me[Symbol("named_sequence")] = pr->named_sequence;
+      Rice::Array out;
+      for (std::list<std::map<std::string, std::list<std::list<Point*>*>>>::iterator x = pr->polygons.begin(); x != pr->polygons.end(); ++x)
+      { Rice::Hash h = Rice::Hash();
+        h[Symbol("outer")] = (*x)["outer"].front();
+        h[Symbol("inner")] = (*x)["inner"];
+        out.push(h);
+      }
+      return_me[Symbol("polygons")] = out;
+      Rice::Array tmapout;
+      for (std::list<int*>::iterator tm = pr->treemap.begin(); tm != pr->treemap.end(); ++tm)
+      { Rice::Array tmentry;
+        tmentry.push((*tm)[0]);
+        tmentry.push((*tm)[1]);
+        tmapout.push(tmentry);
+      }
+      return_me[Symbol("treemap")] = tmapout;
+      return(return_me);
+    }
+  };
+}  // namespace Rice::detail
+
+extern "C"
+void Init_cpp_polygon_finder() {
+  Data_Type<Bitmap> rb_cBitmap =
+    define_class<Bitmap>("CPPBitMap")
+    .define_constructor(Constructor<Bitmap, std::string, int>())
+    .define_method("value_set", &Bitmap::value_set)
+    .define_method("value_at", &Bitmap::value_at)
+    .define_method("w", &Bitmap::w)
+    .define_method("h", &Bitmap::h)
+    .define_method("error", &Bitmap::error)
+    .define_method("clear", &Bitmap::clear)
+    .define_method("print", &Bitmap::print);
+
+  Data_Type<RemoteFastPngBitmap> rb_cRemotePngBitmap =
+    define_class<RemoteFastPngBitmap, Bitmap>("CPPRemotePngBitMap")
+    .define_constructor(Constructor<RemoteFastPngBitmap, std::string*>(), Arg("url"))
+    .define_method("value_set", &FastPngBitmap::value_set)
+    .define_method("value_at", &FastPngBitmap::value_at)
+    .define_method("rgb_value_at", &FastPngBitmap::rgb_value_at)
+    .define_method("w", &FastPngBitmap::w)
+    .define_method("h", &FastPngBitmap::h)
+    .define_method("error", &FastPngBitmap::error)
+    .define_method("print", &FastPngBitmap::print);
+
+  Data_Type<FastPngBitmap> rb_cPngBitmap =
+    define_class<FastPngBitmap, Bitmap>("CPPPngBitMap")
+    .define_constructor(Constructor<FastPngBitmap, std::string>(), Arg("filename"))
+    .define_method("value_set", &FastPngBitmap::value_set)
+    .define_method("value_at", &FastPngBitmap::value_at)
+    .define_method("rgb_value_at", &FastPngBitmap::rgb_value_at)
+    .define_method("w", &FastPngBitmap::w)
+    .define_method("h", &FastPngBitmap::h)
+    .define_method("error", &FastPngBitmap::error)
+    .define_method("print", &FastPngBitmap::print);
+
+  Data_Type<Matcher> rb_cMatcher =
+    define_class<Matcher>("CPPMatcher")
+    .define_constructor(Constructor<Matcher, char>())
+    .define_method("match", &Matcher::match);
+
+  Data_Type<ValueNotMatcher> rb_cValueNotMatcher =
+    define_class<ValueNotMatcher, Matcher>("CPPValueNotMatcher")
+    .define_constructor(Constructor<ValueNotMatcher, char>())
+    .define_method("match", &ValueNotMatcher::match);
+
+  Data_Type<RGBMatcher> rb_cRGBMatcher =
+    define_class<RGBMatcher, Matcher>("CPPRGBMatcher")
+    .define_constructor(Constructor<RGBMatcher, unsigned int>())
+    .define_method("match", &RGBMatcher::match);
+
+  Data_Type<RGBNotMatcher> rb_cRGBNotMatcher =
+    define_class<RGBNotMatcher, Matcher>("CPPRGBNotMatcher")
+    .define_constructor(Constructor<RGBNotMatcher, int>())
+    .define_method("match", &RGBNotMatcher::match);
+
+  Data_Type<PolygonFinder> rb_cPolygonFinder =
+    define_class<PolygonFinder>("CPPPolygonFinder")
+    .define_constructor(Constructor<PolygonFinder, Bitmap*, Matcher*, Bitmap*, std::vector<std::string>*>(), Arg("bitmap"), Arg("matcher"), Arg("test_bitmap") = nullptr, Arg("options") = nullptr)
+    .define_method("get_shapelines", &PolygonFinder::get_shapelines)
+    .define_method("process_info", &PolygonFinder::process_info);
+}

data/ext/cpp_polygon_finder/extconf.rb

@@ -0,0 +1,2 @@
+require "mkmf-rice"
+create_makefile "cpp_polygon_finder"

data/lib/contrek/bitmaps/bitmap.rb

@@ -0,0 +1,21 @@
+module Contrek
+  module Bitmaps
+    class Bitmap
+      include Painting
+
+      def scan
+        x = 0
+        y = 0
+        loop do
+          yield x, y, value_at(x, y)
+          x += 1
+          if x == w
+            x = 0
+            y += 1
+            break if y == h
+          end
+        end
+      end
+    end
+  end
+end

data/lib/contrek/bitmaps/chunky_bitmap.rb

@@ -0,0 +1,33 @@
+module Contrek
+  module Bitmaps
+    class ChunkyBitmap < Bitmap
+      def initialize(data, mod)
+        @raw = data.dup
+        @module = mod
+      end
+
+      def clear(val = "0")
+        @raw = val * @module * h
+      end
+
+      def w
+        @module
+      end
+
+      def h
+        @raw.size / @module
+      end
+
+      def value_at(x, y)
+        @raw[y * @module + x]
+      end
+
+      def value_set(x, y, value)
+        return if y >= h
+        return if x >= w
+
+        @raw[y * @module + x] = value
+      end
+    end
+  end
+end

data/lib/contrek/bitmaps/painting.rb

@@ -0,0 +1,40 @@
+module Contrek
+  module Bitmaps
+    module Painting
+      def draw_line(start_x, start_y, end_x, end_y, value)
+        raise NoMethodError
+      end
+
+      def bitmap_colors(step: 1, max: 0)
+        colors = {}
+        step = 1 if step <= 0
+        0.step(h - 1, step) do |h|
+          0.step(w - 1, step) do |w|
+            color = value_at(w, h)
+            colors[color] ||= 0
+            colors[color] += 1
+            break if colors.size == max
+          end
+        end
+        colors.sort_by { |color, count| -color }
+      end
+
+      def self.direct_draw_polygons(polygons, png_image)
+        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)
+          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("green @ 1.0")
+          poly[:inner].each do |sequence|
+            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)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/contrek/bitmaps/png_bitmap.rb

@@ -0,0 +1,62 @@
+require "chunky_png"
+
+module Contrek
+  module Bitmaps
+    class PngBitmap < Bitmap
+      def initialize(file_path)
+        @image = ChunkyPNG::Image.from_file(file_path)
+      end
+
+      def w
+        @image.dimension.width
+      end
+
+      def h
+        @image.dimension.height
+      end
+
+      def draw_line(start_x, start_y, end_x, end_y, value)
+        @image.line_xiaolin_wu(start_x, start_y, end_x, end_y, value)
+      end
+
+      def value_at(x, y)
+        @image[x, y]
+      end
+
+      def rgb_value_at(x, y)
+        value_at(x, y)
+      end
+
+      def hsv_at(x, y)
+        @image.get_pixel(x, y).to_hsv
+      end
+
+      def value_set(x, y, value)
+        @image[x, y] = value
+      end
+
+      def save(filename)
+        @image.save(filename, interlace: true, compression: Zlib::NO_COMPRESSION)
+      end
+
+      def to_tmp_file
+        tmp_png_file = Tempfile.new
+        tmp_png_file.binmode
+        tmp_png_file.write(@image.to_blob)
+        tmp_png_file
+      end
+
+      def resize_h(new_h)
+        old_w = w
+        old_h = h
+
+        new_w = (old_w * new_h) / old_h
+        @image = @image.resize(new_w, new_h)
+      end
+
+      def inspect
+        "PngBitMap"
+      end
+    end
+  end
+end

data/lib/contrek/bitmaps/rgb_color.rb

@@ -0,0 +1,25 @@
+module Contrek
+  module Bitmaps
+    class RgbColor
+      attr_reader :raw
+      def initialize(r:, g:, b:, a: 255)
+        @r = r
+        @g = g
+        @b = b
+        @a = a
+        @raw = (r << 24) + (g << 16) + (b << 8) + a
+      end
+
+      def to_rgb_raw
+        @raw >> 8
+      end
+
+      def self.reverse_raw(raw)
+        [:a, :b, :g, :r].each_with_object({}) do |c, h|
+          h[c] = raw & 0xFF
+          raw >>= 8
+        end
+      end
+    end
+  end
+end

data/lib/contrek/finder/list.rb

@@ -0,0 +1,132 @@
+module Contrek
+  module Finder
+    class List
+      attr_reader :start, :end, :size, :idd
+      def initialize(id)
+        @start = nil
+        @end = nil
+        @size = 0
+        @idd = id
+      end
+
+      def first
+        @start
+      end
+
+      def find
+        each { |e| return e if yield(e) }
+        nil
+      end
+
+      def contains(entry)
+        entry.data_pointer[@idd].inside
+      end
+
+      def grab(source_list)
+        return if source_list.size == 0
+
+        source_list_idd = source_list.idd
+        source_list_start_entry = source_list.start
+
+        act = source_list.end
+        loop do
+          break if (act = act.data_pointer[source_list_idd].prev).nil?
+        end
+
+        source_entry = source_list.start
+        loop do
+          source_entry.data_pointer[@idd] = source_entry.data_pointer[source_list_idd]
+          next_entry = source_entry.data_pointer[source_list_idd].next
+          source_entry.data_pointer[source_list_idd] = Contrek::Finder::Lists::Link.new(nil, nil, false)
+          break if next_entry.nil?
+          source_entry = next_entry
+        end
+
+        source_list_start_entry.data_pointer[@idd].prev = @end
+        @end.data_pointer[@idd].next = source_list_start_entry unless @end.nil?
+
+        @end = source_list.end
+        @start = source_list.start if @start.nil?
+        @size += source_list.size
+
+        source_list.reset
+      end
+
+      def reset
+        @end = nil
+        @start = nil
+        @size = 0
+      end
+
+      def <<(entry)
+        return if entry.data_pointer[@idd].inside == true
+
+        if @size > 0
+          @end.data_pointer[@idd].next = entry
+          entry.data_pointer[@idd].prev = @end
+        else
+          @start = entry
+        end
+        @end = entry
+        entry.data_pointer[@idd].inside = true
+        @size += 1
+      end
+
+      def shift
+        return nil if @size == 0
+        retme = @start
+        next_of_retme = retme.data_pointer[@idd].next
+        @start = next_of_retme
+
+        @end = nil if retme == @end
+
+        next_of_retme.data_pointer[@idd].prev = nil unless next_of_retme.nil?
+        @size -= 1
+
+        retme.data_pointer[@idd].next = nil
+        retme.data_pointer[@idd].prev = nil
+        retme.data_pointer[@idd].inside = false
+        retme
+      end
+
+      def each
+        return if @size == 0
+        act = @start
+        loop do
+          yield act
+          break if (act = act.data_pointer[@idd].next).nil?
+        end
+      end
+
+      def map
+        ary = []
+        each { |e| ary << yield(e) }
+        ary
+      end
+
+      def delete(entry)
+        return if @size == 0
+        return if entry.data_pointer[@idd].inside == false
+
+        next_of_entry = entry.data_pointer[@idd].next
+        prev_of_entry = entry.data_pointer[@idd].prev
+
+        case entry
+        when @start
+          @start = next_of_entry
+        when @end
+          @end = prev_of_entry
+        end
+
+        next_of_entry.data_pointer[@idd].prev = prev_of_entry unless next_of_entry.nil?
+        prev_of_entry.data_pointer[@idd].next = next_of_entry unless prev_of_entry.nil?
+
+        entry.data_pointer[@idd].next = nil
+        entry.data_pointer[@idd].prev = nil
+
+        @size -= 1
+        entry.data_pointer[@idd].inside = false
+      end
+    end
+  end
+end

data/lib/contrek/finder/list_entry.rb

@@ -0,0 +1,11 @@
+module Contrek
+  module Finder
+    class ListEntry
+      attr_reader :data_pointer, :name
+      def initialize(lists, name)
+        @data_pointer = lists.get_data_pointer
+        @name = name
+      end
+    end
+  end
+end

data/lib/contrek/finder/listable.rb

@@ -0,0 +1,8 @@
+module Contrek
+  module Finder
+    module Listable
+      attr_accessor :data_pointer
+      @data_pointer
+    end
+  end
+end

data/lib/contrek/finder/lists.rb

@@ -0,0 +1,25 @@
+module Contrek
+  module Finder
+    class Lists
+      Link = Struct.new(:next, :prev, :inside)
+      def initialize
+        @lists = []
+      end
+
+      def get_data_pointer
+        data_pointer = Array.new(@lists.size) { [] }
+        @lists.size.times do |n|
+          data_pointer[n] = Link.new(nil, nil, false)
+        end
+
+        data_pointer
+      end
+
+      def add_list
+        list = Contrek::Finder::List.new(@lists.size)
+        @lists << list
+        list
+      end
+    end
+  end
+end