map_view 0.0.1a

data/lib/gd/gis/feature.rb

@@ -0,0 +1,153 @@
+module GD
+  module GIS
+    class Feature
+      attr_reader :geometry, :properties, :layer
+
+      def initialize(geometry, properties, layer = nil)
+        @geometry   = geometry
+        @properties = properties || {}
+        @layer      = layer
+      end
+
+      # -------------------------------------------------
+      # Main draw entry point
+      # -------------------------------------------------
+      def draw(img, projection, color, width, layer = nil)
+        case geometry["type"]
+        when "Polygon"
+          if layer == :water
+            draw_polygon_outline(img, projection, geometry["coordinates"], color, width)
+          elsif layer.is_a?(Hash)
+            draw_polygon_styled(img, projection, geometry["coordinates"], layer)
+          else
+            draw_polygon(img, projection, geometry["coordinates"], color)
+          end
+        when "MultiPolygon"
+          geometry["coordinates"].each do |poly|
+            if layer == :water
+              draw_polygon_outline(img, projection, poly, color, width)
+            elsif layer.is_a?(Hash)
+              draw_polygon_styled(img, projection, poly, layer)
+            else
+              draw_polygon(img, projection, poly, color)
+            end
+          end
+        when "LineString", "MultiLineString"
+          draw_lines(img, projection, geometry["coordinates"], color, width)
+        end
+      end
+
+      # -------------------------------------------------
+      # Styled polygon rendering (fill + stroke)
+      # -------------------------------------------------
+      def draw_polygon_styled(img, projection, rings, style)
+        fill   = style[:fill]   ? GD::Color.rgb(*style[:fill])   : nil
+        stroke = style[:stroke] ? GD::Color.rgb(*style[:stroke]) : nil
+
+        rings.each do |ring|
+          pts = ring.map do |lon,lat|
+            x,y = projection.call(lon,lat)
+            next if x.nil? || y.nil?
+            [x.to_i, y.to_i]
+          end.compact
+
+          pts = pts.chunk_while { |a,b| a == b }.map(&:first)
+          next if pts.length < 3
+
+          img.filled_polygon(pts, fill) if fill
+
+          if stroke
+            pts.each_cons(2) { |a,b| img.line(a[0],a[1], b[0],b[1], stroke) }
+            img.line(pts.last[0], pts.last[1], pts.first[0], pts.first[1], stroke)
+          end
+        end
+      end
+
+      # -------------------------------------------------
+      # Polygon outline (used for water)
+      # -------------------------------------------------
+      def draw_polygon_outline(img, projection, rings, color, width)
+        return if color.nil?
+
+        rings.each do |ring|
+          pts = ring.map do |lon, lat|
+            x, y = projection.call(lon, lat)
+            [x.to_i, y.to_i] if x && y
+          end.compact
+
+          next if pts.size < 2
+
+          img.lines(pts, color, width)
+        end
+      end
+
+      # -------------------------------------------------
+      # Legacy filled polygon (single color)
+      # -------------------------------------------------
+      def draw_polygon(img, projection, rings, color)
+        return if color.nil?
+
+        rings.each do |ring|
+          pts = ring.map do |lon,lat|
+            x,y = projection.call(lon,lat)
+            next if x.nil? || y.nil?
+            [x.to_i, y.to_i]
+          end.compact
+
+          pts = pts.chunk_while { |a,b| a == b }.map(&:first)
+          next if pts.length < 3
+
+          img.filled_polygon(pts, color)
+        end
+      end
+
+      # -------------------------------------------------
+      # Lines
+      # -------------------------------------------------
+      def draw_lines(img, projection, coords, color, width)
+        return if color.nil?
+
+        if coords.first.is_a?(Array) && coords.first.first.is_a?(Array)
+          coords.each { |line| draw_line(img, projection, line, color, width) }
+        else
+          draw_line(img, projection, coords, color, width)
+        end
+      end
+
+      def draw_line(img, projection, coords, color, width)
+        return if color.nil?
+
+        coords.each_cons(2) do |(lon1,lat1),(lon2,lat2)|
+          x1,y1 = projection.call(lon1,lat1)
+          x2,y2 = projection.call(lon2,lat2)
+          img.line(x1, y1, x2, y2, color, thickness: width)
+        end
+      end
+
+      # -------------------------------------------------
+      # Metadata helpers
+      # -------------------------------------------------
+      def label
+        properties["name:ja"] || properties["name"]
+      end
+
+      def centroid
+        pts = []
+
+        case geometry["type"]
+        when "LineString"
+          pts = geometry["coordinates"]
+        when "MultiLineString"
+          pts = geometry["coordinates"].flatten(1)
+        end
+
+        return nil if pts.empty?
+
+        lon = pts.map(&:first).sum / pts.size
+        lat = pts.map(&:last).sum / pts.size
+
+        [lon, lat]
+      end
+    end
+  end
+end

data/lib/gd/gis/geometry.rb

@@ -0,0 +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)
+        validate_coords!(coords)
+
+        left  = []
+        right = []
+
+        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.zero?
+
+          nx = -dy / len
+          ny =  dx / len
+
+          off = meters / 111_320.0
+
+          left  << [x1 + nx * off, y1 + ny * off]
+          right << [x1 - nx * off, y1 - ny * off]
+        end
+
+        x2, y2 = coords.last
+        left  << [x2, y2]
+        right << [x2, y2]
+
+        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/input/detector.rb

