trollio_maps 0.1.0

data/src/map/geometry/point.rb

@@ -0,0 +1,105 @@
+module Mapa
+  class Point
+    include Comparable
+
+    def self.convert(str)
+      case str
+      when String
+        coords = str.gsub(/\[|\]/, '').split(",").map(&:to_f)
+        new(coords[0], coords[1])
+      when Array
+        new(str[0], str[1])
+      end
+    end
+
+    def valid?(x, y)
+      true
+    end
+
+    attr_accessor :x, :y
+
+    def initialize(x, y, round = false)
+      raise Error.new("Invalid point") unless valid?(x, y)
+
+      @x = round ? x.round : x
+      @y = round ? y.round : y
+    end
+
+    def add!(point)
+      self.x += point.x
+      self.y += point.y
+
+      self
+    end
+
+    def <=>(point)
+      if x < point.x && y < point.y
+        -1
+      elsif x >  point.x && y > point.y
+        1
+      else
+        0
+      end
+    end
+
+    def +(point)
+      Point.new(x + point.x, y + point.y)
+    end
+
+    def -(point)
+      Point.new(x - point.x, y - point.y)
+    end
+
+    def subtract(num)
+      Point.new(x - num, y - num)
+    end
+
+    def /(num)
+      Point.new(x / num.x, y / num.y)
+    end
+
+    def *(num)
+      Point.new(x * num.x, y * num.y)
+    end
+
+    def scale(point)
+      Point.new(x * point.x, y * point.y)
+    end
+
+    def unscale(point)
+      Point.new(x / point.x, y / point.y)
+    end
+
+    def round
+      Point.new(x.round, y.round)
+    end
+
+    def floor
+      Point.new(x.floor, y.floor)
+    end
+
+    def ceil
+      Point.new(x.ceil, y.ceil)
+    end
+
+    def distance_to(point)
+      xx = point.x - x
+      yy = point.y - y
+
+      Math.sqrt(xx ** xx + yy ** yy)
+    end
+
+    def ==(point)
+      point.x == x && point.y == y
+    end
+
+    def contains(point)
+      Math.abs(point.x) <= Math.abs(x) &&
+        Math.abs(point.y) <= Math.abs(y)
+    end
+
+    def to_s
+      "Point(#{x}, #{y})"
+    end
+  end
+end

data/src/map/geometry/tile_bounds.rb

@@ -0,0 +1,110 @@
+module Mapa
+  class TileBounds
+    TILE_SIZE = 256
+
+    attr_reader :center, :screen_bounds, :crs
+    attr_accessor :drag_offset, :screen_bounds, :center
+
+    def initialize(crs, latlng, screen_bounds)
+      @crs = crs
+      @center = latlng
+      @screen_bounds = screen_bounds
+      @tiles = {}
+      @drag_offset = Point.new(0, 0)
+    end
+
+    def geo_bounds(bounds, zoom)
+      bounds.to_lat_lng_bounds(crs, zoom)  
+    end
+
+    def offset(zoom)
+      collection(zoom).offset
+    end
+
+    def coords_at(point, zoom)
+      collection = collection(zoom)
+      tile = collection.contains(point)
+      offset = collection.offset
+
+      point.x = point.x - tile.screen.center.x + offset.x
+      point.y = point.y - tile.screen.center.y + offset.y
+
+      # click point x / screen width = ratio
+      nx = (point.x) / (tile.screen.max.x - tile.screen.min.x)
+      # click poidnt y / screen_height = ratio
+      ny = (point.y) / (tile.screen.max.y - tile.screen.min.y)
+
+      mbx = (tile.map.max.x - tile.map.min.x) * nx
+      mby = (tile.map.max.y - tile.map.min.y) * ny
+
+      ax = (tile.map.min.x + mbx)
+      ay = (tile.map.min.y + mby)
+
+      x = Point.new(ax, ay)
+      crs.point_to_lat_lng(x, zoom)
+    end
+
+
+    def collection(zoom)
+      collection = BoundsProxyCollection.new
+      tile_center = crs.lat_lng_to_point(center, zoom)
+      screen_center = screen_bounds.center + drag_offset
+
+      offx = tile_center.x.modulo(1)
+      offy = tile_center.y.modulo(1)
+
+      collection.offset = Point.new(offx * TILE_SIZE, offy * TILE_SIZE)
+
+      sx = screen_center.x
+      sy = screen_center.y
+
+      tile_center = tile_center.floor
+      mx = tile_center.x
+      my = tile_center.y
+
+      tp = Point.new(TILE_SIZE, TILE_SIZE)
+      mp = Point.new(1, 1)
+
+      # find top left...
+      tl = Point.new(screen_center.x - (TILE_SIZE / 2), screen_center.y - (TILE_SIZE / 2))
+      mtl = Point.new(tile_center.x, tile_center.y)
+
+      while tl.x >= screen_bounds.min.x || tl.y >= screen_bounds.min.y
+        tl = tl - tp
+        mtl = mtl - mp
+      end
+      
+      sx = tl.x
+      sy = tl.y
+      mx = mtl.x
+      my = mtl.y
+
+      # populate tiles
+      while sx <= screen_bounds.max.x + TILE_SIZE
+        sy = tl.y
+        my = mtl.y
+
+        while sy <= screen_bounds.max.y + TILE_SIZE
+          sb = Bounds.new(
+            Point.new(sx, sy),
+            Point.new(sx + tp.x, sy + tp.y)
+          )
+
+          mb = Bounds.new(
+            Point.new(mx, my),
+            Point.new(mx + mp.x, my + mp.y)
+          )
+
+          collection << BoundsProxy.new(sb, mb)
+          my += 1
+          sy += TILE_SIZE
+        end
+
+        mx += 1
+        sx += TILE_SIZE
+      end
+
+      collection
+    end
+  end
+end

