bluemesh2d 0.1.1.dev0__py3-none-any.whl

bluemesh2d/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.1.1.dev0'
+__version_tuple__ = version_tuple = (0, 1, 1, 'dev0')
+
+__commit_id__ = commit_id = 'gaa72c9ba7'

bluemesh2d/aabb_tree/findball.py

@@ -0,0 +1,121 @@
+import numpy as np
+
+from .maketree import maketree
+from .mapvert import mapvert
+from .queryset import queryset
+
+
+def findball(bb, pp, tr=None, op=None):
+    """Find d-dimensional balls intersecting query points.
+
+    Parameters
+    ----------
+    bb : ndarray of shape (M, ND + 1)
+        Ball definitions: center coordinates in the first ``ND`` columns and
+        squared radius in the last column.
+    pp : ndarray of shape (P, ND)
+        Query points.
+    tr : dict, optional
+        Precomputed AABB tree from a prior call; reuse only if ``bb`` is
+        unchanged.
+    op : dict, optional
+        Options passed to :func:`maketree` when building the tree.
+
+    Returns
+    -------
+    bp : ndarray of shape (P, 2)
+        Pointer ranges into ``bj`` for each query point; ``bp[i, 0] == 0``
+        when point ``i`` lies outside all balls.
+    bj : ndarray
+        Flattened list of intersecting ball indices.
+    tr : dict
+        AABB tree used for the query; may be reused on later calls.
+
+    References
+    ----------
+    Translation of the MESH2D function ``FINDBALL``.
+    Original MATLAB source: https://github.com/dengwirda/mesh2d
+    """
+
+    bp, bj = np.array([]), np.array([])
+
+    if bb is None or pp is None:
+        raise ValueError("findball:incorrectNumInputs (need at least bb, pp)")
+
+    bb = np.asarray(bb, dtype=float)
+    pp = np.asarray(pp, dtype=float)
+
+    if bb.ndim != 2 or bb.shape[1] < 3:
+        raise ValueError("findball:incorrectDimensions (bb must be (B,ND+1))")
+    if pp.ndim != 2 or bb.shape[1] != pp.shape[1] + 1:
+        raise ValueError("findball:incorrectDimensions (pp must be (P,ND))")
+
+    if tr is not None and not isinstance(tr, dict):
+        raise TypeError("findball:incorrectInputClass (tr must be struct/dict)")
+    if op is not None and not isinstance(op, dict):
+        raise TypeError("findball:incorrectInputClass (op must be struct/dict)")
+
+    if bb.size == 0:
+        return bp, bj, tr
+
+    if tr is None:
+        nd = pp.shape[1]
+        rs = np.sqrt(bb[:, nd])[:, None]  # radii
+        rs = np.tile(rs, (1, nd))
+        ab = np.hstack([bb[:, :nd] - rs, bb[:, :nd] + rs])  # aabb
+        tr = maketree(ab, op)
+
+    tm, _ = mapvert(tr, pp)
+
+    bi, ip, bj = queryset(tr, tm, ballkern, pp, bb)
+
+    bp = np.zeros((pp.shape[0], 2), dtype=int)
+    bp[:, 1] = -1
+    if bi.size > 0:
+        bp[bi, :] = ip
+
+    return bp, bj, tr
+
+
+def ballkern(pk, bk, pp, bb):
+    """Test ball-point intersections within an AABB tree tile.
+
+    Parameters
+    ----------
+    pk : ndarray
+        Indices of query points in the tile.
+    bk : ndarray
+        Indices of candidate balls in the tile.
+    pp : ndarray of shape (P, ND)
+        Query point coordinates.
+    bb : ndarray of shape (B, ND + 1)
+        Ball centers and squared radii.
+
+    Returns
+    -------
+    ip : ndarray
+        Query point indices with an intersection.
+    ib : ndarray
+        Matching ball indices.
+
+    References
+    ----------
+    Translation of the MESH2D function ``BALLKERN``.
+    Original MATLAB source: https://github.com/dengwirda/mesh2d
+    """
+    mp = len(pk)
+    mb = len(bk)
+    nd = pp.shape[1]
+
+    bk_tiled = np.tile(bk, mp)
+    pk_tiled = np.repeat(pk, mb)
+
+    diff = pp[pk_tiled, :] - bb[bk_tiled, :nd]
+    dd = np.sum(diff**2, axis=1)
+
+    inside = dd <= bb[bk_tiled, nd]
+
+    ip = pk_tiled[inside]
+    ib = bk_tiled[inside]
+
+    return ip, ib

