GeoPointInterface

GeoPointInterface representa una coordenada geográfica con latitud, longitud y altitud opcional.

Interfaz e implementación

Interfaz GeoPointInterface

La interfaz GeoPointInterface tiene las siguientes propiedades. Se utiliza para pruebas unitarias y otros propósitos.

interface GeoPointInterface {
    val latitude: Double
    val longitude: Double
    val altitude: Double?
}

GeoPoint

La clase GeoPoint es una implementación de la interfaz GeoPointInterface.

data class GeoPoint(
    override val latitude: Double,
    override val longitude: Double,
    override val altitude: Double = 0.0
) : GeoPointInterface

Métodos de creación

Métodos de fábrica

La clase GeoPoint proporciona los siguientes métodos de fábrica. Los desarrolladores pueden elegir el método que les resulte más conveniente.

// Especificar valores en orden latitud, longitud
GeoPoint.fromLatLong(37.7749, -122.4194)

// Especificar valores en orden longitud, latitud
GeoPoint.fromLongLat(-122.4194, 37.7749)

// Crear desde un objeto con interfaz GeoPointInterface
GeoPoint.from(existingGeoPoint)

// Crear pasando valores directamente al constructor
GeoPoint(latitude = 37.7749, longitude = -122.4194, altitude = 100)

Ejemplos de uso

// Colocación básica de marcador
val sanFrancisco = GeoPoint.fromLatLong(37.7749, -122.4194)

// Reemplace MapViewContainer con GoogleMapView, MapboxMapView u otro SDK de mapa de su elección
MapViewContainer(state = mapViewState) {
    Marker(
        position = sanFrancisco,
        icon = ColorDefaultIcon(label = "SF")
    )
}

Sistema de coordenadas

Latitud

• Rango: -90.0 a 90.0 grados
• -90.0: Polo Sur
• 0.0: Ecuador
• 90.0: Polo Norte

Longitud

• Rango: -180.0 a 180.0 grados
• -180.0: Línea Internacional de Cambio de Fecha (lado oeste)
• 0.0: Meridiano de Greenwich
• 180.0: Línea Internacional de Cambio de Fecha (lado este)

Validación y normalización

Validación

La función de extensión isValid() verifica si las coordenadas de un GeoPointInterface están dentro de rangos válidos.

• Latitud: Dentro del rango -90.0 a 90.0
• Longitud: Dentro del rango -180.0 a 180.0

Devuelve true cuando se cumplen ambas condiciones.

// Ejemplo de uso
val point = GeoPoint.fromLatLong(37.7749, -122.4194)
if (point.isValid()) {
    // Usar el punto
}

Normalización

Hay dos métodos disponibles para mantener las coordenadas dentro de rangos válidos.

normalize()

La función de extensión normalize() ajusta las coordenadas a rangos válidos.

• Latitud: Limitada a -90.0 a 90.0
• Longitud: Normalizada a -180.0 a 180.0 (operación módulo)
• Altitud: Convertida a 0.0 si es null

fun GeoPointInterface.normalize(): GeoPoint

// Ejemplo de uso
val invalidPoint = GeoPoint.fromLatLong(100, 200) // Coordenadas inválidas
val validPoint = invalidPoint.normalize() // Ajustadas al rango válido

wrap()

El método wrap() envuelve apropiadamente las coordenadas que cruzan los polos.

• Cuando la latitud excede 90 grados: Se envuelve desde -90 grados, invierte la longitud 180 grados
• Cuando la latitud cae por debajo de -90 grados: Se envuelve desde 90 grados, invierte la longitud 180 grados
• Longitud: Normalizada a -180.0 a 180.0

// Ejemplo: Coordenadas más allá de los polos
val point = GeoPoint(95, 10) // La latitud excede 90 grados
val wrapped = point.wrap() // 緯度: -85.0, 経度: 190.0 → -170.0

La diferencia entre normalize() y wrap() está en cómo manejan el cruce de polos. normalize() simplemente limita los valores, mientras que wrap() calcula las coordenadas reales como si se cruzaran los polos en un globo.

Comparación

equals()

El método equals() de GeoPoint realiza comparaciones considerando errores de punto flotante.

• Tolerancia: 1e-7 (aproximadamente 0.00000001 grados, alrededor de 1.1cm)
• Objetivos de comparación: Latitud, longitud y altitud

val point1 = GeoPoint(37.7749, -122.4194, 100)
val point2 = GeoPoint(37.77490001, -122.41940001, 100.00000001)
val isEqual = point1 == point2 // true（dentro de la tolerancia）

Esta tolerancia permite que las comparaciones ignoren pequeñas diferencias de la aritmética de punto flotante.

Métodos de utilidad

toUrlValue()

El método toUrlValue() convierte latitud y longitud en una cadena URL.

• Formato: "latitud,longitud"
• Precisión: Por defecto 6 dígitos (aproximadamente 11cm), personalizable

val point = GeoPoint(37.7749, -122.4194)
val urlValue = point.toUrlValue() // "37.774900,-122.419400" - Precisión predeterminada (6 dígitos)
val urlValue3 = point.toUrlValue(precision = 3) // "37.775,-122.419" - Precisión personalizada (3 dígitos)

Puede usarse para parámetros de URL en servicios de mapas como Google Maps o Mapbox.