# 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 or Huang-Ogata approximate maximum likelihood)
- Cox/cluster process models (by Waagepetersen's two-step fitting procedure and minimum contrast)

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

, see the workshop notes
by Baddeley (2010).
Both of these documents are available on the internet.

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

##### Updates

New versions of `latest.news()`

to read the news documentation about
changes to the current installed version of `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 Mat'ern Model I inhibition process
`rMaternII`

simulate the Mat'ern Model II inhibition process
`rSSI`

simulate Simple Sequential Inhibition process
`rStrauss`

simulate Strauss process (perfect simulation)
`rNeymanScott`

simulate a general Neyman-Scott process
`rMatClust`

simulate the Mat'ern Cluster process
`rThomas`

simulate the Thomas process
`rGaussPoisson`

simulate the Gauss-Poisson 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:**
Remember to say `data(amacrine)`

etc.
Type `demo(data)`

to see 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
`copper`

Berman-Huntington copper deposits data
`demopat`

Synthetic point pattern
`finpines`

Finnish Pines data
`flu`

Influenza virus proteins
`hamster`

Aherne's hamster tumour data
`humberside`

North Humberside childhood leukaemia data
`japanesepines`

Japanese Pines data
`lansing`

Lansing Woods data
`longleaf`

Longleaf Pines data
`murchison`

Murchison gold deposits
`nbfires`

New Brunswick fires data
`nztrees`

Mark-Esler-Ripley trees data
`osteo`

Osteocyte lacunae (3D, replicated)
`ponderosa`

Getis-Franklin ponderosa pine trees data
`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
}

**To manipulate a point pattern:**

`plot.ppp`

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

make several translated copies
`affine`

apply affine transformation
`density.ppp`

kernel smoothing
`smooth.ppp`

interpolate pixel values
`sharpen.ppp`

data sharpening
`identify.ppp`

interactively identify points
`unique.ppp`

remove duplicate points
`duplicated.ppp`

determine which points are duplicates
`dirichlet`

compute Dirichlet-Voronoi tessellation
`delaunay`

compute 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
}
See `spatstat.options`

to control plotting behaviour.
**To create a window:**

An object of class `"owin"`

describes a spatial region
(a window of observation).

`owin`

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
}

**To manipulate a window:**

`plot.owin`

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
}

**Digital approximations:**

`as.mask`

Make a discrete pixel approximation of a given window
`as.im.owin`

convert window to pixel image
`pixellate.owin`

convert window to pixel image
`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
}
See `spatstat.options`

to control the approximation

**Geometrical computations with windows:**

`intersect.owin`

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`

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
}

**Pixel images:**
An object of class `"im"`

represents a pixel image.
Such objects are returned by some of the functions in
`Kmeasure`

,
`setcov`

and `density.ppp`

.
`im`

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

apply vector shift to pixel 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
`connected`

find connected components
`compatible.im`

test whether two images have
compatible dimensions
`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
}

**Line segment patterns**

An object of class `"psp"`

represents a pattern of straight line
segments.
`psp`

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
}

**Tessellations**

An object of class `"tess"`

represents a tessellation.

`tess`

create a tessellation
`quadrats`

create a tessellation of rectangles
`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
}

**Three-dimensional point patterns**

An object of class `"pp3"`

represents a three-dimensional
point pattern in a rectangular box. The box is represented by
an object of class `"box3"`

.

`pp3`

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
}

**Multi-dimensional space-time point patterns**

An object of class `"ppx"`

represents a
point pattern in multi-dimensional space and/or time.

`ppx`

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
}

**Point patterns on a linear network**

An object of class `"linnet"`

represents a linear network
(for example, a road network).

`linnet`

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
}
An object of class `"lpp"`

represents a
point pattern on a linear network (for example,
road accidents on a road network).
`lpp`

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
}
**Hyperframes**

A hyperframe is like a data frame, except that the entries may be objects of any kind.

`hyperframe`

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
}

##### 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
}

**Modern exploratory tools:**
`nnclean`

Byers-Raftery feature detection
`sharpen.ppp`

Choi-Hall data sharpening
`rhohat`

Smoothing estimate of covariate effect
}

**Summary statistics for a point pattern:**
`quadratcount`

Quadrat counts
`Fest`

empty space function $F$
`Gest`

nearest neighbour distribution function $G$
`Kest`

Ripley's $K$-function
`Lest`

Besag-Ripley $L$-function
`Jest`

$J$-function $J = (1-G)/(1-F)$
`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
`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
}

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

kernel smoothed density
`smooth.ppp`

spatial interpolation of marks
`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"`

with a component `X$marks`

which is a factor.
`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}$
`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`

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

Related facilities:
`pairdist.lpp`

shortest path distances
`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
}

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

`plot.kppm`

Plot the fitted model
`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`

and `rLGCP`

respectively.
Lower-level fitting functions include:

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

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

fit a log-Gaussian Cox process model
`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
`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
}
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
`DiggleGratton()`

Diggle-Gratton potential
`DiggleGatesStibbard()`

Diggle-Gates-Stibbard potential
`Fiksel()`

Fiksel pairwise interaction process
`Geyer()`

Geyer's saturation process
`Hardcore()`

Hard core process
`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
}
**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
}

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

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

Evalate loglikelihood of fitted
model
`plot.slrm`

Plot fitted probabilities or
intensity
`predict.slrm`

Compute predicted probabilities or
intensity with new data
}
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 Mat'ern Model I inhibition process
`rMaternII`

simulate the Mat'ern Model II inhibition process
`rSSI`

simulate Simple Sequential Inhibition process
`rStrauss`

simulate Strauss process (perfect simulation)
`rNeymanScott`

simulate a general Neyman-Scott process
`rMatClust`

simulate the Mat'ern Cluster process
`rThomas`

simulate the Thomas process
`rLGCP`

simulate the log-Gaussian Cox process
`rGaussPoisson`

simulate the Gauss-Poisson cluster process
`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.
**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
}

