libgd-gis 0.2.6 → 0.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c36a99210906574c046daffe2120213b027d92fdd22dec0b27861df22f88029
-  data.tar.gz: bd991fd3290c3bfb82f5640dad84c8e6486368285539774eed1b942acd7848b6
+  metadata.gz: 78e53ca4b47b3bd61cdc1a52268598fefbfa1797f2781a5296e4be856523787e
+  data.tar.gz: 2cbf66d159688eb784f2801527ba1856fc836c58211187c772ed1060ed702e36
 SHA512:
-  metadata.gz: 6bed27a3930a9512b0f5fff46fdfe2f76fe76932ddf263cc2d219cdaafd754d5161ede878f1b0d929e5a7b00b9c4b546c6905d9ee27d9bc478d5e7914ebc1784
-  data.tar.gz: ee203f7b9dc6f0a2669bbbedcde1e6fe31678c3a847c79a14d975c75cee1cc0a7f2784398acbef9b821943cce9124bdb5b41f0194070ff020fa39824f699a56a
+  metadata.gz: 55886e495283ecac661a25773d87fc98420cd38abaf8ca0f39fc9896b42c58d7e3da40f0aeaecb977def3c9d0eb721fc2520f7eb7d07fe6b5de89506cc1fae50
+  data.tar.gz: 90e030366511f4cc4c8aa8de17ac0ce17a129c56d71c2c3f46d2fb6a03a882c8408870c9ec5bc132c837d4a3a8bf4681385c77862cfd0fdde4b5f03378688c0e

data/lib/gd/gis/color_helpers.rb

@@ -0,0 +1,65 @@
+module GD
+  module GIS
+    module ColorHelpers
+      # --------------------------------------------------
+      # Random RGB color
+      # --------------------------------------------------
+      def self.random_rgb(min: 0, max: 255)
+        GD::Color.rgb(
+          rand(min..max),
+          rand(min..max),
+          rand(min..max)
+        )
+      end
+
+      # --------------------------------------------------
+      # Random RGBA color
+      # --------------------------------------------------
+      def self.random_rgba(min: 0, max: 255, alpha: nil)
+        GD::Color.rgba(
+          rand(min..max),
+          rand(min..max),
+          rand(min..max),
+          alpha || rand(50..255)
+        )
+      end
+
+      # --------------------------------------------------
+      # Random vivid color (avoid gray/mud)
+      # --------------------------------------------------
+      def self.random_vivid
+        h = rand
+        s = rand(0.6..1.0)
+        v = rand(0.7..1.0)
+
+        r, g, b = hsv_to_rgb(h, s, v)
+        GD::Color.rgb(r, g, b)
+      end
+
+      # --------------------------------------------------
+      # HSV → RGB
+      # --------------------------------------------------
+      def self.hsv_to_rgb(h, s, v)
+        i = (h * 6).floor
+        f = h * 6 - i
+        p = v * (1 - s)
+        q = v * (1 - f * s)
+        t = v * (1 - (1 - f) * s)
+
+        r, g, b =
+          case i % 6
+          when 0 then [v, t, p]
+          when 1 then [q, v, p]
+          when 2 then [p, v, t]
+          when 3 then [p, q, v]
+          when 4 then [t, p, v]
+          when 5 then [v, p, q]
+          end
+
+        [(r * 255).to_i, (g * 255).to_i, (b * 255).to_i]
+      end
+
+    end
+  end
+end
+

data/lib/gd/gis/crs_normalizer.rb

