slippy_tiles_scorer 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a911e3fb4c9a3d30d90e52664a3619f2c208581a0a31ee938ab4c44444d9608
-  data.tar.gz: 8093375ef475c76b1c996b31335a7b151e850778c8cd9c285411b0d33926e7a7
+  metadata.gz: 45a20e9e3a868777563acc17792b2ba76f8324fe8e4c13ee7419796dd34282b1
+  data.tar.gz: 32beb051875c07b2b6ef153ebd28927897463f6d587bf4d9d76954f9a93b70bb
 SHA512:
-  metadata.gz: ad02a2cbdda34c8976cdd4cea4a9d90c5c9b80afe3c77c55eec578f054de4c4d89272b1e10eaa47f253184ea96d4fa2716fc16873d7ae51dfe2bf836e47d61e4
-  data.tar.gz: c55a90cf772a57db236e2b182ac6853bc0137685ca92567c48883a1e897e05d5e0bb38bde02e50a63832793b117b1ba619c2bdf255530668fd51b4031d1d9d9d
+  metadata.gz: c9d98be61799953007c5bf71ecd7cfc36ba70d9ed528e83259d9124c81d04d6e618cfe92455b2dc4d1dd5bb3d995eff781ed53b791a306bdaa68f4e2049b2d52
+  data.tar.gz: b3b99dedef94d6cf0fd2248867c7649b1ecd18ee089c77d66971296bcaec2634a9f24a7bfdf847a3d681b059019c90fb799a17cc64a8b709f6535ec7d7f291dc

data/lib/slippy_tiles_scorer/cluster.rb

@@ -3,84 +3,144 @@
 require "set"
 
 module SlippyTilesScorer
-  # finds clusters in a collection/tiles_x_y of points (x, y)
+  # Finds connected clusters in a collection of x/y tiles.
   class Cluster
+    MISSING = Object.new.freeze
+    private_constant :MISSING
+
     attr_accessor :tiles_x_y
 
     def initialize(tiles_x_y: Set.new)
       @tiles_x_y = tiles_x_y
-      @cluster_tiles = Set.new
-      @visited = {}
-      @clusters = []
     end
 
-    # @return [Hash] The clusters and the tiles in the clusters.
-    def clusters
-      @tiles_x_y.each do |i|
-        next if visited?(i[0], i[1])
+    # @return [Hash] The clusters and the tiles surrounded on all four sides.
+    def clusters # rubocop:disable Metrics/MethodLength
+      tile_index = build_tile_index
+
+      clusters = []
+      cluster_tiles = Set.new
+
+      @tiles_x_y.each do |start|
+        x = start[0]
+        y = start[1]
+
+        row = tile_index[y]
+
+        # nil means this tile was already visited.
+        next unless row && row[x]
+
+        row[x] = nil
+
+        cluster = [start]
+        todo = [start]
+
+        broad_search!(
+          todo,
+          cluster,
+          cluster_tiles,
+          tile_index
+        )
 
-        visit!(i[0], i[1])
-        find_cluster_around(i)
+        clusters << cluster
       end
-      { clusters: @clusters, cluster_tiles: @cluster_tiles }
+
+      {
+        clusters: clusters,
+        cluster_tiles: cluster_tiles
+      }
     end
 
     private
 
-    # @param start [Array] The x and y coordinate of the start point.
-    # @return [Array<Array<Integer, Integer>>] The cluster of points.
-    def find_cluster_around(start)
-      cluster = []
-      cluster.push(start)
-      todo = [start]
-      broad_search!(todo, cluster)
+    # Builds a sparse coordinate lookup.
+    #
+    # Values initially contain the original tile Array:
+    #
+    #   {
+    #     y => {
+    #       x => [x, y]
+    #     }
+    #   }
+    #
+    # Once a tile has been scheduled for traversal its value becomes nil.
+    # Hash#key? / Hash#fetch can therefore still distinguish:
+    #
+    #   missing  -> MISSING
+    #   visited  -> nil
+    #   unvisited -> [x, y]
+    #
+    def build_tile_index # rubocop:disable Metrics/MethodLength
+      index = {}
+
+      @tiles_x_y.each do |tile|
+        x = tile[0]
+        y = tile[1]
 