##### VII. TESTS AND DIAGNOSTICS

**Classical hypothesis tests:**
`quadrat.test`

$\chi^2$ goodness-of-fit
test on quadrat counts
`clarkevans.test`

Clark and Evans test
`kstest`

Kolmogorov-Smirnov goodness-of-fit test
`bermantest`

Berman's goodness-of-fit tests
`envelope`

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

Analysis of Deviance for
point process models
}

**Residual diagnostics:**
Residuals for a fitted point process model, and diagnostic plots
based on the residuals, were introduced in Baddeley et al (2005)
and Baddeley, Rubak and Moller (2011).
Type `demo(diagnose)`

for a demonstration of the diagnostics features.

`diagnose.ppm`

diagnostic plots for spatial trend
`qqplot.ppm`

diagnostic Q-Q plot for interpoint interaction
`residualspaper`

examples from Baddeley et al (2005)
`Kcom`

model compensator of $K$ function
`Gcom`

model compensator of $G$ function
`Kres`

score residual of $K$ function
`Gres`

score residual of $G$ function
`psst`

pseudoscore residual of summary function
`psstA`

pseudoscore residual of empty space function
`psstG`

pseudoscore residual of $G$ function
`compareFit`

compare compensators of several fitted models
}

**Resampling and randomisation procedures**

You can build your own tests based on randomisation
and resampling using the following capabilities:
`quadratresample`

block resampling
`rjitter`

apply random displacements to points in a pattern
`rshift`

random shifting of (subsets of) points
`rthin`

random thinning
}

##### VIII. DOCUMENTATION

The online manual entries are quite detailed and should be consulted
first for information about a particular function.
The paper by Baddeley and Turner (2005a) is a brief overview of
the package.
Baddeley and Turner (2005b) is a more detailed explanation of
how to fit point process models to data.
Baddeley (2010) is a complete set of notes from a 2-day workshop
on the use of `spatstat`

.

Type `citation("spatstat")`

to get these references.

##### Licence

This library and its documentation are usable under the terms of the "GNU General Public License", a copy of which is distributed with the package.

##### Acknowledgements

Kasper Klitgaard Berthelsen, Marie-Colette van Lieshout, Ege Rubak, Dominic Schuhmacher and Rasmus Waagepetersen made substantial contributions of code. Additional contributions by Ang Qi Wei, Sandro Azaele, Colin Beale, Ricardo Bernhardt, Brad Biggerstaff, Roger Bivand, Florent Bonneu, Julian Burgos, S. Byers, Ya-Mei Chang, Jianbao Chen, Igor Chernayavsky, Y.C. Chin, Bjarke Christensen, Marcelino de la Cruz, Peter Dalgaard, Peter Diggle, Ian Dryden, Stephen Eglen, Agnes Gault, Marc Genton, Pavel Grabarnik, C. Graf, Janet Franklin, Ute Hahn, Andrew Hardegen, Mandy Hering, Martin Bogsted Hansen, Martin Hazelton, Juha Heikkinen, Kurt Hornik, Ross Ihaka, Abdollah Jalilian, Robert John-Chandran, Devin Johnson, Mike Kuhn, Jeff Laake, Robert Lamb, George Leser, Ben Madin, Robert Mark, Jorge Mateu Mahiques, Monia Mahling, Peter McCullagh, Ulf Mehlig, Sebastian Wastl Meyer, Mi Xiangcheng, Jesper Moller, Linda Stougaard Nielsen, Felipe Nunes, Evgeni Parilov, Jeff Picka, Adrian Raftery, Matt Reiter, Tom Richardson, Brian Ripley, Barry Rowlingson, John Rudge, Aila Sarkka, Katja Schladitz, Bryan Scott, Vadim Shcherbakov, Shen Guochun, Ida-Maria Sintorn, Yong Song, Malte Spiess, Mark Stevenson, Kaspar Stucki, Michael Sumner, P. Surovy, Ben Taylor, Berwin Turlach, Andrew van Burgel, Tobias Verbeke, Alexendre Villers, Hao Wang, H. Wendrock, Jan Wild and Selene Wong.

##### References

Baddeley, A. (2010)
*Analysing spatial point patterns in R*.
Workshop notes. Version 4.1. CSIRO online technical publication.
URL: `www.csiro.au/resources/pf16h.html`

Baddeley, A. and Turner, R. (2005a)
Spatstat: an R package for analyzing spatial point patterns.
*Journal of Statistical Software* **12**:6, 1--42.
URL: `www.jstatsoft.org`

, ISSN: 1548-7660.

Baddeley, A. and Turner, R. (2005b)
Modelling spatial point patterns in R.
In: A. Baddeley, P. Gregori, J. Mateu, R. Stoica, and D. Stoyan,
editors, *Case Studies in Spatial Point Pattern Modelling*,
Lecture Notes in Statistics number 185. Pages 23--74.
Springer-Verlag, New York, 2006.
ISBN: 0-387-28311-0.

Baddeley, A., Turner, R., Moller, J. and Hazelton, M. (2005)
Residual analysis for spatial point processes.
*Journal of the Royal Statistical Society, Series B*
**67**, 617--666.

Baddeley, A., Rubak, E. and Moller, J. (2011)
Score, pseudo-score and residual
diagnostics for spatial point process models.
To appear in *Statistical Science*.

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