Conversión de coordenadas UTM (wsg84) a Latitud y Longitud

Question

He estado buscando desde hace un tiempo (aquí y en Google obviamente) para una forma ordenada de convertir un conjunto de coordenadas UTM a Latitud y Longitud. Tengo los coords y sé en qué zona se encuentran, pero ¿cómo convierto esto a lat y lon? Estaba esperando que habría algún tipo de una clase que podría hacer al menos algo de la magia para mí, pero dosn't parecer tan :(

Cualquier sugerencia acerca de esto?

sé que se puede hacer , ya que este convertidor parece funcionar muy bien:

http://home.hiwaay.net/~taylorc/toolbox/geography/geoutm.html 

Cualquier aportación es muy apreciada :)

Gracias!

Answer 1

Eche un vistazo a esta biblioteca .NET http://projnet.codeplex.com/. Esto debería ayudar en su caso

Answer 2

Si quieres rodar sus propias funciones, se puede encontrar una gran cantidad de información útil en esta página:

http://www.colorado.edu/geography/gcraft/notes/coordsys/coordsys.html

Tengo un par de funciones para convertir entre lat -lon y UTM (en ambos sentidos), pero son un poco largos para escribir aquí.

Answer 3

Hay código C++ disponible en este sitio: http://www.gpsy.com/gpsinfo/geotoutm/

Ir abajo de la página un poco para el "Código Fuente" la partida, y buscar estos archivos en la parte inferior:

Chuck Gantz

Adjuntos: LatLong-UTMconversion.cpp (Ver en línea como archivo de texto) LatLong-UTMconversion.h (vista en línea como archivo de texto) UTMConversions.cpp (vista en línea como archivo de texto) SwissGrid.cpp (vista en línea como te archivo xt) constantes.h (ver en línea como archivo de texto)

p. los primeros enlaces de archivos a: www.gpsy.com/gpsinfo/geotoutm/gantz/LatLong-UTMconversion.cpp etc

Hay funciones aquí para ir en ambos sentidos: UTM a Lat Long, y viceversa. Si mira a otro lado, hay versiones de este código en python. p. en code.google.com/p/pys60gps/source/browse/trunk/lib/LatLongUTMconversion.py?r=246

También hay versiones de C# de parte de ella: en mediakey.dk/~cc/ convert-northing-and-easting-utm-to-longitude-and-latitude/

Buena suerte.

Answer 4

aquí es:

public static void ToLatLon(double utmX, double utmY, string utmZone, out double latitude, out double longitude) 
    { 
     bool isNorthHemisphere = utmZone.Last() >= 'N'; 

     var diflat = -0.00066286966871111111111111111111111111; 
     var diflon = -0.0003868060578; 

     var zone = int.Parse(utmZone.Remove(utmZone.Length - 1)); 
     var c_sa = 6378137.000000; 
     var c_sb = 6356752.314245; 
     var e2 = Math.Pow((Math.Pow(c_sa,2) - Math.Pow(c_sb,2)),0.5)/c_sb; 
     var e2cuadrada = Math.Pow(e2,2); 
     var c = Math.Pow(c_sa,2)/c_sb; 
     var x = utmX - 500000; 
     var y = isNorthHemisphere ? utmY : utmY - 10000000; 

     var s = ((zone * 6.0) - 183.0); 
     var lat = y/(c_sa * 0.9996); 
     var v = (c/Math.Pow(1 + (e2cuadrada * Math.Pow(Math.Cos(lat), 2)), 0.5)) * 0.9996; 
     var a = x/v; 
     var a1 = Math.Sin(2 * lat); 
     var a2 = a1 * Math.Pow((Math.Cos(lat)), 2); 
     var j2 = lat + (a1/2.0); 
     var j4 = ((3 * j2) + a2)/4.0; 
     var j6 = ((5 * j4) + Math.Pow(a2 * (Math.Cos(lat)), 2))/3.0; 
     var alfa = (3.0/4.0) * e2cuadrada; 
     var beta = (5.0/3.0) * Math.Pow(alfa, 2); 
     var gama = (35.0/27.0) * Math.Pow(alfa, 3); 
     var bm = 0.9996 * c * (lat - alfa * j2 + beta * j4 - gama * j6); 
     var b = (y - bm)/v; 
     var epsi = ((e2cuadrada * Math.Pow(a, 2))/2.0) * Math.Pow((Math.Cos(lat)), 2); 
     var eps = a * (1 - (epsi/3.0)); 
     var nab = (b * (1 - epsi)) + lat; 
     var senoheps = (Math.Exp(eps) - Math.Exp(-eps))/2.0; 
     var delt = Math.Atan(senoheps/(Math.Cos(nab))); 
     var tao = Math.Atan(Math.Cos(delt) * Math.Tan(nab)); 

     longitude = ((delt * (180.0/Math.PI)) + s) + diflon; 
     latitude = ((lat + (1 + e2cuadrada * Math.Pow(Math.Cos(lat), 2) - (3.0/2.0) * e2cuadrada * Math.Sin(lat) * Math.Cos(lat) * (tao - lat)) * (tao - lat)) * (180.0/Math.PI)) + diflat; 
    } 