@@ -0,0 +1,57 @@
+module GD
+  module GIS
+    module CRS
+      CRS84    = "urn:ogc:def:crs:OGC:1.3:CRS84"
+      EPSG4326 = "EPSG:4326"
+      EPSG3857 = "EPSG:3857"
+
+      class Normalizer
+        def initialize(crs)
+          @crs = normalize_name(crs)
+        end
+
+        # Accepts:
+        #   normalize(lon,lat)
+        #   normalize(lon,lat,z)
+        #   normalize([lon,lat])
+        #   normalize([lon,lat,z])
+        def normalize(*args)
+          lon, lat = args.flatten
+          return nil if lon.nil? || lat.nil?
+
+          lon = lon.to_f
+          lat = lat.to_f
+
+          case @crs
+          when CRS84, nil
+            [lon, lat]
+
+          when EPSG4326
+            # axis order lat,lon → lon,lat
+            [lat, lon]
+
+          when EPSG3857
+            mercator_to_wgs84(lon, lat)
+
+          else
+            [lon, lat]
+          end
+        end
+
+        private
+
+        def normalize_name(name)
+          return nil if name.nil?
+          name.to_s.strip
+        end
+
+        def mercator_to_wgs84(x, y)
+          r = 6378137.0
+          lon = (x / r) * 180.0 / Math::PI
+          lat = (2 * Math.atan(Math.exp(y / r)) - Math::PI / 2) * 180.0 / Math::PI
+          [lon, lat]
+        end
+      end
+    end
+  end
+end

data/lib/gd/gis/feature.rb

@@ -1,11 +1,12 @@
 module GD
   module GIS
     class Feature
-      attr_reader :geometry, :properties
+      attr_reader :geometry, :properties, :layer
 
-      def initialize(geometry, properties)
+      def initialize(geometry, properties, layer = nil)
         @geometry   = geometry
         @properties = properties || {}
+        @layer      = layer
       end
 
       # -------------------------------------------------

data/lib/gd/gis/geometry.rb

@@ -1,40 +1,235 @@
 module GD
   module GIS
     module Geometry
+
+      TILE_SIZE = 256.0
+      MAX_LAT   = 85.05112878
+
+      # --------------------------------------------------
+      # Validation
+      # --------------------------------------------------
+
+      def self.validate_bbox!(bbox)
+        unless bbox.is_a?(Array) && bbox.size == 4
+          raise ArgumentError, "bbox must be [min_lng, min_lat, max_lng, max_lat]"
+        end
+      end
+
+      def self.validate_coords!(coords)
+        unless coords.is_a?(Array) && coords.size >= 2
+          raise ArgumentError, "coords must be an Array of at least 2 points"
+        end
+      end
+
+      # --------------------------------------------------
+      # Web Mercator Projection
+      # --------------------------------------------------
+
+      def self.lng_to_x(lng, zoom)
+        ((lng + 180.0) / 360.0) * TILE_SIZE * (2**zoom)
+      end
+
+      def self.lat_to_y(lat, zoom)
+        lat = [[lat, MAX_LAT].min, -MAX_LAT].max
+        lat_rad = lat * Math::PI / 180.0
+        n = Math.log(Math.tan(Math::PI / 4.0 + lat_rad / 2.0))
+        (1.0 - n / Math::PI) / 2.0 * TILE_SIZE * (2**zoom)
+      end
+
+      def self.x_to_lng(x, zoom)
+        (x / (TILE_SIZE * (2**zoom))) * 360.0 - 180.0
+      end
+
+      def self.y_to_lat(y, zoom)
+        n = Math::PI - 2.0 * Math::PI * y / (TILE_SIZE * (2**zoom))
+        180.0 / Math::PI * Math.atan(0.5 * (Math.exp(n) - Math.exp(-n)))
+      end
+
+      # --------------------------------------------------
+      # Viewport
+      # --------------------------------------------------
+
+      def self.viewport_bbox(bbox:, zoom:, width:, height:)
+        validate_bbox!(bbox)
+
+        min_lng, min_lat, max_lng, max_lat = bbox
+
+        center_lng = (min_lng + max_lng) / 2.0
+        center_lat = (min_lat + max_lat) / 2.0
+
+        center_x = lng_to_x(center_lng, zoom)
+        center_y = lat_to_y(center_lat, zoom)
+
+        half_w = width  / 2.0
+        half_h = height / 2.0
+
+        min_x = center_x - half_w
+        max_x = center_x + half_w
+        min_y = center_y - half_h
+        max_y = center_y + half_h
+
+        [
+          x_to_lng(min_x, zoom),
+          y_to_lat(max_y, zoom),
+          x_to_lng(max_x, zoom),
+          y_to_lat(min_y, zoom)
+        ]
+      end
+
+      # --------------------------------------------------
+      # Geometry helpers
+      # --------------------------------------------------
+
+      # buffer_line(coords, meters)
+      #
+      # coords  :: Array<[lng, lat]> in WGS84
+      # meters  :: Numeric (approximate)
+      #
+      # NOTE:
+      # - Naive meters-to-degrees conversion
+      # - Suitable for visualization, not analysis
+      #
       def self.buffer_line(coords, meters)
