float distance(a1,a2,a3,a4,a5,b1,b2,b3,b4,b5,c1,c2,c3,c4,c5,d1,d2,d3,d4,d5) { // calculo de distancias a partir de coordenadas.
/* a1,a2,a3,a4,a5 = Latitud origen a1-Grados, a2-minutos, a3-segundos, a4-mantisa de segundos, a5-(0 = Sur, 1= Norte)
b1,b2,b3,b4,b5 = Longitud origen b1-grados,b2- minutos, b3-segundos, b4-mantisa de segundos b5-(0 = Oeste 1 = este)
c1,c2,c3,c4,c5 = Latitud destino c1-Grados,c2- minutos, c3-segundos, c4-mantisa de segundos c5-(0 = Sur, 1= Norte)
d1,d2,d3,d4,d5 = Longitud destino d- 1grados,d2- minutos, d3-segundos,d4- mantisa de segundos d5-(0 = Oeste 1 = este)
*/
// lo primero que hacemos es unir las variables (segundos y mantisa de segundos) en un float
float lat_or_sec = a3 + ((float)a4/100); // creamos nueva variable (latitud origen segundos)
// sumo a los segundos, las decimas de segundos dividido entre 100. Si por ejemplo los segundos son = 13, y las mantisa es 20, esto rersulta: 13,20
// hacemos lo mismo con las de longitud, y con las dos del destino.
float long_or_sec = b3 + ((float)b4/100); // longitus del origen
float lat_des_sec = c3 + ((float)c4/100); // latitud del destino
float long_des_sec = d3 + ((float)d4/100); // longitud del destino
// ahora tenemos las coordenadas en formato grados, minutos y segundos, las vamos a convertir a grados sexageximales.
float orlatdeg = a1 + ((float)a2/60) + (lat_or_sec/3600); // creamos variable para latitud de origen
// sumamos a los grados, los minutos divididos entre 60 y los segundos divididos entre 3600.
// hacemos lo mismo con la longitud y con las del destino
float orlongdeg = b1 + ((float)b2/60) + (long_or_sec/3600); // longitud del origen
float deslatdeg = c1 + ((float)c2/60) + (lat_des_sec/3600); // latitud del destino
float deslongdeg = d1 + ((float)d2/60) + (long_des_sec/3600); // longitud del destino
// ya tenemos las coordenadas en grados decimales. ( orlatdeg y orlongdec son la latitud y longitud del origen, deslatdeg y deslongdeg son latitud y longitud del destino)
// Ahora vamos a calcular la distancia que separa ambos puntos (origen y destino) en el meridiano, es decir, la distancia en grados de las latitudes de ambos puntos. Para ello, tomaremos en cuenta la posicion Norte o Sur de ambos
// puntos. Si los dos tienen latitud norte:
float difdeg; // cargaremos aqui la diferencia en grados que separan origen y destino en grados.
if (a5 == c5) { // si la latitud del origen y de destino están en el mismo hemisferio
difdeg = orlatdeg - deslatdeg; // hallamos la diferencia entre ambas latitudes.
if (difdeg < 0) difdeg = difdeg * (-1); // si nos da negativo el resultado lo invertimos para que siempre sea positivo ya que no nos interesa saber cual está arriba y cual abajo, solo la distancia que los serpara.
}
else { // si las latitudes estan en distintos hemisferios entonces tenemos que sumar ambas latitudes para obtener la distancia total entre origen y destino
difdeg = orlatdeg + deslatdeg;
}
// ya tenemos hallada la diferencia en grados que separan origen y destino en meridiano.
// ahora lo vamos a pasar a kilómetros, para ello, tenemos la longitud total de la circunsferencia de un meridiano
// esa longitud meridiano es: 39941,58068 Kmts.
// si dividimos esa distancia entre los 360º que tiene una circunsferencia tendremos la distancia por grado. Luego multiplicaremos por la distancia en grados obtenida arriba y asi obtendremos la distancia en Kmts
// que separan ambas latitudes entre origen y destino.
float difkm = (39941.58068 / 360) * difdeg; // aqui la diferencia ya en Kmts
// ahora vamos a obtener la diferencia entre origen y destino, pero en el paralelo. A diferencia del meridiano, que miden todos lo mismo, los paralelos miden menos cuanto mas a los polos nos acercamos.
// vamos a determinar cual es la longitud del paralelo donde se encuenta el destino.
// para ello usaremos la siguiente formula: 2 * pi * radio del paralelo . para calcular el radio del paralelo usare la formula: cos(latitud) * radio de la tierra
// el radio de la tierra varía según ecuador, tropicos o circulos polares, para el ecuador el radio es : 6378,3 km mientras que para los polos es de 6357,6
// de modo que para elegir el que mas nos conviene para aproximarnos lo mas posible, dividiremos los 90º de latitud entre la diferencia entre los dos valores y llamaremos elipsoide al resultado.
// la diferencia entre los dos radios es de 20,7 que hay que dividir entre los 90º que los representan dando como resultado 0,23 unidades a incrementar por grado de latitud del destino.
float32 elipsoide = (0.23 * deslatdeg) + 6357.6; // ya tenemos la elipsoide que mejor nos conviene usar segun latitud. En adelante la trataremos como "radio de la tierra"
// la funcion cos(); nos dará el coseno pero hay que darselo en radianes. por lo que primero tenemos que pasar los grados de la latitud a radianes usando la formula radianes = grados * (pi/180).)
float radianes = deslatdeg * (PI / 180); // ya tenemos los radianes para calcular el radio del paralelo:
float radio_paralelo
= (cos(radianes
) * elipsoide
); // obtengo el coseno en radianes y lo multiplico por la elipsoide elegida para la latitud y obtengo así el radio del circulo equivalente a esa latitud.
float longitud_paralelo = (2 * PI) * radio_paralelo; // ya tenemos la longitud del paralelo del destino
// ahora hay que determinar la distancia en el paraleo que separan origen y destino.
// al igual que para el meridiano, tenemos que identificar si origen y destino están a un lado u otro de grenwich
float difdegparal; // cargaremos aqui la diferencia en grados entre origen y destino en el paralelo.
if (b5 == d5) { // si origen y destino están en el mismo lado de grenwich
difdegparal = orlongdeg - deslongdeg; // se restan sus valores.
if (difdegparal < 0) difdegparal = difdegparal * (-1); // si el resultado es negativo invertimos y lo pasamos a positivo ya que nos da igual quien está a un lado grenwich y quien al otro, solo queremos saber si están los dos o no en el mismo lado.
}
else {
difdegparal = orlongdeg + deslongdeg; // si están en distintos lados de genwich entonces sumamos los grados de ambos
}
// ya sabemos la distancia en grados que separan origen y destino en el paralelo. Ahora lo pasamos a Kmts
float difkmparal = (longitud_paralelo / 360) * difdegparal; // ya tenemos la distancia en Kmts que separan origen y destino en el paralelo.
// finalmente para obtener la distancia final entre ambos puntos se aplica teorema de pitágoras:
float dab
= sqrt(pow(difkmparal
,2) + pow(difkm
,2)); // Raiz cuadrada de (distancia en del meridiano al cuadrado + distancia en el paralelo al cuadrado) = Distancia final. // aqui cargaremos la distancia desde A a B
return dab;
}