Answer 5

public static void ToLatLon(double utmX, double utmY, string utmZone) 
    { 
     double latitude = 0; 
     double longitude = 0; 

     bool isNorthHemisphere = utmZone.Last() >= 'N'; 

     var diflat = -0.00066286966871111111111111111111111111; 
     var diflon = -0.0003868060578; 

     var zone = int.Parse(utmZone.Remove(utmZone.Length - 1)); 
     var c_sa = 6378137.000000; 
     var c_sb = 6356752.314245; 
     var e2 = Math.Pow((Math.Pow(c_sa, 2) - Math.Pow(c_sb, 2)), 0.5)/c_sb; 
     var e2cuadrada = Math.Pow(e2, 2); 
     var c = Math.Pow(c_sa, 2)/c_sb; 
     var x = utmX - 500000; 
     var y = isNorthHemisphere ? utmY : utmY - 10000000; 

     var s = ((zone * 6.0) - 183.0); 
     var lat = y/(6366197.724 * 0.9996); // Change c_sa for 6366197.724 
     var v = (c/Math.Pow(1 + (e2cuadrada * Math.Pow(Math.Cos(lat), 2)), 0.5)) * 0.9996; 
     var a = x/v; 
     var a1 = Math.Sin(2 * lat); 
     var a2 = a1 * Math.Pow((Math.Cos(lat)), 2); 
     var j2 = lat + (a1/2.0); 
     var j4 = ((3 * j2) + a2)/4.0; 
     var j6 = (5 * j4 + a2 * Math.Pow((Math.Cos(lat)), 2))/3.0; // saque a2 de multiplicar por el coseno de lat y elevar al cuadrado 
     var alfa = (3.0/4.0) * e2cuadrada; 
     var beta = (5.0/3.0) * Math.Pow(alfa, 2); 
     var gama = (35.0/27.0) * Math.Pow(alfa, 3); 
     var bm = 0.9996 * c * (lat - alfa * j2 + beta * j4 - gama * j6); 
     var b = (y - bm)/v; 
     var epsi = ((e2cuadrada * Math.Pow(a, 2))/2.0) * Math.Pow((Math.Cos(lat)), 2); 
     var eps = a * (1 - (epsi/3.0)); 
     var nab = (b * (1 - epsi)) + lat; 
     var senoheps = (Math.Exp(eps) - Math.Exp(-eps))/2.0; 
     var delt = Math.Atan(senoheps/(Math.Cos(nab))); 
     var tao = Math.Atan(Math.Cos(delt) * Math.Tan(nab)); 

     longitude = (delt/Math.PI) * 180 + s; 
     latitude = (((lat + (1 + e2cuadrada * Math.Pow(Math.Cos(lat), 2) - (3.0/2.0) * e2cuadrada * Math.Sin(lat) * Math.Cos(lat) * (tao - lat)) * (tao - lat)))/Math.PI) * 180; // era incorrecto el calculo 

     Console.WriteLine("Latitud: " + latitude.ToString() + "\nLongitud: " + longitude.ToString()); 

    } 

Este es el nuevo código

Answer 6

