DivideTiles - Elaborazione Piastrelle

Panoramica

L'interfaccia DivideTiles viene utilizzata per dividere le scene in piastrelle prima della ricostruzione. Questa interfaccia supporta metodi di piastrellatura griglia regolare 2D, griglia regolare 3D e adattiva basata sulla memoria, adatti per l'elaborazione di set di dati su larga scala.

Casi d'Uso

• Set di dati ultra-larga scala (migliaia di immagini)
• Ambienti di elaborazione con memoria limitata
• Progetti che richiedono elaborazione parallela
• Scenari di calcolo distribuito

Come Funziona

Chiamata Interfaccia

Chiamata Riga di Comando

# Metodo 1: Tramite motore principale
reconstruct_full_engine.exe -reconstruct_type 4 -task_json divide_config.json

# Metodo 2: Motore di piastrellatura autonomo
divide_engine.exe divide_config.json

Descrizione Parametri

• reconstruct_type: Fisso come 4 (indica DivideTiles)
• task_json: Percorso file di configurazione

Parametri di Configurazione

Parametri Richiesti

Parametro	Tipo	Descrizione
working_dir	string	Directory di lavoro (deve contenere risultati AT)
gdal_folder	string	Percorso dati GDAL
resolution_level	int	Precisione ricostruzione (1=Alto, 2=Medio, 3=Basso)
divide_parameters	JSON	Parametri piastrellatura
roi_for_3d	JSON	ROI per ricostruzione 3D

Parametri Opzionali

Parametro	Tipo	Predefinito	Descrizione
roi_coordinate_system	JSON	WGS84	Sistema coordinate ROI

Parametri Piastrellatura (divide_parameters)

Parametro	Tipo	Predefinito	Descrizione
divide_mode	int	-	Modalità piastrellatura: 0=griglia 2D, 1=griglia 3D, 2=adattivo memoria
tile_size	double	-	Dimensione griglia (richiesto per modalità 0/1)
target_memory	double	0	Limite memoria target (GB)
reconstruct_whole_tile	bool	false	Se ricostruire piastrelle complete (nessun taglio bordi)
tile_system	JSON	Sistema coordinate AT	Sistema coordinate piastrellatura

Modalità Piastrellatura Spiegate

1. Griglia Regolare 2D (divide_mode = 0)

Adatta per aree con poca variazione del terreno:

{
  "divide_mode": 0,
  "tile_size": 500.0,        // griglia 500m x 500m
  "tile_system": {
    "type": 3,
    "epsg_code": 32650       // Sistema coordinate proiezione UTM
  }
}

2. Griglia Regolare 3D (divide_mode = 1)

Adatta per aree con grandi cambiamenti di elevazione:

{
  "divide_mode": 1,
  "tile_size": 300.0,        // cubo 300m x 300m x 300m
  "tile_system": {
    "type": 1                // Sistema coordinate locale
  }
}

3. Piastrellatura Adattiva Memoria (divide_mode = 2)

Piastrellatura automatica basata sui limiti di memoria:

{
  "divide_mode": 2,
  "target_memory": 16.0,     // Massimo 16GB memoria per piastrella
  "reconstruct_whole_tile": false
}

Esempi Configurazione Completa

Scena Scala Città Piastrellatura 2D

{
  "working_dir": "C:/Projects/CityScale",
  "gdal_folder": "C:/MipMap/SDK/data",
  "resolution_level": 2,
  "divide_parameters": {
    "divide_mode": 0,
    "tile_size": 1000.0,     // griglia 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 Montano Piastrellatura 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 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 differenza elevazione
  }
}

Ambiente Memoria Limitata

{
  "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 memoria disponibile
    "reconstruct_whole_tile": false
  },
  "roi_for_3d": {
    "boundary": [...]
  }
}

Risultati Output

Struttura File tiles.json

Il tiles.json generato dopo la piastrellatura:

{
  "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": {             // Informazioni griglia (modalità 0/1)
    "origin": [500000, 2500000],
    "rows": 10,
    "cols": 10
  },
  "tile_size": 1000.0
}

Utilizzo Risultati Piastrellatura

Reconstruct3D leggerà automaticamente tiles.json e eseguirà ricostruzione piastrellata:

{
  "license_id": 9200,
  "working_dir": "C:/Projects/CityScale",  // Contiene tiles.json
  // ... altri parametri Reconstruct3D
}

