# rSSI

##### Simulate Simple Sequential Inhibition

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

##### Usage

`rSSI(r, n=Inf, win = square(1), giveup = 1000, x.init=NULL)`

##### Arguments

- 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 impossi - 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 spec - 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**Detai**

##### Details

This algorithm generates a realisation 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
[object Object],[object Object]
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=as.owin(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.

##### Value

- The simulated point pattern (an object of class
`"ppp"`

).

##### See Also

##### Examples

```
Vinf <- rSSI(0.05)
V100 <- rSSI(0.05, 100)
X <- runifpoint(100)
Y <- rSSI(0.03,142,x.init=X) # Y consists of X together with
# 42 added points.
plot(Y)
plot(X,add=TRUE,chars=20,cols="red")
```

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