bluemesh2d 0.1.1.dev0__py3-none-any.whl

bluemesh2d/mesh_ball/cdtbal2.py

@@ -0,0 +1,104 @@
+import numpy as np
+
+from .tribal2 import tribal2
+
+
+def cdtbal2(pp, ee, tt):
+    """Compute clipped circumballs for a constrained Delaunay triangulation.
+
+    Start from triangle circumballs and replace any ball that extends outside
+    the domain with a smaller edge-centered diametric ball on a constrained
+    face.
+
+    Parameters
+    ----------
+    pp : ndarray of shape (N, 2)
+        Vertex coordinates.
+    ee : ndarray of shape (E, 5)
+        Edge connectivity from :func:`tricon`.
+    tt : ndarray of shape (T, 6)
+        Triangle connectivity from :func:`tricon`.
+
+    Returns
+    -------
+    cc : ndarray of shape (T, 3)
+        Clipped circumball parameters ``[xc, yc, r²]`` for each triangle.
+
+    References
+    ----------
+    Translation of the MESH2D function ``CDTBAL2``.
+    Original MATLAB source: https://github.com/dengwirda/mesh2d
+    """
+
+    if not (
+        isinstance(pp, np.ndarray)
+        and isinstance(ee, np.ndarray)
+        and isinstance(tt, np.ndarray)
+    ):
+        raise TypeError("cdtbal2:incorrectInputClass")
+
+    if pp.ndim != 2 or ee.ndim != 2 or tt.ndim != 2:
+        raise ValueError("cdtbal2:incorrectDimensions")
+
+    if pp.shape[1] != 2 or ee.shape[1] < 5 or tt.shape[1] < 6:
+        raise ValueError("cdtbal2:incorrectDimensions")
+
+    cc = tribal2(pp, tt)
+
+    # Replace with face-balls if smaller
+    cc = minfac2(cc, pp, ee, tt, 0, 1, 2)
+    cc = minfac2(cc, pp, ee, tt, 1, 2, 0)
+    cc = minfac2(cc, pp, ee, tt, 2, 0, 1)
+
+    return cc
+
+
+def minfac2(cc, pp, ee, tt, ni, nj, nk):
+    """Clip circumballs to constrained faces of a CDT.
+
+    Replace circumballs that extend beyond a constrained edge with the
+    diametric ball centered on that edge.
+
+    Parameters
+    ----------
+    cc : ndarray of shape (T, 3)
+        Circumball parameters ``[xc, yc, r²]``.
+    pp : ndarray of shape (N, 2)
+        Vertex coordinates.
+    ee : ndarray of shape (E, 5)
+        Edge connectivity from :func:`tricon`.
+    tt : ndarray of shape (T, 6)
+        Triangle connectivity from :func:`tricon`.
+    ni, nj, nk : int
+        Local vertex indices (0, 1, or 2) defining the edge ``[ni, nj]`` and
+        opposite vertex ``nk`` for the current face pass.
+
+    Returns
+    -------
+    cc : ndarray of shape (T, 3)
+        Updated circumball parameters.
+
+    References
+    ----------
+    Translation of the MESH2D function ``MINFAC2``.
+    Original MATLAB source: https://github.com/dengwirda/mesh2d
+    """
+
+    EF = ee[tt[:, ni + 3], 4] > 0
+
+    bc = 0.5 * (pp[tt[EF, ni], :] + pp[tt[EF, nj], :])
+
+    br = np.sum((bc - pp[tt[EF, ni], :]) ** 2, axis=1) + np.sum(
+        (bc - pp[tt[EF, nj], :]) ** 2, axis=1
+    )
+    br = br * 0.5
+
+    ll = np.sum((bc - pp[tt[EF, nk], :]) ** 2, axis=1)
+
+    bi = (br >= ll) & (br <= cc[EF, 2])
+    ei = np.where(EF)[0]
+    ti = ei[bi]
+    cc[ti, 0:2] = bc[bi, :]
+    cc[ti, 2] = br[bi]
+
+    return cc

