contrek 1.0.0

data/lib/contrek/finder/node.rb

@@ -0,0 +1,126 @@
+module Contrek
+  module Finder
+    class Node
+      include Listable
+      attr_reader :min_x, :max_x, :y, :name, :tangs, :tangs_sequence, :tangs_count, :data_pointer
+      attr_accessor :track, :abs_x_index, :outer_index, :inner_index
+
+      T_UP = -1
+      T_DOWN = 1
+      OMAX = 1 << 0
+      OMIN = 1 << 1
+      IMAX = 1 << 2
+      IMIN = 1 << 3
+      OCOMPLETE = OMIN | OMAX
+
+      TURN_MAX = IMAX | OMAX
+      TURN_MIN = IMIN | OMIN
+
+      # 0 = outer
+      # 1 = inner
+      TURNER = [[OMAX, OMIN], [TURN_MAX, TURN_MIN]]
+
+      OUTER = 0
+      INNER = 1
+
+      def initialize(cluster, min_x, max_x, y, name)
+        @name = name
+        @min_x = min_x
+        @max_x = max_x
+        @y = y
+        @tangs = {T_UP => [], T_DOWN => []}
+        @tangs_sequence = nil
+        @tangs_count = 0
+        @track = 0
+        @abs_x_index = 0
+        @data_pointer = cluster.lists.get_data_pointer
+        @up_indexer = 0
+        @down_indexer = 0
+        @outer_index = -1
+        @inner_index = -1
+        cluster.add_node(self)
+      end
+
+      def tangs?(node)
+        @min_x <= node.max_x && node.min_x <= @max_x
+      end
+
+      def my_next(last, versus, mode)
+        last_node_index = if last.y < y
+          last.abs_x_index + @up_indexer
+        else
+          @down_indexer - last.abs_x_index
+        end
+
+        case mode
+        when :outer
+          if versus == :o
+            (last_node_index == tangs_sequence.size - 1) ? last_node_index = 0 : last_node_index += 1
+          else
+            (last_node_index == 0) ? last_node_index = tangs_sequence.size - 1 : last_node_index -= 1
+          end
+
+        when :inner
+
+          if versus == :o
+            (last_node_index == 0) ? last_node_index = tangs_sequence.size - 1 : last_node_index -= 1
+          else
+            (last_node_index == tangs_sequence.size - 1) ? last_node_index = 0 : last_node_index += 1
+          end
+
+        end
+        tangs_sequence.at(last_node_index)
+      end
+
+      def coords_entering_to(enter_to, enter_mode, tracking)
+        enter_to_index = if enter_to.y < y
+          enter_to.abs_x_index + @up_indexer
+        else
+          @down_indexer - enter_to.abs_x_index
+        end
+        ds = tangs_sequence[enter_to_index]
+        coords_source = ds.send(enter_mode)
+        enter_to.track |= TURNER[tracking][coords_source[:m] - 1]
+        coords_source[:point]
+      end
+
+      def tangs_with_x?(x)
+        x.between?(@min_x, @max_x)
+      end
+
+      def track_uncomplete
+        (@track & OCOMPLETE) != OCOMPLETE
+      end
+
+      def track_complete
+        (@track & OCOMPLETE) == OCOMPLETE
+      end
+
+      def add_intersection(other_node)
+        if other_node.y < y
+          @tangs[T_UP] << other_node
+        else
+          @tangs[T_DOWN] << other_node
+        end
+      end
+
+      def precalc_tangs_sequences
+        @tangs_sequence = Array.new(tangs[T_UP].size + tangs[T_DOWN].size)
+        tangs = self.tangs[T_UP].sort_by(&:min_x)
+        n = -1
+        @up_indexer = -tangs[0].abs_x_index if tangs.size > 0
+        tangs.each do |t_node|
+          nd = Contrek::Finder::PolygonFinder::NodeDescriptor.new(t_node, {point: {x: t_node.max_x, y: t_node.y}, m: OMAX}, {point: {x: t_node.min_x, y: t_node.y}, m: OMIN})
+          tangs_sequence[n += 1] = nd
+        end
+        tangs = self.tangs[T_DOWN].sort_by(&:min_x).reverse
+        @down_indexer = (tangs.last.abs_x_index + self.tangs[T_DOWN].size + self.tangs[T_UP].size - 1) if tangs.size > 0
+        tangs.each do |t_node|
+          nd = Contrek::Finder::PolygonFinder::NodeDescriptor.new(t_node, {point: {x: t_node.min_x, y: t_node.y}, m: OMIN}, {point: {x: t_node.max_x, y: t_node.y}, m: OMAX})
+          tangs_sequence[n += 1] = nd
+        end
+        @tangs_count = tangs_sequence.size
+      end
+    end
+  end
+end

