Add compound and vertical coordinate systems (#103)

* Add compound and vertical coordinate systems, as well as parsing WKT for these systems.
* Add vertical datum
* Modify tests that had been failing due to invalid WKT
* Modify WKT of the ProjectedCoordinateSystem so that it follows the OGC specs.
  This is WIP and will be revisitied later.

Author: tommygebhardt

src/ProjNet/CoordinateSystems/CompoundCoordinateSystem.cs

@@ -0,0 +1,109 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Text;
+
+namespace ProjNet.CoordinateSystems
+{
+    /// <summary>
+    /// This is a compound coordinate system, which combines the coordinate of two other coordinate systems.
+    /// For example, a compound 3D coordinate system could be made up of a
+    /// horizontal coordinate system and a vertical coordinate system.
+    /// </summary>
+    public class CompoundCoordinateSystem : CoordinateSystem
+    {
+        private CoordinateSystem _headCoordinateSystem;
+        private CoordinateSystem _tailCoordinateSystem;
+
+        /// <inheritdoc/>
+        public override string WKT
+        {
+            get
+            {
+                var sb = new StringBuilder();
+                sb.Append($"COMPD_CS[\"{Name}\",{HeadCoordinateSystem.WKT},{TailCoordinateSystem.WKT}");
+                if (!string.IsNullOrWhiteSpace(Authority) && AuthorityCode > 0)
+                {
+                    sb.Append($",AUTHORITY[\"{Authority}\",\"{AuthorityCode}\"]");
+                }
+                sb.Append("]");
+                return sb.ToString();
+            }
+        }
+
+        /// <inheritdoc/>
+        public override string XML
+        {
+            get
+            {
+                var sb = new StringBuilder();
+                sb.AppendFormat(CultureInfo.InvariantCulture.NumberFormat,
+                    "<CS_CoordinateSystem Dimension=\"{0}\"><CS_CompoundCoordinateSystem>{1}",
+                    this.Dimension, InfoXml);
+                foreach (var ai in AxisInfo)
+                    sb.Append(ai.XML);
+                sb.Append(HeadCoordinateSystem.XML);
+                sb.Append(TailCoordinateSystem.XML);
+                sb.AppendFormat("</CS_CompoundCoordinateSystem></CS_CoordinateSystem>");
+                return sb.ToString();
+            }
+        }
+
+        /// <summary>
+        /// The head coordinate system
+        /// </summary>
+        public CoordinateSystem HeadCoordinateSystem { get => _headCoordinateSystem; set { _headCoordinateSystem = value; } }
+
+        /// <summary>
+        /// The tail coordinate system
+        /// </summary>
+        public CoordinateSystem TailCoordinateSystem { get => _tailCoordinateSystem; set { _tailCoordinateSystem = value; } }
+        /// <summary>
+        /// A compound coordinate system
+        /// </summary>
+        /// <param name="headcs">The head (first) coordinate system</param>
+        /// <param name="tailcs">The tail (second) coordinate system</param>
+        /// <param name="name">Name</param>
+        /// <param name="authority">Authority name</param>
+        /// <param name="authorityCode">Authority-specific identification code</param>
+        /// <param name="alias">Alias</param>
+        /// <param name="abbreviation">Abbreviation</param>
+        /// <param name="remarks">Optional information</param>
+        public CompoundCoordinateSystem(CoordinateSystem headcs, CoordinateSystem tailcs, string name, string authority, long authorityCode, string alias, string abbreviation, string remarks)
+            : base(name, authority, authorityCode, alias, abbreviation, remarks)
+        {
+            _headCoordinateSystem = headcs;
+            _tailCoordinateSystem = tailcs;
+            AxisInfo = new List<AxisInfo>();
+            AxisInfo.AddRange(HeadCoordinateSystem.AxisInfo);
+            AxisInfo.AddRange(TailCoordinateSystem.AxisInfo);
+        }
+
+        /// <inheritdoc/>
+        public override bool EqualParams(object obj)
+        {
+            if( obj is CompoundCoordinateSystem compdCs )
+            {
+                return HeadCoordinateSystem.EqualParams(compdCs.HeadCoordinateSystem) && TailCoordinateSystem.EqualParams(compdCs.TailCoordinateSystem);
+            }
+
+            return false;
+        }
+
+        /// <inheritdoc/>
+        public override IUnit GetUnits(int dimension)
+        {
+            if( dimension < 0 || dimension >= Dimension )
+            {
+                throw new ArgumentException("Dimension not valid", nameof(dimension));
+            }
+
+            if( dimension < HeadCoordinateSystem.Dimension)
+            {
+                return HeadCoordinateSystem.GetUnits(dimension);
+            }
+
+            return TailCoordinateSystem.GetUnits(dimension - HeadCoordinateSystem.Dimension);
+        }
+    }
+}

src/ProjNet/CoordinateSystems/CoordinateSystemFactory.cs

@@ -26,8 +26,8 @@ namespace ProjNet.CoordinateSystems
     /// Builds up complex objects from simpler objects or values.
     /// </summary>
     /// <remarks>
-    /// <para>ICoordinateSystemFactory allows applications to make coordinate systems that 
-    /// cannot be created by a <see cref="ICoordinateSystemAuthorityFactory"/>. This factory is very 
+    /// <para>CoordinateSystemFactory allows applications to make coordinate systems that 
+    /// cannot be created by a <see cref="CoordinateSystemAuthorityFactory"/>. This factory is very 
     /// flexible, whereas the authority factory is easier to use.</para>
     /// <para>So <see cref="ICoordinateSystemAuthorityFactory"/>can be used to make 'standard' coordinate 
     /// systems, and <see cref="CoordinateSystemFactory"/> can be used to make 'special' 
@@ -67,19 +67,22 @@ public CoordinateSystem CreateFromWkt(string WKT)
             return info as CoordinateSystem;
         }
 
