593 lines
23 KiB
C#
593 lines
23 KiB
C#
using System;
|
|
using System.Linq;
|
|
using System.Diagnostics;
|
|
using System.ComponentModel;
|
|
|
|
namespace CoordinateSharp
|
|
{
|
|
/// <summary>
|
|
/// Universal Transverse Mercator (UTM) coordinate system. Uses the WGS 84 Datum.
|
|
/// </summary>
|
|
[Serializable]
|
|
public class UniversalTransverseMercator : INotifyPropertyChanged
|
|
{
|
|
/// <summary>
|
|
/// Creates a UniversalTransverMercator object with a WGS84 Datum.
|
|
/// </summary>
|
|
/// <param name="latz">Latitude zone</param>
|
|
/// <param name="longz">Longitude zone</param>
|
|
/// <param name="est">Easting</param>
|
|
/// <param name="nrt">Northing</param>
|
|
public UniversalTransverseMercator(string latz, int longz, double est, double nrt)
|
|
{
|
|
if (longz < 1 || longz > 60) { Debug.WriteLine("Longitudinal zone out of range", "UTM longitudinal zones must be between 1-60."); }
|
|
if (!Verify_Lat_Zone(latz)) { Debug.WriteLine("Latitudinal zone invalid", "UTM latitudinal zone was unrecognized."); }
|
|
if (est < 160000 || est > 834000) { Debug.WriteLine("The Easting value provided is outside the max allowable range. Use with caution."); }
|
|
if (nrt < 0 || nrt > 10000000) { Debug.WriteLine("Northing out of range", "Northing must be between 0-10,000,000."); }
|
|
|
|
latZone = latz;
|
|
longZone =longz;
|
|
easting = est;
|
|
northing = nrt;
|
|
|
|
equatorial_radius = 6378137.0;
|
|
inverse_flattening = 298.257223563;
|
|
}
|
|
/// <summary>
|
|
/// Creates a UniversalTransverMercator object with a custom Datum.
|
|
/// </summary>
|
|
/// <param name="latz">Latitude zone</param>
|
|
/// <param name="longz">Longitude zone</param>
|
|
/// <param name="est">Easting</param>
|
|
/// <param name="nrt">Northing</param>
|
|
/// <param name="radius">Equatorial Radius</param>
|
|
/// <param name="flaten">Inverse Flattening</param>
|
|
public UniversalTransverseMercator(string latz, int longz, double est, double nrt, double radius, double flaten)
|
|
{
|
|
if (longz < 1 || longz > 60) { Debug.WriteLine("Longitudinal zone out of range", "UTM longitudinal zones must be between 1-60."); }
|
|
if (!Verify_Lat_Zone(latz)) { Debug.WriteLine("Latitudinal zone invalid", "UTM latitudinal zone was unrecognized."); }
|
|
if (est < 160000 || est > 834000) { Debug.WriteLine("The Easting value provided is outside the max allowable range. Use with caution."); }
|
|
if (nrt < 0 || nrt > 10000000) { Debug.WriteLine("Northing out of range", "Northing must be between 0-10,000,000."); }
|
|
|
|
latZone = latz;
|
|
longZone = longz;
|
|
easting = est;
|
|
northing = nrt;
|
|
|
|
equatorial_radius = radius;
|
|
inverse_flattening = flaten;
|
|
}
|
|
|
|
private Coordinate coordinate;
|
|
|
|
internal double equatorial_radius;
|
|
internal double inverse_flattening;
|
|
private string latZone;
|
|
private int longZone;
|
|
|
|
private double easting;
|
|
private double northing;
|
|
|
|
private bool withinCoordinateSystemBounds = true;
|
|
|
|
/// <summary>
|
|
/// UTM Zone Letter
|
|
/// </summary>
|
|
public string LatZone
|
|
{
|
|
get { return latZone; }
|
|
set
|
|
{
|
|
if (latZone != value)
|
|
{
|
|
latZone = value;
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// UTM Zone Number
|
|
/// </summary>
|
|
public int LongZone
|
|
{
|
|
get { return longZone; }
|
|
set
|
|
{
|
|
if (longZone != value)
|
|
{
|
|
longZone = value;
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// UTM Easting
|
|
/// </summary>
|
|
public double Easting
|
|
{
|
|
get { return easting; }
|
|
set
|
|
{
|
|
if (easting != value)
|
|
{
|
|
easting = value;
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// UTM Northing
|
|
/// </summary>
|
|
public double Northing
|
|
{
|
|
get { return northing; }
|
|
set
|
|
{
|
|
if (northing != value)
|
|
{
|
|
northing = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Datum Equatorial Radius / Semi Major Axis
|
|
/// </summary>
|
|
public double Equatorial_Radius
|
|
{
|
|
get { return equatorial_radius; }
|
|
}
|
|
/// <summary>
|
|
/// Datum Flattening
|
|
/// </summary>
|
|
public double Inverse_Flattening
|
|
{
|
|
get { return inverse_flattening; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is the UTM conversion within the coordinate system's accurate boundaries after conversion from Lat/Long.
|
|
/// </summary>
|
|
public bool WithinCoordinateSystemBounds
|
|
{
|
|
get { return withinCoordinateSystemBounds; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Constructs a UTM object based off DD Lat/Long
|
|
/// </summary>
|
|
/// <param name="lat">DD Latitude</param>
|
|
/// <param name="longi">DD Longitide</param>
|
|
/// <param name="c">Parent Coordinate Object</param>
|
|
internal UniversalTransverseMercator(double lat, double longi, Coordinate c)
|
|
{
|
|
//validate coords
|
|
|
|
//if (lat > 180) { throw new ArgumentOutOfRangeException("Degrees out of range", "Longitudinal coordinate decimal cannot be greater than 180."); }
|
|
//if (lat < -180) { throw new ArgumentOutOfRangeException("Degrees out of range", "Longitudinal coordinate decimal cannot be less than 180."); }
|
|
|
|
//if (longi > 90) { throw new ArgumentOutOfRangeException("Degrees out of range", "Latitudinal coordinate decimal cannot be greater than 90."); }
|
|
//if (longi < -90) { throw new ArgumentOutOfRangeException("Degrees out of range", "Latitudinal coordinate decimal cannot be less than 90."); }
|
|
equatorial_radius = 6378137.0;
|
|
inverse_flattening = 298.257223563;
|
|
ToUTM(lat, longi, this);
|
|
|
|
coordinate = c;
|
|
}
|
|
/// <summary>
|
|
/// Constructs a UTM object based off DD Lat/Long
|
|
/// </summary>
|
|
/// <param name="lat">DD Latitude</param>
|
|
/// <param name="longi">DD Longitide</param>
|
|
/// <param name="c">Parent Coordinate Object</param>
|
|
/// <param name="rad">Equatorial Radius</param>
|
|
/// <param name="flt">Flattening</param>
|
|
internal UniversalTransverseMercator(double lat, double longi, Coordinate c,double rad,double flt)
|
|
{
|
|
equatorial_radius = rad;
|
|
inverse_flattening = flt;
|
|
ToUTM(lat, longi, this);
|
|
|
|
coordinate = c;
|
|
}
|
|
/// <summary>
|
|
/// Constructs a UTM object based off a UTM coordinate
|
|
/// Not yet implemented
|
|
/// </summary>
|
|
/// <param name="latz">Zone Letter</param>
|
|
/// <param name="longz">Zone Number</param>
|
|
/// <param name="e">Easting</param>
|
|
/// <param name="n">Northing</param>
|
|
/// <param name="c">Parent Coordinate Object</param>
|
|
/// <param name="rad">Equatorial Radius</param>
|
|
/// <param name="flt">Inverse Flattening</param>
|
|
internal UniversalTransverseMercator(string latz, int longz, double e, double n, Coordinate c, double rad, double flt)
|
|
{
|
|
//validate utm
|
|
if (longz < 1 || longz > 60) { Debug.WriteLine("Longitudinal zone out of range", "UTM longitudinal zones must be between 1-60."); }
|
|
if (!Verify_Lat_Zone(latz)) { throw new ArgumentException("Latitudinal zone invalid", "UTM latitudinal zone was unrecognized."); }
|
|
if (e < 160000 || e > 834000) { Debug.WriteLine("The Easting value provided is outside the max allowable range. If this is intentional, use with caution."); }
|
|
if (n < 0 || n > 10000000) { throw new ArgumentOutOfRangeException("Northing out of range", "Northing must be between 0-10,000,000."); }
|
|
equatorial_radius = rad;
|
|
inverse_flattening = flt;
|
|
latZone = latz;
|
|
longZone = longz;
|
|
|
|
easting = e;
|
|
northing = n;
|
|
|
|
coordinate = c;
|
|
if (c.Latitude.DecimalDegree <= -80 || c.Latitude.DecimalDegree >= 84) { withinCoordinateSystemBounds = false; }
|
|
else { withinCoordinateSystemBounds = true; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Verifies Lat zone when convert from UTM to DD Lat/Long
|
|
/// </summary>
|
|
/// <param name="l">Zone Letter</param>
|
|
/// <returns>boolean</returns>
|
|
private bool Verify_Lat_Zone(string l)
|
|
{
|
|
if (LatZones.longZongLetters.Where(x => x == l.ToUpper()).Count() != 1)
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
private double degreeToRadian(double degree)
|
|
{
|
|
return degree * Math.PI / 180;
|
|
}
|
|
/// <summary>
|
|
/// Assigns UTM values based of Lat/Long
|
|
/// </summary>
|
|
/// <param name="lat">DD Latitude</param>
|
|
/// <param name="longi">DD longitude</param>
|
|
/// <param name="utm">UTM Object to modify</param>
|
|
internal void ToUTM(double lat, double longi, UniversalTransverseMercator utm)
|
|
{
|
|
string letter = "";
|
|
double easting = 0;
|
|
double northing = 0;
|
|
int zone = (int)Math.Floor(longi / 6 + 31);
|
|
if (lat < -72)
|
|
letter = "C";
|
|
else if (lat < -64)
|
|
letter = "D";
|
|
else if (lat < -56)
|
|
letter = "E";
|
|
else if (lat < -48)
|
|
letter = "F";
|
|
else if (lat < -40)
|
|
letter = "G";
|
|
else if (lat < -32)
|
|
letter = "H";
|
|
else if (lat < -24)
|
|
letter = "J";
|
|
else if (lat < -16)
|
|
letter = "K";
|
|
else if (lat < -8)
|
|
letter = "L";
|
|
else if (lat < 0)
|
|
letter = "M";
|
|
else if (lat < 8)
|
|
letter = "N";
|
|
else if (lat < 16)
|
|
letter = "P";
|
|
else if (lat < 24)
|
|
letter = "Q";
|
|
else if (lat < 32)
|
|
letter = "R";
|
|
else if (lat < 40)
|
|
letter = "S";
|
|
else if (lat < 48)
|
|
letter = "T";
|
|
else if (lat < 56)
|
|
letter = "U";
|
|
else if (lat < 64)
|
|
letter = "V";
|
|
else if (lat < 72)
|
|
letter = "W";
|
|
else
|
|
letter = "X";
|
|
|
|
double a = utm.equatorial_radius;
|
|
double f = 1.0 / utm.inverse_flattening;
|
|
double b = a * (1 - f); // polar radius
|
|
|
|
double e = Math.Sqrt(1 - Math.Pow(b, 2) / Math.Pow(a, 2));
|
|
double e0 = e / Math.Sqrt(1 - Math.Pow(e, 1));
|
|
|
|
double drad = Math.PI / 180;
|
|
double k0 = 0.9996;
|
|
|
|
double phi = lat * drad; // convert latitude to radians
|
|
double lng = longi * drad; // convert longitude to radians
|
|
double utmz = 1 + Math.Floor((longi + 180) / 6.0); // longitude to utm zone
|
|
double zcm = 3 + 6.0 * (utmz - 1) - 180; // central meridian of a zone
|
|
// this gives us zone A-B for below 80S
|
|
double esq = (1 - (b / a) * (b / a));
|
|
double e0sq = e * e / (1 - Math.Pow(e, 2));
|
|
double M = 0;
|
|
|
|
double N = a / Math.Sqrt(1 - Math.Pow(e * Math.Sin(phi), 2));
|
|
double T = Math.Pow(Math.Tan(phi), 2);
|
|
double C = e0sq * Math.Pow(Math.Cos(phi), 2);
|
|
double A = (longi - zcm) * drad * Math.Cos(phi);
|
|
|
|
// calculate M (USGS style)
|
|
M = phi * (1 - esq * (1.0 / 4.0 + esq * (3.0 / 64.0 + 5.0 * esq / 256.0)));
|
|
M = M - Math.Sin(2.0 * phi) * (esq * (3.0 / 8.0 + esq * (3.0 / 32.0 + 45.0 * esq / 1024.0)));
|
|
M = M + Math.Sin(4.0 * phi) * (esq * esq * (15.0 / 256.0 + esq * 45.0 / 1024.0));
|
|
M = M - Math.Sin(6.0 * phi) * (esq * esq * esq * (35.0 / 3072.0));
|
|
M = M * a;//Arc length along standard meridian
|
|
|
|
double M0 = 0;// if another point of origin is used than the equator
|
|
|
|
// Calculate the UTM values...
|
|
// first the easting
|
|
var x = k0 * N * A * (1 + A * A * ((1 - T + C) / 6 + A * A * (5 - 18 * T + T * T + 72.0 * C - 58 * e0sq) / 120.0)); //Easting relative to CM
|
|
x = x + 500000; // standard easting
|
|
|
|
// Northing
|
|
|
|
double y = k0 * (M - M0 + N * Math.Tan(phi) * (A * A * (1 / 2.0 + A * A * ((5 - T + 9 * C + 4 * C * C) / 24.0 + A * A * (61 - 58 * T + T * T + 600 * C - 330 * e0sq) / 720.0)))); // first from the equator
|
|
double yg = y + 10000000; //yg = y global, from S. Pole
|
|
if (y < 0)
|
|
{
|
|
y = 10000000 + y; // add in false northing if south of the equator
|
|
}
|
|
|
|
|
|
easting = Math.Round(10 * (x)) / 10.0;
|
|
northing = Math.Round(10 * y) / 10.0;
|
|
|
|
utm.latZone = letter;
|
|
utm.longZone = zone;
|
|
utm.easting = easting;
|
|
utm.northing = northing;
|
|
|
|
if(lat<=-80 || lat >= 84) { withinCoordinateSystemBounds = false; }
|
|
else { withinCoordinateSystemBounds = true; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// UTM Default String Format
|
|
/// </summary>
|
|
/// <returns>UTM Formatted Coordinate String</returns>
|
|
public override string ToString()
|
|
{
|
|
if (!withinCoordinateSystemBounds) { return ""; }//MGRS Coordinate is outside its reliable boundaries. Return empty.
|
|
return longZone.ToString() + LatZone + " " + (int)easting + "mE " + (int)northing + "mN";
|
|
}
|
|
|
|
private static Coordinate UTMtoLatLong(double x, double y, double zone, double equatorialRadius, double flattening)
|
|
{
|
|
//x easting
|
|
//y northing
|
|
|
|
//http://home.hiwaay.net/~taylorc/toolbox/geography/geoutm.html
|
|
double phif, Nf, Nfpow, nuf2, ep2, tf, tf2, tf4, cf;
|
|
double x1frac, x2frac, x3frac, x4frac, x5frac, x6frac, x7frac, x8frac;
|
|
double x2poly, x3poly, x4poly, x5poly, x6poly, x7poly, x8poly;
|
|
|
|
double sm_a = equatorialRadius;
|
|
double sm_b = equatorialRadius * (1 - (1.0 / flattening)); //Polar Radius
|
|
|
|
/* Get the value of phif, the footpoint latitude. */
|
|
phif = FootpointLatitude(y,equatorialRadius,flattening);
|
|
|
|
/* Precalculate ep2 */
|
|
ep2 = (Math.Pow(sm_a, 2.0) - Math.Pow(sm_b, 2.0))
|
|
/ Math.Pow(sm_b, 2.0);
|
|
|
|
/* Precalculate cos (phif) */
|
|
cf = Math.Cos(phif);
|
|
|
|
/* Precalculate nuf2 */
|
|
nuf2 = ep2 * Math.Pow(cf, 2.0);
|
|
|
|
/* Precalculate Nf and initialize Nfpow */
|
|
Nf = Math.Pow(sm_a, 2.0) / (sm_b * Math.Sqrt(1 + nuf2));
|
|
Nfpow = Nf;
|
|
|
|
/* Precalculate tf */
|
|
tf = Math.Tan(phif);
|
|
tf2 = tf * tf;
|
|
tf4 = tf2 * tf2;
|
|
|
|
/* Precalculate fractional coefficients for x**n in the equations
|
|
below to simplify the expressions for latitude and longitude. */
|
|
x1frac = 1.0 / (Nfpow * cf);
|
|
|
|
Nfpow *= Nf; /* now equals Nf**2) */
|
|
x2frac = tf / (2.0 * Nfpow);
|
|
|
|
Nfpow *= Nf; /* now equals Nf**3) */
|
|
x3frac = 1.0 / (6.0 * Nfpow * cf);
|
|
|
|
Nfpow *= Nf; /* now equals Nf**4) */
|
|
x4frac = tf / (24.0 * Nfpow);
|
|
|
|
Nfpow *= Nf; /* now equals Nf**5) */
|
|
x5frac = 1.0 / (120.0 * Nfpow * cf);
|
|
|
|
Nfpow *= Nf; /* now equals Nf**6) */
|
|
x6frac = tf / (720.0 * Nfpow);
|
|
|
|
Nfpow *= Nf; /* now equals Nf**7) */
|
|
x7frac = 1.0 / (5040.0 * Nfpow * cf);
|
|
|
|
Nfpow *= Nf; /* now equals Nf**8) */
|
|
x8frac = tf / (40320.0 * Nfpow);
|
|
|
|
/* Precalculate polynomial coefficients for x**n.
|
|
-- x**1 does not have a polynomial coefficient. */
|
|
x2poly = -1.0 - nuf2;
|
|
|
|
x3poly = -1.0 - 2 * tf2 - nuf2;
|
|
|
|
x4poly = 5.0 + 3.0 * tf2 + 6.0 * nuf2 - 6.0 * tf2 * nuf2
|
|
- 3.0 * (nuf2 * nuf2) - 9.0 * tf2 * (nuf2 * nuf2);
|
|
|
|
x5poly = 5.0 + 28.0 * tf2 + 24.0 * tf4 + 6.0 * nuf2 + 8.0 * tf2 * nuf2;
|
|
|
|
x6poly = -61.0 - 90.0 * tf2 - 45.0 * tf4 - 107.0 * nuf2
|
|
+ 162.0 * tf2 * nuf2;
|
|
|
|
x7poly = -61.0 - 662.0 * tf2 - 1320.0 * tf4 - 720.0 * (tf4 * tf2);
|
|
|
|
x8poly = 1385.0 + 3633.0 * tf2 + 4095.0 * tf4 + 1575 * (tf4 * tf2);
|
|
|
|
/* Calculate latitude */
|
|
double nLat = phif + x2frac * x2poly * (x * x)
|
|
+ x4frac * x4poly * Math.Pow(x, 4.0)
|
|
+ x6frac * x6poly * Math.Pow(x, 6.0)
|
|
+ x8frac * x8poly * Math.Pow(x, 8.0);
|
|
|
|
/* Calculate longitude */
|
|
double nLong = zone + x1frac * x
|
|
+ x3frac * x3poly * Math.Pow(x, 3.0)
|
|
+ x5frac * x5poly * Math.Pow(x, 5.0)
|
|
+ x7frac * x7poly * Math.Pow(x, 7.0);
|
|
|
|
double dLat = RadToDeg(nLat);
|
|
double dLong = RadToDeg(nLong);
|
|
if (dLat > 90) { dLat = 90; }
|
|
if (dLat < -90) { dLat = -90; }
|
|
if (dLong > 180) { dLong = 180; }
|
|
if (dLong < -180) { dLong = -180; }
|
|
|
|
Coordinate c = new Coordinate(equatorialRadius,flattening, true);
|
|
CoordinatePart cLat = new CoordinatePart(dLat, CoordinateType.Lat);
|
|
CoordinatePart cLng = new CoordinatePart(dLong, CoordinateType.Long);
|
|
|
|
c.Latitude = cLat;
|
|
c.Longitude = cLng;
|
|
|
|
return c;
|
|
}
|
|
|
|
private static double RadToDeg(double rad)
|
|
{
|
|
double pi = 3.14159265358979;
|
|
return (rad / pi * 180.0);
|
|
}
|
|
private static double DegToRad(double deg)
|
|
{
|
|
double pi = 3.14159265358979;
|
|
return (deg / 180.0 * pi);
|
|
}
|
|
private static double FootpointLatitude(double y, double equatorialRadius, double flattening)
|
|
{
|
|
double y_, alpha_, beta_, gamma_, delta_, epsilon_, n;
|
|
double result;
|
|
|
|
|
|
/* Ellipsoid model constants (actual values here are for WGS84) */
|
|
double sm_a = equatorialRadius;
|
|
double sm_b = equatorialRadius * (1 - (1.0 / flattening));
|
|
|
|
|
|
/* Precalculate n (Eq. 10.18) */
|
|
n = (sm_a - sm_b) / (sm_a + sm_b);
|
|
|
|
/* Precalculate alpha_ (Eq. 10.22) */
|
|
/* (Same as alpha in Eq. 10.17) */
|
|
alpha_ = ((sm_a + sm_b) / 2.0) * (1 + (Math.Pow(n, 2.0) / 4) + (Math.Pow(n, 4.0) / 64));
|
|
|
|
/* Precalculate y_ (Eq. 10.23) */
|
|
y_ = y / alpha_;
|
|
|
|
/* Precalculate beta_ (Eq. 10.22) */
|
|
beta_ = (3.0 * n / 2.0) + (-27.0 * Math.Pow(n, 3.0) / 32.0)
|
|
+ (269.0 * Math.Pow(n, 5.0) / 512.0);
|
|
|
|
/* Precalculate gamma_ (Eq. 10.22) */
|
|
gamma_ = (21.0 * Math.Pow(n, 2.0) / 16.0)
|
|
+ (-55.0 * Math.Pow(n, 4.0) / 32.0);
|
|
|
|
/* Precalculate delta_ (Eq. 10.22) */
|
|
delta_ = (151.0 * Math.Pow(n, 3.0) / 96.0)
|
|
+ (-417.0 * Math.Pow(n, 5.0) / 128.0);
|
|
|
|
/* Precalculate epsilon_ (Eq. 10.22) */
|
|
epsilon_ = (1097.0 * Math.Pow(n, 4.0) / 512.0);
|
|
|
|
/* Now calculate the sum of the series (Eq. 10.21) */
|
|
result = y_ + (beta_ * Math.Sin(2.0 * y_))
|
|
+ (gamma_ * Math.Sin(4.0 * y_))
|
|
+ (delta_ * Math.Sin(6.0 * y_))
|
|
+ (epsilon_ * Math.Sin(8.0 * y_));
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Converts UTM coordinate to Lat/Long
|
|
/// </summary>
|
|
/// <param name="utm">utm</param>
|
|
/// <returns>Coordinate object</returns>
|
|
public static Coordinate ConvertUTMtoLatLong(UniversalTransverseMercator utm)
|
|
{
|
|
|
|
bool southhemi = false;
|
|
if (utm.latZone == "A" || utm.latZone == "B" || utm.latZone == "C" || utm.latZone == "D" || utm.latZone == "E" || utm.latZone == "F" || utm.latZone == "G" || utm.latZone == "H" || utm.latZone == "J" ||
|
|
utm.latZone == "K" || utm.latZone == "L" || utm.latZone == "M")
|
|
{
|
|
southhemi = true;
|
|
}
|
|
|
|
double cmeridian;
|
|
|
|
double x = utm.Easting - 500000.0;
|
|
double UTMScaleFactor = 0.9996;
|
|
x /= UTMScaleFactor;
|
|
|
|
/* If in southern hemisphere, adjust y accordingly. */
|
|
double y = utm.Northing;
|
|
if (southhemi)
|
|
{
|
|
y -= 10000000.0;
|
|
}
|
|
|
|
y /= UTMScaleFactor;
|
|
|
|
cmeridian = UTMCentralMeridian(utm.LongZone);
|
|
|
|
Coordinate c = UTMtoLatLong(x, y, cmeridian, utm.equatorial_radius, utm.inverse_flattening);
|
|
|
|
if (c.Latitude.ToDouble() > 85 || c.Latitude.ToDouble() < -85)
|
|
{
|
|
Debug.WriteLine("UTM conversions greater than 85 degrees or less than -85 degree latitude contain major deviations and should be used with caution.");
|
|
}
|
|
return c;
|
|
|
|
|
|
}
|
|
|
|
private static double UTMCentralMeridian(double zone)
|
|
{
|
|
double cmeridian;
|
|
|
|
cmeridian = DegToRad(-183.0 + (zone * 6.0));
|
|
|
|
return cmeridian;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Property changed event
|
|
/// </summary>
|
|
public event PropertyChangedEventHandler PropertyChanged;
|
|
/// <summary>
|
|
/// Notify property changed
|
|
/// </summary>
|
|
/// <param name="propName">Property name</param>
|
|
public void NotifyPropertyChanged(string propName)
|
|
{
|
|
if (this.PropertyChanged != null)
|
|
{
|
|
PropertyChanged(this, new PropertyChangedEventArgs(propName));
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|