libgd-gis 0.2.7.pre.alpha.1 → 0.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6559ec92e07ae18e0a783d5d822c676437c68896928d7e2a59143ffd0ef9bb7e
-  data.tar.gz: d1d343b32dbef5a5093746577db4b61d678a27d42949737079f3ba8e4c840a9a
+  metadata.gz: 78e53ca4b47b3bd61cdc1a52268598fefbfa1797f2781a5296e4be856523787e
+  data.tar.gz: 2cbf66d159688eb784f2801527ba1856fc836c58211187c772ed1060ed702e36
 SHA512:
-  metadata.gz: 40cdba7a5707db6afde50b1358e6ae65eb936e34880d4ba2d593acfa72945cb09dc25661bab3dfdf7eefc6ea7f260171f9c38bc396dbeb2c42c83fc573964bd7
-  data.tar.gz: ac76fd31a7b28acae6067ed56ed4783d2dabb97992d19c841af25459204caf9e3180cd5bea9e74b9de8c583741ab187044ccbdcabd45ce1b2523438faf5c1b5b
+  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/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/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,7 +1,6 @@
 module GD
   module GIS
     class PointsLayer
-      attr_accessor :data, :size
 
       def initialize(data, lon:, lat:, icon:, label: nil, font: nil, size: 12, color: [0,0,0])
         @data = data
@@ -17,7 +16,6 @@ module GD
         @label = label
         @font  = font
         @size  = size
-        @data = data
         @color = color
 
         @icon.alpha_blending = true
@@ -27,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