bluemesh2d/aabb_tree/findtria.py

@@ -0,0 +1,299 @@
+import numpy as np
+
+from .maketree import maketree
+from .mapvert import mapvert
+from .queryset import queryset
+
+
+def findtria(pp, tt, pj, tree=None, options=None):
+    """Find d-dimensional simplexes intersecting query points.
+
+    Parameters
+    ----------
+    pp : ndarray of shape (N, ND)
+        Vertex coordinates.
+    tt : ndarray of shape (NS, M)
+        Simplex connectivity; ``M=3`` for triangles, ``M=4`` for tetrahedra.
+    pj : ndarray of shape (NP, ND)
+        Query points.
+    tree : dict, optional
+        Precomputed AABB tree from a prior call; reuse only if ``pp`` and
+        ``tt`` are unchanged.
+    options : dict, optional
+        Options passed to :func:`maketree` when building the tree.
+
+    Returns
+    -------
+    tp : ndarray of shape (NP, 2)
+        Pointer ranges into ``tj`` for each query point; ``tp[i, 0] == 0``
+        when point ``i`` has no match.
+    tj : ndarray
+        Flattened list of intersecting simplex indices.
+    tree : dict
+        AABB tree used for the query; may be reused on later calls.
+
+    Notes
+    -----
+    The simplex collection need not form a conforming triangulation. To pick
+    one simplex per query point, take ``tj[tp[mask, 0]]`` where
+    ``mask = tp[:, 0] > 0``.
+
+    References
+    ----------
+    Translation of the MESH2D function ``FINDTRIA``.
+    Original MATLAB source: https://github.com/dengwirda/mesh2d
+    """
+
+    if not (
+        isinstance(pp, np.ndarray)
+        and isinstance(tt, np.ndarray)
+        and isinstance(pj, np.ndarray)
+    ):
+        raise TypeError("pp, tt, and pj must be numpy arrays.")
+
+    if pj.size == 0:
+        return np.zeros((0, 2), dtype=int), np.array([], dtype=int), tree
+
+    if pp.ndim != 2 or tt.ndim != 2 or pj.ndim != 2:
+        raise ValueError("Inputs must be 2D arrays.")
+
+    if pp.shape[1] < 2 or pp.shape[1] > tt.shape[1]:
+        raise ValueError("Incorrect input dimensions.")
+
+    if tt.shape[1] < 3:
+        raise ValueError("Triangles must have at least 3 vertices.")
+
+    if pj.shape[1] != pp.shape[1]:
+        raise ValueError("pj and pp must have the same dimensionality.")
+
+    if tree is None:
+        bi = pp[tt[:, 0], :].copy()
+        bj = pp[tt[:, 0], :].copy()
+        for ii in range(1, tt.shape[1]):
+            bi = np.minimum(bi, pp[tt[:, ii], :])
+            bj = np.maximum(bj, pp[tt[:, ii], :])
+        bb = np.hstack([bi, bj])
+        tree = maketree(bb, options)  # compute aabb-tree
+
+    tm, _ = mapvert(tree, pj)
+
+    x0 = np.min(pp, axis=0)
+    x1 = np.max(pp, axis=0)
+    rt = np.prod(x1 - x0) * np.finfo(float).eps ** 0.8
+
+    ti, ip, tj = queryset(tree, tm, triakern, pj, pp, tt, rt)
+
+    tp = np.zeros((pj.shape[0], 2), dtype=int)
+    tp[:, 1] = -1
+    if ti.size == 0:
+        return tp, tj, tree
+    tp[ti, :] = ip
+
+    return tp, tj, tree
+
+
+def triakern(pk, tk, pi, pp, tt, rt):
+    """Test point/simplex intersections within an AABB tree tile.
+
+    Parameters
+    ----------
+    pk : ndarray
+        Indices of query points in the tile.
+    tk : ndarray
+        Indices of candidate simplexes in the tile.
+    pi : ndarray of shape (P, ND)
+        Query point coordinates.
+    pp : ndarray of shape (V, ND)
+        Vertex coordinates.
+    tt : ndarray of shape (T, nv)
+        Simplex connectivity (0-based vertex indices).
+    rt : float
+        Relative tolerance for point-in-simplex tests.
+
+    Returns
+    -------
+    ip : ndarray
+        Query point indices with an intersection.
+    it : ndarray
+        Matching simplex indices.
+
+    References
+    ----------
+    Translation of the MESH2D function ``TRIAKERN``.
+    Original MATLAB source: https://github.com/dengwirda/mesh2d
+    """
+    mp = len(pk)
+    mt = len(tk)
+
+    pk = np.repeat(pk, mt)
+    tk = np.tile(tk, mp)
+
+    n_vertices = tt.shape[1]
+
+    if n_vertices == 3:
+        inside = intria2(pp, tt[tk, :], pi[pk, :], rt)
+    elif n_vertices == 4:
+        inside = intria3(pp, tt[tk, :], pi[pk, :], rt)
+    else:
+        ii, jj = intrian(pp, tt[tk, :], pi[pk, :])
+        ip = pk[ii]
+        it = tk[jj]
+        return ip, it
+
+    ip = pk[inside]
+    it = tk[inside]
+    return ip, it
+
+
+def intria2(pp, tt, pi, rt):
+    """Test whether query points lie inside 2-simplexes (triangles).
+
+    Parameters
+    ----------
+    pp : ndarray of shape (V, 2)
+        Vertex coordinates.
+    tt : ndarray of shape (T, 3)
+        Triangle connectivity (0-based vertex indices).
+    pi : ndarray of shape (P, 2)
+        Query points (one per triangle row in ``tt``).
+    rt : float
+        Relative tolerance for point-in-triangle tests.
+
+    Returns
+    -------
+    inside : ndarray of bool, shape (T,)
+        ``True`` where the corresponding query point lies inside the triangle.
+
+    References
+    ----------
+    Translation of the MESH2D function ``INTRIA2``.
+    Original MATLAB source: https://github.com/dengwirda/mesh2d
+    """
+    t1, t2, t3 = tt[:, 0], tt[:, 1], tt[:, 2]
+    vi = pp[t1, :] - pi
+    vj = pp[t2, :] - pi
+    vk = pp[t3, :] - pi
+    aa = np.zeros((tt.shape[0], 3))
+    aa[:, 0] = vi[:, 0] * vj[:, 1] - vj[:, 0] * vi[:, 1]
+    aa[:, 1] = vj[:, 0] * vk[:, 1] - vk[:, 0] * vj[:, 1]
+    aa[:, 2] = vk[:, 0] * vi[:, 1] - vi[:, 0] * vk[:, 1]
+    rt2 = rt**2
+    inside = (
+        (aa[:, 0] * aa[:, 1] >= -rt2)
+        & (aa[:, 1] * aa[:, 2] >= -rt2)
+        & (aa[:, 2] * aa[:, 0] >= -rt2)
+    )
+
+    return inside
+
+
+def intria3(pp, tt, pi, rt):
+    """Test whether query points lie inside 3-simplexes (tetrahedra).
+
+    Parameters
+    ----------
+    pp : ndarray of shape (V, 3)
+        Vertex coordinates.
+    tt : ndarray of shape (T, 4)
+        Tetrahedron connectivity (0-based vertex indices).
+    pi : ndarray of shape (P, 3)
+        Query points (one per tetrahedron row in ``tt``).
+    rt : float
+        Relative tolerance for point-in-tetrahedron tests.
+
+    Returns
+    -------
+    inside : ndarray of bool, shape (T,)
+        ``True`` where the corresponding query point lies inside the tetrahedron.
+
+    References
+    ----------
+    Translation of the MESH2D function ``INTRIA3``.
+    Original MATLAB source: https://github.com/dengwirda/mesh2d
+    """
+    t1, t2, t3, t4 = tt[:, 0], tt[:, 1], tt[:, 2], tt[:, 3]
+    v1 = pi - pp[t1, :]
+    v2 = pi - pp[t2, :]
+    v3 = pi - pp[t3, :]
+    v4 = pi - pp[t4, :]
+    aa = np.zeros((tt.shape[0], 4))
+    aa[:, 0] = (
+        v1[:, 0] * (v2[:, 1] * v3[:, 2] - v2[:, 2] * v3[:, 1])
+        - v1[:, 1] * (v2[:, 0] * v3[:, 2] - v2[:, 2] * v3[:, 0])
+        + v1[:, 2] * (v2[:, 0] * v3[:, 1] - v2[:, 1] * v3[:, 0])
+    )
+    aa[:, 1] = (
+        v1[:, 0] * (v4[:, 1] * v2[:, 2] - v4[:, 2] * v2[:, 1])
+        - v1[:, 1] * (v4[:, 0] * v2[:, 2] - v4[:, 2] * v2[:, 0])
+        + v1[:, 2] * (v4[:, 0] * v2[:, 1] - v4[:, 1] * v2[:, 0])
+    )
+    aa[:, 2] = (
+        v2[:, 0] * (v4[:, 1] * v3[:, 2] - v4[:, 2] * v3[:, 1])
+        - v2[:, 1] * (v4[:, 0] * v3[:, 2] - v4[:, 2] * v3[:, 0])
+        + v2[:, 2] * (v4[:, 0] * v3[:, 1] - v4[:, 1] * v3[:, 0])
+    )
+    aa[:, 3] = (
+        v3[:, 0] * (v4[:, 1] * v1[:, 2] - v4[:, 2] * v1[:, 1])
+        - v3[:, 1] * (v4[:, 0] * v1[:, 2] - v4[:, 2] * v1[:, 0])
+        + v3[:, 2] * (v4[:, 0] * v1[:, 1] - v4[:, 1] * v1[:, 0])
+    )
+    rt2 = rt**2
+    inside = (
+        (aa[:, 0] * aa[:, 1] >= -rt2)
+        & (aa[:, 0] * aa[:, 2] >= -rt2)
+        & (aa[:, 0] * aa[:, 3] >= -rt2)
+        & (aa[:, 1] * aa[:, 2] >= -rt2)
+        & (aa[:, 1] * aa[:, 3] >= -rt2)
+        & (aa[:, 2] * aa[:, 3] >= -rt2)
+    )
+
+    return inside
+
+
+def intrian(pp, tt, pi):
+    """Locate query points in general n-simplexes via barycentric coordinates.
+
+    Parameters
+    ----------
+    pp : ndarray of shape (V, ND)
+        Vertex coordinates.
+    tt : ndarray of shape (T, nv)
+        Simplex connectivity (0-based vertex indices).
+    pi : ndarray of shape (P, ND)
+        Query points.
+
+    Returns
+    -------
+    ii : ndarray
+        Indices of query points inside a simplex.
+    jj : ndarray
+        Indices of simplexes containing those points.
+
+    References
+    ----------
+    Translation of the MESH2D function ``INTRIAN``.
+    Original MATLAB source: https://github.com/dengwirda/mesh2d
+    """
+    np_, pd = pi.shape
+    nt, td = tt.shape
+    # Coefficient matrices for barycentric coord.
+    mm = np.zeros((pd, pd, nt))
+    for id_ in range(pd):
+        for jd in range(pd):
+            mm[id_, jd, :] = pp[tt[:, jd], id_] - pp[tt[:, td - 1], id_]
+    # Solve linear systems for barycentric coord.
+    xx = np.zeros((pd, np_, nt))
+    vp = np.zeros((pd, np_))
+
+    for ti in range(nt):
+        for id_ in range(pd):
+            vp[id_, :] = pi[:, id_] - pp[tt[ti, td - 1], id_]
+        # Solve linear systems (LU equivalent)
+        xx[:, :, ti] = np.linalg.solve(mm[:, :, ti], vp)
+    # PI is internal if coord. have same sign
+    in_mask = np.all(xx >= -(np.finfo(float).eps ** 0.8), axis=0) & (
+        np.sum(xx, axis=0) <= 1.0 + np.finfo(float).eps ** 0.8
+    )
+    # Find lists of matching points/simplexes
+    ii, jj = np.where(in_mask.T)
+    return ii, jj

