# spatstat-package

##### The Spatstat Package

This is a summary of the features of
`R`

for the statistical analysis of spatial point patterns.

##### Details

The package supports

- creation, manipulation and plotting of point patterns
- exploratory data analysis
- simulation of point process models
- parametric model-fitting
- hypothesis tests and model diagnostics

The package can fit several types of point process models to a point pattern dataset:

- Poisson point process models (by Berman-Turner approximate maximum likelihood or by spatial logistic regression)
- Gibbs/Markov point process models (by Baddeley-Turner approximate maximum pseudolikelihood, Coeurjolly-Rubak logistic likelihood, or Huang-Ogata approximate maximum likelihood)
- Cox/cluster process models (by Waagepetersen's two-step fitting procedure and minimum contrast, or by composite likelihood)

`formula`

in the `R`

language, and are fitted using
a function analogous to `lm`

and `glm`

.
Fitted models can be printed, plotted, predicted, simulated and so on.
##### Getting Started

For a quick introduction to *Getting started with spatstat*
installed with `help.start()`

to open the help browser, and
navigate to `Packages > spatstat > Vignettes`

).

For a complete 2-day course on using

Type `demo(spatstat)`

for a demonstration
of the package's capabilities.
Type `demo(data)`

to see all the datasets
available in the package.
For information about handling data in **shapefiles**,
see the Vignette *Handling shapefiles in the spatstat package*
installed with

To learn about spatial point process methods, see the short book by Diggle (2003) and the handbook Gelfand et al (2010).

##### Updates

New versions of `latest.news`

to read the news documentation about
changes to the current installed version of

See the Vignette *Summary of recent updates*,
installed with `news(package="spatstat")`

to read news documentation about
all previous versions of the package.

##### FUNCTIONS AND DATASETS

Following is a summary of the main functions and datasets
in the `library(help=spatstat)`

.

For further information on any of these,
type `help(name)`

where `name`

is the name of the function
or dataset.

##### CONTENTS:

##### I. CREATING AND MANIPULATING DATA

**Types of spatial data:**

The main types of spatial data supported by

`ppp`

point pattern
`owin`

window (spatial region)
`im`

pixel image
`psp`

line segment pattern
`tess`

tessellation
`pp3`

three-dimensional point pattern
`ppx`

point pattern in any number of dimensions
`lpp`

point pattern on a linear network
}

**To create a point pattern:**
`ppp`

create a point pattern from $(x,y)$ and window information
`ppp(x, y, xlim, ylim)`

for rectangular window
`ppp(x, y, poly)`

for polygonal window
`ppp(x, y, mask)`

for binary image window
`as.ppp`

convert other types of data to a `ppp`

object
`clickppp`

interactively add points to a plot
`marks<-`

, `%mark%`

attach/reassign marks to a point pattern
}
**To simulate a random point pattern:**
`runifpoint`

generate $n$ independent uniform random points
`rpoint`

generate $n$ independent random points
`rmpoint`

generate $n$ independent multitype random points
`rpoispp`

simulate the (in)homogeneous Poisson point process
`rmpoispp`

simulate the (in)homogeneous multitype Poisson point process
`runifdisc`

generate $n$ independent uniform random points in disc
`rstrat`

stratified random sample of points
`rsyst`

systematic random sample of points
`rjitter`

apply random displacements to points in a pattern
`rMaternI`

simulate the `rMaternII`

simulate the `rSSI`

simulate Simple Sequential Inhibition process
`rStrauss`

simulate Strauss process (perfect simulation)
`rHardcore`

simulate Hard Core process (perfect simulation)
`rDiggleGratton`

simulate Diggle-Gratton process (perfect simulation)
`rDGS`

simulate Diggle-Gates-Stibbard process (perfect simulation)
`rNeymanScott`

simulate a general Neyman-Scott process
`rPoissonCluster`

simulate a general Neyman-Scott process
`rNeymanScott`

simulate a general Neyman-Scott process
`rMatClust`

simulate the `rThomas`

simulate the Thomas process
`rGaussPoisson`

simulate the Gauss-Poisson cluster process
`rCauchy`

simulate Neyman-Scott Cauchy cluster process
`rVarGamma`

simulate Neyman-Scott Variance Gamma cluster process
`rthin`

random thinning
`rcell`

simulate the Baddeley-Silverman cell process
`rmh`

simulate Gibbs point process using Metropolis-Hastings
`simulate.ppm`

simulate Gibbs point process using Metropolis-Hastings
`runifpointOnLines`

generate $n$ random points along specified line segments
`rpoisppOnLines`

generate Poisson random points along specified line segments
}

**To randomly change an existing point pattern:**
`rshift`

random shifting of points
`rjitter`

apply random displacements to points in a pattern
`rthin`

random thinning
`rlabel`

random (re)labelling of a multitype
point pattern
`quadratresample`

block resampling
}

**Standard point pattern datasets:**

Datasets in `data(amacrine)`

etc.

Type `demo(data)`

to see a display of all the datasets
installed with the package.
`amacrine`

