# MeanShiftSmoothing¶

This application smooths an image using the MeanShift algorithm.

## Description¶

MeanShift [1,2,3] is an iterative edge-preserving image smoothing algorithm often used in image processing and as a first step for image segmentation. The MeanShift algorithm can be applied to multispectral images.

At first iteration, for any given pixel of the input image, the filtered value correspond to the average spectral signature of neighborhood pixels that are both spatially closer than the spatial radius parameter (spatialr) and with spectral signature that have an euclidean distance to the input pixel lower than the range radius (ranger), that is, pixels that are both close in space and in spectral signatures. Subsequent iterations will repeat this process by considering that the pixel signature corresponds to the average spectral signature computed during previous iteration, and that the pixel position corresponds to the average position of pixels used to compute the average signature.The algorithm stops when the maximum number of iterations (maxiter) is reached, or when the position and spectral signature does not change much between iterations, according to the convergence threshold (thres). If the modesearch option is used then convergence will also stops if the spatial position reaches a pixel that has already converged. This will speed-up convergence, at the expense of stability of the result.

The application outputs the image of the final averaged spectral signatures (fout), and can also optionally output the 2D displacement field between input pixel position and final pixel position after convergence (foutpos).

Note that computing an euclidean distance between spectral signatures may be inaccurate and that techniques such as color space transform or image normalisation could be applied before using this application. Also note that most satellite images noise model is not gaussian, since noise variance linearly depends on radiance (the higher the radiance, the higher the noise variance). To account for such noise model, the application provides the range radius ramp option (rangeramp), which will vary the range radius linearly with the central pixel intensity. Default value is 1. (no ramp).

This application is the first step of the large scale MeanShift method depicted in [4]. Both outputs (fout and foutpos) can be passed to the large scale MeanShift segmentation application [5]. If the application is used for large scale MeanShift, modesearch option should be off.

This application has several output images and supports “multi-writing”. Instead of computing and writing each image independently, the streamed image blocks are written in a synchronous way for each output. The output images will be computed strip by strip, using the available RAM to compute the strip size, and a user defined streaming mode can be specified using the streaming extended filenames (type, mode and value). Note that multi-writing can be disabled using the multi-write extended filename option: &multiwrite=false, in this case the output images will be written one by one. Note that multi-writing is not supported for MPI writers.

## Parameters¶

**Input Image** `-in image`

*Mandatory*

The input image can be any single or multiband image. Beware of pontential imbalance between bands ranges as it may alter euclidean distance.

**Spectral filtered output** `-fout image [dtype]`

*Mandatory*

This output image contains the final average spectral signatures of each pixel. The output type should be at least as wide as the input image type. Floating point encoding is advised. This output can be used as input image (in) of the LSMSSegmentation application [4,5].

**Spatial filtered displacement output**`-foutpos image [dtype]`

- This output image contains the 2D displacement between the input pixel spatial position and the final position after convergence. Floating point encoding is mandatory. This output can be used as input image (in) of the LSMSSegmentation application [4,5].

**Spatial radius** `-spatialr int`

*Default value: 5*

Radius of the spatial neighborhood for averaging. Higher values will result in more smoothing and higher processing time.

**Range radius** `-ranger float`

*Default value: 15*

Threshold on spectral signature euclidean distance (expressed in radiometry unit) to consider neighborhood pixel for averaging. Higher values will be less edge-preserving (more similar to simple average in neighborhood), whereas lower values will result in less noise smoothing. Note that this parameter has no effect on processing time.

**Mode convergence threshold** `-thres float`

*Default value: 0.1*

Algorithm will stop if update of average spectral signature and spatial position is below this threshold.

**Maximum number of iterations** `-maxiter int`

*Default value: 100*

Algorithm will stop if convergence threshold is not met after the maximum number of iterations.

**Range radius ramp coefficient** `-rangeramp float`

*Default value: 0*

Vary the range radius linearly with the central pixel intensity (experimental).

**Mode search** `-modesearch bool`

*Default value: false*

If activated pixel iterative convergence is stopped if the path crosses an already converged pixel. Be careful, with this option, the result will slightly depend on thread number and the results will not be stable (see [4] for more details).

**Available RAM (MB)** `-ram int`

*Default value: 256*

Available memory for processing (in MB).

## Examples¶

From the command-line:

```
otbcli_MeanShiftSmoothing -in maur_rgb.png -fout smooth.tif -foutpos position.tif -spatialr 16 -ranger 16 -thres 0.1 -maxiter 100
```

From Python:

```
import otbApplication
app = otbApplication.Registry.CreateApplication("MeanShiftSmoothing")
app.SetParameterString("in", "maur_rgb.png")
app.SetParameterString("fout", "smooth.tif")
app.SetParameterString("foutpos", "position.tif")
app.SetParameterInt("spatialr", 16)
app.SetParameterFloat("ranger", 16)
app.SetParameterFloat("thres", 0.1)
app.SetParameterInt("maxiter", 100)
app.ExecuteAndWriteOutput()
```

## Limitations¶

When modesearch is on, the application will yield slightly different results between executions, due to multi-threading. Results will also not be stable [4].