Aller au contenu principal

DivideTiles - Traitement des Tuiles

Aperçu​

L'interface DivideTiles est utilisée pour diviser les scènes en tuiles avant la reconstruction. Cette interface prend en charge les méthodes de pavage en grille régulière 2D, grille régulière 3D et adaptative basée sur la mémoire, adaptées au traitement d'ensembles de données à grande échelle.

Cas d'Usage
  • Ensembles de données ultra-grande échelle (milliers d'images)
  • Environnements de traitement à mémoire limitée
  • Projets nécessitant un traitement parallèle
  • Scénarios de calcul distribué

Comment ça Fonctionne​

Appel d'Interface​

Appel en Ligne de Commande​

# Méthode 1 : Via le moteur principal
reconstruct_full_engine.exe -reconstruct_type 4 -task_json divide_config.json

# Méthode 2 : Moteur de pavage autonome
divide_engine.exe divide_config.json

Description des Paramètres​

  • reconstruct_type : Fixé à 4 (indique DivideTiles)
  • task_json : Chemin du fichier de configuration

Paramètres de Configuration​

Paramètres Requis​

ParamètreTypeDescription
working_dirstringRépertoire de travail (doit contenir les résultats AT)
gdal_folderstringChemin des données GDAL
resolution_levelintPrécision de reconstruction (1=Élevé, 2=Moyen, 3=Faible)
divide_parametersJSONParamètres de pavage
roi_for_3dJSONROI pour la reconstruction 3D

Paramètres Optionnels​

ParamètreTypePar DéfautDescription
roi_coordinate_systemJSONWGS84Système de coordonnées ROI

Paramètres de Pavage (divide_parameters)​

ParamètreTypePar DéfautDescription
divide_modeint-Mode de pavage : 0=grille 2D, 1=grille 3D, 2=adaptatif mémoire
tile_sizedouble-Taille de grille (requis pour mode 0/1)
target_memorydouble0Limite de mémoire cible (GB)
reconstruct_whole_tileboolfalseSi reconstruire des tuiles complètes (pas de découpage de frontières)
tile_systemJSONSystème de coordonnées ATSystème de coordonnées de pavage

Modes de Pavage Expliqués​

1. Grille Régulière 2D (divide_mode = 0)​

Adapté aux zones avec peu de variation de terrain :

{
  "divide_mode": 0,
  "tile_size": 500.0,        // grille de 500m x 500m
  "tile_system": {
    "type": 3,
    "epsg_code": 32650       // Système de coordonnées de projection UTM
  }
}

2. Grille Régulière 3D (divide_mode = 1)​

Adapté aux zones avec de grands changements d'élévation :

{
  "divide_mode": 1,
  "tile_size": 300.0,        // cube de 300m x 300m x 300m
  "tile_system": {
    "type": 1                // Système de coordonnées local
  }
}

3. Pavage Adaptatif Mémoire (divide_mode = 2)​

Pavage automatique basé sur les limites de mémoire :

{
  "divide_mode": 2,
  "target_memory": 16.0,     // Maximum 16GB de mémoire par tuile
  "reconstruct_whole_tile": false
}

Exemples de Configuration Complète​

Scène à l'Échelle de la Ville Pavage 2D​

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

Terrain Montagneux Pavage 3D​

{
  "working_dir": "C:/Projects/Mountain",
  "gdal_folder": "C:/MipMap/SDK/data",
  "resolution_level": 2,
  "divide_parameters": {
    "divide_mode": 1,
    "tile_size": 500.0,      // cube 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 différence d'élévation
  }
}

Environnement à Mémoire Limitée​

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

Résultats de Sortie​

Structure du Fichier tiles.json​

Le tiles.json généré après le pavage :

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

Utilisation des Résultats de Pavage​

Reconstruct3D lira automatiquement tiles.json et effectuera une reconstruction pavée :

{
  "license_id": 9200,
  "working_dir": "C:/Projects/CityScale",  // Contient tiles.json
  // ... autres paramètres Reconstruct3D
}

Sélection de Stratégie de Pavage​

Comparaison par Type de Scène​

Type de ScèneMode RecommandéSuggestion de Taille de GrilleDescription
Ville PlateGrille 2D500-2000mTerrain plat, petits changements d'élévation
Terrain MontagneuxGrille 3D300-1000mGrandes différences d'élévation, nécessite des couches verticales
Scène MixteAdaptatif Mémoire-Optimiser automatiquement le schéma de pavage
Ingénierie LinéaireGrille 2DPersonnaliséDéfinir des bandes allongées le long de la direction de route

Estimation de Mémoire​

Besoin en mémoire par tuile ≈ (Images dans la tuile × Résolution image × 3) / Ratio de compression

Valeurs de référence :

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

Traitement Parallèle​

Parallèle Local​

import subprocess
import json
import concurrent.futures

# Lire les résultats de pavage
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"],
        # ... autres paramètres
    }
    
    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"
    ])

