Upload 4 files

scripts/canopy_plots.py

@@ -0,0 +1,148 @@
+"""
+Canopy height model helpers.
+
+These utilities create canopy height models (CHM) from voxelized point cloud
+data cubes while applying a simple adaptive filter to smooth noisy ground
+estimates (DTM). Functions are written with clarity and deterministic output in
+mind for use in notebooks and scripts.
+"""
+
+from __future__ import annotations
+
+from typing import Tuple
+
+import numpy as np
+from numpy.typing import NDArray
+
+Array2D = NDArray[np.floating]
+Array3D = NDArray[np.floating]
+
+
+def apply_kernel(dtm: Array2D, center: Tuple[int, int], kernel_size: int) -> Array2D:
+    """
+    Return a window of `dtm` centered on `center`, clipped to array bounds.
+
+    Parameters
+    ----------
+    dtm:
+        Two-dimensional digital terrain model array.
+    center:
+        (row, column) index around which to extract the window.
+    kernel_size:
+        Size of the square window (must be positive).
+    """
+    if kernel_size <= 0:
+        raise ValueError("kernel_size must be a positive integer.")
+
+    half = kernel_size // 2
+    row_start = max(center[0] - half, 0)
+    row_end = min(center[0] + half + 1, dtm.shape[0])
+    col_start = max(center[1] - half, 0)
+    col_end = min(center[1] + half + 1, dtm.shape[1])
+
+    return dtm[row_start:row_end, col_start:col_end]
+
+
+def adaptive_dtm_filter(
+    dtm: Array2D, kernel_size: int = 7, percentile: float = 50.0
+) -> Array2D:
+    """
+    Smooth the DTM by replacing outliers with the mean of local lower-percentile values.
+
+    Each pixel greater than the specified percentile in its neighborhood is
+    replaced by the mean of the values at or below that percentile. This
+    mitigates spikes that otherwise lead to artifacts in the derived CHM.
+    """
+    filtered = dtm.copy()
+    rows, cols = filtered.shape
+
+    for row in range(rows):
+        for col in range(cols):
+            window = apply_kernel(filtered, (row, col), kernel_size).ravel()
+            if window.size == 0:
+                continue
+
+            threshold = float(np.percentile(window, percentile))
+            if filtered[row, col] > threshold:
+                lower_values = window[window <= threshold]
+                if lower_values.size:
+                    filtered[row, col] = float(lower_values.mean())
+
+    return filtered
+
+
+def hillshade(
+    array: Array2D, azimuth: float = 90.0, angle_altitude: float = 60.0
+) -> Array2D:
+    """
+    Generate a simple hillshade from a 2D array for visualization.
+
+    Parameters use degrees, consistent with most GIS tools.
+    """
+    azimuth = 360.0 - azimuth
+
+    x_gradient, y_gradient = np.gradient(array)
+    slope = np.pi / 2.0 - np.arctan(np.sqrt(x_gradient * x_gradient + y_gradient * y_gradient))
+    aspect = np.arctan2(-x_gradient, y_gradient)
+    azimuth_rad = azimuth * np.pi / 180.0
+    altitude_rad = angle_altitude * np.pi / 180.0
+
+    shaded = (
+        np.sin(altitude_rad) * np.sin(slope)
+        + np.cos(altitude_rad) * np.cos(slope) * np.cos((azimuth_rad - np.pi / 2.0) - aspect)
+    )
+
+    return 255.0 * (shaded + 1.0) / 2.0
+
+
+def calc_height_surface(cube: Array3D, percentile: float) -> NDArray[np.int64]:
+    """
+    Compute the height surface where the cumulative density exceeds `percentile`.
+    """
+    cumulative = np.cumsum(cube, axis=0)
+    maxima = cumulative.max(axis=0)
+    maxima[maxima == 0] = 1  # avoid division by zero
+    normalized = cumulative / maxima
+
+    surface = normalized > percentile
+    return np.argmax(surface, axis=0).astype(np.int64)
+
+
+def create_chm(
+    cube: Array3D, canopy_percentile: float = 0.98, dtm_percentile: float = 0.05, kernel_size: int = 7
+) -> tuple[Array2D, Array2D, Array2D, NDArray[np.int64]]:
+    """
+    Build a canopy height model, ground model, hillshade, and DEM from a cube.
+
+    Returns
+    -------
+    chm:
+        Canopy height model (DEM minus DTM).
+    dtm:
+        Smoothed digital terrain model.
+    dtm_hillshade:
+        Hillshaded representation of the DTM for visualization.
+    dem:
+        Digital elevation model derived from the cube percentile.
+    """
+    dtm = calc_height_surface(cube, dtm_percentile)
+    dtm = adaptive_dtm_filter(dtm, kernel_size=kernel_size)
+    dem = calc_height_surface(cube, canopy_percentile)
+    chm = dem - dtm
+
+    return chm, dtm, hillshade(dtm), dem
+
+
+# Backwards-compatible aliases for existing notebooks/scripts.
+calcSurf = calc_height_surface
+createCHM = create_chm
+
+__all__ = [
+    "adaptive_dtm_filter",
+    "apply_kernel",
+    "calc_height_surface",
+    "calcSurf",
+    "create_chm",
+    "createCHM",
+    "hillshade",
+]

