slippy_tiles_scorer 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3535ebc0ef81b4b9096043ac739f65877a793c82e9f115f4faa16339184c359c
-  data.tar.gz: f0375a478ee6603038e12fc15f55ecf320c161d2764d30fbd362908bfaf763b9
+  metadata.gz: 95be9f898e6231b3595f43b3b35baf834e5eba161e78db33b2eb14c7baa19975
+  data.tar.gz: 785f9286455947d79581de9cef5ffc2cde4ecd8b1860f7ab0494c6ae47386ff9
 SHA512:
-  metadata.gz: 0df4fbebb75b3f9b3a4019490695d6ae81e9d59498a1479f72f63f92de17ad756b1e1776787025e06cebeff2770aab067faff79aa6f6a2053757daf7972d5a34
-  data.tar.gz: 1c5b8bc92a68023c2fb8fbd84f9bba559eeb1b5eec26b757b7310c22a0aacbf316700736f4c814b31e2871a57b279f26d951d576d8861104c5b2460e10771a6e
+  metadata.gz: f9af7b7e325f515220925b5361cb5c20aefc00add5742539d2b0dfd42a5b9f1d996b880a6d739180ac84d9a8715a68b08325ebcf34008a52a311a9cbe5b51899
+  data.tar.gz: 85ffe608074ddf335004e48dee35feef330bea221de5fdd6f4deab9213df1d266cf29c5edf9d45d07316c588f4d3a62d19e0bd3e7689809cf328375f595a53d2

data/README.md

@@ -1,5 +1,12 @@
 # SlippyTilesScorer
 
