rNeymanScott(kappa, expand, rcluster, win = owin(c(0,1),c(0,1)), ..., lmax=NULL, nsim=1, drop=TRUE, nonempty=TRUE, saveparents=TRUE)"owin"
or something acceptable to as.owin.
rcluster.
kappa
when kappa is a function or pixel image.
nsim=1 and drop=TRUE (the default), the
result will be a point pattern, rather than a list
containing a point pattern.
TRUE (the default), a more efficient algorithm is
used, in which parents are generated conditionally on having at
least one offspring point. If FALSE, parents are generated
even if they have no offspring. Both choices are valid; the default
is recommended unless you need to simulate all the parent points
for some other purpose.
"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 this point pattern: see Details.
kappa is a function(x,y) or a pixel
image (object of class "im"), then it is taken as specifying
the intensity function of an inhomogeneous Poisson process according
to which the parent points are generated.
rcluster is a list of two elements
mu, f and the first entry mu is a
function(x,y) or a pixel image (object of class "im"),
then mu is interpreted as the reference intensity
for offspring points, in the sense of Waagepetersen (2007).
For a given parent point, the offspring constitute a Poisson process
with intensity function equal to mu(x, y) * g(x-x0, y-y0)
where g is the probability density of the offspring
displacements generated by the function f. Equivalently, clusters are first generated with a constant
expected number of points per cluster: the constant is mumax, the
maximum of mu. Then the offspring are randomly thinned
(see rthin) with spatially-varying retention
probabilities given by mu/mumax.
rcluster is a function,
then the cluster associated with a parent point at location
(x0,y0) will be generated by calling
rcluster(x0, y0, ...). The behaviour of this function
could depend on the location (x0,y0) in any fashion.
kappa is an
image, the spatial domain covered by this image must be large
enough to include the expanded window in which the parent
points are to be generated. This requirement means that win must
be small enough so that the expansion of as.rectangle(win)
is contained in the spatial domain of kappa. As a result,
one may wind up having to simulate the process in a window smaller
than what is really desired. In the first two cases, the intensity of the Neyman-Scott process
is equal to kappa * mu if at least one of kappa or
mu is a single number, and is otherwise equal to an
integral involving kappa, mu and f.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. 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
rNeymanScott.
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 argument rcluster specifies the cluster mechanism.
It may be either:
function which will be called to generate each random
cluster (the offspring points of each parent point).
The function should expect to be called
in the form rcluster(x0,y0,...) for a parent point at a location
(x0,y0). The return value of rcluster
should specify the coordinates of the points in the cluster;
it may be a list containing elements
x,y, or a point pattern (object of
class "ppp"). If it is a marked point pattern then the result of
rNeymanScott will be a marked point pattern.
list(mu, f) where mu specifies the mean
number of offspring points in each cluster, and f
generates the random displacements (vectors pointing from the parent
to the offspring). In this case, the number of offspring
in a cluster is assumed to have a Poisson distribution, implying
that the Neyman-Scott process is also a Cox process.
The first element mu should be either a single nonnegative
number (interpreted as the mean of the Poisson distribution of
cluster size)
or a pixel image or a function(x,y) giving a spatially
varying mean cluster size (interpreted in the sense of
Waagepetersen, 2007).
The second element f should be a function that will be
called once in the form f(n) to generate n independent
and identically distributed displacement vectors (i.e. as if there
were a cluster of size n with a parent at the origin
(0,0)).
The function should return
a point pattern (object of class "ppp")
or something acceptable to xy.coords
that specifies the coordinates of n points.
If required, the intermediate stages of the simulation (the
parents and the individual clusters) can also be extracted from
the return value of rNeymanScott 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.
Neyman-Scott models where kappa is a single number
and rcluster = list(mu,f) can be fitted to data
using the function kppm.
Waagepetersen, R. (2007) An estimating function approach to inference for inhomogeneous Neyman-Scott processes. Biometrics 63, 252--258.
rpoispp,
rThomas,
rGaussPoisson,
rMatClust,
rCauchy,
rVarGamma
# 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(rNeymanScott(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(rNeymanScott(15,0.1,nclust2, radius=0.1, n=5))
Run the code above in your browser using DataLab