Skip to content

r.smooth.edgepreserve

Smoothing with anisotropic diffusion

r.smooth.edgepreserve [-p] input=name output=name threshold=float lambda=float steps=integer function=string [memory=memory in MB] [nprocs=integer] [--overwrite] [--verbose] [--quiet] [--qq] [--ui]

Example:

r.smooth.edgepreserve input=name output=name threshold=5 lambda=0.1 steps=10 function=tukey

grass.script.run_command("r.smooth.edgepreserve", input, output, threshold=5, lambda=0.1, steps=10, function="tukey", memory=300, nprocs=0, flags=None, overwrite=False, verbose=False, quiet=False, superquiet=False)

Example:

gs.run_command("r.smooth.edgepreserve", input="name", output="name", threshold=5, lambda=0.1, steps=10, function="tukey")

Parameters

input=name [required]
    Name of input raster map
output=name [required]
    Name for output raster map
threshold=float [required]
    Gradient magnitude threshold (in map units)
    Allowed values: 0.000000001-
    Default: 5
lambda=float [required]
    Rate of diffusion
    Allowed values: 0-1
    Default: 0.1
steps=integer [required]
    Number of diffusion steps
    Allowed values: 1-
    Default: 10
function=string [required]
    Diffusivity function
    Allowed values: exponential, quadratic, tukey
    Default: tukey
memory=memory in MB
    Maximum memory to be used (in MB)
    Cache size for raster rows
    Default: 300
nprocs=integer
    Number of threads for parallel computing
    0: use OpenMP default; >0: use nprocs; <0: use MAX-nprocs
    Default: 0
-p
    Preserve details with Tukey

--overwrite
    Allow output files to overwrite existing files
--help
    Print usage summary
--verbose
    Verbose module output
--quiet
    Quiet module output
--qq
    Very quiet module output
--ui
    Force launching GUI dialog

input : str, required
    Name of input raster map
    Used as: input, raster, name
output : str, required
    Name for output raster map
    Used as: output, raster, name
threshold : float, required
    Gradient magnitude threshold (in map units)
    Allowed values: 0.000000001-
    Default: 5
lambda : float, required
    Rate of diffusion
    Allowed values: 0-1
    Default: 0.1
steps : int, required
    Number of diffusion steps
    Allowed values: 1-
    Default: 10
function : str, required
    Diffusivity function
    Allowed values: exponential, quadratic, tukey
    Default: tukey
memory : int, optional
    Maximum memory to be used (in MB)
    Cache size for raster rows
    Used as: memory in MB
    Default: 300
nprocs : int, optional
    Number of threads for parallel computing
    0: use OpenMP default; >0: use nprocs; <0: use MAX-nprocs
    Default: 0
flags : str, optional
    Allowed values: p
    p
        Preserve details with Tukey

overwrite: bool, optional
    Allow output files to overwrite existing files
    Default: False
verbose: bool, optional
    Verbose module output
    Default: False
quiet: bool, optional
    Quiet module output
    Default: False
superquiet: bool, optional
    Very quiet module output
    Default: False

DESCRIPTION

This module performs adaptive, edge-preserving raster smoothing using anisotropic diffusion. The result is a denoised raster that retains important features, especially edges. Unlike traditional smoothing methods (such as a uniform average filter, like the one available in r.neighbors), this module smooths only areas with similar values and works to preserve sharp transitions between different regions.

An example of smoothed image
Figure: "A" is the original (unsmoothed) raster and "B" is the smoothed version (with quite agressive settings to emphasize smoothing effects).

The module supports three types of diffusivity (conductance) functions:

  • Exponential
  • Quadratic
    (both as proposed by Perona & Malik, 1990)
  • Tukey’s biweight
    (as proposed by Black et al., 1998)

The Tukey’s biweight function is more aggressive than the others and tends to produce large, smoothly blended areas. This makes it particularly useful for raster segmentation. If you prefer a gentler effect that preserves smaller features, you can use the -p flag, which switches to a softer variant of the Tukey function — ideal for applications like visualization.

Parameters

  • threshold
    Defines how small a difference in raster values should be treated as noise. The unit depends on the raster (e.g., digital numbers, meters, etc.), and should be adjusted individually for each map.

  • lambda
    Controls the smoothing rate.

  • For exponential and quadratic functions, the value is automatically clamped between 0 and 0.25 for numeric stability.
  • For Tukey, the full range is used.

  • steps
    Specifies the number of smoothing iterations. Higher values result in stronger smoothing.
    Note that:

  • Excessive iterations can cause loss of fine detail.
  • Detail preservation improves in this order:
    quadraticexponentialTukeyTukey with -p flag.

NOTES

Internally calculations are performed in double precision and only at the end converted to the same type as the input map.

The module will try to keep all temporary data in RAM. Thus it is important to set the memory parameter as high as possible. If the map does not fit into RAM, a temporary file will be used instead.

The original Perona & Malik paper uses von Neumann (4-connected) neighbourhood for value calculation, but this module uses Moore (8-connected) neighbourhood. Computed gradients of neighbouring cells are adjusted to equalise distances for diagonals and non-square cells.

EXAMPLES

# Set computational region to orthophoto map
g.region raster=ortho_2001_t792_1m -p

# Smooth with average in a 3x3 window. Note how all edges have became blurry
# but at the same time streets and roofs are still noisy
r.neighbors input=ortho_2001_t792_1m output=ortho_smoothed_avg \
 size=3 method=average

# Smooth with median in a 3x3 window. Although better than average smoothing,
# thin lines still are lost and noise on streets and roofs is still present.
r.neighbors input=ortho_2001_t792_1m output=ortho_smoothed_med \
 size=3 method=median

# Smooth with quadratic diffusivity function. Note better preservation of
# small details and reduction of noise on streets and roofs.
r.smooth.edgepreserve function=quadratic input=ortho_2001_t792_1m \
 output=ortho_smoothed_qa threshold=15 lambda=0.4 steps=20

# Smooth with exponential diffusivity function. Even better edge delineation
# but at the same time increase of noise in really noisy areas.
r.smooth.edgepreserve function=exponential input=ortho_2001_t792_1m \
 output=ortho_smoothed_ex threshold=15 lambda=0.4 steps=20

# Smooth with aggressive Tukey's diffusivity function. Better preservation of
# minor details e.g. as road markings but little smoothing in areas with
# fine, well expressed texture.
r.smooth.edgepreserve function=tukey input=ortho_2001_t792_1m \
 output=ortho_smoothed_ta threshold=15 lambda=0.4 steps=20

# Smooth with preserving Tukey's diffusivity function. Only low noise areas
# have been smoothed.
r.smooth.edgepreserve function=tukey input=ortho_2001_t792_1m \
 output=ortho_smoothed_tp threshold=15 lambda=0.4 steps=20 -p

SEE ALSO

  • Smooth with statistics: r.neighbours
  • The Mumford-Shah variational model for image segmentation (an add-on): r.smooth.seg

REFERENCES

  • Perona P. and Malik J. 1990. Scale-space and edge detection using anisotropic diffusion. IEEE transactions on pattern analysis and machine intelligence, 12(7).
  • Black M.J., Sapiro G., Marimont D.H. and Heeger D. 1998. Robust anisotropic diffusion. IEEE transactions on image processing, 7(3).

AUTHOR

Maris Nartiss, University of Latvia.

SOURCE CODE

Available at: r.smooth.edgepreserve source code (history)
Latest change: Sunday Jun 29 19:27:34 2025 in commit 99487ae