DivideTiles - Kachelverarbeitung

Überblick

Die DivideTiles-Schnittstelle wird verwendet, um Szenen vor der Rekonstruktion in Kacheln zu unterteilen. Diese Schnittstelle unterstützt 2D-reguläre Raster-, 3D-reguläre Raster- und speicherbasierte adaptive Kachelverfahren, geeignet für die Verarbeitung großskaliger Datensätze.

Anwendungsfälle

Ultra-großskalige Datensätze (Tausende von Bildern)
Speicherbegrenzte Verarbeitungsumgebungen
Projekte, die parallele Verarbeitung erfordern
Verteilte Computing-Szenarien

Funktionsweise

Schnittstellenaufruf

Kommandozeilenaufruf

# Methode 1: Über Hauptmotor
reconstruct_full_engine.exe -reconstruct_type 4 -task_json divide_config.json

# Methode 2: Eigenständiger Kachelmotor
divide_engine.exe divide_config.json

Parameterbeschreibung

reconstruct_type: Fest als 4 (zeigt DivideTiles an)
task_json: Konfigurationsdateipfad

Konfigurationsparameter

Erforderliche Parameter

Parameter	Typ	Beschreibung
`working_dir`	string	Arbeitsverzeichnis (muss AT-Ergebnisse enthalten)
`gdal_folder`	string	GDAL-Datenpfad
`resolution_level`	int	Rekonstruktionspräzision (1=Hoch, 2=Mittel, 3=Niedrig)
`divide_parameters`	JSON	Kachelparameter
`roi_for_3d`	JSON	ROI für 3D-Rekonstruktion

Optionale Parameter

Parameter	Typ	Standard	Beschreibung
`roi_coordinate_system`	JSON	WGS84	ROI-Koordinatensystem

Kachelparameter (divide_parameters)

Parameter	Typ	Standard	Beschreibung
`divide_mode`	int	-	Kachelmodus: 0=2D-Raster, 1=3D-Raster, 2=speicheradaptiv
`tile_size`	double	-	Rastergröße (erforderlich für Modus 0/1)
`target_memory`	double	0	Zielspeicherlimit (GB)
`reconstruct_whole_tile`	bool	false	Ob komplette Kacheln rekonstruiert werden sollen (kein Grenzschnitt)
`tile_system`	JSON	AT-Koordinatensystem	Kachel-Koordinatensystem

Kachelmodi erklärt

1. 2D-reguläres Raster (divide_mode = 0)

Geeignet für Gebiete mit geringen Geländeunterschieden:

{
  "divide_mode": 0,
  "tile_size": 500.0,        // 500m x 500m Raster
  "tile_system": {
    "type": 3,
    "epsg_code": 32650       // UTM-Projektionskoordinatensystem
  }
}

2. 3D-reguläres Raster (divide_mode = 1)

Geeignet für Gebiete mit großen Höhenunterschieden:

{
  "divide_mode": 1,
  "tile_size": 300.0,        // 300m x 300m x 300m Würfel
  "tile_system": {
    "type": 1                // Lokales Koordinatensystem
  }
}

3. Speicheradaptive Kachelung (divide_mode = 2)

Automatische Kachelung basierend auf Speicherlimits:

{
  "divide_mode": 2,
  "target_memory": 16.0,     // Maximal 16GB Speicher pro Kachel
  "reconstruct_whole_tile": false
}

Vollständige Konfigurationsbeispiele

Stadtweite Szene 2D-Kachelung

{
  "working_dir": "C:/Projects/CityScale",
  "gdal_folder": "C:/MipMap/SDK/data",
  "resolution_level": 2,
  "divide_parameters": {
    "divide_mode": 0,
    "tile_size": 1000.0,     // 1km Raster
    "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
  }
}

Berggelände 3D-Kachelung

{
  "working_dir": "C:/Projects/Mountain",
  "gdal_folder": "C:/MipMap/SDK/data",
  "resolution_level": 2,
  "divide_parameters": {
    "divide_mode": 1,
    "tile_size": 500.0,      // 500m Würfel
    "tile_system": {
      "type": 0,             // LocalENU
      "origin_point": [114.123, 22.123, 100.0]
    }
  },
  "roi_for_3d": {
    "boundary": [...],
    "min_z": 100,
    "max_z": 2000           // Großer Höhenunterschied
  }
}

Speicherbegrenzte Umgebung

{
  "working_dir": "C:/Projects/LimitedMemory",
  "gdal_folder": "C:/MipMap/SDK/data",
  "resolution_level": 2,
  "divide_parameters": {
    "divide_mode": 2,
    "target_memory": 8.0,    // Nur 8GB verfügbarer Speicher
    "reconstruct_whole_tile": false
  },
  "roi_for_3d": {
    "boundary": [...]
  }
}

Ausgabeergebnisse

tiles.json Dateistruktur

Die generierte tiles.json nach der Kachelung:

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

Verwendung der Kachelergebnisse

Reconstruct3D liest automatisch tiles.json und führt gekachelte Rekonstruktion durch:

{
  "license_id": 9200,
  "working_dir": "C:/Projects/CityScale",  // Enthält tiles.json
  // ... andere Reconstruct3D-Parameter
}

Auswahl der Kachelstrategie

Szenentyp-Vergleich

Szenentyp	Empfohlener Modus	Rastergröße-Vorschlag	Beschreibung
Flache Stadt	2D-Raster	500-2000m	Flaches Gelände, kleine Höhenunterschiede
Berggelände	3D-Raster	300-1000m	Große Höhenunterschiede, erfordert vertikale Schichtung
Gemischte Szene	Speicheradaptiv	-	Automatische Optimierung des Kachelschemas
Lineare Technik	2D-Raster	Benutzerdefiniert	Längliche Streifen entlang der Routenrichtung setzen

