trollio_maps 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 92688303a3b5c3353ac85142ccd4a61b17a22ad0c5889ccdac2e85252bcc3b71
+  data.tar.gz: f23a95aa6540a93d639e58bb6a0c26c995c691d388782922af1d504c83fe874f
+SHA512:
+  metadata.gz: 39f419c0b08bceeedb88b44fe70767a653e878a1f3e42c9b362ac1b98547ccf9eaac0b4ef571f73948ea9281a06340e60a24dd6e5b2d0a3c9828158891716648
+  data.tar.gz: d919e1909473b20332e170c31c3c3796f67e8a2d8e238d80c4fe167d94a9e4c935c2812d973dac5cf7c5b09a4b998a499affd2676856af135109fb43a9dd9224

data/.gitignore

@@ -0,0 +1 @@
+src/map/layers/downloads/

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://www.rubygems.org"
+
+gem "rest-client"
+gem "hokusai-zero", "0.1.9"

data/Gemfile.lock

@@ -0,0 +1,73 @@
+GEM
+  remote: https://www.rubygems.org/
+  specs:
+    concurrent-ruby (1.3.5)
+    domain_name (0.6.20240107)
+    ffi (1.17.2)
+    ffi (1.17.2-aarch64-linux-gnu)
+    ffi (1.17.2-aarch64-linux-musl)
+    ffi (1.17.2-arm-linux-gnu)
+    ffi (1.17.2-arm-linux-musl)
+    ffi (1.17.2-arm64-darwin)
+    ffi (1.17.2-x86-linux-gnu)
+    ffi (1.17.2-x86-linux-musl)
+    ffi (1.17.2-x86_64-darwin)
+    ffi (1.17.2-x86_64-linux-gnu)
+    ffi (1.17.2-x86_64-linux-musl)
+    hokusai-zero (0.1.9)
+      concurrent-ruby (~> 1.3.4)
+      ffi (~> 1.16)
+      memory_profiler
+      mini_portile2
+      raylib-bindings (~> 0.7.9)
+      sdl2-bindings (~> 0.2.3)
+    http-accept (1.7.0)
+    http-cookie (1.0.8)
+      domain_name (~> 0.5)
+    logger (1.7.0)
+    memory_profiler (1.1.0)
+    mime-types (3.7.0)
+      logger
+      mime-types-data (~> 3.2025, >= 3.2025.0507)
+    mime-types-data (3.2025.0520)
+    mini_portile2 (2.8.9)
+    netrc (0.11.0)
+    raylib-bindings (0.7.12)
+      ffi (~> 1.16)
+    raylib-bindings (0.7.12-aarch64-linux)
+      ffi (~> 1.16)
+    raylib-bindings (0.7.12-arm64-darwin)
+      ffi (~> 1.16)
+    raylib-bindings (0.7.12-x86_64-darwin)
+      ffi (~> 1.16)
+    raylib-bindings (0.7.12-x86_64-linux)
+      ffi (~> 1.16)
+    rest-client (2.1.0)
+      http-accept (>= 1.7.0, < 2.0)
+      http-cookie (>= 1.0.2, < 2.0)
+      mime-types (>= 1.16, < 4.0)
+      netrc (~> 0.8)
+    sdl2-bindings (0.2.3)
+      ffi (~> 1.15)
+
+PLATFORMS
+  aarch64-linux
+  aarch64-linux-gnu
+  aarch64-linux-musl
+  arm-linux-gnu
+  arm-linux-musl
+  arm64-darwin
+  ruby
+  x86-linux-gnu
+  x86-linux-musl
+  x86_64-darwin
+  x86_64-linux
+  x86_64-linux-gnu
+  x86_64-linux-musl
+
+DEPENDENCIES
+  hokusai-zero (= 0.1.9)
+  rest-client
+
+BUNDLED WITH
+   2.6.8

data/README.md

