GeoPosition.cs

using System;
using System.Diagnostics;
using System.Globalization;
using System.Text;
using System.Text.RegularExpressions;
using Waher.Persistence.Attributes;
using Waher.Script.Graphs;
 
namespace Waher.Runtime.Geo
{
    [DebuggerDisplay("{XmlValue}")]
    [TypeName(TypeNameSerialization.None)]
    public sealed class GeoPosition
    {
        public static readonly Regex XmlGeoPositionPattern = new Regex(@"(?'Lat'-?\d+(\.\d+)?),(?'Lon'-?\d+(\.\d+)?)(,(?'Alt'-?\d+(\.\d+)?))?", RegexOptions.Singleline | RegexOptions.Compiled);
 
        public static readonly Regex GpsGeoPositionPattern = new Regex(@"^\s*(?'LatDeg'\d+)\s*°?(\s*(?'LatMin'\d+)'(\s*(?'LatSec'\d+(\.\d+)?)"")?)?\s*(?'LatSign'[nNsS])\s*(?'LonDeg'\d+)\s*°?(\s*(?'LonMin'\d+)'(\s*(?'LonSec'\d+(\.\d+)?)"")?)?\s*(?'LonSign'[eEwW])(\s*,)?\s*((Alt|Altitude)\:?\s*)?((?'Alt'-?\d+(\.\d+)?)\s*(?'AltUnit'(m|ft))?)?\s*$", RegexOptions.Singleline | RegexOptions.Compiled);
 
        private double latitude;
        private double longitude;
        private double? altitude;
 
        public GeoPosition()
        {
        }
 
        public GeoPosition(double Latitude, double Longitude)
        {
            this.latitude = Latitude;
            this.longitude = Longitude;
            this.altitude = null;
        }
 
        public GeoPosition(double Latitude, double Longitude, double? Altitude)
        {
            this.latitude = Latitude;
            this.longitude = Longitude;
            this.altitude = Altitude;
        }
 
        public double Latitude
        {
            get => this.latitude;
            set
            {
                if (value < -90 || value > 90)
                    throw new ArgumentOutOfRangeException(nameof(this.Latitude), "Latitude must be between -90 and 90 degrees.");
 
                this.latitude = value;
            }
        }
 
        public double Longitude
        {
            get => this.longitude;
            set
            {
                if (value < -180 || value > 180)
                    throw new ArgumentOutOfRangeException(nameof(this.Longitude), "Longitude must be between -180 and 180 degrees.");
 
                this.longitude = value;
            }
        }
 
        public double? Altitude
        {
            get => this.altitude;
            set => this.altitude = value;
        }
 
        public double NormalizedLatitude
        {
            get
            {
                if (this.latitude < -90 || this.latitude > 90)
                    throw new InvalidOperationException("Latitude must be between -90 and 90 degrees.");
 
                return (this.latitude + 90) / 180;
            }
        }
 
        public double NormalizedLongitude
        {
            get
            {
                if (this.longitude < -180 || this.longitude > 180)
                    throw new InvalidOperationException("Longitude must be between -180 and 180 degrees.");
 
                return (this.longitude + 180) / 360;
            }
        }
 
        public static GeoPosition Parse(string s)
        {
            if (TryParse(s, out GeoPosition Value))
                return Value;
            else
                throw new FormatException("Invalid geo-position string: " + s);
        }
 
        public static bool TryParse(string s, out GeoPosition Value)
        {
            if (TryParseXml(s, out Value))
                return true;
 
            if (TryParseGps(s, out Value))
                return true;
 
            return false;
        }
 
        public static bool TryParseXml(string s, out GeoPosition Value)
        {
            int i = s.IndexOf(',');
            if (i < 0 ||
                !TryParse(s.Substring(0, i), out double Latitude) ||
                Latitude < -90 ||
                Latitude > 90)
            {
                Value = null;
                return false;
            }
 
            i++;
 
            int j = s.IndexOf(',', i);
            double Longitude;
            double? Altitude;
 
            if (j < 0)
            {
                if (!TryParse(s.Substring(i), out Longitude) ||
                    Longitude < -180 ||
                    Longitude > 180)
                {
                    Value = null;
                    return false;
                }
 
                Altitude = null;
            }
            else
            {
                if (!TryParse(s.Substring(i, j - i), out Longitude) ||
                    Longitude < -180 ||
                    Longitude > 180)
                {
                    Value = null;
                    return false;
                }
 
                if (!TryParse(s.Substring(j + 1), out double d))
                {
                    Value = null;
                    return false;
                }
 
                Altitude = d;
            }
 
            Value = new GeoPosition(Latitude, Longitude, Altitude);
 
            return true;
        }
 
        private static bool TryParse(string s, out double Value)
        {
            return double.TryParse(s.Replace(".", System.Globalization.NumberFormatInfo.CurrentInfo.NumberDecimalSeparator), out Value);
        }
 
        internal static string ToString(double Value)
        {
            string s = Value.ToString(CultureInfo.InvariantCulture);
            return Graph.TrimLabel(s);
        }
 
        internal static string ToString(bool Value)
        {
            return Value ? "true" : "false";
        }
 