Austin Hughes' rabbit amacrine cells
`anemones`

Upton-Fingleton sea anemones data
`ants`

Harkness-Isham ant nests data
`bei`

Tropical rainforest trees
`betacells`

Waessle et al. cat retinal ganglia data
`bramblecanes`

Bramble Canes data
`bronzefilter`

Bronze Filter Section data
`cells`

Crick-Ripley biological cells data
`chicago`

Chicago street crimes
`chorley`

Chorley-Ribble cancer data
`clmfires`

Castilla-La Mancha forest fires
`copper`

Berman-Huntington copper deposits data
`demohyper`

Synthetic point patterns
`demopat`

Synthetic point pattern
`finpines`

Finnish Pines data
`flu`

Influenza virus proteins
`gordon`

People in Gordon Square, London
`gorillas`

Gorilla nest sites
`hamster`

Aherne's hamster tumour data
`humberside`

North Humberside childhood leukaemia data
`hyytiala`

Mixed forest in
`japanesepines`

Japanese Pines data
`lansing`

Lansing Woods data
`longleaf`

Longleaf Pines data
`mucosa`

Cells in gastric mucosa
`murchison`

Murchison gold deposits
`nbfires`

New Brunswick fires data
`nztrees`

Mark-Esler-Ripley trees data
`osteo`

Osteocyte lacunae (3D, replicated)
`paracou`

Kimboto trees in Paracou, French Guiana
`ponderosa`

Getis-Franklin ponderosa pine trees data
`pyramidal`

Pyramidal neurons from 31 brains
`redwood`

Strauss-Ripley redwood saplings data
`redwoodfull`

Strauss redwood saplings data (full set)
`residualspaper`

Data from Baddeley et al (2005)
`shapley`

Galaxies in an astronomical survey
`simdat`

Simulated point pattern (inhomogeneous, with interaction)
`spruces`

Spruce trees in Saxonia
`swedishpines`

Strand-Ripley Swedish pines data
`urkiola`

Urkiola Woods data
`waka`

Trees in Waka national park
`waterstriders`

Insects on water surface

##### bold

- To manipulate a point pattern:
- To create a window:
- To manipulate a window:
- Digital approximations:
- Geometrical computations with windows:
- Pixel images:
- Line segment patterns
- Tessellations
- Three-dimensional point patterns
- Multi-dimensional space-time point patterns
- Point patterns on a linear network
- Hyperframes
- Layered objects
- Colour maps

##### tabular

- ll
- ll
- ll
- ll
- ll
- ll
- ll
- ll
- ll
- ll
- ll
- ll
- ll
- ll
- ll

##### code

##### tab

- plot a point pattern (e.g.
`plot(X)`

)`iplot`

plot a point pattern interactively`[.ppp`

extract or replace a subset of a point pattern`pp[subset]`

or`pp[subwindow]`

`superimpose`

combine several point patterns`by.ppp`

apply a function to sub-patterns of a point pattern`cut.ppp`

classify the points in a point pattern`unmark`

remove marks`npoints`

count the number of points`coords`

extract coordinates, change coordinates`marks`

extract marks, change marks or attach marks`split.ppp`

divide pattern into sub-patterns`rotate`

rotate pattern`shift`

translate pattern`flipxy`

swap $x$ and $y$ coordinates`reflect`

reflect in the origin`periodify`

make several translated copies`affine`

apply affine transformation`scalardilate`

apply scalar dilation`density.ppp`

kernel estimation of point pattern intensity`Smooth.ppp`

kernel smoothing of marks of point pattern`nnmark`

mark value of nearest data point`sharpen.ppp`

data sharpening`identify.ppp`

interactively identify points`unique.ppp`

remove duplicate points`duplicated.ppp`

determine which points are duplicates`connected.ppp`

find clumps of points`dirichlet`

compute Dirichlet-Voronoi tessellation`delaunay`

compute Delaunay triangulation`delaunay.distance`

graph distance in Delaunay triangulation`convexhull`

compute convex hull`discretise`

discretise coordinates`pixellate.ppp`

approximate point pattern by pixel image`as.im.ppp`

approximate point pattern by pixel image - Create a window object
`owin(xlim, ylim)`

for rectangular window`owin(poly)`

for polygonal window`owin(mask)`

for binary image window`as.owin`

Convert other data to a window object`square`

make a square window`disc`

make a circular window`ripras`

Ripley-Rasson estimator of window, given only the points`convexhull`

compute convex hull of something`letterR`

polygonal window in the shape of the Rlogo - plot a window.
`plot(W)`

`bounding.box`

Find a tight bounding box for the window`erosion`

erode window by a distance r`dilation`

dilate window by a distance r`closing`

close window by a distance r`opening`

open window by a distance r`border`

difference between window and its erosion/dilation`complement.owin`

invert (swap inside and outside)`simplify.owin`

approximate a window by a simple polygon`rotate`

rotate window`flipxy`

swap $x$ and $y$ coordinates`shift`

translate window`periodify`

make several translated copies`affine`

apply affine transformation - Make a discrete pixel approximation of a given window
`as.im.owin`

