Cálculo de distancias geodésicas

Los topógrafos necesitan herramientas que les permitan trabajar con datos de coordenadas geográficas (latitud y longitud) y convertirlas a coordenadas cartesianas (UTM). Además, es crucial calcular las distancias precisas entre puntos para aplicaciones como levantamientos topográficos, construcción y mapeo. Este proyecto abordará estas necesidades mediante un programa en C++.

Este programa es funcional para topógrafos que trabajen con datos básicos de coordenadas y necesiten cálculos rápidos. Su modularidad permite ampliarlo para integrar modelos más avanzados, como la proyección UTM completa.

Objetivos

1. Convertir coordenadas geográficas (latitud y longitud) a coordenadas UTM.

2. Calcular la distancia entre dos puntos usando la fórmula de Haversine para geografía esférica y el método cartesiano en coordenadas planas.

3. Proporcionar una herramienta fácil de usar en la línea de comandos.

Problemas que Resuelve el cálculo de distancias geodésicas

Conversión precisa: Los topógrafos suelen usar herramientas externas para convertir coordenadas; este programa simplifica el flujo de trabajo.

Cálculo automatizado: Reduce errores humanos al calcular distancias.

Accesibilidad: Es un programa independiente que no requiere licencias costosas.

Código completo del proyecto

#include <iostream>
#include <cmath>
#include <iomanip>

const double RADIUS_EARTH = 6371.0; // Radio de la Tierra en kilómetros

// Prototipos de funciones
void geodeticToUTM(double latitude, double longitude, double& utmX, double& utmY);
double haversineDistance(double lat1, double lon1, double lat2, double lon2);
double cartesianDistance(double x1, double y1, double x2, double y2);

int main() {
    int choice;
    std::cout << "Sistema de cálculo topográfico:\n";
    std::cout << "1. Convertir coordenadas geográficas a UTM\n";
    std::cout << "2. Calcular distancia entre dos puntos\n";
    std::cout << "Seleccione una opción (1 o 2): ";
    std::cin >> choice;

    if (choice == 1) {
        double latitude, longitude, utmX, utmY;
        std::cout << "Ingrese latitud: ";
        std::cin >> latitude;
        std::cout << "Ingrese longitud: ";
        std::cin >> longitude;

        geodeticToUTM(latitude, longitude, utmX, utmY);

        std::cout << std::fixed << std::setprecision(2);
        std::cout << "Coordenadas UTM: (" << utmX << ", " << utmY << ")\n";
    } else if (choice == 2) {
        double lat1, lon1, lat2, lon2;
        std::cout << "Ingrese latitud del punto 1: ";
        std::cin >> lat1;
        std::cout << "Ingrese longitud del punto 1: ";
        std::cin >> lon1;
        std::cout << "Ingrese latitud del punto 2: ";
        std::cin >> lat2;
        std::cout << "Ingrese longitud del punto 2: ";
        std::cin >> lon2;

        double distance = haversineDistance(lat1, lon1, lat2, lon2);
        std::cout << std::fixed << std::setprecision(2);
        std::cout << "Distancia geodésica: " << distance << " km\n";
    } else {
        std::cout << "Opción inválida.\n";
    }

    return 0;
}

// Función para convertir coordenadas geográficas a UTM (simplificada para fines educativos)
void geodeticToUTM(double latitude, double longitude, double& utmX, double& utmY) {
    double scaleFactor = 0.9996;
    utmX = longitude * 111320.0 * scaleFactor;
    utmY = latitude * 110540.0 * scaleFactor;
}

// Función para calcular la distancia geodésica usando la fórmula de Haversine
double haversineDistance(double lat1, double lon1, double lat2, double lon2) {
    lat1 = lat1 * M_PI / 180.0; // Convertir a radianes
    lon1 = lon1 * M_PI / 180.0;
    lat2 = lat2 * M_PI / 180.0;
    lon2 = lon2 * M_PI / 180.0;

    double dlat = lat2 - lat1;
    double dlon = lon2 - lon1;

    double a = std::sin(dlat / 2) * std::sin(dlat / 2) +
               std::cos(lat1) * std::cos(lat2) *
               std::sin(dlon / 2) * std::sin(dlon / 2);

    double c = 2 * std::atan2(std::sqrt(a), std::sqrt(1 - a));
    return RADIUS_EARTH * c;
}

// Función para calcular la distancia cartesiana entre dos puntos UTM
double cartesianDistance(double x1, double y1, double x2, double y2) {
    return std::sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
}

Explicación Línea a Línea del cálculo de distancias geodésicas

#include <iostream>: Biblioteca estándar para entrada y salida.

#include <cmath>: Proporciona funciones matemáticas como sin, cos y sqrt.

#include <iomanip>: Permite formatear la salida (decimales).

const double RADIUS_EARTH = 6371.0;: Define el radio de la Tierra en kilómetros, utilizado en el cálculo de distancias geodésicas.

Prototipos de funciones: Declaran las funciones que se implementan después de main para mejorar la legibilidad.

int main(): Punto de entrada del programa.

Menú interactivo: Permite al usuario elegir entre conversión de coordenadas o cálculo de distancias.

Conversión de geodésicas a UTM: Usa una fórmula simplificada basada en factores de escala aproximados.

Fórmula de Haversine:

Convierte grados a radianes.

Calcula la distancia esférica basada en la latitud y longitud de dos puntos.

Cálculo cartesiano: Calcula distancias planas entre puntos en coordenadas UTM.

Formato de salida: Muestra los resultados con dos decimales para precisión adecuada.

---

Te invito a que sigas mi página web y mi página de linkedin para poder leer y compartir más tutoriales como este.