Performs spatial smoothing of numeric values observed at a set of irregular locations. Uses kernel smoothing and least-squares cross-validated bandwidth selection.

```
# S3 method for ppp
Smooth(X, sigma=NULL,
...,
weights = rep(1, npoints(X)),
at="pixels",
adjust=1, varcov=NULL,
edge=TRUE, diggle=FALSE,
kernel="gaussian", scalekernel=is.character(kernel),
geometric=FALSE)
```markmean(X, ...)

markvar(X, sigma=NULL, ..., weights=NULL, varcov=NULL)

X

A marked point pattern (object of class `"ppp"`

).

sigma

Smoothing bandwidth.
A single positive number, a numeric vector of length 2,
or a function that selects the bandwidth automatically.
See `density.ppp`

.

…

Further arguments passed to
`bw.smoothppp`

and `density.ppp`

to control the kernel smoothing and
the pixel resolution of the result.

weights

Optional weights attached to the observations.
A numeric vector, a `function(x,y)`

, a pixel image,
or an `expression`

. See `density.ppp`

.

at

String specifying whether to compute the smoothed values
at a grid of pixel locations (`at="pixels"`

) or
only at the points of `X`

(`at="points"`

).

edge,diggle

Arguments passed to `density.ppp`

to
determine the edge correction.

adjust

Optional. Adjustment factor for the bandwidth `sigma`

.

varcov

Variance-covariance matrix. An alternative
to `sigma`

. See `density.ppp`

.

kernel

The smoothing kernel.
A character string specifying the smoothing kernel
(current options are `"gaussian"`

, `"epanechnikov"`

,
`"quartic"`

or `"disc"`

),
or a pixel image (object of class `"im"`

)
containing values of the kernel, or a `function(x,y)`

which
yields values of the kernel.

scalekernel

Logical value.
If `scalekernel=TRUE`

, then the kernel will be rescaled
to the bandwidth determined by `sigma`

and `varcov`

:
this is the default behaviour when `kernel`

is a character string.
If `scalekernel=FALSE`

, then `sigma`

and `varcov`

will be ignored: this is the default behaviour when `kernel`

is a
function or a pixel image.

geometric

Logical value indicating whether to perform geometric mean smoothing instead of arithmetic mean smoothing. See Details.

*If X has a single column of marks:*

If

`at="pixels"`

(the default), the result is a pixel image (object of class`"im"`

). Pixel values are values of the interpolated function.If

`at="points"`

, the result is a numeric vector of length equal to the number of points in`X`

. Entries are values of the interpolated function at the points of`X`

.

*If X has a data frame of marks:*

If

`at="pixels"`

(the default), the result is a named list of pixel images (object of class`"im"`

). There is one image for each column of marks. This list also belongs to the class`"solist"`

, for which there is a plot method.If

`at="points"`

, the result is a data frame with one row for each point of`X`

, and one column for each column of marks. Entries are values of the interpolated function at the points of`X`

.

The return value has attributes
`"sigma"`

and `"varcov"`

which report the smoothing
bandwidth that was used.

If the chosen bandwidth `sigma`

is very small,
kernel smoothing is mathematically equivalent
to nearest-neighbour interpolation; the result will
be computed by `nnmark`

. This is
unless `at="points"`

and `leaveoneout=FALSE`

,
when the original mark values are returned.

The function `Smooth.ppp`

performs spatial smoothing of numeric values
observed at a set of irregular locations. The functions
`markmean`

and `markvar`

are wrappers for `Smooth.ppp`

which compute the spatially-varying mean and variance of the marks of
a point pattern.

`Smooth.ppp`

is a method for the generic function
`Smooth`

for the class `"ppp"`

of point patterns.
Thus you can type simply `Smooth(X)`

.

Smoothing is performed by kernel weighting, using the Gaussian kernel by default. If the observed values are \(v_1,\ldots,v_n\) at locations \(x_1,\ldots,x_n\) respectively, then the smoothed value at a location \(u\) is (ignoring edge corrections) $$ g(u) = \frac{\sum_i k(u-x_i) v_i}{\sum_i k(u-x_i)} $$ where \(k\) is the kernel (a Gaussian kernel by default). This is known as the Nadaraya-Watson smoother (Nadaraya, 1964, 1989; Watson, 1964). By default, the smoothing kernel bandwidth is chosen by least squares cross-validation (see below).

The argument `X`

must be a marked point pattern (object
of class `"ppp"`

, see `ppp.object`

).
The points of the pattern are taken to be the
observation locations \(x_i\), and the marks of the pattern
are taken to be the numeric values \(v_i\) observed at these
locations.

The marks are allowed to be a data frame (in
`Smooth.ppp`

and `markmean`

). Then the smoothing procedure is applied to each
column of marks.

The numerator and denominator are computed by `density.ppp`

.
The arguments `...`

control the smoothing kernel parameters
and determine whether edge correction is applied.
The smoothing kernel bandwidth can be specified by either of the arguments
`sigma`

or `varcov`

which are passed to `density.ppp`

.
If neither of these arguments is present, then by default the
bandwidth is selected by least squares cross-validation,
using `bw.smoothppp`

.

The optional argument `weights`

allows numerical weights to
be applied to the data. If a weight \(w_i\)
is associated with location \(x_i\), then the smoothed
function is
(ignoring edge corrections)
$$
g(u) = \frac{\sum_i k(u-x_i) v_i w_i}{\sum_i k(u-x_i) w_i}
$$

If `geometric=TRUE`

then geometric mean smoothing
is performed instead of arithmetic mean smoothing.
The mark values must be non-negative numbers.
The logarithm of the mark values is computed; these logarithmic values are
kernel-smoothed as described above; then the exponential function
is applied to the smoothed values.

An alternative to kernel smoothing is inverse-distance weighting,
which is performed by `idw`

.

Nadaraya, E.A. (1964) On estimating regression.
*Theory of Probability and its Applications*
**9**, 141--142.

Nadaraya, E.A. (1989)
*Nonparametric estimation of probability densities
and regression curves*.
Kluwer, Dordrecht.

Watson, G.S. (1964)
Smooth regression analysis.
*Sankhya A* **26**, 359--372.

`density.ppp`

,
`bw.smoothppp`

,
`nnmark`

,
`ppp.object`

,
`im.object`

.

See `idw`

for inverse-distance weighted smoothing.

To perform interpolation, see also the `akima`

package.

# NOT RUN { # Longleaf data - tree locations, marked by tree diameter # Local smoothing of tree diameter (automatic bandwidth selection) Z <- Smooth(longleaf) # Kernel bandwidth sigma=5 plot(Smooth(longleaf, 5)) # mark variance plot(markvar(longleaf, sigma=5)) # data frame of marks: trees marked by diameter and height plot(Smooth(finpines, sigma=2)) head(Smooth(finpines, sigma=2, at="points")) # }