# split.ppp

##### Divide Point Pattern into Sub-patterns

Divides a point pattern into several sub-patterns, according to their marks, or according to any user-specified grouping.

##### Usage

```
# S3 method for ppp
split(x, f = marks(x), drop=FALSE, un=NULL, reduce=FALSE, …)
# S3 method for ppp
split(x, f = marks(x), drop=FALSE, un=missing(f), …) <- value
```

##### Arguments

- x
A two-dimensional point pattern. An object of class

`"ppp"`

.- f
Data determining the grouping. Either a factor, a logical vector, a pixel image with factor values, a tessellation, a window, or the name of one of the columns of marks.

- drop
Logical. Determines whether empty groups will be deleted.

- un
Logical. Determines whether the resulting subpatterns will be unmarked (i.e. whether marks will be removed from the points in each subpattern).

- reduce
Logical. Determines whether to delete the column of marks used to split the pattern, when the marks are a data frame.

- …
Other arguments are ignored.

- value
List of point patterns.

##### Details

The function `split.ppp`

divides up the points of the point pattern `x`

into several sub-patterns according to the values of `f`

.
The result is a list of point patterns.

The argument `f`

may be

a factor, of length equal to the number of points in

`x`

. The levels of`f`

determine the destination of each point in`x`

. The`i`

th point of`x`

will be placed in the sub-pattern`split.ppp(x)$l`

where`l = f[i]`

.a pixel image (object of class

`"im"`

) with factor values. The pixel value of`f`

at each point of`x`

will be used as the classifying variable.a tessellation (object of class

`"tess"`

). Each point of`x`

will be classified according to the tile of the tessellation into which it falls.a window (object of class

`"owin"`

). Each point of`x`

will be classified according to whether it falls inside or outside this window.a character string, matching the name of one of the columns of marks, if

`marks(x)`

is a data frame. This column should be a factor.

If `f`

is missing, then it will be determined by the
marks of the point pattern. The pattern `x`

can be either

a multitype point pattern (a marked point pattern whose marks vector is a factor). Then

`f`

is taken to be the marks vector. The effect is that the points of each type are separated into different point patterns.a marked point pattern with a data frame of marks, containing at least one column that is a factor. The first such column will be used to determine the splitting factor

`f`

.

Some of the sub-patterns created by the split
may be empty. If `drop=TRUE`

, then empty sub-patterns will
be deleted from the list. If `drop=FALSE`

then they are retained.

The argument `un`

determines how to handle marks
in the case where `x`

is a marked point pattern.
If `un=TRUE`

then the marks of the
points will be discarded when they are split into groups,
while if `un=FALSE`

then the marks will be retained.

If `f`

and `un`

are both missing,
then the default is `un=TRUE`

for multitype point patterns
and `un=FALSE`

for marked point patterns with a data frame of
marks.

If the marks of `x`

are a data frame, then
`split(x, reduce=TRUE)`

will discard only the column of marks
that was used to split the pattern. This applies only when
the argument `f`

is missing.

The result of `split.ppp`

has class `"splitppp"`

and can be plotted using `plot.splitppp`

.

The assignment function `split<-.ppp`

updates the point pattern `x`

so that
it satisfies `split(x, f, drop, un) = value`

. The argument `value`

is expected to be a list of point patterns, one for each level of
`f`

. These point patterns are expected to be compatible with the
type of data in the original pattern `x`

.

Splitting can also be undone by the function
`superimpose`

,
but this typically changes the ordering of the data.

##### Value

The value of `split.ppp`

is a list of point patterns.
The components of the list are named by the levels of `f`

.
The list also has the class `"splitppp"`

.

The assignment form `split<-.ppp`

returns the updated
point pattern `x`

.

##### See Also

##### Examples

```
# NOT RUN {
# (1) Splitting by marks
# Multitype point pattern: separate into types
u <- split(amacrine)
# plot them
plot(split(amacrine))
# the following are equivalent:
amon <- split(amacrine)$on
amon <- unmark(amacrine[amacrine$marks == "on"])
amon <- subset(amacrine, marks == "on", -marks)
# the following are equivalent:
amon <- split(amacrine, un=FALSE)$on
amon <- amacrine[amacrine$marks == "on"]
# Scramble the locations of the 'on' cells
X <- amacrine
u <- split(X)
u$on <- runifpoint(ex=amon)
split(X) <- u
# Point pattern with continuous marks
trees <- longleaf
# }
# NOT RUN {
# cut the range of tree diameters into three intervals
# using cut.ppp
long3 <- cut(trees, breaks=3)
# now split them
long3split <- split(long3)
# (2) Splitting by a factor
# Unmarked point pattern
swedishpines
# cut & split according to nearest neighbour distance
f <- cut(nndist(swedishpines), 3)
u <- split(swedishpines, f)
# (3) Splitting over a tessellation
tes <- tess(xgrid=seq(0,96,length=5),ygrid=seq(0,100,length=5))
v <- split(swedishpines, tes)
# (4) how to apply an operation to selected points:
# split into components, transform desired component, then un-split
# e.g. apply random jitter to 'on' points only
X <- amacrine
Y <- split(X)
Y$on <- rjitter(Y$on, 0.1)
split(X) <- Y
# }
```

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