convert window to pixel image`pixellate.owin`

convert window to pixel image`commonGrid`

find common pixel grid for windows`nearest.raster.point`

map continuous coordinates to raster locations`raster.x`

raster x coordinates`raster.y`

raster y coordinates`as.polygonal`

convert pixel mask to polygonal window - intersection of two windows
`union.owin`

union of two windows`setminus.owin`

set subtraction of two windows`inside.owin`

determine whether a point is inside a window`area.owin`

compute area`perimeter`

compute perimeter length`diameter.owin`

compute diameter`incircle`

find largest circle inside a window`connected.owin`

find connected components of window`eroded.areas`

compute areas of eroded windows`dilated.areas`

compute areas of dilated windows`bdist.points`

compute distances from data points to window boundary`bdist.pixels`

compute distances from all pixels to window boundary`bdist.tiles`

boundary distance for each tile in tessellation`distmap.owin`

distance transform image`distfun.owin`

distance transform`centroid.owin`

compute centroid (centre of mass) of window`is.subset.owin`

determine whether one window contains another`is.convex`

determine whether a window is convex`convexhull`

compute convex hull`as.mask`

pixel approximation of window`as.polygonal`

polygonal approximation of window`is.rectangle`

test whether window is a rectangle`is.polygonal`

test whether window is polygonal`is.mask`

test whether window is a mask`setcov`

spatial covariance function of window - create a pixel image
`as.im`

convert other data to a pixel image`pixellate`

convert other data to a pixel image`as.matrix.im`

convert pixel image to matrix`as.data.frame.im`

convert pixel image to data frame`plot.im`

plot a pixel image on screen as a digital image`contour.im`

draw contours of a pixel image`persp.im`

draw perspective plot of a pixel image`rgbim`

create colour-valued pixel image`hsvim`

create colour-valued pixel image`[.im`

extract a subset of a pixel image`[<-.im`

replace a subset of a pixel image`rotate.im`

rotate pixel image`shift.im`

apply vector shift to pixel image`affine.im`

apply affine transformation to image`X`

print very basic information about image`X`

`summary(X)`

summary of image`X`

`hist.im`

histogram of image`mean.im`

mean pixel value of image`integral.im`

integral of pixel values`quantile.im`

quantiles of image`cut.im`

convert numeric image to factor image`is.im`

test whether an object is a pixel image`interp.im`

interpolate a pixel image`blur`

apply Gaussian blur to image`Smooth.im`

apply Gaussian blur to image`connected.im`

find connected components`compatible.im`

test whether two images have compatible dimensions`harmonise.im`

make images compatible`commonGrid`

find a common pixel grid for images`eval.im`

evaluate any expression involving images`scaletointerval`

rescale pixel values`zapsmall.im`

set very small pixel values to zero`levelset`

level set of an image`solutionset`

region where an expression is true`imcov`

spatial covariance function of image`convolve.im`

spatial convolution of images`transect.im`

line transect of image - create a line segment pattern
`as.psp`

convert other data into a line segment pattern`is.psp`

determine whether a dataset has class`"psp"`

`plot.psp`

plot a line segment pattern`print.psp`

print basic information`summary.psp`

print summary information`[.psp`

extract a subset of a line segment pattern`as.data.frame.psp`

convert line segment pattern to data frame`marks.psp`

extract marks of line segments`marks<-.psp`

assign new marks to line segments`unmark.psp`

delete marks from line segments`midpoints.psp`

compute the midpoints of line segments`endpoints.psp`

extract the endpoints of line segments`lengths.psp`

compute the lengths of line segments`angles.psp`

compute the orientation angles of line segments`superimpose`

combine several line segment patterns`flipxy`

swap $x$ and $y$ coordinates`rotate.psp`

rotate a line segment pattern`shift.psp`

shift a line segment pattern`periodify`

make several shifted copies`affine.psp`

apply an affine transformation`pixellate.psp`

approximate line segment pattern by pixel image`as.mask.psp`

approximate line segment pattern by binary mask`distmap.psp`

compute the distance map of a line segment pattern`distfun.psp`

compute the distance map of a line segment pattern`density.psp`

kernel smoothing of line segments`selfcrossing.psp`

find crossing points between line segments`crossing.psp`

find crossing points between two line segment patterns`nncross`

find distance to nearest line segment from a given point`nearestsegment`

find line segment closest to a given point`project2segment`

find location along a line segment closest to a given point`pointsOnLines`

generate points evenly spaced along line segment`rpoisline`

generate a realisation of the Poisson line process inside a window`rlinegrid`

generate a random array of parallel lines through a window - create a tessellation
`quadrats`

create a tessellation of rectangles`hextess`

create a tessellation of hexagons`as.tess`

convert other data to a tessellation`plot.tess`

plot a tessellation`tiles`

extract all the tiles of a tessellation`[.tess`

extract some tiles of a tessellation`[<-.tess`

change some tiles of a tessellation`intersect.tess`

intersect two tessellations or restrict a tessellation to a window`chop.tess`

subdivide a tessellation by a line`dirichlet`

