def ConvertirFichero(self):
'''!
'''
with open(self.lineEdit_3.text(), 'r') as f:
for i in f:
QtGui.QApplication.processEvents()
lin = i.split(",")
if len(lin) == 2:
#Radian a ...
ang1 = ang.Angulo(lin[0])
ang1.Convertir(lin[1])
continue
if len(lin) == 3:
# De f1 a f2
ang1 = ang.Angulo(lin[0], formato=lin[1])
ang1.Convertir(lin[2])
continue
if len(lin) == 4:
#Sexagesimal a...
ang1 = ang.Angulo(lin[0], lin[1], lin[2])
ang1.Convertir(lin[3])
continue
if len(lin) == 5:
#Sexagesimal a ...
ang1 = ang.Angulo(lin[0], lin[1], lin[2])
if lin[3] != 'sexagesimal':
self.__msgBoxErr.setText(
"El único formato admisible de cambio es sexagesimal."
)
self.__msgBoxErr.exec_()
return
else:
ang1.Convertir(lin[4])
f.close()
def setAzimut(self, Azimut):
'''!
@brief: Método que asigna y comprueba el azimut introducido.
@param Distancia float|int|str|Angulo: Distancia de cálculo.
'''
if isinstance(Azimut, float) or isinstance(Azimut, int) or isinstance(
Azimut, str):
try:
float(Azimut)
ang.Angulo(Azimut, formato='centesimal')
except Exception as e:
raise Exception(e)
finally:
a1 = ang.Angulo(Azimut, formato='centesimal')
a1.Convertir('radian')
self.__az = float(a1.getAngulo())
elif isinstance(Azimut, ang.Angulo):
if Azimut.getFormato() == 'centesimal':
Azimut.Convertir('radian')
self.__az = Azimut.getAngulo()
else:
raise Exception(
"Se esperaba un ángulo de entrada de tipo centesimal.")
else:
raise Exception("Valor de azimut no válido.")
def main():
rad = Radiacion3D(pt3.Punto3D(10, 20, 10),
40,
ang.Angulo(100, formato='centesimal'),
ang.Angulo(98, formato='centesimal'),
i=0,
m=0)
sal = rad.Radiacion3D()
print(sal.getX(), sal.getY(), sal.getZ())
def main():
r = RadiosDeCurvatura("WGS 84")
print(r.getRadioPrimerVertical(0.785398163),
r.getRadioElipseMeridiana(0.785398163))
p = pgeo.PuntoGeodesico(ang.Angulo(45, formato="latitud"),
ang.Angulo(45, formato="longitud180"))
print(r.getRadioPrimerVertical(p), r.getRadioElipseMeridiana(p))
p = pgeo.PuntoGeodesico(ang.Angulo(0, formato="latitud"),
ang.Angulo(45, formato="longitud180"))
print(r.getRadioPrimerVertical(p), r.getRadioElipseMeridiana(p))
def Calcular(self):
'''!
'''
if self.lineEdit.text() == "":
self.__msgBoxErr.setText(
"Debe introducir un valor para la latitud origen.")
self.__msgBoxErr.exec_()
return
if self.lineEdit_2.text() == "":
self.__msgBoxErr.setText(
"Debe introducir un valor para la la longitud origen.")
self.__msgBoxErr.exec_()
return
if self.lineEdit_3.text() == "":
self.__msgBoxErr.setText(
"Debe introducir un valor para la distancia de calculo.")
self.__msgBoxErr.exec_()
return
if self.lineEdit_4.text() == "":
self.__msgBoxErr.setText(
"Debe introducir un valor para el azimut.")
self.__msgBoxErr.exec_()
return
pasos = None
if self.checkBox.checkState() == 2:
try:
int(self.lineEdit_7.text())
except:
self.__msgBoxErr.setText(
"El número de pasos debe ser un valor entero.")
self.__msgBoxErr.exec_()
return
finally:
pasos = int(self.lineEdit_7.text())
try:
sal = pdg.PDGeodesia(
pgeo.PuntoGeodesico(self.lineEdit.text(),
self.lineEdit_2.text()),
self.lineEdit_3.text(), self.lineEdit_4.text())
lat, lon, az = sal.Rk4o(self.comboBox.currentText(), pasos)
except Exception as e:
self.__msgBoxErr.setText(e.__str__())
self.__msgBoxErr.exec_()
#ang.Angulo(lat).Convertir('pseudosexagesimal').getAngulo()
a1 = ang.Angulo(lat, girar=True)
a1.Convertir('pseudosexagesimal')
self.lineEdit_6.setText(str(a1.getAngulo()))
a1 = ang.Angulo(lon, girar=True)
a1.Convertir('pseudosexagesimal')
self.lineEdit_5.setText(str(a1.getAngulo()))
a1 = ang.Angulo(az, girar=True)
a1.Convertir('pseudosexagesimal')
self.lineEdit_8.setText(str(a1.getAngulo()))
def setPuntoGeodesico(self,PuntoGeodesico):
'''!
@brief: Método que establece y asigna el Punto geodesico.
@param PuntoGeodesico PuntoGeodesico: PuntoGeodesico inicial.
'''
if not isinstance(PuntoGeodesico, pgeo.PuntoGeodesico):
raise Exception("El punto introducido no es una instancia de la clase PuntoGeodesico.")
self.__pgeo=PuntoGeodesico
self.__lat=ang.Angulo(PuntoGeodesico.getLatitud(),formato='pseudosexagesimal')
self.__lon=ang.Angulo(PuntoGeodesico.getLongitud(),formato='pseudosexagesimal')
self.__lat.Convertir('radian')
self.__lon.Convertir('radian')
def Cargeo2Geo(Punto, NombreElipsoide):
'''
@brief: Funcion que transforma de Coordenadas Cartesianas Geocentricas a Geodesicas Elipsoidales.
@param Punto Punto3D: Punto3D con las coordenadas Cartesianas Geocentricas.
@param NombreElipsoide str: Nombre del elipsoide de calculo.
@raise Valor Punto3D: Se produce una excepción en el caso de que el punto introducido no sea de tipo punto3D.
@raise Valor Nombre Elipsoide: Se produce una excepción en el caso que el el Nombre del elipsoide no sea de tipo String.
@return PuntoGeodesico: Punto Geodesico con el resultado.
'''
if not isinstance(Punto, pt3.Punto3D):
raise Exception(
"Se esperaba un objeto de la clase Punto3D como primer valor de entrada del constructor."
)
try:
NombreElipsoide = str(NombreElipsoide)
except:
raise Exception(
"Se esperaba un str como segundo valor entrada de la función.")
x = Punto.getX()
y = Punto.getY()
z = Punto.getZ()
#Calculo de parámetros.
Elipsoide = Elip.Elipsoides(NombreElipsoide)
e = Elipsoide.getPrimeraExcentricidad()
#Calculos auxiliares
r = sqrt((x**2) + (y**2))
latact = atan((z / r) / (1.0 - (e**2)))
latiter = 0.0
helip = 0.0
cont = 0
aux = Rad.RadiosDeCurvatura(NombreElipsoide)
while abs(latact - latiter) > 0.000000000001:
if cont != 0:
latact = latiter
nhu = aux.getRadioPrimerVertical(latact)
helip = (r / cos(latact)) - nhu
latiter = atan((z / r) / (1.0 - ((e**2) * (nhu / (nhu + helip)))))
cont += 1
'''
Casos del arcotangente CUADRANTES
'''
Lat = ang.Angulo(latiter, formato='radian')
Lon = ang.Angulo(atan(y / x), formato='radian')
Lat.Convertir('latitud')
Lon.Convertir('longitud180')
return pgeo.PuntoGeodesico(Lat, Lon, helip)
def main():
'''!
'''
LDirecta = LecturaDirecta(ang.Angulo(301.2365, formato='centesimal'),
ang.Angulo(101.2341, formato='centesimal'))
print(LDirecta.getLecturaDirecta(lectura='azimutal').getAngulo())
print(LDirecta.getErrorLectura(lectura='azimutal', numeroObservaciones=1))
LDirecta = LecturaDirecta(ang.Angulo(301.2365, formato='centesimal'),
ang.Angulo(98.7653, formato='centesimal'))
print(LDirecta.getLecturaDirecta(lectura='cenital').getAngulo())
print(LDirecta.getErrorLectura(lectura='cenital', numeroObservaciones=1))
def main():
PD=PDGeodesia(pgeo.PuntoGeodesico(50,10),1500000,140)
lat,lon,az=PD.Rk4o('Hayford 1950')
#lat,lon,az=PD.Rk4o('WGS 84')
#lat,lon,az=PD.CalcularLegendre('WGS 84')
lat=ang.Angulo(lat)
lat.Convertir('sexagesimal')
print(lat.getAngulo())
lon=ang.Angulo(lon)
lon.Convertir('sexagesimal')
print(lon.getAngulo())
az=ang.Angulo(az)
az.Convertir('sexagesimal')
print(az.getAngulo())
pass
def getLecturaDirecta(self, lectura='azimutal'):
'''!
\param angulo str: ángulo sobre el que se quiere calcular la lectura directa. azimutal o cenital.
'''
try:
lectura = str(lectura)
lectura = lectura.lower()
except Exception as e:
raise Exception(e)
if lectura not in ['azimutal', 'cenital']:
raise Exception(
"El tipo de lectura debe ser azimutal o centesimal")
if self.__LCD == None:
raise Exception("El circulo directo debe contener algun valor.")
if self.__LCI == None:
raise Exception("El circulo inverso debe contener algun valor.")
cd = self.__LCD.getAngulo()
ci = self.__LCI.getAngulo()
angulo = None
if lectura == 'azimutal':
if cd > ci:
angulo = (cd + ci + 200) / 2
elif ci > cd:
angulo = (cd + (ci - 200)) / 2
if lectura == 'cenital':
angulo = (cd + (400 - ci)) / 2
sal = ang.Angulo(angulo, formato='centesimal')
return sal
def Geo2Cargeo(PuntoGeodesico, NombreElipsoide):
'''
@brief: Funcion que transforma de Coordenadas geodesicas a coordenadas Cartesianaes Geocentricas.
@param PuntoGeodesico PuntoGeodesico: Punto Geodesico con las coordenadas del punto.
@param NombreElipsoide str: Nombre del elipsoide de calculo.
@raise Valor Punto Geodesico: Se produce una excepción en el caso de que el punto introducido
no sea de tipo puntoGeodesico.
@raise Valor Nombre Elipsoide: Se produce una excepción en el caso que el el Nombre del elipsoide
no sea de tipo String.
@return Punto3D: Valor del punto calculado.
'''
if not isinstance(PuntoGeodesico, pgeo.PuntoGeodesico):
raise Exception("Valor Punto Geodesico")
try:
NombreElipsoide = str(NombreElipsoide)
except:
raise Exception("Valor Nombre Elipsoide")
Latitud = ang.Angulo(PuntoGeodesico.getLatitud(), formato='latitud')
Longitud = ang.Angulo(PuntoGeodesico.getLongitud(), formato='longitud180')
AlturaElipsoidal = PuntoGeodesico.getAlturaElipsoidal()
#Conversion a radian.
Latitud.Convertir('radian')
Longitud.Convertir('radian')
#Calculo de parámetros.
Elipsoide = Elip.Elipsoides(NombreElipsoide)
e = Elipsoide.getPrimeraExcentricidad()
nhu = Rad.RadiosDeCurvatura(NombreElipsoide).getRadioPrimerVertical(
Latitud.getAngulo())
#Cálculo de Coordenadas.
X = (nhu + AlturaElipsoidal) * (cos(Latitud.getAngulo())) * (cos(
Longitud.getAngulo()))
Y = (nhu + AlturaElipsoidal) * (cos(Latitud.getAngulo())) * (sin(
Longitud.getAngulo()))
Z = (nhu * (1.0 - (e**2)) + AlturaElipsoidal) * (sin(Latitud.getAngulo()))
return pt3.Punto3D(X, Y, Z, negativos=True)
def setAzimut(self,Azimut):
'''!
@brief: Método que establece y asigna el azimut:
@param Azimut float|int|str: Azimut de la línea entre el punto inicila y final en grados pseudoxesagesimales.
'''
if isinstance(Azimut, float) or isinstance(Azimut, int) or isinstance(Azimut, str):
self.__az=ang.Angulo(float(Azimut),formato='pseudosexagesimal')
self.__az.Convertir('radian')
elif isinstance(Azimut, ang.Angulo):
self.__az=Azimut
self.__az.Convertir('radian')
else:
raise Exception("")
def Convertir(self):
'''
'''
try:
c1 = self.comboBox.currentText()
a1 = self.lineEdit.text()
if c1 != 'sexagesimal' and "º" in a1:
self.__msgBoxErr.setText(
"El valor del ángulo introducido sólo es admito para la conversión sexagesimal."
)
self.__msgBoxErr.exec_()
return
c2 = self.comboBox_2.currentText()
if c1 == 'sexagesimal':
g = a1[0:2]
m = a1[3:5]
s = a1[6:]
#print(g,m,s)
ang1 = ang.Angulo(g, m, s)
ang1.Convertir(c2)
self.lineEdit_2.setText(str(ang1.getAngulo()))
else:
ang1 = ang.Angulo(a1, formato=c1)
ang1.Convertir(c2)
if c2 == 'sexagesimal':
g = str(int(ang1.getAngulo()[0]))
m = str(int(ang1.getAngulo()[1]))
s = str(ang1.getAngulo()[2])
self.lineEdit_2.setText(g + "º" + m + "'" + s)
else:
self.lineEdit_2.setText(str(ang1.getAngulo()))
pass
except Exception as e:
self.__msgBoxErr.setText(e.__str__())
self.__msgBoxErr.exec_()
return
def RAC(puntoUTM1,puntoUTM2,NombreElipsoide):
'''!
'''
radcur=rcur.RadiosDeCurvatura(NombreElipsoide)
elip=elipsoides.Elipsoides(NombreElipsoide)
#punto1
angaux=ang.Angulo()
geo1=utm2geo.UTM2Geo(puntoUTM1, NombreElipsoide)
angaux.setAngulo(geo1.getLatitud())
angaux.setFormato('pseudosexagesimal')
angaux.Convertir('raidian')
nhu1=radcur.getRadioPrimerVertical(angaux.getAngulo())
ro1=radcur.getRadioElipseMeridiana(angaux.getAngulo())
x1=(puntoUTM1.getX()-500000)/(0.9996)
y1=puntoUTM1.getY()/0.9996
n21=((elip.getSegundaExcentricidad()**2))*((cos(angaux.getAngulo())**2))
#punto2
angaux=ang.Angulo()
geo2=utm2geo.UTM2Geo(puntoUTM2, NombreElipsoide)
angaux.setAngulo(geo2.getLatitud())
angaux.setFormato('pseudosexagesimal')
angaux.Convertir('raidian')
nhu2=radcur.getRadioPrimerVertical(angaux.getAngulo())
ro2=radcur.getRadioElipseMeridiana(angaux.getAngulo())
x2=(puntoUTM2.getX()-500000)/(0.9996)
y2=puntoUTM2.getY()/0.9996
n22=((elip.getSegundaExcentricidad()**2))*((cos(angaux.getAngulo())**2))
#calculoRAC
nhum=(nhu1+nhu2)/2.0
rom=(ro1+ro2)/2.0
nm=(n21+n22)/2.0
RAC12=((y2-y1)*(2.0*x1+x2)*(1+nm))/(6.0*nhum*rom)
RAC21=((y2-y1)*(2.0*x2+x1)*(1+nm))/(6.0*nhum*rom)
return RAC12,RAC21
def getRadioPrimerVertical(self, Latitud):
'''!
@brief: Método que cálcula el valor del radio del primer vertical del elipsoide.
@param Latitud float|PuntoGeodesico: Latitud del punto de cálculo en Radianes.
@note Latitud: La latitud del punto se puede introducir como un valor float, o como un objeto de la clase PuntoGeodesico.
@return float: Valor del radio del primer vetical en metros (nhu).
'''
lat = None
self.__CheckValor(Latitud)
if isinstance(Latitud, float):
lat = Latitud
elif isinstance(Latitud, pgeo.PuntoGeodesico):
aux = ang.Angulo(Latitud.getLatitud(), formato="latitud")
aux.Convertir('radian')
lat = aux.getAngulo()
Latitud = None
numerador = self.__elip.getSemiEjeMayor()
denominador = sqrt(1 - ((self.__elip.getPrimeraExcentricidad()**2) *
(sin(lat)**2)))
return numerador / denominador
def Calcular(self):
'''!
'''
if self.lineEdit.text()=="":
self.__msgBoxErr.setText("Debe introducir un valor para la latitud origen.")
self.__msgBoxErr.exec_()
return
if self.lineEdit_2.text()=="":
self.__msgBoxErr.setText("Debe introducir un valor para la la longitud origen.")
self.__msgBoxErr.exec_()
return
if self.lineEdit_3.text()=="":
self.__msgBoxErr.setText("Debe introducir un valor para la latitud destino.")
self.__msgBoxErr.exec_()
return
if self.lineEdit_4.text()=="":
self.__msgBoxErr.setText("Debe introducir un valor para la la longitud destino.")
self.__msgBoxErr.exec_()
return
try:
sal=pig.PIGeodesia(pgeo.PuntoGeodesico(self.lineEdit.text(),self.lineEdit_2.text()),pgeo.PuntoGeodesico(self.lineEdit_3.text(),self.lineEdit_4.text()))
az,d=sal.CalcularBessel(self.comboBox.currentText())
except Exception as e:
self.__msgBoxErr.setText(e.__str__())
self.__msgBoxErr.exec_()
a1=ang.Angulo(az,girar=True)
a1.Convertir('pseudosexagesimal')
self.lineEdit_6.setText(str(a1.getAngulo()))
Radio=rcurv.RadiosDeCurvatura(self.comboBox.currentText())
nhu1=Radio.getRadioPrimerVertical(float(self.lineEdit.text()))
ro1=Radio.getRadioElipseMeridiana(float(self.lineEdit.text()))
nhu2=Radio.getRadioPrimerVertical(float(self.lineEdit_3.text()))
ro2=Radio.getRadioElipseMeridiana(float(self.lineEdit_3.text()))
from math import sqrt
Rm=(1/2)*((sqrt(nhu1*ro1))+(sqrt(nhu2*ro2)))
self.lineEdit_5.setText(str(d*Rm))
def getRadioElipseMeridiana(self, Latitud):
'''!
@brief: Método que cálcula el valor del radio de la elipse meridiana.
@param Latitud float|PuntoGeodesico: Latitud del punto de cálculo en Radianes.
@note Latitud: La latitud del punto se puede introducir como un valor float, o como un objeto de la clase PuntoGeodesico.
@return: float: Valor del radio de la elipse meridiana en metros (ro).
'''
lat = None
self.__CheckValor(Latitud)
if isinstance(Latitud, float):
lat = Latitud
elif isinstance(Latitud, pgeo.PuntoGeodesico):
aux = ang.Angulo(Latitud.getLatitud(), formato="latitud")
aux.Convertir('radian')
lat = aux.getAngulo()
Latitud = None
#Se da por supuesto que la latitud ya entra en radianes.
numerador = self.__elip.getSemiEjeMayor() * (
1 - (self.__elip.getPrimeraExcentricidad()**2))
denominador = pow(
1 - ((self.__elip.getPrimeraExcentricidad()**2) * (sin(lat)**2)),
1.5)
return numerador / denominador
def main():
# import os
# print("Conversor de Coordenadas Geodesicas a UTM.")
# 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()
# Lat=float(input("Latitud: "))
# Lon=float(input("Longitud: "))
# Nombre_Elipsoide=input("Elipsoide: ").upper()
# Force=""
# while True:
# Force=input("Forzar Coordenadas a un Huso? (S/N):")
# Force=Force.upper()
# if Force=="S":
# break
# elif Force=="N":
# try:
# p=pgeo.PuntoGeodesico(Lat,Lon)
# sal=Geo2UTM(p,Nombre_Elipsoide)
# print()
# print("Resultados:")
# print("X:\t%.3f"%sal.get_X_UTM())
# print("Y:\t%.3f"%sal.get_Y_UTM())
# print("Z:\t"+str(sal.get_Altura_Elipsoidal()))
# print("Huso:\t"+str(sal.get_Huso()))
# print("W:\t%.8f"%sal.get_Convergencia_Meridianos())
# print("fesca:\t%.9f"%sal.get_Escala_Local_Punto())
# except Exception as e:
# print(e)
# break
# break
# 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: ").upper()
# sal=Geo2UTM_From_File(r_ent,Nombre_Elipsoide)
# pr=open(r_sal,'wb',1024)
# for i in sal:
# a=bytes((""+str(i.get_X_UTM())+";"+str(i.get_Y_UTM())+"\n").encode(encoding='UTF-8',errors='strict'))
# pr.write(a)
# except Exception as e:
# print(e)
# break
# break
#
# else:
# os.system('pause')
# sal=Geo2UTM_From_File('GeodesicasElipsoidales.txt','GRS80')
# input("Y")
# for i in sal:
# print(i.get_X_UTM(),i.get_Y_UTM())
# print("Prueba de la conversión de coordenadas.")
# print("Elipsoide de pruebas:\tGRS80")
# print("Coordenadas geodesicas de prueba:")
# print("\tLatitud:\t45")
# print("\tLongitud:\t-1")
# print("\th elipsoidal:\t50")
# print("\n")
p1 = pgeo.PuntoGeodesico(ang.Angulo(45, formato='latitud'),
ang.Angulo(0.03, formato='longitud180'), 50)
p3 = pgeo.PuntoGeodesico(40, -16)
p2 = Geo2UTM(p3, "GRS 1980")
print("Resultados:")
print("X:\t%.3f" % p2.getX())
print("Y:\t%.3f" % p2.getY())
print("Z:\t%.3f" % p2.getAlturaElipsoidal())
print("Huso:\t" + str(p2.getHuso()))
print("W:\t%.8f" % p2.getConvergenciaMeridianos())
print("fesca:\t%.9f" % p2.getEscalaLocalPunto())
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
def UTM2Geo(PuntoUTM, NombreElipsoide):
'''!
@brief: Método que convierte coordenadas UTM a coordenadas geodeésicas elipsoidales.
@param PuntoUTM PuntoUTM: Punto con las Coordenadas UTM.
@param NombreElipsoide str: Nombre del elipsoide de calculo.
@return PuntoGeodesico: PuntoGeodesico con las coordenadas transfromadas.
'''
# print(type(PuntoUTM))
# print(putm.PuntoUTM.__class__)
if not isinstance(PuntoUTM.__class__, putm.PuntoUTM.__class__):
raise Exception("Valor Punto UTM.")
try:
NombreElipsoide = str(NombreElipsoide)
except:
raise Exception("Valor Nombre Elipsoide")
x = PuntoUTM.getX()
y = PuntoUTM.getY()
helip = PuntoUTM.getAlturaElipsoidal()
posY = PuntoUTM.getHemisferioY()
Huso = PuntoUTM.getHuso()
Elipsoide = Elip.Elipsoides(NombreElipsoide)
a = Elipsoide.getSemiEjeMayor()
e = Elipsoide.getPrimeraExcentricidad()
e2 = Elipsoide.getSegundaExcentricidad()
#Calculos auxiliares.
if posY is "S":
y = 10000000.0 - y
x = (x - 500000.0) / 0.9996
y = y / 0.9996
#Calculo iterativo de la latitud auxiliar.
Lat = (y) / (a * (1 - (e**2)))
Latsig = 0.0
cont = 0
while abs(Lat - Latsig) > 0.000000000001:
if cont != 0:
Lat = Latsig
s1 = sin(Lat)
s3 = (s1**3)
s5 = (s1**5)
s7 = (s1**7)
s9 = (s1**9)
c1 = cos(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.0 / 128.0) * (e**8) * ((-(1.0 / 8.0) * s7 * c1) -
((7.0 / 48.0) * s5 * c1) -
((35.0 / 192.0) * s3 * c1) -
((35.0 / 128.0) * s1 * c1) +
((35.0 / 128.0) * Lat))
g6 = (693.0 / 256.0) * (e**10) * ((-(1.0 / 10.0) * s9 * c1) -
((9.0 / 80.0) * s7 * c1) -
((21.0 / 160.0) * s5 * c1) -
((21.0 / 128.0) * s3 * c1) -
((63.0 / 256.0) * s1 * c1) +
((63.0 / 256.0) * Lat))
Latsig = (y) / (a * (1 - (e**2))) - (g2 + g3 + g4 + g5 + g6)
cont += 1
#Valores Auxiliares
t = tan(Latsig)
t2 = (t**2)
t4 = (t**4)
t6 = (t**6)
t8 = (t**8)
n2 = ((e2**2)) * ((cos(Latsig)**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.
#Calculo del incremento de longitud.
#x cubo.
x3 = (1.0 + 2.0 * t2 + n2)
#x quinta.
x5 = (5.0 + 28.0 * t2 + 24.0 * t4 + 6.0 * n2 + 8.0 * n2 * t2 - 3.0 * n4 +
4.0 * n4 * t2 - 4.0 * n6 + 24.0 * n6 * t2)
#x septima.
x7 = (61.0 + 662.0 * t2 + 1320.0 * t4 + 720.0 * t6 + 107.0 * n2 +
440.0 * n2 * t2 + 336.0 * n2 * t4 + 43.0 * n4 - 234.0 * n4 * t2 -
192.0 * n4 * t4 + 97.0 * n6 - 772.0 * n6 * t2 + 408.0 * n6 * t4 +
188.0 * n8 - 2392.0 * n8 * t2 + 1536.0 * n8 * t4 + 88.0 * n10 -
1632.0 * n10 * t2 + 1920.0 * n10 * t4)
#x novena.
x9 = (1385.0 + 24568.0 * t2 + 83664.0 * t4 + 100800.0 * t6 + 40320.0 * t8 +
3116.0 * n2 + 26736.0 * n2 * t2 + 47808.0 * n2 * t4 +
24192.0 * n2 * t6 + 1158.0 * n4 - 4884.0 * n4 * t2 -
20736.0 * n4 * t4 - 13824.0 * n4 * t6 - 3500.0 * n6 +
27104.0 * n6 * t2 + 576.0 * n6 * t4 + 12192.0 * n6 * t6 -
11735.0 * n8 + 44788.0 * n8 * t2 - 195984.0 * n8 * t4 +
9788.0 * n8 * t6 - 20280.0 * n10 + 459312.0 * n12 * t2 -
1239552.0 * n12 * t4 + 437760.0 * n12 * t6 - 4672.0 * n14 +
175680.0 * n14 * t2 - 603648.0 * n14 * t4 + 322560.0 * n14 * t6)
nhu = Rad.RadiosDeCurvatura(NombreElipsoide).getRadioPrimerVertical(Latsig)
c1 = cos(Latsig)
Alon = (x / (nhu * c1)) - (((x**3) / (6.0 * (nhu**3) * c1)) * x3) + ((
(x**5) / (120.0 * (nhu**5) * c1)) * x5) - ((
(x**7) / (5040.0 * (nhu**7) * c1)) * x7) + (((x**9) /
(362880.0 *
(nhu**9) * c1)) * x9)
lon0 = ang.Angulo((Huso * 6) - 183, formato='longitud180')
lon0.Convertir('radian')
Lon = lon0.getAngulo() + Alon
#Calculo de la Latitud.
#x cuadrado.
x2 = (1.0 + n2)
#x cuarta.
x4 = (5.0 + 3.0 * t2 + 6.0 * n2 - 6.0 * n2 * t2 - 3.0 * n4 -
9.0 * n4 * t2 - 4.0 * n6)
#x sexta.
x6 = (61.0 + 90.0 * t2 + 45.0 * t4 + 107.0 * n2 - 162.0 * n2 * t2 -
45.0 * n2 * t4 + 43.0 * n4 - 318.0 * n4 * t2 + 135.0 * n4 * t4 +
97.0 * n6 + 18.0 * n6 * t2 + 225.0 * n6 * t4)
#x octava.
x8 = (1385.0 + 3633.0 * t2 + 4515.0 * t4 + 2310.0 * t4 + 3116.0 * n2 -
5748.0 * n2 * t2 + 4704.0 * n2 * t4 - 525.0 * n2 * t6 + 1158.0 * n4 -
17826.0 * n4 * t2 + 37734.0 * n4 * t4 - 9450.0 * n4 * t6 -
3500.0 * n6 + 1164.0 * n6 * t2 + 14006.0 * n6 * t4 -
20790.0 * n6 * t6 - 11735.0 * n8 + 29001.0 * n8 * t2 +
13389.0 * n8 * t4 - 45.0 * n8 * t6 - 20280.0 * n10 +
64272.0 * n10 * t2 - 15864.0 * n10 * t4 - 16144.0 * n12 +
75408.0 * n12 * t2 - 31872.0 * n12 * t4 - 4672.0 * n14 +
30528.0 * n14 * t2 - 23040.0 * n14 * t4)
Lats = Latsig + (((-(x**2) / (2.0 * (nhu**2))) * t * x2) +
((((x**4) / (24.0 * (nhu**4))) * t * x4)) -
((((x**6) / (720.0 * (nhu**6))) * t * x6)) +
((((-x**8) / (40320.0 * (nhu**8))) * t * x8)))
#Cálculo de la convergencia de meridianos.
#coeficientes.
s1 = sin(Lats)
c1 = cos(Lats)
c2 = (c1**2)
c4 = (c1**4)
c6 = (c1**6)
t = tan(Lats)
t2 = (t**2)
t4 = (t**4)
t6 = (t**6)
t8 = (t**8)
n2 = ((e2**2)) * ((cos(Lats)**2))
n4 = (n2**2)
n6 = (n2**3)
n8 = (n2**4)
n10 = (n2**5)
n12 = (n2**6)
n14 = (n2**7)
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()
#Calculo de la escala local del punto.
#coeficientes.
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))
#kp=sqrt(kp)
Lats = ang.Angulo(Lats, formato='radian')
Lats.Convertir('latitud')
Lats = Lats.getAngulo()
Lon = ang.Angulo(Lon, formato='radian')
Lon.Convertir('longitud180')
Lon = Lon.getAngulo()
p1 = pgeo.PuntoGeodesico(Lats, Lon, helip)
PuntoUTM.setConvergenciaMeridianos(convmed)
PuntoUTM.setEscalaLocalPunto(kp)
return p1
class CalcAng(QtGui.QWidget):
'''
classdocs
'''
__rutaroot = None
__msgBoxErr = None
__tipos = ang.Angulo().getFormatosDisponibles()
def __init__(self, parent=None):
'''!
Constructor
'''
super(CalcAng, self).__init__()
#Se carga el formulario para el controlador.
self.__rutaroot = normpath(getcwd() + sep + pardir)
uic.loadUi(self.__rutaroot + '/Formularios/AngularCalc.ui', self)
self.__msgBoxErr = QtGui.QMessageBox()
self.__tabChanged()
self.__RellenarCombos()
self.connect(self.tabWidget, QtCore.SIGNAL("currentChanged (int)"),
self.__tabChanged)
self.connect(self.comboBox,
QtCore.SIGNAL("currentIndexChanged(const QString&)"),
self.__RellenarCombos)
self.connect(self.pushButton, QtCore.SIGNAL("clicked()"),
self.Convertir)
self.connect(self.comboBox_2,
QtCore.SIGNAL("currentIndexChanged (int)"),
self.Convertir)
self.connect(self.pushButton_2, QtCore.SIGNAL("clicked()"),
self.AbrirFicheroAngulos)
self.connect(self.pushButton_3, QtCore.SIGNAL("clicked()"),
self.AbrirFicheroResultados)
def __RellenarCombos(self):
'''!
'''
for i in self.__tipos:
if not i in [
self.comboBox.itemText(i)
for i in range(self.comboBox.count())
]:
self.comboBox.addItem(i)
if not i in [
self.comboBox_2.itemText(i)
for i in range(self.comboBox_2.count())
]:
self.comboBox_2.addItem(i)
txt1 = self.comboBox.currentText()
i2 = self.comboBox_2.findText(txt1)
self.comboBox_2.removeItem(i2)
def Convertir(self):
'''
'''
try:
c1 = self.comboBox.currentText()
a1 = self.lineEdit.text()
if c1 != 'sexagesimal' and "º" in a1:
self.__msgBoxErr.setText(
"El valor del ángulo introducido sólo es admito para la conversión sexagesimal."
)
self.__msgBoxErr.exec_()
return
c2 = self.comboBox_2.currentText()
if c1 == 'sexagesimal':
g = a1[0:2]
m = a1[3:5]
s = a1[6:]
#print(g,m,s)
ang1 = ang.Angulo(g, m, s)
ang1.Convertir(c2)
self.lineEdit_2.setText(str(ang1.getAngulo()))
else:
ang1 = ang.Angulo(a1, formato=c1)
ang1.Convertir(c2)
if c2 == 'sexagesimal':
g = str(int(ang1.getAngulo()[0]))
m = str(int(ang1.getAngulo()[1]))
s = str(ang1.getAngulo()[2])
self.lineEdit_2.setText(g + "º" + m + "'" + s)
else:
self.lineEdit_2.setText(str(ang1.getAngulo()))
pass
except Exception as e:
self.__msgBoxErr.setText(e.__str__())
self.__msgBoxErr.exec_()
return
def AbrirFicheroAngulos(self):
'''!
'''
ruta = QtGui.QFileDialog.getOpenFileName(self, 'Abrir Archivo', '.')
self.lineEdit_3.setText(ruta)
def AbrirFicheroResultados(self):
'''!
'''
ruta = QtGui.QFileDialog.getSaveFileName(self, 'Guadar Archivo', '.')
self.lineEdit_4.setText(ruta)
def ConvertirFichero(self):
'''!
'''
with open(self.lineEdit_3.text(), 'r') as f:
for i in f:
QtGui.QApplication.processEvents()
lin = i.split(",")
if len(lin) == 2:
#Radian a ...
ang1 = ang.Angulo(lin[0])
ang1.Convertir(lin[1])
continue
if len(lin) == 3:
# De f1 a f2
ang1 = ang.Angulo(lin[0], formato=lin[1])
ang1.Convertir(lin[2])
continue
if len(lin) == 4:
#Sexagesimal a...
ang1 = ang.Angulo(lin[0], lin[1], lin[2])
ang1.Convertir(lin[3])
continue
if len(lin) == 5:
#Sexagesimal a ...
ang1 = ang.Angulo(lin[0], lin[1], lin[2])
if lin[3] != 'sexagesimal':
self.__msgBoxErr.setText(
"El único formato admisible de cambio es sexagesimal."
)
self.__msgBoxErr.exec_()
return
else:
ang1.Convertir(lin[4])
f.close()
def __tabChanged(self):
'''!
'''
if self.tabWidget.currentIndex() == 0:
self.setFixedSize(502, 132)
elif self.tabWidget.currentIndex() == 1:
self.setFixedSize(522, 270)
pass
elif self.tabWidget.currentIndex() == 2:
self.setFixedSize(360, 120)
pass
def main():
PI = PIGeodesia(pgeo.PuntoGeodesico(50, 10), pgeo.PuntoGeodesico(40, 9))
az, s = PI.CalcularBessel('WGS 84')
az = ang.Angulo(az)
az.Convertir('sexagesimal')
print(az.getAngulo(), s)
def CalcularBessel(self, NombreElipsoide):
'''!
@brief: Método que calcula el problema inverso de la geodesia.
@param NombreElipsoide str: Elipsoide de calculo.
@return
'''
lat1 = ang.Angulo(self.__pgeo1.getLatitud(),
formato='pseudosexagesimal')
lat1.Convertir('radian')
lat1 = lat1.getAngulo()
lon1 = ang.Angulo(self.__pgeo1.getLongitud(),
formato='pseudosexagesimal')
lon1.Convertir('radian')
lon1 = lon1.getAngulo()
lat2 = ang.Angulo(self.__pgeo2.getLatitud(),
formato='pseudosexagesimal')
lat2.Convertir('radian')
lat2 = lat2.getAngulo()
lon2 = ang.Angulo(self.__pgeo2.getLongitud(),
formato='pseudosexagesimal')
lon2.Convertir('radian')
lon2 = lon2.getAngulo()
Alon = lon2 - lon1
elipsoide = elip.Elipsoides(NombreElipsoide)
a = elipsoide.getSemiEjeMayor()
b = elipsoide.getSemiEjeMenor()
e1 = elipsoide.getPrimeraExcentricidad()
latesf1 = atan((b / a) * tan(lat1))
latesf2 = atan((b / a) * tan(lat2))
lonesf1 = lon1
correccion = 0
correccion1 = Alon
while abs(correccion - correccion1) > 0.0000000001:
correccion1 = correccion
lonesf2 = lonesf1 + Alon + correccion
#Solución PI Esfera:
s2 = matrix([[(cos(latesf2) * cos(lonesf2))],
[(cos(latesf2) * sin(lonesf2))], [(sin(latesf2))]])
m1 = matrix([[(-sin(latesf1) * cos(lonesf1)),
(-sin(latesf1) * sin(lonesf1)), (cos(latesf1))],
[(sin(lonesf1)), (-cos(lonesf1)), (0)],
[(cos(latesf1) * cos(lonesf1)),
(cos(latesf1) * sin(lonesf1)), (sin(latesf1))]])
sol = dot(m1, s2)
lonsal = atan2(float(sol[1]), float(sol[0]))
latsal = asin(float(sol[2]))
azsal = 0 #Ya es el bueno.
s = (pi / 2) - latsal #Distancia sobre la esfera
if lonsal == 0:
azsal = 0
elif lonsal < 0:
azsal = abs(lonsal)
elif lonsal > 0:
azsal = 2 * pi - lonsal
#Problema inverso en el elipsoide
M = atan2(tan(latesf1), cos(azsal))
m = asin(sin(azsal) * cos(latesf1))
#Calculo de las integrales.
cMs = cos(M + s)
sMs = sin(M + s)
sMs3 = sMs**3
sMs5 = sMs**5
cm = cos(m)
cm2 = cm**2
cm4 = cm**4
cm6 = cm**6
cM = cos(M)
sm = sin(m)
sM = sin(M)
sM3 = sM**3
sM5 = sM**5
I1=(s)+\
((1/2)*cm2*cMs*sMs)-\
((1/2)*s*cm2)-\
((1/2)*cm2*cM*sM)
I2=(s)+\
(cm2*cMs*sMs)-\
(s*cm2)-\
((1/4)*cm4*cMs*sMs3)-\
((3/8)*cm4*cMs*sMs)-\
((3/8)*s*cm4)-\
(cm2*cM*sM)+\
((1/4)*cm4*cM*sM3)+\
((3/8)*cm4*cM*sM)
I3=(s)+\
((3/2)*cm2*cMs*sMs)-\
((3/2)*s*cm2)-\
((3/4)*cm4*cMs*sMs3)-\
((9/8)*cm4*cMs*sMs)+\
((9/8)*s*cm4)+\
((1/6)*cm6*cMs*sMs5)+\
((5/24)*cm6*cMs*sMs3)+\
((5/16)*cm6*cMs*sMs)-\
((5/16)*s*cm6)+\
((3/2)*cm2*cMs*sMs)+\
((3/4)*cm4*cM*sM3)-\
((9/8)*cm4*cM*sM)-\
((1/6)*cm6*cM*sM5)-\
((5/24)*cm6*cM*sM3)-\
((5/16)*cm6*cM*sM)
correccion=((e1**2*sm)/2)*\
((s)+(((e1**2)/4)*(I1))+(((e1**4)/8)*(I2))+(((5*e1**6)/64)*(I3)))
#print(azsal,s*(a+b)/2,correccion,correccion1)
#input()
return azsal, s
def getPosition(self):
#Cte más adelante cambiar por los valores de los elipsoides en la base de datos.
c = 2.99792458e8
GM = 3.986005e14
we = 7.2921151467e-5
F = -4.442807633e-10
#Cálculo de la posicion para cada satelite en funcion de la epoca.
Sal = [] #se almacenan los valores de salida.
for j in self.obs: #Para cada tipo de observable con el que se quiera calcular.
tipo = j[1] #Tipo de observable:
if "G" in tipo: #Observable GPS:
#Calcular la efemeride más cercana para el observable.
Dif = []
for indi, i in enumerate(self.ef):
if i[1] == j[1]:
t_obs = u2g.UTC2GPS(j[0])
t_efem = u2g.UTC2GPS(i[0])
Dif.append([t_efem - t_obs, indi])
if Dif == []:
continue
vali = Dif[0]
for i in Dif:
if i[0] < vali[0]:
vali = i
#Efemeride GPS.
t = u2g.UTC2GPS(j[0]) #Tiempo de la observación.
#se debe corregir del tiempo de viaje de la señal asi como de efectos atmosfericos si los datos estan disponibles.
t = t - (float(j[2][0])) / c #Tiempo corregido de los efectos.
vali = self.ef[vali[1]]
#Valores de la efemerides. Comprobar si la posición cambia entre diferentes versiones de ficheros RINEX
af0 = vali[2][0]
af1 = vali[2][1]
af2 = vali[2][2]
Crs = vali[2][4]
delta_n = vali[2][5]
M0 = vali[2][6]
Cuc = vali[2][7]
ecc = vali[2][8]
Cus = vali[2][9]
a = vali[2][10]**2
toe = vali[2][11]
Cic = vali[2][12]
OMEGA = vali[2][13]
Cis = vali[2][14]
I0 = vali[2][15]
Crc = vali[2][16]
Omega = vali[2][17]
OMEGA_DOT = vali[2][18]
IDOT = vali[2][19]
week = vali[2][20]
tgd = vali[2][24]
time_trans = vali[2][26]
tk = t - toe
Atsv = af0 + af1 * (tk) + af2 * (tk)**2
tk = tk - Atsv - tgd
M = M0 + ((sqrt((GM) / (a**3))) + (delta_n)) * tk
M = ang.Angulo(M, girar=True)
M = M.getAngulo()
E_ant = M
E_sig = 0
while (abs(E_ant - E_sig) != 0):
E_sig = M + ecc * sin(E_ant)
E_ant = E_sig
E = ang.Angulo(E_sig)
E = E.getAngulo()
tk = tk + (F * ecc * sqrt(a) * sin(E))
true_anom = atan2((sqrt(1 - ecc**2) * sin(E)), (cos(E) - ecc))
alfa = ang.Angulo(2 * (true_anom + Omega), girar=True)
alfa = alfa.getAngulo()
Omega1 = ang.Angulo(Omega + (Cuc * cos(alfa)) +
(Cus * sin(alfa)),
girar=True)
Omega1 = Omega1.getAngulo()
incli = ang.Angulo(
(I0 + (IDOT * tk)) + (Cic * cos(alfa)) + (Cis * sin(alfa)),
girar=True)
incli = incli.getAngulo()
r = (a *
(1 -
(ecc * cos(E)))) + (Crc * cos(alfa)) + (Crs * sin(alfa))
OMEGA_FIN = ang.Angulo(OMEGA + ((OMEGA_DOT - we) * tk) -
(we * toe),
girar=True)
OMEGA_FIN = OMEGA_FIN.getAngulo()
K = matrix([[r * cos(true_anom)], [r * sin(true_anom)], [0]])
R = matrix([[
cos(OMEGA_FIN) * cos(Omega1) -
sin(OMEGA_FIN) * sin(Omega1) * cos(incli),
-cos(OMEGA_FIN) * sin(Omega1) -
sin(OMEGA_FIN) * cos(Omega1) * cos(incli),
sin(OMEGA_FIN) * sin(incli)
],
[
sin(OMEGA_FIN) * cos(Omega1) +
cos(OMEGA_FIN) * sin(Omega1) * cos(incli),
-sin(OMEGA_FIN) * sin(Omega1) +
cos(OMEGA_FIN) * cos(Omega1) * cos(incli),
-cos(OMEGA_FIN) * sin(incli)
],
[
sin(Omega1) * sin(incli),
cos(Omega1) * sin(incli),
cos(incli)
]])
sol = dot(R, K)
X = float(sol[0])
Y = float(sol[1])
Z = float(sol[2])
## print(X,Y,Z)
## print(i[1],E_sig,true_anom,alfa,Omega1,incli,r,OMEGA_FIN,float(j[2][0]))
Sal.append([j[0], j[1], X, Y, Z, float(j[2][0]), Atsv])
elif "R" in tipo:
#Calcular la efemeride más cercana para el observable.
Dif = []
for indi, i in enumerate(self.ef):
if i[1] == j[1]:
t_obs = u2g.UTC2GPS(j[0])
t_efem = u2g.UTC2GPS(i[0])
Dif.append([t_efem - t_obs, indi])
if Dif == []:
continue
vali = Dif[0]
for i in Dif:
if i[0] < vali[0]:
vali = i
vali = self.ef[vali[1]]
#Efemeride GLONASS.
tefem = vali[0]
tobs = j[0]
tau = vali[2][0]
gamma = vali[2][1]
tk = vali[2][2]
X = vali[2][3] * 1000
vx = vali[2][4] * 1000
ax = vali[2][5] * 1000
health = vali[2][6]
Y = vali[2][7] * 1000
vy = vali[2][8] * 1000
ay = vali[2][9] * 1000
f = vali[2][10]
Z = vali[2][11] * 1000
vz = vali[2][12] * 1000
az = vali[2][13] * 1000
age = vali[2][14]
#Corregir tiempo.
t = (u2g.UTC2GPS(tobs) - u2g.UTC2GPS(tefem))
t = t - (float(j[2][0])) / c
#Error del reloj del satélite.
Atsv = -tau + gamma * t
t = t - Atsv
#Calcular la posicion correcto.
##Interpolacion de la posicion por el metodo de Ringe-Kutta 4º orden.
## print(X,Y,Z)
# Xsal=X+vx*t+ax*t**2
# Ysal=Y+vy*t+ay*t**2
# Zsal=Z+vz*t+az*t**2
# print(Xsal,Ysal,Zsal)
pasos = 30
itera = floor(abs(t / pasos))
## print(itera)
##
Xa = X
Ya = Y
Za = Z
vxa = vx
vya = vy
vza = vz
# for s in range(itera):
# err=t/itera
# # print(err)
# sal1=sat_pos.Sat_Motion_Dif(Xa,Ya,Za,vxa,vya,vza,ax,ay,az,Elip.Elipsoides('PZ-90'))
# # print(sal1)
# sal2=sat_pos.Sat_Motion_Dif(Xa+(sal1[0]*err/2),Ya+(sal1[1]*err/2),Za+(sal1[2]*err/2),vxa+(sal1[3]*err/2),vya+(sal1[4]*err/2),vza+(sal1[5]*err/2),ax,ay,az,Elip.Elipsoides('PZ-90'))
# # print(sal2)
# sal3=sat_pos.Sat_Motion_Dif(Xa+(sal2[0]*err/2),Ya+(sal2[1]*err/2),Za+(sal2[2]*err/2),vxa+(sal2[3]*err/2),vya+(sal2[4]*err/2),vza+(sal2[5]*err/2),ax,ay,az,Elip.Elipsoides('PZ-90'))
# # print(sal3)
# sal4=sat_pos.Sat_Motion_Dif(Xa+sal3[0]*err,Ya+sal3[1]*err,Za+sal3[2]*err,vxa+sal3[3]*err,vya+sal3[4]*err,vza+sal3[5]*err,ax,ay,az,Elip.Elipsoides('PZ-90'))
# # print(sal4)
# sal=array([Xa,Ya,Za,vxa,vya,vza])+(array(sal1)+2*array(sal2)+2*array(sal3)+array(sal4))*err/6
# # print(err)
# # print(sal)
# # input()
# Xa=sal[0]
# Ya=sal[1]
# Za=sal[2]
# vxa=sal[3]
# vya=sal[4]
# vza=sal[5]
# print(Xa,Ya,Za)
# input()
#Cambiar de marco.
##Parametros Boucher-Altamini.
Tx = -0.36
Ty = 0.08
Tz = 0.018
# Tx=0.07
# Ty=0.0567
# Tz=-0.7733
# wx=-9.2114599410812E-11
# wy=-1.9392547244381E-11
# wz=1.7113922943167E-9
# d=-3/10E9
##Transformacion de 7 parametros de Helmert.
Xsal = Xa + Tx
Ysal = Ya + Ty
Zsal = Za + Tz
Sal.append(
[j[0], j[1], Xsal, Ysal, Zsal,
float(j[2][0]), Atsv])
return Sal
