# Source code for pointpats.distance_statistics

"""
Distance statistics for planar point patterns

"""
__author__ = "Serge Rey sjsrey@gmail.com"
__all__ = ['DStatistic', 'G', 'F', 'J', 'K', 'L', 'Envelopes', 'Genv', 'Fenv', 'Jenv', 'Kenv', 'Lenv']

from .process import PoissonPointProcess as csr
import numpy as np
from matplotlib import pyplot as plt

[docs]class DStatistic(object):
"""
Abstract Base Class for distance statistics.

Parameters
----------
name       : string
Name of the function. ("G", "F", "J", "K" or "L")

Attributes
----------
d          : array
The distance domain sequence.

"""
[docs]    def __init__(self, name):
self.name = name

[docs]    def plot(self, qq=False):
"""
Plot the distance function

Parameters
----------
qq: Boolean
If False the statistic is plotted against distance. If Frue, the
quantile-quantile plot is generated, observed vs. CSR.
"""

# assuming mpl
x = self.d
if qq:
plt.plot(self.ev, self._stat)
plt.plot(self.ev, self.ev)
else:
plt.plot(x, self._stat, label='{}'.format(self.name))
plt.ylabel("{}(d)".format(self.name))
plt.xlabel('d')
plt.plot(x, self.ev, label='CSR')
plt.title("{} distance function".format(self.name))

[docs]class G(DStatistic):
"""
Estimates the nearest neighbor distance distribution function G for a
point pattern.

Parameters
----------
pp         : :class:.PointPattern
Point Pattern instance.
intervals  : int
The length of distance domain sequence.
dmin       : float
The minimum of the distance domain.
dmax       : float
The maximum of the distance domain.
d          : sequence
The distance domain sequence.
If d is specified, intervals, dmin and dmax are ignored.

Attributes
----------
name       : string
Name of the function. ("G", "F", "J", "K" or "L")
d          : array
The distance domain sequence.
G          : array
The cumulative nearest neighbor distance distribution over d.

Notes
-----
In the analysis of planar point processes, the estimate of :math:G is
typically compared to the value expected from a completely spatial
random (CSR) process given as:

.. math::

G(d) = 1 - e^{-\lambda \pi  d^2}

where :math:\lambda is the intensity (points per unit area) of the point
process and :math:d is distance.

For a clustered pattern, the empirical function will be above the
expectation, while for a uniform pattern the empirical function falls below
the expectation.

"""

[docs]    def __init__(self, pp, intervals=10, dmin=0.0, dmax=None, d=None):
res = _g(pp, intervals, dmin, dmax, d)
self.d = res[:, 0]
self.G = self._stat = res[:, 1]
self.ev = 1 - np.exp(-pp.lambda_window * np.pi * self.d * self.d)
self.pp = pp
super(G, self).__init__(name="G")

[docs]class F(DStatistic):
"""
Estimates the empty space distribution function for a point pattern: F(d).

Parameters
----------
pp         : :class:.PointPattern
Point Pattern instance.
n          : int
Number of empty space points (random points).
intervals  : int
The length of distance domain sequence.
dmin       : float
The minimum of the distance domain.
dmax       : float
The maximum of the distance domain.
d          : sequence
The distance domain sequence.
If d is specified, intervals, dmin and dmax are ignored.

Attributes
----------
d          : array
The distance domain sequence.
G          : array
The cumulative empty space nearest event distance distribution
over d.

Notes
-----
In the analysis of planar point processes, the estimate of :math:F is
typically compared to the value expected from a process that displays
complete spatial randomness (CSR):

.. math::

F(d) = 1 - e^{-\lambda \pi  d^2}

where :math:\lambda is the intensity (points per unit area) of the point
process and :math:d is distance.

The expectation is identical to the expectation for the :class:G function
for a CSR process.  However, for a clustered pattern, the empirical G
function will be below the expectation, while for a uniform pattern the
empirical function falls above the expectation.

"""

