Saltar al contenido principal

DivideTiles - Procesamiento de Mosaicos

Descripción General​

La interfaz DivideTiles se utiliza para dividir escenas en mosaicos antes de la reconstrucción. Esta interfaz admite métodos de mosaicado de cuadrícula regular 2D, cuadrícula regular 3D y adaptativo basado en memoria, adecuados para procesar conjuntos de datos a gran escala.

Casos de Uso
  • Conjuntos de datos de ultra gran escala (miles de imágenes)
  • Entornos de procesamiento con memoria limitada
  • Proyectos que requieren procesamiento paralelo
  • Escenarios de computación distribuida

Cómo Funciona​

Llamada de Interfaz​

Llamada de Línea de Comandos​

# Método 1: A través del motor principal
reconstruct_full_engine.exe -reconstruct_type 4 -task_json divide_config.json

# Método 2: Motor de mosaicado independiente
divide_engine.exe divide_config.json

Descripción de Parámetros​

  • reconstruct_type: Fijo como 4 (indica DivideTiles)
  • task_json: Ruta del archivo de configuración

Parámetros de Configuración​

Parámetros Requeridos​

ParámetroTipoDescripción
working_dirstringDirectorio de trabajo (debe contener resultados AT)
gdal_folderstringRuta de datos GDAL
resolution_levelintPrecisión de reconstrucción (1=Alto, 2=Medio, 3=Bajo)
divide_parametersJSONParámetros de mosaicado
roi_for_3dJSONROI para reconstrucción 3D

Parámetros Opcionales​

ParámetroTipoPor DefectoDescripción
roi_coordinate_systemJSONWGS84Sistema de coordenadas ROI

Parámetros de Mosaicado (divide_parameters)​

ParámetroTipoPor DefectoDescripción
divide_modeint-Modo de mosaicado: 0=cuadrícula 2D, 1=cuadrícula 3D, 2=adaptativo a memoria
tile_sizedouble-Tamaño de cuadrícula (requerido para modo 0/1)
target_memorydouble0Límite de memoria objetivo (GB)
reconstruct_whole_tileboolfalseSi reconstruir mosaicos completos (sin recorte de límites)
tile_systemJSONSistema de coordenadas ATSistema de coordenadas de mosaicado

Modos de Mosaicado Explicados​

1. Cuadrícula Regular 2D (divide_mode = 0)​

Adecuado para áreas con poca variación del terreno:

{
  "divide_mode": 0,
  "tile_size": 500.0,        // cuadrícula de 500m x 500m
  "tile_system": {
    "type": 3,
    "epsg_code": 32650       // Sistema de coordenadas de proyección UTM
  }
}

2. Cuadrícula Regular 3D (divide_mode = 1)​

Adecuado para áreas con grandes cambios de elevación:

{
  "divide_mode": 1,
  "tile_size": 300.0,        // cubo de 300m x 300m x 300m
  "tile_system": {
    "type": 1                // Sistema de coordenadas local
  }
}

3. Mosaicado Adaptativo a Memoria (divide_mode = 2)​

Mosaicado automático basado en límites de memoria:

{
  "divide_mode": 2,
  "target_memory": 16.0,     // Máximo 16GB de memoria por mosaico
  "reconstruct_whole_tile": false
}

Ejemplos de Configuración Completa​

Escena a Escala de Ciudad Mosaicado 2D​

{
  "working_dir": "C:/Projects/CityScale",
  "gdal_folder": "C:/MipMap/SDK/data",
  "resolution_level": 2,
  "divide_parameters": {
    "divide_mode": 0,
    "tile_size": 1000.0,     // cuadrícula de 1km
    "tile_system": {
      "type": 3,
      "epsg_code": 32650
    },
    "reconstruct_whole_tile": true
  },
  "roi_for_3d": {
    "boundary": [
      [500000, 2500000],
      [510000, 2500000],
      [510000, 2510000],
      [500000, 2510000]
    ],
    "min_z": 0,
    "max_z": 500
  },
  "roi_coordinate_system": {
    "type": 3,
    "epsg_code": 32650
  }
}

Terreno Montañoso Mosaicado 3D​

{
  "working_dir": "C:/Projects/Mountain",
  "gdal_folder": "C:/MipMap/SDK/data",
  "resolution_level": 2,
  "divide_parameters": {
    "divide_mode": 1,
    "tile_size": 500.0,      // cubo de 500m
    "tile_system": {
      "type": 0,             // LocalENU
      "origin_point": [114.123, 22.123, 100.0]
    }
  },
  "roi_for_3d": {
    "boundary": [...],
    "min_z": 100,
    "max_z": 2000           // Gran diferencia de elevación
  }
}

Entorno con Memoria Limitada​

{
  "working_dir": "C:/Projects/LimitedMemory",
  "gdal_folder": "C:/MipMap/SDK/data",
  "resolution_level": 2,
  "divide_parameters": {
    "divide_mode": 2,
    "target_memory": 8.0,    // Solo 8GB de memoria disponible
    "reconstruct_whole_tile": false
  },
  "roi_for_3d": {
    "boundary": [...]
  }
}

Resultados de Salida​

Estructura del Archivo tiles.json​

El tiles.json generado después del mosaicado:

{
  "tiles": [
    {
      "name": "tile_0_0",
      "empty": false,
      "max_memory": 12.5,    // GB
      "roi": {
        "boundary": [...],
        "min_z": 100,
        "max_z": 200
      }
    },
    {
      "name": "tile_0_1",
      "empty": false,
      "max_memory": 15.3,
      "roi": {...}
    }
  ],
  "divide_mode": 0,
  "tile_system": {...},
  "tile_grid": {             // Información de cuadrícula (modo 0/1)
    "origin": [500000, 2500000],
    "rows": 10,
    "cols": 10
  },
  "tile_size": 1000.0
}