bluemesh2d/mesh_ball/inv_2x2.py

@@ -0,0 +1,61 @@
+import numpy as np
+
+
+def inv_2x2(AA):
+    """Compute determinant-scaled inverses for a block of 2×2 matrices.
+
+    Returns ``det(A) * inv(A)`` for numerical robustness. Divide by ``DA``
+    when solving linear systems.
+
+    Parameters
+    ----------
+    AA : ndarray of shape (2, 2, N)
+        Stack of ``N`` individual 2×2 matrices.
+
+    Returns
+    -------
+    II : ndarray of shape (2, 2, N)
+        Determinant-scaled inverse of each matrix.
+    DA : ndarray of shape (N,)
+        Determinant of each matrix.
+
+    References
+    ----------
+    Translation of the MESH2D function ``INV_2X2``.
+    Original MATLAB source: https://github.com/dengwirda/mesh2d
+    """
+
+    if not isinstance(AA, np.ndarray):
+        raise TypeError("inv_2x2:incorrectInputClass")
+
+    if AA.ndim > 3:
+        raise ValueError("inv_2x2:incorrectDimensions")
+
+    if AA.shape[0] != 2 or AA.shape[1] != 2:
+        raise ValueError("inv_2x2:incorrectDimensions")
+
+    II = np.zeros_like(AA)
+    DA = det_2x2(AA)
+
+    II[0, 0, :] = AA[1, 1, :]
+    II[1, 1, :] = AA[0, 0, :]
+    II[0, 1, :] = -AA[0, 1, :]
+    II[1, 0, :] = -AA[1, 0, :]
+
+    return II, DA
+
+
+def det_2x2(AA):
+    """Compute determinants for a block of 2×2 matrices.
+
+    Parameters
+    ----------
+    AA : ndarray of shape (2, 2, N)
+        Stack of ``N`` individual 2×2 matrices.
+
+    Returns
+    -------
+    DA : ndarray of shape (N,)
+        Determinant of each matrix.
+    """
+    return AA[0, 0, :] * AA[1, 1, :] - AA[0, 1, :] * AA[1, 0, :]

bluemesh2d/mesh_ball/inv_3x3.py

