libgd-gis 0.1.2 → 0.2.0

data/lib/gd/gis/basemap.rb

@@ -5,6 +5,7 @@ module GD
   module GIS
     class Basemap
       TILE_SIZE = 256
+      attr_reader :origin_x, :origin_y
 
       def initialize(zoom, bbox, provider=:carto_light)
         @zoom = zoom
@@ -12,8 +13,93 @@ module GD
         @provider = provider
       end
 
-      def url(z,x,y)
-        "https://tile.openstreetmap.org/#{z}/#{x}/#{y}.png"
+      def url(z, x, y, style = :osm)
+        case style
+
+        # ==============================
+        # OpenStreetMap
+        # ==============================
+        when :osm
+          "https://tile.openstreetmap.org/#{z}/#{x}/#{y}.png"
+
+        when :osm_hot
+          "https://tile.openstreetmap.fr/hot/#{z}/#{x}/#{y}.png"
+
+        when :osm_fr
+          "https://a.tile.openstreetmap.fr/osmfr/#{z}/#{x}/#{y}.png"
+
+        # ==============================
+        # CARTO
+        # ==============================
+        when :carto_light
+          "https://a.basemaps.cartocdn.com/light_all/#{z}/#{x}/#{y}.png"
+
+        when :carto_light_nolabels
+          "https://a.basemaps.cartocdn.com/light_nolabels/#{z}/#{x}/#{y}.png"
+
+        when :carto_dark
+          "https://a.basemaps.cartocdn.com/dark_all/#{z}/#{x}/#{y}.png"
+
+        when :carto_dark_nolabels
+          "https://a.basemaps.cartocdn.com/dark_nolabels/#{z}/#{x}/#{y}.png"
+
+        # ==============================
+        # ESRI / ArcGIS (Satellite, terrain, hybrid)
+        # ==============================
+        when :esri_satellite
+          "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/#{z}/#{y}/#{x}"
+
+        when :esri_streets
+          "https://services.arcgisonline.com/ArcGIS/rest/services/World_Street_Map/MapServer/tile/#{z}/#{y}/#{x}"
+
+        when :esri_terrain
+          "https://services.arcgisonline.com/ArcGIS/rest/services/World_Topo_Map/MapServer/tile/#{z}/#{y}/#{x}"
+
+        when :esri_hybrid
+          "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/#{z}/#{y}/#{x}"
+
+        # ==============================
+        # STAMEN
+        # ==============================
+        when :stamen_toner
+          "https://stamen-tiles.a.ssl.fastly.net/toner/#{z}/#{x}/#{y}.png"
+
+        when :stamen_toner_lite
+          "https://stamen-tiles.a.ssl.fastly.net/toner-lite/#{z}/#{x}/#{y}.png"
+
+        when :stamen_terrain
+          "https://stamen-tiles.a.ssl.fastly.net/terrain/#{z}/#{x}/#{y}.png"
+
+        when :stamen_watercolor
+          "https://stamen-tiles.a.ssl.fastly.net/watercolor/#{z}/#{x}/#{y}.jpg"
+
+        # ==============================
+        # OpenTopoMap
+        # ==============================
+        when :topo
+          "https://a.tile.opentopomap.org/#{z}/#{x}/#{y}.png"
+
+        # ==============================
+        # Wikimedia
+        # ==============================
+        when :wikimedia
+          "https://maps.wikimedia.org/osm-intl/#{z}/#{x}/#{y}.png"
+
+        # ==============================
+        # OpenRailwayMap
+        # ==============================
+        when :railway
+          "https://tiles.openrailwaymap.org/standard/#{z}/#{x}/#{y}.png"
+
+        # ==============================
+        # CyclOSM
+        # ==============================
+        when :cyclosm
+          "https://a.tile-cyclosm.openstreetmap.fr/cyclosm/#{z}/#{x}/#{y}.png"
+
+        else
+          raise "Unknown basemap style: #{style}"
+        end
       end
 
       def lon2tile(lon)
