map_view 0.0.1a → 0.1.0.pre.alpha

data/lib/gd/gis/geometry.rb

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

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

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

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

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

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