[docs]    def __init__(self, pp, n=100, intervals=10, dmin=0.0, dmax=None, d=None):
res = _f(pp, n, intervals, dmin, dmax, d)
self.d = res[:, 0]
self.F = self._stat = res[:, 1]
self.ev = 1 - np.exp(-pp.lambda_window * np.pi * self.d * self.d)
super(F, self).__init__(name="F")

[docs]class J(DStatistic):
"""
Estimates the J function for a point pattern :cite:VanLieshout1996

Parameters
----------
pp         : :class:.PointPattern
Point Pattern instance.
n          : int
Number of empty space points (random points).
intervals  : int
The length of distance domain sequence.
dmin       : float
The minimum of the distance domain.
dmax       : float
The maximum of the distance domain.
d          : sequence
The distance domain sequence.
If d is specified, intervals, dmin and dmax are ignored.

Attributes
----------
d          : array
The distance domain sequence.
j          : array
F function over d.

Notes
-----

The :math:J function is a ratio of the hazard functions defined for
:math:G and :math:F:

.. math::

J(d) = \\frac{1-G(d) }{1-F(d)}

where :math:G(d) is the nearest neighbor distance distribution function
(see :class:G)
and :math:F(d) is the empty space function (see :class:F).

For a CSR process the J function equals 1. Empirical values larger than 1
are indicative of uniformity, while values below 1 suggest clustering.

"""
[docs]    def __init__(self, pp, n=100, intervals=10, dmin=0.0, dmax=None, d=None):
res = _j(pp, n, intervals, dmin, dmax, d)
self.d = res[:, 0]
self.j = self._stat = res[:, 1]
self.ev = self.j / self.j
super(J, self).__init__(name="J")

[docs]class K(DStatistic):
"""
Estimates the  K function for a point pattern.

Parameters
----------
pp         : :class:.PointPattern
Point Pattern instance.
intervals  : int
The length of distance domain sequence.
dmin       : float
The minimum of the distance domain.
dmax       : float
The maximum of the distance domain.
d          : sequence
The distance domain sequence.
If d is specified, intervals, dmin and dmax are ignored.

Attributes
----------
d          : array
The distance domain sequence.
j          : array
K function over d.

"""
[docs]    def __init__(self, pp, intervals=10, dmin=0.0, dmax=None, d=None):
res = _k(pp, intervals, dmin, dmax, d)
self.d = res[:, 0]
self.k = self._stat = res[:, 1]
self.ev = np.pi * self.d * self.d
super(K, self).__init__(name="K")

[docs]class L(DStatistic):
"""
Estimates the l function for a point pattern.

Parameters
----------
pp         : :class:.PointPattern
Point Pattern instance.
intervals  : int
The length of distance domain sequence.
dmin       : float
The minimum of the distance domain.
dmax       : float
The maximum of the distance domain.
d          : sequence
The distance domain sequence.
If d is specified, intervals, dmin and dmax are ignored.

Attributes
----------
d          : array
The distance domain sequence.
l          : array
L function over d.
"""
[docs]    def __init__(self, pp, intervals=10, dmin=0.0, dmax=None, d=None):
res = _l(pp, intervals, dmin, dmax, d)
self.d = res[:, 0]
self.l = self._stat = res[:, 1]
super(L, self).__init__(name="L")

[docs]    def plot(self):
# assuming mpl
x = self.d
plt.plot(x, self._stat, label='{}'.format(self.name))
plt.ylabel("{}(d)".format(self.name))
plt.xlabel('d')
plt.title("{} distance function".format(self.name))