bluemesh2d/aabb_tree/maketree.py

@@ -0,0 +1,147 @@
+import numpy as np
+
+
+def maketree(rp, op=None):
+    """Assemble an AABB search tree for a collection of (hyper-)rectangles.
+
+    Parameters
+    ----------
+    rp : ndarray of shape (NR, 2*NDIM)
+        Rectangles defined as ``[pmin, pmax]``.
+    op : dict, optional
+        Options: ``"nobj"`` (max rectangles per node, default 32),
+        ``"long"`` (relative length tolerance, default 0.75), and ``"vtol"``
+        (volume tolerance, default 0.55).
+
+    Returns
+    -------
+    tr : dict
+        Tree with keys ``"xx"`` (node bounding boxes), ``"ii"`` (parent/child
+        indexing), and ``"ll"`` (rectangle indices per node).
+
+    References
+    ----------
+    Translation of the MESH2D function ``MAKETREE``.
+    Original MATLAB source: https://github.com/dengwirda/mesh2d
+    """
+
+    tr = {"xx": [], "ii": [], "ll": []}
+
+    if rp is None or len(rp) == 0:
+        return tr
+
+    if not isinstance(rp, np.ndarray):
+        raise TypeError("maketree: incorrect input class")
+
+    if rp.ndim != 2 or rp.shape[1] % 2 != 0:
+        raise ValueError("maketree: incorrect input dimensions")
+
+    NOBJ = 32
+    if op is None:
+        op = {"nobj": NOBJ, "long": 0.75, "vtol": 0.55}
+    else:
+        op.setdefault("nobj", NOBJ)
+        op.setdefault("long", 0.75)
+        op.setdefault("vtol", 0.55)
+    nd = rp.shape[1] // 2
+    ni = rp.shape[0]
+    xl = np.zeros((ni, nd))
+    xr = np.zeros((ni, nd))
+    ii = np.zeros((ni, 2), dtype=int)
+    ll = [None] * ni
+    ss = np.zeros(ni, dtype=int)
+    lv = np.zeros(rp.shape[1], dtype=bool)
+    rv = np.zeros(rp.shape[1], dtype=bool)
+    lv[:nd] = True
+    rv[nd:] = True
+    r0 = np.min(rp[:, lv], axis=0)
+    r1 = np.max(rp[:, rv], axis=0)
+    rd = np.tile(r1 - r0, (ni, 1))
+    rp[:, lv] -= rd * np.power(np.finfo(float).eps, 0.8)
+    rp[:, rv] += rd * np.power(np.finfo(float).eps, 0.8)
+    rc = 0.5 * (rp[:, lv] + rp[:, rv])
+    rd = rp[:, rv] - rp[:, lv]
+    ll[0] = np.arange(ni)
+    ii[0, :] = 0
+    xl[0, :] = np.min(rp[:, lv], axis=0)
+    xr[0, :] = np.max(rp[:, rv], axis=0)
+    # -- main loop : divide nodes until all constraints satisfied
+    ss[0] = 0
+    ns = 1
+    nn = 1
+
+    while ns != 0:
+        ni_node = ss[ns - 1]
+        ns -= 1
+        n1 = nn
+        n2 = nn + 1
+        li = ll[ni_node]
+        dd = xr[ni_node, :] - xl[ni_node, :]
+        ia = np.argsort(dd)
+
+        for id in range(nd - 1, -1, -1):
+            ax = ia[id]
+            mx = dd[ax]
+
+            il = rd[li, ax] > op["long"] * mx
+            lp = li[il]  #  "long" rectangles
+            ls = li[~il]  #  "short" rectangles
+
+            if len(lp) < 0.5 * len(ls) and len(lp) < 0.5 * op["nobj"]:
+                break
+
+        # select the split position: take the mean of the set of
+        # (non-"long") rectangle centres along axis AX
+        if len(ls) == 0:
+            continue
+
+        sp = np.mean(rc[ls, ax])
+        i2 = rc[ls, ax] > sp
+        l1 = ls[~i2]  #  "left" rectangles
+        l2 = ls[i2]  #  "right" rectangles
+
+        if len(l1) <= 1 or len(l2) <= 1:
+            continue
+
+        xl[n1, :] = np.min(rp[l1[:, None], lv], axis=0)
+        xr[n1, :] = np.max(rp[l1[:, None], rv], axis=0)
+        xl[n2, :] = np.min(rp[l2[:, None], lv], axis=0)
+        xr[n2, :] = np.max(rp[l2[:, None], rv], axis=0)
+        if len(li) <= op["nobj"]:
+            vi = np.prod(xr[ni_node, :] - xl[ni_node, :])  #  upper d-dim "vol."
+            v1 = np.prod(xr[n1, :] - xl[n1, :])  # lower d-dim "vol."
+            v2 = np.prod(xr[n2, :] - xl[n2, :])
+
+            if v1 + v2 < op["vtol"] * vi:
+                ii[n1, 0] = ni_node
+                ii[n2, 0] = ni_node
+                ii[ni_node, 1] = n1
+                ll[ni_node] = lp
+                ll[n1] = l1
+                ll[n2] = l2
+
+                ss[ns] = n1
+                ss[ns + 1] = n2
+                ns += 2
+                nn += 2
+        else:
+            ii[n1, 0] = ni_node
+            ii[n2, 0] = ni_node
+            ii[ni_node, 1] = n1
+            ll[ni_node] = lp
+            ll[n1] = l1
+            ll[n2] = l2
+
+            ss[ns] = n1
+            ss[ns + 1] = n2
+            ns += 2
+            nn += 2
+    xl = xl[:nn, :]
+    xr = xr[:nn, :]
+    ii = ii[:nn, :]
+    ll = ll[:nn]
+    tr["xx"] = np.hstack((xl, xr))
+    tr["ii"] = ii
+    tr["ll"] = ll
+
+    return tr

