libgd-gis 0.2.1 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9545a3b2d5b7dfbe786765e7f8ad378a7af124e934ba29a24d4cbbe411c285b
-  data.tar.gz: e088ef217d3c3d90f3d9236633e22aa38e60daa4494b2e9ad24141b2fbd2c4c8
+  metadata.gz: 9112994f7952782be773dc2a7bb8659d96769903b6e9c81b28a563cb2caa80eb
+  data.tar.gz: 569e8be0ac09110cf30b3b888317a5079fc975176988ee8051b7f3419587b721
 SHA512:
-  metadata.gz: eb648bfeec8226763a9cb20a2ee82080f45ffff36407fdc000948973c63809f259df5e8464f9849b80142f3cd32e0f230c5fbaa5df1d9091708ec01240c1f876
-  data.tar.gz: 138e140b503095e790b221e39c27ea3d8384a0d6d059ec7c9e60ae9d8ae8a60097ec3f56c088c167e67393f641b5561b747dc976755204e60d31745502868189
+  metadata.gz: 85d38d16fdbc475ed5938c32a94819dabbdee7b4d706c369f8a84faec9753bf3765bcd5b4134a47ba62775ead533dad0c42a40cad46085d520f1333c0aacdb1c
+  data.tar.gz: ea38df19e492b85550edcebeb1e85157422e619bb7922cf4e49750bd9dc1978afc58e7a6163773de769aabfe60240803f062037c545774bf29f79bbae5324d4a

data/README.md

@@ -32,10 +32,11 @@
 
 | Examples | Examples | Examples |
 | :----: | :----: | :--: |
+| <img src="examples/nyc/nyc.png" height="250"> | <img src="examples/tokyo/tokyo.png" height="250"> | <img src="examples/parana/parana.png" height="250"> | 
 | <img src="docs/examples/america.png" height="250"> | <img src="docs/examples/argentina_museum.png" height="250"> | <img src="docs/examples/museos_parana.png" height="250"> |
 | <img src="docs/examples/asia.png" height="250"> | <img src="docs/examples/europe.png" height="250"> | <img src="docs/examples/icecream_parana.png" height="250"> |
 | <img src="docs/examples/argentina_cities.png" height="250"> | <img src="docs/examples/tanzania_hydro.png" height="250"> | <img src="docs/examples/parana_polygon.png" height="250"> |
-| <img src="docs/examples/parana_carto_dark.png" height="250"> | <img src="docs/examples/ramirez_avenue.png" height="250"> | |
+| <img src="docs/examples/parana_carto_dark.png" height="250"> | <img src="docs/examples/ramirez_avenue.png" height="250"> | <img src="examples/paris/paris.png" height="250"> |
 
 ---
 

data/lib/gd/gis/basemap.rb

@@ -59,7 +59,7 @@ module GD
           "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/#{z}/#{y}/#{x}"
 
         # ==============================
-        # STAMEN
+        # STAMEN 503
         # ==============================
         when :stamen_toner
           "https://stamen-tiles.a.ssl.fastly.net/toner/#{z}/#{x}/#{y}.png"
@@ -80,7 +80,7 @@ module GD
           "https://a.tile.opentopomap.org/#{z}/#{x}/#{y}.png"
 
         # ==============================
-        # Wikimedia
+        # Wikimedia 403
         # ==============================
         when :wikimedia
           "https://maps.wikimedia.org/osm-intl/#{z}/#{x}/#{y}.png"

data/lib/gd/gis/classifier.rb

@@ -0,0 +1,57 @@
+module GD
+  module GIS
+    class Classifier
+      def self.road(feature)
+        tags = feature.properties || {}
+
+        case tags["highway"]
+        when "motorway", "trunk"
+          :motorway
+        when "primary", "primary_link"
+          :primary
+        when "secondary", "secondary_link"
+          :secondary
+        when "tertiary"
+          :street
+        when "residential", "living_street"
+          :street
+        when "service", "track"
+          :minor
+        else
+          nil
+        end
+      end
+
+      def self.water?(feature)
+        p = feature.properties
+
+        p["waterway"] ||
+        p["natural"] == "water" ||
+        p["fclass"] == "river" ||
+        p["fclass"] == "stream"
+      end
+
+      def self.rail?(feature)
+        tags = feature.properties || {}
+        tags["railway"]
+      end
+
+      def self.park?(feature)
+        tags = feature.properties || {}
+        %w[park recreation_ground garden].include?(tags["leisure"]) ||
+          %w[park grass forest].include?(tags["landuse"])
+      end
+
+      def self.water_kind(feature)
+        p = feature.properties
+
+        case p["waterway"] || p["fclass"]
+        when "river"  then :river
+        when "stream" then :stream
+        else :minor
+        end
+      end
+
+    end
+  end
+end