def _g(pp, intervals=10, dmin=0.0, dmax=None, d=None):
"""
Estimate the nearest neighbor distances function G.

Parameters
----------
pp       : :class:.PointPattern
Point Pattern instance.
intevals : int
Number of intervals to evaluate F over.
dmin     : float
Lower limit of distance range.
dmax     : float
Upper limit of distance range. If dmax is None, dmax will be set
to maximum nearest neighor distance.
d        : sequence
The distance domain sequence. If d is specified, intervals, dmin
and dmax are ignored.

Returns
-------
: array
A 2-dimensional numpy array of 2 columns. The first column is
the distance domain sequence for the point pattern. The second
column is the cumulative nearest neighbor distance distribution.

Notes
-----
See :class:G.

"""
if d is None:
w = pp.max_nnd/intervals
if dmax:
w = dmax/intervals
d = [w*i for i in range(intervals + 2)]
cdf = [0] * len(d)
for i, d_i in enumerate(d):
smaller = [nndi for nndi in pp.nnd if nndi <= d_i]
cdf[i] = len(smaller)*1./pp.n
return np.vstack((d, cdf)).T

def _f(pp, n=100, intervals=10, dmin=0.0, dmax=None, d=None):
"""
F empty space function.

Parameters
----------
pp       : :class:.PointPattern
Point Pattern instance.
n        : int
Number of empty space points (random points).
intevals : int
Number of intervals to evaluate F over.
dmin     : float
Lower limit of distance range.
dmax     : float
Upper limit of distance range. If dmax is None, dmax will be set
to maximum nearest neighor distance.
d        : sequence
The distance domain sequence. If d is specified, intervals, dmin
and dmax are ignored.

Returns
-------
: array
A 2-dimensional numpy array of 2 columns. The first column is
the distance domain sequence for the point pattern. The second
column is corresponding F function.

Notes
-----
See :class:.F

"""

# get a csr pattern in window of pp
c = csr(pp.window, n, 1, asPP=True).realizations[0]
# for each point in csr pattern find the closest point in pp and the
# associated distance
nnids, nnds = pp.knn_other(c, k=1)

if d is None:
w = pp.max_nnd/intervals
if dmax:
w = dmax/intervals
d = [w*i for i in range(intervals + 2)]
cdf = [0] * len(d)

for i, d_i in enumerate(d):
smaller = [nndi for nndi in nnds if nndi <= d_i]
cdf[i] = len(smaller)*1./n
return np.vstack((d, cdf)).T

def _j(pp, n=100, intervals=10, dmin=0.0, dmax=None, d=None):
"""
J function: Ratio of hazard functions for F and G.

Parameters
----------
pp       : :class:.PointPattern
Point Pattern instance.
n        : int
Number of empty space points (random points).
intevals : int
Number of intervals to evaluate F over.
dmin     : float
Lower limit of distance range.
dmax     : float
Upper limit of distance range. If dmax is None, dmax will be set
to maximum nearest neighor distance.
d        : sequence
The distance domain sequence. If d is specified, intervals, dmin
and dmax are ignored.

Returns
-------
: array
A 2-dimensional numpy array of 2 columns. The first column is
the distance domain sequence for the point pattern. The second
column is corresponding J function.

Notes
-----
See :class:.J

"""

F = _f(pp, n, intervals=intervals, dmin=dmin, dmax=dmax, d=d)
G = _g(pp, intervals=intervals, dmin=dmin, dmax=dmax, d=d)
FC = 1 - F[:, 1]
GC = 1 - G[:, 1]
last_id = len(GC) + 1
if np.any(FC == 0):
last_id = np.where(FC == 0)[0][0]

return np.vstack((F[:last_id, 0], GC[:last_id]/FC[:last_id])).T

def _k(pp, intervals=10, dmin=0.0, dmax=None, d=None):
"""
Interevent K function.

Parameters
----------
pp       : :class:.PointPattern
Point Pattern instance.
n        : int
Number of empty space points (random points).
intevals : int
Number of intervals to evaluate F over.
dmin     : float
Lower limit of distance range.
dmax     : float
Upper limit of distance range. If dmax is None, dmax will be set
to length of bounding box diagonal.
d        : sequence
The distance domain sequence. If d is specified, intervals, dmin
and dmax are ignored.

Returns
-------
kcdf     : array
A 2-dimensional numpy array of 2 columns. The first column is
the distance domain sequence for the point pattern. The second
column is corresponding K function.

Notes
-----
See :class:.K

"""