-      @clusters.push(cluster)
-      cluster
+        row = index[y]
+
+        if row
+          row[x] = tile
+        else
+          index[y] = { x => tile }
+        end
+      end
+
+      index
     end
 
-    # @param todo [Array] The points to visit.
-    # @param cluster [Array] The cluster of points.
-    def broad_search!(todo, cluster) # rubocop:disable Metrics/CyclomaticComplexity
+    def broad_search!(todo, cluster, cluster_tiles, tile_index) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
       until todo.empty?
         point = todo.pop
-        neighbors = neighbor_points(*point)
-        neighbors_up_down_left_right?(neighbors) && @cluster_tiles.add(point)
-        neighbors.each do |neighbor|
-          next if visited?(neighbor[0], neighbor[1])
-          next unless @tiles_x_y.include?(neighbor)
 
-          visit!(*neighbor) && todo.push(neighbor) && cluster.push(neighbor)
+        x = point[0]
+        y = point[1]
+
+        row = tile_index[y]
+
+        left_x = x - 1
+        right_x = x + 1
+
+        left = row.fetch(left_x, MISSING)
+        right = row.fetch(right_x, MISSING)
+
+        down_row = tile_index[y + 1]
+        up_row = tile_index[y - 1]
+
+        down = down_row ? down_row.fetch(x, MISSING) : MISSING
+        up = up_row ? up_row.fetch(x, MISSING) : MISSING
+
+        if !left.equal?(MISSING) &&
+           !right.equal?(MISSING) &&
+           !down.equal?(MISSING) &&
+           !up.equal?(MISSING)
+          cluster_tiles.add(point)
         end
-      end
-    end
 
-    # @param x [Integer] The x coordinate of the point.
-    # @param y [Integer] The y coordinate of the point.
-    # @return [Boolean] True if the point is visited.
-    def visit!(x, y)
-      @visited[x] ||= {}
-      @visited[x][y] = true
-    end
+        if left && !left.equal?(MISSING)
+          row[left_x] = nil
+          todo << left
+          cluster << left
+        end
 
-    # @param x [Integer] The x coordinate of the point.
-    # @param y [Integer] The y coordinate of the point.
-    # @return [Boolean|Nil] True if the point is visited.
-    def visited?(x, y)
-      @visited.dig(x, y)
-    end
+        if right && !right.equal?(MISSING)
+          row[right_x] = nil
+          todo << right
+          cluster << right
+        end
 
-    # @param neighbors [Array] The neighbors of the point.
-    # @return [Boolean] True if all neighbors are in the tiles_x_y.
-    def neighbors_up_down_left_right?(neighbors)
-      neighbors.all? { |n| @tiles_x_y.include?(n) }
-    end
+        if down && !down.equal?(MISSING)
+          down_row[x] = nil
+          todo << down
+          cluster << down
+        end
+
+        next unless up && !up.equal?(MISSING)
 
-    # @param x [Integer] The x coordinate of the point.
-    # @param y [Integer] The y coordinate of the point.
-    # @return [Array<Array<Integer, Integer>>] The neighbors of the point.
-    def neighbor_points(x, y)
-      [[x - 1, y], [x + 1, y], [x, y + 1], [x, y - 1]]
+        up_row[x] = nil
+        todo << up
+        cluster << up
+      end
     end
   end
 end

data/lib/slippy_tiles_scorer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SlippyTilesScorer
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end

data/mise.toml

@@ -1,2 +1,2 @@
 [tools]
-ruby = "jruby-10"
+ruby = "4"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: slippy_tiles_scorer
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Simon Neutert
@@ -65,7 +65,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.13
+rubygems_version: 4.0.16
 specification_version: 4
 summary: A gem to score a set of slippy tiles.
 test_files: []