@@ -0,0 +1,72 @@
+import numpy as np
+
+
+def inv_3x3(AA):
+    """Compute determinant-scaled inverses for a block of 3×3 matrices.
+
+    Returns ``det(A) * inv(A)`` for numerical robustness. Divide by ``DA``
+    when solving linear systems.
+
+    Parameters
+    ----------
+    AA : ndarray of shape (3, 3, N)
+        Stack of ``N`` individual 3×3 matrices.
+
+    Returns
+    -------
+    II : ndarray of shape (3, 3, N)
+        Determinant-scaled inverse of each matrix.
+    DA : ndarray of shape (N,)
+        Determinant of each matrix.
+
+    References
+    ----------
+    Translation of the MESH2D function ``INV_3X3``.
+    Original MATLAB source: https://github.com/dengwirda/mesh2d
+    """
+
+    if not isinstance(AA, np.ndarray):
+        raise TypeError("inv_3x3:incorrectInputClass")
+
+    if AA.ndim > 3:
+        raise ValueError("inv_3x3:incorrectDimensions")
+
+    if AA.shape[0] != 3 or AA.shape[1] != 3:
+        raise ValueError("inv_3x3:incorrectDimensions")
+
+    II = np.zeros_like(AA)
+    DA = det_3x3(AA)
+
+    II[0, 0, :] = AA[2, 2, :] * AA[1, 1, :] - AA[2, 1, :] * AA[1, 2, :]
+    II[0, 1, :] = AA[2, 1, :] * AA[0, 2, :] - AA[2, 2, :] * AA[0, 1, :]
+    II[0, 2, :] = AA[1, 2, :] * AA[0, 1, :] - AA[1, 1, :] * AA[0, 2, :]
+
+    II[1, 0, :] = AA[2, 0, :] * AA[1, 2, :] - AA[2, 2, :] * AA[1, 0, :]
+    II[1, 1, :] = AA[2, 2, :] * AA[0, 0, :] - AA[2, 0, :] * AA[0, 2, :]
+    II[1, 2, :] = AA[1, 0, :] * AA[0, 2, :] - AA[1, 2, :] * AA[0, 0, :]
+
+    II[2, 0, :] = AA[2, 1, :] * AA[1, 0, :] - AA[2, 0, :] * AA[1, 1, :]
+    II[2, 1, :] = AA[2, 0, :] * AA[0, 1, :] - AA[2, 1, :] * AA[0, 0, :]
+    II[2, 2, :] = AA[1, 1, :] * AA[0, 0, :] - AA[1, 0, :] * AA[0, 1, :]
+
+    return II, DA
+
+
+def det_3x3(AA):
+    """Compute determinants for a block of 3×3 matrices.
+
+    Parameters
+    ----------
+    AA : ndarray of shape (3, 3, N)
+        Stack of ``N`` individual 3×3 matrices.
+
+    Returns
+    -------
+    DA : ndarray of shape (N,)
+        Determinant of each matrix.
+    """
+    return (
+        AA[0, 0, :] * (AA[1, 1, :] * AA[2, 2, :] - AA[1, 2, :] * AA[2, 1, :])
+        - AA[0, 1, :] * (AA[1, 0, :] * AA[2, 2, :] - AA[1, 2, :] * AA[2, 0, :])
+        + AA[0, 2, :] * (AA[1, 0, :] * AA[2, 1, :] - AA[1, 1, :] * AA[2, 0, :])
+    )

bluemesh2d/mesh_ball/pwrbal2.py

