dclab 0.67.0__cp314-cp314-macosx_11_0_arm64.whl

dclab/external/skimage/_find_contours.py

@@ -0,0 +1,216 @@
+import numpy as np
+from . import _find_contours_cy
+
+from collections import deque
+
+_param_options = ('high', 'low')
+
+
+def find_contours(array, level,
+                  fully_connected='low', positive_orientation='low'):
+    """Find iso-valued contours in a 2D array for a given level value.
+
+    Uses the "marching squares" method to compute a the iso-valued contours of
+    the input 2D array for a particular level value. Array values are linearly
+    interpolated to provide better precision for the output contours.
+
+    Parameters
+    ----------
+    array : 2D ndarray of double
+        Input data in which to find contours.
+    level : float
+        Value along which to find contours in the array.
+    fully_connected : str, {'low', 'high'}
+         Indicates whether array elements below the given level value are to be
+         considered fully-connected (and hence elements above the value will
+         only be face connected), or vice-versa. (See notes below for details.)
+    positive_orientation : either 'low' or 'high'
+         Indicates whether the output contours will produce positively-oriented
+         polygons around islands of low- or high-valued elements. If 'low' then
+         contours will wind counter- clockwise around elements below the
+         iso-value. Alternately, this means that low-valued elements are always
+         on the left of the contour. (See below for details.)
+
+    Returns
+    -------
+    contours : list of (n,2)-ndarrays
+        Each contour is an ndarray of shape ``(n, 2)``,
+        consisting of n ``(row, column)`` coordinates along the contour.
+
+    Notes
+    -----
+    The marching squares algorithm is a special case of the marching cubes
+    algorithm [1]_.  A simple explanation is available here::
+
+      http://www.essi.fr/~lingrand/MarchingCubes/algo.html
+
+    There is a single ambiguous case in the marching squares algorithm: when
+    a given ``2 x 2``-element square has two high-valued and two low-valued
+    elements, each pair diagonally adjacent. (Where high- and low-valued is
+    with respect to the contour value sought.) In this case, either the
+    high-valued elements can be 'connected together' via a thin isthmus that
+    separates the low-valued elements, or vice-versa. When elements are
+    connected together across a diagonal, they are considered 'fully
+    connected' (also known as 'face+vertex-connected' or '8-connected'). Only
+    high-valued or low-valued elements can be fully-connected, the other set
+    will be considered as 'face-connected' or '4-connected'. By default,
+    low-valued elements are considered fully-connected; this can be altered
+    with the 'fully_connected' parameter.
+
+    Output contours are not guaranteed to be closed: contours which intersect
+    the array edge will be left open. All other contours will be closed. (The
+    closed-ness of a contours can be tested by checking whether the beginning
+    point is the same as the end point.)
+
+    Contours are oriented. By default, array values lower than the contour
+    value are to the left of the contour and values greater than the contour
+    value are to the right. This means that contours will wind
+    counter-clockwise (i.e. in 'positive orientation') around islands of
+    low-valued pixels. This behavior can be altered with the
+    'positive_orientation' parameter.
+
+    The order of the contours in the output list is determined by the position
+    of the smallest ``x,y`` (in lexicographical order) coordinate in the
+    contour.  This is a side-effect of how the input array is traversed, but
+    can be relied upon.
+
+    .. warning::
+
+       Array coordinates/values are assumed to refer to the *center* of the
+       array element. Take a simple example input: ``[0, 1]``. The interpolated
+       position of 0.5 in this array is midway between the 0-element (at
+       ``x=0``) and the 1-element (at ``x=1``), and thus would fall at
+       ``x=0.5``.
+
+    This means that to find reasonable contours, it is best to find contours
+    midway between the expected "light" and "dark" values. In particular,
+    given a binarized array, *do not* choose to find contours at the low or
+    high value of the array. This will often yield degenerate contours,
+    especially around structures that are a single array element wide. Instead
+    choose a middle value, as above.
+
+    References
+    ----------
+    .. [1] Lorensen, William and Harvey E. Cline. Marching Cubes: A High
+           Resolution 3D Surface Construction Algorithm. Computer Graphics
+           (SIGGRAPH 87 Proceedings) 21(4) July 1987, p. 163-170).
+
+    Examples
+    --------
+    >>> a = np.zeros((3, 3))
+    >>> a[0, 0] = 1
+    >>> a
+    array([[ 1.,  0.,  0.],
+           [ 0.,  0.,  0.],
+           [ 0.,  0.,  0.]])
+    >>> find_contours(a, 0.5)
+    [array([[ 0. ,  0.5],
+           [ 0.5,  0. ]])]
+    """
+    array = np.asarray(array, dtype=np.double)
+    if array.ndim != 2:
+        raise ValueError('Only 2D arrays are supported.')
+    level = float(level)
+    if (fully_connected not in _param_options or
+            positive_orientation not in _param_options):
+        raise ValueError('Parameters "fully_connected" and'
+                         ' "positive_orientation" must be either "high" or'
+                         ' "low".')
+    point_list = _find_contours_cy.iterate_and_store(array, level,
+                                                     fully_connected == 'high')
+    contours = _assemble_contours(_take_2(point_list))
+    if positive_orientation == 'high':
+        contours = [c[::-1] for c in contours]
+    return contours
+
+
+def _take_2(seq):
+    iterator = iter(seq)
+    while True:
+        try:
+            n1 = next(iterator)
+            n2 = next(iterator)
+            yield (n1, n2)
+        except StopIteration:
+            return
+
+
+def _assemble_contours(points_iterator):
+    current_index = 0
+    contours = {}
+    starts = {}
+    ends = {}
+    for from_point, to_point in points_iterator:
+        # Ignore degenerate segments.
+        # This happens when (and only when) one vertex of the square is
+        # exactly the contour level, and the rest are above or below.
+        # This degnerate vertex will be picked up later by neighboring squares.
+        if from_point == to_point:
+            continue
+
+        tail_data = starts.get(to_point)
+        head_data = ends.get(from_point)
+
+        if tail_data is not None and head_data is not None:
+            tail, tail_num = tail_data
+            head, head_num = head_data
+            # We need to connect these two contours.
+            if tail is head:
+                # We need to closed a contour.
+                # Add the end point, and remove the contour from the
+                # 'starts' and 'ends' dicts.
+                head.append(to_point)
+                del starts[to_point]
+                del ends[from_point]
+            else:  # tail is not head
+                # We need to join two distinct contours.
+                # We want to keep the first contour segment created, so that
+                # the final contours are ordered left->right, top->bottom.
+                if tail_num > head_num:
+                    # tail was created second. Append tail to head.
+                    head.extend(tail)
+                    # remove all traces of tail:
+                    del starts[to_point]
+                    try:
+                        del ends[tail[-1]]
+                    except KeyError:
+                        pass
+                    del contours[tail_num]
+                    # remove the old end of head and add the new end.
+                    del ends[from_point]
+                    ends[head[-1]] = (head, head_num)
+                else:  # tail_num <= head_num
+                    # head was created second. Prepend head to tail.
+                    tail.extendleft(reversed(head))
+                    # remove all traces of head:
+                    del starts[head[0]]
+                    del ends[from_point]
+                    del contours[head_num]
+                    # remove the old start of tail and add the new start.
+                    del starts[to_point]
+                    starts[tail[0]] = (tail, tail_num)
+        elif tail_data is None and head_data is None:
+            # we need to add a new contour
+            current_index += 1
+            new_num = current_index
+            new_contour = deque((from_point, to_point))
+            contours[new_num] = new_contour
+            starts[from_point] = (new_contour, new_num)
+            ends[to_point] = (new_contour, new_num)
+        elif tail_data is not None and head_data is None:
+            tail, tail_num = tail_data
+            # We've found a single contour to which the new segment should be
+            # prepended.
+            tail.appendleft(from_point)
+            del starts[to_point]
+            starts[from_point] = (tail, tail_num)
+        elif tail_data is None and head_data is not None:
+            head, head_num = head_data
+            # We've found a single contour to which the new segment should be
+            # appended
+            head.append(to_point)
+            del ends[from_point]
+            ends[to_point] = (head, head_num)
+    # end iteration over from_ and to_ points
+
+    return [np.array(contour) for (num, contour) in sorted(contours.items())]

