Pular para o conteúdo principal

DivideTiles - Processamento de Azulejos

Visão Geral​

A interface DivideTiles é utilizada para dividir cenas em azulejos antes da reconstrução. Esta interface suporta métodos de azulejamento de grade regular 2D, grade regular 3D e adaptativo baseado em memória, adequados para processar conjuntos de dados em larga escala.

Casos de Uso
  • Conjuntos de dados de ultra-larga escala (milhares de imagens)
  • Ambientes de processamento com memória limitada
  • Projetos que requerem processamento paralelo
  • Cenários de computação distribuída

Como Funciona​

Chamada da Interface​

Chamada de Linha de Comando​

# Método 1: Através do motor principal
reconstruct_full_engine.exe -reconstruct_type 4 -task_json divide_config.json

# Método 2: Motor de azulejamento independente
divide_engine.exe divide_config.json

Descrição dos Parâmetros​

  • reconstruct_type: Fixo como 4 (indica DivideTiles)
  • task_json: Caminho do arquivo de configuração

Parâmetros de Configuração​

Parâmetros Obrigatórios​

ParâmetroTipoDescrição
working_dirstringDiretório de trabalho (deve conter resultados AT)
gdal_folderstringCaminho dos dados GDAL
resolution_levelintPrecisão da reconstrução (1=Alto, 2=Médio, 3=Baixo)
divide_parametersJSONParâmetros de azulejamento
roi_for_3dJSONROI para reconstrução 3D

Parâmetros Opcionais​

ParâmetroTipoPadrãoDescrição
roi_coordinate_systemJSONWGS84Sistema de coordenadas ROI

Parâmetros de Azulejamento (divide_parameters)​

ParâmetroTipoPadrãoDescrição
divide_modeint-Modo de azulejamento: 0=grade 2D, 1=grade 3D, 2=adaptativo à memória
tile_sizedouble-Tamanho da grade (obrigatório para modo 0/1)
target_memorydouble0Limite de memória alvo (GB)
reconstruct_whole_tileboolfalseSe deve reconstruir azulejos completos (sem corte de fronteiras)
tile_systemJSONSistema de coordenadas ATSistema de coordenadas de azulejamento

Modos de Azulejamento Explicados​

1. Grade Regular 2D (divide_mode = 0)​

Adequado para áreas com pouca variação de terreno:

{
  "divide_mode": 0,
  "tile_size": 500.0,        // grade de 500m x 500m
  "tile_system": {
    "type": 3,
    "epsg_code": 32650       // Sistema de coordenadas de projeção UTM
  }
}

2. Grade Regular 3D (divide_mode = 1)​

Adequado para áreas com grandes mudanças de elevação:

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

3. Azulejamento Adaptativo à Memória (divide_mode = 2)​

Azulejamento automático baseado em limites de memória:

{
  "divide_mode": 2,
  "target_memory": 16.0,     // Máximo de 16GB de memória por azulejo
  "reconstruct_whole_tile": false
}

Exemplos de Configuração Completa​

Cena em Escala de Cidade Azulejamento 2D​

{
  "working_dir": "C:/Projects/CityScale",
  "gdal_folder": "C:/MipMap/SDK/data",
  "resolution_level": 2,
  "divide_parameters": {
    "divide_mode": 0,
    "tile_size": 1000.0,     // grade 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 Montanhoso Azulejamento 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           // Grande diferença de elevação
  }
}

Ambiente com Memória Limitada​

{
  "working_dir": "C:/Projects/LimitedMemory",
  "gdal_folder": "C:/MipMap/SDK/data",
  "resolution_level": 2,
  "divide_parameters": {
    "divide_mode": 2,
    "target_memory": 8.0,    // Apenas 8GB de memória disponível
    "reconstruct_whole_tile": false
  },
  "roi_for_3d": {
    "boundary": [...]
  }
}

Resultados de Saída​

Estrutura do Arquivo tiles.json​

O tiles.json gerado após o azulejamento:

{
  "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": {             // Informações da grade (modo 0/1)
    "origin": [500000, 2500000],
    "rows": 10,
    "cols": 10
  },
  "tile_size": 1000.0
}

Usando Resultados de Azulejamento​

Reconstruct3D lerá automaticamente tiles.json e executará reconstrução azulejada:

{
  "license_id": 9200,
  "working_dir": "C:/Projects/CityScale",  // Contém tiles.json
  // ... outros parâmetros Reconstruct3D
}