-        left = []
+        validate_coords!(coords)
+
+        left  = []
         right = []
 
-        coords.each_cons(2) do |a,b|
-          x1,y1 = a
-          x2,y2 = b
+        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
+          len = Math.sqrt(dx * dx + dy * dy)
+          next if len.zero?
 
-          # normal vector
           nx = -dy / len
-          ny = dx / 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]
+          left  << [x1 + nx * off, y1 + ny * off]
+          right << [x1 - nx * off, y1 - ny * off]
         end
 
-        # add last point
-        x2,y2 = coords.last
+        x2, y2 = coords.last
         left  << [x2, y2]
         right << [x2, y2]
 
-        polygon = left + right.reverse
-        polygon
+        left + right.reverse
       end
+      
+      def self.project(lng, lat, bbox, zoom)
+        min_lng, _min_lat, _max_lng, max_lat = bbox
+
+        world_x = lng_to_x(lng, zoom)
+        world_y = lat_to_y(lat, zoom)
+
+        offset_x = lng_to_x(min_lng, zoom)
+        offset_y = lat_to_y(max_lat, zoom)
+
+        [
+          world_x - offset_x,
+          world_y - offset_y
+        ]
+      end
+
+      def self.bbox_for_image(path, zoom:, width:, height:, padding_px: 80)
+        data = JSON.parse(File.read(path))
+        points = []
+
+        data["features"].each do |f|
+          geom = f["geometry"]
+          next unless geom
+          collect_points(geom, points)
+        end
+
+        raise "No coordinates found in GeoJSON" if points.empty?
+
+        # --------------------------------------------------
+        # 1. Project to pixel space
+        # --------------------------------------------------
+        xs = []
+        ys = []
+
+        points.each do |lon, lat|
+          xs << lng_to_x(lon, zoom)
+          ys << lat_to_y(lat, zoom)
+        end
+
+        min_x = xs.min - padding_px
+        max_x = xs.max + padding_px
+        min_y = ys.min - padding_px
+        max_y = ys.max + padding_px
+
+        # --------------------------------------------------
+        # 2. Fit bbox to image aspect ratio
+        # --------------------------------------------------
+        target_ratio = width.to_f / height.to_f
+        current_ratio = (max_x - min_x) / (max_y - min_y)
+
+        if current_ratio > target_ratio
+          # too wide → expand vertically
+          new_h = (max_x - min_x) / target_ratio
+          delta = (new_h - (max_y - min_y)) / 2.0
+          min_y -= delta
+          max_y += delta
+        else
+          # too tall → expand horizontally
+          new_w = (max_y - min_y) * target_ratio
+          delta = (new_w - (max_x - min_x)) / 2.0
+          min_x -= delta
+          max_x += delta
+        end
+
+        # --------------------------------------------------
+        # 3. Convert back to lon/lat
+        # --------------------------------------------------
+        [
+          x_to_lng(min_x, zoom),
+          y_to_lat(max_y, zoom),
+          x_to_lng(max_x, zoom),
+          y_to_lat(min_y, zoom)
+        ]
+      end
+
+      def self.collect_points(geom, points)
+        case geom["type"]
+        when "Point"
+          points << geom["coordinates"]
+
+        when "MultiPoint", "LineString"
+          geom["coordinates"].each { |c| points << c }
+
+        when "MultiLineString", "Polygon"
+          geom["coordinates"].each do |line|
+            line.each { |c| points << c }
+          end
+
+        when "MultiPolygon"
+          geom["coordinates"].each do |poly|
+            poly.each do |ring|
+              ring.each { |c| points << c }
+            end
+          end
+        end
+      end
+
+      def self.bbox_around_point(lon, lat, radius_km:)
+        delta_lat = radius_km / 111.0
+        delta_lon = radius_km / (111.0 * Math.cos(lat * Math::PI / 180.0))
+
+        [
+          lon - delta_lon,
+          lat - delta_lat,
+          lon + delta_lon,
+          lat + delta_lat
+        ]
+      end
+
     end
   end
 end
