Support of the Auxiliary Mercator Sphere projection. (#127)

* Support of the Auxiliary Mercator Sphere projection.

* Fixed unsupported c# 8.0 feature.

* Changed WKT to a not corrupted format

Author: mario-mu

src/ProjNet/CoordinateSystems/Projections/MercatorAuxiliarySphere.cs

@@ -0,0 +1,110 @@
+using ProjNet.CoordinateSystems.Transformations;
+using System;
+using System.Collections.Generic;
+
+namespace ProjNet.CoordinateSystems.Projections
+{
+    /// <summary>
+    /// Implements the Mercator Auxiliary Sphere projection (Web Mercator).
+    /// This projection uses a spherical model with a constant radius.
+    /// </summary>
+    [Serializable]
+    internal class MercatorAuxiliarySphere : MapProjection
+    {
+        // Scale factor – for the spherical (auxiliary) Mercator this is 1.
+        private const double _k0 = 1.0;
+
+        /// <summary>
+        /// Initializes the MercatorAuxiliarySphere projection with the specified parameters.
+        /// </summary>
+        /// <param name="parameters">List of projection parameters.</param>
+        public MercatorAuxiliarySphere(IEnumerable<ProjectionParameter> parameters)
+            : this(parameters, null)
+        {
+        }
+
+        /// <summary>
+        /// Initializes the MercatorAuxiliarySphere projection with the specified parameters.
+        /// </summary>
+        /// <param name="parameters">List of projection parameters.</param>
+        /// <param name="isInverse">Reference to the inverse projection.</param>
+        protected MercatorAuxiliarySphere(IEnumerable<ProjectionParameter> parameters, MercatorAuxiliarySphere isInverse)
+            : base(parameters, isInverse)
+        {
+            Authority = "EPSG";
+            Name = "Mercator_Auxiliary_Sphere";
+        }
+
+        /// <summary>
+        /// Converts geographic coordinates (in radians) to projected coordinates (in meters).
+        /// </summary>
+        /// <param name="lon">Longitude in radians.</param>
+        /// <param name="lat">Latitude in radians.</param>
+        /// <remarks>
+        /// It is assumed that _semiMajor and central_meridian (as well as other parameters like false_easting/false_northing)
+        /// are already set in the base class.
+        /// </remarks>
+        protected override void RadiansToMeters(ref double lon, ref double lat)
+        {
+            if (double.IsNaN(lon) || double.IsNaN(lat))
+            {
+                lon = double.NaN;
+                lat = double.NaN;
+                return;
+            }
+
+            double dLon = lon;
+            double dLat = lat;
+
+            if (Math.Abs(Math.Abs(dLat) - HALF_PI) <= EPSLN)
+            {
+                throw new ArgumentException("Transformation cannot be computed at the poles.");
+            }
+
+            // Forward equations for the Spherical (Auxiliary) Mercator Projection:
+            // X = semiMajor * k0 * (lon - central_meridian)
+            // Y = semiMajor * k0 * ln( tan(PI/4 + lat/2) )
+            lon = _semiMajor * _k0 * (dLon - central_meridian);
+            lat = _semiMajor * _k0 * Math.Log(Math.Tan((PI * 0.25) + (dLat * 0.5)));
+            // Note: false_easting and false_northing can be added here if necessary.
+        }
+
+        /// <summary>
+        /// Converts projected coordinates (in meters) to geographic coordinates (in radians).
+        /// </summary>
+        /// <param name="x">X coordinate in meters.</param>
+        /// <param name="y">Y coordinate in meters.</param>
+        /// <remarks>
+        /// Uses the inverse transformation of the Spherical Mercator Projection.
+        /// </remarks>
+        protected override void MetersToRadians(ref double x, ref double y)
+        {
+            double dX = x;
+            double dY = y;
+
+            // Inverse equations:
+            // lon = central_meridian + X / (semiMajor * k0)
+            // lat = PI/2 - 2 * atan( exp( -Y / (semiMajor * k0) ) )
+            double ts = Math.Exp(-dY / (_semiMajor * _k0));
+            double dLat = HALF_PI - (2 * Math.Atan(ts));
+            double dLon = central_meridian + (dX / (_semiMajor * _k0));
+
+            x = dLon;
+            y = dLat;
+            // Note: false_easting/false_northing can be subtracted here if provided in the parameter list.
+        }
+
+        /// <summary>
+        /// Returns the inverse transformation of this projection.
+        /// </summary>
+        /// <returns>The inverse projection as MathTransform.</returns>
+        public override MathTransform Inverse()
+        {
+            if (_inverse is null)
+            {
+                _inverse = new MercatorAuxiliarySphere(_Parameters.ToProjectionParameter(), this);
+            }
+            return _inverse;
+        }
+    }
+}

src/ProjNet/CoordinateSystems/Projections/ProjectionsRegistry.cs

@@ -1,7 +1,6 @@
+using ProjNet.CoordinateSystems.Transformations;
 using System;
 using System.Collections.Generic;
-using System.Reflection;
-using ProjNet.CoordinateSystems.Transformations;
 
 namespace ProjNet.CoordinateSystems.Projections
 {
@@ -21,25 +20,26 @@ public class ProjectionsRegistry
         static ProjectionsRegistry()
         {
             Register("mercator", typeof(Mercator));
-            Register("mercator_1sp", typeof (Mercator));
-            Register("mercator_2sp", typeof (Mercator));
+            Register("mercator_1sp", typeof(Mercator));
+            Register("mercator_2sp", typeof(Mercator));
+            Register("mercator_auxiliary_sphere", typeof(MercatorAuxiliarySphere));
             Register("pseudo-mercator", typeof(PseudoMercator));
             Register("popular_visualisation pseudo-mercator", typeof(PseudoMercator));
-            Register("google_mercator", typeof(PseudoMercator));
-			
+            Register("google_mercator", typeof(PseudoMercator));
+
             Register("transverse_mercator", typeof(TransverseMercator));
             Register("gauss_kruger", typeof(TransverseMercator));
 
-            Register("albers", typeof(AlbersProjection));
-			Register("albers_conic_equal_area", typeof(AlbersProjection));
-
-			Register("krovak", typeof(KrovakProjection));
-
-			Register("polyconic", typeof(PolyconicProjection));
-			
-            Register("lambert_conformal_conic", typeof(LambertConformalConic2SP));
-			Register("lambert_conformal_conic_2sp", typeof(LambertConformalConic2SP));
-			Register("lambert_conic_conformal_(2sp)", typeof(LambertConformalConic2SP));
+            Register("albers", typeof(AlbersProjection));
+            Register("albers_conic_equal_area", typeof(AlbersProjection));
+
+            Register("krovak", typeof(KrovakProjection));
+
+            Register("polyconic", typeof(PolyconicProjection));
+
+            Register("lambert_conformal_conic", typeof(LambertConformalConic2SP));
+            Register("lambert_conformal_conic_2sp", typeof(LambertConformalConic2SP));
+            Register("lambert_conic_conformal_(2sp)", typeof(LambertConformalConic2SP));
 
             Register("lambert_azimuthal_equal_area", typeof(LambertAzimuthalEqualAreaProjection));
 

test/ProjNet.Tests/CoordinateTransformTests.cs

@@ -1128,5 +1128,39 @@ public void TestEllipsoidalOrthographicTransform()
             var @delegate2 = new TestDelegate(() => trans2.MathTransform.Transform(new[] { 180.0, 0.0 }));
             Assert.Throws<ArgumentOutOfRangeException>(@delegate2);
         }
+
+        [Test]
+        public static void TestMercatorAuxilarySphereTransformation()
+        {
+            string sourceWkt = "PROJCS[\"WGS_1984_Web_Mercator_Auxiliary_Sphere\",GEOGCS[\"GCS_WGS_1984\",DATUM[\"D_WGS_1984\",SPHEROID[\"WGS_1984\",6378137.0,298.257223563]],PRIMEM[\"Greenwich\",0.0],UNIT[\"Degree\",0.0174532925199433]],PROJECTION[\"Mercator_Auxiliary_Sphere\"],PARAMETER[\"False_Easting\",0.0],PARAMETER[\"False_Northing\",0.0],PARAMETER[\"Central_Meridian\",0.0],PARAMETER[\"Standard_Parallel_1\",0.0],PARAMETER[\"Auxiliary_Sphere_Type\",0.0],UNIT[\"Meter\",1.0]]";
+            var sourceCoordinateSystem = GetCoordinateSystem(sourceWkt);
+            Assert.NotNull(sourceCoordinateSystem);
+
+            string targetWkt = "PROJCS[\"TX83-NCF\",GEOGCS[\"LL83\",DATUM[\"NAD83\",SPHEROID[\"GRS1980\",6378137.000,298.25722210]],PRIMEM[\"Greenwich\",0],UNIT[\"Degree\",0.017453292519943295]],PROJECTION[\"Lambert_Conformal_Conic_2SP\"],PARAMETER[\"false_easting\",1968500.000],PARAMETER[\"false_northing\",6561666.667],PARAMETER[\"central_meridian\",-98.50000000000000],PARAMETER[\"latitude_of_origin\",31.66666666666666],PARAMETER[\"standard_parallel_1\",33.96666666666667],PARAMETER[\"standard_parallel_2\",32.13333333333333],UNIT[\"Foot_US\",0.30480060960122]]";
+            var targetCoordinateSystem = GetCoordinateSystem(targetWkt);
+            Assert.NotNull(targetCoordinateSystem);
+
+            var transformation = GetTransformation(sourceCoordinateSystem, targetCoordinateSystem);
+            Assert.NotNull(transformation);
+
+            var tranformedPoint = transformation.MathTransform.Transform(-10775704.511, 3865240.329);
+            Assert.NotNull(tranformedPoint);
+
+            Assert.AreEqual(2491034.95, tranformedPoint.x, 0.1);
+            Assert.AreEqual(6968468.98, tranformedPoint.y, 0.1);
+        }
+
+        internal static CoordinateSystem GetCoordinateSystem(string wkt)
+        {
+            var coordinateSystemFactory = new CoordinateSystemFactory();
+            return coordinateSystemFactory.CreateFromWkt(wkt);
+        }
+
+        internal static ICoordinateTransformation GetTransformation(CoordinateSystem sourceCoordinateSystem, CoordinateSystem targetCoordinateSystem)
+        {
+            var coordinateSystemFactory = new CoordinateSystemFactory();
+            var coordinateService = new ProjNet.CoordinateSystemServices(coordinateSystemFactory, new CoordinateTransformationFactory());
+            return coordinateService.CreateTransformation(sourceCoordinateSystem, targetCoordinateSystem);
+        }
     }
 }