dclab/external/skimage/_find_contours_cy.pyx

@@ -0,0 +1,188 @@
+#cython: cdivision=True
+#cython: boundscheck=False
+#cython: nonecheck=False
+#cython: wraparound=False
+#cython: language_level=3
+import numpy as np
+
+
+cdef inline double _get_fraction(double from_value, double to_value,
+                                 double level):
+    if (to_value == from_value):
+        return 0
+    return ((level - from_value) / (to_value - from_value))
+
+
+def iterate_and_store(double[:, :] array,
+                      double level, Py_ssize_t vertex_connect_high):
+    """Iterate across the given array in a marching-squares fashion,
+    looking for segments that cross 'level'. If such a segment is
+    found, its coordinates are added to a growing list of segments,
+    which is returned by the function.  if vertex_connect_high is
+    nonzero, high-values pixels are considered to be face+vertex
+    connected into objects; otherwise low-valued pixels are.
+
+    """
+    if array.shape[0] < 2 or array.shape[1] < 2:
+        raise ValueError("Input array must be at least 2x2.")
+
+    cdef list arc_list = []
+    cdef Py_ssize_t n
+
+    # The plan is to iterate a 2x2 square across the input array. This means
+    # that the upper-left corner of the square needs to iterate across a
+    # sub-array that's one-less-large in each direction (so that the square
+    # never steps out of bounds). The square is represented by four pointers:
+    # ul, ur, ll, and lr (for 'upper left', etc.). We also maintain the current
+    # 2D coordinates for the position of the upper-left pointer. Note that we
+    # ensured that the array is of type 'double' and is C-contiguous (last
+    # index varies the fastest).
+
+    # Current coords start at 0,0.
+    cdef Py_ssize_t[2] coords
+    coords[0] = 0
+    coords[1] = 0
+
+    # Calculate the number of iterations we'll need
+    cdef Py_ssize_t num_square_steps = (array.shape[0] - 1) \
+                                        * (array.shape[1] - 1)
+
+    cdef unsigned char square_case = 0
+    cdef tuple top, bottom, left, right
+    cdef double ul, ur, ll, lr
+    cdef Py_ssize_t r0, r1, c0, c1
+
+    for n in range(num_square_steps):
+        # There are sixteen different possible square types, diagramed below.
+        # A + indicates that the vertex is above the contour value, and a -
+        # indicates that the vertex is below or equal to the contour value.
+        # The vertices of each square are:
+        # ul ur
+        # ll lr
+        # and can be treated as a binary value with the bits in that order. Thus
+        # each square case can be numbered:
+        #  0--   1+-   2-+   3++   4--   5+-   6-+   7++
+        #   --    --    --    --    +-    +-    +-    +-
+        #
+        #  8--   9+-  10-+  11++  12--  13+-  14-+  15++
+        #   -+    -+    -+    -+    ++    ++    ++    ++
+        #
+        # The position of the line segment that cuts through (or
+        # doesn't, in case 0 and 15) each square is clear, except in
+        # cases 6 and 9. In this case, where the segments are placed
+        # is determined by vertex_connect_high.  If
+        # vertex_connect_high is false, then lines like \\ are drawn
+        # through square 6, and lines like // are drawn through square
+        # 9.  Otherwise, the situation is reversed.
+        # Finally, recall that we draw the lines so that (moving from tail to
+        # head) the lower-valued pixels are on the left of the line. So, for
+        # example, case 1 entails a line slanting from the middle of the top of
+        # the square to the middle of the left side of the square.
+
+        r0, c0 = coords[0], coords[1]
+        r1, c1 = r0 + 1, c0 + 1
+
+        ul = array[r0, c0]
+        ur = array[r0, c1]
+        ll = array[r1, c0]
+        lr = array[r1, c1]
+
+        # now in advance the coords indices
+        if coords[1] < array.shape[1] - 2:
+            coords[1] += 1
+        else:
+            coords[0] += 1
+            coords[1] = 0
+
+
+        square_case = 0
+        if (ul > level): square_case += 1
+        if (ur > level): square_case += 2
+        if (ll > level): square_case += 4
+        if (lr > level): square_case += 8
+
+        if (square_case != 0 and square_case != 15):
+            # only do anything if there's a line passing through the
+            # square. Cases 0 and 15 are entirely below/above the contour.
+
+            top = r0, c0 + _get_fraction(ul, ur, level)
+            bottom = r1, c0 + _get_fraction(ll, lr, level)
+            left = r0 + _get_fraction(ul, ll, level), c0
+            right = r0 + _get_fraction(ur, lr, level), c1
+
+            if (square_case == 1):
+                # top to left
+                arc_list.append(top)
+                arc_list.append(left)
+            elif (square_case == 2):
+                # right to top
+                arc_list.append(right)
+                arc_list.append(top)
+            elif (square_case == 3):
+                # right to left
+                arc_list.append(right)
+                arc_list.append(left)
+            elif (square_case == 4):
+                # left to bottom
+                arc_list.append(left)
+                arc_list.append(bottom)
+            elif (square_case == 5):
+                # top to bottom
+                arc_list.append(top)
+                arc_list.append(bottom)
+            elif (square_case == 6):
+                if vertex_connect_high:
+                    arc_list.append(left)
+                    arc_list.append(top)
+
+                    arc_list.append(right)
+                    arc_list.append(bottom)
+                else:
+                    arc_list.append(right)
+                    arc_list.append(top)
+                    arc_list.append(left)
+                    arc_list.append(bottom)
+            elif (square_case == 7):
+                # right to bottom
+                arc_list.append(right)
+                arc_list.append(bottom)
+            elif (square_case == 8):
+                # bottom to right
+                arc_list.append(bottom)
+                arc_list.append(right)
+            elif (square_case == 9):
+                if vertex_connect_high:
+                    arc_list.append(top)
+                    arc_list.append(right)
+
+                    arc_list.append(bottom)
+                    arc_list.append(left)
+                else:
+                    arc_list.append(top)
+                    arc_list.append(left)
+
+                    arc_list.append(bottom)
+                    arc_list.append(right)
+            elif (square_case == 10):
+                # bottom to top
+                arc_list.append(bottom)
+                arc_list.append(top)
+            elif (square_case == 11):
+                # bottom to left
+                arc_list.append(bottom)
+                arc_list.append(left)
+            elif (square_case == 12):
+                # lef to right
+                arc_list.append(left)
+                arc_list.append(right)
+            elif (square_case == 13):
+                # top to right
+                arc_list.append(top)
+                arc_list.append(right)
+            elif (square_case == 14):
+                # left to top
+                arc_list.append(left)
+                arc_list.append(top)
+
+    return arc_list
+

