def main():
sal = UTM2Geo(putm.PuntoUTM(500000, 4000000), 'WGS 84')
import os
print("Conversor de Coordenadas UTM a Geodesicas.")
opt = None
while opt != 0:
print()
print(
"Seleccione una opción:\n\t1-Convertir un punto.\n\t2-Convertir un fichero.\n\t0-Salir."
)
opt = int(input("Opción: "))
if opt > 2:
print("Opción Invalida")
continue
else:
if opt == 1:
print()
try:
X = float(input("X(UTM): "))
Y = float(input("Y(UTM): "))
Huso = int(input("Huso: "))
Nombre_Elipsoide = str(input("Elipsoide: "))
p = putm.PuntoUTM(X, Y, Huso=Huso)
sal = UTM2Geo(p, Nombre_Elipsoide)
print()
print("Resultados:")
print("Latitud: " + str(sal.getLatitud()))
print("Longitud: " + str(sal.getLongitud()))
print("h Elipsoidal: " + str(sal.getAlturaElipsoidal()))
print("kp: %.5f" % p.getEscalaLocalPunto())
print("conv_med: %.6f" % p.getConvergenciaMeridianos())
except Exception as e:
print(e)
continue
elif opt == 2:
print()
try:
r_ent = input("Ruta fichero Entrada: ")
r_sal = input("Ruta fichero Salida: ")
if r_ent == r_sal:
print()
print(
"Error: El archivo de entrada no puede conincidir con el de salida."
)
continue
Nombre_Elipsoide = input("Elipsoide: ")
sal = UTM2GeoFromFile(r_ent, Nombre_Elipsoide)
pr = open(r_sal, 'wb', 1024)
for i in sal:
a = bytes(("" + str(i.getLatitud()) + ";" +
str(i.getLongitud()) + "\n").encode(
encoding='UTF-8', errors='strict'))
pr.write(a)
except Exception as e:
print(e)
continue
else:
os.system('pause')
def UTM2GeoFromFile(File, NombreElipsoide):
'''!
@brief: Función que realiza la conversión de geodesicas a UTM desde un fichero.
@param File str: Ruta del fichero con las coordenadas a transformar.
@note: El fichero debe tener el siguiente formato como mínimo: id,X,Y,Hemisferio,Huso
'''
import os
from PyQt4 import QtGui
if not type(File) == str:
raise Exception(
"El formato del fichero introducido no es de tipo str.")
if not os.path.exists(File):
raise Exception("El fichero introducido no existe.")
if not os.path.isfile(File):
raise Exception(
"El fichero introducido no se corresponde con un archivo.")
#ID,X,Y,Huso,helip.....
IDs = []
Xs = []
Ys = []
posY = []
Huso = []
helip = []
f = open(File, 'r')
for i in f:
QtGui.QApplication.processEvents()
i = i.split(",")
IDs.append(i[0])
Xs.append(i[1])
Ys.append(i[2])
posY.append(i[3])
Huso.append(i[4])
try:
h = i[4]
helip.append(h)
except:
helip.append(None)
f.close()
Sal = []
for ids, x, y, py, H, hel in zip(IDs, Xs, Ys, posY, Huso, helip):
QtGui.QApplication.processEvents()
p = putm.PuntoUTM(x, y, huso=H, helip=hel, hemisferioY=py)
p1 = UTM2Geo(p, NombreElipsoide)
Sal.append([ids, p, p1])
# IDs=[i.split(",")[0] for i in f]
# f.seek(0)
# Xs=[i.split(",")[1] for i in f]
# f.seek(0)
# Ys=[i.split(",")[2] for i in f]
# f.close()
# Elips=[NombreElipsoide]*len(Xs)
# QtGui.QApplication.processEvents()
# Puntos=[putm.PuntoUTM(i,j) for i,j in zip(Xs,Ys)]
# sal=map(UTM2Geo,Puntos,Elips,QtGui.QApplication.processEvents())
return Sal
def UTM2GeoFromFile(File, NombreElipsoide):
import os
'''
Función que realiza la conversión de geodesicas a UTM desde un fichero.
@param File:
@type File: str.
'''
if not type(File) == str:
raise Exception("Not str")
if not os.path.exists(File):
raise Exception("Not Exists")
if not os.path.isfile(File):
raise Exception("Not File")
#ID,Lat,Lon,helip.....
f = open(File, 'r')
Xs = [i.split(",")[1] for i in f]
f.seek(0)
Ys = [i.split(",")[2] for i in f]
f.close()
Elips = [NombreElipsoide] * len(Xs)
Puntos = [putm.PuntoUTM(i, j) for i, j in zip(Xs, Ys)]
sal = map(UTM2Geo, Puntos, Elips)
return sal
def Geo2UTM(PuntoGeodesico, NombreElipsoide, Huso=None, w=True, kp=True):
'''!
@brief: Método que convierte coordenadas Geodésicas elipsoidales a coordenadas UTM.
@param PuntoGeodesico PuntoGeodesico: Punto Geodesico con las coordenadas del punto.
@param NombreElipsoide str: Nombre del elipsoide de calculo.
@param Huso int: Valor del Huso en el caso de que se quieran forzar las coordenadas a ese Huso.
@return PuntoUTM: Punto con las coordenadas UTM transformadas.
'''
if not isinstance(PuntoGeodesico, pgeo.PuntoGeodesico):
raise Exception("Valor Punto Geodesico")
try:
NombreElipsoide = str(NombreElipsoide)
except:
raise Exception("Valor Nombre Elipsoide")
#Conversion a radian.
Latitud = ang.Angulo(PuntoGeodesico.getLatitud(), formato='latitud')
Latitud.Convertir('radian')
Lat = Latitud.getAngulo()
Longitud = ang.Angulo(PuntoGeodesico.getLongitud(), formato='longitud180')
Longitud.Convertir('radian')
Lon = Longitud.getAngulo()
AlturaElipsoidal = PuntoGeodesico.getAlturaElipsoidal()
#Calculo de parámetros del elipsoide.
Elipsoide = Elip.Elipsoides(NombreElipsoide)
nhu = Rad.RadiosDeCurvatura(NombreElipsoide).getRadioPrimerVertical(Lat)
e = Elipsoide.getPrimeraExcentricidad()
e2 = Elipsoide.getSegundaExcentricidad()
#Valores Auxiliares
t = tan(Lat)
t2 = (t**2)
t4 = (t**4)
t6 = (t**6)
t8 = (t**8)
n2 = ((e2**2)) * ((cos(Lat)**2))
n4 = (n2**2)
n6 = (n2**3)
n8 = (n2**4)
n10 = (n2**5)
n12 = (n2**6)
n14 = (n2**7)
#Claculo de las series de terminos.
#x cubo.
x3 = (1.0 - t2 + n2)
#x quinta.
x5 = (5.0 - 18.0 * t2 + t4 + 14.0 * n2 - 58.0 * n2 * t2 + 13.0 * n4 -
64.0 * n4 * t2 + 4.0 * n6 - 24.0 * n6 * t2)
#x septima.
x7 = (61.0 - 479.0 * t2 + 179.0 * t4 - t6 + 331.0 * n2 - 3298.0 * n2 * t2 +
177.0 * n2 * t4 + 715.0 * n4 - 8655.0 * n4 * t2 + 6080.0 * n4 * t4 +
769.0 * n6 - 10964.0 * n6 * t2 + 9480.0 * n6 * t4 + 412.0 * n8 -
5176.0 * n8 * t2 + 6912.0 * n8 * t4 + 88.0 * n10 -
1632.0 * n10 * t2 + 1920.0 * n10 * t4)
#x novena.
x9 = (1385.0 - 20480.0 * t2 + 20690.0 * t4 - 1636.0 * t6 + t8 +
12284.0 * n2 - 173088.0 * n2 * t2 + 201468.0 * n2 * t4 -
54979.0 * n2 * t6 - 21.0 * n2 * t8 + 45318.0 * n4 -
883449.0 * n4 * t2 + 14499197.0 * n4 * t4 - 390607.0 * n4 * t6 -
14.0 * n4 * t8 + 90804.0 * n6 - 2195193.0 * n6 * t2 +
549800.0 * n6 * t4 - 1394064.0 * n6 * t6 + 104073.0 * n8 -
2875680.0 * n8 * t2 + 7041648.0 * n8 * t4 - 2644992.0 * n8 * t6 +
68568.0 * n10 - 2115840.0 * n10 * t2 + 5968512.0 * n10 * t4 -
2741760.0 * n10 * t6 + 25552.0 * n12 - 880192.0 * n12 * t2 +
2811456.0 * n12 * t4 - 1474560.0 * n12 * t6 + 4672.0 * n14 -
175680.0 * n14 * t2 + 603648.0 * n14 * t4 - 322560.0 * n14 * t6)
#y cuarta.
y4 = (5.0 - t2 + 9.0 * n2 + 4.0 * n4)
#y sexta.
y6 = (61.0 - 58.0 * t2 + t4 + 270.0 * n2 - 330.0 * n2 * t2 + 445.0 * n4 -
680.0 * n4 * t2 + 324.0 * n6 - 600.0 * n6 * t2 + 88.0 * n8 -
192.0 * n8 * t2)
#y octava.
y8 = (1385.0 - 3595.0 * t2 + 543.0 * t4 - t6 + 10899.0 * n2 -
18634.0 * n2 * t2 + 10787.0 * n2 * t4 + 7.0 * n2 * t6 +
34419.0 * n4 - 120582.0 * n4 * t2 + 49644.0 * n4 * t4 +
56385.0 * n6 - 252084.0 * n6 * t2 + 121800.0 * n6 * t4 +
47688.0 * n8 - 242496.0 * n8 * t2 + 151872.0 * n8 * t4 +
20880.0 * n10 - 121920.0 * n10 * t2 + 94080.0 * n10 * t4 +
4672.0 * n12 - 30528.0 * n12 * t2 + 23040.0 * n12 * t4)
#Calculo de lam.
s1 = sin(Lat)
s3 = (s1**3)
s5 = (s1**5)
s7 = (s1**7)
s9 = (s1**9)
c1 = cos(Lat)
g1 = Lat
g2 = 1.5 * (e**2) * ((-0.5 * s1 * c1) + 0.5 * Lat)
g3 = (15.0 / 8.0) * (e**4) * ((-0.25 * s3 * c1) - ((3.0 / 8.0) * s1 * c1) +
((3.0 / 8.0) * Lat))
g4 = (35.0 / 16.0) * (e**6) * ((-(1.0 / 6.0) * s5 * c1) -
((5.0 / 24.0) * s3 * c1) -
((5.0 / 16.0) * s1 * c1) +
((5.0 / 16.0) * Lat))
g5 = (315 / 128) * (e**8) * ((-(1 / 8) * s7 * c1) - ((7 / 48) * s5 * c1) -
((35 / 192) * s3 * c1) -
((35 / 128) * s1 * c1) + ((35 / 128) * Lat))
g6 = (693 / 256) * (e**10) * ((-(1 / 10) * s9 * c1) -
((9 / 80) * s7 * c1) -
((21 / 160) * s5 * c1) -
((21 / 128) * s3 * c1) -
((63 / 256) * s1 * c1) + ((63 / 256) * Lat))
lam = Elipsoide.getSemiEjeMayor() * (1 - (e**2)) * (g1 + g2 + g3 + g4 +
g5 + g6)
#Calculo del Huso.
if Huso == None:
Huso = floor(((180.0 + Lon * (180 / pi)) / 6) + 1)
lon0 = ang.Angulo((Huso * 6) - 183, formato='pseudosexagesimal')
lon0.Convertir('radian')
lon0 = lon0.getAngulo()
#print(lon0)
else:
Huso = int(Huso)
#Meridiano central.
lon0 = ang.Angulo((Huso * 6) - 183, formato='pseudosexagesimal')
lon0.Convertir('radian')
lon0 = lon0.getAngulo()
lon0d = lon0 + 0.05817764173314432 #3º20'
lon0i = lon0 - 0.05817764173314432
#print(lon0d,lon0i,Lon)
if Lon < lon0i or Lon > lon0d:
raise Exception(
"Solo se pueden forzar las coordenadas a los Husos adyacentes un máximo de 20', si estas se en cuentran en el extremo del Huso"
)
#Incremento de longitud.
Alon = Lon - lon0
#Calculo de X.
c3 = (c1**3)
c5 = (c1**5)
c7 = (c1**7)
c9 = (c1**9)
X = 500000.0 + (0.9996 *
((Alon * nhu * c1) + (((Alon**3) / 6.0) * nhu * c3 * x3) +
(((Alon**5) / 120.0) * nhu * c5 * x5) +
(((Alon**7) / 5040.0) * nhu * c7 * x7) +
(((Alon**9) / 362880.0) * nhu * c9 * x9)))
#Calculo de Y.
c2 = (cos(Lat)**2)
c4 = (cos(Lat)**4)
c6 = (cos(Lat)**6)
c8 = (cos(Lat)**8)
Y = 0.9996 * (lam + (((Alon**2) / 2.0) * nhu * t * c2) +
(((Alon**4) / 24.0) * nhu * t * c4 * y4) +
(((Alon**6) / 720.0) * nhu * t * c6 * y6) +
(((Alon**8) / 40320.0) * nhu * t * c8 * y8))
# Si la latiud está en el Hemisferio Sur:
if Latitud.getAngulo() < 0:
Y = 10000000.0 - Y
#Cálculo de la convergencia de meridianos.
#coeficientes.
if w:
m3 = (1.0 + 3.0 * n2 + 2 * n4)
m5 = (2.0 - t2 + 15.0 * n2 * t2 + 35.0 * n4 - 50.0 * n4 * t2 +
33.0 * n6 - 60.0 * n6 * t2 + 11.0 * n8 - 24.0 * n8 * t2)
m7 = (-148.0 - 3427.0 * t2 + 18.0 * t4 - 1387.0 * t6 + 2023.0 * n2 -
46116.0 * n2 * t2 + 5166.0 * n2 * t4 + 18984.0 * n4 -
100212.0 * n4 * t4 + 34783 * n6 - 219968.0 * n6 * t2 +
144900.0 * n6 * t4 + 36180.0 * n8 - 261508.0 * n8 * t2 +
155904.0 * n8 * t4 + 18472.0 * n10 - 114528.0 * n10 * t2 +
94080.0 * n10 * t4 + 4672.0 * n12 - 30528.0 * n12 * t2 +
23040.0 * n12 * t4)
convmed = (Alon * s1) + (((Alon**3) / 3.0) * s1 * c2 * m3) + ((
(Alon**5) / 15.0) * s1 * c4 * m5) + ((
(Alon**7) / 5040.0) * s1 * c6 * m7)
convmed = ang.Angulo(convmed, formato='radian')
convmed.Convertir('pseudosexagesimal')
convmed = convmed.getAngulo()
else:
convmed = None
#Calculo de la escala local del punto.
#coeficientes.
if kp:
k2 = (1 + n2)
k4 = (5.0 - 4.0 * t2 + 14.0 * n2 - 28.0 * n2 * t2 + 13.0 * n4 -
48.0 * n4 * t2 + 4.0 * n6 - 24.0 * n6 * t2)
k6 = (61.0 + 10636.0 * t2 - 9136.0 * t4 + 224.0 * t6 + 331.0 * n2 +
44432.0 * n2 * t2 - 50058.0 * n2 * t4 - 715.0 * n4 +
68100.0 * n4 * t2 - 95680.0 * n4 * t4 + 769.0 * n6 +
43816.0 * n6 * t2 - 80160.0 * n6 * t4 + 412.0 * n8 +
9644.0 * n8 * t2 - 21888.0 * n8 * t4 + 88.0 * n10 -
1632.0 * n10 * t2 + 1920.0 * n10 * t4)
kp = (0.9996) * (1 + (0.5 * (Alon**2) * c2 * k2) +
(((Alon**4) / 24.0) * c4 * k4) +
(((Alon**6) / 720.0) * c6 * k6))
else:
kpsal = None
posY = None
if Latitud.getAngulo() > 0:
posY = "N"
else:
posY = "S"
sal = putm.PuntoUTM(X,
Y,
hemisferioY=str(posY),
helip=AlturaElipsoidal,
huso=int(Huso))
sal.setConvergenciaMeridianos(convmed)
sal.setEscalaLocalPunto(kpsal)
return sal