@@ -36,30 +122,51 @@ module GD
         @x_min = x_min
         @y_min = y_min
 
+        @origin_x = x_min * TILE_SIZE
+        @origin_y = y_min * TILE_SIZE
+
         FileUtils.mkdir_p("tmp/tiles")
 
         tiles = []
 
         (x_min..x_max).each do |x|
           (y_min..y_max).each do |y|
-            path = "tmp/tiles/#{@zoom}_#{x}_#{y}.png"
-            unless File.exist?(path)
-              uri = URI(url(@zoom,x,y))
+            path = nil
+
+            unless File.exist?("tmp/tiles/#{@provider}_#{@zoom}_#{x}_#{y}.png") ||
+                  File.exist?("tmp/tiles/#{@provider}_#{@zoom}_#{x}_#{y}.jpg")
+
+              uri = URI(url(@zoom, x, y, @provider))
 
               Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
                 req = Net::HTTP::Get.new(uri)
                 req["User-Agent"] = "libgd-gis/0.1 (Ruby)"
 
                 res = http.request(req)
+                raise "Tile fetch failed #{res.code}" unless res.code == "200"
+
+                content_type = res["content-type"]
 
-                unless res.code == "200"
-                  raise "Tile fetch failed #{res.code}"
-                end
+                ext =
+                  if content_type&.include?("png")
+                    "png"
+                  elsif content_type&.include?("jpeg") || content_type&.include?("jpg")
+                    "jpg"
+                  else
+                    raise "Unsupported tile type: #{content_type}"
+                  end
 
+                path = "tmp/tiles/#{@provider}_#{@zoom}_#{x}_#{y}.#{ext}"
                 File.binwrite(path, res.body)
               end
-
+            else
+              if File.exist?("tmp/tiles/#{@provider}_#{@zoom}_#{x}_#{y}.png")
+                path = "tmp/tiles/#{@provider}_#{@zoom}_#{x}_#{y}.png"
+              else
+                path = "tmp/tiles/#{@provider}_#{@zoom}_#{x}_#{y}.jpg"
+              end
             end
+
             tiles << [x,y,path]
           end
         end

data/lib/gd/gis/geometry.rb

@@ -0,0 +1,40 @@
+module GD
+  module GIS
+    module Geometry
+      def self.buffer_line(coords, meters)
+        left = []
+        right = []
+
+        coords.each_cons(2) do |a,b|
+          x1,y1 = a
+          x2,y2 = b
+
+          dx = x2 - x1
+          dy = y2 - y1
+
+          len = Math.sqrt(dx*dx + dy*dy)
+          next if len == 0
+
+          # normal vector
+          nx = -dy / len
+          ny = dx / len
+
+          # offset in degrees (approx)
+          # 1 meter ≈ 1 / 111_320 degrees
+          off = meters / 111_320.0
+
+          left  << [x1 + nx*off, y1 + ny*off]
+          right << [x1 - nx*off, y1 - ny*off]
+        end
+
+        # add last point
+        x2,y2 = coords.last
+        left  << [x2, y2]
+        right << [x2, y2]
+
+        polygon = left + right.reverse
+        polygon
+      end
+    end
+  end
+end

data/lib/gd/gis/layer_geojson.rb

