Examples and Tutorials

Complete collection of practical examples to learn and master IGN LiDAR HD.

🚀 Quick Start

Basic Example

# example_basic.py - First simple example
from ign_lidar import Processor

# Initialization
processor = Processor(verbose=True)

# Process a file
result = processor.process_tile(
    input_path="sample.las",
    output_path="enriched.las"
)

print(f"Processed {result['points_count']} points")
print(f"Detected classes: {result['classes_found']}")

Batch Processing

# example_batch.py - Process multiple files
from ign_lidar import BatchProcessor

batch = BatchProcessor(
    n_jobs=4,  # 4 parallel processes
    verbose=True
)

# Process a directory
results = batch.process_directory(
    input_dir="raw_data/",
    output_dir="processed/",
    pattern="*.las"
)

for result in results:
    print(f"{result['filename']}: {result['status']}")

🏗️ Building Detection

Advanced Configuration

# example_buildings.py - Fine building detection
from ign_lidar import Processor, Config

config = Config(
    features=['buildings'],
    building_detection={
        'method': 'advanced',
        'min_points': 50,
        'height_threshold': 2.0,
        'planarity_threshold': 0.1,
        'roof_analysis': True
    }
)

processor = Processor(config=config)
result = processor.process_tile("urban_area.las", "buildings_detected.las")

# Detailed statistics
stats = result.get_building_statistics()
print(f"Buildings detected: {stats['building_count']}")
print(f"Total built area: {stats['total_area']:.1f} m²")
print(f"Average height: {stats['avg_height']:.1f} m")

Regional Extraction

# example_regional_buildings.py - Regional adaptation
from ign_lidar import RegionalProcessor

# Processor adapted for Île-de-France
processor = RegionalProcessor(region="ile-de-france")

# Automatic configuration based on region
result = processor.process_urban_area(
    "paris_scan.las",
    "paris_buildings.las",
    heritage_mode=True  # Heritage preservation
)

🌿 Vegetation Classification

Forest Analysis

# example_forest.py - Complete forest analysis
from ign_lidar import ForestAnalyzer

analyzer = ForestAnalyzer()

# Multi-layer analysis
forest_data = analyzer.analyze_forest_structure(
    "forest_scan.las",
    layers=['canopy', 'understory', 'ground'],
    species_detection=True
)

# Dendrometric metrics
metrics = forest_data.get_forest_metrics()
print(f"Canopy height: {metrics['canopy_height']:.1f} m")
print(f"Density: {metrics['tree_density']:.1f} trees/ha")
print(f"Estimated biomass: {metrics['biomass_estimate']:.1f} t/ha")

Urban Vegetation

# example_urban_vegetation.py - City vegetation
from ign_lidar import UrbanVegetationAnalyzer

urban_veg = UrbanVegetationAnalyzer()

# Fine classification of urban vegetation
veg_classes = urban_veg.classify_urban_vegetation(
    "city_scan.las",
    categories=[
        'street_trees', 'park_vegetation', 'private_gardens',
        'green_roofs', 'hedges', 'lawn_areas'
    ]
)

# Environmental report
report = urban_veg.generate_environmental_report(veg_classes)
print(f"Vegetation coverage: {report['vegetation_coverage']:.1%}")
print(f"Ecosystem services: {report['ecosystem_services']}")

🎨 RGB Augmentation

Orthophoto Integration

# example_rgb_basic.py - Adding RGB colors
from ign_lidar import RGBProcessor

rgb_processor = RGBProcessor(
    interpolation_method='bilinear',
    quality_threshold=0.8
)

# Enrich with orthophoto
colored_lidar = rgb_processor.add_rgb_colors(
    lidar_path="scan.las",
    orthophoto_path="orthophoto.tif",
    output_path="colored_scan.las"
)

print(f"Colored points: {colored_lidar['colored_points']}")
print(f"Average quality: {colored_lidar['avg_quality']:.2f}")

Batch Processing with GPU

# example_rgb_gpu_batch.py - GPU batch processing
from ign_lidar import GPURGBProcessor

gpu_processor = GPURGBProcessor(
    gpu_memory_limit=0.8,  # 80% of VRAM
    batch_size=10
)