compute Dirichlet-Voronoi tessellation of points`delaunay`

compute Delaunay triangulation of points`rpoislinetess`

generate tessellation using Poisson line process`tile.areas`

area of each tile in tessellation`bdist.tiles`

boundary distance for each tile in tessellation - create a 3-D point pattern
`plot.pp3`

plot a 3-D point pattern`coords`

extract coordinates`as.hyperframe`

extract coordinates`unitname.pp3`

name of unit of length`npoints`

count the number of points`runifpoint3`

generate uniform random points in 3-D`rpoispp3`

generate Poisson random points in 3-D`envelope.pp3`

generate simulation envelopes for 3-D pattern`box3`

create a 3-D rectangular box`as.box3`

convert data to 3-D rectangular box`unitname.box3`

name of unit of length`diameter.box3`

diameter of box`volume.box3`

volume of box`shortside.box3`

shortest side of box`eroded.volumes`

volumes of erosions of box - create a multidimensional space-time point pattern
`coords`

extract coordinates`as.hyperframe`

extract coordinates`unitname.ppx`

name of unit of length`npoints`

count the number of points`runifpointx`

generate uniform random points`rpoisppx`

generate Poisson random points`boxx`

define multidimensional box`diameter.boxx`

diameter of box`volume.boxx`

volume of box`shortside.boxx`

shortest side of box`eroded.volumes.boxx`

volumes of erosions of box - create a linear network
`clickjoin`

interactively join vertices in network`simplenet`

simple example of network`lineardisc`

disc in a linear network`methods.linnet`

methods for`linnet`

objects - create a point pattern on a linear network
`methods.lpp`

methods for`lpp`

objects`rpoislpp`

simulate Poisson points on linear network`runiflpp`

simulate random points on a linear network`chicago`

Chicago street crime data - create a hyperframe
`as.hyperframe`

convert data to hyperframe`plot.hyperframe`

plot hyperframe`with.hyperframe`

evaluate expression using each row of hyperframe`cbind.hyperframe`

combine hyperframes by columns`rbind.hyperframe`

combine hyperframes by rows`as.data.frame.hyperframe`

convert hyperframe to data frame - create layered object
`plot.layered`

plot layered object`[.layered`

extract subset of layered object - create a colour map
`plot.colourmap`

plot the colour map only`tweak.colourmap`

alter individual colour values`interp.colourmap`

make a smooth transition between colours`beachcolourmap`

one special colour map

##### pkg

spatstat

##### II. EXPLORATORY DATA ANALYSIS

**Inspection of data:**
`summary(X)`

print useful summary of point pattern `X`

`X`

print basic description of point pattern `X`

`any(duplicated(X))`

check for duplicated points in pattern `X`

`istat(X)`

Interactive exploratory analysis
}

**Classical exploratory tools:**
`clarkevans`

Clark and Evans aggregation index
`fryplot`

Fry plot
`miplot`

Morishita Index plot
}

**Smoothing:**
`density.ppp`

kernel smoothed density/intensity
`relrisk`

kernel estimate of relative risk
`Smooth.ppp`

spatial interpolation of marks
`bw.diggle`

cross-validated bandwidth selection
for `density.ppp`

`bw.ppl`

likelihood cross-validated bandwidth selection
for `density.ppp`

`bw.scott`

Scott's rule of thumb
for density estimation
`bw.relrisk`

cross-validated bandwidth selection
for `relrisk`

`bw.smoothppp`

cross-validated bandwidth selection
for `Smooth.ppp`

`bw.frac`

bandwidth selection using window geometry
`bw.stoyan`

Stoyan's rule of thumb for bandwidth
for `pcf`

}

**Modern exploratory tools:**
`clusterset`

Allard-Fraley feature detection
`nnclean`

Byers-Raftery feature detection
`sharpen.ppp`

Choi-Hall data sharpening
`rhohat`

Kernel estimate of covariate effect
`rho2hat`

Kernel estimate of covariate effect
}

**Summary statistics for a point pattern:**
Type `demo(sumfun)`

for a demonstration of many
of the summary statistics.
`intensity`

Mean intensity
`quadratcount`

Quadrat counts
`intensity.quadratcount`

Mean intensity in quadrats
`Fest`

empty space function $F$
`Gest`

nearest neighbour distribution function $G$
`Jest`

$J$-function $J = (1-G)/(1-F)$
`Kest`

Ripley's $K$-function
`Lest`

Besag $L$-function
`Tstat`

Third order $T$-function
`allstats`

all four functions $F$, $G$, $J$, $K$
`pcf`

pair correlation function
`Kinhom`

$K$ for inhomogeneous point patterns
`Linhom`

$L$ for inhomogeneous point patterns
`pcfinhom`

pair correlation for inhomogeneous patterns
`Finhom`

$F$ for inhomogeneous point patterns
`Ginhom`

$G$ for inhomogeneous point patterns
`Jinhom`

$J$ for inhomogeneous point patterns
`localL`

Getis-Franklin neighbourhood density function
`localK`