data/lib/gd/gis/dump.sh

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+
+set -e
+
+OUT="all_ruby_sources.txt"
+> "$OUT"
+
+echo "### Ruby sources dump ($(date))" >> "$OUT"
+echo >> "$OUT"
+
+find . -type f -name "*.rb" | sort | while read -r file; do
+  echo "===== FILE: $file =====" >> "$OUT"
+  echo >> "$OUT"
+  cat "$file" >> "$OUT"
+  echo >> "$OUT"
+  echo >> "$OUT"
+done
+
+echo "Wrote $OUT"

data/lib/gd/gis/feature.rb

@@ -0,0 +1,152 @@
+module GD
+  module GIS
+    class Feature
+      attr_reader :geometry, :properties
+
+      def initialize(geometry, properties)
+        @geometry   = geometry
+        @properties = properties || {}
+      end
+
+      # -------------------------------------------------
+      # Main draw entry point
+      # -------------------------------------------------
+      def draw(img, projection, color, width, layer = nil)
+        case geometry["type"]
+        when "Polygon"
+          if layer == :water
+            draw_polygon_outline(img, projection, geometry["coordinates"], color, width)
+          elsif layer.is_a?(Hash)
+            draw_polygon_styled(img, projection, geometry["coordinates"], layer)
+          else
+            draw_polygon(img, projection, geometry["coordinates"], color)
+          end
+        when "MultiPolygon"
+          geometry["coordinates"].each do |poly|
+            if layer == :water
+              draw_polygon_outline(img, projection, poly, color, width)
+            elsif layer.is_a?(Hash)
+              draw_polygon_styled(img, projection, poly, layer)
+            else
+              draw_polygon(img, projection, poly, color)
+            end
+          end
+        when "LineString", "MultiLineString"
+          draw_lines(img, projection, geometry["coordinates"], color, width)
+        end
+      end
+
+      # -------------------------------------------------
+      # Styled polygon rendering (fill + stroke)
+      # -------------------------------------------------
+      def draw_polygon_styled(img, projection, rings, style)
+        fill   = style[:fill]   ? GD::Color.rgb(*style[:fill])   : nil
+        stroke = style[:stroke] ? GD::Color.rgb(*style[:stroke]) : nil
+
+        rings.each do |ring|
+          pts = ring.map do |lon,lat|
+            x,y = projection.call(lon,lat)
+            next if x.nil? || y.nil?
+            [x.to_i, y.to_i]
+          end.compact
+
+          pts = pts.chunk_while { |a,b| a == b }.map(&:first)
+          next if pts.length < 3
+
+          img.filled_polygon(pts, fill) if fill
+
+          if stroke
+            pts.each_cons(2) { |a,b| img.line(a[0],a[1], b[0],b[1], stroke) }
+            img.line(pts.last[0], pts.last[1], pts.first[0], pts.first[1], stroke)
+          end
+        end
+      end
+
+      # -------------------------------------------------
+      # Polygon outline (used for water)
+      # -------------------------------------------------
+      def draw_polygon_outline(img, projection, rings, color, width)
+        return if color.nil?
+
+        rings.each do |ring|
+          pts = ring.map do |lon, lat|
+            x, y = projection.call(lon, lat)
+            [x.to_i, y.to_i] if x && y
+          end.compact
+
+          next if pts.size < 2
+
+          img.lines(pts, color, width)
+        end
+      end
+
+      # -------------------------------------------------
+      # Legacy filled polygon (single color)
+      # -------------------------------------------------
+      def draw_polygon(img, projection, rings, color)
+        return if color.nil?
+
+        rings.each do |ring|
+          pts = ring.map do |lon,lat|
+            x,y = projection.call(lon,lat)
+            next if x.nil? || y.nil?
+            [x.to_i, y.to_i]
+          end.compact
+
+          pts = pts.chunk_while { |a,b| a == b }.map(&:first)
+          next if pts.length < 3
+
+          img.filled_polygon(pts, color)
+        end
+      end
+
+      # -------------------------------------------------
+      # Lines
+      # -------------------------------------------------
+      def draw_lines(img, projection, coords, color, width)
+        return if color.nil?
+
+        if coords.first.is_a?(Array) && coords.first.first.is_a?(Array)
+          coords.each { |line| draw_line(img, projection, line, color, width) }
+        else
+          draw_line(img, projection, coords, color, width)
+        end
+      end
+
+      def draw_line(img, projection, coords, color, width)
+        return if color.nil?
+
+        coords.each_cons(2) do |(lon1,lat1),(lon2,lat2)|
+          x1,y1 = projection.call(lon1,lat1)
+          x2,y2 = projection.call(lon2,lat2)
+          img.line(x1, y1, x2, y2, color, thickness: width)
+        end
+      end
+
+      # -------------------------------------------------
+      # Metadata helpers
+      # -------------------------------------------------
+      def label
+        properties["name:ja"] || properties["name"]
+      end
+
+      def centroid
+        pts = []
+
+        case geometry["type"]
+        when "LineString"
+          pts = geometry["coordinates"]
+        when "MultiLineString"
+          pts = geometry["coordinates"].flatten(1)
+        end
+
+        return nil if pts.empty?
+
+        lon = pts.map(&:first).sum / pts.size
+        lat = pts.map(&:last).sum / pts.size
+
+        [lon, lat]
+      end
+    end
+  end
+end