data/lib/contrek/finder/node_cluster.rb

@@ -0,0 +1,294 @@
+module Contrek
+  module Finder
+    class NodeCluster
+      attr_reader :root_nodes, :sequences, :polygons, :lists, :treemap, :vert_nodes
+      VERSUS_INVERTER = {a: :o, o: :a}
+
+      def initialize(h, options)
+        @options = options
+        @vert_nodes = Array.new(h) { [] }      # per y immetto i nodi
+        @sequences = []
+        @polygons = []
+        @treemap = []
+        @nodes = 0
+        @lists = Contrek::Finder::Lists.new
+        @root_nodes = @lists.add_list
+        @inner_plot = @lists.add_list
+        @inner_new = @lists.add_list
+      end
+
+      def path_sequences
+        @polygons.compact.each do |polygon|
+          yield polygon[:outer]
+          polygon[:inner].each do |sequence|
+            yield sequence
+          end
+        end
+      end
+
+      def compress_coords
+        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::VisvalingamReducer.new(points: seq, options: @options[:compress][:visvalingam]).reduce! if @options[:compress].has_key?(:visvalingam)
+        end
+      end
+
+      # nominal sequence
+      def named_sequence
+        @plot_sequence.map(&:name).join
+      end
+
+      # builds node sequences (with space coordinates) array scanning upper and lower element
+      # needs root_nodes ready
+      def build_tangs_sequence
+        @vert_nodes.each do |line|
+          line.each do |node|
+            node.precalc_tangs_sequences
+          end
+        end
+      end
+
+      def plot(bitmap)
+        versus = @options[:versus]
+        inner_v = VERSUS_INVERTER[versus]
+        index_order = 0
+        while @root_nodes.size > 0
+          root_node = @root_nodes.shift
+          root_node.outer_index = index_order
+          @plot_sequence = []
+          @sequence_coords = []
+          # external polygon
+          @plot_sequence << root_node
+          next_node_nd = if versus == :a
+            root_node.tangs_sequence.last
+          else
+            root_node.tangs_sequence.first
+          end
+          #---------------
+          if !next_node_nd.nil?
+            next_node = next_node_nd.node
+            @sequence_coords << next_node.coords_entering_to(root_node, VERSUS_INVERTER[versus], Contrek::Finder::Node::OUTER)
+          end
+          #---------------
+          plot_node(next_node, root_node, versus) if @nodes > 0 && !next_node_nd.nil?
+
+          draw_sequence(bitmap, "X") unless bitmap.nil?
+          @polygons << {outer: @sequence_coords, inner: []} if @sequence_coords.size >= 2
+          @sequences << @plot_sequence
+
+          @count = 0
+          index_inner = 0
+          while @inner_plot.size > 0
+            @plot_sequence = []
+            @sequence_coords = []
+            # mia test
+            first = @inner_plot.find { |x| x.tangs_count <= 2 } || @inner_plot.first
+
+            @plot_sequence << first
+            @inner_plot.delete(first)
+            @root_nodes.delete(first)
+
+            first.inner_index = index_inner
+
+            # @count += 1
+            # if @count > 10000
+            #  puts "Houston, we have a problem!"
+            #  break
+            # end
+
+            next_node = if (first.track & Contrek::Finder::Node::OMAX) != 0
+              (inner_v == :a) ? first.tangs[Contrek::Finder::Node::T_UP].first : first.tangs[Contrek::Finder::Node::T_DOWN].first
+            else
+              (inner_v == :a) ? first.tangs[Contrek::Finder::Node::T_DOWN].last : first.tangs[Contrek::Finder::Node::T_UP].last
+            end
+
+            if !next_node.nil?
+              @sequence_coords << next_node.coords_entering_to(first, inner_v, Contrek::Finder::Node::INNER)
+            end
+
+            plot_inner_node(next_node, inner_v, first, root_node) if !next_node.nil?
+
+            draw_sequence(bitmap, "+") unless bitmap.nil?
+
+            @polygons.last[:inner] << @sequence_coords
+
+            @inner_plot.grab(@inner_new)
+            index_inner += 1
+          end
+          # tree
+          @treemap << ((versus == :a) ? test_in_hole_a(root_node) : test_in_hole_o(root_node)) if @options.has_key?(:treemap)
+          index_order += 1
+        end
+      end
+
+      def test_in_hole_a(node)
+        if node.outer_index > 0
+          start_left = node.abs_x_index - 1
+          loop do
+            prev = @vert_nodes[node.y][start_left]
+            if ((cindex = prev.outer_index) < node.outer_index) && ((prev.track & Contrek::Finder::Node::IMAX) != 0)
+              start_right = node.abs_x_index
+              while (start_right += 1) != @vert_nodes[node.y].size
+                tnext = @vert_nodes[node.y][start_right]
+                if tnext.outer_index == cindex
+                  if (tnext.track & Contrek::Finder::Node::IMIN) != 0
+                    return [cindex, prev.inner_index]
+                  else
+                    return [-1, -1]
+                  end
+                end
+              end
+            end
+            break if (start_left -= 1) < 0
+          end
+        end
+        [-1, -1]
+      end
+
+      def test_in_hole_o(node)
+        if node.outer_index > 0 && @vert_nodes[node.y].last != node
+          start_left = node.abs_x_index + 1
+          loop do
+            prev = @vert_nodes[node.y][start_left]
+            if ((cindex = prev.outer_index) < node.outer_index) && ((prev.track & Contrek::Finder::Node::IMIN) != 0)
+              start_right = node.abs_x_index
+              while (start_right -= 1) >= 0
+                tnext = @vert_nodes[node.y][start_right]
+                if tnext.outer_index == cindex
+                  if (tnext.track & Contrek::Finder::Node::IMAX) != 0
+                    return [cindex, prev.inner_index]
+                  else
+                    return [-1, -1]
+                  end
+                end
+              end
+            end
+            break if (start_left += 1) == @vert_nodes[node.y].size
+          end
+        end
+        [-1, -1]
+      end
+
+      def draw_sequence(bitmap, val = nil)
+        count = 1
+        @sequence_coords.each do |coords|
+          bitmap.value_set(coords[:x], coords[:y], val.nil? ? count.alph : val)
+          count += 1
+        end
+      end
+
+      # inner way
+      # nodes in @plot_sequence
+      # coordinates in @sequence_coords
+      def plot_inner_node(node, versus, stop_at, start_node)
+        node.outer_index = start_node.outer_index
+        node.inner_index = stop_at.inner_index
+        @root_nodes.delete(node)
+        @inner_plot.delete(node)
+        last_node = @plot_sequence.last
+        next_node_nd = node.my_next(last_node, versus, :inner)
+        next_node = next_node_nd.node
+        @plot_sequence << node
+
+        plot = true
+        if next_node.y == last_node.y
+          plot = (node.tangs_sequence.send((versus == :a) ? :first : :last).node == 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)
+            end
+          end
+        end
+
+        if node.track_uncomplete
+          @inner_new << node
+        else
+          @inner_new.delete(node)
+        end
+
+        return 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, versus = :a)
+        @root_nodes.delete(node)
+
+        node.outer_index = start_node.outer_index
+        last_node = @plot_sequence.last
+        next_node_nd = node.my_next(last_node, versus, :outer)
+        next_node = next_node_nd.node
+
+        @plot_sequence << node
+
+        plot = true
+        if next_node.y == last_node.y
+          plot = (node.tangs_sequence.send((versus == :a) ? :last : :first).node == next_node)
+        end
+
+        # coord
+        if plot
+          @sequence_coords << last_node.coords_entering_to(node, versus, Contrek::Finder::Node::OUTER)
+
+          if node != start_node
+            @inner_plot.contains(node) ? @inner_plot.delete(node) : @inner_plot << node
+            if last_node.y == next_node.y
+              @sequence_coords << next_node.coords_entering_to(node, VERSUS_INVERTER[versus], Contrek::Finder::Node::OUTER)
+              @inner_plot.contains(node) ? @inner_plot.delete(node) : @inner_plot << node
+            end
+          end
+        end
+        # exit if root_node
+
+        if node == start_node
+          return if node.track_complete
+        end
+        plot_node(next_node, start_node, versus)
+      end
+
+      def add_node(node)
+        @nodes += 1
+        node.abs_x_index = @vert_nodes[node.y].size
+
+        @vert_nodes[node.y] << node
+        @root_nodes << node
+
+        if node.y > 0
+          # all nodes untle up_node.max_x >= node.min_x
+          up_nodes = @vert_nodes[node.y - 1]
+          up_nodes_count = up_nodes.size
+          if up_nodes_count > 0
+            index = 0
+            loop do
+              up_node = up_nodes[index]
+              if up_node.max_x >= node.min_x
+                if up_node.min_x <= node.max_x
+                  node.add_intersection(up_node)
+                  up_node.add_intersection(node)
+                end
+                return if (index += 1) == up_nodes_count
+                loop do
+                  up_node = up_nodes[index]
+                  if up_node.min_x <= node.max_x
+                    node.add_intersection(up_node)
+                    up_node.add_intersection(node)
+                  else
+                    return
+                  end
+                  break if (index += 1) == up_nodes_count
+                end
+                return
+              end
+              break if (index += 1) == up_nodes_count
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/contrek/finder/polygon_finder.rb

