geodetic 0.5.0 → 0.5.2

data/lib/geodetic/geojson.rb

@@ -0,0 +1,303 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Geodetic
+  class GeoJSON
+    include Enumerable
+
+    def initialize(*objects)
+      @objects = []
+      list = objects.length == 1 && objects[0].is_a?(Array) ? objects[0] : objects
+      list.each { |obj| add(obj) }
+    end
+
+    # --- Accumulate ---
+
+    def <<(object)
+      if object.is_a?(Array)
+        object.each { |obj| add(obj) }
+      else
+        add(object)
+      end
+      self
+    end
+
+    # --- Query ---
+
+    def size
+      @objects.size
+    end
+
+    alias length size
+
+    def empty?
+      @objects.empty?
+    end
+
+    def each(&block)
+      @objects.each(&block)
+    end
+
+    # --- Remove ---
+
+    def delete(object)
+      @objects.delete(object)
+      self
+    end
+
+    def clear
+      @objects.clear
+      self
+    end
+
+    # --- Export ---
+
+    def to_h
+      {
+        "type" => "FeatureCollection",
+        "features" => @objects.map { |obj| wrap_as_feature(obj) }
+      }
+    end
+
+    def to_json(pretty: false)
+      if pretty
+        JSON.pretty_generate(to_h)
+      else
+        JSON.generate(to_h)
+      end
+    end
+
+    def save(path, pretty: false)
+      File.write(path, to_json(pretty: pretty))
+    end
+
+    # --- Display ---
+
+    def to_s
+      "GeoJSON::FeatureCollection(#{size} features)"
+    end
+
+    def inspect
+      "#<Geodetic::GeoJSON size=#{size}>"
+    end
+
+    private
+
+    def add(object)
+      @objects << object
+    end
+
+    def wrap_as_feature(obj)
+      if obj.is_a?(Feature)
+        obj.to_geojson
+      else
+        { "type" => "Feature", "geometry" => obj.to_geojson, "properties" => {} }
+      end
+    end
+
+    # ---------------------------------------------------------------
+    # Geometry helpers (module-level, used by to_geojson on each type)
+    # ---------------------------------------------------------------
+
+    class << self
+      # --- Export helpers ---
+
+      def position(lla)
+        if lla.alt != 0.0
+          [lla.lng, lla.lat, lla.alt]
+        else
+          [lla.lng, lla.lat]
+        end
+      end
+
+      def point_hash(lla)
+        { "type" => "Point", "coordinates" => position(lla) }
+      end
+
+      def line_string_hash(lla_array)
+        { "type" => "LineString", "coordinates" => lla_array.map { |p| position(p) } }
+      end
+
+      def polygon_hash(rings)
+        { "type" => "Polygon", "coordinates" => rings.map { |ring| ring.map { |p| position(p) } } }
+      end
+
+      # --- Import ---
+
+      def load(path)
+        data = JSON.parse(File.read(path))
+        parse(data)
+      end
+
+      def parse(data)
+        case data["type"]
+        when "FeatureCollection"
+          data["features"].flat_map { |f| parse(f) }
+        when "Feature"
+          parse_feature(data)
+        when "GeometryCollection"
+          data["geometries"].flat_map { |g| parse_geometry(g) }
+        else
+          [parse_geometry(data)]
+        end
+      end
+
+      private
+
+      def parse_feature(data)
+        geometry = parse_geometry(data["geometry"])
+        properties = data["properties"] || {}
+
+        results = geometry.is_a?(Array) ? geometry : [geometry]
+
+        results.map do |geom|
+          name = properties["name"]
+          metadata = properties.reject { |k, _| k == "name" }
+
+          if name || !metadata.empty?
+            Feature.new(
+              label: name,
+              geometry: geom,
+              metadata: metadata.transform_keys(&:to_sym)
+            )
+          else
+            geom
+          end
+        end
+      end
+
+      def parse_geometry(data)
+        case data["type"]
+        when "Point"
+          parse_point(data["coordinates"])
+        when "LineString"
+          parse_line_string(data["coordinates"])
+        when "Polygon"
+          parse_polygon(data["coordinates"])
+        when "MultiPoint"
+          data["coordinates"].map { |pos| parse_point(pos) }
+        when "MultiLineString"
+          data["coordinates"].map { |coords| parse_line_string(coords) }
+        when "MultiPolygon"
+          data["coordinates"].map { |rings| parse_polygon(rings) }
+        when "GeometryCollection"
+          data["geometries"].flat_map { |g| parse_geometry(g) }
+        else
+          raise ArgumentError, "unknown GeoJSON geometry type: #{data["type"]}"
+        end
+      end
+
+      def parse_point(coords)
+        lng, lat = coords[0], coords[1]
+        alt = coords[2] || 0.0
+        Coordinate::LLA.new(lat: lat, lng: lng, alt: alt)
+      end
+
+      def parse_line_string(coords)
+        points = coords.map { |pos| parse_point(pos) }
+        if points.length == 2
+          Segment.new(points[0], points[1])
+        else
+          Path.new(coordinates: points)
+        end
+      end
+
+      def parse_polygon(rings)
+        outer = rings[0].map { |pos| parse_point(pos) }
+        # Remove closing point if it duplicates the first (Polygon#initialize adds it)
+        outer.pop if outer.length > 1 && outer.first == outer.last
+        Areas::Polygon.new(boundary: outer)
+      end
+    end
+
+    # ---------------------------------------------------------------
+    # Mixin for coordinate classes (applied at bottom of this file)
+    # ---------------------------------------------------------------
+
+    module CoordinateMethods
+      def to_geojson
+        if is_a?(Coordinate::ENU) || is_a?(Coordinate::NED)
+          raise ArgumentError,
+            "#{self.class.name.split('::').last} is a relative coordinate system " \
+            "and cannot be exported to GeoJSON without a reference point. " \
+            "Convert to an absolute system (e.g., LLA) first."
+        end
+
+        lla = is_a?(Coordinate::LLA) ? self : to_lla
+        GeoJSON.point_hash(lla)
+      end
+    end
+  end
+end
+
+# ---------------------------------------------------------------
+# Add to_geojson to non-coordinate geometry types
+# ---------------------------------------------------------------
+
+module Geodetic
+  class Segment
+    def to_geojson
+      GeoJSON.line_string_hash([@start_point, @end_point])
+    end
+  end
+
+  class Path
+    def to_geojson(as: :line_string)
+      raise ArgumentError, "path is empty" if empty?
+
+      if as == :polygon
+        raise ArgumentError, "need at least 3 coordinates for a polygon" if size < 3
+        ring = @coordinates.dup
+        ring << ring.first unless ring.first == ring.last
+        GeoJSON.polygon_hash([ring])
+      else
+        raise ArgumentError, "need at least 2 coordinates for a line string" if size < 2
+        GeoJSON.line_string_hash(@coordinates)
+      end
+    end
+  end
+
+  class Feature
+    def to_geojson
+      properties = {}
+      properties["name"] = @label if @label
+      properties.merge!(@metadata.transform_keys(&:to_s)) if @metadata && !@metadata.empty?
+      { "type" => "Feature", "geometry" => @geometry.to_geojson, "properties" => properties }
+    end
+  end
+
+  module Areas
+    class Polygon
+      def to_geojson
+        GeoJSON.polygon_hash([@boundary])
+      end
+    end
+
+    class Circle
+      def to_geojson(segments: 32)
+        step = 360.0 / segments
+        ring = segments.times.map do |i|
+          Vector.new(distance: @radius, bearing: step * i).destination_from(@centroid)
+        end
+        ring << ring.first
+        GeoJSON.polygon_hash([ring])
+      end
+    end
+
+    class BoundingBox
+      def to_geojson
+        ring = [nw, ne, @se, sw, nw]
+        GeoJSON.polygon_hash([ring])
+      end
+    end
+  end
+end
+
+# ---------------------------------------------------------------
+# Apply coordinate mixin to all registered coordinate classes
+# ---------------------------------------------------------------
+
+Geodetic::Coordinate.systems.each do |klass|
+  klass.include(Geodetic::GeoJSON::CoordinateMethods)
+end