data/src/map/geometry/transform.rb

@@ -0,0 +1,26 @@
+module Mapa
+  class Transformation
+    attr_reader :a, :b, :c, :d
+
+    def initialize(a, b, c, d)
+      @a = a
+      @b = b
+      @c = c
+      @d = d
+    end
+
+    def transform(point, scale = 1)
+      Point.new(
+        scale * (a * point.x + b),
+        scale * (c * point.y + d)
+      )
+    end
+
+    def untransform(point, scale = 1)
+      Point.new(
+        (point.x / scale - b) / a,
+        (point.y / scale - d) / c
+      )
+    end
+  end
+end

data/src/map/geometry.rb

@@ -0,0 +1,5 @@
+require_relative "./geometry/bounds"
+require_relative "./geometry/point"
+require_relative "./geometry/transform"
+require_relative "./geometry/bounds_collection"
+require_relative "./geometry/tile_bounds"

data/src/map/layers/marker_layer.rb

@@ -0,0 +1,30 @@
+module Mapa
+  class MarkerLayer < Hokusai::Block
+    template <<~EOF
+    [template]
+      virtual
+    EOF
+
+    computed :marker, default: nil
+
+    inject :zoom
+    inject :center
+    inject :container_size
+    inject :tile_bounds
+
+    def on_mounted
+      node.meta.set_prop(:z, "3")
+      node.meta.set_prop(:ztarget, "parent")
+    end
+
+    def render(canvas)
+      return if marker.nil?
+
+      draw do
+        circle(marker.x, marker.y, 5) do |command|
+          command.color = Hokusai::Color.new(44, 68, 224)
+        end
+      end
+    end
+  end
+end

data/src/map/layers/tile_layer.rb

