libgd-gis 0.2.6 → 0.2.8

data/lib/gd/gis/map.rb

@@ -8,57 +8,151 @@ require_relative "layer_polygons"
 
 module GD
   module GIS
+    attr_accessor :debug
+
     class Map
       TILE_SIZE = 256
 
       attr_reader :image
+      attr_reader :layers
       attr_accessor :style
 
-      def initialize(bbox:, zoom:, basemap:)
-        @bbox     = bbox
-        @zoom     = zoom
-        @basemap  = Basemap.new(zoom, bbox, basemap)
+      def initialize(
+        bbox:,
+        zoom:,
+        basemap:,
+        width: nil,
+        height: nil,
+        crs: nil,
+	      fitted_bbox: false
+      )
+        # --------------------------------------------------
+        # 1. Basic input validation
+        # --------------------------------------------------
+        raise ArgumentError, "bbox must be [min_lng, min_lat, max_lng, max_lat]" unless
+          bbox.is_a?(Array) && bbox.size == 4
+
+        raise ArgumentError, "zoom must be an Integer" unless zoom.is_a?(Integer)
+
+        if (width && !height) || (!width && height)
+          raise ArgumentError, "width and height must be provided together"
+        end
+
+        @zoom   = zoom
+        @width  = width
+        @height = height
+
+        # --------------------------------------------------
+        # 2. CRS normalization (input → WGS84 lon/lat)
+        # --------------------------------------------------
+        if crs
+          normalizer = GD::GIS::CRS::Normalizer.new(crs)
+
+          min_lng, min_lat = normalizer.normalize(bbox[0], bbox[1])
+          max_lng, max_lat = normalizer.normalize(bbox[2], bbox[3])
+
+          bbox = [min_lng, min_lat, max_lng, max_lat]
+        end
+
+        # --------------------------------------------------
+        # 3. Final bbox (viewport-aware if width/height)
+        # --------------------------------------------------
+        @bbox =
+          if width && height && !fitted_bbox
+            GD::GIS::Geometry.viewport_bbox(
+              bbox: bbox,
+              zoom: zoom,
+              width: width,
+              height: height
+            )
+          else
+            bbox
+          end
+
+        # --------------------------------------------------
+        # 4. Basemap (uses FINAL bbox)
+        # --------------------------------------------------
+        @basemap = GD::GIS::Basemap.new(zoom, @bbox, basemap)
 
-        # 🔒 DO NOT CHANGE — this is the working GeoJSON pipeline
+        # --------------------------------------------------
+        # 5. Legacy semantic layers (REQUIRED by render)
+        # --------------------------------------------------
         @layers = {
-          motorway: [],
-          primary: [],
+          motorway:  [],
+          primary:   [],
           secondary: [],
-          street: [],
-          minor: [],
-          rail: [],
-          water: [],
-          park: []
+          street:    [],
+          minor:     [],
+          rail:      [],
+          water:     [],
+          park:      []
         }
 
-        # 🆕 overlay layers
+        # Optional alias (semantic clarity, no behavior change)
+        @road_layers = @layers
+
+        # --------------------------------------------------
+        # 6. Overlay layers (generic)
+        # --------------------------------------------------
         @points_layers   = []
         @lines_layers    = []
         @polygons_layers = []
 
+        # --------------------------------------------------
+        # 7. Style
+        # --------------------------------------------------
         @style = nil
+
+	      @debug = false
+      end
+
+      def features_by_layer(layer)
+        return [] unless @layers[layer]
+
+        @layers[layer].map do |item|
+          item.is_a?(Array) ? item.last : item
+        end
+      end
+
+      def features
+        @layers.values.flatten.map do |item|
+          item.is_a?(Array) ? item.last : item
+        end
       end
 
       # -----------------------------------
-      # GeoJSON input (unchanged)
+      # GeoJSON input (unchanged behavior)
       # -----------------------------------
-
       def add_geojson(path)
         features = LayerGeoJSON.load(path)
 
         features.each do |feature|