neighbourhood K-function
`localpcf`

local pair correlation function
`localKinhom`

local $K$ for inhomogeneous point patterns
`localLinhom`

local $L$ for inhomogeneous point patterns
`localpcfinhom`

local pair correlation for inhomogeneous patterns
`Kest.fft`

fast $K$-function using FFT for large datasets
`Kmeasure`

reduced second moment measure
`envelope`

simulation envelopes for a summary
function
`varblock`

variances and confidence intervals
for a summary function
`lohboot`

bootstrap for a summary function
}

Related facilities:
`plot.fv`

plot a summary function
`eval.fv`

evaluate any expression involving
summary functions
`eval.fasp`

evaluate any expression involving
an array of functions
`with.fv`

evaluate an expression for a
summary function
`Smooth.fv`

apply smoothing to a summary function
`deriv.fv`

calculate derivative of a summary function
`nndist`

nearest neighbour distances
`nnwhich`

find nearest neighbours
`pairdist`

distances between all pairs of points
`crossdist`

distances between points in two patterns
`nncross`

nearest neighbours between two point patterns
`exactdt`

distance from any location to nearest data point
`distmap`

distance map image
`distfun`

distance map function
`nnmap`

nearest point image
`nnfun`

nearest point function
`density.ppp`

kernel smoothed density
`Smooth.ppp`

spatial interpolation of marks
`relrisk`

kernel estimate of relative risk
`sharpen.ppp`

data sharpening
`rknn`

theoretical distribution of nearest
neighbour distance
}

**Summary statistics for a multitype point pattern:**
A multitype point pattern is represented by an object `X`

of class `"ppp"`

such that `marks(X)`

is a factor.
`relrisk`

kernel estimation of relative risk
`scan.test`

spatial scan test of elevated risk
`Gcross,Gdot,Gmulti`

multitype nearest neighbour distributions
$G_{ij}, G_{i\bullet}$
`Kcross,Kdot, Kmulti`

multitype $K$-functions
$K_{ij}, K_{i\bullet}$
`Lcross,Ldot`

multitype $L$-functions
$L_{ij}, L_{i\bullet}$
`Jcross,Jdot,Jmulti`

multitype $J$-functions
$J_{ij}, J_{i\bullet}$
`pcfcross`

multitype pair correlation function $g_{ij}$
`pcfdot`

multitype pair correlation function $g_{i\bullet}$
`pcfmulti`

general pair correlation function
`markconnect`

marked connection function $p_{ij}$
`alltypes`

estimates of the above
for all $i,j$ pairs
`Iest`

multitype $I$-function
`Kcross.inhom,Kdot.inhom`

inhomogeneous counterparts of `Kcross`

, `Kdot`

`Lcross.inhom,Ldot.inhom`

inhomogeneous counterparts of `Lcross`

, `Ldot`

`pcfcross.inhom,pcfdot.inhom`

inhomogeneous counterparts of `pcfcross`

, `pcfdot`

}

**Summary statistics for a marked point pattern:**
A marked point pattern is represented by an object `X`

of class `"ppp"`

with a component `X$marks`

.
The entries in the vector `X$marks`

may be numeric, complex,
string or any other atomic type. For numeric marks, there are the
following functions:
`markmean`

smoothed local average of marks
`markvar`

smoothed local variance of marks
`markcorr`

mark correlation function
`markvario`

mark variogram
`markcorrint`

mark correlation integral
`Emark`

mark independence diagnostic $E(r)$
`Vmark`

mark independence diagnostic $V(r)$
`nnmean`

nearest neighbour mean index
`nnvario`

nearest neighbour mark variance index
}
For marks of any type, there are the following:
`Gmulti`

multitype nearest neighbour distribution
`Kmulti`

multitype $K$-function
`Jmulti`

multitype $J$-function
}
Alternatively use `cut.ppp`

to convert a marked point pattern
to a multitype point pattern.

**Programming tools:**
`applynbd`

apply function to every neighbourhood
in a point pattern
`markstat`

apply function to the marks of neighbours
in a point pattern
`marktable`

tabulate the marks of neighbours
in a point pattern
`pppdist`

find the optimal match between two point
patterns
}

**Summary statistics for a point pattern on a linear network:**

These are for point patterns on a linear network (class `lpp`

).
For unmarked patterns:
`linearK`

$K$ function on linear network
`linearKinhom`

inhomogeneous $K$ function on linear network
`linearpcf`

pair correlation function on linear network
`linearpcfinhom`

inhomogeneous pair correlation on linear network
}

For multitype patterns:
`linearKcross`

$K$ function between two types of points
`linearKdot`

$K$ function from one type to any type
`linearKcross.inhom`

Inhomogeneous version of `linearKcross`

`linearKdot.inhom`

Inhomogeneous version of `linearKdot`

`linearmarkconnect`

Mark connection function on linear network
`linearmarkequal`

Mark equality function on linear network
`linearpcfcross`

Pair correlation between two types of points
`linearpcfdot`

Pair correlation from one type to any type
`linearpcfcross.inhom`

Inhomogeneous version of `linearpcfcross`