@@ -0,0 +1,134 @@
+import numpy as np
+
+from .inv_2x2 import inv_2x2
+from .inv_3x3 import inv_3x3
+
+
+def pwrbal2(pp, pw, tt):
+    """Compute power balls (orthoballs) for a weighted triangulation.
+
+    Parameters
+    ----------
+    pp : ndarray of shape (N, 2) or (N, 3)
+        Vertex coordinates.
+    pw : ndarray of shape (N, 1)
+        Vertex weights.
+    tt : ndarray of shape (T, 3)
+        Triangle connectivity.
+
+    Returns
+    -------
+    bb : ndarray of shape (T, 3) or (T, 4)
+        Power-ball parameters ``[xc, yc, r²]`` in 2D or ``[xc, yc, zc, r²]`` in 3D.
+
+    References
+    ----------
+    Translation of the MESH2D function ``PWRBAL2``.
+    Original MATLAB source: https://github.com/dengwirda/mesh2d
+    """
+
+    if not (
+        isinstance(pp, np.ndarray)
+        and isinstance(pw, np.ndarray)
+        and isinstance(tt, np.ndarray)
+    ):
+        raise TypeError("pwrbal2:incorrectInputClass")
+
+    if pp.ndim != 2 or pw.ndim != 2 or tt.ndim != 2:
+        raise ValueError("pwrbal2:incorrectDimensions")
+
+    if pp.shape[0] != pw.shape[0] or tt.shape[1] < 3 or pp.shape[1] < 2:
+        raise ValueError("pwrbal2:incorrectDimensions")
+
+    dim = pp.shape[1]
+
+    if dim == 2:
+        bb = np.zeros((tt.shape[0], 3))
+
+        ab = pp[tt[:, 1], :] - pp[tt[:, 0], :]
+        ac = pp[tt[:, 2], :] - pp[tt[:, 0], :]
+
+        AA = np.zeros((2, 2, tt.shape[0]))
+        AA[0, 0, :] = ab[:, 0] * 2.0
+        AA[0, 1, :] = ab[:, 1] * 2.0
+        AA[1, 0, :] = ac[:, 0] * 2.0
+        AA[1, 1, :] = ac[:, 1] * 2.0
+
+        Rv = np.zeros((2, 1, tt.shape[0]))
+        Rv[0, 0, :] = np.sum(ab * ab, axis=1) - (pw[tt[:, 1], 0] - pw[tt[:, 0], 0])
+        Rv[1, 0, :] = np.sum(ac * ac, axis=1) - (pw[tt[:, 2], 0] - pw[tt[:, 0], 0])
+
+        II, dd = inv_2x2(AA)
+
+        bb[:, 0] = (II[0, 0, :] * Rv[0, 0, :] + II[0, 1, :] * Rv[1, 0, :]) / dd
+        bb[:, 1] = (II[1, 0, :] * Rv[0, 0, :] + II[1, 1, :] * Rv[1, 0, :]) / dd
+
+        bb[:, 0:2] = pp[tt[:, 0], :] + bb[:, 0:2]
+
+        r1 = np.sum((bb[:, 0:2] - pp[tt[:, 0], :]) ** 2, axis=1)
+        r2 = np.sum((bb[:, 0:2] - pp[tt[:, 1], :]) ** 2, axis=1)
+        r3 = np.sum((bb[:, 0:2] - pp[tt[:, 2], :]) ** 2, axis=1)
+
+        r1 -= pw[tt[:, 0], 0]
+        r2 -= pw[tt[:, 1], 0]
+        r3 -= pw[tt[:, 2], 0]
+
+        bb[:, 2] = (r1 + r2 + r3) / 3.0
+
+    elif dim == 3:
+        bb = np.zeros((tt.shape[0], 4))
+
+        ab = pp[tt[:, 1], :] - pp[tt[:, 0], :]
+        ac = pp[tt[:, 2], :] - pp[tt[:, 0], :]
+
+        AA = np.zeros((3, 3, tt.shape[0]))
+        AA[0, 0, :] = ab[:, 0] * 2.0
+        AA[0, 1, :] = ab[:, 1] * 2.0
+        AA[0, 2, :] = ab[:, 2] * 2.0
+        AA[1, 0, :] = ac[:, 0] * 2.0
+        AA[1, 1, :] = ac[:, 1] * 2.0
+        AA[1, 2, :] = ac[:, 2] * 2.0
+
+        nv = np.cross(ab, ac)
+        AA[2, 0, :] = nv[:, 0]
+        AA[2, 1, :] = nv[:, 1]
+        AA[2, 2, :] = nv[:, 2]
+
+        Rv = np.zeros((3, 1, tt.shape[0]))
+        Rv[0, 0, :] = np.sum(ab * ab, axis=1) - (pw[tt[:, 1], 0] - pw[tt[:, 0], 0])
+        Rv[1, 0, :] = np.sum(ac * ac, axis=1) - (pw[tt[:, 2], 0] - pw[tt[:, 0], 0])
+
+        II, dd = inv_3x3(AA)
+
+        bb[:, 0] = (
+            II[0, 0, :] * Rv[0, 0, :]
+            + II[0, 1, :] * Rv[1, 0, :]
+            + II[0, 2, :] * Rv[2, 0, :]
+        ) / dd
+        bb[:, 1] = (
+            II[1, 0, :] * Rv[0, 0, :]
+            + II[1, 1, :] * Rv[1, 0, :]
+            + II[1, 2, :] * Rv[2, 0, :]
+        ) / dd
+        bb[:, 2] = (
+            II[2, 0, :] * Rv[0, 0, :]
+            + II[2, 1, :] * Rv[1, 0, :]
+            + II[2, 2, :] * Rv[2, 0, :]
+        ) / dd
+
+        bb[:, 0:3] = pp[tt[:, 0], :] + bb[:, 0:3]
+
+        r1 = np.sum((bb[:, 0:3] - pp[tt[:, 0], :]) ** 2, axis=1)
+        r2 = np.sum((bb[:, 0:3] - pp[tt[:, 1], :]) ** 2, axis=1)
+        r3 = np.sum((bb[:, 0:3] - pp[tt[:, 2], :]) ** 2, axis=1)
+
+        r1 -= pw[tt[:, 0], 0]
+        r2 -= pw[tt[:, 1], 0]
+        r3 -= pw[tt[:, 2], 0]
+
+        bb[:, 3] = (r1 + r2 + r3) / 3.0
+
+    else:
+        raise ValueError("pwrbal2:unsupportedDimension")
+
+    return bb

