# rpoint

##### Generate N Random Points

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`

.

##### See Also

##### Examples

```
# NOT RUN {
# 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
data(letterR)
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)
# }
```

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