Generate a random point pattern, a realisation of the Simple Sequential Inhibition (SSI) process.

```
rSSI(r, n=Inf, win = square(1), giveup = 1000, x.init=NULL, ...,
f=NULL, fmax=NULL, nsim=1, drop=TRUE)
```

r

Inhibition distance.

n

Maximum number of points allowed.
If `n`

is finite, stop when the *total* number of points
in the point pattern reaches `n`

.
If `n`

is infinite (the default), stop only when
it is apparently impossible to add any more points.
See **Details**.

win

Window in which to simulate the pattern.
An object of class `"owin"`

or something acceptable to `as.owin`

.
The default window is the unit square, unless
`x.init`

is specified, when the default window
is the window of `x.init`

.

giveup

Number of rejected proposals after which the algorithm should terminate.

x.init

Optional. Initial configuration of points. A point pattern
(object of class `"ppp"`

). The pattern returned by
`rSSI`

consists of this pattern together with the points
added via simple sequential inhibition. See **Details**.

…

Ignored.

f,fmax

Optional arguments passed to `rpoint`

to specify a non-uniform probability density for the random points.

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.

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

)
if `nsim=1`

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

.

This algorithm generates one or more realisations of the Simple Sequential
Inhibition point process inside the window `win`

.

Starting with an empty window (or with the point pattern
`x.init`

if specified), the algorithm adds points
one-by-one. Each new point is generated uniformly in the window
and independently of preceding points. If the new point lies
closer than `r`

units from an existing point, then it is
rejected and another random point is generated.
The algorithm terminates when either

- (a)
the desired number

`n`

of points is reached, or- (b)
the current point configuration has not changed for

`giveup`

iterations, suggesting that it is no longer possible to add new points.

If `n`

is infinite (the default) then the algorithm terminates
only when (b) occurs. The result is sometimes called a
*Random Sequential Packing*.

Note that argument `n`

specifies the maximum permitted
**total** number of points in the pattern returned by
`rSSI()`

. If `x.init`

is not `NULL`

then
the number of points that are *added*
is at most `n - npoints(x.init)`

if `n`

is finite.

Thus if `x.init`

is not `NULL`

then argument `n`

must be at least as large as `npoints(x.init)`

, otherwise
an error is given. If `n==npoints(x.init)`

then a warning
is given and the call to `rSSI()`

has no real effect;
`x.init`

is returned.

There is no requirement that the points of `x.init`

be at
a distance at least `r`

from each other. All of the *added*
points will be at a distance at least `r`

from each other
and from any point of `x.init`

.

The points will be generated inside the window `win`

and the result will be a point pattern in the same window.

The default window is the unit square, `win = square(1)`

,
unless `x.init`

is specified, when the default
is `win=Window(x.init)`

, the window of `x.init`

.

If both `win`

and `x.init`

are specified, and if the
two windows are different, then a warning will be issued.
Any points of `x.init`

lying outside `win`

will be removed,
with a warning.

# NOT RUN { Vinf <- rSSI(0.07) V100 <- rSSI(0.07, 100) X <- runifpoint(100) Y <- rSSI(0.03,142,x.init=X) # Y consists of X together with # 42 added points. plot(Y, main="rSSI") plot(X,add=TRUE,chars=20,cols="red") ## inhomogeneous Z <- rSSI(0.07, 50, f=function(x,y){x}) plot(Z) # }