+> [!NOTE]  
+> This gem's API is not considered stable yet.
+> Things might change in the future.
+
+[![Gem Version](https://badge.fury.io/rb/slippy_tiles_scorer.svg)](https://badge.fury.io/rb/slippy_tiles_scorer) \
+[![Ruby](https://github.com/simonneutert/slippy_tiles_scorer/actions/workflows/main.yml/badge.svg)](https://github.com/simonneutert/slippy_tiles_scorer/actions/workflows/main.yml)
+
 Calculate scores of map tiles (x, y) on a map. The scores are total, (max)
 clusters, and max squares.
 
@@ -7,18 +14,16 @@ To experiment with that code, run `bin/console` for an interactive prompt.
 
 ## Installation
 
-TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
-
 Install the gem and add to the application's Gemfile by executing:
 
 ```bash
-bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+bundle add slippy_tiles_scorer
 ```
 
 If bundler is not being used to manage dependencies, install the gem by executing:
 
 ```bash
-gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+gem install slippy_tiles_scorer
 ```
 
 ## Usage
@@ -43,7 +48,7 @@ collection_of_tiles.add([2, 0])
 collection_of_tiles.add([2, 1])
 collection_of_tiles.add([2, 2])
 
-tile_scorer = SlippyTilesScorer::Scorer.new(tiles_x_y: collection_of_tiles)
+tile_scorer = SlippyTilesScorer::Score.new(tiles_x_y: collection_of_tiles)
 tile_scorer.valid? # => true
 
 # the collection_of_tiles is a 3x3 map and will be used to calculate scores,
@@ -55,15 +60,17 @@ tile_scorer.visited # => 9
 tile_scorer.clusters # => 
     #   {
     #       :clusters=>[
-    #           <Set: {[0, 0], [1, 0], [0, 1], [1, 1], [0, 2], [1, 2], [2, 2], [2, 1], [2, 0]}>
+    #           [
+    #             [0, 0], [1, 0], [0, 1], [1, 1], [0, 2], [1, 2], [2, 2], [2, 1], [2, 0]
+    #           ]
     #       ],
     #       :cluster_tiles=>#<Set: {[1, 1]}>,
-    #       :clusters_of_cluster_tiles=>[]
+    #       :clusters_of_cluster_tiles=>[[[1, 1]]]
     #   }
 
 # calculate max squares
-tile_scorer.max_squares # => {:size=>3, top_left_tile_x_y=>#<Set: {[0, 0]}>}
-tile_scorer.max_squares(min_size: 4) # => {:size=>4, top_left_tile_x_y=>#<Set: {}>}
+tile_scorer.max_squares # => {:size=>0, top_left_tile_x_y=>#<Set: {[0, 0]}>}
+tile_scorer.max_squares(min_size: 4) # => {:size=>0, top_left_tile_x_y=>#<Set: {}>}
 ```
 
 ### Optimized
@@ -72,7 +79,7 @@ An more computationally optimized example of how to use the `TileScorer` class,
 
 ```ruby
 ### OPTIMIZE COMPUTATION ###
-tile_scorer = SlippyTilesScorer::Scorer.new(tiles_x_y: collection_of_tiles)
+tile_scorer = SlippyTilesScorer::Score.new(tiles_x_y: collection_of_tiles)
 # Optimize computation by calculating clusters first,
 result_clusters = tile_scorer.clusters
 clusters = result_clusters[:clusters]

data/lib/slippy_tiles_scorer/cluster.rb

@@ -6,18 +6,17 @@ module SlippyTilesScorer
     attr_accessor :tiles_x_y
 
     def initialize(tiles_x_y: Set.new)
-      @tiles_x_y = Marshal.load(Marshal.dump(tiles_x_y))
+      @tiles_x_y = tiles_x_y
       @cluster_tiles = Set.new
-      @visited = Set.new
+      @visited = {}
       @clusters = []
     end
 
     def clusters
-      while @tiles_x_y.any?
-        start = @tiles_x_y.first
-        @tiles_x_y.delete(start)
-        @visited.add(start)
-        find_cluster_around(start)
+      @tiles_x_y.each do |i|
+        next if visited?(i[0], i[1])
+        visit!(i[0], i[1])
+        find_cluster_around(i)
       end
       { clusters: @clusters, cluster_tiles: @cluster_tiles }
     end
@@ -25,44 +24,43 @@ module SlippyTilesScorer
     private
 
     def find_cluster_around(start)
-      cluster = Set.new
-      cluster.add(start)
+      cluster = []
+      cluster.push(start)
       todo = [start]
+      broad_search!(todo, cluster)
 
-      cluster = broad_search(todo, cluster)
-
-      @clusters.push(cluster) if cluster.size > 1
+      @clusters.push(cluster) if cluster.size > 0
       cluster
     end
 
     def neighbors_up_down_left_right?(neighbors)
-      neighbors.all? { |n| @tiles_x_y.include?(n) || @visited.include?(n) }
+      neighbors.all? { |n| @tiles_x_y.include?(n) }
     end
 
-    def broad_search(todo, cluster) # rubocop:disable Metrics/MethodLength
+    def broad_search!(todo, cluster) # rubocop:disable Metrics/MethodLength
       until todo.empty?
         point = todo.pop
         neighbors = neighbor_points(*point)
-
-        next if neighbors.empty?
-
-        @cluster_tiles.add(point) if neighbors_up_down_left_right?(neighbors)
+        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)
-          next if @visited.include?(neighbor)
-
-          @visited.add(neighbor)
-          cluster.add(neighbor)
-          todo.push(neighbor)
+          visit!(*neighbor) && todo.push(neighbor) && cluster.push(neighbor)
         end
       end
-      cluster
     end
 
-    def neighbor_points(x, y) # rubocop:disable Naming/MethodParameterName
-      res = Set.new
-      [[x - 1, y], [x + 1, y], [x, y + 1], [x, y - 1]].each { |point| res.add(point) }
-      res
+    def visit!(x, y)
+      @visited[x] ||= {}
+      @visited[x][y] = true
+    end
+
+    def visited?(x, y)
+      @visited.dig(x, y)
+    end
+
+    def neighbor_points(x, y)
+      [[x - 1, y], [x + 1, y], [x, y + 1], [x, y - 1]]
     end
   end
 end

data/lib/slippy_tiles_scorer/max_square.rb

@@ -6,22 +6,33 @@ module SlippyTilesScorer
     attr_accessor :tiles_x_y
 
     def initialize(tiles_x_y: Set.new)
-      @tiles_x_y = Marshal.load(Marshal.dump(tiles_x_y))
+      @tiles_x_y = tiles_x_y
+      @tiles_lut = nil
     end
 
     # @param min_size [Integer] The minimum size of the square, should be 3 or greater.
     #   As the smallest square is 3x3 and therefor a cluster tile needs to be the center.
     # @return [Hash] The size of the square and the points of the square.
     def max_squares(min_size: 3)
+      @max_size_found = 0
       raise ArgumentError, 'min_size must be 2 or greater' if min_size < 2
 
-      result = { size: min_size, top_left_tile_x_y: Set.new }
+      result = { size: @max_size_found, top_left_tile_x_y: Set.new }
       @tiles_x_y.each do |(x, y)|
         raise ArgumentError, 'x and y must be greater than or equal to 0' if x.negative? || y.negative?
 
         steps = max_square(x: x, y: y)
-        track_result(result: result, steps: steps, x: x, y: y) if steps >= min_size
+        next if steps < min_size
+        if steps > @max_size_found
+          @max_size_found = steps
+          result = { size: @max_size_found, top_left_tile_x_y: Set.new }
+          track_result(result: result, steps: steps, x: x, y: y)
+        elsif steps == @max_size_found
+          result ||= { size: @max_size_found, top_left_tile_x_y: Set.new }
+          track_result(result: result, steps: steps, x: x, y: y)
+        end
       end
+      @tiles_lut = nil
       result
     end
 
@@ -32,23 +43,29 @@ module SlippyTilesScorer
     end
 
     def steps_fulfilled?(x:, y:, steps:) # rubocop:disable Naming/MethodParameterName
-      @tiles_x_y.include?([x + steps, y + steps]) &&
-        (0...steps).all? do |i|
-          @tiles_x_y.include?([x + steps, y + i]) &&
-            @tiles_x_y.include?([x + i, y + steps])
-        end
+      in_lut?(x: x + steps, y: y + steps) &&
+      (0...steps).all? do |i|
+        in_lut?(x: x + steps, y: y + i) &&
+          in_lut?(x: x + i, y: y + steps)
+      end
     end
 
     private
 
-    def track_result(result:, steps:, x:, y:) # rubocop:disable Naming/MethodParameterName
-      if steps > result[:size]
-        result[:size] = steps
-        result[:top_left_tile_x_y] = Set.new
-        result[:top_left_tile_x_y] << [x, y]
-      elsif steps == result[:size]
-        result[:top_left_tile_x_y] << [x, y]
+    def in_lut?(x:, y:)
+      unless @tiles_lut
+        @tiles_lut = {}
+        @tiles_x_y.each do |(x, y)|
+          @tiles_lut[x] ||= {}
+          @tiles_lut[x][y] = true
+        end
       end
+      @tiles_lut.dig(x, y)
+    end
+
+    def track_result(result:, steps:, x:, y:) # rubocop:disable Naming/MethodParameterName
+      result[:size] = steps
+      result[:top_left_tile_x_y] << [x, y]
       result
     end
   end

data/lib/slippy_tiles_scorer/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: slippy_tiles_scorer
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Simon Neutert
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-25 00:00:00.000000000 Z
+date: 2024-11-26 00:00:00.000000000 Z
 dependencies: []
 description: For a given set of slippy tiles, this gem calculates the score of the
   tiles, like total tiles, clusters and max squares.