Captura1

La fotografía es una forma poderosa de capturar momentos, pero cuando añadimos coordenadas GPS a nuestras imágenes, transformamos esos momentos en recuerdos geolocalizados. En este artículo, exploraremos cómo utilizar un script de Python para extraer las coordenadas GPS de las fotos y exportarlas a archivos CSV y KML, facilitando la visualización y el análisis de nuestros recuerdos fotográficos.

¿Qué Necesitamos?

Para comenzar, asegúrate de tener instalado Python y las siguientes bibliotecas:

  • Pillow: Para manejar imágenes y extraer los datos EXIF.
  • simplekml: Para crear archivos KML que se pueden cargar en Google Earth.
  • csv: Para manejar la exportación de datos a CSV.

Puedes instalar las librerías necesarias usando pip:

pip install Pillow simplekml

El Script

import os
import csv
import simplekml
from PIL import Image
from PIL.ExifTags import TAGS, GPSTAGS

def get_exif_data(image):
    """
    Extrae datos EXIF de una imagen.

    Args:
        image (PIL.Image.Image): La imagen de la cual extraer datos EXIF.

    Returns:
        dict: Un diccionario que contiene los datos EXIF.
    """
    exif_data = {}
    info = image._getexif()
    if info:
        for tag, value in info.items():
            tag_name = TAGS.get(tag, tag)
            exif_data[tag_name] = value
    return exif_data

def get_gps_info(exif_data):
    """
    Extrae información GPS de los datos EXIF.

    Args:
        exif_data (dict): Un diccionario que contiene datos EXIF.

    Returns:
        dict: Un diccionario que contiene información GPS.
    """
    gps_info = {}
    if "GPSInfo" in exif_data:
        for key in exif_data["GPSInfo"].keys():
            decode = GPSTAGS.get(key, key)
            gps_info[decode] = exif_data["GPSInfo"][key]
    return gps_info

def convert_to_degrees(value):
    """
    Convierte coordenadas GPS almacenadas en grados, minutos y segundos a grados decimales.

    Args:
        value (tuple): Una tupla que contiene las coordenadas GPS en grados, minutos y segundos.

    Returns:
        float: Las coordenadas en grados decimales.
    """
    d = float(value[0])
    m = float(value[1])
    s = float(value[2])
    return d + (m / 60.0) + (s / 3600.0)

def get_coordinates(gps_info):
    """
    Extrae latitud y longitud de la información GPS.

    Args:
        gps_info (dict): Un diccionario que contiene información GPS.

    Returns:
        tuple: Una tupla que contiene la latitud y longitud.
    """
    lat = None
    lon = None
    if "GPSLatitude" in gps_info and "GPSLatitudeRef" in gps_info and \
       "GPSLongitude" in gps_info and "GPSLongitudeRef" in gps_info:
        lat = convert_to_degrees(gps_info["GPSLatitude"])
        if gps_info["GPSLatitudeRef"] != "N":
            lat = 0 - lat

        lon = convert_to_degrees(gps_info["GPSLongitude"])
        if gps_info["GPSLongitudeRef"] != "E":
            lon = 0 - lon
    return lat, lon

def extract_coordinates_from_images(directory):
    """
    Extrae coordenadas GPS de todas las imágenes en un directorio.

    Args:
        directory (str): El directorio que contiene las imágenes.

    Returns:
        list: Una lista de tuplas, cada una con el nombre de archivo, latitud y longitud.
    """
    coordinates = []
    for filename in os.listdir(directory):
        if filename.lower().endswith(('.jpg', '.jpeg', '.tiff', '.png')):
            image_path = os.path.join(directory, filename)
            image = Image.open(image_path)
            exif_data = get_exif_data(image)
            gps_info = get_gps_info(exif_data)
            lat, lon = get_coordinates(gps_info)
            if lat and lon:
                coordinates.append((filename, lat, lon))
    return coordinates

def save_coordinates_to_csv(coordinates, output_path):
    """
    Guarda coordenadas GPS en un archivo CSV.

    Args:
        coordinates (list): Una lista de tuplas, cada una con el nombre de archivo, latitud y longitud.
        output_path (str): La ruta del archivo CSV de salida.
    """
    with open(output_path, 'w', newline='') as csvfile:
        fieldnames = ['Filename', 'Latitude', 'Longitude']
        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
        writer.writeheader()
        for filename, lat, lon in coordinates:
            writer.writerow({'Filename': filename, 'Latitude': lat, 'Longitude': lon})