@@ -0,0 +1,75 @@
+require "json"
+
+module GD
+  module GIS
+    class LayerGeoJSON
+      def initialize(path, options = {})
+        @geojson = JSON.parse(File.read(path))
+        @color   = options[:color]
+        @icon    = options[:icon]
+        @label   = options[:label]
+        @font    = options[:font]
+        @size    = options[:size] || 10
+      end
+
+      def render!(img, projection)
+        features = @geojson["features"] || []
+
+        features.each do |f|
+            geom = f["geometry"]
+            next unless geom
+
+            type   = geom["type"]
+            coords = geom["coordinates"]
+
+            case type
+            when "Point"
+                draw_points(img, projection, [coords], f["properties"])
+            when "MultiPoint"
+                draw_points(img, projection, coords, f["properties"])
+            when "LineString"
+                draw_lines(img, projection, [coords])
+            when "MultiLineString"
+                coords.each { |l| draw_lines(img, projection, [l]) }
+            when "Polygon"
+                draw_polygons(img, projection, coords)
+            when "MultiPolygon"
+                coords.each { |p| draw_polygons(img, projection, p) }
+            end
+        end
+      end
+
+      private
+
+      def draw_lines(img, projection, lines)
+        color = @color || [120,120,120]
+
+        lines.each do |line|
+          pts = line.map { |p| projection.call(p[0], p[1]) }
+
+          pts.each_cons(2) do |(x1, y1), (x2, y2)|
+            img.line(x1, y1, x2, y2, color)
+          end
+        end
+      end
+
+      def draw_polygons(img, projection, rings)
+        fill   = @color || [200,200,200]
+        stroke = [120,120,120]
+
+        rings.each do |ring|
+          pts = ring.map { |p| projection.call(p[0], p[1]) }
+
+          img.polygon(pts, fill: fill, stroke: stroke, width: 1)
+        end
+      end
+
+      def draw_polygons(map, rings)
+        map.add_polygons(
+          rings.map { |r| r.map { |p| [p[0], p[1]] } },
+          color: @color || [200,200,200]
+        )
+      end
+    end
+  end
+end

data/lib/gd/gis/layer_lines.rb

@@ -0,0 +1,36 @@
+module GD
+  module GIS
+    class LinesLayer
+      def initialize(features, stroke:, width:)
+        @features = features
+        @stroke = stroke
+        @width = width
+      end
+
+      def render!(img, projection)
+        @features.each do |f|
+          geom = f["geometry"]
+
+          case geom["type"]
+          when "LineString"
+            draw_line(geom["coordinates"], img, projection)
+          when "MultiLineString"
+            geom["coordinates"].each do |line|
+              draw_line(line, img, projection)
+            end
+          end
+        end
+      end
+
+      def draw_line(coords, img, projection)
+        pts = coords.map { |p| projection.call(p[0], p[1]) }
+
+        (0...pts.size-1).each do |i|
+          x1,y1 = pts[i]
+          x2,y2 = pts[i+1]
+          img.line(x1,y1,x2,y2,@stroke, thickness: @width)
+        end
+      end
+    end
+  end
+end

data/lib/gd/gis/layer_points.rb

@@ -5,7 +5,12 @@ module GD
         @data = data
         @lon = lon
         @lat = lat
-        @icon = GD::Image.open(icon)
+
+        if icon
+          @icon = GD::Image.open(icon)
+        else
+          @icon = build_default_marker
+        end
 
         @label = label
         @font  = font
@@ -16,6 +21,31 @@ module GD
         @icon.save_alpha = true
       end
 
+      def build_default_marker
+        size = 32
+        img = GD::Image.new(size, size)
+        img.alpha_blending = true
+        img.save_alpha = true
+
+        transparent = GD::Color.rgba(0,0,0,0)
+        img.filled_rectangle(0,0,size,size,transparent)
+
+        white = GD::Color.rgb(255,255,255)
+        black = GD::Color.rgb(0,0,0)
+
+        cx = size / 2
+        cy = size / 2
+        r  = 12
+
+        # borde blanco
+        img.arc(cx, cy, r*2+4, r*2+4, 0, 360, white)
+
+        # relleno negro
+        img.filled_arc(cx, cy, r*2, r*2, 0, 360, black)
+
+        img
+      end
+
       def render!(img, projector)
         w = @icon.width
         h = @icon.height

data/lib/gd/gis/layer_polygons.rb