# Accelerated processing of multiple tiles
results = gpu_processor.batch_rgb_enhancement(
    lidar_tiles="tiles/*.las",
    orthophoto_dir="orthophotos/",
    output_dir="rgb_enhanced/",
    parallel_gpu_streams=2
)

⚡ GPU and Performance

Optimal GPU Configuration

# example_gpu_config.py - Advanced GPU configuration
from ign_lidar import GPUProcessor
import torch

# GPU check
if torch.cuda.is_available():
    gpu_processor = GPUProcessor(
        device='cuda:0',
        precision='mixed',  # Mixed precision for speed
        memory_efficient=True
    )

    # Processing with profiling
    with gpu_processor.profile_performance():
        result = gpu_processor.process_large_dataset(
            "huge_dataset.las",
            chunk_size=2000000,
            overlap=0.1
        )

    # Performance statistics
    perf_stats = gpu_processor.get_performance_stats()
    print(f"Speed: {perf_stats['points_per_second']:,.0f} points/s")
    print(f"GPU utilization: {perf_stats['gpu_utilization']:.1%}")

Memory Optimization

# example_memory_optimization.py - Optimal memory management
from ign_lidar import MemoryEfficientProcessor
import psutil

# Configuration adapted to available RAM
available_ram = psutil.virtual_memory().available / (1024**3)  # GB
optimal_chunk_size = min(available_ram * 0.3 * 1000000, 5000000)

processor = MemoryEfficientProcessor(
    chunk_size=int(optimal_chunk_size),
    streaming_mode=True,
    compression_level=1
)

# Process very large volumes
processor.process_huge_dataset(
    input_pattern="massive_data/*.laz",
    output_dir="processed/",
    progress_callback=lambda p: print(f"Progress: {p:.1%}")
)

🔧 Auto-Parameters

Automatic Optimization

# example_auto_params.py - Using auto-parameters
from ign_lidar import AutoParamsProcessor

auto_processor = AutoParamsProcessor()

# Automatic analysis and optimization
optimal_params = auto_processor.analyze_and_optimize(
    sample_files=["sample1.las", "sample2.las", "sample3.las"],
    quality_target="high",
    time_constraint=300  # 5 minutes max
)

# Apply optimized parameters
result = auto_processor.process_with_optimal_params(
    "input.las",
    "output.las",
    optimal_params
)

print(f"Optimized parameters: {optimal_params}")
print(f"Quality score: {result['quality_score']:.2f}")

Custom Learning

# example_custom_learning.py - Custom model
from ign_lidar import ParameterLearner

learner = ParameterLearner()

# Training on annotated data
custom_model = learner.train_custom_optimizer(
    training_data="annotated_samples/",
    region="custom_region",
    target_applications=["urban_planning", "heritage_preservation"]
)

# Save model
learner.save_model(custom_model, "my_optimizer.pkl")

# Use custom model
processor = AutoParamsProcessor(model_path="my_optimizer.pkl")

🌐 QGIS Integration

QGIS Plugin

# example_qgis_integration.py - QGIS integration
from qgis.core import QgsApplication, QgsProject
from ign_lidar.qgis import IGNLiDARProcessor

# QGIS initialization
app = QgsApplication([], False)
app.initQgis()

# Processing with QGIS integration
qgis_processor = IGNLiDARProcessor()

# Automatic addition to QGIS
layer = qgis_processor.process_and_add_to_qgis(
    input_file="data.las",
    project=QgsProject.instance(),
    style_preset="urban_classification"
)

print(f"Layer added: {layer.name()}")

Automation with Processing

# example_qgis_processing.py - Automation via Processing
import processing
from qgis.core import QgsApplication

# Configure IGN LiDAR algorithms
processing.run("ignlidar:batch_enrich", {
    'INPUT_DIR': 'raw_data/',
    'OUTPUT_DIR': 'processed/',
    'FEATURES': ['buildings', 'vegetation'],
    'AUTO_PARAMS': True,
    'QUALITY_PRESET': 'high'
})

📊 Analysis and Statistics

Quality Metrics

