# quadratcount

##### Quadrat counting for a point pattern

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

##### Usage

`quadratcount(X, …)` # S3 method for ppp
quadratcount(X, nx=5, ny=nx, …,
xbreaks=NULL, ybreaks=NULL, tess=NULL)

# S3 method for splitppp
quadratcount(X, …)

##### Arguments

- X
A point pattern (object of class

`"ppp"`

) or a split point pattern (object of class`"splitppp"`

).- nx,ny
Numbers of rectangular quadrats in the \(x\) and \(y\) directions. Incompatible with

`xbreaks`

and`ybreaks`

.- …
Additional arguments passed to

`quadratcount.ppp`

.- xbreaks
Numeric vector giving the \(x\) coordinates of the boundaries of the rectangular quadrats. Incompatible with

`nx`

.- ybreaks
Numeric vector giving the \(y\) coordinates of the boundaries of the rectangular quadrats. Incompatible with

`ny`

.- tess
Tessellation (object of class

`"tess"`

or something acceptable to`as.tess`

) determining the quadrats. Incompatible with`nx,ny,xbreaks,ybreaks`

.

##### Details

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.

##### Value

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.

##### Note

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

.

##### Warning

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.

##### References

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.

##### See Also

`plot.quadratcount`

,
`intensity.quadratcount`

,
`quadrats`

,
`quadrat.test`

,
`tess`

,
`hextess`

,
`quadratresample`

,
`miplot`

##### Examples

```
# NOT RUN {
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)
# }
```

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