-          if Classifier.water?(feature)
-            kind = Classifier.water_kind(feature)
+          case feature.layer
+          when :water
+            kind =
+              case (feature.properties["objeto"] || feature.properties["waterway"]).to_s.downcase
+              when /river|río/     then :river
+              when /stream|arroyo/ then :stream
+              else :minor
+              end
+
             @layers[:water] << [kind, feature]
 
-          elsif Classifier.park?(feature)
-            @layers[:park] << feature
+          when :roads
+            @layers[:street] << feature
 
-          elsif Classifier.rail?(feature)
-            @layers[:rail] << feature
+          when :parks
+            @layers[:park] << feature
 
-          elsif type = Classifier.road(feature)
-            @layers[type] << feature
+          when :track
+            # elegí una:
+            @layers[:minor]  << feature
+            # o @layers[:street] << feature
+          else
+            geom_type = feature.geometry["type"]
+            if geom_type == "LineString" || geom_type == "MultiLineString"
+              @layers[:minor] << feature
+            end
           end
         end
       end
@@ -66,35 +160,12 @@ module GD
       # -----------------------------------
       # Overlay layers
       # -----------------------------------
-
       def add_points(data, **opts)
         @points_layers << GD::GIS::PointsLayer.new(data, **opts)
       end
 
-      def add_line(coords, **opts)
-        feature = {
-          "type" => "Feature",
-          "geometry" => {
-            "type" => "LineString",
-            "coordinates" => coords
-          },
-          "properties" => {}
-        }
-
-        add_lines([feature], **opts)
-      end
-
-      def add_multiline(lines, **opts)
-        feature = {
-            "type" => "Feature",
-            "geometry" => {
-                      "type" => "MultiLineString",
-                      "coordinates" => lines
-            },
-            "properties" => []
-          }
-
-        add_lines([feature], **opts)
+      def add_lines(features, **opts)
+        @lines_layers << GD::GIS::LinesLayer.new(features, **opts)
       end
 
       def add_polygons(polygons, **opts)
@@ -102,12 +173,21 @@ module GD
       end
 
       # -----------------------------------
-      # Rendering
+      # Rendering (LEGACY, UNCHANGED)
       # -----------------------------------
-
       def render
         raise "map.style must be set" unless @style
 
+        if @width && @height
+          render_viewport
+        else
+          render_tiles
+        end
+      end
+      
+      def render_tiles
+        raise "map.style must be set" unless @style
+
         tiles, x_min, y_min = @basemap.fetch_tiles
 
         xs = tiles.map { |t| t[0] }
@@ -141,7 +221,7 @@ module GD
           [(x - origin_x).round, (y - origin_y).round]
         end
 
-        # 1️⃣ Semantic GeoJSON layers (this is what was working)
+        # 1️⃣ GeoJSON semantic layers
         @style.order.each do |kind|
           draw_layer(kind, projection)
         end
@@ -152,6 +232,75 @@ module GD
         @points_layers.each   { |l| l.render!(@image, projection) }
       end
 
+      def render_viewport
+        raise "map.style must be set" unless @style
+
+        @image = GD::Image.new(@width, @height)
+        @image.antialias = false
+
+        # --------------------------------------------------
+        # 1. Compute global pixel bbox
+        # --------------------------------------------------
+        min_lng, min_lat, max_lng, max_lat = @bbox
+
+        x1, y1 = GD::GIS::Projection.lonlat_to_global_px(min_lng, max_lat, @zoom)
+        x2, y2 = GD::GIS::Projection.lonlat_to_global_px(max_lng, min_lat, @zoom)
+
+        # --------------------------------------------------
+        # 2. Fetch tiles
+        # --------------------------------------------------
+        tiles, = @basemap.fetch_tiles
+
+        # --------------------------------------------------
+        # 3. Draw tiles clipped to viewport
+        # --------------------------------------------------
+        tiles.each do |x, y, file|
+          tile = GD::Image.open(file)
+
+          tile_x = x * TILE_SIZE
+          tile_y = y * TILE_SIZE
+
+          dst_x = tile_x - x1
+          dst_y = tile_y - y1
+
+          src_x = [0, -dst_x].max
+          src_y = [0, -dst_y].max
+
+          draw_w = [TILE_SIZE - src_x, @width  - dst_x - src_x].min
+          draw_h = [TILE_SIZE - src_y, @height - dst_y - src_y].min
+
+          next if draw_w <= 0 || draw_h <= 0
+
+          @image.copy(
+            tile,
+            dst_x + src_x,
+            dst_y + src_y,
+            src_x,
+            src_y,
+            draw_w,
+            draw_h
+          )
+        end
+
+        # --------------------------------------------------
+        # 4. Projection (viewport version)
+        # --------------------------------------------------
+        projection = lambda do |lon, lat|
+          GD::GIS::Geometry.project(lon, lat, @bbox, @zoom)
+        end
+
+        # --------------------------------------------------
+        # 5. REUSE the same render pipeline
+        # --------------------------------------------------
+        @style.order.each do |kind|
+          draw_layer(kind, projection)
+        end
+
+        @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)
         @image.save(path)
       end