data/lib/geodetic/path.rb

@@ -161,8 +161,9 @@ module Geodetic
     def bounds
       raise ArgumentError, "path is empty" if empty?
 
-      lats = @coordinates.map { |c| c.is_a?(Coordinate::LLA) ? c.lat : c.to_lla.lat }
-      lngs = @coordinates.map { |c| c.is_a?(Coordinate::LLA) ? c.lng : c.to_lla.lng }
+      llas = @coordinates.map { |c| c.is_a?(Coordinate::LLA) ? c : c.to_lla }
+      lats = llas.map(&:lat)
+      lngs = llas.map(&:lng)
 
       Areas::BoundingBox.new(
         nw: Coordinate::LLA.new(lat: lats.max, lng: lngs.min, alt: 0),
@@ -186,6 +187,8 @@ module Geodetic
     def intersects?(other_path)
       raise ArgumentError, "expected a Path" unless other_path.is_a?(Path)
 
+      return false unless bounds_overlap?(bounds, other_path.bounds)
+
       segments.each do |seg1|
         other_path.segments.each do |seg2|
           return true if seg1.intersects?(seg2)
@@ -494,19 +497,6 @@ module Geodetic
       end
     end
 
-    def resolve_point_from(other)
-      case other
-      when Feature
-        geo = other.geometry
-        geo.respond_to?(:centroid) ? geo.centroid : geo
-      when Path
-        raise ArgumentError, "path is empty" if other.empty?
-        other.first
-      else
-        other.respond_to?(:centroid) ? other.centroid : other
-      end
-    end
-
     def dup_path
       self.class.new(coordinates: @coordinates.dup)
     end
@@ -519,6 +509,13 @@ module Geodetic
       Vector.new(distance: distance_m, bearing: bearing_deg).destination_from(lla)
     end
 
+    def bounds_overlap?(a, b)
+      a.nw.lat >= b.se.lat &&
+        b.nw.lat >= a.se.lat &&
+        a.se.lng >= b.nw.lng &&
+        b.se.lng >= a.nw.lng
+    end
+
     def mean_bearing(b1, b2)
       r1 = b1 * RAD_PER_DEG
       r2 = b2 * RAD_PER_DEG

data/lib/geodetic/segment.rb

@@ -77,24 +77,8 @@ module Geodetic
 
     # Tests if a point lies on this segment within a tolerance (meters).
     def contains?(point, tolerance: 10.0)
-      target = point.is_a?(Coordinate::LLA) ? point : point.to_lla
-      seg_len = length_meters
-
-      return @start_point == target || @end_point == target if seg_len < 1e-6
-
-      dist_a_p = @start_point.distance_to(target).meters
-      dist_p_b = target.distance_to(@end_point).meters
-
-      # Exact endpoint match
-      return true if dist_a_p < 1e-6 || dist_p_b < 1e-6
-
-      return false if dist_a_p > seg_len || dist_p_b > seg_len
-
-      delta = Math.atan(tolerance / seg_len) * Geodetic::DEG_PER_RAD
-      bearing_ap = @start_point.bearing_to(target).degrees
-      bearing_pb = target.bearing_to(@end_point).degrees
-
-      (bearing_ap - bearing_pb).abs <= delta
+      _closest, distance = project(point)
+      distance <= tolerance
     end
 
     # True if the point is a vertex (start or end point).

data/lib/geodetic/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Geodetic
-  VERSION = "0.5.0"
+  VERSION = "0.5.2"
 end

data/lib/geodetic.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+module Geodetic
+  class Error < StandardError; end
+end
+
 require_relative "geodetic/version"
 require_relative "geodetic/datum"
 require_relative "geodetic/distance"
@@ -11,7 +15,4 @@ require_relative "geodetic/vector"
 require_relative "geodetic/segment"
 require_relative "geodetic/path"
 require_relative "geodetic/feature"
-
-module Geodetic
-  class Error < StandardError; end
-end
+require_relative "geodetic/geojson"

data/mkdocs.yml

@@ -132,6 +132,13 @@ nav:
       - UPS: coordinate-systems/ups.md
       - State Plane: coordinate-systems/state-plane.md
       - BNG: coordinate-systems/bng.md
+      - GH36: coordinate-systems/gh36.md
+      - GH: coordinate-systems/gh.md
+      - HAM: coordinate-systems/ham.md
+      - OLC: coordinate-systems/olc.md
+      - GEOREF: coordinate-systems/georef.md
+      - GARS: coordinate-systems/gars.md
+      - H3: coordinate-systems/h3.md
   - Reference:
       - Datums: reference/datums.md
       - Geoid Height: reference/geoid-height.md
@@ -141,4 +148,7 @@ nav:
       - Feature: reference/feature.md
       - Serialization: reference/serialization.md
       - Conversions: reference/conversions.md
+      - Vector: reference/vector.md
+      - Arithmetic: reference/arithmetic.md
+      - GeoJSON Export: reference/geojson.md
       - Map Rendering: reference/map-rendering.md

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: geodetic
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.2
 platform: ruby
 authors:
 - Dewayne VanHoozer
@@ -56,6 +56,7 @@ files:
 - docs/reference/datums.md
 - docs/reference/feature.md
 - docs/reference/geoid-height.md
+- docs/reference/geojson.md
 - docs/reference/map-rendering.md
 - docs/reference/path.md
 - docs/reference/segment.md
@@ -76,7 +77,9 @@ files:
 - examples/06_path_operations.rb
 - examples/07_segments_and_shapes.rb
 - examples/08_geodetic_arithmetic.rb
+- examples/09_geojson_export.rb
 - examples/README.md
+- examples/geodetic_demo.geojson
 - fiddle_pointer_buffer_pool.md
 - lib/geodetic.rb
 - lib/geodetic/areas.rb
@@ -114,6 +117,7 @@ files:
 - lib/geodetic/distance.rb
 - lib/geodetic/feature.rb
 - lib/geodetic/geoid_height.rb
+- lib/geodetic/geojson.rb
 - lib/geodetic/path.rb
 - lib/geodetic/segment.rb
 - lib/geodetic/vector.rb