@@ -0,0 +1,176 @@
+require "fileutils"
+require "rest-client"
+module Mapa
+  class TileLayer < Hokusai::Block
+    template <<~EOF
+    [template]
+      empty {
+        @mousedown="start_drag"
+        @mousemove="drag"
+        @mouseup="end_drag"
+      }
+    EOF
+
+    uses(
+      empty: Hokusai::Blocks::Empty
+    )
+
+    computed! :url
+    computed :tile_size, default: 256, convert: proc(&:to_i)
+    computed :min_zoom, default: 0, convert: proc(&:to_i)
+    computed :max_zoom, default: 18, convert: proc(&:to_i)
+    computed :subdomains, default: ['a', 'b', 'c']
+    computed :error_tile_url, default: ''
+    computed :zoom_offset, default: 9, convert: proc(&:to_i)
+    computed :tms, default: false
+    computed :zoom_reverse, default: false
+    computed :detect_retina, default: false
+    computed :cross_origin, default: false
+    computed :referrer_policy, default: false
+
+    inject :zoom
+    inject :center
+    inject :container_size
+    inject :tile_bounds
+
+    attr_reader :tiles, :levels, :size, :update_interval, :dragging
+
+    def initialize(**args)
+      super
+
+      @tiles = {}
+      @dragging = false
+      @drag_start = nil
+    end
+
+    def start_drag(event)
+      pp ["Started drag"]
+      if !@dragging && event.left.down
+        @dragging = true
+        @drag_start = Point.new(event.pos.x, event.pos.y)
+      end
+    end
+
+    def drag(event)
+      if event.left.down && dragging
+        tile_bounds.drag_offset = Point.new(event.pos.x, event.pos.y) - @drag_start
+        # @last = tile_bounds.coords_at(tile_bounds.screen_bounds.center, zoom)
+      end
+    end
+
+    def end_drag(event)
+      if dragging && event.left.up
+        @dragging = false
+        if tile_bounds.drag_offset.x > 5 || tile_bounds.drag_offset.y > 5
+
+          collection = tile_bounds.collection(zoom)
+          off = tile_bounds.drag_offset
+
+          pp [collection.offset]
+
+          c = tile_bounds.screen_bounds.center
+
+
+
+          center = tile_bounds.coords_at(c, zoom)
+
+          pp ["unset drag offset",  center]
+
+
+          tile_bounds.drag_offset = Point.new(0, 0)
+          tile_bounds.center = center
+
+          emit("update", center)
+        end
+        
+        @drag_start = nil
+      end
+    end
+
+    def downloads
+      FileUtils.mkdir_p "#{__dir__}/downloads"
+
+      "#{__dir__}/downloads"
+    end
+
+    def fetch_download(url)
+      path = "#{downloads}/#{url.gsub("/", "-")}"
+
+      if File.exist?(path)
+        @tiles[url] = path
+        path
+      else
+        Thread.new do
+          block = proc do |res|
+            File.open(path, "wb") do |io|
+              res.read_body do |chunk|
+                io.write chunk
+              end
+            end
+
+            @tiles[url] = path
+
+          end
+
+          RestClient::Request.execute(method: :get, url: url, block_response: block)
+        end
+        nil
+      end
+    end
+
+    def subdomain(coords)
+      index = (coords.x + coords.y % subdomains.size).abs
+      subdomains[index]
+    end
+
+    def zoom_for_url
+      if zoom_reverse
+        max_zoom - zoom
+      else
+        zoom + zoom_offset
+      end
+    end
+
+    # https://{s}.somedomain.com/blabla/{z}/{x}/{y}{r}.png'
+    def tile_url(coords)
+      opts = {
+        s: subdomain(coords),
+        z: zoom_for_url,
+        x: coords.x.to_i,
+        y: coords.y.to_i,
+        r: ''
+      }
+
+      url.gsub(/\{ *([\w_ -]+) *\}/) do |match|
+        opts[match[1].to_sym]
+      end    
+    end
+
+    def before_updated
+      if @throttled
+        if (Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) - @ttime)  > 200
+          @throttled = false
+        end 
+      end
+    end
+
+    def render(canvas)
+      # @canvas = canvas
+      collection = tile_bounds.collection(zoom)
+      offx = collection.offset.x
+      offy = collection.offset.y
+
+
+      draw do
+        collection.each_with_index do |item, i|
+          # next if i.odd?
+          if file = fetch_download(tile_url(item.map.center))
+            image(file, item.screen.center.x - offx, item.screen.center.y - offy, tile_size, tile_size)
+          end
+        end
+      end
+
+      yield canvas
+    end
+  end
+end

data/src/map/layers.rb

@@ -0,0 +1,2 @@
+require_relative "./layers/tile_layer"
+require_relative "./layers/marker_layer"

data/src/map.rb