@@ -164,9 +313,12 @@ module GD
           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
+          when :rail
+            @style.rails
+          when :water
+            @style.water
+          when :park
+            @style.parks
           else
             @style.extra[kind] if @style.respond_to?(:extra)
           end
@@ -186,20 +338,25 @@ module GD
 
             if style[:stroke]
               color = GD::Color.rgb(*style[:stroke])
+
+              color = GD::GIS::ColorHelpers.random_vivid if @debug
+
               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
+
+                color = GD::GIS::ColorHelpers.random_vivid if @debug
+
+                width = style[:stroke_width] ? style[:stroke_width].round : 1
+                width = 1 if width < 1
                 f.draw(@image, projection, color, width)
               end
             end
@@ -207,18 +364,7 @@ module GD
         end
       end
 
-      private
-
-      def add_lines(features, **opts)
-        stroke = opts.delete(:color) || opts.delete(:stroke)
-        width = opts.delete(:width) || opts.delete(:stroke_width)
-
-        raise ArgumentError, "missing :color or :stroke" unless stroke
-        raise ArgumentError, "missing :width" unless width
-
-        @lines_layers << GD::GIS::LinesLayer.new(features, :stroke => stroke, :width => width)
-      end
-
     end
   end
 end
+

data/lib/gd/gis/middleware.rb

@@ -0,0 +1,89 @@
+module GD
+  module GIS
+    module CRS
+      CRS84      = "urn:ogc:def:crs:OGC:1.3:CRS84"
+      EPSG4326   = "EPSG:4326"
+      EPSG3857   = "EPSG:3857"
+      GK_ARGENTINA = "EPSG:22195"   # Gauss–Krüger Argentina (zone 5 example)
+
+      # Normalize any CRS → CRS84 (lon,lat in degrees)
+      class Normalizer
+        def initialize(crs)
+          @crs = normalize_name(crs)
+        end
+
+        def normalize(lon, lat)
+          case @crs
+          when CRS84
+            [lon, lat]
+
+          when EPSG4326
+            # EPSG:4326 uses (lat, lon)
+            [lat, lon]
+
+          when GK_ARGENTINA
+            gk_to_wgs84(lon, lat)
+
+          when EPSG3857
+            mercator_to_wgs84(lon, lat)
+
+          else
+            raise "Unsupported CRS: #{@crs}"
+          end
+        end
+
+        private
+
+        def normalize_name(name)
+          return CRS84 if name.nil?
+          name.to_s.strip
+        end
+
+        # Web Mercator → WGS84
+        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
+
+        # Gauss–Krüger Argentina (Zone 5) → WGS84
+        # This is enough precision for mapping
+        def gk_to_wgs84(easting, northing)
+          # Parameters for Argentina GK Zone 5
+          a = 6378137.0
+          f = 1 / 298.257223563
+          e2 = 2*f - f*f
+          lon0 = -60.0 * Math::PI / 180.0   # central meridian zone 5
+
+          x = easting - 500000.0
+          y = northing
+
+          m = y
+          mu = m / (a * (1 - e2/4 - 3*e2*e2/64))
+
+          e1 = (1 - Math.sqrt(1 - e2)) / (1 + Math.sqrt(1 - e2))
+
+          j1 = 3*e1/2 - 27*e1**3/32
+          j2 = 21*e1**2/16 - 55*e1**4/32
+
+          fp = mu + j1*Math.sin(2*mu) + j2*Math.sin(4*mu)
+
+          c1 = e2 * Math.cos(fp)**2
+          t1 = Math.tan(fp)**2
+          r1 = a * (1 - e2) / (1 - e2 * Math.sin(fp)**2)**1.5
+          n1 = a / Math.sqrt(1 - e2 * Math.sin(fp)**2)
+
+          d = x / n1
+
+          lat = fp - (n1*Math.tan(fp)/r1) *
+            (d**2/2 - (5 + 3*t1 + 10*c1)*d**4/24)
+
+          lon = lon0 + (d - (1 + 2*t1 + c1)*d**3/6) / Math.cos(fp)
+
+          [lon * 180.0 / Math::PI, lat * 180.0 / Math::PI]
+        end
+      end
+    end
+  end
+end

