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)

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

.

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

.

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

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.

```
Z <- as.im(function(x,y) { 4 * x^2 + 3 * y }, letterR)
opa <- 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(opa)
```

Run the code above in your browser using DataLab