`linearpcfdot.inhom`

Inhomogeneous version of `linearpcfdot`

}

Related facilities:
`pairdist.lpp`

distances between pairs
`crossdist.lpp`

distances between pairs
`nndist.lpp`

nearest neighbour distances
`nncross.lpp`

nearest neighbour distances
`nnwhich.lpp`

find nearest neighbours
`nnfun.lpp`

find nearest data point
`distfun.lpp`

distance transform
`envelope.lpp`

simulation envelopes
`rpoislpp`

simulate Poisson points on linear network
`runiflpp`

simulate random points on a linear network
}
It is also possible to fit point process models to `lpp`

objects.
See Section IV.
**Summary statistics for a three-dimensional point pattern:**

These are for 3-dimensional point pattern objects (class `pp3`

).

`F3est`

empty space function $F$
`G3est`

nearest neighbour function $G$
`K3est`

$K$-function
`pcf3est`

pair correlation function
}

Related facilities:
`envelope.pp3`

simulation envelopes
`pairdist.pp3`

distances between all pairs of
points
`crossdist.pp3`

distances between points in
two patterns
`nndist.pp3`

nearest neighbour distances
`nnwhich.pp3`

find nearest neighbours
`nncross.pp3`

find nearest neighbours in another pattern
}

**Computations for multi-dimensional point pattern:**

These are for multi-dimensional space-time
point pattern objects (class `ppx`

).

`pairdist.ppx`

distances between all pairs of
points
`crossdist.ppx`

distances between points in
two patterns
`nndist.ppx`

nearest neighbour distances
`nnwhich.ppx`

find nearest neighbours
}

**Summary statistics for random sets:**
These work for point patterns (class `ppp`

),
line segment patterns (class `psp`

)
or windows (class `owin`

).
`Hest`

spherical contact distribution $H$
`Gfox`

Foxall $G$-function
`Jfox`

Foxall $J$-function
}

##### III. MODEL FITTING (CLUSTER MODELS)

Cluster process models (with homogeneous or inhomogeneous intensity)
and Cox processes can be fitted by the function `kppm`

.
Its result is an object of class `"kppm"`

.
The fitted model can be printed, plotted, predicted, simulated
and updated.

`kppm`

Fit model
`plot.kppm`

Plot the fitted model
`fitted.kppm`

Compute fitted intensity
`predict.kppm`

Compute fitted intensity
`update.kppm`

Update the model
`simulate.kppm`

Generate simulated realisations
`vcov.kppm`

Variance-covariance matrix of coefficients
`Kmodel.kppm`

$K$ function of fitted model
`pcfmodel.kppm`

Pair correlation of fitted model
}
The theoretical models can also be simulated,
for any choice of parameter values,
using `rThomas`

, `rMatClust`

,
`rCauchy`

, `rVarGamma`

,
and `rLGCP`

.
Lower-level fitting functions include:

`lgcp.estK`

fit a log-Gaussian Cox process model
`lgcp.estpcf`

fit a log-Gaussian Cox process model
`thomas.estK`

fit the Thomas process model
`thomas.estpcf`

fit the Thomas process model
`matclust.estK`

fit the Matern Cluster process model
`matclust.estpcf`

fit the Matern Cluster process model
`cauchy.estK`

fit a Neyman-Scott Cauchy cluster process
`cauchy.estpcf`

fit a Neyman-Scott Cauchy cluster process
`vargamma.estK`

fit a Neyman-Scott Variance Gamma process
`vargamma.estpcf`

fit a Neyman-Scott Variance Gamma process
`mincontrast`

low-level algorithm for fitting models
by the method of minimum contrast
}

##### IV. MODEL FITTING (POISSON AND GIBBS MODELS)

**Types of models**
Poisson point processes are the simplest models for point patterns.
A Poisson model assumes that the points are stochastically
independent. It may allow the points to have a non-uniform spatial
density. The special case of a Poisson process with a uniform
spatial density is often called Complete Spatial Randomness.
Poisson point processes are included in the more general class of Gibbs point
process models. In a Gibbs model, there is *interaction*
or dependence between points. Many different types of interaction
can be specified.
For a detailed explanation of how to fit Poisson or
Gibbs point process models to point pattern data using **To fit a Poison or Gibbs point process model:**

Model fitting in `ppm`

. Its result is an object of class `"ppm"`

.
Here are some examples, where `X`

is a point pattern (class
`"ppp"`

):
*command* *model*
`ppm(X)`

Complete Spatial Randomness
`ppm(X, ~1)`

Complete Spatial Randomness
`ppm(X, ~x)`

Poisson process with
intensity loglinear in $x$ coordinate
`ppm(X, ~1, Strauss(0.1))`

Stationary Strauss process
`ppm(X, ~x, Strauss(0.1))`

Strauss process with
conditional intensity loglinear in $x$
}
It is also possible to fit models that depend on
other covariates.

**Manipulating the fitted model:**

`plot.ppm`

Plot the fitted model
`predict.ppm`

Compute the spatial trend and conditional intensity
of the fitted point process model
`coef.ppm`

