Update point cloud processing code - 2025-09-25T15:11:13.442455

point_cloud_preprocessing/00_crop_dem_to_bb.py

@@ -0,0 +1,389 @@
+#!/usr/bin/env python3
+"""
+Crop DEM to match the shared bounding box of the LAS point clouds and convert to ellipsoidal heights.
+
+This script:
+1. Crops a DEM raster to the same spatial extent as the LAS point clouds
+2. Converts orthometric heights (NAVD88) to ellipsoidal heights (NAD83 2011)
+   using the GEOID12B model, ensuring vertical datum compatibility with LAS data
+
+Outputs:
+- qspatial_2019_orthometric.tif: Cropped DEM with original orthometric heights
+- qspatial_2019_ellipsoidal.tif: Final DEM with ellipsoidal heights matching LAS data
+"""
+
+import json
+import subprocess
+from pathlib import Path
+from osgeo import gdal, osr
+import numpy as np
+import tempfile
+
+def get_las_bounds(las_file):
+    """Get bounding box of LAS file using PDAL info."""
+    try:
+        result = subprocess.run(
+            ['pdal', 'info', '--metadata', str(las_file)],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        metadata = json.loads(result.stdout)
+
+        bounds = {
+            'minx': metadata['metadata']['minx'],
+            'maxx': metadata['metadata']['maxx'],
+            'miny': metadata['metadata']['miny'],
+            'maxy': metadata['metadata']['maxy'],
+            'minz': metadata['metadata']['minz'],
+            'maxz': metadata['metadata']['maxz']
+        }
+
+        # Also get the SRS info
+        srs_wkt = metadata['metadata']['spatialreference']
+
+        return bounds, srs_wkt
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(f"Failed to get bounds for {las_file}: {e}")
+
+def calculate_shared_bounds(las_files):
+    """Calculate the smallest shared bounding box from multiple LAS files."""
+    bounds_list = []
+    srs_wkt = None
+
+    for las_file in las_files:
+        bounds, wkt = get_las_bounds(las_file)
+        bounds_list.append(bounds)
+        if srs_wkt is None:
+            srs_wkt = wkt
+
+    shared_bounds = {
+        'minx': max(b['minx'] for b in bounds_list),
+        'maxx': min(b['maxx'] for b in bounds_list),
+        'miny': max(b['miny'] for b in bounds_list),
+        'maxy': min(b['maxy'] for b in bounds_list),
+    }
+
+    # Validate that we have a valid bounding box
+    if (shared_bounds['minx'] >= shared_bounds['maxx'] or
+        shared_bounds['miny'] >= shared_bounds['maxy']):
+        raise ValueError("No spatial overlap between input files")
+
+    return shared_bounds, srs_wkt
+
+def crop_dem_to_bounds(input_dem, output_dem, bounds, target_srs_wkt=None):
+    """
+    Crop DEM to specified bounds using GDAL.
+
+    Args:
+        input_dem: Path to input DEM file
+        output_dem: Path to output cropped DEM
+        bounds: Dictionary with minx, maxx, miny, maxy
+        target_srs_wkt: Target SRS in WKT format (optional, for reprojection)
+    """
+    # Open the input DEM
+    src_ds = gdal.Open(str(input_dem))
+    if src_ds is None:
+        raise RuntimeError(f"Failed to open {input_dem}")
+
+    # Get source SRS
+    src_srs = osr.SpatialReference()
+    src_srs.ImportFromWkt(src_ds.GetProjection())
+
+    # Set up target SRS if provided
+    if target_srs_wkt:
+        target_srs = osr.SpatialReference()
+        target_srs.ImportFromWkt(target_srs_wkt)
+
+        # Check if reprojection is needed
+        if not src_srs.IsSame(target_srs):
+            print("  Note: DEM and LAS use different coordinate systems")
+            print(f"    DEM SRS: {src_srs.GetAttrValue('PROJCS') or src_srs.GetAttrValue('GEOGCS')}")
+            print(f"    LAS SRS: {target_srs.GetAttrValue('PROJCS') or target_srs.GetAttrValue('GEOGCS')}")
+
+    # Use GDAL Warp to crop (and optionally reproject)
+    warp_options = gdal.WarpOptions(
+        outputBounds=[bounds['minx'], bounds['miny'], bounds['maxx'], bounds['maxy']],
+        outputBoundsSRS=target_srs_wkt if target_srs_wkt else None,
+        dstSRS=target_srs_wkt if target_srs_wkt else None,
+        resampleAlg='bilinear',
+        format='GTiff',
+        creationOptions=['COMPRESS=LZW', 'TILED=YES']
+    )
+
+    # Perform the warp operation
+    gdal.Warp(str(output_dem), src_ds, options=warp_options)
+
+    # Close dataset
+    src_ds = None
+
+    # Verify output
+    result_ds = gdal.Open(str(output_dem))
+    if result_ds is None:
+        raise RuntimeError(f"Failed to create {output_dem}")
+
+    # Get output info
+    geotransform = result_ds.GetGeoTransform()
+    width = result_ds.RasterXSize
+    height = result_ds.RasterYSize
+
+    # Calculate actual bounds of output
+    actual_minx = geotransform[0]
+    actual_maxy = geotransform[3]
+    actual_maxx = actual_minx + width * geotransform[1]
+    actual_miny = actual_maxy + height * geotransform[5]
+
+    # Get elevation statistics
+    band = result_ds.GetRasterBand(1)
+    stats = band.GetStatistics(True, True)
+    min_elev, max_elev, mean_elev, std_elev = stats
+
+    result_ds = None
+
+    return {
+        'width': width,
+        'height': height,
+        'pixel_size': abs(geotransform[1]),
+        'bounds': {
+            'minx': actual_minx,
+            'maxx': actual_maxx,
+            'miny': actual_miny,
+            'maxy': actual_maxy
+        },
+        'elevation': {
+            'min': min_elev,
+            'max': max_elev,
+            'mean': mean_elev,
+            'std': std_elev
+        }
+    }
+
+def convert_to_ellipsoidal_height(input_dem, output_dem, geoid_file):
+    """
+    Convert orthometric heights to ellipsoidal heights using GDAL warp + raster math.
+
+    This approach:
+    1. Warps the geoid to match the DEM's projection and resolution
+    2. Adds the geoid separation to the orthometric heights: ellipsoidal = orthometric + geoid
+
+    Args:
+        input_dem: Path to input DEM with orthometric heights
+        output_dem: Path to output DEM with ellipsoidal heights
+        geoid_file: Path to geoid model file (GEOID12B binary format)
+    """
+    print(f"    Warping geoid to match DEM projection and resolution...")
+
+    # Open the DEM to get its spatial reference and geotransform
+    dem_ds = gdal.Open(str(input_dem))
+    if dem_ds is None:
+        raise RuntimeError(f"Failed to open {input_dem}")
+
+    dem_proj = dem_ds.GetProjection()
+    dem_geotransform = dem_ds.GetGeoTransform()
+    dem_width = dem_ds.RasterXSize
+    dem_height = dem_ds.RasterYSize
+
+    # Calculate DEM bounds
+    minx = dem_geotransform[0]
+    maxy = dem_geotransform[3]
+    maxx = minx + dem_width * dem_geotransform[1]
+    miny = maxy + dem_height * dem_geotransform[5]
+
+    # Create temporary warped geoid file
+    temp_geoid = tempfile.NamedTemporaryFile(suffix='_warped_geoid.tif', delete=False)
+    temp_geoid_path = temp_geoid.name
+    temp_geoid.close()
+
+    try:
+        # Warp geoid to match DEM
+        warp_options = gdal.WarpOptions(
+            format='GTiff',
+            outputBounds=[minx, miny, maxx, maxy],
+            width=dem_width,
+            height=dem_height,
+            dstSRS=dem_proj,
+            resampleAlg='bilinear',
+            creationOptions=['COMPRESS=LZW', 'TILED=YES']
+        )
+
+        print(f"    Warping {geoid_file} to match DEM...")
+        gdal.Warp(temp_geoid_path, str(geoid_file), options=warp_options)
+
+        # Verify warped geoid was created
+        geoid_ds = gdal.Open(temp_geoid_path)
+        if geoid_ds is None:
+            raise RuntimeError(f"Failed to warp geoid file")
+
+        print(f"    Adding geoid separation to orthometric heights...")
+
+        # Read the DEM data
+        dem_band = dem_ds.GetRasterBand(1)
+        dem_data = dem_band.ReadAsArray()
+        dem_nodata = dem_band.GetNoDataValue()
+
+        # Read the warped geoid data
+        geoid_band = geoid_ds.GetRasterBand(1)
+        geoid_data = geoid_band.ReadAsArray()
+
+        # Ensure arrays have the same shape
+        if dem_data.shape != geoid_data.shape:
+            raise RuntimeError(f"DEM and geoid array shapes don't match: {dem_data.shape} vs {geoid_data.shape}")
+
+        # Apply conversion: ellipsoidal = orthometric + geoid
+        ellipsoidal_data = dem_data.copy()
+
+        if dem_nodata is not None:
+            # Only apply to valid pixels
+            valid_mask = dem_data != dem_nodata
+            ellipsoidal_data[valid_mask] = dem_data[valid_mask] + geoid_data[valid_mask]
+        else:
+            # Apply to all pixels
+            ellipsoidal_data = dem_data + geoid_data
+
+        # Create output DEM
+        driver = gdal.GetDriverByName('GTiff')
+        out_ds = driver.Create(
+            str(output_dem),
+            dem_width,
+            dem_height,
+            1,
+            gdal.GDT_Float32,
+            ['COMPRESS=LZW', 'TILED=YES']
+        )
+
+        # Set spatial reference and geotransform
+        out_ds.SetProjection(dem_proj)
+        out_ds.SetGeoTransform(dem_geotransform)
+
+        # Write the ellipsoidal data
+        out_band = out_ds.GetRasterBand(1)
+        out_band.WriteArray(ellipsoidal_data)
+        if dem_nodata is not None:
+            out_band.SetNoDataValue(dem_nodata)
+
+        # Get statistics
+        stats = out_band.GetStatistics(True, True)
+        min_elev, max_elev, mean_elev, std_elev = stats
+
+        # Calculate average geoid separation (for reporting)
+        if dem_nodata is not None:
+            valid_geoid = geoid_data[valid_mask]
+            avg_geoid_sep = np.mean(valid_geoid) if len(valid_geoid) > 0 else 0
+        else:
+            avg_geoid_sep = np.mean(geoid_data)
+
+        # Close datasets
+        dem_ds = None
+        geoid_ds = None
+        out_ds = None
+
+        return {
+            'elevation': {
+                'min': min_elev,
+                'max': max_elev,
+                'mean': mean_elev,
+                'std': std_elev
+            },
+            'avg_geoid_separation': avg_geoid_sep,
+            'method': 'gdal_warp_plus_raster_math'
+        }
+
+    finally:
+        # Clean up temporary file
+        try:
+            Path(temp_geoid_path).unlink()
+        except:
+            pass  # Ignore cleanup errors
+
+def main():
+    # Input paths
+    input_dem = Path('/Users/kdoherty/bitterroot_canopy/data/raster/lidar_raw/dems/2019/46114f1_2019_qspatial_dem.tif')
+    geoid_file = Path('data/raster/dems/g2012bu1.bin')
+    las_dir = Path('data/point_cloud')
+
+    # LAS files to get bounds from (three timepoints)
+    las_files = [
+        las_dir / '1000.las',
+        las_dir / '1200.las',
+        las_dir / '1500.las'
+    ]
+
+    # Output paths
+    output_dir = Path('data/raster/dems')
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Intermediate file (orthometric heights, cropped)
+    orthometric_dem = output_dir / 'qspatial_2019_orthometric.tif'
+    # Final file (ellipsoidal heights)
+    ellipsoidal_dem = output_dir / 'qspatial_2019_ellipsoidal.tif'
+
+    # Validate input files exist
+    if not input_dem.exists():
+        raise FileNotFoundError(f"Input DEM not found: {input_dem}")
+
+    if not geoid_file.exists():
+        raise FileNotFoundError(f"Geoid file not found: {geoid_file}")
+
+    for las_file in las_files:
+        if not las_file.exists():
+            raise FileNotFoundError(f"LAS file not found: {las_file}")
+
+    print("Analyzing three timepoint LAS files for shared bounding box...")
+
+    # Get shared bounds from LAS files
+    shared_bounds, las_srs_wkt = calculate_shared_bounds(las_files)
+
+    print(f"\nShared bounding box across timepoints:")
+    print(f"  X: {shared_bounds['minx']:.3f} → {shared_bounds['maxx']:.3f}")
+    print(f"  Y: {shared_bounds['miny']:.3f} → {shared_bounds['maxy']:.3f}")
+    print(f"  Width: {shared_bounds['maxx'] - shared_bounds['minx']:.3f} m")
+    print(f"  Height: {shared_bounds['maxy'] - shared_bounds['miny']:.3f} m")
+
+    print(f"\nStep 1: Cropping DEM to LAS bounds...")
+    print(f"  Input: {input_dem}")
+    print(f"  Output: {orthometric_dem}")
+
+    # Crop the DEM (orthometric heights)
+    crop_result = crop_dem_to_bounds(input_dem, orthometric_dem, shared_bounds, las_srs_wkt)
+
+    print(f"\nCrop complete!")
+    print(f"  Output dimensions: {crop_result['width']} x {crop_result['height']} pixels")
+    print(f"  Pixel size: {crop_result['pixel_size']:.3f} m")
+    print(f"  Final bounds:")
+    print(f"    X: {crop_result['bounds']['minx']:.3f} → {crop_result['bounds']['maxx']:.3f}")
+    print(f"    Y: {crop_result['bounds']['miny']:.3f} → {crop_result['bounds']['maxy']:.3f}")
+    print(f"  Orthometric elevation range:")
+    print(f"    Min: {crop_result['elevation']['min']:.2f} m")
+    print(f"    Max: {crop_result['elevation']['max']:.2f} m")
+    print(f"    Mean: {crop_result['elevation']['mean']:.2f} m (±{crop_result['elevation']['std']:.2f})")
+
+    print(f"\nStep 2: Converting to ellipsoidal heights...")
+    print(f"  Input: {orthometric_dem}")
+    print(f"  Geoid: {geoid_file}")
+    print(f"  Output: {ellipsoidal_dem}")
+
+    # Convert orthometric heights to ellipsoidal heights
+    conversion_result = convert_to_ellipsoidal_height(orthometric_dem, ellipsoidal_dem, geoid_file)
+
+    print(f"\nConversion complete!")
+    print(f"  Ellipsoidal elevation range:")
+    print(f"    Min: {conversion_result['elevation']['min']:.2f} m")
+    print(f"    Max: {conversion_result['elevation']['max']:.2f} m")
+    print(f"    Mean: {conversion_result['elevation']['mean']:.2f} m (±{conversion_result['elevation']['std']:.2f})")
+
+    # Show conversion method used
+    if 'method' in conversion_result:
+        print(f"  Conversion method: {conversion_result['method']}")
+
+    # Show geoid separation statistics
+    if 'avg_geoid_separation' in conversion_result:
+        print(f"  Average geoid separation: {conversion_result['avg_geoid_separation']:.3f} m")
+    else:
+        # Fallback calculation
+        ortho_mean = crop_result['elevation']['mean']
+        ellip_mean = conversion_result['elevation']['mean']
+        geoid_sep = ellip_mean - ortho_mean
+        print(f"  Average geoid separation: {geoid_sep:.3f} m")
+
+if __name__ == "__main__":
+    main()

point_cloud_preprocessing/01_normalize_and_chm.R

@@ -0,0 +1,270 @@
+# Load required libraries
+library(lidR)
+library(raster)
+library(terra)
+library(sf)
+library(jsonlite)
+
+# Ground classification function using DEM (for catalog chunks)
+classify_ground_by_dem <- function(las, dem_raster, tol) {
+
+# Convert raster to terra SpatRaster if needed
+if (class(dem_raster)[1] == "RasterLayer") {
+dem <- terra::rast(dem_raster)
+} else {
+dem <- dem_raster
+}
+
+# Create points for extraction
+points_df <- data.frame(
+X = las@data$X,
+Y = las@data$Y,
+Z = las@data$Z
+)
+
+# Create SpatVector from points
+pts <- terra::vect(points_df[, c("X", "Y")],
+geom = c("X", "Y"),
+crs = terra::crs(dem))
+
+# Extract DEM values at point locations
+dem_values <- terra::extract(dem, pts, ID = FALSE)
+dem_col_name <- names(dem_values)[1]
+
+# Check for NA values
+na_count <- sum(is.na(dem_values[[dem_col_name]]))
+
+# Calculate vertical distances for valid points
+valid_idx <- which(!is.na(dem_values[[dem_col_name]]))
+z_diff <- abs(points_df$Z[valid_idx] - dem_values[[dem_col_name]][valid_idx])
+
+# Initialize classification (1 = unclassified)
+classification <- rep(1, nrow(points_df))
+
+# Classify ground points (within tolerance)
+ground_indices <- valid_idx[z_diff <= tol]
+classification[ground_indices] <- 2 # ASPRS ground class
+
+# Classify vegetation points (beyond tolerance)
+veg_indices <- valid_idx[z_diff > tol]
+classification[veg_indices] <- 5 # ASPRS vegetation class
+
+# Update LAS classification (ensure integer type)
+las@data$Classification <- as.integer(classification)
+
+return(las)
+}
+
+# Load metadata for z-error threshold calculation
+metadata <- fromJSON("data/point_cloud/metadata.json")
+z_errors <- sapply(metadata$acquisitions, function(x) x$z_error)
+mean_z_error <- mean(z_errors)
+cat(sprintf("Ground threshold: %.3f m (mean z-error)\n", mean_z_error))
+
+# File paths for three timepoints
+las_files <- c(
+"data/point_cloud/1000.las",
+"data/point_cloud/1200.las",
+"data/point_cloud/1500.las"
+)
+ellipsoidal_dem <- "data/raster/dems/qspatial_2019_ellipsoidal.tif"
+output_chm <- "data/raster/dems/canopy_height.tif"
+target_resolution <- 0.05 # meters
+
+# Validate input files
+for (las_file in las_files) {
+if (!file.exists(las_file)) {
+stop(paste("Required file not found:", las_file))
+}
+}
+if (!file.exists(ellipsoidal_dem)) {
+stop(paste("Required file not found:", ellipsoidal_dem))
+}
+
+# Function to calculate shared bounding box
+get_shared_bounds <- function(las_files) {
+cat("\nStep 1: Calculating shared bounding box...\n")
+
+bounds_list <- list()
+for (i in 1:length(las_files)) {
+las <- readLAS(las_files[i], select = "xyz") # Only read coordinates for speed
+bounds_list[[i]] <- list(
+xmin = min(las@data$X),
+xmax = max(las@data$X),
+ymin = min(las@data$Y),
+ymax = max(las@data$Y)
+)
+cat(sprintf(" %s: X(%.2f,%.2f) Y(%.2f,%.2f)\n",
+basename(las_files[i]),
+bounds_list[[i]]$xmin, bounds_list[[i]]$xmax,
+bounds_list[[i]]$ymin, bounds_list[[i]]$ymax))
+}
+
+# Calculate intersection (minimum bounding box)
+shared_bounds <- list(
+xmin = max(sapply(bounds_list, function(b) b$xmin)),
+xmax = min(sapply(bounds_list, function(b) b$xmax)),
+ymin = max(sapply(bounds_list, function(b) b$ymin)),
+ymax = min(sapply(bounds_list, function(b) b$ymax))
+)
+
+cat(sprintf(" Shared bounds: X(%.2f,%.2f) Y(%.2f,%.2f)\n",
+shared_bounds$xmin, shared_bounds$xmax,
+shared_bounds$ymin, shared_bounds$ymax))
+cat(sprintf(" Shared area: %.1f x %.1f m\n",
+shared_bounds$xmax - shared_bounds$xmin,
+shared_bounds$ymax - shared_bounds$ymin))
+
+return(shared_bounds)
+}
+
+# Calculate shared bounding box
+shared_bounds <- get_shared_bounds(las_files)
+
+# Create template raster for consistent CRS and extent
+las_crs <- sf::st_crs(readLAS(las_files[1], select = "xyz"))$wkt
+template_raster <- terra::rast(xmin = shared_bounds$xmin,
+xmax = shared_bounds$xmax,
+ymin = shared_bounds$ymin,
+ymax = shared_bounds$ymax,
+res = target_resolution,
+crs = las_crs)
+
+cat(sprintf(" Template raster: %d x %d pixels, CRS: %s\n",
+ncol(template_raster), nrow(template_raster),
+substr(las_crs, 1, 50)))
+
+cat("\nStep 2: Loading ellipsoidal DEM...\n")
+cat(sprintf(" Input: %s\n", ellipsoidal_dem))
+dtm <- raster(ellipsoidal_dem)
+cat(sprintf(" DEM dimensions: %d x %d pixels\n", ncol(dtm), nrow(dtm)))
+cat(sprintf(" DEM resolution: %.3f m\n", res(dtm)[1]))
+cat(sprintf(" DEM elevation range: %.2f to %.2f meters\n", cellStats(dtm, min), cellStats(dtm, max)))
+
+
+# Function to process a single timepoint
+process_timepoint <- function(las_file, template, dtm, mean_z_error) {
+timepoint <- tools::file_path_sans_ext(basename(las_file))
+cat(sprintf("\n Processing timepoint %s...\n", timepoint))
+
+# Read LAS file
+las <- readLAS(las_file)
+cat(sprintf(" Loaded %s points\n", format(npoints(las), big.mark = ",")))
+
+# Fix return metadata for photogrammetric point cloud
+las@data$ReturnNumber <- as.integer(1)
+las@data$NumberOfReturns <- as.integer(1)
+
+# Classify ground points
+cat(" Classifying ground points using DEM...\n")
+las <- classify_ground_by_dem(las, dtm, mean_z_error)
+
+# Normalize heights using TIN from classified ground points
+cat(" Normalizing heights using TIN...\n")
+las_norm <- normalize_height(las, algorithm = tin())
+
+# Clamp negative values to 0
+las_norm@data$Z[las_norm@data$Z < 0] <- 0.0
+
+# --- THIS IS THE CRUCIAL FIX ---
+# Clip the point cloud to the template's extent before rasterizing.
+# This prevents the "point out of raster" error.
+cat(" Clipping point cloud to shared extent...\n")
+bbox <- raster::extent(template)
+las_clipped <- clip_rectangle(las_norm, bbox@xmin, bbox@ymin, bbox@xmax, bbox@ymax)
+
+# Check if any points remain after clipping
+if (is.empty(las_clipped)) {
+cat(" Warning: No points remaining after clipping. Skipping this timepoint.\n")
+return(NULL)
+}
+
+# Generate CHM using the clipped point cloud and the pitfree algorithm
+cat(sprintf(" Generating CHM using template grid (%.3f m resolution)...\n", xres(template)))
+chm <- rasterize_canopy(
+las_clipped, # <-- Use the clipped LAS object
+res = template, # Use the template raster directly
+algorithm = p2r(subcircle = 0.5 * xres(template), na.fill = knnidw())
+)
+
+# Clamp negative values that may be introduced by interpolation
+chm[chm < 0] <- 0
+
+# Apply Gaussian smoothing to reduce noise
+cat("  Applying Gaussian smoothing...\n")
+chm_terra <- terra::rast(chm)
+chm_smoothed <- terra::focal(chm_terra, w=3, fun="mean", na.rm=TRUE)
+chm <- raster(chm_smoothed)  # Convert back to raster for consistency
+
+# Verify we have data
+max_val <- cellStats(chm, "max")
+if (is.na(max_val) || max_val == -Inf || max_val <= 0) {
+cat(" Warning: CHM has no positive values after generation.\n")
+return(NULL)
+}
+
+# Convert final raster to SpatRaster for consistency before returning
+chm_terra <- terra::rast(chm)
+
+cat(sprintf(" CHM: %d x %d pixels, Height range: %.2f to %.2f m\n",
+ncol(chm_terra), nrow(chm_terra),
+terra::global(chm_terra, "min", na.rm = TRUE)[1,1],
+terra::global(chm_terra, "max", na.rm = TRUE)[1,1]))
+
+return(chm_terra)
+}
+
+cat("\nStep 3: Processing each timepoint...\n")
+
+# --- ADDED: Convert terra template to raster for lidR compatibility ---
+# lidR's rasterize_* functions expect a RasterLayer object from the 'raster' package
+template_raster_legacy <- raster(template_raster)
+
+# Check if CHM already exists
+if (file.exists(output_chm)) {
+cat(sprintf(" CHM already exists, skipping: %s\n", output_chm))
+chm <- terra::rast(output_chm)
+cat(sprintf(" Loaded existing CHM: %d x %d pixels\n", ncol(chm), nrow(chm)))
+cat(sprintf(" CHM height range: %.2f to %.2f meters\n",
+terra::global(chm, "min", na.rm = TRUE)[1,1],
+terra::global(chm, "max", na.rm = TRUE)[1,1]))
+} else {
+# Process each timepoint to generate CHMs
+chm_list <- list()
+
+for (i in 1:length(las_files)) {
+  chm_result <- process_timepoint(las_files[i], template_raster_legacy, dtm, mean_z_error)
+  if (!is.null(chm_result)) {
+    chm_list[[length(chm_list) + 1]] <- chm_result
+  }
+}
+
+cat(sprintf("\nStep 4: Averaging %d CHMs across timepoints...\n", length(chm_list)))
+
+if (length(chm_list) == 0) {
+stop("No valid CHMs were generated from any timepoint!")
+}
+
+# Average the CHMs
+if (length(chm_list) == 1) {
+final_chm <- chm_list[[1]]
+cat(" Using single CHM (only one timepoint processed successfully)\n")
+} else {
+chm_stack <- terra::rast(chm_list)
+final_chm <- terra::app(chm_stack, mean, na.rm = TRUE)
+}
+
+cat(sprintf(" Final CHM: %d x %d pixels, Height range: %.2f to %.2f m\n",
+ncol(final_chm), nrow(final_chm),
+terra::global(final_chm, "min", na.rm = TRUE)[1,1],
+terra::global(final_chm, "max", na.rm = TRUE)[1,1]))
+
+cat(sprintf(" Saving averaged CHM: %s\n", output_chm))
+dir.create(dirname(output_chm), showWarnings = FALSE, recursive = TRUE)
+terra::writeRaster(final_chm, output_chm, overwrite = TRUE)
+}
+
+cat(sprintf("\nProcessing complete!\n"))
+cat(sprintf(" Averaged CHM (%.3f m): %s\n", target_resolution, output_chm))
+cat(sprintf(" Based on %d timepoints: %s\n", length(las_files),
+paste(basename(tools::file_path_sans_ext(las_files)), collapse = ", ")))