@@ -0,0 +1,121 @@
+require "benchmark"
+# todo
+# - builtin png decoder which makes blocks to pass vert_nodes
+# - work only in clockwise (no more :o e :a); finally for coords use push_back on :a and
+#   push_front on :o
+module Contrek
+  module Finder
+    class PolygonFinder
+      NodeDescriptor = Struct.new(:node, :a, :o)
+      def initialize(bitmap, matcher, test_bitmap = nil, options = {})
+        @options = {versus: :a}.merge(options)
+        sanitize_options
+        @source_bitmap = bitmap
+        @matcher = matcher
+
+        @test_bitmap = test_bitmap
+        @node_cluster = NodeCluster.new(@source_bitmap.h, @options)
+        @reports = {}
+
+        # 1 finds matching blocks
+        @reports[:scan] = Benchmark.measure do
+          scan
+        end
+
+        # 2 builds relational spatially tree map
+        @reports[:build_tangs_sequence] = Benchmark.measure do
+          @node_cluster.build_tangs_sequence
+        end
+
+        # 3 plotting
+        @reports[:plot] = Benchmark.measure do
+          @node_cluster.plot(@test_bitmap)
+        end
+
+        # 4 compress
+        @reports[:compress] = Benchmark.measure do
+          if @options.has_key?(:compress)
+            @node_cluster.compress_coords
+          end
+        end
+      end
+
+      def sanitize_options
+        @options[:versus] = :a unless @options[:versus] == :a || @options[:versus] == :o
+      end
+
+      # infos
+      def process_info
+        {named_sequence: @node_cluster.sequences.map { |list| list.map(&:name).join }.join("-"),
+         groups: @node_cluster.sequences.size,
+         groups_names: @node_cluster.root_nodes.map(&:name).join,
+         polygons: @node_cluster.polygons,
+         benchmarks: format_benchmarks,
+         treemap: (@node_cluster.treemap if @options.has_key?(:treemap))}
+      end
+
+      def get_shapelines
+        shapes = []
+        @node_cluster.vert_nodes.each do |line|
+          line.each do |node|
+            shapes << {start_x: node.min_x, end_x: node.max_x, y: node.y}
+          end
+        end
+        shapes
+      end
+
+      def draw_polygons(png_image)
+        Contrek::Bitmaps::Painting.direct_draw_polygons(@node_cluster.polygons, png_image)
+      end
+
+      def draw_shapelines(png_image)
+        slines = get_shapelines
+        color = ChunkyPNG::Color("blue @ 1.0")
+        slines.each do |sline|
+          png_image.draw_line(sline[:start_x], sline[:y], sline[:end_x], sline[:y], color)
+        end
+      end
+
+      private
+
+      # image scan
+      def scan
+        last_color = nil
+        matching = false
+        min_x = 0
+        max_x = 0
+        @source_bitmap.scan do |x, y, color|
+          if @matcher.match?(color) && matching == false
+            min_x = x
+            last_color = color
+            matching = true
+            if x == (@source_bitmap.w - 1)
+              max_x = x
+              Contrek::Finder::Node.new(@node_cluster, min_x, max_x, y, last_color)
+              matching = false
+            end
+          elsif @matcher.unmatch?(color) && matching == true
+            max_x = x - 1
+            Contrek::Finder::Node.new(@node_cluster, min_x, max_x, y, last_color)
+            matching = false
+          elsif x == (@source_bitmap.w - 1) && matching == true
+            max_x = x
+            Contrek::Finder::Node.new(@node_cluster, min_x, max_x, y, last_color)
+            matching = false
+          end
+        end
+      end
+
+      def format_benchmarks
+        r = {}
+        total = 0
+        @reports.each do |k, v|
+          r[k] = (v.real * 1000).round(3)
+          total += v.real * 1000
+        end
+        r[:total] = total.round(3)
+        r
+      end
+    end
+  end
+end