@@ -0,0 +1,5 @@
+# Trollio Maps
+
+# Map component for Hokusai
+
+![](./mapreversegeocode.gif)

data/bin/trollio-maps

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+require 'mini_portile2'
+require "pathname"
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+if MiniPortile.darwin?
+  ENV["RAYLIB_PATH"] = "libraylib.dylib"
+elsif MiniPortile.linux?
+  ENV["RAYLIB_PATH"] = "libraylib.so"
+elsif MiniPortile.windows?
+  ENV["RAYLIB_PATH"] = "raylib.dll"
+end
+
+require_relative "../src/map"
+
+Hokusai::Backends::RaylibBackend.run(App) do |config|
+  config.title = "Trollio Maps"
+  config.width = 800
+  config.height = 800
+
+  config.after_load do
+    pp TrollioConfig.asset("Inter-Regular.ttf")
+    Hokusai.fonts.register "inter", Hokusai::Backends::RaylibBackend::Font.from(TrollioConfig.asset("Inter-Regular.ttf"))
+    Hokusai.fonts.activate "inter"
+  end
+end
+
+

data/src/config.rb

@@ -0,0 +1,13 @@
+require "pathname"
+
+class TrollioConfig
+  class << self
+    def assets_path
+      Pathname.new(__dir__).join("..").join("assets")
+    end
+
+    def asset(name)
+      assets_path.join(name).to_s
+    end
+  end
+end

data/src/map/control.rb

@@ -0,0 +1,79 @@
+module Mapa
+  class Control < Hokusai::Block
+    style <<~EOF
+    [style]
+    container {
+      background: rgb(206, 206, 206);
+      outline: outline(1.0, 1.0, 1.0, 1.0);
+      outline_color: rgb(136, 136, 136);
+      rounding: 0.2;
+    }
+
+    border {
+      outline: outline(0.0, 0.0, 1.0, 0.0);
+      outline_color: rgb(136, 136, 136);
+    }
+
+    zoomIn {
+      content: "+";
+      size: 20;
+      padding: padding(10.0, 0.0, 0.0, 12.5);
+    }
+
+    zoomOut {
+      content: "-";
+      size: 20;
+      padding: padding(10.0, 0.0, 0.0, 12.5);
+    }
+    EOF
+    
+    template <<~EOF
+    [template]
+      vblock {
+        @mousedown="stop"
+        @mouseup="stop"
+        ...container
+      }
+        rect.zoomin {
+          @click="emit_zoom_in"
+          ...border
+        }
+          label { ...zoomIn }
+        rect.zoomout {
+          @click="emit_zoom_out"
+        }
+          label { ...zoomOut }
+    EOF
+
+    uses(
+      vblock: Hokusai::Blocks::Vblock,
+      rect: Hokusai::Blocks::Rect,
+      label: Hokusai::Blocks::Label
+    )
+
+    def stop(event)
+      # pp ["stopping", event.captures.map(&:class)]
+      event.stop
+    end
+
+    def emit_zoom_in(event)
+      pp ["clicked zoomin"]
+      event.stop
+      emit("zoomin")
+    end
+
+    def emit_zoom_out(event)
+      pp ["clicked zoomout"]
+      event.stop
+      emit("zoomout")
+    end
+
+    def render(canvas)
+      canvas.x += 10.0
+      canvas.y += 10.0
+      canvas.width = 35.0
+
+      yield canvas
+    end
+  end
+end

data/src/map/error.rb

@@ -0,0 +1,3 @@
+module Mapa
+  class Error < ::StandardError; end
+end

data/src/map/geo/crs/EPSG3857.rb

@@ -0,0 +1,18 @@
+require_relative "./earth"
+
+module Mapa
+  class EPSG3857 < Earth
+    class << self
+      def projection
+        SphericalMercator
+      end
+
+      def transformation
+        @transformation ||= begin
+          scale = 0.5 / (Math::PI * SphericalMercator::R)
+          Transformation.new(scale, 0.5, -scale, 0.5)
+        end
+      end
+    end
+  end
+end

