lapy 1.5.0__tar.gz → 1.7.0.dev0__tar.gz

{lapy-1.5.0 → lapy-1.7.0.dev0}/PKG-INFO

@@ -1,31 +1,10 @@
 Metadata-Version: 2.4
 Name: lapy
-Version: 1.5.0
+Version: 1.7.0.dev0
 Summary: A package for differential geometry on meshes (Laplace, FEM)
 Author-email: Martin Reuter <martin.reuter@dzne.de>
 Maintainer-email: Martin Reuter <martin.reuter@dzne.de>
-License: MIT License
-        
-        Copyright (c) 2020 Deep Medical Imaging Lab (PI Reuter)
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to deal
-        in the Software without restriction, including without limitation the rights
-        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-        copies of the Software, and to permit persons to whom the Software is
-        furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all
-        copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-        SOFTWARE.
-        
+License-Expression: MIT
 Project-URL: homepage, https://Deep-MI.github.io/LaPy/dev/index.html
 Project-URL: documentation, https://Deep-MI.github.io/LaPy/dev/index.html
 Project-URL: source, https://github.com/Deep-MI/LaPy
@@ -35,45 +14,39 @@ Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: Unix
 Classifier: Operating System :: MacOS
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Natural Language :: English
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Intended Audience :: Science/Research
-Requires-Python: >=3.9
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: nibabel
-Requires-Dist: numpy>=1.21
-Requires-Dist: plotly
-Requires-Dist: psutil
-Requires-Dist: scipy!=1.13.0
+Requires-Dist: nibabel>=4.0
+Requires-Dist: numpy>=1.23.2
+Requires-Dist: plotly>=5.0
+Requires-Dist: psutil>=5.9
+Requires-Dist: scipy!=1.13.0,>=1.9.2
 Provides-Extra: build
 Requires-Dist: build; extra == "build"
 Requires-Dist: twine; extra == "build"
 Provides-Extra: chol
-Requires-Dist: scikit-sparse>=0.4.16; extra == "chol"
+Requires-Dist: cholespy>=2.0; extra == "chol"
 Provides-Extra: doc
 Requires-Dist: furo!=2023.8.17; extra == "doc"
 Requires-Dist: matplotlib; extra == "doc"
-Requires-Dist: memory-profiler; extra == "doc"
 Requires-Dist: numpydoc; extra == "doc"
-Requires-Dist: sphinx!=7.2.*; extra == "doc"
+Requires-Dist: sphinx!=7.2.*,>=7.0; extra == "doc"
 Requires-Dist: sphinxcontrib-bibtex; extra == "doc"
 Requires-Dist: sphinx-copybutton; extra == "doc"
 Requires-Dist: sphinx-design; extra == "doc"
-Requires-Dist: sphinx-gallery; extra == "doc"
-Requires-Dist: sphinx-issues; extra == "doc"
-Requires-Dist: pypandoc; extra == "doc"
 Requires-Dist: nbsphinx; extra == "doc"
 Requires-Dist: IPython; extra == "doc"
 Requires-Dist: ipykernel; extra == "doc"
 Provides-Extra: style
 Requires-Dist: bibclean; extra == "style"
 Requires-Dist: codespell; extra == "style"
-Requires-Dist: pydocstyle[toml]; extra == "style"
 Requires-Dist: ruff; extra == "style"
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
@@ -85,8 +58,6 @@ Requires-Dist: lapy[chol]; extra == "all"
 Requires-Dist: lapy[doc]; extra == "all"
 Requires-Dist: lapy[style]; extra == "all"
 Requires-Dist: lapy[test]; extra == "all"
