# Kmulti.inhom

##### Inhomogeneous Marked K-Function

For a marked point pattern,
estimate the inhomogeneous version of the multitype $K$ function
which counts the expected number of points of subset $J$
within a given distance from a typical point in subset `I`

,
adjusted for spatially varying intensity.

##### Usage

```
Kmulti.inhom(X, I, J, lambdaI=NULL, lambdaJ=NULL,
...,
r=NULL, breaks=NULL,
correction=c("border", "isotropic", "Ripley", "translate"),
lambdaIJ=NULL,
sigma=NULL, varcov=NULL)
```

##### Arguments

- X
- The observed point pattern, from which an estimate of the inhomogeneous multitype $K$ function $K_{IJ}(r)$ will be computed. It must be a marked point pattern. See under Details.
- I
- Subset index specifying the points of
`X`

from which distances are measured. See Details. - J
- Subset index specifying the points in
`X`

to which distances are measured. See Details. - lambdaI
- Optional.
Values of the estimated intensity of the sub-process
`X[I]`

. Either a pixel image (object of class`"im"`

), a numeric vector containing the intensity values at each of the points in`X[I]`

, or - lambdaJ
- Optional.
Values of the estimated intensity of the sub-process
`X[J]`

. Either a pixel image (object of class`"im"`

), a numeric vector containing the intensity values at each of the points in`X[J]`

, or - ...
- Ignored.
- r
- Optional. Numeric vector. The values of the argument $r$ at which the multitype $K$ function $K_{IJ}(r)$ should be evaluated. There is a sensible default. First-time users are strongly advised not to specify this argument. See below fo
- breaks
- This argument is for internal use only.
- correction
- A character vector containing any selection of the
options
`"border"`

,`"bord.modif"`

,`"isotropic"`

,`"Ripley"`

,`"translate"`

,`"none"`

or`"best"`

. It specifie - lambdaIJ
- Optional. A matrix containing estimates of
the product of the intensities
`lambdaI`

and`lambdaJ`

for each pair of points, the first point - sigma,varcov
- Optional arguments passed to
`density.ppp`

to control the smoothing bandwidth, when`lambda`

is estimated by kernel smoothing.

##### Details

The function `Kmulti.inhom`

is the counterpart, for spatially-inhomogeneous marked point patterns,
of the multitype $K$ function `Kmulti`

.

Suppose $X$ is a marked point process, with marks of any kind. Suppose $X_I$, $X_J$ are two sub-processes, possibly overlapping. Typically $X_I$ would consist of those points of $X$ whose marks lie in a specified range of mark values, and similarly for $X_J$. Suppose that $\lambda_I(u)$, $\lambda_J(u)$ are the spatially-varying intensity functions of $X_I$ and $X_J$ respectively. Consider all the pairs of points $(u,v)$ in the point process $X$ such that the first point $u$ belongs to $X_I$, the second point $v$ belongs to $X_J$, and the distance between $u$ and $v$ is less than a specified distance $r$. Give this pair $(u,v)$ the numerical weight $1/(\lambda_I(u)\lambda_J(u))$. Calculate the sum of these weights over all pairs of points as described. This sum (after appropriate edge-correction and normalisation) is the estimated inhomogeneous multitype $K$ function.

The argument `X`

must be a point pattern (object of class
`"ppp"`

) or any data that are acceptable to `as.ppp`

.

The arguments `I`

and `J`

specify two subsets of the
point pattern. They may be any type of subset indices, for example,
logical vectors of length equal to `npoints(X)`

,
or integer vectors with entries in the range 1 to
`npoints(X)`

, or negative integer vectors.

Alternatively, `I`

and `J`

may be **functions**
that will be applied to the point pattern `X`

to obtain
index vectors. If `I`

is a function, then evaluating
`I(X)`

should yield a valid subset index. This option
is useful when generating simulation envelopes using
`envelope`

.

The argument `lambdaI`

supplies the values
of the intensity of the sub-process identified by index `I`

.
It may be either
[object Object],[object Object],[object Object],[object Object]
If `lambdaI`

is omitted, then it will be estimated using
a `leave-one-out' kernel smoother, as described in Baddeley, `lambdaI`

for a given
point is computed by removing the point from the
point pattern, applying kernel smoothing to the remaining points using
`density.ppp`

, and evaluating the smoothed intensity
at the point in question. The smoothing kernel bandwidth is controlled
by the arguments `sigma`

and `varcov`

, which are passed to
`density.ppp`

along with any extra arguments.

Similarly `lambdaJ`

supplies the values
of the intensity of the sub-process identified by index `J`

.

The argument `r`

is the vector of values for the
distance $r$ at which $K_{IJ}(r)$ should be evaluated.
It is also used to determine the breakpoints
(in the sense of `hist`

)
for the computation of histograms of distances.

First-time users would be strongly advised not to specify `r`

.
However, if it is specified, `r`

must satisfy `r[1] = 0`

,
and `max(r)`

must be larger than the radius of the largest disc
contained in the window.

Biases due to edge effects are
treated in the same manner as in `Kinhom`

.
The edge corrections implemented here are
[object Object],[object Object],[object Object]
The pair correlation function `pcf`

can also be applied to the
result of `Kmulti.inhom`

.
}
*Statistica Neerlandica* **54**, 329--350.
}
`Kmulti`

,
`Kdot.inhom`

,
`Kcross.inhom`

,
`pcf`

##### Value

- An object of class
`"fv"`

(see`fv.object`

).Essentially a data frame containing numeric columns

r the values of the argument $r$ at which the function $K_{IJ}(r)$ has been estimated theo the theoretical value of $K_{IJ}(r)$ for a marked Poisson process, namely $\pi r^2$ - together with a column or columns named
`"border"`

,`"bord.modif"`

,`"iso"`

and/or`"trans"`

, according to the selected edge corrections. These columns contain estimates of the function $K_{IJ}(r)$ obtained by the edge corrections named.

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