if d is None:
# use length of bounding box diagonal as max distance
bb = pp.mbb
dbb = np.sqrt((bb[0]-bb[2])**2 + (bb[1]-bb[3])**2)
w = dbb/intervals
if dmax:
w = dmax/intervals
d = [w*i for i in range(intervals + 2)]
den = pp.lambda_window * pp.n * 2.
kcdf = np.asarray([(di, len(pp.tree.query_pairs(di))/den) for di in d])
return kcdf

def _l(pp, intervals=10, dmin=0.0, dmax=None, d=None):
"""
Interevent L function.

Parameters
----------
pp       : :class:.PointPattern
Point Pattern instance.
n        : int
Number of empty space points (random points).
intevals : int
Number of intervals to evaluate F over.
dmin     : float
Lower limit of distance range.
dmax     : float
Upper limit of distance range. If dmax is None, dmax will be set
to length of bounding box diagonal.
d        : sequence
The distance domain sequence. If d is specified, intervals, dmin
and dmax are ignored.

Returns
-------
kf       : array
A 2-dimensional numpy array of 2 columns. The first column is
the distance domain sequence for the point pattern. The second
column is corresponding L function.

Notes
-----
See :class:.L

"""

kf = _k(pp, intervals, dmin, dmax, d)
kf[:, 1] = np.sqrt(kf[:, 1] / np.pi) - kf[:, 0]
return kf

[docs]class Envelopes(object):
"""
Abstract base class for simulation envelopes.

Parameters
----------
pp          : :class:.PointPattern
Point Pattern instance.
intervals   : int
The length of distance domain sequence. Default is 10.
dmin        : float
The minimum of the distance domain.
dmax        : float
The maximum of the distance domain.
d           : sequence
The distance domain sequence.
If d is specified, intervals, dmin and dmax are ignored.
pct         : float
1-alpha, alpha is the significance level. Default is 0.05,
1-alpha is the confidence level for the envelope.
realizations: :class:.PointProcess
Point process instance with more than 1 realizations.

Attributes
----------
name        : string
Name of the function. ("G", "F", "J", "K" or "L")
observed    : array
A 2-dimensional numpy array of 2 columns. The first column is
the distance domain sequence for the observed point pattern.
The second column is the specific function ("G", "F", "J",
"K" or "L") over the distance domain sequence for the
observed point pattern.
low         : array
A 1-dimensional numpy array. Lower bound of the simulation
envelope.
high        : array
A 1-dimensional numpy array. Higher bound of the simulation
envelope.
mean        : array
A 1-dimensional numpy array. Mean values of the simulation
envelope.

"""
[docs]    def __init__(self, *args,  **kwargs):
# setup arguments
self.name = kwargs['name']

# calculate observed function
self.pp = args[0]
self.observed = self.calc(*args, **kwargs)
self.d = self.observed[:, 0]  # domain to be used in all realizations

# do realizations
self.mapper(kwargs['realizations'])

def mapper(self, realizations):
reals = realizations.realizations
res = np.asarray([self.calc(reals[p]) for p in reals])

# When calculating the J function for all the simulations, the length
# of the returned interval domains might be different.

if self.name == "J":
res = []
for p in reals:
j = self.calc(reals[p])
if j.shape[0] < self.d.shape[0]:
diff = self.d.shape[0]-j.shape[0]
for i in range(diff):
j = np.append(j, [[self.d[i+diff], np.inf]], axis=0)
res.append(j)
res = np.array(res)

res = res[:, :, -1]
res.sort(axis=0)
nres = len(res)
self.low = res[np.int(nres * self.pct/2.)]
self.high = res[np.int(nres * (1-self.pct/2.))]
self.mean = res.mean(axis=0)

def calc(self, *args, **kwargs):
print('implement in subclass')

