/// <summary>
/// Creates an instance of a Geographic Coordinate System
/// </summary>
/// <param name="angularUnit">Angular units</param>
/// <param name="horizontalDatum">Horizontal datum</param>
/// <param name="primeMeridian">Prime meridian</param>
/// <param name="axisInfo">Axis info</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>
internal GeographicCoordinateSystem(IAngularUnit angularUnit, IHorizontalDatum horizontalDatum, IPrimeMeridian primeMeridian, List <AxisInfo> axisInfo, string name, string authority, long authorityCode, string alias, string abbreviation, string remarks)
:
base(horizontalDatum, axisInfo, name, authority, authorityCode, alias, abbreviation, remarks)
{
_AngularUnit = angularUnit;
_PrimeMeridian = primeMeridian;
}
private static IGeographicCoordinateSystem ReadGeographicCoordinateSystem(XmlTextReader reader)
{
if (!(reader.NodeType == XmlNodeType.Element && reader.Name == "CS_GeographicCoordinateSystem"))
{
throw new ParseException(String.Format("Expected a IGeographicCoordinateSystem but got a {0} at line {1} col {2}", reader.Name, reader.LineNumber, reader.LinePosition));
}
string authority = "", authorityCode = "", abbreviation = "", name = "";
reader.Read();
ReadInfo(reader, ref authority, ref authorityCode, ref abbreviation, ref name);
//reader.Read();
ArrayList list = new ArrayList();
while (reader.NodeType == XmlNodeType.Element && reader.Name == "CS_AxisInfo")
{
IAxisInfo axis = ReadAxisInfo(reader);
list.Add(axis);
reader.Read();
}
IAxisInfo[] axisInfos = new IAxisInfo[list.Count];
axisInfos = (IAxisInfo[])list.ToArray(typeof(IAxisInfo));
IHorizontalDatum horizontalDatum = ReadHorizontalDatum(reader);
//reader.Read();
IAngularUnit angularUnit = ReadAngularUnit(reader);
//reader.Read();
IPrimeMeridian primeMeridian = ReadPrimeMeridian(reader);
reader.Read();
IGeographicCoordinateSystem geographicCoordinateSystem = new GeographicCoordinateSystem(angularUnit, horizontalDatum,
primeMeridian, axisInfos[0], axisInfos[1], "",
authority, authorityCode, name, "", abbreviation);
return(geographicCoordinateSystem);
}
internal GeographicCoordinateSystem(
IAngularUnit angularUnit,
IHorizontalDatum horizontalDatum,
IPrimeMeridian primeMeridian,
IAxisInfo axis0,
IAxisInfo axis1,
string remarks, string authority, string authorityCode, string name, string alias, string abbreviation)
: base(remarks, authority, authorityCode, name, alias, abbreviation)
{
_angularUnit = angularUnit;
_horizontalDatum = horizontalDatum;
_primeMeridian = primeMeridian;
_axisInfo = new IAxisInfo[] { axis0, axis1 };
CoordinatePoint minPt = new CoordinatePoint();
minPt.Ord = new Double[2];
minPt.Ord.SetValue(-180, 0);
minPt.Ord.SetValue(-90, 1);
CoordinatePoint maxPt = new CoordinatePoint();
maxPt.Ord = new Double[2];
maxPt.Ord.SetValue(-180, 0);
maxPt.Ord.SetValue(-90, 1);
// define the envelope.
_defaultEnvelope = new Positioning.Envelope();
_defaultEnvelope.MinCP = minPt;
_defaultEnvelope.MaxCP = maxPt;
}
/// <summary>
/// Initializes a new instance of a prime meridian
/// </summary>
/// <param name="longitude">Longitude of prime meridian</param>
/// <param name="angularUnit">Angular unit</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>
internal PrimeMeridian(double longitude, IAngularUnit angularUnit, string name, string authority, long authorityCode, string alias, string abbreviation, string remarks)
:
base(name, authority, authorityCode, alias, abbreviation, remarks)
{
_Longitude = longitude;
_AngularUnit = angularUnit;
}
/// <summary>
/// Writes an angular unit to the given IndentedTextWriter object.
/// </summary>
/// <param name="angularUnit">The angular unit to write.</param>
/// <param name="writer">The IndentedTextWriter to write to. </param>
private static void WriteAngularUnit(IAngularUnit angularUnit, XmlTextWriter writer)
{
writer.WriteStartElement("CS_AngularUnit");
writer.WriteAttributeString("RadiansPerUnit", angularUnit.RadiansPerUnit.ToString());
WriteCSInfo(angularUnit, writer);
writer.WriteEndElement();
}
/// <summary>
/// create a crazy coordinate system
/// </summary>
/// <returns></returns>
private ISpatialReference CreateGeographicSpatialReference()
{
ISpatialReferenceFactory spatialRefFatcory = new SpatialReferenceEnvironmentClass();
IGeographicCoordinateSystem geoCoordSys;
geoCoordSys = spatialRefFatcory.CreateGeographicCoordinateSystem((int)esriSRGeoCSType.esriSRGeoCS_WGS1984);
//assign a user defined datum to the SR (just for the test)
IDatum datum = new DatumClass();
IDatumEdit datumEdit = (IDatumEdit)datum;
ISpheroid spheroid = spatialRefFatcory.CreateSpheroid((int)esriSRSpheroidType.esriSRSpheroid_Clarke1880);
datumEdit.DefineEx("MyDatum", "My Datum", "MDTM", "", spheroid);
IPrimeMeridian primeMeridian = spatialRefFatcory.CreatePrimeMeridian((int)esriSRPrimeMType.esriSRPrimeM_Greenwich);
IAngularUnit angularUnits = spatialRefFatcory.CreateUnit((int)esriSRUnitType.esriSRUnit_Degree) as IAngularUnit;
IGeographicCoordinateSystemEdit geoCoordSysEdit = (IGeographicCoordinateSystemEdit)geoCoordSys;
geoCoordSysEdit.DefineEx("MyGeoCoordSys", "MyGeoCoordSys", "MGCS", "", "", datum, primeMeridian, angularUnits);
geoCoordSys.SetFalseOriginAndUnits(-180.0, -180.0, 5000000.0);
geoCoordSys.SetZFalseOriginAndUnits(0.0, 100000.0);
geoCoordSys.SetMFalseOriginAndUnits(0.0, 100000.0);
return(geoCoordSys as ISpatialReference);
}
/// <summary>
/// Creates a prime meridian given a code.
/// </summary>
/// <param name="code">The EPSG code of the prime meridian.</param>
/// <returns>An object that implements the IPrimeMeridian interface.</returns>
public IPrimeMeridian CreatePrimeMeridian(string code)
{
if (code == null)
{
throw new ArgumentNullException("code");
}
string sqlQuery =
"SELECT PRIME_MERIDIAN_CODE, PRIME_MERIDIAN_NAME,GREENWICH_LONGITUDE," +
" UOM_CODE,REMARKS,INFORMATION_SOURCE,DATA_SOURCE "+
"FROM [Prime Meridian]" +
"WHERE PRIME_MERIDIAN_CODE={0}";
sqlQuery = String.Format(System.Globalization.CultureInfo.InvariantCulture, sqlQuery, code);
IDataReader reader = Database.ExecuteQuery(_databaseConnection, sqlQuery);
IPrimeMeridian primeMeridian = null;
bool recordFound = reader.Read();
if (!recordFound)
{
throw new ArgumentOutOfRangeException(String.Format(System.Globalization.CultureInfo.InvariantCulture, "Prime meridian with a code of '{0}' was not found in the database.", code));
}
double degreesFromGreenwich = (double)reader["GREENWICH_LONGITUDE"];
string remarks = reader["REMARKS"].ToString();
string name = reader["PRIME_MERIDIAN_NAME"].ToString();
string datasource = reader["DATA_SOURCE"].ToString();
string unitsOfMeasure = reader["UOM_CODE"].ToString();
Database.CheckOneRow(reader, code, "Prime meridian");
IAngularUnit degrees = this.CreateAngularUnit(unitsOfMeasure);
primeMeridian = new PrimeMeridian(name, degrees, degreesFromGreenwich, remarks, datasource, code, "", "");
return(primeMeridian);
}
/// <summary>
/// Initializes a new instance of a prime meridian
/// </summary>
/// <param name="longitude">Longitude of prime meridian</param>
/// <param name="angularUnit">Angular unit</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>
internal PrimeMeridian(double longitude, IAngularUnit angularUnit, string name, string authority, long authorityCode, string alias, string abbreviation, string remarks)
:
base(name, authority, authorityCode, alias, abbreviation, remarks)
{
_Longitude = longitude;
_AngularUnit = angularUnit;
}
internal GeographicCoordinateSystem(
IAngularUnit angularUnit,
IHorizontalDatum horizontalDatum,
IPrimeMeridian primeMeridian,
IAxisInfo axis0,
IAxisInfo axis1,
string remarks, string authority, string authorityCode, string name, string alias, string abbreviation)
: base(remarks, authority, authorityCode, name, alias, abbreviation)
{
_angularUnit = angularUnit;
_horizontalDatum = horizontalDatum;
_primeMeridian = primeMeridian;
_axisInfo = new IAxisInfo[]{axis0,axis1};
CoordinatePoint minPt = new CoordinatePoint();
minPt.Ord= new Double[2];
minPt.Ord.SetValue(-180,0);
minPt.Ord.SetValue(-90,1);
CoordinatePoint maxPt = new CoordinatePoint();
maxPt.Ord= new Double[2];
maxPt.Ord.SetValue(-180,0);
maxPt.Ord.SetValue(-90,1);
// define the envelope.
_defaultEnvelope = new Positioning.Envelope();
_defaultEnvelope.MinCP = minPt;
_defaultEnvelope.MaxCP = maxPt;
}
/// <summary>
/// Creates an instance of a Geographic Coordinate System
/// </summary>
/// <param name="angularUnit">Angular units</param>
/// <param name="horizontalDatum">Horizontal datum</param>
/// <param name="primeMeridian">Prime meridian</param>
/// <param name="axisInfo">Axis info</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>
internal GeographicCoordinateSystem(IAngularUnit angularUnit, IHorizontalDatum horizontalDatum, IPrimeMeridian primeMeridian, List<AxisInfo> axisInfo, string name, string authority, long authorityCode, string alias, string abbreviation, string remarks)
:
base(horizontalDatum, axisInfo, name, authority, authorityCode, alias, abbreviation, remarks)
{
_AngularUnit = angularUnit;
_PrimeMeridian = primeMeridian;
}
public void TestReadUnit2()
{
string wkt1 = "UNIT[\"degree\",0.01745329251994433,AUTHORITY[\"EPSG\",\"9102\"]]";
IAngularUnit angularUnit = CoordinateSystemWktReader.Create(wkt1) as IAngularUnit;
string wkt2 = angularUnit.WKT;
bool same = Compare.CompareAgainstString(Global.GetUnitTestRootDirectory() + @"\IO\AngularUnit.txt", wkt2);
//Assertion.AssertEquals("test 1",true,same); fails because of issues with double and precsision
}
public void Test_TestAngularUnit()
{
IAngularUnit angularUnit = _factory.CreateAngularUnit("9101");
Assertion.AssertEquals("AngularUnit - untis per meter ", 1.0, angularUnit.RadiansPerUnit);
Assertion.AssertEquals("AngularUnit - Authority", "EPSG", angularUnit.Authority);
Assertion.AssertEquals("AngularUnit - Remarks", "SI standard unit.", angularUnit.Remarks);
}
/// <summary>
/// Creates a <see cref="PrimeMeridian"/>, relative to Greenwich.
/// </summary>
/// <param name="name">Name of prime meridian</param>
/// <param name="angularUnit">Angular unit</param>
/// <param name="longitude">Longitude</param>
/// <returns>Prime meridian</returns>
public IPrimeMeridian CreatePrimeMeridian(string name, IAngularUnit angularUnit, double longitude)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentException("Invalid name");
}
return(new PrimeMeridian(longitude, angularUnit, name, String.Empty, -1, String.Empty, String.Empty, String.Empty));
}
/// <summary>
/// Reads a geographic coordinate system.
/// </summary>
private static IGeographicCoordinateSystem ReadGeographicCoordinateSystem(WktStreamTokenizer tokenizer)
{
tokenizer.ReadToken("[");
string name = tokenizer.ReadDoubleQuotedWord();
tokenizer.ReadToken(",");
tokenizer.ReadToken("DATUM");
IHorizontalDatum horizontalDatum = ReadHorizontalDatum(tokenizer);
tokenizer.ReadToken(",");
tokenizer.ReadToken("PRIMEM");
IPrimeMeridian primeMeridian = ReadPrimeMeridian(tokenizer);
tokenizer.ReadToken(",");
tokenizer.ReadToken("UNIT");
IAngularUnit angularUnit = ReadAngularUnit(tokenizer);
string authority = String.Empty;
long authorityCode = -1;
tokenizer.NextToken();
List <AxisInfo> info = new List <AxisInfo>(2);
if (tokenizer.GetStringValue() == ",")
{
tokenizer.NextToken();
while (tokenizer.GetStringValue() == "AXIS")
{
info.Add(ReadAxis(tokenizer));
tokenizer.NextToken();
if (tokenizer.GetStringValue() == ",")
{
tokenizer.NextToken();
}
}
if (tokenizer.GetStringValue() == ",")
{
tokenizer.NextToken();
}
if (tokenizer.GetStringValue() == "AUTHORITY")
{
//tokenizer.ReadAuthority(ref authority, ref authorityCode);
ReadAuthority(tokenizer, ref authority, ref authorityCode);
tokenizer.ReadToken("]");
}
}
// значения по умолчанию для осей
if (info.Count == 0)
{
info.Add(new AxisInfo("Lon", AxisOrientationEnum.East));
info.Add(new AxisInfo("Lat", AxisOrientationEnum.North));
}
IGeographicCoordinateSystem geographicCS = new GeographicCoordinateSystem(angularUnit, horizontalDatum,
primeMeridian, info, name, authority, authorityCode, String.Empty, String.Empty, String.Empty);
return(geographicCS);
}
/// <summary>
///
/// </summary>
/// <param name="tokenizer"></param>
/// <returns></returns>
private static IGeographicCoordinateSystem ReadGeographicCoordinateSystem(WktStreamTokenizer tokenizer)
{
/*
* GEOGCS["OSGB 1936",
* DATUM["OSGB 1936",SPHEROID["Airy 1830",6377563.396,299.3249646,AUTHORITY["EPSG","7001"]]TOWGS84[0,0,0,0,0,0,0],AUTHORITY["EPSG","6277"]]
* PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]]
* AXIS["Geodetic latitude","NORTH"]
* AXIS["Geodetic longitude","EAST"]
* AUTHORITY["EPSG","4277"]
* ]
*/
tokenizer.ReadToken("[");
string name = tokenizer.ReadDoubleQuotedWord();
tokenizer.ReadToken(",");
tokenizer.ReadToken("DATUM");
IHorizontalDatum horizontalDatum = ReadHorizontalDatum(tokenizer);
tokenizer.ReadToken(",");
tokenizer.ReadToken("PRIMEM");
IPrimeMeridian primeMeridian = ReadPrimeMeridian(tokenizer);
tokenizer.ReadToken(",");
tokenizer.ReadToken("UNIT");
IAngularUnit angularUnit = ReadAngularUnit(tokenizer);
string authority = String.Empty;
long authorityCode = -1;
tokenizer.NextToken();
List <AxisInfo> info = new List <AxisInfo>(2);
if (tokenizer.GetStringValue() == ",")
{
tokenizer.NextToken();
while (tokenizer.GetStringValue() == "AXIS")
{
info.Add(ReadAxis(tokenizer));
tokenizer.NextToken();
}
if (tokenizer.GetStringValue() == "AUTHORITY")
{
tokenizer.ReadAuthority(ref authority, ref authorityCode);
tokenizer.ReadToken("]");
}
}
//This is default axis values if not specified.
if (info.Count == 0)
{
info.Add(new AxisInfo("Lon", AxisOrientationEnum.East));
info.Add(new AxisInfo("Lat", AxisOrientationEnum.North));
}
IGeographicCoordinateSystem geographicCS = new GeographicCoordinateSystem(angularUnit, horizontalDatum,
primeMeridian, info, name, authority, authorityCode, String.Empty, String.Empty, String.Empty);
return(geographicCS);
}
internal GeographicCoordinateSystem(string name,
IAngularUnit angularUnit,
IHorizontalDatum horizontalDatum,
IPrimeMeridian primeMeridian,
IAxisInfo axis0,
IAxisInfo axis1) :
this(angularUnit, horizontalDatum, primeMeridian, axis0, axis1, "", "", "", name, "", "")
{
}
private static void WriteAngularUnit(IAngularUnit angularUnit, IndentedTextWriter writer)
{
writer.WriteLine("UNIT[");
writer.Indent = writer.Indent + 1;
writer.WriteLine(String.Format(System.Globalization.CultureInfo.InvariantCulture, "\"{0}\",{1:r},", angularUnit.Name, angularUnit.RadiansPerUnit));
writer.WriteLine(String.Format(System.Globalization.CultureInfo.InvariantCulture, "AUTHORITY[\"{0}\",\"{1}\"]", angularUnit.Authority, angularUnit.AuthorityCode));
writer.Indent = writer.Indent - 1;
writer.WriteLine("]");
}
internal GeographicCoordinateSystem(string name,
IAngularUnit angularUnit,
IHorizontalDatum horizontalDatum,
IPrimeMeridian primeMeridian,
IAxisInfo axis0,
IAxisInfo axis1)
: this(angularUnit,horizontalDatum,primeMeridian, axis0, axis1,"","","",name,"","")
{
}
private static void WriteAngularUnit(IAngularUnit angularUnit, IndentedTextWriter writer)
{
writer.WriteLine("UNIT[");
writer.Indent = writer.Indent + 1;
writer.WriteLine(String.Format("\"{0}\",{1:r},", angularUnit.Name, angularUnit.RadiansPerUnit));
writer.WriteLine(String.Format("AUTHORITY[\"{0}\",\"{1}\"]", angularUnit.Authority, angularUnit.AuthorityCode));
writer.Indent = writer.Indent - 1;
writer.WriteLine("]");
}
/// <summary>
/// Should not find this record so throw an exception.
/// </summary>
public void Test_TestAngularUnit2()
{
try
{
IAngularUnit angularUnit3 = _factory.CreateAngularUnit("-1");
Assertion.Fail("Angular Unit - Exception should be thrown.");
}
catch (ArgumentOutOfRangeException)
{
}
}
/// <summary>
/// Try creating a unit that is not 'angular'.
/// </summary>
public void Test_TestAngularUnit3()
{
try
{
IAngularUnit angularUnit3 = _factory.CreateAngularUnit("9001");
Assertion.Fail("Angular Unit - Exception should be thrown. 9001 is a linear unit.");
}
catch (ArgumentException)
{
}
}
public void TestWriteUnit2()
{
IAngularUnit AngularUnit = _factory.CreateAngularUnit("9101");
TextWriter textwriter = new StringWriter();
IndentedTextWriter indentedTextWriter = new IndentedTextWriter(textwriter);
CoordinateSystemWktWriter.Write(AngularUnit, indentedTextWriter);
bool same = Compare.CompareAgainstString(Global.GetUnitTestRootDirectory() + @"\IO\Radians.txt", textwriter.ToString());
Assertion.AssertEquals("test 1", true, same);
}
/// <summary>
/// Initializes a new instance of the PrimeMeridian class.
/// </summary>
/// <param name="name">The name of the prime meridian.</param>
/// <param name="angularUnit">The angular unit the longitude is measured in.</param>
/// <param name="longitude">The longitude of the prime meridian.</param>
/// <param name="remarks">Remarks about this object.</param>
/// <param name="authority">The name of the authority.</param>
/// <param name="authorityCode">The code the authority uses to identidy this object.</param>
/// <param name="alias">The alias of the object.</param>
/// <param name="abbreviation">The abbreviated name of this object.</param>
internal PrimeMeridian(string name, IAngularUnit angularUnit, double longitude, string remarks, string authority, string authorityCode, string alias, string abbreviation)
: base(remarks, authority, authorityCode, name, alias, abbreviation)
{
if (angularUnit==null)
{
throw new ArgumentNullException("angularUnit");
}
_name = name;
_angularUnit = angularUnit;
_longitude = longitude;
}
/// <summary>
/// Initializes a new instance of the PrimeMeridian class.
/// </summary>
/// <param name="name">The name of the prime meridian.</param>
/// <param name="angularUnit">The angular unit the longitude is measured in.</param>
/// <param name="longitude">The longitude of the prime meridian.</param>
/// <param name="remarks">Remarks about this object.</param>
/// <param name="authority">The name of the authority.</param>
/// <param name="authorityCode">The code the authority uses to identidy this object.</param>
/// <param name="alias">The alias of the object.</param>
/// <param name="abbreviation">The abbreviated name of this object.</param>
internal PrimeMeridian(string name, IAngularUnit angularUnit, double longitude, string remarks, string authority, string authorityCode, string alias, string abbreviation)
: base(remarks, authority, authorityCode, name, alias, abbreviation)
{
if (angularUnit==null)
{
throw new ArgumentNullException("angularUnit");
}
_name = name;
_angularUnit = angularUnit;
_longitude = longitude;
}
public IPrimeMeridian CreatePrimeMeridian(string name, IAngularUnit angularUnit, double longitude)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (angularUnit == null)
{
throw new ArgumentNullException("angularUnit");
}
return(new PrimeMeridian(name, angularUnit, longitude));
}
/// <summary>
/// Returns an AngularUnit object from a code.
/// </summary>
/// <remarks>
/// Some common angular units and their codes are described in the table below.
/// <list type="table">
/// <listheader><term>EPSG Code</term><description>Descriptions</description></listheader>
/// <item><term>9101</term><description>Radian</description></item>
/// <item><term>9102</term><description>Degree</description></item>
/// <item><term>9103</term><description>Arc-minute</description></item>
/// <item><term>9104</term><description>Arc-second</description></item>
/// </list>
/// </remarks>
/// <param name="code">The EPSG code.</param>
/// <returns>An object that implements the IAngularUnit interface.</returns>
public IAngularUnit CreateAngularUnit(string code)
{
if (code == null)
{
throw new ArgumentNullException("code");
}
string sqlQuery = "SELECT UNIT_OF_MEAS_NAME, " +
" UNIT_OF_MEAS_TYPE, TARGET_UOM_CODE, " +
" FACTOR_B, FACTOR_C, " +
" REMARKS, INFORMATION_SOURCE, DATA_SOURCE " +
"FROM [Unit of Measure]" +
"WHERE UOM_CODE={0}";
sqlQuery = String.Format(System.Globalization.CultureInfo.InvariantCulture, sqlQuery, code);
IDataReader reader = Database.ExecuteQuery(_databaseConnection, sqlQuery);
IAngularUnit angularUnit = null;
bool recordFound = reader.Read();
if (!recordFound)
{
throw new ArgumentOutOfRangeException(String.Format(System.Globalization.CultureInfo.InvariantCulture, "Angular unit with a code of '{0}' was not found in the database.", code));
}
string unitOfMeasureType = reader["UNIT_OF_MEAS_TYPE"].ToString();
if (unitOfMeasureType.ToLower() != "angle")
{
throw new ArgumentException(String.Format(System.Globalization.CultureInfo.InvariantCulture, "Requested unit ({0}) is not a angular unit.", unitOfMeasureType));
}
string remarks = reader["REMARKS"].ToString();
string name = reader["UNIT_OF_MEAS_NAME"].ToString();
string targetUOMcode = reader["TARGET_UOM_CODE"].ToString();
if (!reader.IsDBNull(3)) //TODO: 4th item in the select statement. Should realy determine this using GetOrdinal()
{
double factorB = (double)reader["FACTOR_B"];
double factorC = (double)reader["FACTOR_C"];
double radiansPerUnit = factorB / factorC;
Database.CheckOneRow(reader, code, "Angular Unit");
angularUnit = new AngularUnit(radiansPerUnit, remarks, "EPSG", code, name, "", "");
}
else
{
// some units have a null for the Factor B - so must then try using the other UOM code.
Database.CheckOneRow(reader, code, "Angular Unit");
angularUnit = this.CreateAngularUnit(targetUOMcode);
}
return(angularUnit);
}
/// <summary>
/// Gets native units to meters conversion factor
/// </summary>
/// <param name="ipSpatialReference">The spatial reference</param>
/// <returns>The meters conversion factor</returns>
private static double GetConversionFactor(ISpatialReference ipSpatialReference)
{
double dConversionFactor = 0.0;
if (ipSpatialReference is IGeographicCoordinateSystem)
{
IAngularUnit ipAngularUnit = ((IGeographicCoordinateSystem)ipSpatialReference).CoordinateUnit;
dConversionFactor = ipAngularUnit.ConversionFactor;
}
else
{
ILinearUnit ipLinearUnit = ((IProjectedCoordinateSystem)ipSpatialReference).CoordinateUnit;
dConversionFactor = ipLinearUnit.ConversionFactor;
}
return(dConversionFactor);
}
private static IPrimeMeridian ReadPrimeMeridian(XmlTextReader reader)
{
/*
* <?xml version="1.0"?>
* <IPrimeMeridian Longitude="0">
* <IInfo AuthorityCode="8901" Authority="EPSG" Name="Greenwich"/>
* <IAngularUnit RadiansPerUnit="1.74532925199433E-02">
* <IInfo AuthorityCode="9110" Authority="EPSG" Name="DDD.MMSSsss"/>
* </IAngularUnit>
* </IPrimeMeridian>
*/
double longitude = XmlConvert.ToDouble(reader.GetAttribute("Longitude"));
string authority = "", authorityCode = "", abbreviation = "", name = "";
reader.Read();
ReadInfo(reader, ref authority, ref authorityCode, ref abbreviation, ref name);
IAngularUnit angularUnit = ReadAngularUnit(reader);
reader.Read();
IPrimeMeridian primeMeridian = new PrimeMeridian(name, angularUnit, longitude, "", authority, authorityCode, "", abbreviation);
return(primeMeridian);
}
/// <summary>
/// Initializes a new instance of the PrimeMeridian class.
/// </summary>
/// <param name="name">The name of the prime meridian.</param>
/// <param name="angularUnit">The angular unit the longitude is measured in.</param>
/// <param name="longitude">The longitude of the prime meridian.</param>
internal PrimeMeridian(string name, IAngularUnit angularUnit, double longitude)
: this(name,angularUnit, longitude, "","","","","")
{
}
public IPrimeMeridian CreatePrimeMeridian(string name, IAngularUnit angularUnit, double longitude)
{
if (name==null)
{
throw new ArgumentNullException("name");
}
if (angularUnit==null)
{
throw new ArgumentNullException("angularUnit");
}
return new PrimeMeridian(name, angularUnit, longitude);
}
public IGeographicCoordinateSystem GetSpatialRefrence()
{
double num;
if (this.int_0 > 0)
{
MessageBox.Show("请检查输入数据是否正确！");
return(null);
}
if (this.textEditName.Text.Length == 0)
{
MessageBox.Show("未指定名字，必须为坐标系统指定一个名字！");
return(null);
}
if (this.cboSpheres.SelectedIndex <= 0)
{
double num2;
num = Convert.ToDouble(this.txtMajorAxis.Text);
if (this.rdoFlattening.Checked)
{
num2 = 1.0 / Convert.ToDouble(this.txtFlattening.Text);
}
else
{
double num3 = Convert.ToDouble(this.txtMiniorAxis.Text);
num2 = (num - num3) / num;
}
((ISpheroidEdit)this.ispheroid_0).DefineEx(this.cboSpheres.Text, null, null, null, ref num, ref num2);
}
if (this.cboDatumName.SelectedIndex <= 0)
{
((IDatumEdit)this.idatum_0).DefineEx(this.cboDatumName.Text, null, null, null, this.ispheroid_0);
}
if (this.cboAngleName.SelectedIndex <= 0)
{
num = Convert.ToDouble(this.txtValue.Text);
((IAngularUnitEdit)this.iunit_0).DefineEx(this.cboAngleName.Text, null, null, null, ref num);
}
if (this.cboPrimeMeridians.SelectedIndex <= 0)
{
double num4 = Convert.ToDouble(this.txtDegree.Text);
if (num4 < 0.0)
{
num = (num4 - (Convert.ToDouble(this.txtMinute.Text) / 60.0)) -
(Convert.ToDouble(this.txtSecond.Text) / 3600.0);
}
else
{
num = (num4 + (Convert.ToDouble(this.txtMinute.Text) / 60.0)) +
(Convert.ToDouble(this.txtSecond.Text) / 3600.0);
}
((IPrimeMeridianEdit)this.iprimeMeridian_0).DefineEx(this.cboPrimeMeridians.Text, null, null, null,
ref num);
}
this.igeographicCoordinateSystem_0 = new GeographicCoordinateSystemClass();
IGeographicCoordinateSystemEdit edit = this.igeographicCoordinateSystem_0 as IGeographicCoordinateSystemEdit;
IAngularUnit geographicUnit = this.iunit_0 as IAngularUnit;
string alias = "";
try
{
edit.DefineEx(this.textEditName.Text, alias, alias, alias, alias, this.idatum_0, this.iprimeMeridian_0,
geographicUnit);
}
catch
{
MessageBox.Show("无法定义地理坐标!");
return(null);
}
return(this.igeographicCoordinateSystem_0);
}
private static void WriteAngularUnit(IAngularUnit angularUnit, IndentedTextWriter writer)
{
writer.WriteLine("UNIT[");
writer.Indent=writer.Indent+1;
writer.WriteLine(String.Format(System.Globalization.CultureInfo.InvariantCulture, "\"{0}\",{1:r},", angularUnit.Name, angularUnit.RadiansPerUnit));
writer.WriteLine(String.Format(System.Globalization.CultureInfo.InvariantCulture, "AUTHORITY[\"{0}\",\"{1}\"]", angularUnit.Authority, angularUnit.AuthorityCode));
writer.Indent=writer.Indent-1;
writer.WriteLine("]");
}
private static void WriteAngularUnit(IAngularUnit angularUnit, IndentedTextWriter writer)
{
writer.WriteLine("UNIT[");
writer.Indent=writer.Indent+1;
writer.WriteLine(String.Format("\"{0}\",{1:r},", angularUnit.Name, angularUnit.RadiansPerUnit));
writer.WriteLine(String.Format("AUTHORITY[\"{0}\",\"{1}\"]", angularUnit.Authority, angularUnit.AuthorityCode));
writer.Indent=writer.Indent-1;
writer.WriteLine("]");
}
public IPrimeMeridian CreatePrimeMeridian(string name, IAngularUnit angularUnit, double longitude)
{
throw new NotImplementedException();
}
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);
}
public void TestReadUnit1()
{
string wkt = "UNIT[\"degree\",0.01745329251994433,AUTHORITY[\"EPSG\",\"9102\"]]";
IAngularUnit angularUnit = CoordinateSystemWktReader.Create(wkt) as IAngularUnit;
}
/// <summary>
/// Creates a <see cref="GeographicCoordinateSystem"/>, which could be Lat/Lon or Lon/Lat.
/// </summary>
/// <param name="name">Name of geographical coordinate system</param>
/// <param name="angularUnit">Angular units</param>
/// <param name="datum">Horizontal datum</param>
/// <param name="primeMeridian">Prime meridian</param>
/// <param name="axis0">First axis</param>
/// <param name="axis1">Second axis</param>
/// <returns>Geographic coordinate system</returns>
public IGeographicCoordinateSystem CreateGeographicCoordinateSystem(string name, IAngularUnit angularUnit, IHorizontalDatum datum, IPrimeMeridian primeMeridian, AxisInfo axis0, AxisInfo axis1)
{
if (string.IsNullOrEmpty(name))
throw new ArgumentException("Invalid name");
List<AxisInfo> info = new List<AxisInfo>(2);
info.Add(axis0);
info.Add(axis1);
return new GeographicCoordinateSystem(angularUnit, datum, primeMeridian,info, name, String.Empty, -1, String.Empty, String.Empty, String.Empty);
}
// =========================================================================
// Functions (Public)
// =========================================================================
public string GetGmlFromLocation(List <RecordingLocation> recordingLocations, double distance, out Color color, SpatialReference cyclSpatialRef)
{
string result = WfsHeader;
// ReSharper disable UseIndexedProperty
if (_featureClass != null)
{
IGeometry geometryBag = new GeometryBagClass();
var geometryCollection = geometryBag as IGeometryCollection;
Config config = Config.Instance;
SpatialReference spatRel = config.SpatialReference;
ISpatialReference gsSpatialReference = (spatRel == null) ? ArcUtils.SpatialReference : spatRel.SpatialRef;
var projCoord = gsSpatialReference as IProjectedCoordinateSystem;
if (projCoord == null)
{
var geoCoord = gsSpatialReference as IGeographicCoordinateSystem;
if (geoCoord != null)
{
IAngularUnit unit = geoCoord.CoordinateUnit;
double factor = unit.ConversionFactor;
distance = distance * factor;
}
}
else
{
ILinearUnit unit = projCoord.CoordinateUnit;
double factor = unit.ConversionFactor;
distance = distance / factor;
}
foreach (var recordingLocation in recordingLocations)
{
double x = recordingLocation.X;
double y = recordingLocation.Y;
IEnvelope envelope = new EnvelopeClass
{
XMin = x - distance,
XMax = x + distance,
YMin = y - distance,
YMax = y + distance,
SpatialReference = gsSpatialReference
};
envelope.Project(SpatialReference);
geometryCollection.AddGeometry(envelope);
}
ITopologicalOperator unionedPolygon = new PolygonClass();
unionedPolygon.ConstructUnion(geometryBag as IEnumGeometry);
var polygon = unionedPolygon as IPolygon;
ISpatialFilter spatialFilter = new SpatialFilterClass
{
Geometry = polygon,
GeometryField = _featureClass.ShapeFieldName,
SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects
};
var featureCursor = _featureClass.Search(spatialFilter, false);
var featureCount = _featureClass.FeatureCount(spatialFilter);
var shapeId = featureCursor.FindField(_featureClass.ShapeFieldName);
var gmlConverter = new GMLConverter();
for (int i = 0; i < featureCount; i++)
{
IFeature feature = featureCursor.NextFeature();
if (!EditFeatures.Contains(feature))
{
IFields fields = feature.Fields;
var fieldvalues = new Dictionary <string, string> {
{ "FEATURECLASSNAME", _featureClass.AliasName }
};
for (int j = 0; j < fields.FieldCount; j++)
{
IField field = fields.Field[j];
string name = field.Name;
int id = featureCursor.FindField(name);
string value = (id != shapeId)
? feature.get_Value(id).ToString()
: _featureClass.ShapeType.ToString().Replace("esriGeometry", string.Empty);
fieldvalues.Add(name, value);
}
var shapeVar = feature.get_Value(shapeId);
var geometry = shapeVar as IGeometry;
if (geometry != null)
{
geometry.Project((cyclSpatialRef == null) ? gsSpatialReference : cyclSpatialRef.SpatialRef);
if (!HasZ)
{
var pointCollection = geometry as IPointCollection4;
if (pointCollection != null)
{
for (int j = 0; j < pointCollection.PointCount; j++)
{
IPoint point = pointCollection.Point[j];
if (point != null)
{
point.Z = double.NaN;
}
pointCollection.ReplacePoints(j, 1, 1, point);
}
shapeVar = pointCollection as IGeometry;
}
else
{
var point = geometry as IPoint;
if (point != null)
{
point.Z = double.NaN;
shapeVar = point;
}
}
}
}
gmlConverter.ESRIGeometry = shapeVar;
string gml = gmlConverter.GML;
gml = gml.Replace("<Polygon>", string.Format("<Polygon srsDimension=\"{0}\" >", HasZ ? 3 : 2));
gml = gml.Replace("<LineString>", string.Format("<LineString srsDimension=\"{0}\" >", HasZ ? 3 : 2));
gml = gml.Replace("<point>", string.Format("<point srsDimension=\"{0}\" >", HasZ ? 3 : 2));
gml = gml.Replace("point", "Point");
gml = gml.Replace(",1.#QNAN", string.Empty);
gml = gml.Replace("<", "<gml:");
gml = gml.Replace("<gml:/", "</gml:");
string fieldValueStr = fieldvalues.Aggregate(string.Empty,
(current, fieldvalue) => string.Format("{0}<{1}>{2}</{1}>", current, fieldvalue.Key, fieldvalue.Value));
result = string.Format("{0}<gml:featureMember><xs:Geometry>{1}{2}</xs:Geometry></gml:featureMember>", result,
fieldValueStr, gml);
}
}
}
// ReSharper restore UseIndexedProperty
color = ArcUtils.GetColorFromLayer(_layer);
GmlChanged = (_color != color);
_color = color;
string newGml = string.Concat(result, WfsFinished);
GmlChanged = ((newGml != _gml) || GmlChanged);
return(_gml = newGml);
}
void AnadeParámetroAListaParámetros(List<ProjectionParameter> parámetros, string nombre, double valor, IAngularUnit unidad)
{
valor = unidad.RadiansPerUnit * valor * 180.0 / Math.PI;
parámetros.Add(new ProjectionParameter(nombre, valor));
}
/// <summary>
/// Creates a <see cref="PrimeMeridian"/>, relative to Greenwich.
/// </summary>
/// <param name="name">Name of prime meridian</param>
/// <param name="angularUnit">Angular unit</param>
/// <param name="longitude">Longitude</param>
/// <returns>Prime meridian</returns>
public IPrimeMeridian CreatePrimeMeridian(string name, IAngularUnit angularUnit, double longitude)
{
if (string.IsNullOrEmpty(name))
throw new ArgumentException("Invalid name");
return new PrimeMeridian(longitude, angularUnit, name, String.Empty, -1, String.Empty, String.Empty, String.Empty);
}
public IPrimeMeridian CreatePrimeMeridian(string name, IAngularUnit angularUnit, double longitude)
{
throw new NotImplementedException();
}
/// <summary>
/// Creates a <see cref="GeographicCoordinateSystem"/>, which could be Lat/Lon or Lon/Lat.
/// </summary>
/// <param name="name">Name of geographical coordinate system</param>
/// <param name="angularUnit">Angular units</param>
/// <param name="datum">Horizontal datum</param>
/// <param name="primeMeridian">Prime meridian</param>
/// <param name="axis0">First axis</param>
/// <param name="axis1">Second axis</param>
/// <returns>Geographic coordinate system</returns>
public IGeographicCoordinateSystem CreateGeographicCoordinateSystem(string name, IAngularUnit angularUnit, IHorizontalDatum datum, IPrimeMeridian primeMeridian, AxisInfo axis0, AxisInfo axis1)
{
if (String.IsNullOrEmpty(name))
{
throw new ArgumentException("Invalid name");
}
List <AxisInfo> info = new List <AxisInfo>(2);
info.Add(axis0);
info.Add(axis1);
return(new GeographicCoordinateSystem(angularUnit, datum, primeMeridian, info, name, String.Empty, -1, String.Empty, String.Empty, String.Empty));
}
public IGeographicCoordinateSystem CreateGeographicCoordinateSystem(string name, IAngularUnit angularUnit,
IHorizontalDatum datum, IPrimeMeridian primeMeridian, AxisInfo axis0, AxisInfo axis1)
{
throw new NotImplementedException();
}
/// <summary>
/// Creates a GCS, which could be Lat/Lon or Lon/Lat.
/// </summary>
/// <param name="name">The name of the coordinae system.</param>
/// <param name="angularUnit">The angular units to use.</param>
/// <param name="horizontalDatum">Ghe horizontal datum to use.</param>
/// <param name="primeMeridian">The prime meridian to use.</param>
/// <param name="axis0">Information about the x axis.</param>
/// <param name="axis1">Information about the y axis.</param>
/// <returns>an object that implements the IGeographicCoordinateSystem interface.</returns>
public IGeographicCoordinateSystem CreateGeographicCoordinateSystem(string name, IAngularUnit angularUnit, IHorizontalDatum horizontalDatum, IPrimeMeridian primeMeridian, IAxisInfo axis0, IAxisInfo axis1)
{
return(new GeographicCoordinateSystem(name, angularUnit, horizontalDatum, primeMeridian, axis0, axis1));
}
/// <summary>
/// Creates a GCS, which could be Lat/Lon or Lon/Lat.
/// </summary>
/// <param name="name">The name of the coordinae system.</param>
/// <param name="angularUnit">The angular units to use.</param>
/// <param name="horizontalDatum">Ghe horizontal datum to use.</param>
/// <param name="primeMeridian">The prime meridian to use.</param>
/// <param name="axis0">Information about the x axis.</param>
/// <param name="axis1">Information about the y axis.</param>
/// <returns>an object that implements the IGeographicCoordinateSystem interface.</returns>
public IGeographicCoordinateSystem CreateGeographicCoordinateSystem(string name, IAngularUnit angularUnit, IHorizontalDatum horizontalDatum, IPrimeMeridian primeMeridian, IAxisInfo axis0, IAxisInfo axis1)
{
return new GeographicCoordinateSystem(name, angularUnit, horizontalDatum, primeMeridian, axis0, axis1);
}
