spatstat.core (version 2.3-1)

rPoissonCluster: Simulate Poisson Cluster Process

Description

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, saveparents=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.

saveparents

Logical value indicating whether to save the locations of the parent points as an attribute.

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.

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. (If these data are not required, it is more efficient to set saveparents=FALSE.)

See Also

rpoispp, rMatClust, rThomas, rCauchy, rVarGamma, rNeymanScott, rGaussPoisson.

Examples

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