geodetic 0.0.1

data/lib/geodetic/coordinates/ned.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+require_relative '../datum'
+
+module Geodetic
+  module Coordinates
+    class NED
+      attr_reader :n, :e, :d
+      alias_method :north, :n
+      alias_method :east, :e
+      alias_method :down, :d
+
+      def initialize(n: 0.0, e: 0.0, d: 0.0)
+        @n = n.to_f
+        @e = e.to_f
+        @d = d.to_f
+      end
+
+      def n=(value)
+        @n = value.to_f
+      end
+      alias_method :north=, :n=
+
+      def e=(value)
+        @e = value.to_f
+      end
+      alias_method :east=, :e=
+
+      def d=(value)
+        @d = value.to_f
+      end
+      alias_method :down=, :d=
+
+      def to_enu
+        ENU.new(e: @e, n: @n, u: -@d)
+      end
+
+      def self.from_enu(enu)
+        raise ArgumentError, "Expected ENU" unless enu.is_a?(ENU)
+
+        enu.to_ned
+      end
+
+      def to_ecef(reference_ecef, reference_lla = nil)
+        raise ArgumentError, "Expected ECEF" unless reference_ecef.is_a?(ECEF)
+
+        enu = self.to_enu
+        enu.to_ecef(reference_ecef, reference_lla)
+      end
+
+      def self.from_ecef(ecef, reference_ecef, reference_lla = nil)
+        raise ArgumentError, "Expected ECEF" unless ecef.is_a?(ECEF)
+        raise ArgumentError, "Expected ECEF" unless reference_ecef.is_a?(ECEF)
+
+        enu = ecef.to_enu(reference_ecef, reference_lla)
+        enu.to_ned
+      end
+
+      def to_lla(reference_lla)
+        raise ArgumentError, "Expected LLA" unless reference_lla.is_a?(LLA)
+
+        enu = self.to_enu
+        enu.to_lla(reference_lla)
+      end
+
+      def self.from_lla(lla, reference_lla)
+        raise ArgumentError, "Expected LLA" unless lla.is_a?(LLA)
+        raise ArgumentError, "Expected LLA" unless reference_lla.is_a?(LLA)
+
+        lla.to_ned(reference_lla)
+      end
+
+      def to_utm(reference_lla, datum = WGS84)
+        raise ArgumentError, "Expected LLA" unless reference_lla.is_a?(LLA)
+
+        lla = self.to_lla(reference_lla)
+        lla.to_utm(datum)
+      end
+
+      def self.from_utm(utm, reference_lla, datum = WGS84)
+        raise ArgumentError, "Expected UTM" unless utm.is_a?(UTM)
+        raise ArgumentError, "Expected LLA" unless reference_lla.is_a?(LLA)
+
+        lla = utm.to_lla(datum)
+        lla.to_ned(reference_lla)
+      end
+
+      def to_mgrs(reference_lla, datum = WGS84, precision = 5)
+        MGRS.from_lla(to_lla(reference_lla), datum, precision)
+      end
+
+      def self.from_mgrs(mgrs_coord, reference_lla, datum = WGS84)
+        lla = mgrs_coord.to_lla(datum)
+        from_lla(lla, reference_lla)
+      end
+
+      def to_usng(reference_lla, datum = WGS84, precision = 5)
+        USNG.from_lla(to_lla(reference_lla), datum, precision)
+      end
+
+      def self.from_usng(usng_coord, reference_lla, datum = WGS84)
+        lla = usng_coord.to_lla(datum)
+        from_lla(lla, reference_lla)
+      end
+
+      def to_web_mercator(reference_lla, datum = WGS84)
+        WebMercator.from_lla(to_lla(reference_lla), datum)
+      end
+
+      def self.from_web_mercator(wm_coord, reference_lla, datum = WGS84)
+        lla = wm_coord.to_lla(datum)
+        from_lla(lla, reference_lla)
+      end
+
+      def to_ups(reference_lla, datum = WGS84)
+        UPS.from_lla(to_lla(reference_lla), datum)
+      end
+
+      def self.from_ups(ups_coord, reference_lla, datum = WGS84)
+        lla = ups_coord.to_lla(datum)
+        from_lla(lla, reference_lla)
+      end
+
+      def to_state_plane(reference_lla, zone_code, datum = WGS84)
+        StatePlane.from_lla(to_lla(reference_lla), zone_code, datum)
+      end
+
+      def self.from_state_plane(sp_coord, reference_lla, datum = WGS84)
+        lla = sp_coord.to_lla(datum)
+        from_lla(lla, reference_lla)
+      end
+
+      def to_bng(reference_lla)
+        BNG.from_lla(to_lla(reference_lla))
+      end
+
+      def self.from_bng(bng_coord, reference_lla)
+        lla = bng_coord.to_lla
+        from_lla(lla, reference_lla)
+      end
+
+      def to_gh36(reference_lla, precision: 10)
+        GH36.new(to_lla(reference_lla), precision: precision)
+      end
+
+      def self.from_gh36(gh36_coord, reference_lla)
+        lla = gh36_coord.to_lla
+        from_lla(lla, reference_lla)
+      end
+
+      def to_s(precision = 2)
+        precision = precision.to_i
+        if precision == 0
+          "#{@n.round}, #{@e.round}, #{@d.round}"
+        else
+          format("%.#{precision}f, %.#{precision}f, %.#{precision}f", @n, @e, @d)
+        end
+      end
+
+      def to_a
+        [@n, @e, @d]
+      end
+
+      def self.from_array(array)
+        new(n: array[0].to_f, e: array[1].to_f, d: array[2].to_f)
+      end
+
+      def self.from_string(string)
+        parts = string.split(',').map(&:strip)
+        new(n: parts[0].to_f, e: parts[1].to_f, d: parts[2].to_f)
+      end
+
+      def ==(other)
+        return false unless other.is_a?(NED)
+
+        delta_n = (@n - other.n).abs
+        delta_e = (@e - other.e).abs
+        delta_d = (@d - other.d).abs
+
+        delta_n <= 1e-6 && delta_e <= 1e-6 && delta_d <= 1e-6
+      end
+
+
+      def horizontal_distance_to(other)
+        raise ArgumentError, "Expected NED" unless other.is_a?(NED)
+
+        dn = @n - other.n
+        de = @e - other.e
+
+        Math.sqrt(dn**2 + de**2)
+      end
+
+      # Local tangent-plane bearing to another NED point (degrees, 0-360).
+      # For great-circle bearing across coordinate systems, use the universal bearing_to.
+      def local_bearing_to(other)
+        raise ArgumentError, "Expected NED" unless other.is_a?(NED)
+
+        dn = other.n - @n
+        de = other.e - @e
+
+        bearing_rad = Math.atan2(de, dn)
+        bearing_deg = bearing_rad * DEG_PER_RAD
+
+        bearing_deg += 360 if bearing_deg < 0
+        bearing_deg
+      end
+
+      # Local tangent-plane elevation angle to another NED point (degrees).
+      # For elevation angle across coordinate systems, use the universal elevation_to.
+      def local_elevation_angle_to(other)
+        raise ArgumentError, "Expected NED" unless other.is_a?(NED)
+
+        horizontal_dist = horizontal_distance_to(other)
+        return 0.0 if horizontal_dist == 0.0
+
+        vertical_diff = @d - other.d
+        elevation_rad = Math.atan2(vertical_diff, horizontal_dist)
+        elevation_rad * DEG_PER_RAD
+      end
+
+      def distance_to_origin
+        Math.sqrt(@n**2 + @e**2 + @d**2)
+      end
+
+      def elevation_angle
+        horizontal_dist = Math.sqrt(@n**2 + @e**2)
+        return 0.0 if horizontal_dist == 0.0
+
+        elevation_rad = Math.atan2(-@d, horizontal_dist)
+        elevation_rad * DEG_PER_RAD
+      end
+
+      def bearing_from_origin
+        bearing_rad = Math.atan2(@e, @n)
+        bearing_deg = bearing_rad * DEG_PER_RAD
+
+        bearing_deg += 360 if bearing_deg < 0
+        bearing_deg
+      end
+
+      def horizontal_distance_to_origin
+        Math.sqrt(@n**2 + @e**2)
+      end
+    end
+  end
+end