bluemesh2d/mesh_ball/tribal2.py

@@ -0,0 +1,27 @@
+import numpy as np
+from .pwrbal2 import pwrbal2
+
+def tribal2(pp, tt):
+    """Compute circumballs for triangles in R² or R³.
+
+    Equivalent to :func:`pwrbal2` with zero vertex weights.
+
+    Parameters
+    ----------
+    pp : ndarray of shape (N, 2) or (N, 3)
+        Vertex coordinates.
+    tt : ndarray of shape (T, 3)
+        Triangle connectivity.
+
+    Returns
+    -------
+    bb : ndarray of shape (T, 3) or (T, 4)
+        Circumball parameters ``[xc, yc, r²]`` in 2D or ``[xc, yc, zc, r²]`` in 3D.
+
+    References
+    ----------
+    Translation of the MESH2D function ``TRIBAL2``.
+    Original MATLAB source: https://github.com/dengwirda/mesh2d
+    """
+
+    return pwrbal2(pp, np.zeros((pp.shape[0], 1)), tt)

bluemesh2d/mesh_cost/relhfn.py

@@ -0,0 +1,62 @@
+import numpy as np
+
+
+def relhfn(vert, tria, hvrt):
+    """Compute relative edge lengths against a mesh-size function.
+
+    For each unique mesh edge, return ``edge_length / mean(h at endpoints)``.
+    Values near 1 indicate good conformance to the sizing field.
+
+    Parameters
+    ----------
+    vert : ndarray of shape (V, 2)
+        Vertex coordinates.
+    tria : ndarray of shape (T, 3)
+        Triangle connectivity.
+    hvrt : ndarray of shape (V,)
+        Mesh-size function evaluated at vertices.
+
+    Returns
+    -------
+    hrel : ndarray of shape (E,)
+        Relative edge lengths for the unique edges in the triangulation.
+
+    References
+    ----------
+    Translation of the MESH2D function ``RELHFN2``.
+    Original MATLAB source: https://github.com/dengwirda/mesh2d
+    """
+
+    if not (
+        isinstance(vert, np.ndarray)
+        and isinstance(tria, np.ndarray)
+        and isinstance(hvrt, np.ndarray)
+    ):
+        raise TypeError("relhfn:incorrectInputClass")
+
+    if vert.ndim != 2 or tria.ndim != 2:
+        raise ValueError("relhfn:incorrectDimensions")
+    if vert.shape[1] != 2 or tria.shape[1] < 3:
+        raise ValueError("relhfn:incorrectDimensions")
+    if len(hvrt.shape) != 1 or hvrt.shape[0] != vert.shape[0]:
+        raise ValueError("relhfn:incorrectDimensions")
+
+    nnod = vert.shape[0]
+
+    if np.min(tria[:, :3]) < 0 or np.max(tria[:, :3]) >= nnod:
+        raise ValueError("relhfn:invalidInputs")
+
+    eset = np.vstack([tria[:, [0, 1]], tria[:, [1, 2]], tria[:, [2, 0]]])
+
+    eset = np.sort(eset, axis=1)
+    eset = np.unique(eset, axis=0)
+
+    evec = vert[eset[:, 1], :] - vert[eset[:, 0], :]
+
+    elen = np.sqrt(np.sum(evec**2, axis=1))
+
+    hmid = hvrt[eset[:, 1]] + hvrt[eset[:, 0]]
+    hmid = 0.5 * hmid
+    hrel = elen / hmid
+
+    return hrel

