# quadratcount: Quadrat counting for a point pattern In spatstat: Spatial Point Pattern Analysis, Model-Fitting, Simulation, Tests

## Description

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

## Usage

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

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

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

## Note

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

and \rolf

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

`plot.quadratcount`, `intensity.quadratcount`, `quadrats`, `quadrat.test`, `tess`, `hextess`, `quadratresample`, `miplot`

## Examples

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

### Example output

```Loading required package: nlme

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 April 5, 2018, 5:04 p.m.