@@ -0,0 +1,34 @@
+module GD
+  module GIS
+    module Input
+      module Detector
+        def self.detect(path)
+          return :geojson   if geojson?(path)
+          return :kml       if kml?(path)
+          return :shapefile if shapefile?(path)
+          return :osm_pbf   if pbf?(path)
+          :unknown
+        end
+
+        def self.geojson?(path)
+          File.open(path) do |f|
+            head = f.read(2048)
+            head.include?('"FeatureCollection"') || head.include?('"GeometryCollection"')
+          end
+        end
+
+        def self.kml?(path)
+          File.open(path) { |f| f.read(512).include?("<kml") }
+        end
+
+        def self.shapefile?(path)
+          File.open(path, "rb") { |f| f.read(4) == "\x00\x00\x27\x0A" }
+        end
+
+        def self.pbf?(path)
+          File.open(path, "rb") { |f| f.read(2) == "\x1f\x8b" }
+        end
+      end
+    end
+  end
+end

data/lib/gd/gis/layer_geojson.rb

@@ -0,0 +1,66 @@
+require "json"
+require_relative "feature"
+require_relative "crs_normalizer"
+require_relative "ontology"
+
+module GD
+  module GIS
+    class LayerGeoJSON
+
+      def self.load(path)
+        data = JSON.parse(File.read(path))
+
+        # 1) Detect CRS
+        crs_name   = data["crs"]&.dig("properties", "name")
+        normalizer = CRS::Normalizer.new(crs_name)
+
+        # 2) Load ontology
+        ontology = Ontology.new
+
+        # 3) Normalize geometries + classify
+        data["features"].map do |f|
+          normalize_geometry!(f["geometry"], normalizer)
+          layer = ontology.classify(f["properties"] || {})
+          Feature.new(f["geometry"], f["properties"], layer)
+        end
+      end
+
+      # --------------------------------------------
+      # CRS normalization (2D + 3D safe)
+      # --------------------------------------------
+      def self.normalize_geometry!(geometry, normalizer)
+        case geometry["type"]
+
+        when "Point"
+          geometry["coordinates"] =
+            normalizer.normalize(geometry["coordinates"])
+
+        when "LineString"
+          geometry["coordinates"] =
+            geometry["coordinates"].map { |c| normalizer.normalize(c) }
+
+        when "MultiLineString"
+          geometry["coordinates"] =
+            geometry["coordinates"].map do |line|
+              line.map { |c| normalizer.normalize(c) }
+            end
+
+        when "Polygon"
+          geometry["coordinates"] =
+            geometry["coordinates"].map do |ring|
+              ring.map { |c| normalizer.normalize(c) }
+            end
+
+        when "MultiPolygon"
+          geometry["coordinates"] =
+            geometry["coordinates"].map do |poly|
+              poly.map do |ring|
+                ring.map { |c| normalizer.normalize(c) }
+              end
+            end
+        end
+      end
+
+    end
+  end
+end

data/lib/gd/gis/layer_lines.rb

@@ -0,0 +1,44 @@
+module GD
+  module GIS
+    class LinesLayer
+      attr_accessor :debug
+
+      def initialize(lines, stroke:, width:)
+        @lines  = lines
+        @stroke = stroke
+        @width  = width
+        @debug  = false
+      end
+
+      def render!(img, projection)
+        @lines.each do |line|
+          raise "Invalid line: #{line.inspect}" unless valid_line?(line)
+
+          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
+
+      private
+
+      def valid_line?(line)
+        line.is_a?(Array) &&
+          line.size >= 2 &&
+          line.first.is_a?(Array) &&
+          line.first.size == 2
+      end
+    end
+  end
+end

data/lib/gd/gis/layer_points.rb

@@ -0,0 +1,78 @@
+module GD
+  module GIS
+    class PointsLayer
+
+      def initialize(data, lon:, lat:, icon:, label: nil, font: nil, size: 12, color: [0,0,0])
+        @data = data
+        @lon = lon
+        @lat = lat
+
+        if icon
+          @icon = GD::Image.open(icon)
+        else
+          @icon = build_default_marker
+        end
+
+        @label = label
+        @font  = font
+        @size  = size
+        @color = color
+
+        @icon.alpha_blending = true
+        @icon.save_alpha = true
+      end
+
+      def build_default_marker
+        size = 32
+        img = GD::Image.new(size, size)
+        img.antialias = true
+        
+        white = GD::Color.rgb(255,255,255)
+        black = GD::Color.rgb(0,0,0)
+
+        cx = size / 2
+        cy = size / 2
+        r  = 12
+
+        # borde blanco
+        img.arc(cx, cy, r*2+4, r*2+4, 0, 360, white)
+
+        # relleno negro
+        img.filled_arc(cx, cy, r*2, r*2, 0, 360, black)
+
+        img
+      end
+
+      def render!(img, projector)
+        w = @icon.width
+        h = @icon.height
+
+        @data.each do |row|
+          lon = @lon.call(row)
+          lat = @lat.call(row)
+
+          x,y = projector.call(lon,lat)
+
+          # icono
+          img.copy(@icon, x - w/2, y - h/2, 0,0,w,h)
+
+          # etiqueta opcional
+          if @label && @font
+            text = @label.call(row)
+            unless text.nil? || text.strip.empty?
+              font_h = @size * 1.1
+
+              img.text(text,
+                x: x + w/2 + 4,
+                y: y + font_h/2,
+                size: @size,
+                color: @color,
+                font: @font
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gd/gis/layer_polygons.rb

@@ -0,0 +1,54 @@
+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:)
+        polys = []
+
+        features.each do |f|
+          coords = f["geometry"]["coordinates"]
+          poly = Geometry.buffer_line(coords, width)
+          polys << poly
+        end
+
+        new(polys, fill: fill, stroke: stroke)
+      end
+
+      def render!(img, projection)
+        @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
+
+            @stroke = GD::GIS::ColorHelpers.random_vivid if @debug
+            @fill   = GD::GIS::ColorHelpers.random_vivid if @debug
+
+            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