def plot(self):
# assuming mpl
x = self.d
plt.plot(x, self.observed[:, 1], label='{}'.format(self.name))
plt.plot(x, self.mean, 'g-.', label='CSR')
plt.plot(x, self.low, 'r-.', label='LB')
plt.plot(x, self.high, 'r-.', label="UB")
plt.ylabel("{}(d)".format(self.name))
plt.xlabel('d')
plt.title("{} Simulation Envelopes".format(self.name))
plt.legend(loc=0)

[docs]class Genv(Envelopes):
"""
Simulation envelope for G function.

Parameters
----------
pp          : :class:.PointPattern
Point Pattern instance.
intervals   : int
The length of distance domain sequence. Default is 10.
dmin        : float
The minimum of the distance domain.
dmax        : float
Upper limit of distance range. If dmax is None, dmax will be
set to maximum nearest neighbor distance.
d           : sequence
The distance domain sequence.
If d is specified, intervals, dmin and dmax are ignored.
pct         : float
1-alpha, alpha is the significance level. Default is 0.05,
which means 95% confidence level for the envelopes.
realizations: :class:.PointProcess
Point process instance with more than 1 realizations.

Attributes
----------
name        : string
Name of the function. ("G", "F", "J", "K" or "L")
observed    : array
A 2-dimensional numpy array of 2 columns. The first column is
the distance domain sequence for the observed point pattern.
The second column is cumulative nearest neighbor distance
distribution (G function) for the observed point pattern.
low         : array
A 1-dimensional numpy array. Lower bound of the simulation
envelope.
high        : array
A 1-dimensional numpy array. Higher bound of the simulation
envelope.
mean        : array
A 1-dimensional numpy array. Mean values of the simulation
envelope.

Examples
--------
.. plot::

>>> import libpysal as ps
>>> from pointpats import Genv, PoissonPointProcess, Window
>>> from libpysal.cg import shapely_ext
>>> va = ps.io.open(ps.examples.get_path("vautm17n.shp"))
>>> polys = [shp for shp in va]
>>> pp = PoissonPointProcess(Window(state.parts), 100, 1, asPP=True).realizations[0]
>>> csrs = PoissonPointProcess(pp.window, 100, 100, asPP=True)
>>> genv_bb = Genv(pp, realizations=csrs)
>>> genv_bb.plot()

"""

[docs]    def __init__(self, pp, intervals=10, dmin=0.0, dmax=None, d=None, pct=0.05,
realizations=None):
self.pp = pp
self.intervals = intervals
self.dmin = dmin
self.dmax = dmax
self.d = d
self.pct = pct
super(Genv, self).__init__(pp, realizations=realizations, name="G")

[docs]    def calc(self, *args, **kwargs):
pp = args[0]
return _g(pp, intervals=self.intervals, dmin=self.dmin, dmax=self.dmax,
d=self.d)

[docs]class Fenv(Envelopes):
"""
Simulation envelope for F function.

Parameters
----------
pp          : :class:.PointPattern
Point Pattern instance.
n           : int
Number of empty space points (random points).
intervals   : int
The length of distance domain sequence. Default is 10.
dmin        : float
The minimum of the distance domain.
dmax        : float
Upper limit of distance range. If dmax is None, dmax will be
set to maximum nearest neighbor distance.
d           : sequence
The distance domain sequence.
If d is specified, intervals, dmin and dmax are ignored.
pct         : float
1-alpha, alpha is the significance level. Default is 0.05,
which means 95% confidence level for the envelopes.
realizations: :class:.PointProcess
Point process instance with more than 1 realizations.

Attributes
----------
name        : string
Name of the function. ("G", "F", "J", "K" or "L")
observed    : array
A 2-dimensional numpy array of 2 columns. The first column is
the distance domain sequence for the observed point pattern.
The second column is F function for the observed point
pattern.
low         : array
A 1-dimensional numpy array. Lower bound of the simulation
envelope.
high        : array
A 1-dimensional numpy array. Higher bound of the simulation
envelope.
mean        : array
A 1-dimensional numpy array. Mean values of the simulation
envelope.

Examples
--------
.. plot::

>>> import libpysal as ps
>>> from libpysal.cg import shapely_ext
>>> from pointpats import PoissonPointProcess,Window,Fenv
>>> va = ps.io.open(ps.examples.get_path("vautm17n.shp"))
>>> polys = [shp for shp in va]
>>> pp = PoissonPointProcess(Window(state.parts), 100, 1, asPP=True).realizations[0]
>>> csrs = PoissonPointProcess(pp.window, 100, 100, asPP=True)
>>> fenv = Fenv(pp, realizations=csrs)
>>> fenv.plot()

"""
[docs]    def __init__(self, pp, n=100, intervals=10, dmin=0.0, dmax=None, d=None,
pct=0.05, realizations=None):
self.pp = pp
self.n = n
self.intervals = intervals
self.dmin = dmin
self.dmax = dmax
self.d = d
self.pct = pct
super(Fenv, self).__init__(pp, realizations=realizations, name="F")

