Filtering Noise and Outliers from LiDAR with PDAL

Airborne LiDAR arrives contaminated with returns that never touched the forest: high points from birds, aircraft, and atmospheric scatter, and low points from multipath reflections and sensor artifacts that sit metres below the true ground. Left in place, a single high-noise return inflates a canopy height percentile and a single low-noise pit anchors a ground filter onto empty air. Removing this noise is the first substantive step in LiDAR Point Cloud Preprocessing, part of the wider Canopy Height Modeling & Terrain Extraction workflow, and it must run before ground classification so that noise is never a candidate ground point. A clean cloud here is what makes the downstream Normalizing LiDAR Point Clouds with PDAL step and the eventual Canopy Height Model Creation trustworthy.

PDAL offers three complementary noise tools. filters.outlier flags statistically or geometrically isolated points and tags them as ASPRS Class 7 (low noise) or 18 (high noise). filters.elm (Extended Local Minimum) specifically hunts the low pits that morphological ground filters are most vulnerable to. filters.range then physically drops the flagged points, or restricts the cloud to any classification range you specify. Used together they turn a raw tile into a noise-free cloud without deleting a single legitimate return.

When to use each tool

Reach for the tool that matches the noise geometry. Most forestry tiles need filters.outlier in statistical mode plus a filters.range cleanup; add filters.elm when low pits survive.

filters.outlier does not delete points — it reclassifies them. To actually remove noise before ground classification, pair it with a filters.range stage that excludes Class 7 and 18, or set filters.csf/filters.smrf to ignore those classes.

Minimal reproducible example

The pipeline below is the production pattern for forested tiles: strip low pits with ELM, flag statistically isolated high and low noise with the outlier filter, then physically drop both noise classes with a range filter so only clean returns survive into ground classification.

{
  "pipeline": [
    "input_tile.laz",
    {
      "type": "filters.elm",
      "cell": 10.0,
      "threshold": 1.0
    },
    {
      "type": "filters.outlier",
      "method": "statistical",
      "mean_k": 12,
      "multiplier": 2.2
    },
    {
      "type": "filters.range",
      "limits": "Classification![7:7],Classification![18:18]"
    },
    {
      "type": "writers.las",
      "filename": "denoised_tile.laz",
      "forward": "all"
    }
  ]
}

filters.elm marks extended-local-minimum points as Class 7. filters.outlier in statistical mode computes each point’s mean distance to its mean_k nearest neighbours and flags any point beyond multiplier standard deviations of the global mean distance — high birds as Class 18, low outliers as Class 7. The filters.range stage then keeps only points whose classification is not 7 and not 18 (the ! negates the range), physically removing them from the cloud.

For dense surveys where point density varies across the tile, radius mode adapts better than the global statistical test:

{
  "type": "filters.outlier",
  "method": "radius",
  "radius": 1.0,
  "min_k": 4
}

Radius mode flags any point with fewer than min_k neighbours inside radius metres — a purely geometric isolation test that does not assume uniform density. Run either variant from Python so parameters stay version-controlled:

import json
import pdal

def denoise(in_laz: str, out_laz: str, mean_k: int = 12, multiplier: float = 2.2) -> int:
    """Flag and remove high/low noise; return the number of points kept."""
    pipeline = {
        "pipeline": [
            in_laz,
            {"type": "filters.elm", "cell": 10.0, "threshold": 1.0},
            {
                "type": "filters.outlier",
                "method": "statistical",
                "mean_k": mean_k,
                "multiplier": multiplier,
            },
            {"type": "filters.range",
             "limits": "Classification![7:7],Classification![18:18]"},
            {"type": "writers.las", "filename": out_laz, "forward": "all"},
        ]
    }
    p = pdal.Pipeline(json.dumps(pipeline))
    kept = p.execute()
    return kept

Parameter reference

The arguments that control detection sensitivity, with dense-forest starting values and the reason each matters.

Expected output and verification

A correct run writes a LAZ with fewer points than the input — the difference is the removed noise — and no returns remaining in Class 7 or 18. The vertical extent should also tighten: the implausible maximum and minimum Z values from birds and pits disappear. Verify both the point-count drop and the surviving Z range:

import numpy as np
import laspy

def verify_denoise(raw_laz: str, clean_laz: str) -> dict:
    """Confirm noise was removed and no Class 7/18 remains in the clean cloud."""
    with laspy.open(raw_laz) as fh:
        raw = fh.read()
    with laspy.open(clean_laz) as fh:
        clean = fh.read()
    clean_cls = np.asarray(clean.classification)
    z = np.asarray(clean.z)
    report = {
        "removed": len(raw.points) - len(clean.points),
        "residual_noise": int(((clean_cls == 7) | (clean_cls == 18)).sum()),
        "z_min": float(z.min()),
        "z_max": float(z.max()),
    }
    assert report["residual_noise"] == 0, "noise classes still present — check filters.range limits"
    assert report["removed"] > 0, "nothing removed — multiplier likely too high"
    return report

print(verify_denoise("input_tile.laz", "denoised_tile.laz"))

Running pdal info --stats denoised_tile.laz reports the same Z minimum and maximum from the command line; both should now sit within physically plausible bounds for the terrain and canopy. If the maximum is still hundreds of metres above the ground, a high bird survived — lower multiplier toward 2.0 or add a radius-mode pass.

Common pitfalls

• Removing too much on steep slopes. A low multiplier (below 2.0) flags legitimate returns on steep ravines and ridgelines as outliers, thinning true terrain. Start at 2.2 and only tighten if noise survives.
• Flagging without removing. filters.outlier only reclassifies to Class 7/18. If you forget the filters.range cleanup (or an ignore on the ground filter), the noise is still in the cloud and still poisons rasterization.
• ELM cell too small. A tiny cell in filters.elm treats normal micro-relief as pits and over-marks ground. Keep cell at 8–20 m so only genuine below-surface artifacts are caught.
• Wrong negation syntax. Classification[7:7] keeps only Class 7; you want Classification![7:7] to exclude it. Mixing these up silently deletes every return except the noise.

Frequently Asked Questions

Related

• LiDAR Point Cloud Preprocessing — the parent workflow this denoising step opens
• Normalizing LiDAR Point Clouds with PDAL — the height-above-ground step that assumes a denoised cloud
• Canopy Height Model Creation — where surviving noise would inflate canopy statistics
• Canopy Height Modeling & Terrain Extraction — the full point-cloud-to-canopy pipeline

Up: LiDAR Point Cloud Preprocessing · Canopy Height Modeling & Terrain Extraction