|
|
""" |
|
|
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 |
|
|
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 |
|
|
|
|
|
|
|
|
|
|
|
calcSurf = calc_height_surface |
|
|
createCHM = create_chm |
|
|
|
|
|
__all__ = [ |
|
|
"adaptive_dtm_filter", |
|
|
"apply_kernel", |
|
|
"calc_height_surface", |
|
|
"calcSurf", |
|
|
"create_chm", |
|
|
"createCHM", |
|
|
"hillshade", |
|
|
] |
|
|
|
