slippy_tiles_scorer 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3535ebc0ef81b4b9096043ac739f65877a793c82e9f115f4faa16339184c359c
+  data.tar.gz: f0375a478ee6603038e12fc15f55ecf320c161d2764d30fbd362908bfaf763b9
+SHA512:
+  metadata.gz: 0df4fbebb75b3f9b3a4019490695d6ae81e9d59498a1479f72f63f92de17ad756b1e1776787025e06cebeff2770aab067faff79aa6f6a2053757daf7972d5a34
+  data.tar.gz: 1c5b8bc92a68023c2fb8fbd84f9bba559eeb1b5eec26b757b7310c22a0aacbf316700736f4c814b31e2871a57b279f26d951d576d8861104c5b2460e10771a6e

data/.rubocop.yml

@@ -0,0 +1,10 @@
+AllCops:
+  TargetRubyVersion: 3.0
+  Exclude:
+    '*.gemspec'
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2024-11-25
+
+- Initial release

data/README.md

@@ -0,0 +1,103 @@
+# SlippyTilesScorer
+
+Calculate scores of map tiles (x, y) on a map. The scores are total, (max)
+clusters, and max squares.
+
+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
+```
+
+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
+```
+
+## Usage
+
+Find some examples below.
+
+### Simple
+
+A simple example of how to use the `TileScorer` class, when tinkering in a REPL.
+
+```ruby
+require 'tile_scorer'
+
+collection_of_tiles = Set.new
+collection_of_tiles.add([0, 0])
+collection_of_tiles.add([0, 1])
+collection_of_tiles.add([1, 0])
+collection_of_tiles.add([1, 1])
+collection_of_tiles.add([0, 2])
+collection_of_tiles.add([1, 2])
+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.valid? # => true
+
+# the collection_of_tiles is a 3x3 map and will be used to calculate scores,
+# unless you provide a different set of tiles, when calling the methods.
+
+tile_scorer.visited # => 9
+
+# calculate clusters
+tile_scorer.clusters # => 
+    #   {
+    #       :clusters=>[
+    #           <Set: {[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=>[]
+    #   }
+
+# 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: {}>}
+```
+
+### Optimized
+
+An more computationally optimized example of how to use the `TileScorer` class, when using the code in production.
+
+```ruby
+### OPTIMIZE COMPUTATION ###
+tile_scorer = SlippyTilesScorer::Scorer.new(tiles_x_y: collection_of_tiles)
+# Optimize computation by calculating clusters first,
+result_clusters = tile_scorer.clusters
+clusters = result_clusters[:clusters]
+# then max squares based on the clusters.
+max_squares_of_clusters = clusters.flat_map do |cluster|
+  tile_scorer.max_squares(tiles_x_y: cluster)
+end
+# Find the max squares with the biggest edge size.
+max_squares_max_size_mapped = max_squares_of_clusters.map do |max_square| 
+  max_square[:size]
+end
+max_squares_max_size = max_squares_max_size_mapped.max
+# Select and keep only the max squares with the biggest edge size.
+max_squares = max_squares_of_clusters.select do |max_square|
+  max_square[:size] == max_squares_max_size
+end
+puts max_squares # =>[{:size=>3, top_left_tile_x_y=>#<Set: {[0, 0]}>}]
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/simonneutert/slippy_tiles_scorer.

data/Rakefile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rubocop/rake_task"
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]
+
+# TODO: add more tasks here

data/lib/slippy_tiles_scorer/cluster.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module SlippyTilesScorer
+  # finds clusters in a collection/tiles_x_y of points (x, y)
+  class Cluster
+    attr_accessor :tiles_x_y
+
+    def initialize(tiles_x_y: Set.new)
+      @tiles_x_y = Marshal.load(Marshal.dump(tiles_x_y))
+      @cluster_tiles = Set.new
+      @visited = Set.new
+      @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)
+      end
+      { clusters: @clusters, cluster_tiles: @cluster_tiles }
+    end
+
+    private
+
+    def find_cluster_around(start)
+      cluster = Set.new
+      cluster.add(start)
+      todo = [start]
+
+      cluster = broad_search(todo, cluster)
+
+      @clusters.push(cluster) if cluster.size > 1
+      cluster
+    end
+
+    def neighbors_up_down_left_right?(neighbors)
+      neighbors.all? { |n| @tiles_x_y.include?(n) || @visited.include?(n) }
+    end
+
+    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.each do |neighbor|
+          next unless @tiles_x_y.include?(neighbor)
+          next if @visited.include?(neighbor)
+
+          @visited.add(neighbor)
+          cluster.add(neighbor)
+          todo.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
+    end
+  end
+end

data/lib/slippy_tiles_scorer/max_square.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module SlippyTilesScorer
+  # finds the maximum square in a collection/tiles_x_y of points (x, y)
+  class MaxSquare
+    attr_accessor :tiles_x_y
+
+    def initialize(tiles_x_y: Set.new)
+      @tiles_x_y = Marshal.load(Marshal.dump(tiles_x_y))
+    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)
+      raise ArgumentError, 'min_size must be 2 or greater' if min_size < 2
+
+      result = { size: min_size, 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
+      end
+      result
+    end
+
+    def max_square(x:, y:) # rubocop:disable Naming/MethodParameterName
+      steps = 1
+      steps += 1 while steps_fulfilled?(x: x, y: y, steps: steps)
+      steps
+    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
+    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]
+      end
+      result
+    end
+  end
+end

data/lib/slippy_tiles_scorer/version.rb

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

data/lib/slippy_tiles_scorer.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "slippy_tiles_scorer/version"
+require_relative "./slippy_tiles_scorer/cluster"
+require_relative "./slippy_tiles_scorer/max_square"
+
+module SlippyTilesScorer
+  class Error < StandardError; end
+
+  # Score class to calculate the score of a collection of points (x, y)
+  class Score
+    attr_accessor :tiles_x_y
+
+    def initialize(tiles_x_y: Set.new)
+      @tiles_x_y = tiles_x_y
+    end
+
+    def valid?
+      return true if @tiles_x_y.empty?
+
+      raise ArgumentError, "@tiles_x_y must be a Set" unless @tiles_x_y.is_a?(Set)
+
+      set_of_arrays?
+      set_of_arrays_of_integers?
+    end
+
+    def clusters(tiles_x_y: @tiles_x_y)
+      service = SlippyTilesScorer::Cluster.new(tiles_x_y: tiles_x_y)
+      result = service.clusters
+      result[:clusters_of_cluster_tiles] =
+        SlippyTilesScorer::Cluster.new(tiles_x_y: result[:cluster_tiles]).clusters[:clusters]
+      result
+    end
+
+    def max_square(x:, y:, tiles_x_y: @tiles_x_y) # rubocop:disable Naming/MethodParameterName
+      SlippyTilesScorer::MaxSquare.new(tiles_x_y: tiles_x_y).max_square(x: x, y: y)
+    end
+
+    def max_squares(tiles_x_y: @tiles_x_y, min_size: 3)
+      SlippyTilesScorer::MaxSquare.new(tiles_x_y: tiles_x_y).max_squares(min_size: min_size)
+    end
+
+    def steps_fulfilled?(x:, y:, steps:) # rubocop:disable Naming/MethodParameterName
+      SlippyTilesScorer::MaxSquare.new(tiles_x_y: @tiles_x_y).steps_fulfilled?(x: x, y: y, steps: steps)
+    end
+
+    def visited(tiles_x_y: @tiles_x_y)
+      tiles_x_y.size
+    end
+
+    private
+
+    def set_of_arrays?
+      return if @tiles_x_y.all? { |point| point.is_a?(Array) && point.size == 2 }
+
+      raise ArgumentError, "each point must be an array with two elements"
+    end
+
+    def set_of_arrays_of_integers?
+      return if @tiles_x_y.all? { |point| point.all? { |coord| coord.is_a?(Integer) } }
+
+      raise ArgumentError, "each point must be an array with two integers"
+    end
+  end
+end

data/sig/slippy_tiles_scorer.rbs

@@ -0,0 +1,4 @@
+module SlippyTilesScorer
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: slippy_tiles_scorer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Simon Neutert
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-11-25 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.
+email:
+- simonneutert@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- CHANGELOG.md
+- README.md
+- Rakefile
+- lib/slippy_tiles_scorer.rb
+- lib/slippy_tiles_scorer/cluster.rb
+- lib/slippy_tiles_scorer/max_square.rb
+- lib/slippy_tiles_scorer/version.rb
+- sig/slippy_tiles_scorer.rbs
+homepage: https://github.com/simonneutert/slippy_tiles_scorer
+licenses: []
+metadata:
+  homepage_uri: https://github.com/simonneutert/slippy_tiles_scorer
+  source_code_uri: https://github.com/simonneutert/slippy_tiles_scorer
+  changelog_uri: https://github.com/simonneutert/slippy_tiles_scorer/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: A gem to score a set of slippy tiles.
+test_files: []