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

data/lib/gd/gis/map.rb

@@ -8,55 +8,130 @@ 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 = []
 
-        @dynamic_points = []
-        @dynamic_lines  = []
-        @dynamic_polys  = []
-
+        # --------------------------------------------------
+        # 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|
           case feature.layer
           when :water
-            # optional: detect river vs canal from properties
             kind =
               case (feature.properties["objeto"] || feature.properties["waterway"]).to_s.downcase
-              when /river|río/   then :river
+              when /river|río/     then :river
               when /stream|arroyo/ then :stream
               else :minor
               end
@@ -64,14 +139,47 @@ module GD
             @layers[:water] << [kind, feature]
 
           when :roads
-            # map to style categories if you want later
             @layers[:street] << feature
 
           when :parks
             @layers[:park] << feature
 
+          when :track
+            # elegí una:
+            @layers[:minor]  << feature
+            # o @layers[:street] << feature
           else
-            # ignore unclassified for now
+            geom_type = feature.geometry["type"]
+
+            if geom_type == "Point"
+              points_style = @style.points or
+                raise ArgumentError, "Style error: missing 'points' section"
+
+              font = points_style[:font] or
+                raise ArgumentError, "Style error: points.font is required"
+
+              size = points_style[:size] or
+                raise ArgumentError, "Style error: points.size is required"
+
+              raw_color = points_style[:color]
+              color = @style.normalize_color(raw_color)
+
+              icon  = points_style.key?(:icon_fill) && points_style.key?(:icon_stroke) ? [points_style[:icon_stroke], points_style[:icon_stroke]] : nil
+              icon  = points_style.key?(:icon) ? points_style[:icon] : nil if icon.nil?
+
+              @points_layers << GD::GIS::PointsLayer.new(
+                [feature],
+                lon:   ->(f) { f.geometry["coordinates"][0] },
+                lat:   ->(f) { f.geometry["coordinates"][1] },
+                icon:  icon,
+                label: ->(f) { f.properties["name"] },  # 👈 TEXTO
+                font:  font,
+                size:  size,
+                color: color
+              )
+            elsif geom_type == "LineString" || geom_type == "MultiLineString"
+              @layers[:minor] << feature
+            end
           end
         end
       end
@@ -79,37 +187,12 @@ module GD
       # -----------------------------------
       # Overlay layers
       # -----------------------------------
-
       def add_points(data, **opts)
-        layer = GD::GIS::PointsLayer.new(data, **opts)
-        @points_layers << layer
-        layer
-      end
-
-      def add_line(coords, **opts)
-        feature = {
-          "type" => "Feature",
-          "geometry" => {
-            "type" => "LineString",
-            "coordinates" => coords
-          },
-          "properties" => {}
-        }
-
-        add_lines([feature], **opts)
+        @points_layers << GD::GIS::PointsLayer.new(data, **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)
@@ -117,12 +200,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] }
@@ -151,26 +243,89 @@ module GD
           )
         end
 
-        @projection = lambda do |lon, lat|
+        projection = lambda do |lon, lat|
           x, y = GD::GIS::Projection.lonlat_to_global_px(lon, lat, @zoom)
           [(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)
+          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) }
+        @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 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)
 
-        @dynamic_polys.each  { |l| l.render!(@image, @projection) }
-        @dynamic_lines.each  { |l| l.render!(@image, @projection) }
-        @dynamic_points.each { |l| l.render!(@image, @projection) }
+        # --------------------------------------------------
+        # 2. Fetch tiles
+        # --------------------------------------------------
+        tiles, = @basemap.fetch_tiles
 
-        @image
+        # --------------------------------------------------
+        # 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)
@@ -185,9 +340,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
@@ -207,77 +365,33 @@ module GD
 
             if style[:stroke]
               color = GD::Color.rgb(*style[:stroke])
-              f.draw(@image, @projection, color, width, :water)
-            end
 
+              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)
+              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)
+
+                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
           end
         end
       end
 
-      def clear_dynamic_layers
-        @dynamic_points.clear
-        @dynamic_lines.clear
-        @dynamic_polys.clear
-      end
-
-      def add_dynamic_point(data, **opts)
-        @dynamic_points << GD::GIS::PointsLayer.new(data, **opts)
-      end
-
-      def add_dynamic_line(coords, **opts)
-        feature = {
-          "type" => "Feature",
-          "geometry" => {
-            "type" => "LineString",
-            "coordinates" => coords
-          },
-          "properties" => {}
-        }
-        @dynamic_lines << GD::GIS::LinesLayer.new([feature], **opts)
-      end
-
-      def render_base
-        render
-        @base_image = @image
-      end
-
-      def render_with_base
-        img = GD::Image.new(@base_image.width, @base_image.height)
-        img.copy(@base_image, 0,0, 0,0, @base_image.width, @base_image.height)
-
-        @points_layers.each   { |l| l.render!(img, @projection) }
-        @lines_layers.each    { |l| l.render!(img, @projection) }
-        @polygons_layers.each{ |l| l.render!(img, @projection) }
-
-        img
-      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

@@ -8,7 +8,7 @@ module GD
         @rules = YAML.load_file(path)
       end
 
-      def classify(properties)
+      def classify(properties, geometry_type: nil)
         @rules.each do |layer, sources|
           sources.each do |source, rules|
             rules.each do |key, values|
@@ -19,8 +19,12 @@ module GD
             end
           end
         end
+
+        return :points if geometry_type == "Point"
+
         nil
       end
+
     end
   end
 end