@@ -0,0 +1,38 @@
+module GD
+  module GIS
+    class PolygonsLayer
+      def initialize(polygons, fill:, stroke: nil, width: nil)
+        @polygons = polygons
+        @fill = fill
+        @stroke = stroke
+        @width = width
+      end
+
+      def self.from_lines(features, stroke:, fill:, width:)
+        polys = []
+
+        features.each do |f|
+          coords = f["geometry"]["coordinates"]
+          poly = Geometry.buffer_line(coords, width)
+          polys << poly
+        end
+
+        new(polys, fill: fill, stroke: stroke)
+      end
+
+      def render!(img, projection)
+        @polygons.each do |poly|
+          pts = poly.map { |p| projection.call(p[0], p[1]) }
+
+          img.filled_polygon(pts, @fill)
+
+          if @stroke
+            pts.each_cons(2) do |a,b|
+              img.line(a[0],a[1],b[0],b[1],@stroke, thickness: 1)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gd/gis/map.rb

@@ -1,19 +1,29 @@
 require "gd"
 require_relative "basemap"
 require_relative "projection"
+require_relative "geometry"
 require_relative "layer_points"
+require_relative "layer_lines"
+require_relative "layer_polygons"
+require_relative "layer_geojson"
 
 module GD
   module GIS
     class Map
+      TILE_SIZE = 256
+
       def initialize(bbox:, zoom:, basemap:)
-        @bbox = bbox
-        @zoom = zoom
+        @bbox   = bbox
+        @zoom   = zoom
         @basemap = Basemap.new(zoom, bbox, basemap)
         @layers = []
       end
 
-      def add_points(data, lon:, lat:, icon:, label: nil, font: nil, size: 12, color: [0,0,0])
+      # ------------------------------
+      # Layer DSL
+      # ------------------------------
+
+      def add_points(data, lon:, lat:, icon: nil, label: nil, font: nil, size: 12, color: [0,0,0])
         @layers << PointsLayer.new(
           data,
           lon: lon,
@@ -26,98 +36,68 @@ module GD
         )
       end
 
-      def render
+      def add_lines(features, stroke:, width:)
+        @layers << LinesLayer.new(features, stroke: stroke, width: width)
+      end
+
+      def add_polygons(polygons, fill:, stroke: nil, width: nil)
+        @layers << PolygonsLayer.new(polygons, fill: fill, stroke: stroke, width: width)
+      end
+
+      def add_geojson(path, **options)
+        @layers << LayerGeoJSON.new(path, options)
+      end
+
+      # ------------------------------
+      # Rendering
+      # ------------------------------
+
+      def render(path = "map.png")
         tiles, x_min, y_min = @basemap.fetch_tiles
 
-        x0 = x_min * 256
-        y0 = y_min * 256
+        xs = tiles.map { |t| t[0] }
+        ys = tiles.map { |t| t[1] }
+
+        cols = xs.max - xs.min + 1
+        rows = ys.max - ys.min + 1
 
-        cols = tiles.map{|t| t[0]}.uniq.size
-        rows = tiles.map{|t| t[1]}.uniq.size
+        width  = cols * TILE_SIZE
+        height = rows * TILE_SIZE
 
-        width = cols * 256
-        height = rows * 256
+        origin_x = x_min * TILE_SIZE
+        origin_y = y_min * TILE_SIZE
 
-        @img = GD::Image.new(width,height)
+        @img = GD::Image.new(width, height)
         @img.alpha_blending = true
         @img.save_alpha = true
 
-        tiles.each do |x,y,path|
-          tile = GD::Image.open(path)
+        # Draw basemap
+        tiles.each do |x, y, file|
+          tile = GD::Image.open(file)
           cx = x - x_min
           cy = y - y_min
-          @img.copy(tile, cx*256, cy*256, 0,0,256,256)
+          @img.copy(tile, cx * TILE_SIZE, cy * TILE_SIZE, 0, 0, TILE_SIZE, TILE_SIZE)
         end
 