def calc(self, *args, **kwargs):
pp = args[0]
return _f(pp, self.n, intervals=self.intervals, dmin=self.dmin,
dmax=self.dmax, d=self.d)

[docs]class Jenv(Envelopes):
"""
Simulation envelope for J function.

Parameters
----------
pp          : :class:.PointPattern
Point Pattern instance.
n           : int
Number of empty space points (random points).
intervals   : int
The length of distance domain sequence. Default is 10.
dmin        : float
The minimum of the distance domain.
dmax        : float
Upper limit of distance range. If dmax is None, dmax will be
set to maximum nearest neighbor distance.
d           : sequence
The distance domain sequence.
If d is specified, intervals, dmin and dmax are ignored.
pct         : float
1-alpha, alpha is the significance level. Default is 0.05,
which means 95% confidence level for the envelopes.
realizations: :class:.PointProcess
Point process instance with more than 1 realizations.

Attributes
----------
name        : string
Name of the function. ("G", "F", "J", "K" or "L")
observed    : array
A 2-dimensional numpy array of 2 columns. The first column is
the distance domain sequence for the observed point pattern.
The second column is J function for the observed point
pattern.
low         : array
A 1-dimensional numpy array. Lower bound of the simulation
envelope.
high        : array
A 1-dimensional numpy array. Higher bound of the simulation
envelope.
mean        : array
A 1-dimensional numpy array. Mean values of the simulation
envelope.

Examples
--------
.. plot::

>>> import libpysal as ps
>>> from pointpats import Jenv, PoissonPointProcess, Window
>>> from libpysal.cg import shapely_ext
>>> va = ps.io.open(ps.examples.get_path("vautm17n.shp"))
>>> polys = [shp for shp in va]
>>> pp = PoissonPointProcess(Window(state.parts), 100, 1, asPP=True).realizations[0]
>>> csrs = PoissonPointProcess(pp.window, 100, 100, asPP=True)
>>> jenv = Jenv(pp, realizations=csrs)
>>> jenv.plot()

"""
[docs]    def __init__(self, pp, n=100, intervals=10, dmin=0.0, dmax=None, d=None,
pct=0.05, realizations=None):
self.pp = pp
self.n = n
self.intervals = intervals
self.dmin = dmin
self.dmax = dmax
self.d = d
self.pct = pct
super(Jenv, self).__init__(pp, realizations=realizations, name="J")

def calc(self, *args, **kwargs):
pp = args[0]
return _j(pp, self.n, intervals=self.intervals, dmin=self.dmin,
dmax=self.dmax, d=self.d)