Uso de Resultados de Mosaicado​

Reconstruct3D leerá automáticamente tiles.json y realizará reconstrucción en mosaicos:

{
  "license_id": 9200,
  "working_dir": "C:/Projects/CityScale",  // Contiene tiles.json
  // ... otros parámetros de Reconstruct3D
}

Selección de Estrategia de Mosaicado​

Comparación por Tipo de Escena​

Tipo de EscenaModo RecomendadoSugerencia de Tamaño de CuadrículaDescripción
Ciudad PlanaCuadrícula 2D500-2000mTerreno plano, pequeños cambios de elevación
Terreno MontañosoCuadrícula 3D300-1000mGrandes diferencias de elevación, requiere capas verticales
Escena MixtaAdaptativo a Memoria-Optimizar automáticamente esquema de mosaicado
Ingeniería LinealCuadrícula 2DPersonalizadoEstablecer tiras alargadas a lo largo de la dirección de ruta

Estimación de Memoria​

Requerimiento de memoria por mosaico ≈ (Imágenes en mosaico × Resolución de imagen × 3) / Ratio de compresión

Valores de referencia:

  • 100 imágenes de 20MP ≈ 8-12 GB
  • 200 imágenes de 20MP ≈ 16-24 GB

Procesamiento Paralelo​

Paralelo Local​

import subprocess
import json
import concurrent.futures

# Leer resultados de mosaicado
with open("tiles.json", "r") as f:
    tiles_info = json.load(f)

def process_tile(tile):
    if tile["empty"]:
        return
    
    config = {
        "license_id": 9200,
        "working_dir": f"./output/{tile['name']}",
        "tile_name": tile["name"],
        # ... otros parámetros
    }
    
    with open(f"{tile['name']}.json", "w") as f:
        json.dump(config, f)
    
    subprocess.run([
        "reconstruct_full_engine.exe",
        "-reconstruct_type", "2",
        "-task_json", f"{tile['name']}.json"
    ])

# Procesamiento paralelo
with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
    executor.map(process_tile, tiles_info["tiles"])

Procesamiento Distribuido​

Los resultados de mosaicado pueden distribuirse a múltiples máquinas para procesamiento:

  1. El nodo maestro realiza el mosaicado
  2. Distribuir tiles.json y datos
  3. Cada nodo procesa independientemente los mosaicos asignados
  4. Agregar resultados

Mejores Prácticas​

1. Selección de Tamaño de Mosaico​

  • Memoria suficiente: Usar mosaicos más grandes para reducir efectos de borde
  • Memoria limitada: Usar mosaicos más pequeños para asegurar estabilidad
  • Procesamiento paralelo: Equilibrar número de mosaicos y tiempo de procesamiento por mosaico

2. Manejo de Área de Superposición​

{
  "reconstruct_whole_tile": true,  // Generar mosaicos completos
  // Fusionar áreas de superposición en post-procesamiento
}

3. Selección de Sistema de Coordenadas​

  • Mosaicado 2D: Usar sistema de coordenadas proyectadas (unidades métricas)
  • Mosaicado 3D: Local o LocalENU
  • Evitar mosaicado 3D en sistemas de coordenadas geográficas

4. Optimización ROI​

{
  "roi_for_3d": {
    "boundary": [
      // Usar Smart ROI generado desde AT
      // Extender límites apropiadamente para evitar recorte
    ]
  }
}

Optimización de Rendimiento​

1. Estimación de Tiempo de Procesamiento​

Tiempo total = Tiempo de mosaicado + max(Tiempo de procesamiento por mosaico) + Tiempo de fusión

2. Equilibrio de Carga​

  • Verificar distribución de max_memory
  • Ajustar parámetros para equilibrar carga entre mosaicos
  • Considerar asignación dinámica de tareas

3. Optimización de Almacenamiento​

  • Usar SSD para directorio de trabajo
  • Distribuir resultados de mosaicos entre múltiples discos
  • Reservar espacio temporal suficiente

Problemas Comunes​

P: ¿Espacios en límites de mosaicos después del mosaicado?​

R:

  • Establecer reconstruct_whole_tile: true
  • Aumentar superposición entre mosaicos (extendiendo ROI)
  • Optimizar fusión en post-procesamiento

P: ¿Algunos mosaicos fallan al procesar?​

R:

  • Verificar si max_memory del mosaico excede límites
  • Revisar distribución de imágenes en mosaicos específicos
  • Considerar re-mosaicado o ajuste de parámetros

P: ¿Demasiados mosaicos?​

R:

  • Aumentar tile_size o target_memory
  • Usar modo de mosaicado diferente
  • Considerar estrategia de procesamiento jerárquico

Aplicaciones Avanzadas​

Esquemas de Mosaicado Personalizados​

Basado en tiles.json, puedes:

  1. Ajustar manualmente límites de mosaicos
  2. Fusionar mosaicos pequeños
  3. Dividir mosaicos grandes
  4. Establecer prioridades

Actualizaciones Incrementales​

# Procesar solo áreas cambiadas
changed_tiles = identify_changed_areas()
for tile in changed_tiles:
    process_tile(tile)

Próximos Pasos​

Consejo: Una estrategia de mosaicado adecuada es clave para procesar datos a gran escala. Se recomienda probar primero con datos pequeños para encontrar parámetros óptimos antes de procesar conjuntos de datos completos.