R: Generate N Random Points

rpoint {spatstat.core} | R Documentation

## Generate N Random Points

### Description

Generate a random point pattern containing n independent, identically distributed random points with any specified distribution.

### Usage

     rpoint(n, f, fmax=NULL, win=unit.square(),
            ..., giveup=1000, verbose=FALSE,
            nsim=1, drop=TRUE)

### Arguments

`n` | Number of points to generate.
`f` | The probability density of the points, possibly un-normalised. Either a constant, a function `f(x,y,...)`, or a pixel image object.
`fmax` | An upper bound on the values of `f`. If missing, this number will be estimated.
`win` | Window in which to simulate the pattern. Ignored if `f` is a pixel image.
`...` | Arguments passed to the function `f`.
`giveup` | Number of attempts in the rejection method after which the algorithm should stop trying to generate new points.
`verbose` | Flag indicating whether to report details of performance of the simulation algorithm.
`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 function generates `n` independent, identically distributed random points with common probability density proportional to `f`.

The argument `f` may be

a numerical constant:

  uniformly distributed random points will be generated.

a function:

  random points will be generated in the window `win` with probability density proportional to `f(x,y,...)` where `x` and `y` are the cartesian coordinates. The function `f` must accept two vectors of coordinates `x,y` and return the corresponding vector of function values. Additional arguments `...` of any kind may be passed to the function.

a pixel image:

  if `f` is a pixel image object of class `"im"` (see `im.object`) then random points will be generated in the window of this pixel image, with probability density proportional to the pixel values of `f`.

The algorithm is as follows:

- If `f` is a constant, we invoke `runifpoint`.

- If `f` is a function, then we use the rejection method. Proposal points are generated from the uniform distribution. A proposal point (x,y) is accepted with probability `f(x,y,...)/fmax` and otherwise rejected. The algorithm continues until `n` points have been accepted. It gives up after `giveup * n` proposals if there are still fewer than `n` points.

- If `f` is a pixel image, then a random sequence of pixels is selected (using `sample`) with probabilities proportional to the pixel values of `f`. Then for each pixel in the sequence we generate a uniformly distributed random point in that pixel.

The algorithm for pixel images is more efficient than that for functions.

### Value

A point pattern (an object of class `"ppp"`) if `nsim=1`, or a list of point patterns if `nsim > 1`.

### Author(s)

Adrian Baddeley Adrian.Baddeley@curtin.edu.au

and Rolf Turner r.turner@auckland.ac.nz

### See Also

`ppp.object`, `owin.object`, `runifpoint`

### Examples

     # 100 uniform random points in the unit square
     X <- rpoint(100)

     # 100 random points with probability density proportional to x^2 + y^2
     X <- rpoint(100, function(x,y) { x^2 + y^2}, 1)

     # `fmax' may be omitted
     X <- rpoint(100, function(x,y) { x^2 + y^2})

     # irregular window
     X <- rpoint(100, function(x,y) { x^2 + y^2}, win=letterR)

     # make a pixel image
     Z <- setcov(letterR)
     # 100 points with density proportional to pixel values
     X <- rpoint(100, Z)

[Package spatstat.core version 2.0-0 Index]