[docs]class Kenv(Envelopes):
"""
Simulation envelope for K function.

Parameters
----------
pp          : :class:.PointPattern
Point Pattern instance.
intervals   : int
The length of distance domain sequence. Default is 10.
dmin        : float
The minimum of the distance domain.
dmax        : float
Upper limit of distance range. If dmax is None, dmax will be
set to maximum nearest neighbor distance.
d           : sequence
The distance domain sequence.
If d is specified, intervals, dmin and dmax are ignored.
pct         : float
1-alpha, alpha is the significance level. Default is 0.05,
which means 95% confidence level for the envelope.
realizations: :class:.PointProcess
Point process instance with more than 1 realizations.

Attributes
----------
name        : string
Name of the function. ("G", "F", "J", "K" or "L")
observed    : array
A 2-dimensional numpy array of 2 columns. The first column is
the distance domain sequence for the observed point pattern.
The second column is K function for the observed point
pattern.
low         : array
A 1-dimensional numpy array. Lower bound of the simulation
envelope.
high        : array
A 1-dimensional numpy array. Higher bound of the simulation
envelope.
mean        : array
A 1-dimensional numpy array. Mean values of the simulation
envelope.

Examples
--------
.. plot::

>>> import libpysal as ps
>>> from pointpats import Kenv, PoissonPointProcess, Window
>>> from libpysal.cg import shapely_ext
>>> va = ps.io.open(ps.examples.get_path("vautm17n.shp"))
>>> polys = [shp for shp in va]
>>> pp = PoissonPointProcess(Window(state.parts), 100, 1, asPP=True).realizations[0]
>>> csrs = PoissonPointProcess(pp.window, 100, 100, asPP=True)
>>> kenv = Kenv(pp, realizations=csrs)
>>> kenv.plot()

"""
[docs]    def __init__(self, pp, intervals=10, dmin=0.0, dmax=None, d=None,
pct=0.05, realizations=None):
self.pp = pp
self.intervals = intervals
self.dmin = dmin
self.dmax = dmax
self.d = d
self.pct = pct
super(Kenv, self).__init__(pp, realizations=realizations, name="K")

def calc(self, *args, **kwargs):
pp = args[0]
return _k(pp, intervals=self.intervals, dmin=self.dmin, dmax=self.dmax,
d=self.d)

[docs]class Lenv(Envelopes):
"""
Simulation envelope for L function.

Parameters
----------
pp          : :class:.PointPattern
Point Pattern instance.
intervals   : int
The length of distance domain sequence. Default is 10.
dmin        : float
The minimum of the distance domain.
dmax        : float
Upper limit of distance range. If dmax is None, dmax will be
set to maximum nearest neighbor distance.
d           : sequence
The distance domain sequence.
If d is specified, intervals, dmin and dmax are ignored.
pct         : float
1-alpha, alpha is the significance level. Default is 0.05,
which means 95% confidence level for the envelopes.
realizations: :class:.PointProcess
Point process instance with more than 1 realizations.

Attributes
----------
name        : string
Name of the function. ("G", "F", "J", "K" or "L")
observed    : array
A 2-dimensional numpy array of 2 columns. The first column is
the distance domain sequence for the observed point pattern.
The second column is L function for the observed point
pattern.
low         : array
A 1-dimensional numpy array. Lower bound of the simulation
envelope.
high        : array
A 1-dimensional numpy array. Higher bound of the simulation
envelope.
mean        : array
A 1-dimensional numpy array. Mean values of the simulation
envelope.

Examples
--------
.. plot::

>>> import libpysal as ps
>>> from pointpats import Lenv, PoissonPointProcess, Window
>>> from libpysal.cg import shapely_ext
>>> va = ps.io.open(ps.examples.get_path("vautm17n.shp"))
>>> polys = [shp for shp in va]
>>> pp = PoissonPointProcess(Window(state.parts), 100, 1, asPP=True).realizations[0]
>>> csrs = PoissonPointProcess(pp.window, 100, 100, asPP=True)
>>> lenv = Lenv(pp, realizations=csrs)
>>> lenv.plot()

"""

[docs]    def __init__(self, pp, intervals=10, dmin=0.0, dmax=None, d=None,
pct=0.05, realizations=None):
self.pp = pp
self.intervals = intervals
self.dmin = dmin
self.dmax = dmax
self.d = d
self.pct = pct
super(Lenv, self).__init__(pp, realizations=realizations, name="L")

def calc(self, *args, **kwargs):
pp = args[0]
return _l(pp, intervals=self.intervals, dmin=self.dmin, dmax=self.dmax,
d=self.d)