# Traitement parallèle
with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
    executor.map(process_tile, tiles_info["tiles"])

Traitement Distribué​

Les résultats de pavage peuvent être distribués sur plusieurs machines pour traitement :

  1. Le nœud maître effectue le pavage
  2. Distribuer tiles.json et les données
  3. Chaque nœud traite indépendamment les tuiles assignées
  4. Agréger les résultats

Meilleures Pratiques​

1. Sélection de Taille de Tuile​

  • Mémoire suffisante : Utiliser des tuiles plus grandes pour réduire les effets de bord
  • Mémoire limitée : Utiliser des tuiles plus petites pour assurer la stabilité
  • Traitement parallèle : Équilibrer le nombre de tuiles et le temps de traitement par tuile

2. Gestion de Zone de Chevauchement​

{
  "reconstruct_whole_tile": true,  // Générer des tuiles complètes
  // Fusionner les zones de chevauchement en post-traitement
}

3. Sélection de Système de Coordonnées​

  • Pavage 2D : Utiliser un système de coordonnées projetées (unités métriques)
  • Pavage 3D : Local ou LocalENU
  • Éviter le pavage 3D dans les systèmes de coordonnées géographiques

4. Optimisation ROI​

{
  "roi_for_3d": {
    "boundary": [
      // Utiliser Smart ROI généré depuis AT
      // Étendre correctement les frontières pour éviter le découpage
    ]
  }
}

Optimisation des Performances​

1. Estimation du Temps de Traitement​

Temps total = Temps de pavage + max(Temps de traitement par tuile) + Temps de fusion

2. Équilibrage de Charge​

  • Vérifier la distribution de max_memory
  • Ajuster les paramètres pour équilibrer la charge entre les tuiles
  • Considérer l'allocation dynamique de tâches

3. Optimisation de Stockage​

  • Utiliser SSD pour le répertoire de travail
  • Distribuer les résultats de tuiles sur plusieurs disques
  • Réserver un espace temporaire suffisant

Problèmes Courants​

Q : Espaces aux frontières de tuiles après pavage ?​

R :

  • Définir reconstruct_whole_tile: true
  • Augmenter le chevauchement entre tuiles (en étendant ROI)
  • Optimiser la fusion en post-traitement

Q : Certaines tuiles échouent au traitement ?​

R :

  • Vérifier si la max_memory de la tuile dépasse les limites
  • Réviser la distribution d'images dans des tuiles spécifiques
  • Considérer un re-pavage ou ajustement des paramètres

Q : Trop de tuiles ?​

R :

  • Augmenter tile_size ou target_memory
  • Utiliser un mode de pavage différent
  • Considérer une stratégie de traitement hiérarchique

Applications Avancées​

Schémas de Pavage Personnalisés​

Basé sur tiles.json, vous pouvez :

  1. Ajuster manuellement les frontières de tuiles
  2. Fusionner les petites tuiles
  3. Diviser les grandes tuiles
  4. Définir les priorités

Mises à Jour Incrémentales​

# Traiter seulement les zones modifiées
changed_tiles = identify_changed_areas()
for tile in changed_tiles:
    process_tile(tile)

Prochaines Étapes​

Conseil : Une stratégie de pavage appropriée est la clé du traitement de données à grande échelle. Il est recommandé de tester d'abord avec de petites données pour trouver des paramètres optimaux avant de traiter des ensembles de données complets.