-Provides-Extra: full
-Requires-Dist: lapy[all]; extra == "full"
 Dynamic: license-file
 
 [![PyPI version](https://badge.fury.io/py/lapy.svg)](https://pypi.org/project/lapy/)
@@ -109,13 +80,16 @@ Key design goals:
 - [References](#references)
 
 ## Features
-- `TriaMesh`: triangle mesh class with orientation checking, boundary handling, normals, smoothing and quality metrics; efficient edge and adjacency representations; IO for OFF, VTK and related formats.
+- `TriaMesh`: triangle mesh class with orientation checking, boundary handling, normals, smoothing and quality metrics; efficient edge and adjacency representations; IO for OFF, VTK; Gifti and related formats.
 - `TetMesh`: tetrahedral mesh utilities, boundary handling and IO.
+- `Polygon`: polygon class representing open and closed polygon curves.
 - `Solver`: FEM routines producing stiffness and mass matrices, sparse eigenvalue solvers, Poisson and heat equation solvers, and support for anisotropic operators.
 - `diffgeo`: gradient, divergence, mean-curvature flow and related differential operators.
 - `heat`: heat kernel and diffusion utilities, geodesics via heat method.
 - `shapedna`: compute ShapeDNA (Laplace spectra) for shape descriptors.
 - `conformal`: conformal mapping methods for genus-0 surfaces.
+- `intersect`: self-intersection tests for triangle meshes, and undoing vertex moves that create intersections.
+- `remesh`: isotropic remeshing to near-equilateral triangles that keeps the topology, and closest points on a surface.
 - `io`: read/write vertex functions and eigenvector files.
 - `plot`: lightweight Plotly wrappers for interactive visualization.
 
@@ -150,8 +124,7 @@ python3 -m pip install --user --src /my/preferred/location --editable git+https:
 
 ### Dependencies and optional backends
 - Core: Python 3, NumPy, SciPy.
-- Optional (recommended): scikit-sparse (for CHOLMOD) to accelerate Cholesky sparse solves.
-Note: CHOLMOD (via scikit-sparse) is not currently installable via plain `pip` on all platforms; use `conda` when possible. If `use_cholmod=True` is requested, LaPy attempts to import CHOLMOD and will raise if it is unavailable. Install ordering: install `numpy` and `scipy` first, then `scikit-sparse`.
+- Optional: cholespy (for CHOLMOD) to accelerate sparse solves with the Cholesky decomposition. Install it with `pip install lapy[chol]`. If `use_cholmod=True` is requested without cholespy, LaPy raises an ImportError.
 
 ## Solver backends
 - Default: SciPy sparse LU/QR routines.

{lapy-1.5.0 → lapy-1.7.0.dev0}/README.md

@@ -18,13 +18,16 @@ Key design goals:
 - [References](#references)
 
 ## Features
-- `TriaMesh`: triangle mesh class with orientation checking, boundary handling, normals, smoothing and quality metrics; efficient edge and adjacency representations; IO for OFF, VTK and related formats.
+- `TriaMesh`: triangle mesh class with orientation checking, boundary handling, normals, smoothing and quality metrics; efficient edge and adjacency representations; IO for OFF, VTK; Gifti and related formats.
 - `TetMesh`: tetrahedral mesh utilities, boundary handling and IO.
+- `Polygon`: polygon class representing open and closed polygon curves.
 - `Solver`: FEM routines producing stiffness and mass matrices, sparse eigenvalue solvers, Poisson and heat equation solvers, and support for anisotropic operators.
 - `diffgeo`: gradient, divergence, mean-curvature flow and related differential operators.
 - `heat`: heat kernel and diffusion utilities, geodesics via heat method.
 - `shapedna`: compute ShapeDNA (Laplace spectra) for shape descriptors.
 - `conformal`: conformal mapping methods for genus-0 surfaces.
+- `intersect`: self-intersection tests for triangle meshes, and undoing vertex moves that create intersections.
+- `remesh`: isotropic remeshing to near-equilateral triangles that keeps the topology, and closest points on a surface.
 - `io`: read/write vertex functions and eigenvector files.
 - `plot`: lightweight Plotly wrappers for interactive visualization.
 
@@ -59,8 +62,7 @@ python3 -m pip install --user --src /my/preferred/location --editable git+https:
 
 ### Dependencies and optional backends
 - Core: Python 3, NumPy, SciPy.
-- Optional (recommended): scikit-sparse (for CHOLMOD) to accelerate Cholesky sparse solves.
-Note: CHOLMOD (via scikit-sparse) is not currently installable via plain `pip` on all platforms; use `conda` when possible. If `use_cholmod=True` is requested, LaPy attempts to import CHOLMOD and will raise if it is unavailable. Install ordering: install `numpy` and `scipy` first, then `scikit-sparse`.
+- Optional: cholespy (for CHOLMOD) to accelerate sparse solves with the Cholesky decomposition. Install it with `pip install lapy[chol]`. If `use_cholmod=True` is requested without cholespy, LaPy raises an ImportError.
 
 ## Solver backends
 - Default: SciPy sparse LU/QR routines.

lapy-1.7.0.dev0/lapy/_cholmod.py

@@ -0,0 +1,102 @@
+"""Sparse Cholesky factorization with CHOLMOD, provided by the cholespy package."""
+
+import numpy as np
+from scipy import sparse
+
+from .utils._imports import import_optional_dependency
+
+_INT32_MAX = np.iinfo(np.int32).max
+
+
+def require_cholmod() -> None:
+    """Raise an ImportError if cholespy, which provides CHOLMOD, is not installed."""
+    import_optional_dependency("cholespy", extra="It is required for use_cholmod=True.", raise_error=True)
+
+
+class CholeskyFactor:
+    """Cholesky factorization of a sparse symmetric positive definite matrix.
+
+    CHOLMOD reads only one triangle of the matrix, so the matrix has to be
+    genuinely symmetric. The factorization and the solves run in double
+    precision; solutions are returned in ``float32`` for a ``float32`` matrix
+    and in ``float64`` otherwise.
+
+    Parameters
+    ----------
+    matrix : scipy.sparse.spmatrix
+        Sparse symmetric positive definite matrix of shape (n, n).
+
+    Raises
+    ------
+    ImportError
+        If cholespy is not installed.
+    ValueError
+        If the matrix is not square, too large for 32-bit indices, or not
+        positive definite.
+    """
+
+    def __init__(self, matrix) -> None:
+        cholespy = import_optional_dependency(
+            "cholespy", extra="It is required for use_cholmod=True.", raise_error=True
+        )
+        a = sparse.csc_matrix(matrix)
+        a.sum_duplicates()
+        a.sort_indices()
+        n = a.shape[0]
+        if a.shape != (n, n):
+            raise ValueError(f"Cholesky factorization needs a square matrix, got shape {a.shape}.")
+        # cholespy takes 32-bit indices; scipy switches to 64-bit ones beyond that range
+        if n > _INT32_MAX or a.nnz > _INT32_MAX:
+            raise ValueError(
+                f"Matrix with {n} rows and {a.nnz} non-zeros is too large for CHOLMOD's 32-bit indices."
+            )
+        # output precision; cholespy factorizes in double precision on the CPU either way
+        self.dtype = np.dtype(np.float32) if a.dtype == np.float32 else np.dtype(np.float64)
+        # Passed as CSR, which for a symmetric matrix holds the same arrays as CSC.
+        # cholespy reallocates the arrays of a CSC input in place, which corrupts the
+        # heap when NumPy owns them (it crashes on Windows), but copies a CSR input.
+        try:
+            self._solver = cholespy.CholeskySolverD(
+                n,
+                a.indptr.astype(np.int32),
+                a.indices.astype(np.int32),
+                a.data.astype(np.float64),
+                cholespy.MatrixType.CSR,
+            )
+        except ValueError as err:
+            if "positive definite" not in str(err):
+                raise
+            raise ValueError(
+                "Cholesky factorization failed because the matrix is not positive definite, "
+                "for example a Laplace operator without boundary conditions. "
+                "Use use_cholmod=False for the LU decomposition instead."
+            ) from err
+        self.shape = (n, n)
+
+    def solve(self, b) -> np.ndarray:
+        """Solve ``A x = b`` with the factorized matrix.
+
+        Parameters
+        ----------
+        b : array_like or scipy.sparse.spmatrix
+            Right hand side of shape (n,) or (n, n_rhs).
+
+        Returns
+        -------
+        np.ndarray
+            Solution of the same shape as ``b``, ``float32`` for a ``float32``
+            matrix and ``float64`` otherwise.
+
+        Raises
+        ------
+        ValueError
+            If the first dimension of ``b`` does not match the matrix.
+        """
+        if sparse.issparse(b):
+            b = b.toarray()
+        b = np.ascontiguousarray(np.asarray(b), dtype=np.float64)
+        if b.ndim not in (1, 2) or b.shape[0] != self.shape[0]:
+            raise ValueError(f"Right hand side of shape {b.shape} does not match a matrix of shape {self.shape}.")
+        x = np.empty_like(b)
+        self._solver.solve(b, x)
+        return x.astype(self.dtype, copy=False)

lapy-1.7.0.dev0/lapy/_gmsh_io.py

@@ -0,0 +1,266 @@
+"""Shared reader for GMSH meshes, MSH 2 ASCII format.
+
+Both :mod:`lapy._tria_io` and :mod:`lapy._tet_io` parse the same file format,
+so the parsing lives here once and each of them keeps only the thin wrapper
+that turns the result into its own mesh type.
+
+.. moduleauthor:: Nico Schloemer <nico.schloemer@gmail.com>
+LICENSE MIT
+https://github.com/nschloe/meshio
+http://geuz.org/gmsh/doc/texinfo/gmsh.html#MSH-ASCII-file-format
+"""
+
+import logging
+import os
+import re
+from itertools import islice
+
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+# gmsh element code -> name, and the vertex count of each name.
+GMSH_TO_NAME = {
+    15: "vertex",
+    1: "line",
+    2: "triangle",
+    3: "quad",
+    4: "tetra",
+    5: "hexahedron",
+    6: "wedge",
+    7: "pyramid",
+    8: "line3",
+    9: "triangle6",
+    10: "quad9",
+    11: "tetra10",
+    12: "hexahedron27",
+    13: "prism18",
+    14: "pyramid14",
+    26: "line4",
+    36: "quad16",
+}
+NAME_TO_GMSH = {v: k for k, v in GMSH_TO_NAME.items()}
+NODES_PER_CELL = {
+    "vertex": 1,
+    "line": 2,
+    "triangle": 3,
+    "quad": 4,
+    "tetra": 4,
+    "hexahedron": 8,
+    "wedge": 6,
+    "pyramid": 5,
+    "line3": 3,
+    "triangle6": 6,
+    "quad9": 9,
+    "tetra10": 10,
+    "hexahedron27": 27,
+    "prism18": 18,
+    "pyramid14": 14,
+    "line4": 4,
+    "quad16": 16,
+}
+
+
+def _fail(msg: str) -> None:
+    """Log and raise in the format the other readers use."""
+    msg = f"[{msg}] --> FAILED\n"
+    logger.error(msg)
+    raise ValueError(msg)
+
+
+def _expect(line: str, keyword: str) -> None:
+    """Fail on a malformed file.
+
+    Not an assert: these validate untrusted file content, and assert is
+    stripped under ``python -O``, which would let a truncated file through and
+    only surface much later as a wrong mesh.
+    """
+    if line.strip() != keyword:
+        _fail(f"{keyword} keyword not found")
+
+
+def _holds_type(block: str, name: str) -> bool:
+    """Say whether an element block contains a cell type, without parsing it.
+
+    Each record starts ``number type ...``, so the type is the second token of
+    a line. Scanning the raw text for that is several times cheaper than
+    converting the whole block to integers, which lets a caller that asked for
+    triangles reject a volume mesh before paying for the conversion.
+    """
+    return re.search(rf"(?m)^\s*\d+\s+{NAME_TO_GMSH[name]}\s", block) is not None
+
+
+def _cells_from_block(flat: np.ndarray, num_cells: int) -> dict:
+    """Split a flat MSH 2 element block into 0-based node indices per cell type.
+
+    A record is ``number type n_tags <tags...> <nodes...>``, so records only
+    share a width when the block holds a single element type with a single tag
+    count. That is the common case and reshapes in one step; a mixed block
+    falls back to walking the records.
+
+    Parameters
+    ----------
+    flat : np.ndarray
+        All integers of the element block, in file order.
+    num_cells : int
+        Number of records the block declares.
+
+    Returns
+    -------
+    dict
+        Maps an element name to its (n_cells, n_vertices) index array.
+    """
+    if num_cells == 0:
+        return {}
+
+    width, remainder = divmod(flat.size, num_cells)
+    if remainder == 0:
+        rows = flat.reshape(num_cells, width)
+        etype, n_tags = int(rows[0, 1]), int(rows[0, 2])
+        name = GMSH_TO_NAME[etype]
+        uniform = (
+            3 + n_tags + NODES_PER_CELL[name] == width
+            and bool((rows[:, 1] == etype).all())
+            and bool((rows[:, 2] == n_tags).all())
+        )
+        if uniform:
+            return {name: rows[:, -NODES_PER_CELL[name] :] - 1}
+
+    # Mixed block: walk the records. tolist() keeps the walk in plain python,
+    # which is far cheaper than numpy scalar indexing in a loop, and the node
+    # indices are extended into one flat list per type rather than appended as
+    # rows, so the final conversion is a single reshape.
+    values = flat.tolist()
+    chunks: dict = {}
+    pos, size = 0, len(values)
+    while pos < size:
+        name = GMSH_TO_NAME[values[pos + 1]]
+        n_nodes = NODES_PER_CELL[name]
+        end = pos + 3 + values[pos + 2] + n_nodes
+        chunks.setdefault(name, []).extend(values[end - n_nodes : end])
+        pos = end
+    return {
+        k: np.array(v, dtype=np.int64).reshape(-1, NODES_PER_CELL[k]) - 1
+        for k, v in chunks.items()
+    }
+
+
+def read_gmsh(filename: str, want: str | None = None) -> tuple[np.ndarray, dict]:
+    """Read points and cells from a GMSH file, MSH 2 ASCII format.
+
+    Parameters
+    ----------
+    filename : str
+        Filename to load, must end in ``.msh``.
+    want : str or None, default=None
+        Cell type the caller needs, for example ``"triangle"`` or ``"tetra"``.
+        When given, a file that cannot supply it is rejected as early as
+        possible: the node coordinates are skipped rather than parsed until the
+        element block has been checked, and the check itself is a text scan
+        rather than a full conversion. Reading a volume mesh as a triangle mesh
+        therefore costs a fraction of a full read.
+
+    Returns
+    -------
+    points : np.ndarray
+        Vertex coordinates, shape (n_points, 3).
+    cells : dict
+        Maps an element name to its (n_cells, n_vertices) index array.
+
+    Raises
+    ------
+    OSError
+        If file is not found or not readable.
+    ValueError
+        If the extension is not ``.msh``, the file is binary or not version 2,
+        a section is malformed, or ``want`` is not present.
+    """
+    if os.path.splitext(filename)[1] != ".msh":
+        _fail("no .msh file")
+
+    logger.debug("--> GMSH format         ... ")
+
+    try:
+        f = open(filename)
+    except OSError:
+        logger.error("[file not found or not readable]")
+        raise
+
+    points = None
+    node_offset = None
+    num_nodes = 0
+    cells: dict = {}
+
+    with f:
+        while True:
+            line = f.readline()
+            if not line:
+                break
+            if not line.startswith("$"):
+                _fail(f"section keyword expected, found '{line.strip()}'")
+            section = line[1:].strip()
+
+            if section == "MeshFormat":
+                larr = list(filter(None, f.readline().split()))
+                if larr[0][0] != "2":
+                    _fail(f"need mesh format 2, found {larr[0]}")
+                if larr[1] != "0":
+                    # The file is opened in text mode, so the binary layout
+                    # cannot be read from this handle at all.
+                    _fail("binary format not implemented")
+                _expect(f.readline(), "$EndMeshFormat")
+
+            elif section == "Nodes":
+                num_nodes = int(f.readline())
+                if want is not None and not cells:
+                    # Skip for now. If the element block turns out not to hold
+                    # `want` we never pay to parse these coordinates, and
+                    # skipping is about thirty times cheaper than parsing.
+                    node_offset = f.tell()
+                    for _ in islice(f, num_nodes):
+                        pass
+                else:
+                    points = _read_points(f, num_nodes)
+                _expect(f.readline(), "$EndNodes")
+
+            elif section == "Elements":
+                num_cells = int(f.readline())
+                block = "".join(islice(f, num_cells))
+                if want is not None:
+                    first = block.split("\n", 1)[0].split()
+                    known = len(first) > 1 and int(first[1]) == NAME_TO_GMSH[want]
+                    if not known and not _holds_type(block, want):
+                        _fail(f"file holds no {want} elements")
+                cells = _cells_from_block(
+                    np.array(block.split(), dtype=np.int64), num_cells
+                )
+                _expect(f.readline(), "$EndElements")
+
+            else:
+                # Skip sections we do not use, such as $PhysicalNames,
+                # $Periodic or $NodeData. Erroring out instead would reject
+                # perfectly good files.
+                end = f"$End{section}"
+                while True:
+                    line = f.readline()
+                    if not line:
+                        _fail(f"{end} keyword not found")
+                    if line.strip() == end:
+                        break
+
+        if points is None and node_offset is not None:
+            f.seek(node_offset)
+            points = _read_points(f, num_nodes)
+
+    if points is None:
+        _fail("$Nodes section not found")
+    if want is not None and want not in cells:
+        _fail(f"file holds no {want} elements")
+
+    return points, cells
+
+
+def _read_points(f, num_nodes: int) -> np.ndarray:
+    """Read a node block as (n, 3), dropping the leading index column."""
+    points = np.fromfile(f, "float32", num_nodes * 4, " ").reshape(num_nodes, 4)
+    return np.ascontiguousarray(points[:, 1:])

{lapy-1.5.0 → lapy-1.7.0.dev0}/lapy/_tet_io.py

@@ -4,7 +4,6 @@ Should be called via the TetMesh member functions.
 """
 
 import logging
-import os.path
 from typing import TYPE_CHECKING
 
 import numpy as np
@@ -15,7 +14,7 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 def read_gmsh(filename: str) -> "TetMesh":
-    """Load GMSH tetrahedron mesh.
+    """Load GMSH tetrahedron mesh, MSH 2 ASCII format.
 
     Parameters
     ----------
@@ -32,101 +31,17 @@ def read_gmsh(filename: str) -> "TetMesh":
     OSError
         If file is not found or not readable.
     ValueError
-        If file format is invalid or binary format is encountered.
+        If the extension is not ``.msh``, the file is binary or not version 2,
+        a section is malformed, or the file holds no tetrahedra.
     """
-    extension = os.path.splitext(filename)[1]
-    verbose = 1
-    if verbose > 0:
-        logger.info("--> GMSH format         ... ")
-    if extension != ".msh":
-        msg = "[no .msh file] --> FAILED\n"
-        logger.error(msg)
-        raise ValueError(msg)
-    try:
-        f = open(filename)
-    except OSError:
-        logger.error("[file not found or not readable]")
-        raise
-    line = f.readline()
-    if not line.startswith("$MeshFormat"):
-        msg = "[$MeshFormat keyword not found] --> FAILED\n"
-        logger.error(msg)
-        f.close()
-        raise ValueError(msg)
-    line = f.readline()
-    larr = line.split()
-    ver = float(larr[0])
-    ftype = int(larr[1])
-    datatype = int(larr[2])
-    logger.debug(
-        "Msh file ver %s, ftype %s, datatype %s",
-        ver,
-        ftype,
-        datatype,
-    )
-    if ftype != 0:
-        msg = "[binary format not implemented] --> FAILED\n"
-        logger.error(msg)
-        f.close()
-        raise ValueError(msg)
-    line = f.readline()
-    if not line.startswith("$EndMeshFormat"):
-        msg = "[$EndMeshFormat keyword not found] --> FAILED\n"
-        logger.error(msg)
-        f.close()
-        raise ValueError(msg)
-    line = f.readline()
-    if not line.startswith("$Nodes"):
-        msg = "[$Nodes keyword not found] --> FAILED\n"
-        logger.error(msg)
-        f.close()
-        raise ValueError(msg)
-    pnum = int(f.readline())
-    # read (nodes X 4) matrix as chunk
-    # drop first column
-    v = np.fromfile(f, "float32", 4 * pnum, " ")
-    v.shape = (pnum, 4)
-    v = np.delete(v, 0, 1)
-    line = f.readline()
-    if not line.startswith("$EndNodes"):
-        msg = "[$EndNodes keyword not found] --> FAILED\n"
-        logger.error(msg)
-        f.close()
-        raise ValueError(msg)
-    line = f.readline()
-    if not line.startswith("$Elements"):
-        msg = "[$Elements keyword not found] --> FAILED\n"
-        logger.error(msg)
-        f.close()
-        raise ValueError(msg)
-    tnum = int(f.readline())
-    pos = f.tell()
-    line = f.readline()
-    f.seek(pos)
-    larr = line.split()
-    if int(larr[1]) != 4:
-        logger.debug("larr: %s", larr)
-        msg = "[can only read tetras] --> FAILED\n"
-        logger.error(msg)
-        f.close()
-        raise ValueError(msg)
-    # read (nodes X ?) matrix
-    t = np.fromfile(f, "int", tnum * len(larr), " ")
-    t.shape = (tnum, len(larr))
-    t = np.delete(t, np.s_[0 : len(larr) - 4], 1)
-    line = f.readline()
-    if not line.startswith("$EndElements"):
-        logger.debug("Line: %s", line)
-        msg = "[$EndElements keyword not found] --> FAILED\n"
-        logger.error(msg)
-        f.close()
-        raise ValueError(msg)
-    f.close()
-    logger.info(" --> DONE ( V: %d , T: %d )", v.shape[0], t.shape[0])
     from . import TetMesh
+    from ._gmsh_io import read_gmsh as _read
 
-    return TetMesh(v, t)
-
+    points, cells = _read(filename, want="tetra")
+    logger.info(
+        " --> DONE ( V: %d , T: %d )", points.shape[0], cells["tetra"].shape[0]
+    )
+    return TetMesh(points, cells["tetra"])
 
 def read_vtk(filename: str) -> "TetMesh":
     """Load VTK tetrahedron mesh.
@@ -194,7 +109,7 @@ def read_vtk(filename: str) -> "TetMesh":
     pnum = int(larr[1])
     # read points as chunk
     v = np.fromfile(f, "float32", 3 * pnum, " ")
-    v.shape = (pnum, 3)
+    v = v.reshape(pnum, 3)
     # expect polygon or tria_strip line
     line = f.readline()
     larr = line.split()
@@ -207,7 +122,7 @@ def read_vtk(filename: str) -> "TetMesh":
             logger.error(msg)
             raise ValueError(msg)
         t = np.fromfile(f, "int", ttnum, " ")
-        t.shape = (tnum, 5)
+        t = t.reshape(tnum, 5)
         if t[tnum - 1][0] != 4:
             msg = "[can only read tetras] --> FAILED\n"
             logger.error(msg)