bluemesh2d 0.1.1.dev0__py3-none-any.whl

bluemesh2d/poly_test/inpoly.py

@@ -0,0 +1,105 @@
+import numpy as np
+
+from .inpoly_mat import inpoly_mat
+
+
+def inpoly(vert, node, edge=None, ftol=None):
+    """Test whether points lie inside a 2D polygon.
+
+    Parameters
+    ----------
+    vert : ndarray of shape (N, 2)
+        Query point coordinates.
+    node : ndarray of shape (M, 2)
+        Polygon vertex coordinates.
+    edge : ndarray of shape (P, 2), optional
+        Edge connectivity as vertex-index pairs. When omitted, vertices in
+        ``node`` are connected in order.
+    ftol : float, optional
+        Floating-point tolerance for boundary tests; default is
+        ``eps**0.85``.
+
+    Returns
+    -------
+    stat : ndarray of bool, shape (N,)
+        ``True`` for points classified as inside the polygon.
+    bnds : ndarray of bool, shape (N,)
+        ``True`` for points lying on a polygon edge.
+
+    Notes
+    -----
+    Uses a crossing-number algorithm with sorted query points and binary
+    search over edge y-ranges.
+
+    References
+    ----------
+    Translation of the MESH2D function ``INPOLY2``.
+    Original MATLAB source: https://github.com/dengwirda/mesh2d
+    """
+
+    node = np.asarray(node, dtype=float)
+    vert = np.asarray(vert, dtype=float)
+    if edge is None:
+        nnod = node.shape[0]
+        edge = np.vstack(
+            [np.column_stack([np.arange(nnod - 1), np.arange(1, nnod)]), [nnod - 1, 0]]
+        )
+    else:
+        edge = np.asarray(edge, dtype=int)
+
+    if ftol is None:
+        ftol = np.finfo(float).eps ** 0.85
+
+    nnod = node.shape[0]
+    nvrt = vert.shape[0]
+
+    if edge.min() < 0 or edge.max() > nnod:
+        raise ValueError("inpoly: invalid EDGE input array.")
+
+    STAT = np.zeros(nvrt, dtype=bool)
+    BNDS = np.zeros(nvrt, dtype=bool)
+
+    nmin = node.min(axis=0)
+    nmax = node.max(axis=0)
+    ddxy = nmax - nmin
+    lbar = ddxy.sum() / 2.0
+    veps = ftol * lbar
+
+    mask = (
+        (vert[:, 0] >= nmin[0] - veps)
+        & (vert[:, 0] <= nmax[0] + veps)
+        & (vert[:, 1] >= nmin[1] - veps)
+        & (vert[:, 1] <= nmax[1] + veps)
+    )
+
+    if not np.any(mask):
+        return STAT, BNDS
+
+    vmask = np.where(mask)[0]
+    vsub = vert[mask, :].copy()
+    nsub = node.copy()
+
+    # Flip to ensure the y-axis is the "long" axis
+    vmin = vsub.min(axis=0)
+    vmax = vsub.max(axis=0)
+    ddxy = vmax - vmin
+    if ddxy[0] > ddxy[1]:
+        vsub = vsub[:, [1, 0]]
+        nsub = nsub[:, [1, 0]]
+
+    swap = nsub[edge[:, 1], 1] < nsub[edge[:, 0], 1]
+    edge[swap] = edge[swap][:, [1, 0]]
+
+    ivec = np.lexsort((vsub[:, 0], vsub[:, 1]))
+    vsub = vsub[ivec, :]
+
+    stat, bnds = inpoly_mat(vsub, nsub, edge, ftol, lbar)
+
+    inv = np.argsort(ivec)
+    stat = stat[inv]
+    bnds = bnds[inv]
+
+    STAT[vmask] = stat
+    BNDS[vmask] = bnds
+
+    return STAT, BNDS

bluemesh2d/poly_test/inpoly_mat.py

@@ -0,0 +1,104 @@
+import numpy as np
+
+
+def inpoly_mat(vert, node, edge, fTOL, lbar):
+    """Run the crossing-number point-in-polygon test on sorted points.
+
+    Parameters
+    ----------
+    vert : ndarray of shape (N, 2)
+        Query points, sorted by y-coordinate.
+    node : ndarray of shape (M, 2)
+        Polygon vertex coordinates.
+    edge : ndarray of shape (P, 2)
+        Edge connectivity as vertex-index pairs.
+    fTOL : float
+        Relative floating-point tolerance scale.
+    lbar : float
+        Characteristic polygon length scale.
+
+    Returns
+    -------
+    stat : ndarray of bool, shape (N,)
+        ``True`` for points classified as inside the polygon.
+    bnds : ndarray of bool, shape (N,)
+        ``True`` for points lying on a polygon edge.
+
+    References
+    ----------
+    Translation of the MESH2D function ``INPOLY2_MAT``.
+    Original MATLAB source: https://github.com/dengwirda/mesh2d
+    """
+
+    feps = fTOL * lbar**1
+    veps = fTOL * lbar**1
+
+    nvrt = vert.shape[0]
+    _nnod = node.shape[0]
+    nedg = edge.shape[0]
+
+    stat = np.zeros(nvrt, dtype=bool)
+    bnds = np.zeros(nvrt, dtype=bool)
+    for epos in range(nedg):
+        inod = edge[epos, 0]
+        jnod = edge[epos, 1]
+        yone = node[inod, 1]
+        ytwo = node[jnod, 1]
+        xone = node[inod, 0]
+        xtwo = node[jnod, 0]
+
+        xmin = min(xone, xtwo) - veps
+        xmax = max(xone, xtwo) + veps
+
+        ymin = yone - veps
+        ymax = ytwo + veps
+
+        ydel = ytwo - yone
+        xdel = xtwo - xone
+
+        edel = abs(xdel) + ydel
+        ilow = 0
+        iupp = nvrt - 1
+
+        while ilow < iupp - 1:  # binary search
+            imid = ilow + (iupp - ilow) // 2
+            if vert[imid, 1] < ymin:
+                ilow = imid
+            else:
+                iupp = imid
+
+        if vert[ilow, 1] >= ymin:
+            ilow -= 1
+        for jpos in range(ilow + 1, nvrt):
+            if bnds[jpos]:
+                continue
+
+            xpos = vert[jpos, 0]
+            ypos = vert[jpos, 1]
+
+            if ypos <= ymax:
+                if xpos >= xmin:
+                    if xpos <= xmax:
+                        mul1 = ydel * (xpos - xone)
+                        mul2 = xdel * (ypos - yone)
+
+                        if (feps * edel) >= abs(mul2 - mul1):
+                            bnds[jpos] = True
+                            stat[jpos] = True
+                        elif ypos == yone and xpos == xone:
+                            bnds[jpos] = True
+                            stat[jpos] = True
+                        elif ypos == ytwo and xpos == xtwo:
+                            bnds[jpos] = True
+                            stat[jpos] = True
+                        elif mul1 < mul2:
+                            if ypos >= yone and ypos < ytwo:
+                                stat[jpos] = ~stat[jpos]
+
+                else:
+                    if ypos >= yone and ypos < ytwo:
+                        stat[jpos] = ~stat[jpos]
+            else:
+                break  # -- done -- due to the sort
+
+    return stat, bnds