@@ -0,0 +1,239 @@
+require "hokusai"
+require "hokusai/backends/raylib"
+require_relative "./map/error"
+require_relative "./map/geo"
+require_relative "./map/layers"
+require_relative "./map/geometry"
+require_relative "./map/control"
+require_relative "./config"
+
+module Mapa
+  class Map < Hokusai::Block
+    template <<~EOF
+    [template]
+      vblock
+        slot
+    EOF
+
+    uses(vblock: Hokusai::Blocks::Vblock)
+
+    attr_reader :size
+    attr_accessor :sdrag
+  
+    provide :zoom, :zoom
+    provide :center, :center
+    provide :container_size, :size
+    provide :tile_bounds, :tile_bounds
+
+    computed! :center
+    computed :crs, default: "EPSG3857"
+    computed :zoom, default: 1
+    computed :min_zoom, default: nil
+    computed :max_zoom, default: nil
+    computed :update_center, default: nil
+
+    def before_updated
+      if update_center
+        @bounds = TileBounds.new(Mapa::EPSG3857, update_center, size)
+        emit("clear_update_center")
+      end
+    end
+
+    def start_drag(event)
+      if event.left.down && !@started
+        self.sdrag = [event.pos.x.clone, event.pos.y.clone]
+        @started = true
+      end
+    end
+
+    def on_resize(canvas)
+      @size = Bounds.new([canvas.x, canvas.y], [canvas.x + canvas.width, canvas.y + canvas.height])
+      @bounds = TileBounds.new(Mapa::EPSG3857, center, size)
+    end
+
+    def center_point
+      Mapa::EPSG3857.lat_lng_to_point(center, zoom)
+    end
+
+    def alert_latlng(event)
+      if sdrag && ((event.pos.x - sdrag[0]).abs > 5 || (event.pos.y - sdrag[1]).abs > 5)
+        @started = false
+        self.sdrag = nil
+        return
+      end
+    
+      if event.left.released
+        point = Point.new(event.pos.x, event.pos.y)
+        clicked = Point.new(event.pos.x, event.pos.y)
+        emit("change", tile_bounds.coords_at(point, zoom), clicked)
+        @started = false
+      end
+    end
+
+    def tile_bounds
+      @bounds ||= TileBounds.new(Mapa::EPSG3857, center, size)
+    end
+
+    def render(canvas)
+      if @size.nil?
+        on_resize(canvas)
+      end
+
+      yield canvas
+    end
+  end
+end
+
+class App < Hokusai::Block
+  style <<~EOF
+  [style]
+    tileStyle {
+      url: "https://tile.openstreetmap.org/{z}/{x}/{y}.png";
+      zoom_offset: 8;
+    }
+    box {
+      background: rgb(48, 48, 48);
+      height: 100.0;
+      padding: padding(20.0, 0.0, 30.0, 0.0);
+    }
+
+    input {
+      background: rgb(255,255,255);
+      color: rgb(22,22,22);
+      padding: padding(5.0, 15.0, 5.0, 15.0);
+      outline: outline(1.0, 1.0, 1.0, 1.0)
+      outline_color: rgb(33,33,33);
+      height: 50.0;
+      rounding: 0.2;
+    }
+
+    label {
+      color: rgb(255,255,255);
+    }
+
+    zstyle {
+      z: 2;
+      ztarget: "parent";
+      reverse: true;
+    }
+  EOF
+
+  template <<~EOF
+  [template]
+    vblock
+      map {
+        @change="update_latlng"
+        @clear_update_center="clear_update_center"
+        :update_center="update_center"
+        cursor="pointer"
+        :center="center"
+        :zoom="zoom"
+      }
+        tile_layer {
+          ...tileStyle 
+        }
+        marker_layer {:marker="marker"}
+    hblock { ...zstyle }
+      control { 
+        @zoomin="zoom_in"
+        @zoomout="zoom_out"
+        :height="80.0" :width="65.0"
+      }
+      empty
+      vblock { padding="10.0,0.0,0.0,10.0"}
+        input { @mousedown="stop" @change="search" ...input }
+  EOF
+
+  uses(
+    hblock: Hokusai::Blocks::Hblock,
+    vblock: Hokusai::Blocks::Vblock,
+    label: Hokusai::Blocks::Label,
+    input: Hokusai::Blocks::Input,
+    empty: Hokusai::Blocks::Empty,
+    control: Mapa::Control,
+    button: Hokusai::Blocks::Button,
+    map: Mapa::Map,
+    tile_layer: Mapa::TileLayer,
+    marker_layer: Mapa::MarkerLayer
+  )
+
+  attr_reader :drag_offset, :update_center
+
+  def stop(event)
+    event.stop
+  end
+
+  def point
+    @point || "no point"
+  end
+
+  def initialize(**args)
+    super
+
+    @dragging = false
+  end
+
+  def marker
+    @marker
+  end
+
+  def search(term)
+    begin
+    res = JSON.parse RestClient.get("https://geoffrey.skinnyjames.net/api/v1/us/geocode/#{CGI.escapeURIComponent(term)}").body, symbolize_names: true
+      res = res.first
+      pp res
+      @update_center = Mapa::LatLng.new(res[:latitude], res[:longitude])
+      @marker = Mapa::Point.new(400, 400)
+    rescue
+      pp ["point can't be located"]
+    end
+  end
+
+  def update_latlng(latlng, point)
+    pp ["changing"]
+    @marker = point.clone
+    add = latlng.reverse_geo
+    @point = <<~EOF
+    #{latlng}
+    #{add[:address_number]} #{add[:street_name]} #{add[:street_posttype]}
+    #{add[:postal_community]}, #{add[:state]} #{add[:zip_code]}
+    EOF
+  end
+  
+  def clear_update_center
+    @update_center = nil
+  end
+
+  def zoom_out
+    @marker = nil
+    @zoom -= 1
+  end
+
+  def zoom
+    @zoom ||= 1
+  end
+
+  def center
+    @center ||= Mapa::LatLng.new(39.9612, -82.9988)
+  end
+
+  def zoom_in
+    @marker = nil
+
+    @zoom += 1
+  end
+end
+#
+# 1 = 9
+# 2 = 10
+# 3 = 11
+#
+#
+
+# latlng = Mapa::LatLng.new(39.9612, -82.9988)
+# point = Mapa::EPSG3857.lat_lng_to_point(latlng, 4)
+# new_lat_lng = Mapa::EPSG3857.point_to_lat_lng(point, 4)
+
+# map = Mapa::EPSG3857
+
+# pp map.projection.project(map.projection.unproject(Mapa::Point.new(0, 0)))