bluemesh2d/aabb_tree/mapvert.py

@@ -0,0 +1,72 @@
+import numpy as np
+
+from .scantree import scantree
+
+
+def mapvert(tr, pi):
+    """Compute tree-to-vertex and vertex-to-tree mappings for an AABB tree.
+
+    Parameters
+    ----------
+    tr : dict
+        AABB tree from :func:`maketree`, with keys ``"xx"``, ``"ii"``, and
+        ``"ll"``.
+    pi : ndarray of shape (NP, NDIM)
+        Vertex coordinates.
+
+    Returns
+    -------
+    tm : dict
+        Tree-to-vertex mapping with keys ``"ii"`` (node indices) and ``"ll"``
+        (vertex indices per node).
+    im : dict
+        Vertex-to-tree mapping with keys ``"ii"`` (vertex indices) and ``"ll"``
+        (tree node indices per vertex).
+
+    References
+    ----------
+    Translation of the MESH2D function ``MAPVERT``.
+    Original MATLAB source: https://github.com/dengwirda/mesh2d
+    """
+
+
+    # Call SCANTREE to do the actual work
+    results = scantree(tr, pi, partvert)
+    if len(results) == 1:
+        return results[0], None
+    else:
+        return results
+
+
+def partvert(pi, b1, b2):
+    """Partition points between two bounding boxes for :func:`scantree`.
+
+    Parameters
+    ----------
+    pi : ndarray of shape (N, ND)
+        Query points.
+    b1, b2 : ndarray of shape (2*ND,)
+        Bounding boxes as ``[pmin, pmax]``.
+
+    Returns
+    -------
+    j1, j2 : ndarray of bool, shape (N,)
+        Masks of points inside ``b1`` and ``b2``, respectively.
+
+    References
+    ----------
+    Translation of the MESH2D function ``PARTVERT``.
+    Original MATLAB source: https://github.com/dengwirda/mesh2d
+    """
+    nd = b1.shape[0] // 2
+
+    j1 = np.ones(pi.shape[0], dtype=bool)
+    j2 = np.ones(pi.shape[0], dtype=bool)
+
+    for ax in range(nd):
+        # Remains TRUE if inside bounds along axis AX
+        j1 &= (pi[:, ax] >= b1[ax]) & (pi[:, ax] <= b1[ax + nd])
+        # Remains TRUE if inside bounds along axis AX
+        j2 &= (pi[:, ax] >= b2[ax]) & (pi[:, ax] <= b2[ax + nd])
+
+    return j1, j2