public void TestNamedMeridians()
{
foreach (NamedMeridian nm in Enum.GetValues(typeof(NamedMeridian)))
{
if (nm == NamedMeridian.Unknown || nm == NamedMeridian.Undefined)
{
continue;
}
var m = Meridian.CreateByNamedMeridian(nm);
Assert.AreEqual((int)nm, m.Code);
Assert.AreEqual(nm, m.Name);
Assert.AreEqual(string.Format(" +pm={0}", nm.ToString().ToLower()), m.Proj4Description);
var c = new GeoAPI.Geometries.Coordinate(0, 0);
m.InverseAdjust(c);
Assert.AreEqual(m.Longitude, c.X, 1e-7);
m.Adjust(c);
Assert.AreEqual(0, c.X, 1e-7);
var m2 = Meridian.CreateByName(nm.ToString().ToLower());
Assert.AreEqual(m, m2);
var m3 = Meridian.CreateByDegree(Utility.ProjectionMath.ToDegrees(m.Longitude));
Assert.AreEqual(m, m3);
}
}
public void DefaultCtor()
{
var target = new Meridian();
Assert.IsNotNull(target);
Assert.AreEqual(Proj4Meridian.Greenwich.ToString(), target.Name);
}
public void WellKnownTextConverterToIdentifiedObjectTest()
{
for (Int32 index = 0; index < this.identifiedObjects.Length; index++)
{
IdentifiedObject identifiedObject = WellKnownTextConverter.ToIdentifiedObject(this.identifiedObjectsText[index], TestUtilities.ReferenceProvider);
Assert.AreEqual(this.identifiedObjects[index], identifiedObject);
}
Meridian meridian = WellKnownTextConverter.ToIdentifiedObject("PRIMEM[\"Greenwich\",0.0]", TestUtilities.ReferenceProvider) as Meridian;
Assert.AreEqual(meridian, TestUtilities.ReferenceProvider.Meridians["EPSG", 8901]);
meridian = WellKnownTextConverter.ToIdentifiedObject("PRIMEM(\"Greenwich\",0.0)", TestUtilities.ReferenceProvider) as Meridian;
Assert.AreEqual(meridian, TestUtilities.ReferenceProvider.Meridians["EPSG", 8901]);
meridian = WellKnownTextConverter.ToIdentifiedObject("PRIMEM(Greenwich,0.0)", TestUtilities.ReferenceProvider) as Meridian;
Assert.AreEqual(meridian, TestUtilities.ReferenceProvider.Meridians["EPSG", 8901]);
meridian = WellKnownTextConverter.ToIdentifiedObject("PRIMEM[\"Greenwich\", 0.0, AUTHORITY[\"EPSG\", 8901]]", TestUtilities.ReferenceProvider) as Meridian;
Assert.AreEqual(meridian, TestUtilities.ReferenceProvider.Meridians["EPSG", 8901]);
meridian = WellKnownTextConverter.ToIdentifiedObject("PRIMEM [\"Greenwich\", 0.0, AUTHORITY [\"EPSG\", 8901]])", TestUtilities.ReferenceProvider) as Meridian;
Assert.AreEqual(meridian, TestUtilities.ReferenceProvider.Meridians["EPSG", 8901]);
meridian = WellKnownTextConverter.ToIdentifiedObject("PRIMEM[Greenwich, 0.0, AUTHORITY[EPSG, 8901]]", TestUtilities.ReferenceProvider) as Meridian;
Assert.AreEqual(meridian, TestUtilities.ReferenceProvider.Meridians["EPSG", 8901]);
Assert.Throws <ArgumentNullException>(() => WellKnownTextConverter.ToIdentifiedObject(null, null));
Assert.Throws <ArgumentException>(() => WellKnownTextConverter.ToIdentifiedObject(String.Empty, TestUtilities.ReferenceProvider));
Assert.Throws <ArgumentException>(() => WellKnownTextConverter.ToIdentifiedObject("UNDEFINED[\"something\"]", TestUtilities.ReferenceProvider));
}
public void CtorLongitudeName(Tuple <Proj4Meridian, double, int> meridian)
{
var target = new Meridian(meridian.Item2, meridian.Item1.ToString());
Assert.IsNotNull(target);
Assert.AreEqual(meridian.Item2, target.Longitude);
Assert.AreEqual(meridian.Item1.ToString(), target.Name);
}
private void CmbMeridianSelectedIndexChanged(object sender, EventArgs e)
{
Proj4Meridian mer = (Proj4Meridian)Enum.Parse(typeof(Proj4Meridian), (string)cmbMeridian.SelectedItem);
Meridian m = new Meridian(mer);
SelectedProjectionInfo.GeographicInfo.Meridian = m;
dbMeridian.Value = m.Longitude;
}
public void TestCustomMeridian()
{
var degree = 5.7;
var m = Meridian.CreateByDegree(degree);
Assert.AreEqual(NamedMeridian.Unknown, m.Name);
Assert.AreEqual(Utility.ProjectionMath.ToDegrees(m.Longitude), degree);
Assert.AreEqual(string.Format(System.Globalization.NumberFormatInfo.InvariantInfo, " +pm={0}", degree), m.Proj4Description);
}
/// <summary>
/// Returns a hash code for this instance.
/// </summary>
/// <returns>
/// A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table.
/// </returns>
public override int GetHashCode()
{
return(Direction.GetHashCode() ^
LegalSubdivision.GetHashCode() ^
Meridian.GetHashCode() ^
Range.GetHashCode() ^
Section.GetHashCode() ^
Township.GetHashCode());
}
public void AssignMeridian(Tuple <Proj4Meridian, double, int> meridian)
{
var target = new Meridian();
target.AssignMeridian(meridian.Item1);
Assert.AreEqual(meridian.Item3, target.Code);
Assert.AreEqual(meridian.Item2, target.Longitude);
Assert.AreEqual(meridian.Item1.ToString(), target.Name);
}
public void PmDoubleValue(Tuple <Proj4Meridian, double, int> meridian)
{
var target = new Meridian {
pm = meridian.Item2.ToString(CultureInfo.InvariantCulture)
};
Assert.AreEqual(meridian.Item3, target.Code);
Assert.AreEqual(meridian.Item2, target.Longitude);
Assert.AreEqual(meridian.Item1.ToString(), target.Name);
}
public void PmStringValue(Tuple <Proj4Meridian, double, int> meridian)
{
var target = new Meridian {
pm = meridian.Item1.ToString()
};
Assert.AreEqual(meridian.Item3, target.Code);
Assert.AreEqual(meridian.Item2, target.Longitude);
Assert.AreEqual(meridian.Item1.ToString(), target.Name);
}
public Meridian GetMeridianById(int id)
{
Meridian meridian = null;
if (!this.id_MeridianMap.TryGetValue(id, out meridian))
{
Logger.Warn("Invalid Meridian Id : {0:X}", new object[] { id });
return(null);
}
return(meridian);
}
private MeridianGroup LoadMeridianGroupFromXml(SecurityElement element)
{
MeridianGroup group = new MeridianGroup {
type = TypeNameContainer <_MeridianType> .Parse(element.Attribute("Type"), 0)
};
if (element.Children != null)
{
foreach (SecurityElement element2 in element.Children)
{
string str;
if (((str = element2.Tag) != null) && (str == "Meridian"))
{
Meridian item = this.LoadMeridianFromXml(element2);
group.meridians.Add(item);
}
}
}
return(group);
}
/// <summary>
/// Computes the geodetic datum.
/// </summary>
/// <returns>The geodetic datum.</returns>
/// <exception cref="System.IO.InvalidDataException">Geodetic Datum code is invalid.</exception>
private GeodeticDatum ComputeGeodeticDatum()
{
Int32 code = Convert.ToInt32(_currentGeoKeys[GeoKey.GeodeticDatum]);
// EPSG geodetic datum codes
if (code >= 6000 && code <= 6999)
{
return(GeodeticDatums.FromIdentifier("EPSG::" + code).FirstOrDefault());
}
// user-defined geodetic datum
if (code == Int16.MaxValue)
{
Ellipsoid ellipsoid = ComputeEllipsoid();
Meridian primeMeridian = ComputePrimeMeridian();
return(new GeodeticDatum(GeodeticDatum.UserDefinedIdentifier, GeodeticDatum.UserDefinedName, null, null, null, ellipsoid, primeMeridian));
}
throw new InvalidDataException("Geodetic datum code is invalid.");
}
private Meridian LoadMeridianFromXml(SecurityElement element)
{
Meridian meridian = new Meridian {
id = StrParser.ParseHexInt(element.Attribute("Id"), 0),
name = StrParser.ParseStr(element.Attribute("Name"), ""),
level = StrParser.ParseDecInt(element.Attribute("Level"), 1),
preMeridianId = StrParser.ParseHexInt(element.Attribute("PreMeridianId"), 0),
buffAddition = StrParser.ParseFloat(element.Attribute("BuffAddition"), 0f)
};
if (element.Children != null)
{
foreach (SecurityElement element2 in element.Children)
{
MeridianBuff buff;
string tag = element2.Tag;
if (tag != null)
{
if (tag == "IncreaseCost")
{
meridian.increaseCosts.Add(IncreaseCost.LoadFromXml(element2));
}
else if (tag == "Buff")
{
goto Label_00E5;
}
}
continue;
Label_00E5:
buff = new MeridianBuff();
buff.id = StrParser.ParseHexInt(element2.Attribute("BuffId"), 0);
buff.weight = StrParser.ParseDecInt(element2.Attribute("Weight"), 1);
meridian.meridianBuffs.Add(buff);
}
}
return(meridian);
}
public static Meridian Create(IPrimeMeridianInfo primeMeridian)
{
if (primeMeridian == null)
{
throw new ArgumentNullException("primeMeridian");
}
Contract.Ensures(Contract.Result <Meridian>() != null);
var lon = primeMeridian.Longitude;
if (primeMeridian.Unit.Name != "degrees")
{
var conversion = SimpleUnitConversionGenerator.FindConversion(primeMeridian.Unit, OgcAngularUnit.DefaultDegrees);
if (conversion != null)
{
lon = conversion.TransformValue(lon);
}
else
{
throw new InvalidOperationException("Could not convert meridian unit.");
}
}
var result = new Meridian(lon, primeMeridian.Name);
if (primeMeridian.Authority != null)
{
int epsgCode;
if (primeMeridian.Authority.Name == "EPSG" && Int32.TryParse(primeMeridian.Authority.Code, out epsgCode))
{
result.Code = epsgCode;
}
}
return(result);
}
/// <summary>
/// Inverse solution of geodetic problem from start point, end point to the distance and azimuth.
/// </summary>
/// <param name="start">start point of geodesic</param>
/// <param name="end">end point of geodesic</param>
/// <param name="distance">distance of geodesic</param>
/// <param name="bearing">azimuth of geodesic</param>
/// <param name="ivBearing">inverse azimuth of geodesic</param>
protected override void Inverse(GeoPoint start, GeoPoint end, out double distance, out Angle bearing, out Angle ivBearing)
{
double lat1 = start.Latitude.Radians;
double lng1 = start.Longitude.Radians;
double lat2 = end.Latitude.Radians;
double lng2 = end.Longitude.Radians;
// If the two point on the same meridian
if (Math.Abs(lng1 - lng2) < double.Epsilon)
{
Meridian meridian = new Meridian(start.Longitude, start.Latitude, end.Latitude, start.Ellipsoid);
distance = meridian.Length;
bearing = meridian.Azimuth;
ivBearing = meridian.InverseAzimuth;
return;
}
double a = start.Ellipsoid.a;
double es = start.Ellipsoid.ee;
double ses = start.Ellipsoid._ee;
double u1 = Math.Atan(Math.Sqrt(1 - es) * Math.Tan(lat1));
double u2 = Math.Atan(Math.Sqrt(1 - es) * Math.Tan(lat2));
double dL = lng2 - lng1;
double sigma = Math.Sin(u1) * Math.Sin(u2) + Math.Cos(u1) * Math.Cos(u2) * Math.Cos(dL); //Cos(sigma)
sigma = Math.Atan(Math.Sqrt(1 - sigma * sigma) / sigma);
if (sigma < 0)
{
sigma += Math.PI;
}
double m = Math.Cos(u1) * Math.Cos(u2) * Math.Sin(dL) / Math.Sin(sigma); //Sin(m)
m = Math.Atan(m / Math.Sqrt(1 - m * m));
double KK, alpha, beta, gamma;
double temp = dL;
double lamda = dL + 0.003351 * sigma * Math.Sin(m);
double M = Math.PI / 2;
while (Math.Abs(lamda - temp) > Settings.Epsilon5) //精度0.00001秒
{
temp = lamda;
m = Math.Cos(u1) * Math.Cos(u2) * Math.Sin(lamda) / Math.Sin(sigma); //Sin(m)
m = Math.Atan(m / Math.Sqrt(1 - m * m));
double tanA = Math.Sin(lamda) / (Math.Cos(u1) * Math.Tan(u2) - Math.Sin(u1) * Math.Cos(lamda));
M = Math.Atan(Math.Sin(u1) * tanA / Math.Sin(m));
if (M < 0)
{
M += Math.PI;
}
KK = es * Math.Pow(Math.Cos(m), 2);
alpha = es / 2 + es * es / 8 + Math.Pow(es, 3) / 16 - es * (1 + es) * KK / 16 + 3 * es * KK * KK / 128;
beta = es * (1 + es) * KK / 16 - es * KK * KK / 32;
gamma = es * KK * KK / 256;
lamda = dL + Math.Sin(m) * (alpha * sigma + beta * Math.Sin(sigma) * Math.Cos(2 * M + sigma) + gamma * Math.Sin(2 * sigma) * Math.Cos(4 * M + 2 * sigma));
sigma = Math.Sin(u1) * Math.Sin(u2) + Math.Cos(u1) * Math.Cos(u2) * Math.Cos(lamda); //Cos(sigma)
sigma = Math.Atan(Math.Sqrt(1 - sigma * sigma) / sigma);
if (sigma < 0)
{
sigma += Math.PI;
}
}
double A1 = Math.Atan(Math.Sin(lamda) / (Math.Cos(u1) * Math.Tan(u2) - Math.Sin(u1) * Math.Cos(lamda)));
if (A1 < 0)
{
A1 += Math.PI;
}
if (m < 0)
{
A1 += Math.PI;
}
bearing = Angle.FromRadians(A1);
double A2 = Math.Atan(Math.Sin(lamda) / (Math.Sin(u2) * Math.Cos(lamda) - Math.Tan(u1) * Math.Cos(u2)));
if (A2 < 0)
{
A2 += Math.PI;
}
if (m > 0)
{
A2 += Math.PI;
}
ivBearing = Angle.FromRadians(A2);
KK = ses * Math.Pow(Math.Cos(m), 2);
alpha = Math.Sqrt(1 + ses) * (1 - KK / 4 + 7 * KK * KK / 64 - 15 * Math.Pow(KK, 3) / 256) / a;
beta = KK / 4 - KK * KK / 8 + 37 * Math.Pow(KK, 3) / 512;
gamma = KK * KK * (1 - KK) / 128;
distance = (sigma - beta * Math.Sin(sigma) * Math.Cos(2 * M + sigma) - gamma * Math.Sin(2 * sigma) * Math.Cos(4 * M + 2 * sigma)) / alpha;
}
public Proj4MeridianWrapper(Meridian meridian)
: base(meridian.Name ?? "Unknown", new AuthorityTag("PROJ4", meridian.Code.ToString(CultureInfo.InvariantCulture)))
{
Contract.Requires(meridian != null);
Core = meridian;
}
/// <summary>
/// Returns a collection with items with the specified prime meridian.
/// </summary>
/// <param name="collection">The geodetic datum collection.</param>
/// <param name="primeMeridian">The prime meridian.</param>
/// <returns>A collection containing the items that are with the specified prime meridian.</returns>
/// <exception cref="System.ArgumentNullException">
/// The collection is null.
/// or
/// The prime meridian is null.
/// </exception>
public static IEnumerable <GeodeticDatum> WithPrimeMeridian(this IEnumerable <GeodeticDatum> collection, Meridian primeMeridian)
{
if (collection == null)
{
throw new ArgumentNullException(nameof(collection));
}
if (primeMeridian == null)
{
throw new ArgumentNullException(nameof(primeMeridian));
}
return(collection.Where(item => item.PrimeMeridian.Equals(primeMeridian)));
}
private void cmbMeridian_SelectedIndexChanged(object sender, EventArgs e)
{
Proj4Meridian mer = (Proj4Meridian)Enum.Parse(typeof(Proj4Meridian), (string)cmbMeridian.SelectedItem);
Meridian m = new Meridian(mer);
_selectedProjectionInfo.GeographicInfo.Meridian = m;
dbMeridian.Value = m.Longitude;
}
///<summary>
/// Creates a <see cref="Projection"/> initialized from a PROJ.4 argument list.
///</summary>
private Projection.Projection ParseProjection(IDictionary <String, String> parameters, Ellipsoid ellipsoid)
{
Projection.Projection projection = null;
String s;
if (parameters.TryGetValue(Proj4Keyword.proj, out s))
{
projection = registry.GetProjection(s, parameters);
}
if (projection == null)
{
throw new ArgumentException("Unknown projection: " + s);
}
projection.Ellipsoid = ellipsoid;
// not sure what CSes use this??
/*
* s = (String)parameters.TryGetValue( "init" );
* if ( s != null ) {
* projection = CreateFromName( s ).getProjection();
* if ( projection == null )
* throw new ProjectionException( "Unknown projection: "+s );
* a = projection.getEquatorRadius();
* es = projection.getEllipsoid().getEccentricitySquared();
* }
*/
//TODO: better error handling for things like bad number syntax.
// Should be able to report the original param string in the error message
// Also should the exception be lib specific? (Say ParseException)
// Other parameters
// projection.ProjectionLatitudeDegrees = 0;
// projection.ProjectionLatitude1Degrees = 0;
// projection.ProjectionLatitude2Degrees = 0;
if (parameters.TryGetValue(Proj4Keyword.alpha, out s))
{
projection.AlphaDegrees = Double.Parse(s, CultureInfo.InvariantCulture);
}
if (parameters.TryGetValue(Proj4Keyword.lonc, out s))
{
projection.LonCDegrees = Double.Parse(s, CultureInfo.InvariantCulture);
}
if (parameters.TryGetValue(Proj4Keyword.lat_0, out s))
{
projection.ProjectionLatitudeDegrees = ParseAngle(s);
}
if (parameters.TryGetValue(Proj4Keyword.lon_0, out s))
{
projection.ProjectionLongitudeDegrees = ParseAngle(s);
}
if (parameters.TryGetValue(Proj4Keyword.lat_1, out s))
{
projection.ProjectionLatitude1Degrees = ParseAngle(s);
}
if (parameters.TryGetValue(Proj4Keyword.lat_2, out s))
{
projection.ProjectionLatitude2Degrees = ParseAngle(s);
}
if (parameters.TryGetValue(Proj4Keyword.lat_ts, out s))
{
projection.TrueScaleLatitudeDegrees = ParseAngle(s);
}
if (parameters.TryGetValue(Proj4Keyword.x_0, out s))
{
projection.FalseEasting = Double.Parse(s, CultureInfo.InvariantCulture);
}
if (parameters.TryGetValue(Proj4Keyword.y_0, out s))
{
projection.FalseNorthing = Double.Parse(s, CultureInfo.InvariantCulture);
}
if (!parameters.TryGetValue(Proj4Keyword.k_0, out s))
{
if (!parameters.TryGetValue(Proj4Keyword.k, out s))
{
s = null;
}
}
if (s != null)
{
projection.ScaleFactor = Double.Parse(s, CultureInfo.InvariantCulture);
}
if (parameters.TryGetValue(Proj4Keyword.units, out s))
{
Unit unit = Units.Units.FindUnit(s);
// TODO: report unknown units name as error
if (unit != null)
{
projection.FromMetres = (1.0 / unit.Value);
projection.Unit = unit;
}
}
if (parameters.TryGetValue(Proj4Keyword.to_meter, out s))
{
projection.FromMetres = (1.0 / Double.Parse(s, CultureInfo.InvariantCulture));
}
if (parameters.ContainsKey(Proj4Keyword.south))
{
projection.SouthernHemisphere = true;
}
if (parameters.TryGetValue(Proj4Keyword.pm, out s))
{
double pm;
projection.PrimeMeridian = double.TryParse(s, out pm)
? Meridian.CreateByDegree(pm)
: Meridian.CreateByName(s);
}
//TODO: implement some of these parameters ?
// this must be done last, since behaviour depends on other parameters being set (eg +south)
if (projection is TransverseMercatorProjection)
{
if (parameters.TryGetValue("zone", out s))
{
((TransverseMercatorProjection)projection).UTMZone = int.Parse(s);
}
}
projection.Initialize();
return(projection);
}
