Merge develop into branch

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
 {
@@ -26,21 +25,21 @@ static ProjectionsRegistry()
             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("albers", typeof(AlbersProjection));
+            Register("albers_conic_equal_area", typeof(AlbersProjection));
+
+            Register("krovak", typeof(KrovakProjection));
+
+            Register("polyconic", typeof(PolyconicProjection));
 
-			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_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));
 

src/ProjNet/IO/CoordinateSystems/CoordinateSystemWktReader.cs

@@ -38,6 +38,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Runtime.InteropServices.ComTypes;
 using System.Text;
 using ProjNet.CoordinateSystems;
@@ -360,14 +361,22 @@ private static ProjectedCoordinateSystem ReadProjectedCoordinateSystem(WktStream
             tokenizer.ReadToken("GEOGCS");
             var geographicCS = ReadGeographicCoordinateSystem(tokenizer);
             tokenizer.ReadToken(",");
-            tokenizer.ReadToken("PROJECTION");
+            tokenizer.NextToken();
+
+            LinearUnit linearUnit = null;
+
+            if (tokenizer.GetStringValue().Equals("UNIT", StringComparison.OrdinalIgnoreCase))
+            {
+                linearUnit = ReadLinearUnit(tokenizer);
+                tokenizer.ReadToken(",");
+            }
             var projection = ReadProjection(tokenizer);
-            var unit = ReadLinearUnit(tokenizer);
+            var unit = linearUnit ?? ReadLinearUnit(tokenizer);
             var axisInfo = new List<AxisInfo>(2);
             string authority = string.Empty;
             long authorityCode = -1;
 
-            tokenizer.NextToken();
+            var ct = tokenizer.NextToken();
             if (tokenizer.GetStringValue() == ",")
             {
                 tokenizer.NextToken();
@@ -377,11 +386,18 @@ private static ProjectedCoordinateSystem ReadProjectedCoordinateSystem(WktStream
                     tokenizer.NextToken();
                     if (tokenizer.GetStringValue() == ",") tokenizer.NextToken();
                 }
-                if (tokenizer.GetStringValue() == ",") tokenizer.NextToken();
-                if (tokenizer.GetStringValue() == "AUTHORITY")
+
+                while (ct != TokenType.Eol && ct != TokenType.Eof)
                 {
-                    tokenizer.ReadAuthority(out authority, out authorityCode);
-                    tokenizer.ReadCloser(bracket);
+                    if (tokenizer.GetStringValue() == "AUTHORITY")
+                    {
+                        tokenizer.ReadAuthority(out authority, out authorityCode);
+                        break;
+                    }
+                    else
+                    {
+                        ct = tokenizer.NextToken();
+                    }
                 }
             }
             //This is default axis values if not specified.
@@ -443,8 +459,13 @@ private static CompoundCoordinateSystem ReadCompoundCoordinateSystem(WktStreamTo
             tokenizer.ReadToken(",");
             tokenizer.NextToken();
             var headcs = ReadCoordinateSystem(null, tokenizer);
-            tokenizer.ReadToken(",");
-            tokenizer.NextToken();
+
+            var ct = tokenizer.NextToken();
+            while (ct != TokenType.Eol && ct != TokenType.Eof && new[] { ",", "]"}.Contains(tokenizer.GetStringValue()))
+            {
+               ct = tokenizer.NextToken();
+
+            }
             var tailcs = ReadCoordinateSystem(null, tokenizer);
 
             string authority = string.Empty;

test/ProjNet.Tests/CoordinateSystemServicesTest.cs

@@ -88,7 +88,7 @@ private static IEnumerable<KeyValuePair<int, string>> LoadXml(string xmlPath)
                 var sridElement = node.Element("SRID");
                 if (sridElement != null)
                 {
-                    var srid = int.Parse(sridElement.Value);
+                    int srid = int.Parse(sridElement.Value);
                     yield return new KeyValuePair<int, string>(srid, node.LastNode.ToString());
                 }
             }

test/ProjNet.Tests/CoordinateTransformTests.cs

@@ -1129,6 +1129,27 @@ public void TestEllipsoidalOrthographicTransform()
             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);
+        }
+
         [Test]
         public void TestPopularVisualizationPseudoMercatorProjectionRegistry()
         {

test/ProjNet.Tests/ProjNetIssues.cs

@@ -297,5 +297,22 @@ public void TestGitHubIssue98()
             Assert.IsTrue(cmpdCs.HeadCoordinateSystem is ProjectedCoordinateSystem);
             Assert.IsTrue(cmpdCs.TailCoordinateSystem is VerticalCoordinateSystem);
         }
+
+        /// <summary>
+        /// Tests if a coordinate system can be created from a Well-Known Text (WKT) representation
+        /// and verifies that the authority code is correctly loaded.
+        /// </summary>
+        /// <remarks>
+        /// This test ensures that the WKT parsing functionality of the CoordinateSystemFactory
+        /// correctly initializes the coordinate system and its associated metadata, such as the authority code.
+        /// </remarks>
+        [Test]
+        public void TestAuthorityNotLoadedIssue()
+        {
+            string wkt = "PROJCS[\"WGS 84 / Pseudo-Mercator\",GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS 84\",6378137,298.257223563,AUTHORITY[\"EPSG\",\"7030\"]],AUTHORITY[\"EPSG\",\"6326\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.0174532925199433,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"4326\"]],PROJECTION[\"Mercator_1SP\"],PARAMETER[\"central_meridian\",0],PARAMETER[\"scale_factor\",1],PARAMETER[\"false_easting\",0],PARAMETER[\"false_northing\",0],UNIT[\"metre\",1,AUTHORITY[\"EPSG\",\"9001\"]],AXIS[\"X\",EAST],AXIS[\"Y\",NORTH],EXTENSION[\"PROJ4\",\"+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +wktext +no_defs\"],AUTHORITY[\"EPSG\",\"3857\"]]";
+            var coordinateSystem = CoordinateSystemFactory.CreateFromWkt(wkt);
+            Assert.IsNotNull(coordinateSystem);
+            Assert.AreEqual(coordinateSystem.AuthorityCode, 3857);
+        }
     }
 }