+

data/lib/gd/gis/input/detector.rb

@@ -0,0 +1,34 @@
+module GD
+  module GIS
+    module Input
+      module Detector
+        def self.detect(path)
+          return :geojson   if geojson?(path)
+          return :kml       if kml?(path)
+          return :shapefile if shapefile?(path)
+          return :osm_pbf   if pbf?(path)
+          :unknown
+        end
+
+        def self.geojson?(path)
+          File.open(path) do |f|
+            head = f.read(2048)
+            head.include?('"FeatureCollection"') || head.include?('"GeometryCollection"')
+          end
+        end
+
+        def self.kml?(path)
+          File.open(path) { |f| f.read(512).include?("<kml") }
+        end
+
+        def self.shapefile?(path)
+          File.open(path, "rb") { |f| f.read(4) == "\x00\x00\x27\x0A" }
+        end
+
+        def self.pbf?(path)
+          File.open(path, "rb") { |f| f.read(2) == "\x1f\x8b" }
+        end
+      end
+    end
+  end
+end

data/lib/gd/gis/layer_geojson.rb

@@ -1,16 +1,66 @@
 require "json"
 require_relative "feature"
+require_relative "crs_normalizer"
+require_relative "ontology"
 
 module GD
   module GIS
     class LayerGeoJSON
+
       def self.load(path)
         data = JSON.parse(File.read(path))
-        features = data["features"]
-        features.map do |f|
-          Feature.new(f["geometry"], f["properties"])
+
+        # 1) Detect CRS
+        crs_name   = data["crs"]&.dig("properties", "name")
+        normalizer = CRS::Normalizer.new(crs_name)
+
+        # 2) Load ontology
+        ontology = Ontology.new
+
+        # 3) Normalize geometries + classify
+        data["features"].map do |f|
+          normalize_geometry!(f["geometry"], normalizer)
+          layer = ontology.classify(f["properties"] || {})
+          Feature.new(f["geometry"], f["properties"], layer)
         end
       end
+
+      # --------------------------------------------
+      # CRS normalization (2D + 3D safe)
+      # --------------------------------------------
+      def self.normalize_geometry!(geometry, normalizer)
+        case geometry["type"]
+
+        when "Point"
+          geometry["coordinates"] =
+            normalizer.normalize(geometry["coordinates"])
+
+        when "LineString"
+          geometry["coordinates"] =
+            geometry["coordinates"].map { |c| normalizer.normalize(c) }
+
+        when "MultiLineString"
+          geometry["coordinates"] =
+            geometry["coordinates"].map do |line|
+              line.map { |c| normalizer.normalize(c) }
+            end
+
+        when "Polygon"
+          geometry["coordinates"] =
+            geometry["coordinates"].map do |ring|
+              ring.map { |c| normalizer.normalize(c) }
+            end
+
+        when "MultiPolygon"
+          geometry["coordinates"] =
+            geometry["coordinates"].map do |poly|
+              poly.map do |ring|
+                ring.map { |c| normalizer.normalize(c) }
+              end
+            end
+        end
+      end
+
     end
   end
 end

