map_view 0.0.1a → 0.1.1.pre.alpha

data/lib/gd/gis/map.rb

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

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

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

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

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

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

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

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