Selezione Strategia Piastrellatura

Confronto Tipo Scena

Tipo Scena	Modalità Raccomandata	Suggerimento Dimensione Griglia	Descrizione
Città Piatta	Griglia 2D	500-2000m	Terreno piatto, piccoli cambiamenti elevazione
Terreno Montano	Griglia 3D	300-1000m	Grandi differenze elevazione, richiede stratificazione verticale
Scena Mista	Adattivo Memoria	-	Ottimizzare automaticamente schema piastrellatura
Ingegneria Lineare	Griglia 2D	Personalizzato	Impostare strisce allungate lungo direzione percorso

Stima Memoria

Requisito memoria per piastrella ≈ (Immagini in piastrella × Risoluzione immagine × 3) / Rapporto compressione

Valori di riferimento:

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

Elaborazione Parallela

Parallela Locale

import subprocess
import json
import concurrent.futures

# Leggere risultati piastrellatura
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"],
        # ... altri parametri
    }
    
    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"
    ])

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

Elaborazione Distribuita

I risultati di piastrellatura possono essere distribuiti su più macchine per l'elaborazione:

1. Il nodo master esegue la piastrellatura
2. Distribuire tiles.json e dati
3. Ogni nodo elabora indipendentemente le piastrelle assegnate
4. Aggregare risultati

Migliori Pratiche

1. Selezione Dimensione Piastrella

• Memoria sufficiente: Usare piastrelle più grandi per ridurre effetti bordo
• Memoria limitata: Usare piastrelle più piccole per garantire stabilità
• Elaborazione parallela: Bilanciare numero piastrelle e tempo elaborazione per piastrella

2. Gestione Area Sovrapposizione

{
  "reconstruct_whole_tile": true,  // Generare piastrelle complete
  // Unire aree sovrapposizione in post-elaborazione
}

3. Selezione Sistema Coordinate

• Piastrellatura 2D: Usare sistema coordinate proiettate (unità metriche)
• Piastrellatura 3D: Locale o LocalENU
• Evitare piastrellatura 3D in sistemi coordinate geografiche

4. Ottimizzazione ROI

{
  "roi_for_3d": {
    "boundary": [
      // Usare Smart ROI generato da AT
      // Estendere appropriatamente i confini per evitare taglio
    ]
  }
}

Ottimizzazione Prestazioni

1. Stima Tempo Elaborazione

Tempo totale = Tempo piastrellatura + max(Tempo elaborazione per piastrella) + Tempo unione

2. Bilanciamento Carico

• Controllare distribuzione max_memory
• Regolare parametri per bilanciare carico tra piastrelle
• Considerare allocazione dinamica attività

3. Ottimizzazione Archiviazione

• Usare SSD per directory lavoro
• Distribuire risultati piastrelle su più dischi
• Riservare spazio temporaneo sufficiente

Problemi Comuni

D: Spazi vuoti ai confini piastrelle dopo piastrellatura?

R:

• Impostare reconstruct_whole_tile: true
• Aumentare sovrapposizione tra piastrelle (estendendo ROI)
• Ottimizzare unione in post-elaborazione

D: Alcune piastrelle falliscono nell'elaborazione?

R:

• Controllare se max_memory piastrella supera limiti
• Rivedere distribuzione immagini in piastrelle specifiche
• Considerare ri-piastrellatura o regolazione parametri

D: Troppe piastrelle?

R:

• Aumentare tile_size o target_memory
• Usare modalità piastrellatura diversa
• Considerare strategia elaborazione gerarchica

Applicazioni Avanzate

Schemi Piastrellatura Personalizzati

Basato su tiles.json, puoi:

1. Regolare manualmente confini piastrelle
2. Unire piastrelle piccole
3. Dividere piastrelle grandi
4. Impostare priorità

Aggiornamenti Incrementali

# Elaborare solo aree cambiate
changed_tiles = identify_changed_areas()
for tile in changed_tiles:
    process_tile(tile)

Prossimi Passi

• Impara su Reconstruct3D per ricostruzione piastrellata
• Controlla Concetti Base per più tecniche elaborazione

---

Suggerimento: Una strategia di piastrellatura appropriata è la chiave per elaborare dati su larga scala. Si raccomanda di testare prima con dati piccoli per trovare parametri ottimali prima di elaborare set di dati completi.