Usar este código:

 public static void UTMToLatLon(double Easting, double Northing, double Zone, double Hemi, out double latitude, out double longitude) 
    { 
     double DtoR = Math.PI/180, RtoD = 180/Math.PI; 
     double a = 6378137, f = 0.00335281066474748071984552861852, northernN0 = 0, southernN0 = 10000000, E0 = 500000, 
      n = f/(2 - f), k0 = 0.9996, 
      A = a * (1 + (1/4) * Math.Pow(n, 2) + (1/64) * Math.Pow(n, 4) + (1/256) * Math.Pow(n, 6) + (25/16384) * Math.Pow(n, 8) + (49/65536) * Math.Pow(n, 10))/(1 + n),    
      beta1 = n/2 - (2/3) * Math.Pow(n, 2) + (37/96) * Math.Pow(n, 3) - (1/360) * Math.Pow(n, 4) - (81/512) * Math.Pow(n, 5) + (96199/604800) * Math.Pow(n, 6) - (5406467/38707200) * Math.Pow(n, 7) + (7944359/67737600) * Math.Pow(n, 8) - (7378753979/97542144000) * Math.Pow(n, 9) + (25123531261/804722688000) * Math.Pow(n, 10), 
      beta2 = (1/48) * Math.Pow(n, 2) + (1/15) * Math.Pow(n, 3) - (437/1440) * Math.Pow(n, 4) + (46/105) * Math.Pow(n, 5) - (1118711/3870720) * Math.Pow(n, 6) + (51841/1209600) * Math.Pow(n, 7) + (24749483/348364800) * Math.Pow(n, 8) - (115295683/1397088000) * Math.Pow(n, 9) + (5487737251099/51502252032000) * Math.Pow(n, 10), 
      beta3 = (17/480) * Math.Pow(n, 3) - (37/840) * Math.Pow(n, 4) - (209/4480) * Math.Pow(n, 5) + (5569/90720) * Math.Pow(n, 6) + (9261899/58060800) * Math.Pow(n, 7) - (6457463/17740800) * Math.Pow(n, 8) + (2473691167/9289728000) * Math.Pow(n, 9) - (852549456029/20922789888000) * Math.Pow(n, 10), 
      beta4 = (4397/161280) * Math.Pow(n, 4) - (11/504) * Math.Pow(n, 5) - (830251/7257600) * Math.Pow(n, 6) + (466511/2494800) * Math.Pow(n, 7) + (324154477/7664025600) * Math.Pow(n, 8) - (937932223/3891888000) * Math.Pow(n, 9) - (89112264211/5230697472000) * Math.Pow(n, 10), 
      beta5 = (4583/161280) * Math.Pow(n, 5) - (108847/3991680) * Math.Pow(n, 6) - (8005831/63866880) * Math.Pow(n, 7) + (22894433/124540416) * Math.Pow(n, 8) + (112731569449/557941063680) * Math.Pow(n, 9) - (5391039814733/10461394944000) * Math.Pow(n, 10), 
      beta6 = (20648693/638668800) * Math.Pow(n, 6) - (16363163/518918400) * Math.Pow(n, 7) - (2204645983/12915302400) * Math.Pow(n, 8) + (4543317553/18162144000) * Math.Pow(n, 9) + (54894890298749/167382319104000) * Math.Pow(n, 10), 
      beta7 = (219941297/5535129600) * Math.Pow(n, 7) - (497323811/12454041600) * Math.Pow(n, 8) - (79431132943/7776000) * Math.Pow(n, 9) + (4346429528407/12703122432000) * Math.Pow(n, 10), 
      beta8 = (191773887257/3719607091200) * Math.Pow(n, 8) - (17822319343/336825216000) * Math.Pow(n, 9) - (497155444501631/1422749712384000) * Math.Pow(n, 10), 
      beta9 = (11025641854267/158083301376000) * Math.Pow(n, 9) - (492293158444691/6758061133824000) * Math.Pow(n, 10), 
      beta10 = (7028504530429621/72085985427456000) * Math.Pow(n, 10), 
      delta1 = 2 * n - (2/3) * Math.Pow(n, 2) - 2 * Math.Pow(n, 3), 
      delta2 = (7/3) * Math.Pow(n, 2) - (8/5) * Math.Pow(n, 3), 
      delta3 = (56/15) * Math.Pow(n, 3), 
      ksi = (Northing/100 - northernN0)/(k0 * A), eta = (Easting/100 - E0)/(k0 * A), 
      ksi_prime = ksi - (beta1 * Math.Sin(2 * ksi) * Math.Cosh(2 * eta) + beta2 * Math.Sin(4 * ksi) * Math.Cosh(4 * eta) + beta3 * Math.Sin(6 * ksi) * Math.Cosh(6 * eta) + beta4 * Math.Sin(8 * ksi) * Math.Cosh(8 * eta) + beta5 * Math.Sin(10 * ksi) * Math.Cosh(10 * eta) + 
         beta6 * Math.Sin(12 * ksi) * Math.Cosh(12 * eta) + beta7 * Math.Sin(14 * ksi) * Math.Cosh(14 * eta) + beta8 * Math.Sin(16 * ksi) * Math.Cosh(16 * eta) + beta9 * Math.Sin(18 * ksi) * Math.Cosh(18 * eta) + beta10 * Math.Sin(20 * ksi) * Math.Cosh(20 * eta)), 
      eta_prime = eta - (beta1 * Math.Cos(2 * ksi) * Math.Sinh(2 * eta) + beta2 * Math.Cos(4 * ksi) * Math.Sinh(4 * eta) + beta3 * Math.Cos(6 * ksi) * Math.Sinh(6 * eta)), 
      sigma_prime = 1 - (2 * beta1 * Math.Cos(2 * ksi) * Math.Cosh(2 * eta) + 2 * beta2 * Math.Cos(4 * ksi) * Math.Cosh(4 * eta) + 2 * beta3 * Math.Cos(6 * ksi) * Math.Cosh(6 * eta)), 
      taw_prime = 2 * beta1 * Math.Sin(2 * ksi) * Math.Sinh(2 * eta) + 2 * beta2 * Math.Sin(4 * ksi) * Math.Sinh(4 * eta) + 2 * beta3 * Math.Sin(6 * ksi) * Math.Sinh(6 * eta), 
      ki = Math.Asin(Math.Sin(ksi_prime)/Math.Cosh(eta_prime)); 

     latitude = (ki + delta1 * Math.Sin(2 * ki) + delta2 * Math.Sin(4 * ki) + delta3 * Math.Sin(6 * ki)) * RtoD; 
     double longitude0 = Zone * 6 * DtoR - 183 * DtoR ; 
     longitude = (longitude0 + Math.Atan(Math.Sinh(eta_prime)/Math.Cos(ksi_prime))) * RtoD; 
    } 

Este código es mucho más preciso que otros.

Answer 7

Hice un puerto de una biblioteca javascript para C#, he probado y funciona perfectamente, se puede echar un vistazo a: https://github.com/owaremx/LatLngUTMConverter