data/src/map/geo/crs/earth.rb

@@ -0,0 +1,25 @@
+module Mapa
+  class Earth < CRS
+    WRAP_LNG = [-180, 180]
+    R = 6371000
+
+    class << self
+      def distance(a, b)
+        rad = Math::PI / 180
+        lat1 = a.lat * rad
+        lat2 = b.lat * rad
+
+        sin_d_lat = Math.sin((b.lat - a.lat) * rad / 2)
+        sin_d_lon = Math.sin((b.lng - a.lng) * rad / 2)
+
+        a = sin_d_lat * sin_d_lat + Math.cos(lat1) * Math.cos(lat2) * sin_d_lon * sin_d_lon
+        c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a))
+
+        Earth::R * c
+      end
+
+      def wrap_lat_lng(latlng)
+      end
+    end
+  end
+end

data/src/map/geo/crs.rb

@@ -0,0 +1,51 @@
+module Mapa
+  class CRS
+    class << self
+      def get(code)
+        {
+          "EPSG3857" => EPSG3857,
+        }
+      end
+
+      def lat_lng_to_point(latlng, zoom)
+        point = projection.project(latlng)
+        scale = scale(zoom)
+
+        transformation.transform(point, scale)
+      end
+
+      def point_to_lat_lng(point, zoom)
+        scale = scale(zoom)
+        untransformed = transformation.untransform(point, scale)
+
+        projection.unproject(untransformed)
+      end
+
+      def project(latlng)
+      end
+
+      def unproject(point)
+      end
+
+      def scale(zoom)
+        256 * 2 ** zoom;
+      end
+
+      def zoom(scale)
+      end
+
+      def projected_bounds(zoom)
+        b = projection.bounds
+        s = scale(zoom)
+        min = transformation.transform(b.min, s)
+        max = transformation.transform(b.max, s)
+        Bounds.new(min, max)
+      end
+
+      def wrap_lat_lng(latlng)
+      end
+    end
+  end
+end
+
+require_relative "./crs/EPSG3857"

data/src/map/geo/lat_lng.rb

@@ -0,0 +1,57 @@
+require "json"
+
+module Mapa
+  class LatLng
+    def self.from(array)
+      new(array[0], array[1])
+    end
+
+    attr_accessor :lat, :lng, :alt
+    
+    def initialize(lat, lng, altitude = nil)
+      @lat = lat
+      @lng = lng
+      @alt = altitude
+    end
+
+    def ==(latlng, max_margin = nil)
+      margin = [(lat - latlng.lat).abs, (lng - latlng.lng).abs].max
+
+      margin <= (max_margin || 1.0E-9)
+    end
+
+    def reverse_geo
+      pp ["latlng", lat, lng]
+      body = JSON.parse(RestClient.get("https://geoffrey.skinnyjames.net/api/v1/us/reverse-geocode?lat=#{lat}&lng=#{lng}").body, symbolize_names: true)
+      body[0]
+    end
+
+    def to_point(crs, zoom)
+      crs.lat_lng_to_point(self, zoom)
+    end
+
+    def to_s(precision = 4)
+      "LatLng(#{lat.round(precision)}, #{lng.round(precision)})"
+    end
+
+    def distance_to(other)
+      Earth.distance(self, other)
+    end
+
+    def wrap
+      Earth.wrap_lat_lng(self)
+    end
+
+    def to_bounds(meters)
+      lat_accuracy = 100 * meters / 40075017
+      lng_accuracy = lat_accuracy / Math.cos((Math::PI / 180) * lat)
+
+      LatLngBounds.new(
+        lat - lat_accuracy, 
+        lng - lng_accuracy,
+        lat + lat_accuracy,
+        lng + lng_accuracy
+      )
+    end
+  end
+end

data/src/map/geo/lat_lng_bounds.rb