scripts/forward_model.py

@@ -0,0 +1,121 @@
+import math
+
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+try:
+    # When imported as part of the package.
+    from .canopy_plots import createCHM
+except ImportError:
+    # Fallback for running as a standalone script (python -m hhdc.forward_model).
+    from hhdc.canopy_plots import createCHM
+
+
+class LidarForwardImagingModel(nn.Module):
+    def __init__(
+        self,
+        input_res_m=(2.0, 2.0),
+        output_res_m=(3.0, 6.0),
+        footprint_diameter_m=10.0,
+        b=0.1,
+        eta=0.5,
+        ref_altitude=500.0,
+        ref_photon_count=20.0,
+    ):
+        """
+        Args:
+            input_res_m (tuple): Physical size of input pixels (dy, dx) in meters.
+            output_res_m (tuple): Physical size of output pixels (dy, dx) in meters.
+            footprint_diameter_m (float): The 1/e^2 beam diameter in meters.
+            b (float): Background noise.
+            eta (float): Readout noise.
+            ref_altitude (float): Reference altitude (km).
+            ref_photon_count (float): Target photon count.
+        """
+        super().__init__()
+        self.b = b
+        self.eta = eta
+        self.ref_altitude = ref_altitude
+        self.ref_photon_count = ref_photon_count
+
+        self.input_res_m = input_res_m
+        self.output_res_m = output_res_m
+
+        # 1. Calculate Area Scale Factor
+        in_area = input_res_m[0] * input_res_m[1]
+        out_area = output_res_m[0] * output_res_m[1]
+        self.area_scale_factor = out_area / in_area
+
+        # 2. Calculate Sigma in Input Pixels
+        # Def: 1/e^2 diameter is 4 * sigma
+        sigma_m = footprint_diameter_m / 4.0
+
+        avg_input_res = (input_res_m[0] + input_res_m[1]) / 2.0
+        sigma_px = sigma_m / avg_input_res
+
+        # 3. Create Base Kernel
+        # We use 6*sigma for the kernel size to capture >99% of energy
+        # (Since diameter is 4*sigma, this means kernel is 1.5x the footprint size)
+        kernel_size = int(math.ceil(6 * sigma_px))
+        if kernel_size % 2 == 0:
+            kernel_size += 1
+
+        self.register_buffer("kernel", self._create_gaussian_kernel(kernel_size, sigma_px))
+
+        print(f"Model Initialized: In {input_res_m}m -> Out {output_res_m}m")
+        print(f"Footprint (1/e^2): {footprint_diameter_m}m (Sigma: {sigma_m:.2f}m / {sigma_px:.2f} px)")
+
+    def _create_gaussian_kernel(self, size, sigma):
+        coords = torch.arange(size).float() - (size - 1) / 2
+        x_grid, y_grid = torch.meshgrid(coords, coords, indexing='ij')
+        kernel = torch.exp(-(x_grid**2 + y_grid**2) / (2 * sigma**2))
+        kernel = kernel / kernel.sum()
+        return kernel.view(1, 1, size, size)
+
+    def forward(self, X_h, altitude=500.0):
+        if X_h.ndim == 3:
+            X_h = X_h.unsqueeze(0)
+
+        batch_size, num_bins, h_in, w_in = X_h.shape
+
+        # --- 1. Dynamic Output Size ---
+        fov_h_m = h_in * self.input_res_m[0]
+        fov_w_m = w_in * self.input_res_m[1]
+
+        out_h = int(fov_h_m / self.output_res_m[0])
+        out_w = int(fov_w_m / self.output_res_m[1])
+        output_size = (out_h, out_w)
+
+        # --- 2. Physics Normalization ---
+        energy_per_tube = X_h.sum(dim=1, keepdim=True)
+        global_mean_energy = energy_per_tube.mean(dim=(2, 3), keepdim=True)
+        X_norm = X_h / (global_mean_energy + 1e-8)
+
+        dist_scale = (self.ref_altitude / altitude) ** 2
+        target_intensity = (self.ref_photon_count / self.area_scale_factor) * dist_scale
+        X_scaled = X_norm * target_intensity
+
+        # --- 3. Spatial Blurring ---
+        # Expand single-channel kernel to match height bins
+        current_kernel = self.kernel.repeat(num_bins, 1, 1, 1)
+
+        padding = current_kernel.shape[-1] // 2
+        X_blurred = F.conv2d(X_scaled, current_kernel, padding=padding, groups=num_bins)
+
+        # --- 4. Downsampling ---
+        X_binned = F.interpolate(X_blurred, size=output_size, mode='area')
+        X_integrated = X_binned * self.area_scale_factor
+
+        # --- 5. Noise ---
+        lambda_val = torch.relu(X_integrated) + self.b
+        X_l = torch.poisson(lambda_val)
+        gaussian_noise = torch.randn_like(X_l) * self.eta
+        Y_l = X_l + gaussian_noise
+
+        if Y_l.shape[0] == 1:
+            Y_l = Y_l.squeeze(0)
+
+        return Y_l