Seleção de Estratégia de Azulejamento​

Comparação por Tipo de Cena​

Tipo de CenaModo RecomendadoSugestão de Tamanho de GradeDescrição
Cidade PlanaGrade 2D500-2000mTerreno plano, pequenas mudanças de elevação
Terreno MontanhosoGrade 3D300-1000mGrandes diferenças de elevação, requer camadas verticais
Cena MistaAdaptativo à Memória-Otimizar automaticamente o esquema de azulejamento
Engenharia LinearGrade 2DPersonalizadoDefinir faixas alongadas ao longo da direção da rota

Estimativa de Memória​

Requisito de memória por azulejo ≈ (Imagens no azulejo × Resolução da imagem × 3) / Taxa de compressão

Valores de referência:

  • 100 imagens de 20MP ≈ 8-12 GB
  • 200 imagens de 20MP ≈ 16-24 GB

Processamento Paralelo​

Paralelo Local​

import subprocess
import json
import concurrent.futures

# Ler resultados de azulejamento
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"],
        # ... outros 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"
    ])

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

Processamento Distribuído​

Resultados de azulejamento podem ser distribuídos para múltiplas máquinas para processamento:

  1. Nó mestre executa azulejamento
  2. Distribuir tiles.json e dados
  3. Cada nó processa independentemente azulejos atribuídos
  4. Agregar resultados

Melhores Práticas​

1. Seleção de Tamanho de Azulejo​

  • Memória suficiente: Usar azulejos maiores para reduzir efeitos de fronteira
  • Memória limitada: Usar azulejos menores para garantir estabilidade
  • Processamento paralelo: Equilibrar número de azulejos e tempo de processamento por azulejo

2. Tratamento de Área de Sobreposição​

{
  "reconstruct_whole_tile": true,  // Gerar azulejos completos
  // Mesclar áreas de sobreposição no pós-processamento
}

3. Seleção de Sistema de Coordenadas​

  • Azulejamento 2D: Usar sistema de coordenadas projetadas (unidades métricas)
  • Azulejamento 3D: Local ou LocalENU
  • Evitar azulejamento 3D em sistemas de coordenadas geográficas

4. Otimização ROI​

{
  "roi_for_3d": {
    "boundary": [
      // Usar Smart ROI gerado do AT
      // Estender adequadamente fronteiras para evitar corte
    ]
  }
}

Otimização de Performance​

1. Estimativa de Tempo de Processamento​

Tempo total = Tempo de azulejamento + max(Tempo de processamento por azulejo) + Tempo de mesclagem

2. Balanceamento de Carga​

  • Verificar distribuição de max_memory
  • Ajustar parâmetros para equilibrar carga entre azulejos
  • Considerar alocação dinâmica de tarefas

3. Otimização de Armazenamento​

  • Usar SSD para diretório de trabalho
  • Distribuir resultados de azulejos em múltiplos discos
  • Reservar espaço temporário suficiente

Problemas Comuns​

P: Lacunas em fronteiras de azulejos após azulejamento?​

R:

  • Definir reconstruct_whole_tile: true
  • Aumentar sobreposição entre azulejos (estendendo ROI)
  • Otimizar mesclagem no pós-processamento

P: Alguns azulejos falham no processamento?​

R:

  • Verificar se max_memory do azulejo excede limites
  • Revisar distribuição de imagens em azulejos específicos
  • Considerar re-azulejamento ou ajuste de parâmetros

P: Muitos azulejos?​

R:

  • Aumentar tile_size ou target_memory
  • Usar modo de azulejamento diferente
  • Considerar estratégia de processamento hierárquico

Aplicações Avançadas​

Esquemas de Azulejamento Personalizados​

Baseado em tiles.json, você pode:

  1. Ajustar manualmente fronteiras de azulejos
  2. Mesclar azulejos pequenos
  3. Dividir azulejos grandes
  4. Definir prioridades

Atualizações Incrementais​

# Processar apenas áreas alteradas
changed_tiles = identify_changed_areas()
for tile in changed_tiles:
    process_tile(tile)

Próximos Passos​

Dica: Uma estratégia adequada de azulejamento é fundamental para processar dados em larga escala. É recomendado testar primeiro com dados pequenos para encontrar parâmetros ótimos antes de processar conjuntos de dados completos.