Extract the fitted model coefficients
`formula.ppm`

Extract the trend formula
`intensity.ppm`

Compute fitted intensity
`Kmodel.ppm`

$K$ function of fitted model
`pcfmodel.ppm`

pair correlation of fitted model
`fitted.ppm`

Compute fitted conditional intensity at quadrature points
`residuals.ppm`

Compute point process residuals at quadrature points
`update.ppm`

Update the fit
`vcov.ppm`

Variance-covariance matrix of estimates
`rmh.ppm`

Simulate from fitted model
`simulate.ppm`

Simulate from fitted model
`print.ppm`

Print basic information about a fitted model
`summary.ppm`

Summarise a fitted model
`effectfun`

Compute the fitted effect of one covariate
`logLik.ppm`

log-likelihood or log-pseudolikelihood
`anova.ppm`

Analysis of deviance
`model.frame.ppm`

Extract data frame used to fit model
`model.images`

Extract spatial data used to fit model
`model.depends`

Identify variables in the model
`as.interact`

Interpoint interaction component of model
`fitin`

Extract fitted interpoint interaction
`is.hybrid`

Determine whether the model is a hybrid
`valid.ppm`

Check the model is a valid point process
`project.ppm`

Ensure the model is a valid point process
}
For model selection, you can also use
the generic functions `step`

, `drop1`

and `AIC`

on fitted point process models.
See `spatstat.options`

to control plotting of fitted model.
**To specify a point process model:**
The first order ``trend'' of the model is determined by an `R`

language formula. The formula specifies the form of the
*logarithm* of the trend.
`~1`

No trend (stationary)
`~x`

Loglinear trend
$\lambda(x,y) = \exp(\alpha + \beta x)$
where $x,y$ are Cartesian coordinates
`~polynom(x,y,3)`

Log-cubic polynomial trend
`~harmonic(x,y,2)`

Log-harmonic polynomial trend
}

The higher order (``interaction'') components are described by
an object of class `"interact"`

. Such objects are created by:
`Poisson()`

the Poisson point process
`AreaInter()`

Area-interaction process
`BadGey()`

multiscale Geyer process
`Concom()`

connected component interaction
`DiggleGratton()`

Diggle-Gratton potential
`DiggleGatesStibbard()`

Diggle-Gates-Stibbard potential
`Fiksel()`

Fiksel pairwise interaction process
`Geyer()`

Geyer's saturation process
`Hardcore()`

Hard core process
`Hybrid()`

Hybrid of several interactions
`LennardJones()`

Lennard-Jones potential
`MultiHard()`

multitype hard core process
`MultiStrauss()`

multitype Strauss process
`MultiStraussHard()`

multitype Strauss/hard core process
`OrdThresh()`

Ord process, threshold potential
`Ord()`

Ord model, user-supplied potential
`PairPiece()`

pairwise interaction, piecewise constant
`Pairwise()`

pairwise interaction, user-supplied potential
`SatPiece()`

Saturated pair model, piecewise constant potential
`Saturated()`

Saturated pair model, user-supplied potential
`Softcore()`

pairwise interaction, soft core potential
`Strauss()`

Strauss process
`StraussHard()`

Strauss/hard core point process
`Triplets()`

Geyer triplets process
}
Note that it is also possible to combine several such interactions
using `Hybrid`

.
**Finer control over model fitting:**
A quadrature scheme is represented by an object of
class `"quad"`

. To create a quadrature scheme, typically
use `quadscheme`

.
`quadscheme`

default quadrature scheme
using rectangular cells or Dirichlet cells
`pixelquad`

quadrature scheme based on image pixels
`quad`

create an object of class `"quad"`

}
To inspect a quadrature scheme:
`plot(Q)`

plot quadrature scheme `Q`

`print(Q)`

print basic information about quadrature scheme `Q`

`summary(Q)`

summary of quadrature scheme `Q`

}

A quadrature scheme consists of data points, dummy points, and
weights. To generate dummy points:
`default.dummy`

default pattern of dummy points
`gridcentres`

dummy points in a rectangular grid
`rstrat`

stratified random dummy pattern
`spokes`

radial pattern of dummy points
`corners`

dummy points at corners of the window
}
To compute weights:
`gridweights`

quadrature weights by the grid-counting rule
`dirichlet.weights`

quadrature weights are
Dirichlet tile areas
}

**Simulation and goodness-of-fit for fitted models:**
`rmh.ppm`

simulate realisations of a fitted model
`simulate.ppm`

simulate realisations of a fitted model
`envelope`

compute simulation envelopes for a
fitted model
}

**Point process models on a linear network:**

An object of class `"lpp"`

represents a pattern of points on
a linear network. Point process models can also be fitted to these
objects. Currently only Poisson models can be fitted.

`lppm`

point process model on linear network
`anova.lppm`

analysis of deviance for
point process model on linear network
`envelope.lppm`

simulation envelopes for
point process model on linear network
`predict.lppm`

model prediction on linear network
`linim`

pixel image on linear network
`plot.linim`

