Description Usage Arguments Details Value Warning Note Author(s) References See Also Examples

Divides window into quadrats and counts the numbers of points in each quadrat.

1 2 3 4 5 6 7 8 | ```
quadratcount(X, ...)
## S3 method for class 'ppp'
quadratcount(X, nx=5, ny=nx, ...,
xbreaks=NULL, ybreaks=NULL, tess=NULL)
## S3 method for class 'splitppp'
quadratcount(X, ...)
``` |

`X` |
A point pattern (object of class |

`nx,ny` |
Numbers of rectangular quadrats in the |

`...` |
Additional arguments passed to |

`xbreaks` |
Numeric vector giving the |

`ybreaks` |
Numeric vector giving the |

`tess` |
Tessellation (object of class |

Quadrat counting is an elementary technique for analysing spatial point patterns. See Diggle (2003).

**If X is a point pattern**, then
by default, the window containing the point pattern

`X`

is divided into
an `nx * ny`

grid of rectangular tiles or ‘quadrats’.
(If the window is not a rectangle, then these tiles are intersected
with the window.)
The number of points of `X`

falling in each quadrat is
counted. These numbers are returned as a contingency table.
If `xbreaks`

is given, it should be a numeric vector
giving the *x* coordinates of the quadrat boundaries.
If it is not given, it defaults to a
sequence of `nx+1`

values equally spaced
over the range of *x* coordinates in the window `Window(X)`

.

Similarly if `ybreaks`

is given, it should be a numeric
vector giving the *y* coordinates of the quadrat boundaries.
It defaults to a vector of `ny+1`

values
equally spaced over the range of *y* coordinates in the window.
The lengths of `xbreaks`

and `ybreaks`

may be different.

Alternatively, quadrats of any shape may be used.
The argument `tess`

can be a tessellation (object of class
`"tess"`

) whose tiles will serve as the quadrats.

The algorithm counts the number of points of `X`

falling in each quadrat, and returns these counts as a
contingency table.

The return value is a `table`

which can be printed neatly.
The return value is also a member of the special class
`"quadratcount"`

. Plotting the object will display the
quadrats, annotated by their counts. See the examples.

To perform a chi-squared test based on the quadrat counts,
use `quadrat.test`

.

To calculate an estimate of intensity based on the quadrat counts,
use `intensity.quadratcount`

.

To extract the quadrats used in a `quadratcount`

object,
use `as.tess`

.

**If X is a split point pattern** (object of class

`"splitppp"`

then quadrat counting will be performed on
each of the components point patterns, and the resulting
contingency tables will be returned in a list. This list can be
printed or plotted.
Marks attached to the points are ignored by `quadratcount.ppp`

.
To obtain a separate contingency table for each type of point
in a multitype point pattern,
first separate the different points using `split.ppp`

,
then apply `quadratcount.splitppp`

. See the Examples.

The value of `quadratcount.ppp`

is a
contingency table containing the number of points in each
quadrat. The table is also an object of the
special class `"quadratcount"`

and there is a plot method for this class.

The value of `quadratcount.splitppp`

is a list of such
contingency tables, each containing the quadrat counts for one of the
component point patterns in `X`

.
This list also has the class `"solist"`

which has
print and plot methods.

If `Q`

is the result of `quadratcount`

using rectangular tiles, then `as.numeric(Q)`

extracts the counts **in the wrong order**.
To obtain the quadrat counts in the same order as the
tiles of the corresponding tessellation would be listed,
use `as.vector(t(Q))`

, which works in all cases.

To perform a chi-squared test based on the quadrat counts,
use `quadrat.test`

.

and \rolf

Diggle, P.J. *Statistical analysis of spatial point patterns*.
Academic Press, 2003.

Stoyan, D. and Stoyan, H. (1994)
*Fractals, random shapes and point fields:
methods of geometrical statistics.*
John Wiley and Sons.

`plot.quadratcount`

,
`intensity.quadratcount`

,
`quadrats`

,
`quadrat.test`

,
`tess`

,
`hextess`

,
`quadratresample`

,
`miplot`

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | ```
X <- runifpoint(50)
quadratcount(X)
quadratcount(X, 4, 5)
quadratcount(X, xbreaks=c(0, 0.3, 1), ybreaks=c(0, 0.4, 0.8, 1))
qX <- quadratcount(X, 4, 5)
# plotting:
plot(X, pch="+")
plot(qX, add=TRUE, col="red", cex=1.5, lty=2)
# irregular window
data(humberside)
plot(humberside)
qH <- quadratcount(humberside, 2, 3)
plot(qH, add=TRUE, col="blue", cex=1.5, lwd=2)
# multitype - split
plot(quadratcount(split(humberside), 2, 3))
# quadrats determined by tessellation:
B <- dirichlet(runifpoint(6))
qX <- quadratcount(X, tess=B)
plot(X, pch="+")
plot(qX, add=TRUE, col="red", cex=1.5, lty=2)
``` |

```
Loading required package: nlme
Loading required package: rpart
spatstat 1.51-0 (nickname: 'Poetic Licence')
For an introduction to spatstat, type 'beginner'
Note: spatstat version 1.51-0 is out of date by more than 4 months; we recommend upgrading to the latest version.
x
y [0,0.2) [0.2,0.4) [0.4,0.6) [0.6,0.8) [0.8,1]
[0.8,1] 2 0 2 2 2
[0.6,0.8) 2 0 2 4 1
[0.4,0.6) 2 1 0 2 3
[0.2,0.4) 7 0 0 2 2
[0,0.2) 3 4 1 3 3
x
y [0,0.25) [0.25,0.5) [0.5,0.75) [0.75,1]
[0.8,1] 2 1 2 3
[0.6,0.8) 2 1 3 3
[0.4,0.6) 2 1 2 3
[0.2,0.4) 7 0 2 2
[0,0.2) 4 4 1 5
x
y [0,0.3) [0.3,1]
[0.8,1] 2 6
[0.4,0.8) 4 13
[0,0.4) 11 14
PLEASE NOTE: The components "delsgs" and "summary" of the
object returned by deldir() are now DATA FRAMES rather than
matrices (as they were prior to release 0.0-18).
See help("deldir").
PLEASE NOTE: The process that deldir() uses for determining
duplicated points has changed from that used in version
0.0-9 of this package (and previously). See help("deldir").
```

spatstat documentation built on June 15, 2018, 9:04 a.m.

Embedding an R snippet on your website

Add the following code to your website.

For more information on customizing the embed code, read Embedding Snippets.