dclab/external/skimage/_pnpoly.pyx

@@ -0,0 +1,99 @@
+#cython: cdivision=True
+#cython: boundscheck=False
+#cython: nonecheck=False
+#cython: wraparound=False
+import numpy as np
+
+cimport numpy as cnp
+from ._shared.geometry cimport point_in_polygon, points_in_polygon
+
+cnp.import_array()
+
+
+def _grid_points_in_poly(shape, verts):
+    """Test whether points on a specified grid are inside a polygon.
+
+    For each ``(r, c)`` coordinate on a grid, i.e. ``(0, 0)``, ``(0, 1)`` etc.,
+    test whether that point lies inside a polygon.
+
+    Parameters
+    ----------
+    shape : tuple (M, N)
+        Shape of the grid.
+    verts : (V, 2) array
+        Specify the V vertices of the polygon, sorted either clockwise
+        or anti-clockwise.  The first point may (but does not need to be)
+        duplicated.
+
+    See Also
+    --------
+    points_in_poly
+
+    Returns
+    -------
+    mask : (M, N) ndarray of bool
+        True where the grid falls inside the polygon.
+
+    """
+    cdef double[:] vx, vy
+    verts = np.asarray(verts)
+
+    vx = verts[:, 0].astype(np.double)
+    vy = verts[:, 1].astype(np.double)
+    cdef Py_ssize_t V = vx.shape[0]
+
+    cdef Py_ssize_t M = shape[0]
+    cdef Py_ssize_t N = shape[1]
+    cdef Py_ssize_t m, n
+
+    cdef cnp.ndarray[dtype=cnp.uint8_t, ndim=2, mode="c"] out = \
+         np.zeros((M, N), dtype=np.uint8)
+
+    with nogil:
+        for m in range(M):
+            for n in range(N):
+                out[m, n] = point_in_polygon(V, &vx[0], &vy[0], m, n)
+
+    return out.view(bool)
+
+
+def _points_in_poly(points, verts):
+    """Test whether points lie inside a polygon.
+
+    Parameters
+    ----------
+    points : (N, 2) array
+        Input points, ``(x, y)``.
+    verts : (M, 2) array
+        Vertices of the polygon, sorted either clockwise or anti-clockwise.
+        The first point may (but does not need to be) duplicated.
+
+    See Also
+    --------
+    grid_points_in_poly
+
+    Returns
+    -------
+    mask : (N,) array of bool
+        True if corresponding point is inside the polygon.
+
+    """
+    cdef double[:] x, y, vx, vy
+
+    points = np.asarray(points)
+    verts = np.asarray(verts)
+
+    x = points[:, 0].astype(np.double)
+    y = points[:, 1].astype(np.double)
+
+    vx = verts[:, 0].astype(np.double)
+    vy = verts[:, 1].astype(np.double)
+
+    cdef cnp.ndarray[cnp.uint8_t, ndim=1] out = \
+         np.zeros(x.shape[0], dtype=np.uint8)
+
+    points_in_polygon(vx.shape[0], &vx[0], &vy[0],
+                      x.shape[0], &x[0], &y[0],
+                      <unsigned char*>out.data)
+
+    return out.astype(bool)

