GeoExtensions.cs

using System.Text.RegularExpressions;
 
namespace Waher.Runtime.Geo
{
    public static class GeoExtensions
    {
        public static bool LiesOutside(this GeoPosition Position, GeoPosition Min, GeoPosition Max)
        {
            return Position.LiesOutside(Min, Max, false, false, false);
        }
 
        public static bool LiesOutside(this GeoPosition Position, GeoPosition Min, GeoPosition Max,
            bool IncludeMin, bool IncludeMax)
        {
            return Position.LiesOutside(Min, Max, IncludeMin, IncludeMax, false);
        }
 
        public static bool LiesOutside(this GeoPosition Position, GeoPosition Min, GeoPosition Max,
            bool IncludeMin, bool IncludeMax, bool IgnoreAltitude)
        {
            if (Position.Latitude.OutOfRange(Min?.Latitude, Max?.Latitude, IncludeMin, IncludeMax))
                return true;
 
            if (!(Min is null) && !(Max is null) && Min.Longitude > Max.Longitude)
            {
                if (!Position.Longitude.OutOfRange(Max.Longitude, Min.Longitude, !IncludeMin, !IncludeMax))
                    return true;
            }
            else
            {
                if (Position.Longitude.OutOfRange(Min?.Longitude, Max?.Longitude, IncludeMin, IncludeMax))
                    return true;
            }
 
            if (IgnoreAltitude)
                return false;
 
            if (Position.Altitude.HasValue &&
                Position.Altitude.Value.OutOfRange(Min?.Altitude, Max?.Altitude, IncludeMin, IncludeMax))
            {
                return true;
            }
 
            return false;
        }
 
        private static bool OutOfRange(this double Value, double? Min, double? Max,
            bool IncludeMin, bool IncludeMax)
        {
            int MinComp = Min.HasValue ? Value.CompareTo(Min.Value) : 1;
            int MaxComp = Max.HasValue ? Value.CompareTo(Max.Value) : -1;
 
            if (MinComp < 0 || IncludeMin && MinComp == 0)
                return true;
 
            if (MaxComp > 0 || IncludeMax && MaxComp == 0)
                return true;
 
            return false;
        }
 
        private static bool InRange(this double Value, double? Min, double? Max,
            bool IncludeMin, bool IncludeMax)
        {
            int MinComp = Min.HasValue ? Value.CompareTo(Min.Value) : 1;
            int MaxComp = Max.HasValue ? Value.CompareTo(Max.Value) : -1;
 
            if (MinComp < 0 || (!IncludeMin && MinComp == 0))
                return false;
 
            if (MaxComp > 0 || (!IncludeMax && MaxComp == 0))
                return false;
 
            return true;
        }
 
        public static bool NorthOf(this GeoPosition Position, GeoPosition Reference, bool IncludeReference)
        {
            int i = Position.Latitude.CompareTo(Reference.Latitude);
            return i > 0 || (IncludeReference && i == 0);
        }
 
        public static bool SouthOf(this GeoPosition Position, GeoPosition Reference, bool IncludeReference)
        {
            int i = Position.Latitude.CompareTo(Reference.Latitude);
            return i < 0 || (IncludeReference && i == 0);
        }
 
        public static bool EastOf(this GeoPosition Position, GeoPosition Reference, bool IncludeReference)
        {
            int i = Position.Longitude.CompareTo(Reference.Longitude);
            return i > 0 || (IncludeReference && i == 0);
        }
 
        public static bool WestOf(this GeoPosition Position, GeoPosition Reference, bool IncludeReference)
        {
            int i = Position.Longitude.CompareTo(Reference.Longitude);
            return i < 0 || (IncludeReference && i == 0);
        }
 
        public static bool NorthOf(this GeoPosition Position, IGeoBoundingBox Reference)
        {
            return Position.NorthOf(Reference.Max, !Reference.IncludeMax);
        }
 
        public static bool SouthOf(this GeoPosition Position, IGeoBoundingBox Reference)
        {
            return Position.SouthOf(Reference.Min, !Reference.IncludeMin);
        }
 
        public static bool EastOf(this GeoPosition Position, IGeoBoundingBox Reference)
        {
            if (Reference.LongitudeWrapped)
                return Position.EastOf(Reference.Min, !Reference.IncludeMin);
            else
                return Position.EastOf(Reference.Max, !Reference.IncludeMax);
        }
 
        public static bool WestOf(this GeoPosition Position, IGeoBoundingBox Reference)
        {
            if (Reference.LongitudeWrapped)
                return Position.WestOf(Reference.Max, !Reference.IncludeMax);
            else
                return Position.WestOf(Reference.Min, !Reference.IncludeMin);
        }
 
        public static bool AltitudeCheck(this GeoPosition Position, IGeoBoundingBox Reference)
        {
            if (Position.Altitude.HasValue)
            {
                return Position.Altitude.Value.InRange(Reference.Min?.Altitude, Reference.Max?.Altitude,
                    Reference.IncludeMin, Reference.IncludeMax);
            }
 
            return true;
        }
 
        public static bool GeoIdPatternCheck(this string GeoId, Regex Pattern)
        {
            Match M = Pattern.Match(GeoId);
 
            return M.Success && M.Index == 0 && M.Length == GeoId.Length;
        }
    }
}