@@ -0,0 +1,59 @@
+module Mapa
+  class LatLngBounds
+    attr_accessor :south_west, :north_east
+
+    def initialize(bl, tr)
+      sw_lat = bl.is_a?(Array) ? bl[0] : bl.lat
+      sw_lng = tr.is_a?(Array) ? bl[1] : bl.lng
+      ne_lat = bl.is_a?(Array) ? tr[0] : tr.lat
+      ne_lng = tr.is_a?(Array) ? tr[1] : tr.lng
+
+      @south_west = LatLng.new(sw_lat, sw_lng)
+      @north_east = LatLng.new(ne_lat, ne_lng)
+    end
+
+    def pad(buffer_ratio)
+      height_buffer = Math.abs(south_west.lat - north_east.lat) * buffer_ratio
+      width_buffer = Math.abs(south_west.lng - north_east.lng) * buffer_ratio
+
+      LatLngBounds.new(
+        LatLng.new(south_west.lat - height_buffer, south_west.lng - width_buffer),
+        LatLng.new(north_east.lat + height_buffer, north_east.lng + width_buffer)
+      )
+    end
+
+    def center
+      LatLng.new(
+        (south_west.lat + north_east.lat) / 2,
+        (south_west.lng + north_east.lng) / 2
+      )
+    end
+
+    def north_west
+      LatLng.new(north_east.lat, south_west.lng)
+    end
+
+    def south_east
+      LatLng.new(south_west.lat, north_east.lng)
+    end
+
+    def contains(obj)
+      case obj
+      when LatLng
+        (obj.lat >= south_west.lat) && (obj.lat <= north_east.lat) &&
+        (obj.lng >= south_west.lng) && (obj.lng <= north_east.lng)
+      when LatLngBounds
+        (obj.south_west.lat >= south_west.lat) && (obj.north_east.lat <= north_east.lat) &&
+        (obj.south_west.lng >= south_west.lng) && (obj.south_west.lng <= north_east.lng)
+      else
+        raise Error.new("Must pass LatLng or LatLngBounds")
+      end
+    end
+
+    def intersects(bounds)
+    end
+
+    def overlaps(bounds)
+    end
+  end
+end

data/src/map/geo/projections/spherical_mercator.rb

@@ -0,0 +1,32 @@
+module Mapa
+  class SphericalMercator
+    R = 6378137
+    MAX_LATITUDE = 85.0511287798
+
+    class << self
+      def project(latlng)
+        d = Math::PI / 180
+        lat = [[MAX_LATITUDE, latlng.lat].min, -MAX_LATITUDE].max
+        sin = Math.sin(lat * d)
+
+        Point.new(
+          SphericalMercator::R * latlng.lng * d,
+          SphericalMercator::R * Math.log((1 + sin) / (1 - sin)) / 2)
+      end
+
+      def unproject(point)
+        d = 180 / Math::PI
+
+        LatLng.new(
+          (2 * Math.atan(Math.exp(point.y / SphericalMercator::R)) - (Math::PI / 2)) * d,
+          point.x * d / R
+        )
+      end
+
+      def bounds
+        d = MAX_LATITUDE * Math::PI
+        Bounds.new([-d,-d], [d, d])
+      end
+    end
+  end
+end

data/src/map/geo.rb

@@ -0,0 +1,4 @@
+require_relative "./geo/projections/spherical_mercator"
+require_relative "./geo/crs"
+require_relative "./geo/lat_lng"
+require_relative "./geo/lat_lng_bounds"

data/src/map/geometry/bounds.rb

