private static IHorizontalDatum ReadHorizontalDatum(WktStreamTokenizer tokenizer)
{
//DATUM["OSGB 1936",SPHEROID["Airy 1830",6377563.396,299.3249646,AUTHORITY["EPSG","7001"]]TOWGS84[0,0,0,0,0,0,0],AUTHORITY["EPSG","6277"]]
tokenizer.ReadToken("[");
string name = tokenizer.ReadDoubleQuotedWord();
tokenizer.ReadToken(",");
tokenizer.ReadToken("SPHEROID");
IEllipsoid ellipsoid = ReadEllipsoid(tokenizer);
tokenizer.ReadToken("TOWGS84");
WGS84ConversionInfo wgsInfo = ReadWGS84ConversionInfo(tokenizer);
tokenizer.ReadToken(",");
string authority = "";
string authorityCode = "";
tokenizer.ReadAuthority(ref authority, ref authorityCode);
// make an assumption about the datum type.
DatumType datumType = DatumType.IHD_Geocentric;
IHorizontalDatum horizontalDatum = new HorizontalDatum(name, datumType, ellipsoid, wgsInfo, "", authority, authorityCode, "", "");
tokenizer.ReadToken("]");
return(horizontalDatum);
}
private static void WriteWGS84ConversionInfo(WGS84ConversionInfo conversionInfo, IndentedTextWriter writer)
{
writer.WriteLine(String.Format("TOWGS84[{0},{1},{2},{3},{4},{5},{6}],",
conversionInfo.Dx, conversionInfo.Dy, conversionInfo.Dz,
conversionInfo.Ex, conversionInfo.Ey, conversionInfo.Ez,
conversionInfo.Ppm));
}
private static IHorizontalDatum ReadHorizontalDatum(XmlTextReader reader)
{
if (!(reader.NodeType == XmlNodeType.Element && reader.Name == "CS_HorizontalDatum"))
{
throw new ParseException(String.Format("Expected a IHorizontalDatum but got a {0} at line {1} col {2}", reader.Name, reader.LineNumber, reader.LinePosition));
}
/* <IHorizontalDatum DatumType="1001">
* <IInfo AuthorityCode="6277" Authority="EPSG" Name="OSGB_1936"/>
* <IEllipsoid SemiMajorAxis="6377563.396" SemiMinorAxis="6356256.90923729" InverseFlattening="299.3249646" IvfDefinitive="1">
* <IInfo AuthorityCode="7001" Authority="EPSG" Name="Airy 1830"/>
* <ILinearUnit MetersPerUnit="1">
* <IInfo AuthorityCode="9001" Abbreviation="m" Authority="EPSG" Name="metre"/>
* </ILinearUnit>
* </IEllipsoid>
* <IWGS84ConversionInfo Dx="375" Dy="-111" Dz="431" Ex="0" Ey="0" Ez="0" Ppm="0"/>
* </IHorizontalDatum>
*/
string datumTypeString = reader.GetAttribute("DatumType");
DatumType datumType = (DatumType)Enum.Parse(typeof(DatumType), datumTypeString, true);
string authority = "", authorityCode = "", abbreviation = "", name = "";
reader.Read();
ReadInfo(reader, ref authority, ref authorityCode, ref abbreviation, ref name);
IEllipsoid ellipsoid = ReadEllipsoid(reader);
WGS84ConversionInfo wgs84info = ReadWGS84ConversionInfo(reader);
reader.Read();
HorizontalDatum horizontalDatum = new HorizontalDatum(name, datumType, ellipsoid, wgs84info, "", authority, authorityCode, "", abbreviation);
return(horizontalDatum);
}
private static void WriteWGS84ConversionInfo(WGS84ConversionInfo conversionInfo, IndentedTextWriter writer)
{
writer.WriteLine(String.Format(System.Globalization.CultureInfo.InvariantCulture, "TOWGS84[{0},{1},{2},{3},{4},{5},{6}],",
conversionInfo.Dx, conversionInfo.Dy, conversionInfo.Dz,
conversionInfo.Ex, conversionInfo.Ey, conversionInfo.Ez,
conversionInfo.Ppm));
}
private static void WriteWGS84ConversionInfo(WGS84ConversionInfo conversionInfo, XmlTextWriter writer)
{
writer.WriteStartElement("CS_WGS84ConversionInfo");
writer.WriteAttributeString("Dx", conversionInfo.Dx.ToString());
writer.WriteAttributeString("Dy", conversionInfo.Dy.ToString());
writer.WriteAttributeString("Dz", conversionInfo.Dz.ToString());
writer.WriteAttributeString("Ex", conversionInfo.Ex.ToString());
writer.WriteAttributeString("Ey", conversionInfo.Ey.ToString());
writer.WriteAttributeString("Ez", conversionInfo.Ex.ToString());
writer.WriteAttributeString("Ppm", conversionInfo.Ppm.ToString());
writer.WriteEndElement();
}
public void Test_Constructor()
{
IEllipsoid ellipsoid = new Ellipsoid(20926348, -1.0, 294.26068, true, new LinearUnit(1));
WGS84ConversionInfo wgsInfo = new WGS84ConversionInfo();
wgsInfo.Dx = 1.0;
HorizontalDatum horizontalDatum = new HorizontalDatum("name", DatumType.IHD_Geocentric, ellipsoid, wgsInfo);
Assertion.AssertEquals("test 1", "name", horizontalDatum.Name);
Assertion.AssertEquals("test 2", DatumType.IHD_Geocentric, horizontalDatum.DatumType);
Assertion.AssertEquals("test 3", ellipsoid, horizontalDatum.Ellipsoid);
Assertion.AssertEquals("test 4", wgsInfo, horizontalDatum.WGS84Parameters);
}
public void TestCreateHorizontalDatum1()
{
ILinearUnit linearUnit = new LinearUnit(1);
IEllipsoid ellipsoid = _csFactory.CreateFlattenedSphere("test", 1, 2, linearUnit);
WGS84ConversionInfo wgs = new WGS84ConversionInfo();
wgs.Dx = 1;
IHorizontalDatum horizontalDatum = _csFactory.CreateHorizontalDatum("name", DatumType.IHD_Geocentric, ellipsoid, wgs);
Assertion.AssertEquals("ctor 1", "name", horizontalDatum.Name);
Assertion.AssertEquals("ctor 2", DatumType.IHD_Geocentric, horizontalDatum.DatumType);
Assertion.AssertEquals("ctor 3", ellipsoid, horizontalDatum.Ellipsoid);
Assertion.AssertEquals("ctor 4", wgs, horizontalDatum.WGS84Parameters);
}
public void TestCreateHorizontalDatum2()
{
ILinearUnit linearUnit = new LinearUnit(1);
IEllipsoid ellipsoid = _csFactory.CreateFlattenedSphere("test", 1, 2, linearUnit);
WGS84ConversionInfo wgs = new WGS84ConversionInfo();
wgs.Dx = 1;
try
{
IHorizontalDatum horizontalDatum = _csFactory.CreateHorizontalDatum("name", DatumType.IHD_Geocentric, null, wgs);
Assertion.Fail("Should throw a ArgumentNullException.");
}
catch (ArgumentNullException)
{
}
}
public void TestReadWGS84ConversionInfo()
{
// can't use the Test() method here because IWGS84ConversionInfo is a struct
// and does not implement the IInfo interface.
string filename = "WGS84ConversionInfo.xml";
StreamReader tr = new StreamReader(Global.GetUnitTestRootDirectory() + @"\IO\" + filename);
string xml1 = tr.ReadToEnd();
WGS84ConversionInfo info = (WGS84ConversionInfo)CoordinateSystemXmlReader.Create(xml1);
string xml2 = CoordinateSystemXmlWriter.Write(info);
StringReader textReader1 = new StringReader(xml1);
XmlTextReader xmlReader1 = new XmlTextReader(textReader1);
StringReader textReader2 = new StringReader(xml2);
XmlTextReader xmlReader2 = new XmlTextReader(textReader2);
bool same = _xmlDiff.Compare(xmlReader1, xmlReader2);
Assertion.AssertEquals("WGS84ConversionInfo", true, same);
}
public void Test_Constructor()
{
ICoordinateSystemFactory csFactory = new CoordinateSystemFactory();
IAngularUnit angularUnit = new AngularUnit(1);
ILinearUnit linearUnit = new LinearUnit(1);
IEllipsoid ellipsoid = csFactory.CreateFlattenedSphere("test", 1, 2, linearUnit);
IAxisInfo axis0 = new AxisInfo("axis0name", AxisOrientation.Up);
IAxisInfo axis1 = new AxisInfo("axis1name", AxisOrientation.Up);
WGS84ConversionInfo wgs = new WGS84ConversionInfo();
IPrimeMeridian primeMeridian = csFactory.CreatePrimeMeridian("name", angularUnit, 2.0);
IHorizontalDatum horizontalDatum = csFactory.CreateHorizontalDatum("datum", DatumType.IHD_Geocentric, ellipsoid, wgs);
IGeographicCoordinateSystem gcs = csFactory.CreateGeographicCoordinateSystem("name", angularUnit, horizontalDatum, primeMeridian, axis0, axis1);
//PrimeMeridian primeMeridian = new PrimeMeridian("name", angularUnit, 0.5);
IAxisInfo[] axisArray = new IAxisInfo[2];
axisArray[0] = axis0;
axisArray[1] = axis1;
ProjectionParameter[] paramList = new ProjectionParameter[1];
paramList[0].Name = "test";
paramList[0].Value = 2.2;
Projection projection = new Projection("mercator", paramList, "class", "remarks", "authority", "authoritycode");
ProjectedCoordinateSystem pjc = new ProjectedCoordinateSystem(horizontalDatum,
axisArray, gcs, linearUnit, projection,
"remarks", "authority", "authorityCode", "name", "alias", "abbreviation");
Assertion.AssertEquals("Test 1", linearUnit, pjc.LinearUnit);
Assertion.AssertEquals("Test 2", horizontalDatum, pjc.HorizontalDatum);
Assertion.AssertEquals("Test 3", axis0, pjc.GetAxis(0));
Assertion.AssertEquals("Test 4", axis1, pjc.GetAxis(1));
Assertion.AssertEquals("Test 5", gcs, pjc.GeographicCoordinateSystem);
Assertion.AssertEquals("Test 6", "abbreviation", pjc.Abbreviation);
Assertion.AssertEquals("Test 7", "alias", pjc.Alias);
Assertion.AssertEquals("Test 8", "authority", pjc.Authority);
Assertion.AssertEquals("Test 9", "authorityCode", pjc.AuthorityCode);
Assertion.AssertEquals("Test 10", "name", pjc.Name);
Assertion.AssertEquals("Test 11", "remarks", pjc.Remarks);
}
/// <summary>
/// Converts a given coordinate system object to a IndentedTextWriter.
/// </summary>
/// <param name="obj">The coordinate system to convert.</param>
/// <param name="writer"></param>
/// <remarks>
/// <list type="bullet">
/// <listheader><term>Items</term><description>Descriptions</description></listheader>
/// <item><term>ICoordinateSystem</term><description>Your Description</description></item>
/// <item><term>IDatum</term><description>Your Description</description></item>
/// <item><term>IEllipsoid</term><description>Your Description</description></item>
/// <item><term>IAxisInfo</term><description>Your Description</description></item>
/// <item><term>IWGS84ConversionInfo</term><description>Your Description</description></item>
/// <item><term>IUnit</term><description>Your Description</description></item>
/// <item><term>IPrimeMeridian</term><description>Your Description</description></item>
/// <item><term>ICompoundCoordinateSystem</term><description>Your Description</description></item>
/// <item><term>IGeographicCoordinateSystem</term><description>Your Description</description></item>
/// <item><term>IProjectedCoordinateSystem</term><description>Your Description</description></item>
/// <item><term>IVerticalCoordinateSystem</term><description>Your Description</description></item>
/// </list>
/// </remarks>
public static void Write(object obj, XmlTextWriter writer)
{
if (obj is ICoordinateSystem)
{
WriteCoordinateSystem(obj as ICoordinateSystem, writer);
}
else if (obj is IDatum)
{
WriteDatum(obj as IDatum, writer);
}
else if (obj is IEllipsoid)
{
WriteEllipsoid(obj as IEllipsoid, writer);
}
else if (obj is IAxisInfo)
{
IAxisInfo info = (IAxisInfo)obj;
WriteAxis(info, writer);
}
else if (obj is WGS84ConversionInfo)
{
WGS84ConversionInfo info = (WGS84ConversionInfo)obj;
WriteWGS84ConversionInfo(info, writer);
}
else if (obj is IUnit)
{
WriteUnit(obj as IUnit, writer);
}
else if (obj is IPrimeMeridian)
{
WritePrimeMeridian(obj as IPrimeMeridian, writer);
}
else if (obj is IProjection)
{
WriteProjection(obj as IProjection, writer);
}
else
{
throw new NotImplementedException(String.Format(System.Globalization.CultureInfo.InvariantCulture, "Cannot convert {0} to XML.", obj.GetType().FullName));
}
}
public void Test_Constructor()
{
ICoordinateSystemFactory csFactory = new CoordinateSystemFactory();
IAngularUnit angularUnit = new AngularUnit(1);
ILinearUnit linearUnit = new LinearUnit(1);
IEllipsoid ellipsoid = csFactory.CreateFlattenedSphere("test", 1, 2, linearUnit);
IAxisInfo axis0 = new AxisInfo("axis0name", AxisOrientation.Up);
IAxisInfo axis1 = new AxisInfo("axis1name", AxisOrientation.Up);
WGS84ConversionInfo wgs = new WGS84ConversionInfo();
IPrimeMeridian primeMeridian = csFactory.CreatePrimeMeridian("name", angularUnit, 2.0);
IHorizontalDatum horizontalDatum = csFactory.CreateHorizontalDatum("datum", DatumType.IHD_Geocentric, ellipsoid, wgs);
IGeographicCoordinateSystem gcs = csFactory.CreateGeographicCoordinateSystem("name", angularUnit, horizontalDatum, primeMeridian, axis0, axis1);
Assertion.AssertEquals("ctor 1", "name", gcs.Name);
Assertion.AssertEquals("ctor 2", angularUnit, gcs.AngularUnit);
Assertion.AssertEquals("ctor 3", horizontalDatum, gcs.HorizontalDatum);
Assertion.AssertEquals("ctor 4", primeMeridian, gcs.PrimeMeridian);
Assertion.AssertEquals("ctor 5", axis0, gcs.GetAxis(0));
Assertion.AssertEquals("ctor 5", axis1, gcs.GetAxis(1));
}
private static WGS84ConversionInfo ReadWGS84ConversionInfo(XmlTextReader reader)
{
double dx = XmlConvert.ToDouble(reader.GetAttribute("Dx"));
double dy = XmlConvert.ToDouble(reader.GetAttribute("Dy"));
double dz = XmlConvert.ToDouble(reader.GetAttribute("Dz"));
double ex = XmlConvert.ToDouble(reader.GetAttribute("Ex"));
double ey = XmlConvert.ToDouble(reader.GetAttribute("Ey"));
double ez = XmlConvert.ToDouble(reader.GetAttribute("Ez"));
double ppm = XmlConvert.ToDouble(reader.GetAttribute("Ppm"));
WGS84ConversionInfo wgs84Info = new WGS84ConversionInfo();
wgs84Info.Dx = dx;
wgs84Info.Dy = dy;
wgs84Info.Dz = dz;
wgs84Info.Ex = ex;
wgs84Info.Ey = ey;
wgs84Info.Ez = ez;
wgs84Info.Ppm = ppm;
reader.Read();
return(wgs84Info);
}
private static WGS84ConversionInfo ReadWGS84ConversionInfo(WktStreamTokenizer tokenizer)
{
//TOWGS84[0,0,0,0,0,0,0]
tokenizer.ReadToken("[");
WGS84ConversionInfo info = new WGS84ConversionInfo();
tokenizer.NextToken();
info.Dx = tokenizer.GetNumericValue();
tokenizer.ReadToken(",");
tokenizer.NextToken();
info.Dy = tokenizer.GetNumericValue();
tokenizer.ReadToken(",");
tokenizer.NextToken();
info.Dz = tokenizer.GetNumericValue();
tokenizer.ReadToken(",");
tokenizer.NextToken();
info.Ex = tokenizer.GetNumericValue();
tokenizer.ReadToken(",");
tokenizer.NextToken();
info.Ey = tokenizer.GetNumericValue();
tokenizer.ReadToken(",");
tokenizer.NextToken();
info.Ez = tokenizer.GetNumericValue();
tokenizer.ReadToken(",");
tokenizer.NextToken();
info.Ppm = tokenizer.GetNumericValue();
tokenizer.ReadToken("]");
return(info);
}
public void Test_Constructor()
{
IEllipsoid ellipsoid = new Ellipsoid(20926348, -1.0, 294.26068, true, new LinearUnit(1));
WGS84ConversionInfo wgsInfo = new WGS84ConversionInfo();
wgsInfo.Dx = 1.0;
HorizontalDatum horizontalDatum = new HorizontalDatum("name", DatumType.IHD_Geocentric, ellipsoid, wgsInfo);
IAxisInfo[] axisInfos = new IAxisInfo[2];
axisInfos[0] = AxisInfo.Latitude;
axisInfos[1] = AxisInfo.Longitude;
HorizontalCoordinateSystem horzCS = new HorizontalCoordinateSystem(horizontalDatum, axisInfos, "remarks", "authority", "code", "name", "alias", "abbreviation");
Assertion.AssertEquals("ctor1.", "remarks", horzCS.Remarks);
Assertion.AssertEquals("ctor2.", "authority", horzCS.Authority);
Assertion.AssertEquals("ctor3.", "code", horzCS.AuthorityCode);
Assertion.AssertEquals("ctor4.", "name", horzCS.Name);
Assertion.AssertEquals("ctor5.", "alias", horzCS.Alias);
Assertion.AssertEquals("ctor6.", "abbreviation", horzCS.Abbreviation);
Assertion.AssertEquals("test 7", horizontalDatum, horzCS.HorizontalDatum);
//Assertion.AssertEquals("test 8",axisInfos[0],horzCS.GetAxis(0));
//Assertion.AssertEquals("test 9",axisInfos[1],horzCS.GetAxis(1));
}
public static object Create(XmlTextReader reader)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
// we don't want to handle whitespace
reader.WhitespaceHandling = WhitespaceHandling.None;
object returnObject = null;
reader.Read();
// skip declarions and comments.
while (reader.NodeType != XmlNodeType.Element)
{
reader.Read();
}
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case "CS_LinearUnit":
ILinearUnit linearUnit = ReadLinearUnit(reader);
returnObject = linearUnit;
break;
case "CS_AngularUnit":
IAngularUnit angularUnit = ReadAngularUnit(reader);
returnObject = angularUnit;
break;
case "CS_VerticalDatum":
IVerticalDatum verticalDatum = ReadVerticalDatum(reader);
returnObject = verticalDatum;
break;
case "CS_Ellipsoid":
IEllipsoid ellipsoid = ReadEllipsoid(reader);
returnObject = ellipsoid;
break;
case "CS_WGS84ConversionInfo":
WGS84ConversionInfo wgsInfo = ReadWGS84ConversionInfo(reader);
returnObject = wgsInfo;
break;
case "CS_HorizontalDatum":
IHorizontalDatum horizontalDatum = ReadHorizontalDatum(reader);
returnObject = horizontalDatum;
break;
case "CS_PrimeMeridian":
IPrimeMeridian primeMeridian = ReadPrimeMeridian(reader);
returnObject = primeMeridian;
break;
case "CS_VerticalCoordinateSystem":
IVerticalCoordinateSystem verticalCS = ReadVerticalCoordinateSystem(reader);
returnObject = verticalCS;
break;
case "CS_GeographicCoordinateSystem":
IGeographicCoordinateSystem geographicCS = ReadGeographicCoordinateSystem(reader);
returnObject = geographicCS;
break;
case "CS_ProjectedCoordinateSystem":
IProjectedCoordinateSystem projectedCS = ReadProjectedCoordinateSystem(reader);
returnObject = projectedCS;
break;
case "CS_CompoundCoordinateSystem":
ICompoundCoordinateSystem compoundCS = ReadCompoundCoordinateSystem(reader);
returnObject = compoundCS;
break;
case "CS_Projection":
IProjection projection = ReadProjection(reader);
returnObject = projection;
break;
case "CS_CoordinateSystem":
// must be a compound coord sys since all other coord system should have been
// taken care of by now.
reader.Read();
ICoordinateSystem coordinateSystem = ReadCompoundCoordinateSystem(reader);
reader.Read();
returnObject = coordinateSystem;
break;
case "CS_GEOCCS":
case "CS_FITTED_CS":
case "CS_LOCAL_CS":
throw new NotSupportedException(String.Format("{0} is not implemented.", reader.Name));
default:
throw new ParseException(String.Format("Element type {0} was is not understoon.", reader.Name));
}
}
return(returnObject);
}
/// <summary>
/// Creates the appropriate object given a string containing XML.
/// </summary>
/// <param name="wkt">String containing XML.</param>
/// <returns>Object representation of the XML.</returns>
/// <exception cref="ParseException">If a token is not recognised.</exception>
public static object Create(string wkt)
{
object returnObject = null;
StringReader reader = new StringReader(wkt);
WktStreamTokenizer tokenizer = new WktStreamTokenizer(reader);
tokenizer.NextToken();
string objectName = tokenizer.GetStringValue();
switch (objectName)
{
case "UNIT":
IUnit unit = ReadUnit(tokenizer);
returnObject = unit;
break;
case "VERT_DATUM":
IVerticalDatum verticalDatum = ReadVerticalDatum(tokenizer);
returnObject = verticalDatum;
break;
case "SPHEROID":
IEllipsoid ellipsoid = ReadEllipsoid(tokenizer);
returnObject = ellipsoid;
break;
case "TOWGS84":
WGS84ConversionInfo wgsInfo = ReadWGS84ConversionInfo(tokenizer);
returnObject = wgsInfo;
break;
case "DATUM":
IHorizontalDatum horizontalDatum = ReadHorizontalDatum(tokenizer);
returnObject = horizontalDatum;
break;
case "PRIMEM":
IPrimeMeridian primeMeridian = ReadPrimeMeridian(tokenizer);
returnObject = primeMeridian;
break;
case "VERT_CS":
IVerticalCoordinateSystem verticalCS = ReadVerticalCoordinateSystem(tokenizer);
returnObject = verticalCS;
break;
case "GEOGCS":
IGeographicCoordinateSystem geographicCS = ReadGeographicCoordinateSystem(tokenizer);
returnObject = geographicCS;
break;
case "PROJCS":
IProjectedCoordinateSystem projectedCS = ReadProjectedCoordinateSystem(tokenizer);
returnObject = projectedCS;
break;
case "COMPD_CS":
ICompoundCoordinateSystem compoundCS = ReadCompoundCoordinateSystem(tokenizer);
returnObject = compoundCS;
break;
case "GEOCCS":
case "FITTED_CS":
case "LOCAL_CS":
throw new NotSupportedException(String.Format("{0} is not implemented.", objectName));
default:
throw new ParseException(String.Format("'{0'} is not recongnized.", objectName));
}
reader.Close();
return(returnObject);
}