data/lib/gd/gis/layer_geojson.rb

@@ -1,69 +1,16 @@
 require "json"
+require_relative "feature"
 
 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
+      def self.load(path)
+        data = JSON.parse(File.read(path))
+        features = data["features"]
+        features.map do |f|
+          Feature.new(f["geometry"], f["properties"])
         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
-
     end
   end
 end

data/lib/gd/gis/map.rb

@@ -1,58 +1,91 @@
-require "gd"
 require_relative "basemap"
 require_relative "projection"
-require_relative "geometry"
+require_relative "classifier"
+require_relative "layer_geojson"
 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
 
+      attr_reader :image
+      attr_accessor :style
+
       def initialize(bbox:, zoom:, basemap:)
-        @bbox   = bbox
-        @zoom   = zoom
-        @basemap = Basemap.new(zoom, bbox, basemap)
-        @layers = []
+        @bbox     = bbox
+        @zoom     = zoom
+        @basemap  = Basemap.new(zoom, bbox, basemap)
+
+        # 🔒 DO NOT CHANGE — this is the working GeoJSON pipeline
+        @layers = {
+          motorway: [],
+          primary: [],
+          secondary: [],
+          street: [],
+          minor: [],
+          rail: [],
+          water: [],
+          park: []
+        }
+
+        # 🆕 overlay layers
+        @points_layers   = []
+        @lines_layers    = []
+        @polygons_layers = []
+
+        @style = nil
       end
 
-      # ------------------------------
-      # 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,
-          lat: lat,
-          icon: icon,
-          label: label,
-          font: font,
-          size: size,
-          color: color
-        )
+      # -----------------------------------
+      # GeoJSON input (unchanged)
+      # -----------------------------------
+
+      def add_geojson(path)
+        features = LayerGeoJSON.load(path)
+
+        features.each do |feature|
+          if Classifier.water?(feature)
+            kind = Classifier.water_kind(feature)
+            @layers[:water] << [kind, feature]
+
+          elsif Classifier.park?(feature)
+            @layers[:park] << feature
+
+          elsif Classifier.rail?(feature)
+            @layers[:rail] << feature
+
+          elsif type = Classifier.road(feature)
+            @layers[type] << feature
+          end
+        end
       end
 
-      def add_lines(features, stroke:, width:)
-        @layers << LinesLayer.new(features, stroke: stroke, width: width)
+      # -----------------------------------
+      # Overlay layers
+      # -----------------------------------
+
+      def add_points(data, **opts)
+        @points_layers << GD::GIS::PointsLayer.new(data, **opts)
       end
 
-      def add_polygons(polygons, fill:, stroke: nil, width: nil)
-        @layers << PolygonsLayer.new(polygons, fill: fill, stroke: stroke, width: width)
+      def add_lines(features, **opts)
+        @lines_layers << GD::GIS::LinesLayer.new(features, **opts)
       end
 
-      def add_geojson(path, **options)
-        @layers << LayerGeoJSON.new(path, options)
+      def add_polygons(polygons, **opts)
+        @polygons_layers << GD::GIS::PolygonsLayer.new(polygons, **opts)
       end
 
-      # ------------------------------
+      # -----------------------------------
       # Rendering
-      # ------------------------------
+      # -----------------------------------
+
+      def render
+        raise "map.style must be set" unless @style
 
-      def render(path = "map.png")
         tiles, x_min, y_min = @basemap.fetch_tiles
 
         xs = tiles.map { |t| t[0] }
@@ -67,42 +100,92 @@ module GD
         origin_x = x_min * TILE_SIZE
         origin_y = y_min * TILE_SIZE
 
-        @img = GD::Image.new(width, height)
-        @img.alpha_blending = true
-        @img.save_alpha = true
+        @image = GD::Image.new(width, height)
+        @image.antialias(false)
 
-        # Draw basemap
+        # Basemap
         tiles.each do |x, y, file|
           tile = GD::Image.open(file)
-          cx = x - x_min
-          cy = y - y_min
-          @img.copy(tile, cx * TILE_SIZE, cy * TILE_SIZE, 0, 0, TILE_SIZE, TILE_SIZE)
+          @image.copy(
+            tile,
+            (x - x_min) * TILE_SIZE,
+            (y - y_min) * TILE_SIZE,
+            0, 0, TILE_SIZE, TILE_SIZE
+          )
         end
 