bluemesh2d/mesh_cost/triang.py

@@ -0,0 +1,59 @@
+import numpy as np
+
+
+def triang(pp, tt):
+    """Compute internal triangle angles in degrees.
+
+    Parameters
+    ----------
+    pp : ndarray of shape (V, 2)
+        Vertex coordinates.
+    tt : ndarray of shape (T, 3)
+        Triangle connectivity.
+
+    Returns
+    -------
+    dcos : ndarray of shape (T, 3)
+        Internal angles at the three vertices of each triangle.
+
+    References
+    ----------
+    Translation of the MESH2D function ``TRIANG2``.
+    Original MATLAB source: https://github.com/dengwirda/mesh2d
+    """
+
+    if not (isinstance(pp, np.ndarray) and isinstance(tt, np.ndarray)):
+        raise TypeError("triang:incorrectInputClass")
+
+    if pp.ndim != 2 or tt.ndim != 2:
+        raise ValueError("triang:incorrectDimensions")
+    if pp.shape[1] != 2 or tt.shape[1] < 3:
+        raise ValueError("triang:incorrectDimensions")
+
+    nnod = pp.shape[0]
+    if np.min(tt[:, :3]) < 0 or np.max(tt[:, :3]) >= nnod:
+        raise ValueError("triang:invalidInputs")
+
+    dcos = np.zeros((tt.shape[0], 3))
+
+    ev12 = pp[tt[:, 1], :] - pp[tt[:, 0], :]
+    ev23 = pp[tt[:, 2], :] - pp[tt[:, 1], :]
+    ev31 = pp[tt[:, 0], :] - pp[tt[:, 2], :]
+
+    lv11 = np.sqrt(np.sum(ev12**2, axis=1))
+    lv22 = np.sqrt(np.sum(ev23**2, axis=1))
+    lv33 = np.sqrt(np.sum(ev31**2, axis=1))
+
+    ev12 = ev12 / lv11[:, None]
+    ev23 = ev23 / lv22[:, None]
+    ev31 = ev31 / lv33[:, None]
+
+    dcos[:, 0] = np.sum(-ev12 * ev23, axis=1)
+    dcos[:, 1] = np.sum(-ev23 * ev31, axis=1)
+    dcos[:, 2] = np.sum(-ev31 * ev12, axis=1)
+
+    dcos = np.clip(dcos, -1.0, 1.0)
+
+    dcos = np.arccos(dcos) * 180.0 / np.pi
+
+    return dcos

bluemesh2d/mesh_cost/triarea.py

@@ -0,0 +1,51 @@
+import numpy as np
+
+
+def triarea(pp, tt):
+    """Compute signed triangle areas.
+
+    Positive area indicates counter-clockwise vertex ordering in 2D.
+
+    Parameters
+    ----------
+    pp : ndarray of shape (V, 2) or (V, 3)
+        Vertex coordinates.
+    tt : ndarray of shape (T, 3)
+        Triangle connectivity.
+
+    Returns
+    -------
+    area : ndarray of shape (T,)
+        Signed triangle areas (2D) or Euclidean areas (3D).
+
+    References
+    ----------
+    Translation of the MESH2D function ``TRIAREA``.
+    Original MATLAB source: https://github.com/dengwirda/mesh2d
+    """
+
+    if not (isinstance(pp, np.ndarray) and isinstance(tt, np.ndarray)):
+        raise TypeError("triarea:incorrectInputClass")
+
+    if pp.ndim != 2 or tt.ndim != 2:
+        raise ValueError("triarea:incorrectDimensions")
+    if pp.shape[1] not in (2, 3) or tt.shape[1] < 3:
+        raise ValueError("triarea:incorrectDimensions")
+
+    nnod = pp.shape[0]
+    if np.min(tt[:, :3]) < 0 or np.max(tt[:, :3]) >= nnod:
+        raise ValueError("triarea:invalidInputs")
+    ev12 = pp[tt[:, 1], :] - pp[tt[:, 0], :]
+    ev13 = pp[tt[:, 2], :] - pp[tt[:, 0], :]
+
+    if pp.shape[1] == 2:
+        area = ev12[:, 0] * ev13[:, 1] - ev12[:, 1] * ev13[:, 0]
+        area = 0.5 * area
+    elif pp.shape[1] == 3:
+        avec = np.cross(ev12, ev13)
+        area = np.sqrt(np.sum(avec**2, axis=1))
+        area = 0.5 * area
+    else:
+        raise ValueError("triarea:Unsupported dimension")
+
+    return area

