Applies a Gaussian blur to a pixel image.

```
blur(x, sigma = NULL, …,
kernel="gaussian", normalise=FALSE, bleed = TRUE, varcov=NULL)
```# S3 method for im
Smooth(X, sigma = NULL, …,
kernel="gaussian",
normalise=FALSE, bleed = TRUE, varcov=NULL)

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`

.

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

.

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 \ast G\) of the (zero-padded) pixel image \(x\) with the specified Gaussian kernel \(G\).

If `normalise=FALSE`

, then this convolution \(x\ast G\)
is returned.
If `normalise=TRUE`

, then the convolution \(x \ast G\)
is normalised by
dividing it by the convolution \(w \ast 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.

`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.

# NOT RUN { 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)) # }