data/lib/gd/gis/layer_lines.rb

@@ -1,35 +1,43 @@
 module GD
   module GIS
     class LinesLayer
-      def initialize(features, stroke:, width:)
-        @features = features
+      attr_accessor :debug
+
+      def initialize(lines, stroke:, width:)
+        @lines  = lines
         @stroke = stroke
-        @width = width
+        @width  = width
+        @debug  = false
       end
 
       def render!(img, projection)
-        @features.each do |f|
-          geom = f["geometry"]
+        @lines.each do |line|
+          raise "Invalid line: #{line.inspect}" unless valid_line?(line)
 
-          case geom["type"]
-          when "LineString"
-            draw_line(geom["coordinates"], img, projection)
-          when "MultiLineString"
-            geom["coordinates"].each do |line|
-              draw_line(line, img, projection)
-            end
+          pts = line.map do |lng, lat|
+            projection.call(lng, lat)
+          end
+
+          color = @debug ? ColorHelpers.random_vivid : @stroke
+
+          pts.each_cons(2) do |a, b|
+            img.line(
+              a[0], a[1],
+              b[0], b[1],
+              color,
+              thickness: @width
+            )
           end
         end
       end
 
-      def draw_line(coords, img, projection)
-        pts = coords.map { |p| projection.call(p[0], p[1]) }
+      private
 
-        (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
+      def valid_line?(line)
+        line.is_a?(Array) &&
+          line.size >= 2 &&
+          line.first.is_a?(Array) &&
+          line.first.size == 2
       end
     end
   end

data/lib/gd/gis/layer_points.rb

@@ -1,6 +1,7 @@
 module GD
   module GIS
     class PointsLayer
+
       def initialize(data, lon:, lat:, icon:, label: nil, font: nil, size: 12, color: [0,0,0])
         @data = data
         @lon = lon
@@ -24,12 +25,8 @@ module GD
       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)
-
+        img.antialias = true
+        
         white = GD::Color.rgb(255,255,255)
         black = GD::Color.rgb(0,0,0)
 

data/lib/gd/gis/layer_polygons.rb

@@ -1,11 +1,15 @@
 module GD
   module GIS
     class PolygonsLayer
+      attr_accessor :debug
+
       def initialize(polygons, fill:, stroke: nil, width: nil)
         @polygons = polygons
         @fill = fill
         @stroke = stroke
         @width = width
+
+	@debug = false
       end
 
       def self.from_lines(features, stroke:, fill:, width:)
@@ -21,18 +25,30 @@ module GD
       end
 
       def render!(img, projection)
-        @polygons.each do |poly|
-          pts = poly.map { |p| projection.call(p[0], p[1]) }
+        @polygons.each do |polygon|
+          # polygon = [ ring, ring, ... ]
+          polygon.each_with_index do |ring, idx|
+            pts = ring.map do |lng, lat|
+              projection.call(lng, lat)
+            end
 
-          img.filled_polygon(pts, @fill)
+            @stroke = GD::GIS::ColorHelpers.random_vivid if @debug
+            @fill   = GD::GIS::ColorHelpers.random_vivid if @debug
 
-          if @stroke
-            pts.each_cons(2) do |a,b|
-              img.line(a[0],a[1],b[0],b[1],@stroke, thickness: 1)
+            if idx == 0
+              # ring exterior
+              img.filled_polygon(pts, @fill)
+            end
+
+            if @stroke
+              pts.each_cons(2) do |a, b|
+                img.line(a[0], a[1], b[0], b[1], @stroke, thickness: (@width || 1))
+              end
             end
           end
         end
       end
+
     end
   end
 end