-        # projection bbox
-        min_x = Projection.mercator_x(@bbox[0])
-        max_x = Projection.mercator_x(@bbox[2])
-        min_y = Projection.mercator_y(@bbox[1])
-        max_y = Projection.mercator_y(@bbox[3])
-
-        projector = ->(lon,lat) {
-          px = ((lon + 180.0) / 360.0 * (2 ** @zoom) * 256)
-          rad = lat * Math::PI / 180.0
-          py = ((1 - Math.log(Math.tan(rad) + 1 / Math.cos(rad)) / Math::PI) / 2 * (2 ** @zoom) * 256)
-
-          [ (px - x0).to_i, (py - y0).to_i ]
-        }
-
-        @layers.each { |l| l.render!(@img, projector) }
-      end
-
-      def tile2lon(x, z)
-        x.to_f / (2**z) * 360.0 - 180.0
-      end
+        # WebMercator projection → local pixels
+        scale = TILE_SIZE * (2 ** @zoom)
 
-      def tile2lat(y, z)
-        n = Math::PI - (2.0 * Math::PI * y.to_f) / (2**z)
-        180.0 / Math::PI * Math.atan(0.5 * (Math.exp(n) - Math.exp(-n)))
-      end
+        projection = lambda do |lon, lat|
+          x = (lon + 180.0) / 360.0 * scale
 
-      def tile_bbox(z,x,y)
-        west  = tile2lon(x, z)
-        east  = tile2lon(x+1, z)
-        north = tile2lat(y, z)
-        south = tile2lat(y+1, z)
-        [west, south, east, north]
-      end
-
-      def intersect_bbox(a,b)
-        [
-          [a[0], b[0]].max,
-          [a[1], b[1]].max,
-          [a[2], b[2]].min,
-          [a[3], b[3]].min
-        ]
-      end
+          lat_rad = lat * Math::PI / 180.0
+          y = (1.0 - Math.log(Math.tan(lat_rad) + 1.0 / Math.cos(lat_rad)) / Math::PI) / 2.0 * scale
 
-      def tile(z,x,y)
-        tb = tile_bbox(z,x,y)
-        ib = intersect_bbox(@bbox, tb)
-
-        # Si no hay intersección, devolvemos tile vacío
-        if ib[0] >= ib[2] || ib[1] >= ib[3]
-          return GD::Image.new(256,256)
+          [
+            (x - origin_x).round,
+            (y - origin_y).round
+          ]
         end
 
-        submap = GD::GIS::Map.new(
-          bbox: ib,
-          zoom: z,
-          basemap: :carto_light
-        )
-
-        # copiar capas
-        @layers.each { |l| submap.instance_variable_get(:@layers) << l }
-
-        submap.render
-
-        # recortar al tamaño exacto del tile
-        img = GD::Image.new(256,256)
-        img.alpha_blending = true
-        img.save_alpha = true
-        img.copy(submap.instance_variable_get(:@img), 0,0,0,0,256,256)
-        img
+        # Draw layers
+        @layers.each do |layer|
+          layer.render!(@img, projection)
+        end
       end
 
       def save(path)

data/lib/gd/gis/projection.rb

@@ -20,6 +20,20 @@ module GD
 
         [px.to_i, py.to_i]
       end
+
+      TILE_SIZE = 256
+
+      def self.lonlat_to_global_px(lon, lat, zoom)
+        lat = [[lat, 85.05112878].min, -85.05112878].max
+        n = 2.0 ** zoom
+
+        x = (lon + 180.0) / 360.0 * n * TILE_SIZE
+
+        lat_rad = lat * Math::PI / 180.0
+        y = (1.0 - Math.log(Math.tan(lat_rad) + 1.0 / Math.cos(lat_rad)) / Math::PI) / 2.0 * n * TILE_SIZE
+
+        [x, y]
+      end
     end
   end
 end