map_view 0.0.1a

data/lib/gd/gis/map.rb

@@ -0,0 +1,370 @@
+require_relative "basemap"
+require_relative "projection"
+require_relative "classifier"
+require_relative "layer_geojson"
+require_relative "layer_points"
+require_relative "layer_lines"
+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:,
+        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)
+
+        # --------------------------------------------------
+        # 5. Legacy semantic layers (REQUIRED by render)
+        # --------------------------------------------------
+        @layers = {
+          motorway:  [],
+          primary:   [],
+          secondary: [],
+          street:    [],
+          minor:     [],
+          rail:      [],
+          water:     [],
+          park:      []
+        }
+
+        # 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 behavior)
+      # -----------------------------------
+      def add_geojson(path)
+        features = LayerGeoJSON.load(path)
+
+        features.each do |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]
+
+          when :roads
+            @layers[:street] << feature
+
+          when :parks
+            @layers[:park] << 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
+
+      # -----------------------------------
+      # Overlay layers
+      # -----------------------------------
+      def add_points(data, **opts)
+        @points_layers << GD::GIS::PointsLayer.new(data, **opts)
+      end
+
+      def add_lines(features, **opts)
+        @lines_layers << GD::GIS::LinesLayer.new(features, **opts)
+      end
+
+      def add_polygons(polygons, **opts)
+        @polygons_layers << GD::GIS::PolygonsLayer.new(polygons, **opts)
+      end
+
+      # -----------------------------------
+      # 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] }
+        ys = tiles.map { |t| t[1] }
+
+        cols = xs.max - xs.min + 1
+        rows = ys.max - ys.min + 1
+
+        width  = cols * TILE_SIZE
+        height = rows * TILE_SIZE
+
+        origin_x = x_min * TILE_SIZE
+        origin_y = y_min * TILE_SIZE
+
+        @image = GD::Image.new(width, height)
+        @image.antialias = false
+
+        # Basemap
+        tiles.each do |x, y, file|
+          tile = GD::Image.open(file)
+          @image.copy(
+            tile,
+            (x - x_min) * TILE_SIZE,
+            (y - y_min) * TILE_SIZE,
+            0, 0, TILE_SIZE, TILE_SIZE
+          )
+        end
+
+        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️⃣ GeoJSON semantic layers
+        @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 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
+
+      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
+            @style.rails
+          when :water
+            @style.water
+          when :park
+            @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])
+
+              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"
+              f.draw(@image, projection, nil, nil, style)
+            else
+              if style[:stroke]
+                color = GD::Color.rgb(*style[:stroke])
+
+                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
+
+    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/projection.rb

@@ -0,0 +1,39 @@
+module GD
+  module GIS
+    module Projection
+      R = 6378137.0
+
+      def self.mercator_x(lon)
+        lon * Math::PI / 180.0 * R
+      end
+
+      def self.mercator_y(lat)
+        Math.log(Math.tan(Math::PI/4 + lat * Math::PI / 360.0)) * R
+      end
+
+      def self.lonlat_to_pixel(lon, lat, min_x, max_x, min_y, max_y, width, height)
+        x = mercator_x(lon)
+        y = mercator_y(lat)
+
+        px = (x - min_x) / (max_x - min_x) * width
+        py = height - (y - min_y) / (max_y - min_y) * height
+
+        [px.to_i, py.to_i]
+      end
+
+      TILE_SIZE = 256
+
+      def self.lonlat_to_global_px(lon, lat, zoom)
+        lat = [[lat, 85.05112878].min, -85.05112878].max
+        n = 2.0 ** zoom
+
+        x = (lon + 180.0) / 360.0 * n * TILE_SIZE
+
+        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 * n * TILE_SIZE
+
+        [x, y]
+      end
+    end
+  end
+end

data/lib/gd/gis/style.rb

@@ -0,0 +1,45 @@
+require "yaml"
+
+module GD
+  module GIS
+    class Style
+      attr_reader :roads, :rails, :water, :parks, :order
+
+      def initialize(definition)
+        @roads = definition[:roads] || {}
+        @rails = definition[:rails] || {}
+        @water = definition[:water] || {}
+        @parks = definition[:parks] || {}
+        @order = definition[:order] || []
+      end
+
+      def self.load(name, from: "styles")
+        path = File.join(from, "#{name}.yml")
+        raise "Style not found: #{path}" unless File.exist?(path)
+
+        data = YAML.load_file(path)
+        data = deep_symbolize(data)
+
+        new(
+          roads: data[:roads],
+          rails: data[:rail] || data[:rails],
+          water: data[:water],
+          parks: data[:park] || data[:parks],
+          order: (data[:order] || []).map(&:to_sym)
+        )
+      end
+
+      def self.deep_symbolize(obj)
+        case obj
+        when Hash
+          obj.transform_keys(&:to_sym)
+             .transform_values { |v| deep_symbolize(v) }
+        when Array
+          obj.map { |v| deep_symbolize(v) }
+        else
+          obj
+        end
+      end
+    end
+  end
+end

data/lib/gd/gis.rb

@@ -0,0 +1,15 @@
+require "gd"
+
+require_relative "gis/color_helpers"
+require_relative "gis/style"
+require_relative "gis/classifier"
+
+require_relative "gis/feature"
+require_relative "gis/map"
+require_relative "gis/basemap"
+require_relative "gis/projection"
+require_relative "gis/geometry"
+require_relative "gis/layer_points"
+require_relative "gis/layer_lines"
+require_relative "gis/layer_polygons"
+require_relative "gis/layer_geojson"

data/lib/libgd_gis.rb

@@ -0,0 +1,44 @@
+require "libgd_gis"
+
+require "open-uri"
+require "tempfile"
+require "gd"
+
+module LibGD
+  module GIS
+    class Tile
+        attr_reader :z, :x, :y, :image
+
+        def self.osm(z:, x:, y:)
+        new(
+            z: z,
+            x: x,
+            y: y,
+            source: "https://api.maptiler.com/maps/basic/#{z}/#{x}/#{y}.png?key=GetYourOwnKey"
+        )
+        end
+
+        def initialize(z:, x:, y:, source:)
+            @z = z
+            @x = x
+            @y = y
+            @source = source
+        end
+
+        def render
+            tmp = Tempfile.new(["tile", ".png"])
+            tmp.binmode
+            tmp.write URI.open(@source).read
+            tmp.flush
+
+            @image = GD::Image.open(tmp.path)
+        ensure
+            tmp.close
+        end
+
+        def save(path)
+            @image.save(path)
+        end
+    end
+  end
+end