data/lib/contrek/map/mercator_projection.rb

@@ -0,0 +1,76 @@
+module Map
+  class MercatorProjection
+    MERCATOR_RANGE = 256
+
+    class LatLng
+      attr_reader :lat, :lng
+      def initialize(lat:, lng:)
+        @lat = lat
+        @lng = lng
+      end
+    end
+
+    class Point
+      attr_accessor :x, :y
+      def initialize(x: 0, y: 0)
+        @x = x
+        @y = y
+      end
+    end
+
+    def initialize
+      @pixel_origin = Point.new(x: MERCATOR_RANGE / 2, y: MERCATOR_RANGE / 2)
+      @pixels_per_lon_degree = MERCATOR_RANGE.to_f / 360
+      @pixels_per_lon_radian = MERCATOR_RANGE.to_f / (2 * Math::PI)
+    end
+
+    def self.get_corners(center, zoom, map_width, map_height)
+      scale = 2**zoom
+      proj = Map::MercatorProjection.new
+      center_px = proj.from_lat_lng_to_point(lat_lng: center)
+      sw_point = Point.new(x: center_px.x - ((map_width / 2).to_f / scale), y: center_px.y + ((map_height / 2).to_f / scale))
+      sw_lat_lon = proj.from_point_to_lat_lng(sw_point)
+      ne_point = Point.new(x: center_px.x + ((map_width / 2).to_f / scale), y: center_px.y - ((map_height / 2).to_f / scale))
+      ne_lat_lon = proj.from_point_to_lat_lng(ne_point)
+      {
+        N: ne_lat_lon.lat,
+        E: ne_lat_lon.lng,
+        S: sw_lat_lon.lat,
+        W: sw_lat_lon.lng
+      }
+    end
+
+    def from_lat_lng_to_point(lat_lng:, opt_point: nil)
+      point = opt_point.nil? ? Point.new(x: 0, y: 0) : opt_point
+      origin = @pixel_origin
+      point.x = origin.x + (lat_lng.lng * @pixels_per_lon_degree)
+      siny = bound(Math.sin(degreesToRadians(lat_lng.lat)), -0.9999, 0.9999)
+      point.y = origin.y + (0.5 * Math.log((1 + siny) / (1 - siny)) * -@pixels_per_lon_radian)
+      point
+    end
+
+    def from_point_to_lat_lng(point)
+      origin = @pixel_origin
+      lng = (point.x - origin.x) / @pixels_per_lon_degree
+      lat_radians = (point.y - origin.y) / -@pixels_per_lon_radian
+      lat = radiansToDegrees(2 * Math.atan(Math.exp(lat_radians)) - (Math::PI / 2))
+      LatLng.new(lat: lat, lng: lng)
+    end
+
+    private
+
+    def degreesToRadians(deg)
+      deg * (Math::PI / 180)
+    end
+
+    def radiansToDegrees(rad)
+      rad / (Math::PI / 180)
+    end
+
+    def bound(value, opt_min, opt_max)
+      value = [value, opt_min].max if !opt_min.nil?
+      value = [value, opt_max].min if !opt_max.nil?
+      value
+    end
+  end
+end