-        /*
+
         /// <summary>
         /// Creates a <see cref="CompoundCoordinateSystem"/> [NOT IMPLEMENTED].
         /// </summary>
         /// <param name="name">Name of compound coordinate system.</param>
         /// <param name="head">Head coordinate system</param>
         /// <param name="tail">Tail coordinate system</param>
         /// <returns>Compound coordinate system</returns>
-        public ICompoundCoordinateSystem CreateCompoundCoordinateSystem(string name, ICoordinateSystem head, ICoordinateSystem tail)
+        public CompoundCoordinateSystem CreateCompoundCoordinateSystem(string name, CoordinateSystem head, CoordinateSystem tail)
         {
-            throw new NotImplementedException();
+            if (string.IsNullOrWhiteSpace(name))
+                throw new ArgumentException("Invalid name");
+
+            return new CompoundCoordinateSystem(head, tail, name, string.Empty, -1, string.Empty, string.Empty, string.Empty);
         }
-         */
+
         /// <summary>
         /// Creates a <see cref="FittedCoordinateSystem"/>.
         /// </summary>
@@ -91,12 +94,30 @@ public ICompoundCoordinateSystem CreateCompoundCoordinateSystem(string name, ICo
         /// should not rotate this coordinate system in any other plane.</remarks>
         /// <param name="name">Name of coordinate system</param>
         /// <param name="baseCoordinateSystem">Base coordinate system</param>
-        /// <param name="toBaseWkt"></param>
-        /// <param name="arAxes"></param>
+        /// <param name="toBaseWkt">WKT of the math transform to the base coordinate system</param>
+        /// <param name="arAxes">Axiis of the fitted coordinate system</param>
         /// <returns>Fitted coordinate system</returns>
         public FittedCoordinateSystem CreateFittedCoordinateSystem(string name, CoordinateSystem baseCoordinateSystem, string toBaseWkt, List<AxisInfo> arAxes)
         {
-            throw new NotImplementedException();
+            if (string.IsNullOrWhiteSpace(name))
+                throw new ArgumentException("Invalid name");
+
+            var toBaseTransform = MathTransformWktReader.Parse(toBaseWkt);
+            return new FittedCoordinateSystem(baseCoordinateSystem, toBaseTransform, name, string.Empty, -1, string.Empty, string.Empty, string.Empty);
+        }
+
+        /// <inheritdoc cref="CreateFittedCoordinateSystem(string, CoordinateSystem, string, List{AxisInfo})"/>
+        /// <param name="name">Name of coordinate system</param>
+        /// <param name="baseCoordinateSystem">Base coordinate system</param>
+        /// <param name="toBase">the math transform to the base coordinate system</param>
+        /// <param name="arAxes">Axiis of the fitted coordinate system</param>
+        /// <returns></returns>
+        public FittedCoordinateSystem CreateFittedCoordinateSystem(string name, CoordinateSystem baseCoordinateSystem, Transformations.MathTransform toBase, List<AxisInfo> arAxes)
+        {
+            if (string.IsNullOrWhiteSpace(name))
+                throw new ArgumentException("Invalid name");
+
+            return new FittedCoordinateSystem(baseCoordinateSystem, toBase, name, string.Empty, -1, string.Empty, string.Empty, string.Empty);
         }
 
         /*
@@ -270,33 +291,39 @@ public ILocalDatum CreateLocalDatum(string name, DatumType datumType)
         }
         */
 
-        /*
+
         /// <summary>
-        /// Creates a <see cref="IVerticalDatum"/> from an enumerated type value.
+        /// Creates a <see cref="VerticalDatum"/> from an enumerated type value.
         /// </summary>
         /// <param name="name">Name of datum</param>
         /// <param name="datumType">Type of datum</param>
         /// <returns>Vertical datum</returns>	
-        public IVerticalDatum CreateVerticalDatum(string name, DatumType datumType)
+        public VerticalDatum CreateVerticalDatum(string name, DatumType datumType)
         {
-            throw new NotImplementedException();
+            if (string.IsNullOrWhiteSpace(name))
+                throw new ArgumentException("Invalid name");
+
+            return new VerticalDatum(datumType, name, string.Empty, -1, string.Empty, string.Empty, string.Empty);
         }
-        */
 
-        /*
+
+
         /// <summary>
-        /// Creates a <see cref="IVerticalCoordinateSystem"/> from a <see cref="IVerticalDatum">datum</see> and <see cref="LinearUnit">linear units</see>.
+        /// Creates a <see cref="VerticalCoordinateSystem"/> from a <see cref="VerticalDatum">datum</see> and <see cref="LinearUnit">linear units</see>.
         /// </summary>
         /// <param name="name">Name of vertical coordinate system</param>
         /// <param name="datum">Vertical datum</param>
         /// <param name="verticalUnit">Unit</param>
         /// <param name="axis">Axis info</param>
         /// <returns>Vertical coordinate system</returns>
-        public IVerticalCoordinateSystem CreateVerticalCoordinateSystem(string name, IVerticalDatum datum, ILinearUnit verticalUnit, AxisInfo axis)
+        public VerticalCoordinateSystem CreateVerticalCoordinateSystem(string name, VerticalDatum datum, LinearUnit verticalUnit, AxisInfo axis)
         {
-            throw new NotImplementedException();
+            if (string.IsNullOrWhiteSpace(name))
+                throw new ArgumentException("Invalid name");
+
+            return new VerticalCoordinateSystem(verticalUnit, datum, axis, name, string.Empty, -1, string.Empty, string.Empty, string.Empty);
         }
-         */
+
         /// <summary>
         /// Creates a <see cref="CreateGeocentricCoordinateSystem"/> from a <see cref="HorizontalDatum">datum</see>, 
         /// <see cref="LinearUnit">linear unit</see> and <see cref="PrimeMeridian"/>.

src/ProjNet/CoordinateSystems/ProjectedCoordinateSystem.cs

@@ -156,21 +156,19 @@ public override string WKT
 			get
 			{
 				var sb = new StringBuilder();
-                sb.AppendFormat("PROJCS[\"{0}\", {1}, {2}, {3}", Name, GeographicCoordinateSystem.WKT, LinearUnit.WKT, Projection.WKT);
+                sb.AppendFormat("PROJCS[\"{0}\", {1}, {2}", Name, GeographicCoordinateSystem.WKT, Projection.WKT);
 				for(int i=0;i<Projection.NumParameters;i++)
 					sb.AppendFormat(CultureInfo.InvariantCulture.NumberFormat, ", {0}", Projection.GetParameter(i).WKT);
-				//sb.AppendFormat(", {0}", LinearUnit.WKT);
-                //Skip authority and code if not defined
-                if (!string.IsNullOrWhiteSpace(Authority) && AuthorityCode > 0)
-                    sb.AppendFormat(", AUTHORITY[\"{0}\", \"{1}\"]", Authority, AuthorityCode);
+				sb.AppendFormat(", {0}", LinearUnit.WKT);
                 //Skip axis info if they contain default values
 				if (AxisInfo.Count != 2 ||
 					AxisInfo[0].Name != "X" || AxisInfo[0].Orientation != AxisOrientationEnum.East ||
 					AxisInfo[1].Name != "Y" || AxisInfo[1].Orientation != AxisOrientationEnum.North)
 					for (int i = 0; i < AxisInfo.Count; i++)
 						sb.AppendFormat(", {0}", GetAxis(i).WKT);
-                //if (!string.IsNullOrWhiteSpace(Authority) && AuthorityCode > 0)
-                //    sb.AppendFormat(", AUTHORITY[\"{0}\", \"{1}\"]", Authority, AuthorityCode);
+                //Skip authority and code if not defined
+                if (!string.IsNullOrWhiteSpace(Authority) && AuthorityCode > 0)
+                    sb.AppendFormat(", AUTHORITY[\"{0}\", \"{1}\"]", Authority, AuthorityCode);
                 sb.Append("]");
 				return sb.ToString();
 			}

src/ProjNet/CoordinateSystems/VerticalCoordinateSystem.cs

@@ -0,0 +1,119 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Text;
+
+namespace ProjNet.CoordinateSystems
+{
+    /// <summary>
+	/// A 1D coordinate system suitable vertical coordinates
+    /// </summary>
+    public class VerticalCoordinateSystem : CoordinateSystem
+    {
+        /// <summary>
+        /// Creates an instance of a VerticalCoordinateSystem
+        /// </summary>
+        /// <param name="linearUnit">The linear unit</param>
+        /// <param name="verticalDatum">The vertical datum</param>
+        /// <param name="axisInfo">Axis information</param>
+        /// <param name="name">Name</param>
+		/// <param name="authority">Authority name</param>
+		/// <param name="authorityCode">Authority-specific identification code.</param>
+		/// <param name="alias">Alias</param>
+		/// <param name="abbreviation">Abbreviation</param>
+		/// <param name="remarks">Provider-supplied remarks</param>
+        public VerticalCoordinateSystem(LinearUnit linearUnit, VerticalDatum verticalDatum, AxisInfo axisInfo, string name, string authority, long authorityCode, string alias, string abbreviation, string remarks) : base(name, authority, authorityCode, alias, abbreviation, remarks)
+        {
+            VerticalDatum = verticalDatum;
+            AxisInfo = new List<AxisInfo>() { axisInfo };
+            LinearUnit = linearUnit;
+        }
+
+        /// <summary>
+        /// Gets or sets the VerticalDatum
+        /// </summary>
+        public VerticalDatum VerticalDatum { get; set; }
+
+        /// <summary>
+        /// Gets or sets the LinearUnit
+        /// </summary>
+        public LinearUnit LinearUnit { get; set; }
+
+        /// <summary>
+        /// Creates a meter unit coordinate system with <see cref="VerticalDatum.ODN"/>
+        /// </summary>
+        public static VerticalCoordinateSystem ODN =>
+            new VerticalCoordinateSystem(
+                new LinearUnit(1, "metre", "EPSG", 9001, string.Empty, "m", string.Empty)
+                , VerticalDatum.ODN, new AxisInfo("Up", AxisOrientationEnum.Up)
+                , "Newlyn"
+                , "EPSG"
+                , 5701
+                , string.Empty
+                , "ODN"
+                , string.Empty
+                );
+        /// <inheritdoc/>
+        public override string WKT
+        {
+            get
+            {
+                var sb = new StringBuilder();
+                sb.AppendFormat("VERT_CS[\"{0}\", {1}, {2}", Name, VerticalDatum.WKT, LinearUnit.WKT);
+                //Skip axis info if they contain default values
+                if (AxisInfo.Count != 1 ||
+                    AxisInfo[0].Name != "Up" || AxisInfo[0].Orientation != AxisOrientationEnum.Up)
+                {
+                    sb.AppendFormat(", {0}", GetAxis(0).WKT);
+                }
+                if (!string.IsNullOrWhiteSpace(Authority) && AuthorityCode > 0)
+                    sb.AppendFormat(", AUTHORITY[\"{0}\", \"{1}\"]", Authority, AuthorityCode);
+                sb.Append("]");
+                return sb.ToString();
+            }
+        }
+
+        /// <inheritdoc/>
+        public override string XML
+        {
+            get
+            {
+                var sb = new StringBuilder();
+                sb.AppendFormat(CultureInfo.InvariantCulture.NumberFormat,
+                    "<CS_CoordinateSystem Dimension=\"{0}\"><CS_VerticalCoordinateSystem>{1}",
+                    this.Dimension, InfoXml);
+                foreach (var ai in AxisInfo)
+                    sb.Append(ai.XML);
+                sb.AppendFormat("{0}{1}</CS_VerticalCoordinateSystem></CS_CoordinateSystem>",
+                    VerticalDatum.XML, LinearUnit.XML);
+                return sb.ToString();
+            }
+        }
+
+        /// <inheritdoc/>
+        public override bool EqualParams(object obj)
+        {
+            if (!(obj is VerticalCoordinateSystem vcs))
+                return false;
+
+            if (vcs.Dimension != Dimension) return false;
+            if (AxisInfo.Count != vcs.AxisInfo.Count) return false;
+            for (int i = 0; i < vcs.AxisInfo.Count; i++)
+                if (vcs.AxisInfo[i].Orientation != AxisInfo[i].Orientation)
+                    return false;
+            return vcs.LinearUnit.EqualParams(LinearUnit) &&
+                    vcs.VerticalDatum.EqualParams(VerticalDatum);
+        }
+
+        /// <inheritdoc/>
+        public override IUnit GetUnits(int dimension)
+        {
+            if( dimension != 0 )
+            {
+                throw new ArgumentOutOfRangeException(nameof(dimension), "Vertical Coordinate Systems have only one dimension");
+            }
+
+            return LinearUnit;
+        }
+    }
+}