R: Apply Gaussian Blur to a Pixel Image

blur {spatstat.core} | R Documentation

## Apply Gaussian Blur to a Pixel Image

### Description

Applies a Gaussian blur to a pixel image.

### Usage

    blur(x, sigma = NULL, ...,
         kernel="gaussian", normalise=FALSE, bleed = TRUE, varcov=NULL)

    ## S3 method for class 'im'
    Smooth(X, sigma = NULL, ...,
                        kernel="gaussian",
                        normalise=FALSE, bleed = TRUE, varcov=NULL)

### Arguments

`x,X` | The pixel image. An object of class `"im"`.
`sigma` | Standard deviation of isotropic Gaussian smoothing kernel.
`...` | Ignored.
`kernel` | String (partially matched) specifying the smoothing kernel. Current options are `"gaussian"`, `"epanechnikov"`, `"quartic"` or `"disc"`.
`normalise` | Logical flag indicating whether the output values should be divided by the corresponding blurred image of the window itself. See Details.
`bleed` | Logical flag indicating whether to allow blur to extend outside the original domain of the image. See Details.
`varcov` | Variance-covariance matrix of anisotropic Gaussian kernel. Incompatible with `sigma`.

### Details

This command applies a Gaussian blur to the pixel image `x`.

`Smooth.im` is a method for the generic `Smooth` for pixel images. It is currently identical to `blur`, apart from the name of the first argument.

The blurring kernel is the isotropic Gaussian kernel with standard deviation `sigma`, or the anisotropic Gaussian kernel with variance-covariance matrix `varcov`. The arguments `sigma` and `varcov` are incompatible. Also `sigma` may be a vector of length 2 giving the standard deviations of two independent Gaussian coordinates, thus equivalent to `varcov = diag(sigma^2)`.

If the pixel values of `x` include some `NA` values (meaning that the image domain does not completely fill the rectangular frame) then these `NA` values are first reset to zero.

The algorithm then computes the convolution x * G of the (zero-padded) pixel image x with the specified Gaussian kernel G.

If `normalise=FALSE`, then this convolution x * G is returned. If `normalise=TRUE`, then the convolution x * G is normalised by dividing it by the convolution w * G of the image domain `w` with the same Gaussian kernel. Normalisation ensures that the result can be interpreted as a weighted average of input pixel values, without edge effects due to the shape of the domain.

If `bleed=FALSE`, then pixel values outside the original image domain are set to `NA`. Thus the output is a pixel image with the same domain as the input. If `bleed=TRUE`, then no such alteration is performed, and the result is a pixel image defined everywhere in the rectangular frame containing the input image.

Computation is performed using the Fast Fourier Transform.

### Value

A pixel image with the same pixel array as the input image `x`.

### Author(s)

Adrian Baddeley Adrian.Baddeley@curtin.edu.au and Rolf Turner r.turner@auckland.ac.nz

### See Also

`interp.im` for interpolating a pixel image to a finer resolution, `density.ppp` for blurring a point pattern, `Smooth.ppp` for interpolating marks attached to points.

### Examples

       Z <- as.im(function(x,y) { 4 * x^2 + 3 * y }, letterR)
       par(mfrow=c(1,3))
       plot(Z)
       plot(letterR, add=TRUE)
       plot(blur(Z, 0.3, bleed=TRUE))
       plot(letterR, add=TRUE)
       plot(blur(Z, 0.3, bleed=FALSE))
       plot(letterR, add=TRUE)
       par(mfrow=c(1,1))

[Package spatstat.core version 2.4-4 Index]