dclab/external/skimage/_shared/__init__.py

@@ -0,0 +1 @@
+from . import geometry  # noqa: F401

dclab/external/skimage/_shared/geometry.pxd

@@ -0,0 +1,6 @@
+cdef unsigned char point_in_polygon(Py_ssize_t nr_verts, double *xp, double *yp,
+                                    double x, double y) nogil
+
+cdef void points_in_polygon(Py_ssize_t nr_verts, double *xp, double *yp,
+                            Py_ssize_t nr_points, double *x, double *y,
+                            unsigned char *result) nogil

dclab/external/skimage/_shared/geometry.pyx

@@ -0,0 +1,55 @@
+#cython: cdivision=True
+#cython: boundscheck=False
+#cython: nonecheck=False
+#cython: wraparound=False
+
+
+cdef inline unsigned char point_in_polygon(Py_ssize_t nr_verts, double *xp,
+                                           double *yp, double x,
+                                           double y) nogil:
+    """Test whether point lies inside a polygon.
+
+    Parameters
+    ----------
+    nr_verts : int
+        Number of vertices of polygon.
+    xp, yp : double array
+        Coordinates of polygon with length nr_verts.
+    x, y : double
+        Coordinates of point.
+    """
+    cdef Py_ssize_t i
+    cdef unsigned char c = 0
+    cdef Py_ssize_t j = nr_verts - 1
+    for i in range(nr_verts):
+        if (
+            (((yp[i] <= y) and (y < yp[j])) or
+            ((yp[j] <= y) and (y < yp[i])))
+            and (x < (xp[j] - xp[i]) * (y - yp[i]) / (yp[j] - yp[i]) + xp[i])
+        ):
+            c = not c
+        j = i
+    return c
+
+
+cdef void points_in_polygon(Py_ssize_t nr_verts, double *xp, double *yp,
+                            Py_ssize_t nr_points, double *x, double *y,
+                            unsigned char *result) nogil:
+    """Test whether points lie inside a polygon.
+
+    Parameters
+    ----------
+    nr_verts : int
+        Number of vertices of polygon.
+    xp, yp : double array
+        Coordinates of polygon with length nr_verts.
+    nr_points : int
+        Number of points to test.
+    x, y : double array
+        Coordinates of points.
+    result : unsigned char array
+        Test results for each point.
+    """
+    cdef Py_ssize_t n
+    for n in range(nr_points):
+        result[n] = point_in_polygon(nr_verts, xp, yp, x[n], y[n])