Speicherschätzung

Speicherbedarf pro Kachel ≈ (Bilder in Kachel × Bildauflösung × 3) / Komprimierungsverhältnis

Referenzwerte:

100 20MP-Bilder ≈ 8-12 GB
200 20MP-Bilder ≈ 16-24 GB

Parallele Verarbeitung

Lokale Parallelität

import subprocess
import json
import concurrent.futures

# Kachelergebnisse lesen
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"],
        # ... andere Parameter
    }
    
    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"
    ])

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

Verteilte Verarbeitung

Kachelergebnisse können zur Verarbeitung auf mehrere Maschinen verteilt werden:

Master-Knoten führt Kachelung durch
Verteile tiles.json und Daten
Jeder Knoten verarbeitet zugewiesene Kacheln unabhängig
Ergebnisse aggregieren

Bewährte Praktiken

1. Kachelgrößenauswahl

Ausreichender Speicher: Verwende größere Kacheln zur Reduzierung von Grenzeffekten
Begrenzter Speicher: Verwende kleinere Kacheln zur Stabilitätsgewährleistung
Parallele Verarbeitung: Balance zwischen Kachelanzahl und Verarbeitungszeit pro Kachel

2. Überlappungsbereich-Behandlung

{
  "reconstruct_whole_tile": true,  // Komplette Kacheln generieren
  // Überlappungsbereiche in Nachbearbeitung zusammenführen
}

3. Koordinatensystemauswahl

2D-Kachelung: Verwende projiziertes Koordinatensystem (metrische Einheiten)
3D-Kachelung: Lokal oder LocalENU
Vermeide 3D-Kachelung in geografischen Koordinatensystemen

4. ROI-Optimierung

{
  "roi_for_3d": {
    "boundary": [
      // Verwende Smart ROI generiert von AT
      // Grenzen ordnungsgemäß erweitern um Abschneiden zu vermeiden
    ]
  }
}

Leistungsoptimierung

1. Verarbeitungszeit-Schätzung

Gesamtzeit = Kachelzeit + max(Verarbeitungszeit pro Kachel) + Zusammenführungszeit

2. Lastausgleich

max_memory-Verteilung prüfen
Parameter anpassen um Last über Kacheln auszugleichen
Dynamische Aufgabenzuteilung berücksichtigen

3. Speicheroptimierung

Verwende SSD für Arbeitsverzeichnis
Verteile Kachelergebnisse über mehrere Festplatten
Reserviere ausreichenden temporären Speicherplatz

Häufige Probleme

F: Lücken an Kachelgrenzen nach Kachelung?

Setze reconstruct_whole_tile: true
Erhöhe Überlappung zwischen Kacheln (durch ROI-Erweiterung)
Optimiere Zusammenführung in Nachbearbeitung

F: Einige Kacheln verarbeiten nicht?

Prüfe ob Kachel-max_memory Limits überschreitet
Überprüfe Bildverteilung in spezifischen Kacheln
Erwäge Neu-Kachelung oder Parameteranpassung

F: Zu viele Kacheln?

Erhöhe tile_size oder target_memory
Verwende anderen Kachelmodus
Erwäge hierarchische Verarbeitungsstrategie

Erweiterte Anwendungen

Benutzerdefinierte Kachelschemas

Basierend auf tiles.json kannst du:

Kachelgrenzen manuell anpassen
Kleine Kacheln zusammenführen
Große Kacheln aufteilen
Prioritäten setzen

Inkrementelle Updates

# Nur geänderte Bereiche verarbeiten
changed_tiles = identify_changed_areas()
for tile in changed_tiles:
    process_tile(tile)

Nächste Schritte

Lerne über Reconstruct3D für gekachelte Rekonstruktion
Prüfe Grundkonzepte für weitere Verarbeitungstechniken

Tipp: Eine ordnungsgemäße Kachelstrategie ist der Schlüssel zur Verarbeitung großskaliger Daten. Es wird empfohlen, zuerst mit kleinen Daten zu testen, um optimale Parameter zu finden, bevor komplette Datensätze verarbeitet werden.

Überblick​

Funktionsweise​

Schnittstellenaufruf​

Kommandozeilenaufruf​

Parameterbeschreibung​

Konfigurationsparameter​

Erforderliche Parameter​

Optionale Parameter​

Kachelparameter (divide_parameters)​

Kachelmodi erklärt​

1. 2D-reguläres Raster (divide_mode = 0)​

2. 3D-reguläres Raster (divide_mode = 1)​

3. Speicheradaptive Kachelung (divide_mode = 2)​

Vollständige Konfigurationsbeispiele​

Stadtweite Szene 2D-Kachelung​

Berggelände 3D-Kachelung​

Speicherbegrenzte Umgebung​

Ausgabeergebnisse​

tiles.json Dateistruktur​

Verwendung der Kachelergebnisse​

Auswahl der Kachelstrategie​

Szenentyp-Vergleich​

Speicherschätzung​

Parallele Verarbeitung​

Lokale Parallelität​

Verteilte Verarbeitung​

Bewährte Praktiken​

1. Kachelgrößenauswahl​

2. Überlappungsbereich-Behandlung​

3. Koordinatensystemauswahl​

4. ROI-Optimierung​

Leistungsoptimierung​

1. Verarbeitungszeit-Schätzung​

2. Lastausgleich​

3. Speicheroptimierung​

Häufige Probleme​

F: Lücken an Kachelgrenzen nach Kachelung?​

F: Einige Kacheln verarbeiten nicht?​

F: Zu viele Kacheln?​

Erweiterte Anwendungen​

Benutzerdefinierte Kachelschemas​

Inkrementelle Updates​

Nächste Schritte​