@@ -0,0 +1,101 @@
+module Mapa
+  class Bounds
+    attr_accessor :min, :max
+
+    def initialize(tl, br)
+      min_x = tl.is_a?(Array) ? tl[0] : tl.x
+      max_x = br.is_a?(Array) ? br[0] : br.x
+      min_y = tl.is_a?(Array) ? tl[1] : tl.y
+      max_y = br.is_a?(Array) ? br[1] : br.y
+
+      @min = Point.new(min_x, min_y)
+      @max = Point.new(max_x, max_y)
+    end
+
+    def extend(point_or_bounds)
+      case point_or_bounds
+      when Point
+        self.min.x = [point_or_bounds.x, min.x].min
+        self.min.y = [point_or_bounds.y, min.y].min
+        self.max.x = [point_or_bounds.x, max.x].max
+        self.max.y = [point_or_bounds.y, max.y].max
+      when Bounds
+        self.min.x = [point_or_bounds.min.x, min.x].min
+        self.min.y = [point_or_bounds.min.y, min.y].min
+        self.max.x = [point_or_bounds.max.x, max.x].max
+        self.max.y = [point_or_bounds.max.y, max.y].max  
+      else
+        raise Error.new("Extends requires a Point or Bounds")
+      end
+    end
+
+    def to_lat_lng_bounds(crs, zoom)
+      pp [crs.point_to_lat_lng(min, zoom), min]
+
+      tl = crs.point_to_lat_lng(min, zoom)
+      br = crs.point_to_lat_lng(max, zoom)
+
+      sw = LatLng.new(tl.lat, br.lng)
+      ne = LatLng.new(br.lat, tl.lng)
+      LatLngBounds.new(sw, ne)
+    end
+
+    def center(round = false)
+      Point.new(
+        (min.x + max.x) / 2,
+        (min.y + max.y )/ 2,
+        round
+      )
+    end
+
+    def bottom_left
+      Point.new(min.x, max.y)
+    end
+
+    def top_right
+      Point.new(max.x, min.y)
+    end
+
+    def top_left
+      min
+    end
+
+    def bottom_right
+      max
+    end
+
+    def size
+      max - min
+    end
+
+    def contains(point_or_bounds)
+      case point_or_bounds
+      when Point
+        (point_or_bounds.x >= min.x) &&
+        (point_or_bounds.x <= max.x) && 
+        (point_or_bounds.y >= min.y) &&
+        (point_or_bounds.y <= max.y) 
+      when Bounds
+        (point_or_bounds.min.x >= min.x) &&
+        (point_or_bounds.max.x <= max.x) && 
+        (point_or_bounds.min.y >= min.y) &&
+        (point_or_bounds.max.y <= max.y) 
+      else
+        raise Error.new("contains requires a Point or Bounds")
+      end
+    end
+
+    def intersects(bounds)
+    end
+
+    def overlaps(bounds)
+    end
+
+    def pad(buffer)
+    end
+
+    def ==(bounds)
+      min == bounds.top_left && max == bounds.bottom_right
+    end
+  end
+end

data/src/map/geometry/bounds_collection.rb

@@ -0,0 +1,61 @@
+module Mapa
+  class BoundsProxy
+    attr_reader :map, :screen
+
+    def initialize(screen, map)
+      @map = map
+      @screen = screen
+    end
+
+    def top_left
+      screen.top_left
+    end
+
+    def bottom_right
+      screen.bottom_right
+    end
+  end
+
+  class BoundsProxyCollection
+    include Enumerable
+
+    attr_reader :bounds
+
+    attr_accessor :offset
+    
+    def initialize
+      @bounds = []
+      @offset = Point.new(0, 0)
+    end
+
+    def each
+      bounds.each do |b|
+        yield b
+      end
+    end
+
+    def <<(proxy)
+      @bounds << proxy
+    end
+
+    def top_left
+      bounds.map(&:top_left).min
+    end
+
+    def bottom_right
+      bounds.map(&:bottom_right).max
+    end
+
+    def map_contains(point)
+      bounds.find do |b|
+        b.map.contains(point)
+      end
+    end
+
+    def contains(point)
+      bounds.find do |b|
+        b.screen.contains(point)
+      end
+    end
+  end
+end