        public static bool TryParseGps(string s, out GeoPosition Value)
        {
            Value = null;
 
            Match M = GpsGeoPositionPattern.Match(s);
            if (!M.Success || M.Index > 0 || M.Length < s.Length)
                return false;
 
            if (!TryParse(M.Groups["LatDeg"], M.Groups["LatMin"], M.Groups["LatSec"],
                M.Groups["LatSign"], -90, 90, out double Latitude))
            {
                return false;
            }
 
            if (!TryParse(M.Groups["LonDeg"], M.Groups["LonMin"], M.Groups["LonSec"],
                M.Groups["LonSign"], -180, 180, out double Longitude))
            {
                return false;
            }
 
            string AltitudeStr = M.Groups["Alt"].Value;
            if (string.IsNullOrEmpty(AltitudeStr))
                Value = new GeoPosition(Latitude, Longitude);
            else
            {
                if (!TryParse(AltitudeStr, out double Altitude))
                    return false;
 
                string Unit = M.Groups["AltUnit"].Value;
 
                if (!string.IsNullOrEmpty(Unit))
                {
                    switch (Unit.ToLower())
                    {
                        case "m":
                            break;
 
                        case "ft":
                            Altitude *= 0.3048;
                            break;
 
                        default:
                            return false;
                    }
                }
 
                Value = new GeoPosition(Latitude, Longitude, Altitude);
            }
 
            return true;
        }
 
        private static bool TryParse(Group Deg, Group Minute, Group Second, Group Sign,
            double Min, double Max, out double Value)
        {
            int i;
 
            if (Second is null || string.IsNullOrEmpty(Second.Value))
                Value = 0;
            else if (!TryParse(Second.Value, out Value))
                return false;
 
            Value /= 60;
 
            if (!string.IsNullOrEmpty(Minute?.Value))
            {
                if (!int.TryParse(Minute.Value, out i))
                    return false;
 
                Value += i;
            }
 
            Value /= 60;
 
            if (!int.TryParse(Deg.Value, out i))
                return false;
 
            Value += i;
 
            if (Sign is null || string.IsNullOrEmpty(Sign.Value) || Sign.Value.Length != 1)
                return false;
 
            char ch = char.ToUpper(Sign.Value[0]);
 
            if (ch == 'S' || ch == 'W')
                Value = -Value;
            else if (ch != 'N' && ch != 'E')
                return false;
 
            if (Value < Min || Value > Max)
                return false;
 
            return true;
        }
 
        public string XmlValue
        {
            get
            {
                StringBuilder sb = new StringBuilder();
 
                sb.Append(ToString(this.latitude));
                sb.Append(',');
                sb.Append(ToString(this.longitude));
 
                if (this.altitude.HasValue)
                {
                    sb.Append(',');
                    sb.Append(ToString(this.altitude.Value));
                }
 
                return sb.ToString();
            }
        }
 
        public string NormalizedValue
        {
            get
            {
                StringBuilder sb = new StringBuilder();
 
                sb.Append(ToString(this.NormalizedLatitude));
                sb.Append(',');
                sb.Append(ToString(this.NormalizedLongitude));
 
                if (this.altitude.HasValue)
                {
                    sb.Append(',');
                    sb.Append(ToString(this.altitude.Value));
                }
 
                return sb.ToString();
            }
        }
 
        public string HumanReadable
        {
            get
            {
                StringBuilder sb = new StringBuilder();
 
                Append(this.latitude, 'N', 'S', sb);
                sb.Append(' ');
                Append(this.longitude, 'E', 'W', sb);
 
                if (this.altitude.HasValue)
                {
                    sb.Append(", ");
                    sb.Append(ToString(this.altitude.Value));
                    sb.Append(" m");
                }
 
                return sb.ToString();
            }
        }
 
        private static void Append(double Nr, char PosChar, char NegChar, StringBuilder sb)
        {
            int Degrees;
            int Minutes;
            double Seconds;
            char Char;
 
            if (Nr >= 0)
                Char = PosChar;
            else
            {
                Char = NegChar;
                Nr = -Nr;
            }
 
            Degrees = (int)Nr;
            Nr -= Degrees;
            Nr *= 60;
 
            Minutes = (int)Nr;
            Nr -= Minutes;
            Nr *= 60;
 
            Seconds = Nr;
 
            if (Seconds < 1e-10)
                Seconds = 0;
            else if (Seconds > 60 - 1e-10)
            {
                Seconds = 0;
                Minutes++;
                if (Minutes == 60)
                {
                    Minutes = 0;
                    Degrees++;
                }
            }
 
            sb.Append(Degrees);
            sb.Append("° ");
 
            if (Minutes != 0 || Seconds != 0)
            {
                sb.Append(Minutes);
                sb.Append("' ");
 
                if (Seconds != 0)
                {
                    sb.Append(ToString(Seconds));
                    sb.Append("\" ");
                }
            }
 
            sb.Append(Char);
        }
 
        public override string ToString()
        {
            return this.XmlValue;
        }
 
        public override bool Equals(object obj)
        {
            return
                obj is GeoPosition P &&
                this.latitude == P.latitude &&
                this.longitude == P.longitude &&
                this.altitude == P.altitude;
        }
 
        public override int GetHashCode()
        {
            int Result = this.latitude.GetHashCode();
            Result ^= Result << 5 ^ this.longitude.GetHashCode();
 
            if (this.altitude.HasValue)
                Result ^= Result << 5 ^ this.altitude.Value.GetHashCode();
 
            return Result;
        }
 
        public static bool operator ==(GeoPosition A, GeoPosition B)
        {
            if (A is null ^ B is null)
                return false;
 
            if (A is null)
                return true;
 
            return A.Equals(B);
        }
 
        public static bool operator !=(GeoPosition A, GeoPosition B)
        {
            if (A is null ^ B is null)
                return true;
 
            if (A is null)
                return false;
 
            return !A.Equals(B);
        }
 
    }
}