R: Spatial smoothing of observations at irregular points

Smooth.ppp {spatstat.core} | R Documentation

## Spatial smoothing of observations at irregular points

### Description

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

### Usage

    ## S3 method for class '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)

### Arguments

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

### Details

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],...,v[n] at locations x[1],...,x[n] respectively, then the smoothed value at a location u is (ignoring edge corrections)

g(u) = (sum of k(u-x[i]) v[i])/(sum of 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) = (sum of k(u-x[i]) v[i] w[i])/(sum of 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`.

### Value

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.

### Very small bandwidth

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.

### Author(s)

Adrian Baddeley Adrian.Baddeley@curtin.edu.au, Rolf Turner r.turner@auckland.ac.nz and Ege Rubak rubak@math.aau.dk.

### References

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.

### See Also

`Smooth`,

`density.ppp`, `bw.smoothppp`, `nnmark`, `ppp.object`, `im.object`.

See `idw` for inverse-distance weighted smoothing.

To perform interpolation, see also the `akima` package.

### Examples

       # 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"))

[Package spatstat.core version 1.65-5 Index]