plot a pixel image on linear network
`eval.linim`

evaluate expression involving images
`linfun`

function defined on linear network
`methods.linfun`

conversion facilities
}

##### V. MODEL FITTING (SPATIAL LOGISTIC REGRESSION)

**Logistic regression**
Pixel-based spatial logistic regression is an alternative
technique for analysing spatial point patterns
that is widely used in Geographical Information Systems.
It is approximately equivalent to fitting a Poisson point process
model.
In pixel-based logistic regression, the spatial domain is
divided into small pixels, the presence or absence of a
data point in each pixel is recorded, and logistic regression
is used to model the presence/absence indicators as a function
of any covariates.
Facilities for performing spatial logistic regression are
provided in **Fitting a spatial logistic regression**
Spatial logistic regression is performed by the function
`slrm`

. Its result is an object of class `"slrm"`

.
There are many methods for this class, including methods for
`print`

, `fitted`

, `predict`

, `simulate`

,
`anova`

, `coef`

, `logLik`

, `terms`

,
`update`

, `formula`

and `vcov`

.
For example, if `X`

is a point pattern (class
`"ppp"`

):
*command* *model*
`slrm(X ~ 1)`

Complete Spatial Randomness
`slrm(X ~ x)`

Poisson process with
intensity loglinear in $x$ coordinate
`slrm(X ~ Z)`

Poisson process with
intensity loglinear in covariate `Z`

}

**Manipulating a fitted spatial logistic regression**
`anova.slrm`

Analysis of deviance
`coef.slrm`

Extract fitted coefficients
`vcov.slrm`

Variance-covariance matrix of fitted coefficients
`fitted.slrm`

Compute fitted probabilities or
intensity
`logLik.slrm`

Evaluate loglikelihood of fitted
model
`plot.slrm`

Plot fitted probabilities or
intensity
`predict.slrm`

Compute predicted probabilities or
intensity with new data
`simulate.slrm`

Simulate model
}
There are many other undocumented methods for this class,
including methods for `print`

, `update`

, `formula`

and `terms`

. Stepwise model selection is
possible using `step`

or `stepAIC`

.

##### VI. SIMULATION

There are many ways to generate a random point pattern,
line segment pattern, pixel image or tessellation
in

**Random point patterns:**

`runifpoint`

generate $n$ independent uniform random points
`rpoint`

generate $n$ independent random points
`rmpoint`

generate $n$ independent multitype random points
`rpoispp`

simulate the (in)homogeneous Poisson point process
`rmpoispp`

simulate the (in)homogeneous multitype Poisson point process
`runifdisc`

generate $n$ independent uniform random points in disc
`rstrat`

stratified random sample of points
`rsyst`

systematic random sample (grid) of points
`rMaternI`

simulate the `rMaternII`

simulate the `rSSI`

simulate Simple Sequential Inhibition process
`rStrauss`

simulate Strauss process (perfect simulation)
`rNeymanScott`

simulate a general Neyman-Scott process
`rMatClust`

simulate the `rThomas`

simulate the Thomas process
`rLGCP`

simulate the log-Gaussian Cox process
`rGaussPoisson`

simulate the Gauss-Poisson cluster process
`rCauchy`

simulate Neyman-Scott process with Cauchy clusters
`rVarGamma`

simulate Neyman-Scott process with Variance Gamma clusters
`rcell`

simulate the Baddeley-Silverman cell process
`runifpointOnLines`

generate $n$ random points along specified line segments
`rpoisppOnLines`

generate Poisson random points along specified line segments
}
**Resampling a point pattern:**

`quadratresample`

block resampling
`rjitter`

apply random displacements to points in a pattern
`rshift`

random shifting of (subsets of) points
`rthin`

random thinning
}
See also `varblock`

for estimating the variance
of a summary statistic by block resampling, and
`lohboot`

for another bootstrap technique.
**Fitted point process models:**

If you have fitted a point process model to a point pattern dataset, the fitted model can be simulated.

Cluster process models
are fitted by the function `kppm`

yielding an
object of class `"kppm"`

. To generate one or more simulated
realisations of this fitted model, use
`simulate.kppm`

.

Gibbs point process models
are fitted by the function `ppm`

yielding an
object of class `"ppm"`

. To generate a simulated
realisation of this fitted model, use `rmh`

.
To generate one or more simulated realisations of the fitted model,
use `simulate.ppm`

.

**Other random patterns:**

`rlinegrid`

generate a random array of parallel lines through a window
`rpoisline`

simulate the Poisson line process within a window
`rpoislinetess`

generate random tessellation using Poisson line process
`rMosaicSet`

generate random set by selecting some tiles of a tessellation
`rMosaicField`

generate random pixel image by assigning random values
in each tile of a tessellation
}

**Simulation-based inference**

`envelope`

critical envelope for Monte Carlo
test of goodness-of-fit
`qqplot.ppm`

diagnostic plot for interpoint
interaction
`scan.test`

spatial scan statistic/test
}

*Documentation reproduced from package spatstat, version 1.36-0, License: GPL (>= 2)*