data/lib/contrek/matchers/matcher.rb

@@ -0,0 +1,20 @@
+module Contrek
+  module Matchers
+    class Matcher
+      attr_reader :values, :counters
+      def initialize(value)
+        @value_is = value
+        @values = []
+        @counters = {}
+      end
+
+      def match?(value)
+        @value_is == value
+      end
+
+      def unmatch?(value)
+        !match?(value)
+      end
+    end
+  end
+end

data/lib/contrek/matchers/matcher_hsb.rb

@@ -0,0 +1,24 @@
+module Contrek
+  module Matchers
+    class MatcherHsb < Matcher
+      def match?(value)
+        if @values.index(value).nil?
+          @values << value
+          @counters[value] = {count: 1, match: 0}
+        else
+          @counters[value][:count] += 1
+        end
+
+        match = value[0].between?(@value_is[:h][:min], @value_is[:h][:max]) &&
+          value[1].between?(@value_is[:s][:min], @value_is[:s][:max]) &&
+          value[2].between?(@value_is[:b][:min], @value_is[:b][:max])
+
+        if match
+          @counters[value][:match] += 1
+        end
+
+        match
+      end
+    end
+  end
+end

data/lib/contrek/matchers/value_not_matcher.rb

@@ -0,0 +1,9 @@
+module Contrek
+  module Matchers
+    class ValueNotMatcher < Matcher
+      def match?(value)
+        @value_is != value
+      end
+    end
+  end
+end

data/lib/contrek/reducers/linear_reducer.rb

@@ -0,0 +1,25 @@
+module Contrek
+  module Reducers
+    class LinearReducer < Reducer
+      def reduce!
+        start_p = @points[0]
+        end_p = @points[1]
+        dir = seq_dir(start_p, end_p)
+        @points[2..].map.with_index do |point, i|
+          if (act_seq = seq_dir(end_p, point)) == dir
+            @points.delete_at(@points.index(end_p))
+          else
+            dir = act_seq
+          end
+          end_p = point
+        end
+      end
+
+      private
+
+      def seq_dir(a, b)
+        [b[:x] - a[:x], b[:y] - a[:y]]
+      end
+    end
+  end
+end