bluemesh2d/mesh_cost/trideg.py

@@ -0,0 +1,44 @@
+import numpy as np
+
+
+def trideg(pp, tt):
+    """Count incident triangles at each vertex.
+
+    Parameters
+    ----------
+    pp : ndarray of shape (V, D)
+        Vertex coordinates (``D >= 2``).
+    tt : ndarray of shape (T, 3)
+        Triangle connectivity.
+
+    Returns
+    -------
+    vdeg : ndarray of shape (V,), dtype int
+        Number of triangles incident to each vertex.
+
+    References
+    ----------
+    Translation of the MESH2D function ``TRIDEG2``.
+    Original MATLAB source: https://github.com/dengwirda/mesh2d
+    """
+
+    if not (isinstance(pp, np.ndarray) and isinstance(tt, np.ndarray)):
+        raise TypeError("trideg:incorrectInputClass")
+
+    if pp.ndim != 2 or tt.ndim != 2:
+        raise ValueError("trideg:incorrectDimensions")
+    if pp.shape[1] < 2 or tt.shape[1] < 3:
+        raise ValueError("trideg:incorrectDimensions")
+
+    nvrt = pp.shape[0]
+    _ntri = tt.shape[0]
+
+    if np.min(tt[:, :3]) < 0 or np.max(tt[:, :3]) >= nvrt:
+        raise ValueError("trideg:invalidInputs")
+
+    vdeg = np.zeros(nvrt, dtype=int)
+
+    for tri in tt[:, :3]:
+        vdeg[tri] += 1
+
+    return vdeg

bluemesh2d/mesh_cost/triscr.py

@@ -0,0 +1,43 @@
+import numpy as np
+from .triarea import triarea
+
+def triscr(pp, tt):
+    """Compute scaled area-to-length ratios for mesh quality.
+
+    Higher values indicate more equilateral triangles. The scale factor
+    ``4*sqrt(3)/3`` normalizes an equilateral triangle to unity.
+
+    Parameters
+    ----------
+    pp : ndarray of shape (V, 2)
+        Vertex coordinates.
+    tt : ndarray of shape (T, 3)
+        Triangle connectivity.
+
+    Returns
+    -------
+    tscr : ndarray of shape (T,)
+        Area-to-mean-squared-edge-length ratio for each triangle.
+
+    References
+    ----------
+    Translation of the MESH2D function ``TRISCR2``.
+    Original MATLAB source: https://github.com/dengwirda/mesh2d
+    """
+
+    # Compute signed area-len. ratios
+    scal = 4.0 * np.sqrt(3.0) / 3.0
+
+    area = triarea(pp, tt) # also error checks!
+
+    lrms = (
+        np.sum((pp[tt[:, 1], :] - pp[tt[:, 0], :])**2, axis=1) +
+        np.sum((pp[tt[:, 2], :] - pp[tt[:, 1], :])**2, axis=1) +
+        np.sum((pp[tt[:, 2], :] - pp[tt[:, 0], :])**2, axis=1)
+    )
+
+    lrms = (lrms / 3.0) ** 1.0
+
+    tscr = scal * area / lrms
+
+    return tscr