linearKinhom | R Documentation |

Computes an estimate of the inhomogeneous linear *K* function
for a point pattern on a linear network.

linearKinhom(X, lambda=NULL, r=NULL, ..., correction="Ang", normalise=TRUE, normpower=1, update=TRUE, leaveoneout=TRUE, ratio=FALSE)

`X` |
Point pattern on linear network (object of class |

`lambda` |
Intensity values for the point pattern. Either a numeric vector,
a |

`r` |
Optional. Numeric vector of values of the function argument |

`...` |
Ignored. |

`correction` |
Geometry correction.
Either |

`normalise` |
Logical. If |

`normpower` |
Integer (usually either 1 or 2). Normalisation power. See Details. |

`update` |
Logical value indicating what to do when |

`leaveoneout` |
Logical value (passed to |

`ratio` |
Logical.
If |

This command computes the inhomogeneous version of the
linear *K* function from point pattern data on a linear network.

If `lambda = NULL`

the result is equivalent to the
homogeneous *K* function `linearK`

.
If `lambda`

is given, then it is expected to provide estimated values
of the intensity of the point process at each point of `X`

.
The argument `lambda`

may be a numeric vector (of length equal to
the number of points in `X`

), or a `function(x,y)`

that will be
evaluated at the points of `X`

to yield numeric values,
or a pixel image (object of class `"im"`

) or a fitted point
process model (object of class `"ppm"`

or `"lppm"`

).

If `lambda`

is a fitted point process model,
the default behaviour is to update the model by re-fitting it to
the data, before computing the fitted intensity.
This can be disabled by setting `update=FALSE`

.

If `correction="none"`

, the calculations do not include
any correction for the geometry of the linear network.
If `correction="Ang"`

, the pair counts are weighted using
Ang's correction (Ang, 2010).

Each estimate is initially computed as

*
K^inhom(r)= (1/length(L)) sum[i] sum[j] 1(d[i,j] <= r) *
e(x[i],x[j])/(lambda(x[i]) * lambda(x[j]))
*

where `L`

is the linear network,
*d[i,j]* is the distance between points
*x[i]* and *x[j]*, and
*e(x[i],x[j])* is a weight.
If `correction="none"`

then this weight is equal to 1,
while if `correction="Ang"`

the weight is
*e(x[i],x[j],r) = 1/m(x[i],d[i,j])*
where *m(u,t)* is the number of locations on the network that lie
exactly *t* units distant from location *u* by the shortest
path.

If `normalise=TRUE`

(the default), then the estimates
described above
are multiplied by *c^normpower* where
*
c = length(L)/sum[i] (1/lambda(x[i])).
*
This rescaling reduces the variability and bias of the estimate
in small samples and in cases of very strong inhomogeneity.
The default value of `normpower`

is 1 (for consistency with
previous versions of spatstat)
but the most sensible value is 2, which would correspond to rescaling
the `lambda`

values so that
*
sum[i] (1/lambda(x[i])) = area(W).
*

Function value table (object of class `"fv"`

).

Ang Qi Wei aqw07398@hotmail.com and \adrian

Ang, Q.W. (2010) Statistical methodology for spatial point patterns on a linear network. MSc thesis, University of Western Australia.

Ang, Q.W., Baddeley, A. and Nair, G. (2012)
Geometrically corrected second-order analysis of
events on a linear network, with applications to
ecology and criminology.
*Scandinavian Journal of Statistics* **39**, 591–617.

`lpp`

data(simplenet) X <- rpoislpp(5, simplenet) fit <- lppm(X ~x) K <- linearKinhom(X, lambda=fit) plot(K)

Embedding an R snippet on your website

Add the following code to your website.

For more information on customizing the embed code, read Embedding Snippets.