data/lib/gd/gis/ontology.rb

@@ -0,0 +1,26 @@
+require "yaml"
+
+module GD
+  module GIS
+    class Ontology
+      def initialize(path = nil)
+        path ||= File.expand_path("ontology.yml", __dir__)
+        @rules = YAML.load_file(path)
+      end
+
+      def classify(properties)
+        @rules.each do |layer, sources|
+          sources.each do |source, rules|
+            rules.each do |key, values|
+              v = (properties[key.to_s] || properties[key.to_sym]).to_s.strip.downcase
+              values = values.map { |x| x.to_s.downcase }
+
+              return layer.to_sym if values.any? { |x| v.include?(x) }
+            end
+          end
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/gd/gis/ontology.yml

@@ -0,0 +1,28 @@
+water:
+  ign:
+    objeto:
+      - canal
+      - río
+      - arroyo
+      - embalse
+      - laguna
+      - dique
+      - represa
+    gna:
+      - canal
+      - río
+      - arroyo
+      - embalse
+      - laguna
+
+  natural_earth:
+    featurecla:
+      - river
+      - lake
+      - reservoir
+      - riverbank
+
+track:
+  gps:
+    name:
+      - track

data/lib/gd/gis.rb

@@ -1,5 +1,6 @@
 require "gd"
 
+require_relative "gis/color_helpers"
 require_relative "gis/style"
 require_relative "gis/classifier"
 

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: libgd-gis
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.2.8
 platform: ruby
 authors:
 - Germán Alberto Giménez Silva
+autorequire:
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-01-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-libgd
@@ -15,20 +16,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.1
+        version: 0.2.3
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.1
+        version: 0.2.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.1
+        version: 0.2.3
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.1
+        version: 0.2.3
 description: A native GIS raster engine for Ruby built on libgd. Render maps, GeoJSON,
   heatmaps and tiles.
 email:
@@ -41,23 +42,30 @@ files:
 - lib/gd/gis.rb
 - lib/gd/gis/basemap.rb
 - lib/gd/gis/classifier.rb
+- lib/gd/gis/color_helpers.rb
+- lib/gd/gis/crs_normalizer.rb
 - lib/gd/gis/feature.rb
 - lib/gd/gis/geometry.rb
+- lib/gd/gis/input/detector.rb
+- lib/gd/gis/input/geojson.rb
+- lib/gd/gis/input/kml.rb
+- lib/gd/gis/input/shapefile.rb
 - lib/gd/gis/layer_geojson.rb
 - lib/gd/gis/layer_lines.rb
 - lib/gd/gis/layer_points.rb
 - lib/gd/gis/layer_polygons.rb
 - lib/gd/gis/map.rb
+- lib/gd/gis/middleware.rb
+- lib/gd/gis/ontology.rb
+- lib/gd/gis/ontology.yml
 - lib/gd/gis/projection.rb
 - lib/gd/gis/style.rb
-- lib/gd/gis/style/dark.rb
-- lib/gd/gis/style/light.rb
-- lib/gd/gis/style/solarized.rb
 - lib/libgd_gis.rb
 homepage: https://github.com/ggerman/libgd-gis
 licenses:
 - MIT
 metadata: {}
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -72,7 +80,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: Geospatial raster rendering for Ruby using libgd
 test_files: []

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

@@ -1,49 +0,0 @@
-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