dclab/external/skimage/measure.py

@@ -0,0 +1,7 @@
+"""skimage.measure.find_contours
+
+This submodule is copied from skimage.measure to avoid the additional
+dependency scikit-image in dclab.
+"""
+from ._find_contours import find_contours  # noqa: F401
+from .pnpoly import points_in_poly  # noqa: F401

dclab/external/skimage/pnpoly.py

@@ -0,0 +1,53 @@
+from ._pnpoly import _grid_points_in_poly, _points_in_poly
+
+
+def grid_points_in_poly(shape, verts):
+    """Test whether points on a specified grid are inside a polygon.
+
+    For each ``(r, c)`` coordinate on a grid, i.e. ``(0, 0)``, ``(0, 1)`` etc.,
+    test whether that point lies inside a polygon.
+
+    Parameters
+    ----------
+    shape : tuple (M, N)
+        Shape of the grid.
+    verts : (V, 2) array
+        Specify the V vertices of the polygon, sorted either clockwise
+        or anti-clockwise. The first point may (but does not need to be)
+        duplicated.
+
+    See Also
+    --------
+    points_in_poly
+
+    Returns
+    -------
+    mask : (M, N) ndarray of bool
+        True where the grid falls inside the polygon.
+
+    """
+    return _grid_points_in_poly(shape, verts)
+
+
+def points_in_poly(points, verts):
+    """Test whether points lie inside a polygon.
+
+    Parameters
+    ----------
+    points : (N, 2) array
+        Input points, ``(x, y)``.
+    verts : (M, 2) array
+        Vertices of the polygon, sorted either clockwise or anti-clockwise.
+        The first point may (but does not need to be) duplicated.
+
+    See Also
+    --------
+    grid_points_in_poly
+
+    Returns
+    -------
+    mask : (N,) array of bool
+        True if corresponding point is inside the polygon.
+
+    """
+    return _points_in_poly(points, verts)

dclab/external/statsmodels/LICENSE

@@ -0,0 +1,35 @@
+Copyright (C) 2006, Jonathan E. Taylor
+All rights reserved.
+
+Copyright (c) 2006-2008 Scipy Developers.
+All rights reserved.
+
+Copyright (c) 2009-2018 Statsmodels Developers.
+All rights reserved.
+
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  a. Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+  b. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+  c. Neither the name of Statsmodels nor the names of its contributors
+     may be used to endorse or promote products derived from this software
+     without specific prior written permission.
+
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL STATSMODELS OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGE.
+

dclab/external/statsmodels/__init__.py

@@ -0,0 +1,6 @@
+"""statsmodels.nonparametric.kernel_density.KDEMultivariate
+
+This submodule is copied from statsmodels to avoid the additional
+dependency in dclab.
+"""
+from . import nonparametric  # noqa: F401

dclab/external/statsmodels/nonparametric/__init__.py

@@ -0,0 +1 @@
+from . import kernel_density  # noqa: F401