# rPoissonCluster

##### Simulate Poisson Cluster Process

Generate a random point pattern, a realisation of the general Poisson cluster process.

##### Usage

```
rPoissonCluster(kappa, expand, rcluster, win = owin(c(0,1),c(0,1)),
..., lmax=NULL, nsim=1, drop=TRUE)
```

##### Arguments

- kappa
- Intensity of the Poisson process of cluster centres. A single positive number, a function, or a pixel image.
- expand
- Size of the expansion of the simulation window for generating parent points. A single non-negative number.
- rcluster
- A function which generates random clusters.
- win
- Window in which to simulate the pattern.
An object of class
`"owin"`

or something acceptable to`as.owin`

. - ...
- Arguments passed to
`rcluster`

- lmax
- Optional. Upper bound on the values of
`kappa`

when`kappa`

is a function or pixel image. - nsim
- Number of simulated realisations to be generated.
- drop
- Logical. If
`nsim=1`

and`drop=TRUE`

(the default), the result will be a point pattern, rather than a list containing a point pattern.

##### Details

This algorithm generates a realisation of the
general Poisson cluster process, with the cluster mechanism
given by the function `rcluster`

.

First, the algorithm
generates a Poisson point process of ``parent'' points
with intensity `kappa`

in an expanded
window as explained below.. Here `kappa`

may be a single
positive number, a function `kappa(x, y)`

, or a pixel image
object of class `"im"`

(see `im.object`

).
See `rpoispp`

for details.
Second, each parent point is replaced by a random cluster of points,
created by calling the function `rcluster`

. These clusters are
combined together to yield a single point pattern, and the restriction
of this pattern to the window `win`

is then returned as the
result of `rPoissonCluster`

.

The expanded window consists of `as.rectangle(win)`

extended by the amount `expand`

in each direction. The size of
the expansion is saved in the attribute `"expand"`

and may be
extracted by `attr(X, "expand")`

where `X`

is the generated
point pattern.

The function `rcluster`

should expect to be called as
`rcluster(xp[i],yp[i],...)`

for each parent point at a location
`(xp[i],yp[i])`

. The return value of `rcluster`

should be a list with elements
`x,y`

which are vectors of equal length giving the absolute
$x$ and `y`

coordinates of the points in the cluster.

If the return value of `rcluster`

is a point pattern (object of
class `"ppp"`

) then it may have marks. The result of
`rPoissonCluster`

will then be a marked point pattern.

If required, the intermediate stages of the simulation (the parents
and the individual clusters) can also be extracted from
the return value of `rPoissonCluster`

through the attributes `"parents"`

and `"parentid"`

.
The attribute `"parents"`

is the point pattern of parent points.
The attribute `"parentid"`

is an integer vector specifying
the parent for each of the points in the simulated pattern.

##### Value

- A point pattern (an object of class
`"ppp"`

) if`nsim=1`

, or a list of point patterns if`nsim > 1`

. Additionally, some intermediate results of the simulation are returned as attributes of the point pattern: see Details.

##### See Also

`rpoispp`

,
`rMatClust`

,
`rThomas`

,
`rCauchy`

,
`rVarGamma`

,
`rNeymanScott`

,
`rGaussPoisson`

.

##### Examples

```
# each cluster consist of 10 points in a disc of radius 0.2
nclust <- function(x0, y0, radius, n) {
return(runifdisc(n, radius, centre=c(x0, y0)))
}
plot(rPoissonCluster(10, 0.2, nclust, radius=0.2, n=5))
# multitype Neyman-Scott process (each cluster is a multitype process)
nclust2 <- function(x0, y0, radius, n, types=c("a", "b")) {
X <- runifdisc(n, radius, centre=c(x0, y0))
M <- sample(types, n, replace=TRUE)
marks(X) <- M
return(X)
}
plot(rPoissonCluster(15,0.1,nclust2, radius=0.1, n=5))
```

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