# example_quality_metrics.py - Quality assessment
from ign_lidar import QualityAssessment

qa = QualityAssessment()

# Comprehensive assessment
quality_report = qa.comprehensive_assessment(
    processed_file="enriched.las",
    reference_file="ground_truth.las",
    metrics=['precision', 'recall', 'f1_score', 'iou']
)

# Detailed report
qa.generate_quality_report(
    quality_report,
    output_path="quality_assessment.html",
    include_visualizations=True
)

Temporal Comparison

# example_temporal_analysis.py - Temporal analysis
from ign_lidar import TemporalAnalyzer

temporal = TemporalAnalyzer()

# Change detection
changes = temporal.detect_changes(
    reference_scan="2020_scan.las",
    comparison_scan="2024_scan.las",
    change_threshold=0.5  # meters
)

# Evolution statistics
evolution_stats = temporal.compute_evolution_statistics(changes)
print(f"New buildings: {evolution_stats['new_buildings']}")
print(f"Demolished buildings: {evolution_stats['demolished_buildings']}")
print(f"Vegetation growth: +{evolution_stats['vegetation_growth']:.1f}%")

🔍 Specialized Use Cases

Historical Heritage

# example_heritage.py - Heritage analysis
from ign_lidar import HeritageAnalyzer

heritage = HeritageAnalyzer(
    sensitivity="maximum",
    preservation_mode=True
)

# Fine analysis of a monument
monument_analysis = heritage.analyze_historical_building(
    "cathedral_scan.las",
    reference_model="cathedral_3d_model.ply",
    detection_precision="millimetric"
)

# Conservation report
conservation_report = heritage.generate_conservation_report(
    monument_analysis,
    include_recommendations=True
)

Urban Planning

# example_urban_planning.py - Urban planning
from ign_lidar import UrbanPlanningAnalyzer

planner = UrbanPlanningAnalyzer()

# Urban impact analysis
impact_analysis = planner.analyze_development_potential(
    current_scan="city_current.las",
    zoning_rules="plu_zonage.shp",
    development_scenarios=["densification", "green_spaces"]
)

# Planning recommendations
recommendations = planner.generate_planning_recommendations(
    impact_analysis,
    sustainability_focus=True
)

📚 Advanced Tutorials

Complete Pipeline

# tutorial_complete_pipeline.py - End-to-end workflow
def complete_lidar_pipeline(input_dir, output_dir):
    """Complete LiDAR processing pipeline"""

    # 1. Data preparation
    from ign_lidar import DataPreprocessor
    preprocessor = DataPreprocessor()
    preprocessor.validate_and_clean_dataset(input_dir)

    # 2. Auto-optimization
    from ign_lidar import AutoParamsProcessor
    auto_processor = AutoParamsProcessor()
    optimal_params = auto_processor.optimize_for_dataset(input_dir)

    # 3. Main processing
    from ign_lidar import BatchProcessor
    batch_processor = BatchProcessor(
        params=optimal_params,
        n_jobs=-1,  # All cores
        gpu_acceleration=True
    )
    results = batch_processor.process_directory(input_dir, output_dir)

    # 4. Quality control
    from ign_lidar import QualityController
    qc = QualityController()
    quality_report = qc.validate_batch_results(results)

    # 5. Visualization and report
    from ign_lidar import ReportGenerator
    report_gen = ReportGenerator()
    report_gen.create_comprehensive_report(
        results, quality_report, f"{output_dir}/final_report.html"
    )

    return results, quality_report

# Run pipeline
if __name__ == "__main__":
    results, quality = complete_lidar_pipeline("raw_data/", "processed/")
    print("Pipeline completed successfully!")

🔗 Additional Resources

Utility Scripts

• Data validation
• Format conversion
• GPU optimization

Jupyter Notebooks

• Quick start
• Forest analysis
• Urban detection

Configuration Templates

# Example configurations in config_examples/
production_config.yaml    # Production configuration
research_config.yaml      # R&D configuration
heritage_config.yaml      # Heritage preservation
forestry_config.yaml      # Forest analysis
urban_config.yaml         # Urban analysis

See also: Getting Started Guide | Complete API | Video Tutorials