def save_coordinates_to_kml(coordinates, output_path):
    """
    Guarda coordenadas GPS en un archivo KML.

    Args:
        coordinates (list): Una lista de tuplas, cada una con el nombre de archivo, latitud y longitud.
        output_path (str): La ruta del archivo KML de salida.
    """
    kml = simplekml.Kml()
    
    for filename, lat, lon in coordinates:
        # Crea un punto para cada imagen
        point = kml.newpoint(name=filename)
        point.coords = [(lon, lat)]  # KML usa el orden (longitud, latitud)
        point.style.iconstyle.icon.href = 'http://maps.google.com/mapfiles/kml/paddle/red-circle.png'
        
    kml.save(output_path)

if __name__ == "__main__":
    # Cambia el directorio de trabajo a la ubicación del script
    os.chdir(os.path.dirname(os.path.abspath(__file__)))
    
    # Obtiene el directorio actual
    directory = os.getcwd()
    
    print("Extrayendo coordenadas de imágenes...")
    coordinates = extract_coordinates_from_images(directory)
    
    if coordinates:
        # Guardar archivo CSV
        csv_output_path = os.path.join(directory, 'coordinates.csv')
        save_coordinates_to_csv(coordinates, csv_output_path)
        print(f"Coordenadas guardadas en {csv_output_path}")
        
        # Guardar archivo KML
        kml_output_path = os.path.join(directory, 'coordinates.kml')
        save_coordinates_to_kml(coordinates, kml_output_path)
        print(f"Archivo KML guardado en {kml_output_path}")
        
        print(f"\nProcesadas {len(coordinates)} imágenes con coordenadas GPS")
    else:
        print("No se encontraron imágenes con coordenadas GPS en el directorio")
    
    # Esperar entrada del usuario antes de cerrar
    input("\nPresione Enter para salir...")

El script que vamos a utilizar permite extraer las coordenadas GPS de todas las imágenes en un directorio dado. A continuación, se describen los pasos clave que realiza el script:

  1. Leer los datos EXIF de las imágenes: Los datos EXIF (Exchangeable Image File Format) son metadatos que las cámaras digitales suelen incluir en las fotos. Estos datos pueden contener información sobre la ubicación donde se tomó la foto, siempre que la cámara tenga habilitado el GPS.

  2. Extraer la información GPS: El script identifica y extrae las coordenadas de las imágenes que contienen datos GPS en sus metadatos.

  3. Convertir las coordenadas a un formato manejable: Las coordenadas GPS pueden estar en diferentes formatos (grados, minutos, segundos). El script convierte estas coordenadas a grados decimales.

  4. Guardar las coordenadas en archivos CSV y KML: Finalmente, el script guarda las coordenadas en dos formatos diferentes, facilitando su uso en distintas aplicaciones.

Cómo Usar el Script

Para utilizar el script, simplemente sigue estos pasos:

  1. Coloca tus imágenes en un directorio: Asegúrate de que tus imágenes (JPG, JPEG, TIFF, PNG) estén en un directorio específico.

  2. Ejecuta el script: Coloca el script en el mismo directorio que tus imágenes o ajusta la ruta en el script para que apunte a tu directorio de imágenes. Luego, ejecuta el script en tu terminal:

python coordfotos.py
  1. Revisa los archivos generados: Una vez que el script se ejecute, generará dos archivos: coordinates.csv y coordinates.kml. El archivo CSV contendrá las coordenadas en un formato de tabla, mientras que el archivo KML te permitirá visualizar las ubicaciones en Google Earth.

Ejemplo de Uso

Supongamos que tienes un directorio llamado fotos_vacaciones con varias imágenes. Después de ejecutar el script, puedes abrir coordinates.csv en Excel o cualquier editor de texto, y ver algo como esto:

Filename, Latitude, Longitude
foto1.jpg, 37.7749, -122.4194
foto2.jpg, 34.0522, -118.2437

El archivo coordinates.kml puede ser abierto directamente en Google Earth, donde podrás ver marcadores en el mapa que corresponden a las ubicaciones de tus fotos.

La capacidad de geolocalizar tus imágenes no solo hace que tus recuerdos sean más significativos, sino que también te permite revivir tus aventuras de una manera interactiva. Imagina poder mostrar a tus amigos un mapa de cada lugar que has visitado y las fotos que tomaste en cada uno. Con este sencillo script de Python, puedes hacerlo de manera eficiente y efectiva.