data/lib/geodetic/coordinates/state_plane.rb

@@ -0,0 +1,451 @@
+# frozen_string_literal: true
+
+# State Plane Coordinate System (SPC)
+# US state-based coordinate systems using various projections
+# Each state has one or more zones with specific parameters
+
+module Geodetic
+  module Coordinates
+    class StatePlane
+      require_relative '../datum'
+
+      attr_reader :easting, :northing, :zone_code, :state, :datum
+
+      # State Plane zone definitions (simplified subset - real implementation would have all zones)
+      ZONES = {
+        # California zones (Lambert Conformal Conic)
+        'CA_I' => {
+          state: 'California',
+          zone: 'I',
+          fips: '0401',
+          epsg: '2225',
+          projection: 'lambert_conformal_conic',
+          central_meridian: -122.0,
+          standard_parallel_1: 40.0,
+          standard_parallel_2: 41.666667,
+          latitude_of_origin: 39.333333,
+          false_easting: 2000000.0,
+          false_northing: 500000.0,
+          units: 'US Survey Feet'
+        },
+        'CA_II' => {
+          state: 'California',
+          zone: 'II',
+          fips: '0402',
+          epsg: '2226',
+          projection: 'lambert_conformal_conic',
+          central_meridian: -122.0,
+          standard_parallel_1: 38.333333,
+          standard_parallel_2: 39.833333,
+          latitude_of_origin: 37.666667,
+          false_easting: 2000000.0,
+          false_northing: 500000.0,
+          units: 'US Survey Feet'
+        },
+        # Texas zones (Lambert Conformal Conic)
+        'TX_NORTH' => {
+          state: 'Texas',
+          zone: 'North',
+          fips: '4201',
+          epsg: '2275',
+          projection: 'lambert_conformal_conic',
+          central_meridian: -101.5,
+          standard_parallel_1: 34.65,
+          standard_parallel_2: 36.183333,
+          latitude_of_origin: 34.0,
+          false_easting: 200000.0,
+          false_northing: 1000000.0,
+          units: 'US Survey Feet'
+        },
+        # Florida zones (Transverse Mercator)
+        'FL_EAST' => {
+          state: 'Florida',
+          zone: 'East',
+          fips: '0901',
+          epsg: '2236',
+          projection: 'transverse_mercator',
+          central_meridian: -81.0,
+          scale_factor: 0.9999411764705882,
+          latitude_of_origin: 24.333333,
+          false_easting: 200000.0,
+          false_northing: 0.0,
+          units: 'US Survey Feet'
+        },
+        # New York zones (Transverse Mercator)
+        'NY_LONG_ISLAND' => {
+          state: 'New York',
+          zone: 'Long Island',
+          fips: '3104',
+          epsg: '2263',
+          projection: 'transverse_mercator',
+          central_meridian: -74.0,
+          scale_factor: 0.9999,
+          latitude_of_origin: 40.166667,
+          false_easting: 300000.0,
+          false_northing: 0.0,
+          units: 'US Survey Feet'
+        }
+      }
+
+      # Unit conversion factors
+      METERS_PER_US_SURVEY_FOOT = 1200.0 / 3937.0
+      US_SURVEY_FEET_PER_METER = 3937.0 / 1200.0
+      METERS_PER_INTERNATIONAL_FOOT = 0.3048
+      INTERNATIONAL_FEET_PER_METER = 1.0 / 0.3048
+
+      def initialize(easting: 0.0, northing: 0.0, zone_code: 'CA_I', datum: WGS84)
+        @easting = easting.to_f
+        @northing = northing.to_f
+        @zone_code = zone_code.to_s.upcase
+        @datum = datum
+
+        validate_zone
+      end
+
+      def easting=(value)
+        @easting = value.to_f
+      end
+
+      def northing=(value)
+        @northing = value.to_f
+      end
+
+      def zone_code=(value)
+        value = value.to_s.upcase
+        raise ArgumentError, "Unknown State Plane zone: #{value}" unless ZONES.key?(value)
+        @zone_code = value
+      end
+
+      def to_s(precision = 2)
+        precision = precision.to_i
+        if precision == 0
+          "#{@easting.round}, #{@northing.round}, #{@zone_code}"
+        else
+          format("%.#{precision}f, %.#{precision}f, %s", @easting, @northing, @zone_code)
+        end
+      end
+
+      def to_a
+        [@easting, @northing, @zone_code]
+      end
+
+      def self.from_array(array)
+        new(easting: array[0].to_f, northing: array[1].to_f, zone_code: array[2].to_s)
+      end
+
+      def self.from_string(string)
+        parts = string.split(',').map(&:strip)
+        new(easting: parts[0].to_f, northing: parts[1].to_f, zone_code: parts[2].to_s)
+      end
+
+      def zone_info
+        ZONES[@zone_code]
+      end
+
+      def to_lla(datum = nil)
+        datum ||= @datum
+        zone_info = ZONES[@zone_code]
+
+        case zone_info[:projection]
+        when 'lambert_conformal_conic'
+          lambert_conformal_conic_to_lla(zone_info, datum)
+        when 'transverse_mercator'
+          transverse_mercator_to_lla(zone_info, datum)
+        else
+          raise ArgumentError, "Unsupported projection: #{zone_info[:projection]}"
+        end
+      end
+
+      def self.from_lla(lla_coord, zone_code, datum = WGS84)
+        zone_info = ZONES[zone_code.to_s.upcase]
+        raise ArgumentError, "Unknown zone: #{zone_code}" unless zone_info
+
+        case zone_info[:projection]
+        when 'lambert_conformal_conic'
+          from_lla_lambert_conformal_conic(lla_coord, zone_code, zone_info, datum)
+        when 'transverse_mercator'
+          from_lla_transverse_mercator(lla_coord, zone_code, zone_info, datum)
+        else
+          raise ArgumentError, "Unsupported projection: #{zone_info[:projection]}"
+        end
+      end
+
+      def to_ecef(datum = nil)
+        to_lla(datum).to_ecef(datum || @datum)
+      end
+
+      def self.from_ecef(ecef_coord, zone_code, datum = WGS84)
+        lla_coord = ecef_coord.to_lla(datum)
+        from_lla(lla_coord, zone_code, datum)
+      end
+
+      def to_utm(datum = nil)
+        to_lla(datum).to_utm(datum || @datum)
+      end
+
+      def self.from_utm(utm_coord, zone_code, datum = WGS84)
+        lla_coord = utm_coord.to_lla(datum)
+        from_lla(lla_coord, zone_code, datum)
+      end
+
+      def to_enu(reference_lla, datum = nil)
+        to_lla(datum).to_enu(reference_lla)
+      end
+
+      def self.from_enu(enu_coord, reference_lla, zone_code, datum = WGS84)
+        lla_coord = enu_coord.to_lla(reference_lla)
+        from_lla(lla_coord, zone_code, datum)
+      end
+
+      def to_ned(reference_lla, datum = nil)
+        to_lla(datum).to_ned(reference_lla)
+      end
+
+      def self.from_ned(ned_coord, reference_lla, zone_code, datum = WGS84)
+        lla_coord = ned_coord.to_lla(reference_lla)
+        from_lla(lla_coord, zone_code, datum)
+      end
+
+      def to_mgrs(datum = nil, precision = 5)
+        MGRS.from_lla(to_lla(datum), datum || @datum, precision)
+      end
+
+      def self.from_mgrs(mgrs_coord, zone_code, datum = WGS84)
+        lla_coord = mgrs_coord.to_lla(datum)
+        from_lla(lla_coord, zone_code, datum)
+      end
+
+      def to_usng(datum = nil, precision = 5)
+        USNG.from_lla(to_lla(datum), datum || @datum, precision)
+      end
+
+      def self.from_usng(usng_coord, zone_code, datum = WGS84)
+        lla_coord = usng_coord.to_lla(datum)
+        from_lla(lla_coord, zone_code, datum)
+      end
+
+      def to_web_mercator(datum = nil)
+        WebMercator.from_lla(to_lla(datum), datum || @datum)
+      end
+
+      def self.from_web_mercator(web_mercator_coord, zone_code, datum = WGS84)
+        lla_coord = web_mercator_coord.to_lla(datum)
+        from_lla(lla_coord, zone_code, datum)
+      end
+
+      def to_ups(datum = nil)
+        UPS.from_lla(to_lla(datum), datum || @datum)
+      end
+
+      def self.from_ups(ups_coord, zone_code, datum = WGS84)
+        lla_coord = ups_coord.to_lla(datum)
+        from_lla(lla_coord, zone_code, datum)
+      end
+
+      def to_bng(datum = nil)
+        BNG.from_lla(to_lla(datum), datum || @datum)
+      end
+
+      def self.from_bng(bng_coord, zone_code, datum = WGS84)
+        lla_coord = bng_coord.to_lla(datum)
+        from_lla(lla_coord, zone_code, datum)
+      end
+
+      def to_gh36(datum = nil, precision: 10)
+        GH36.new(to_lla(datum), precision: precision)
+      end
+
+      def self.from_gh36(gh36_coord, zone_code, datum = WGS84)
+        lla_coord = gh36_coord.to_lla(datum)
+        from_lla(lla_coord, zone_code, datum)
+      end
+
+      # Unit conversion methods
+      def to_meters
+        zone_info = ZONES[@zone_code]
+        if zone_info[:units] == 'US Survey Feet'
+          easting_m = @easting * METERS_PER_US_SURVEY_FOOT
+          northing_m = @northing * METERS_PER_US_SURVEY_FOOT
+        else
+          easting_m = @easting
+          northing_m = @northing
+        end
+
+        StatePlane.new(easting: easting_m, northing: northing_m, zone_code: @zone_code, datum: @datum)
+      end
+
+      def to_us_survey_feet
+        zone_info = ZONES[@zone_code]
+        if zone_info[:units] == 'US Survey Feet'
+          return self
+        else
+          easting_ft = @easting * US_SURVEY_FEET_PER_METER
+          northing_ft = @northing * US_SURVEY_FEET_PER_METER
+          StatePlane.new(easting: easting_ft, northing: northing_ft, zone_code: @zone_code, datum: @datum)
+        end
+      end
+
+      # Distance calculation
+      def ==(other)
+        return false unless other.is_a?(StatePlane)
+
+        (@easting - other.easting).abs <= 1e-6 &&
+        (@northing - other.northing).abs <= 1e-6 &&
+        @zone_code == other.zone_code
+      end
+
+
+      def valid?
+        ZONES.key?(@zone_code)
+      end
+
+      # Get all available zones for a state
+      def self.zones_for_state(state_name)
+        ZONES.select { |code, info| info[:state].downcase == state_name.downcase }
+      end
+
+      # Find appropriate zone for a given LLA coordinate
+      def self.find_zone_for_lla(lla_coord, state_name = nil)
+        # This is a simplified version - real implementation would use precise zone boundaries
+        candidate_zones = state_name ? zones_for_state(state_name) : ZONES
+
+        # For now, return the first zone in the state (in practice, would check boundaries)
+        candidate_zones.keys.first
+      end
+
+      private
+
+      def validate_zone
+        unless ZONES.key?(@zone_code)
+          raise ArgumentError, "Unknown State Plane zone: #{@zone_code}"
+        end
+      end
+
+      def lambert_conformal_conic_to_lla(zone_info, datum)
+        # Lambert Conformal Conic inverse projection
+        a = datum.a
+        e = datum.e
+        e2 = datum.e2
+
+        # Zone parameters
+        lat0_rad = zone_info[:latitude_of_origin] * RAD_PER_DEG
+        lon0_rad = zone_info[:central_meridian] * RAD_PER_DEG
+        phi1_rad = zone_info[:standard_parallel_1] * RAD_PER_DEG
+        phi2_rad = zone_info[:standard_parallel_2] * RAD_PER_DEG
+        false_easting = zone_info[:false_easting]
+        false_northing = zone_info[:false_northing]
+
+        # Convert to meters if necessary
+        x = @easting
+        y = @northing
+        if zone_info[:units] == 'US Survey Feet'
+          x = x * METERS_PER_US_SURVEY_FOOT - false_easting * METERS_PER_US_SURVEY_FOOT
+          y = y * METERS_PER_US_SURVEY_FOOT - false_northing * METERS_PER_US_SURVEY_FOOT
+        else
+          x = x - false_easting
+          y = y - false_northing
+        end
+
+        # Lambert Conformal Conic calculations (simplified)
+        # This is a complex calculation - using simplified approximation
+        lat = lat0_rad + (y / a)
+        lng = lon0_rad + (x / (a * Math.cos(lat0_rad)))
+
+        lat = [[-90.0, lat * DEG_PER_RAD].max, 90.0].min
+        lng = [[-180.0, lng * DEG_PER_RAD].max, 180.0].min
+
+        LLA.new(lat: lat, lng: lng, alt: 0.0)
+      end
+
+      def transverse_mercator_to_lla(zone_info, datum)
+        # Transverse Mercator inverse projection
+        a = datum.a
+        e = datum.e
+        e2 = datum.e2
+
+        # Zone parameters
+        lat0_rad = zone_info[:latitude_of_origin] * RAD_PER_DEG
+        lon0_rad = zone_info[:central_meridian] * RAD_PER_DEG
+        k0 = zone_info[:scale_factor] || 0.9996
+        false_easting = zone_info[:false_easting]
+        false_northing = zone_info[:false_northing]
+
+        # Convert to meters if necessary
+        x = @easting
+        y = @northing
+        if zone_info[:units] == 'US Survey Feet'
+          x = (x - false_easting) * METERS_PER_US_SURVEY_FOOT
+          y = (y - false_northing) * METERS_PER_US_SURVEY_FOOT
+        else
+          x = x - false_easting
+          y = y - false_northing
+        end
+
+        # Simplified Transverse Mercator inverse (approximation)
+        lat = lat0_rad + (y / (a * k0))
+        lng = lon0_rad + (x / (a * k0 * Math.cos(lat0_rad)))
+
+        lat = lat * DEG_PER_RAD
+        lng = lng * DEG_PER_RAD
+
+        lat = [[-90.0, lat].max, 90.0].min
+        lng = [[-180.0, lng].max, 180.0].min
+
+        LLA.new(lat: lat, lng: lng, alt: 0.0)
+      end
+
+      def self.from_lla_lambert_conformal_conic(lla_coord, zone_code, zone_info, datum)
+        # Lambert Conformal Conic forward projection (simplified)
+        lat = lla_coord.lat * RAD_PER_DEG
+        lng = lla_coord.lng * RAD_PER_DEG
+
+        lat0_rad = zone_info[:latitude_of_origin] * RAD_PER_DEG
+        lon0_rad = zone_info[:central_meridian] * RAD_PER_DEG
+
+        a = datum.a
+
+        # Simplified calculation
+        x = a * (lng - lon0_rad) * Math.cos(lat0_rad)
+        y = a * (lat - lat0_rad)
+
+        # Apply false easting/northing
+        if zone_info[:units] == 'US Survey Feet'
+          x = x * US_SURVEY_FEET_PER_METER + zone_info[:false_easting]
+          y = y * US_SURVEY_FEET_PER_METER + zone_info[:false_northing]
+        else
+          x = x + zone_info[:false_easting]
+          y = y + zone_info[:false_northing]
+        end
+
+        new(easting: x, northing: y, zone_code: zone_code, datum: datum)
+      end
+
+      def self.from_lla_transverse_mercator(lla_coord, zone_code, zone_info, datum)
+        # Transverse Mercator forward projection (simplified)
+        lat = lla_coord.lat * RAD_PER_DEG
+        lng = lla_coord.lng * RAD_PER_DEG
+
+        lat0_rad = zone_info[:latitude_of_origin] * RAD_PER_DEG
+        lon0_rad = zone_info[:central_meridian] * RAD_PER_DEG
+        k0 = zone_info[:scale_factor] || 0.9996
+
+        a = datum.a
+
+        # Simplified calculation
+        x = a * k0 * (lng - lon0_rad) * Math.cos(lat0_rad)
+        y = a * k0 * (lat - lat0_rad)
+
+        # Apply false easting/northing
+        if zone_info[:units] == 'US Survey Feet'
+          x = x * US_SURVEY_FEET_PER_METER + zone_info[:false_easting]
+          y = y * US_SURVEY_FEET_PER_METER + zone_info[:false_northing]
+        else
+          x = x + zone_info[:false_easting]
+          y = y + zone_info[:false_northing]
+        end
+
+        new(easting: x, northing: y, zone_code: zone_code, datum: datum)
+      end
+    end
+  end
+end