-        # WebMercator projection → local pixels
-        scale = TILE_SIZE * (2 ** @zoom)
-
         projection = lambda do |lon, lat|
-          x = (lon + 180.0) / 360.0 * scale
-
-          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
-
-          [
-            (x - origin_x).round,
-            (y - origin_y).round
-          ]
+          x, y = GD::GIS::Projection.lonlat_to_global_px(lon, lat, @zoom)
+          [(x - origin_x).round, (y - origin_y).round]
         end
 
-        # Draw layers
-        @layers.each do |layer|
-          layer.render!(@img, projection)
+        # 1️⃣ Semantic GeoJSON layers (this is what was working)
+        @style.order.each do |kind|
+          draw_layer(kind, projection)
         end
+
+        # 2️⃣ Generic overlays
+        @polygons_layers.each { |l| l.render!(@image, projection) }
+        @lines_layers.each    { |l| l.render!(@image, projection) }
+        @points_layers.each   { |l| l.render!(@image, projection) }
       end
 
       def save(path)
-        @img.save(path)
+        @image.save(path)
       end
+
+      def draw_layer(kind, projection)
+        items = @layers[kind]
+        return if items.nil? || items.empty?
+
+        style =
+          case kind
+          when :street, :primary, :motorway, :secondary, :minor
+            @style.roads[kind]
+          when :rail   then @style.rails
+          when :water  then @style.water
+          when :park   then @style.parks
+          else
+            @style.extra[kind] if @style.respond_to?(:extra)
+          end
+
+        return if style.nil?
+
+        items.each do |item|
+          if kind == :water
+            water_kind, f = item
+
+            width =
+              case water_kind
+              when :river  then 2.5
+              when :stream then 1.5
+              else 1
+              end
+
+            if style[:stroke]
+              color = GD::Color.rgb(*style[:stroke])
+              f.draw(@image, projection, color, width, :water)
+            end
+
+          else
+            f = item
+            geom = f.geometry["type"]
+
+            if geom == "Polygon" || geom == "MultiPolygon"
+              # THIS is the critical fix
+              f.draw(@image, projection, nil, nil, style)
+            else
+              if style[:stroke]
+                color = GD::Color.rgb(*style[:stroke])
+                width = style[:stroke_width] || 1
+                f.draw(@image, projection, color, width)
+              end
+            end
+          end
+        end
+      end
+
+
     end
   end
 end

data/lib/gd/gis/style/dark.rb

@@ -0,0 +1,49 @@
+module GD
+  module GIS
+    class Style
+      DARK = Style.new(
+        roads: {
+          motorway: {
+            stroke: [255,255,255],
+            stroke_width: 10,
+            fill: [60,60,60],
+            fill_width: 6
+          },
+          primary: {
+            stroke: [200,200,200],
+            stroke_width: 7,
+            fill: [80,80,80],
+            fill_width: 4
+          },
+          street: {
+            stroke: [120,120,120],
+            stroke_width: 1
+          }
+        },
+        rail: {
+          stroke: [255,255,255],
+          stroke_width: 6,
+          fill: [220,50,50],
+          fill_width: 4,
+          center: [255,255,255],
+          center_width: 1
+        },
+        water: {
+          fill: [40,80,120],
+          stroke: [100,160,220]
+        },
+        park: {
+          fill: [40,80,40]
+        },
+        order: [
+          :water,
+          :park,
+          :street,
+          :primary,
+          :motorway,
+          :rail
+        ]
+      )
+    end
+  end
+end

data/lib/gd/gis/style/light.rb

@@ -0,0 +1,49 @@
+module GD
+  module GIS
+    class Style
+      LIGHT = Style.new(
+        roads: {
+          motorway: {
+            stroke: [100,100,100],
+            stroke_width: 10,
+            fill: [245,245,245],
+            fill_width: 6
+          },
+          primary: {
+            stroke: [140,140,140],
+            stroke_width: 7,
+            fill: [240,240,240],
+            fill_width: 4
+          },
+          street: {
+            stroke: [220,220,220],
+            stroke_width: 1
+          }
+        },
+        rail: {
+          stroke: [80,80,80],
+          stroke_width: 6,
+          fill: [230,70,70],
+          fill_width: 4,
+          center: [255,255,255],
+          center_width: 1
+        },
+        water: {
+          fill: [168,208,255],
+          stroke: [120,180,240]
+        },
+        park: {
+          fill: [205,238,203]
+        },
+        order: [
+          :water,
+          :park,
+          :street,
+          :primary,
+          :motorway,
+          :rail
+        ]
+      )
+    end
+  end
+end