capytaine 2.3__cp39-cp39-macosx_14_0_arm64.whl → 3.0.0a1__cp39-cp39-macosx_14_0_arm64.whl

capytaine/meshes/meshes.py

@@ -1,81 +1,186 @@
-""" This module contains a class to describe the 2D mesh of the surface of a body in a 3D space.
-Based on meshmagick <https://github.com/LHEEA/meshmagick> by François Rongère.
-"""
-# Copyright (C) 2017-2019 Matthieu Ancellin, based on the work of François Rongère
-# See LICENSE file at <https://github.com/mancellin/capytaine>
+# Copyright 2025 Mews Labs
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
 
 import logging
-from itertools import count
+from functools import cached_property
+from typing import List, Union, Tuple, Dict, Optional, Literal
 
 import numpy as np
 
-from capytaine.meshes.geometry import Abstract3DObject, ClippableMixin, Plane, inplace_transformation, xOy_Plane
-from capytaine.meshes.properties import compute_faces_properties, connected_components, connected_components_of_waterline
-from capytaine.meshes.surface_integrals import SurfaceIntegralsMixin
-from capytaine.meshes.quality import (merge_duplicates, heal_normals, remove_unused_vertices,
-                                      heal_triangles, remove_degenerated_faces)
-from capytaine.tools.optional_imports import import_optional_dependency
-from capytaine.meshes.quadratures import compute_quadrature_on_faces
+from .abstract_meshes import AbstractMesh
+from .geometry import (
+    compute_faces_areas,
+    compute_faces_centers,
+    compute_faces_normals,
+    compute_faces_radii,
+    compute_gauss_legendre_2_quadrature,
+    get_vertices_face,
+)
+from .clip import clip_faces
+from .clean import clean_mesh
+from .export import export_mesh
+from .quality import _is_valid, check_mesh_quality
+from .visualization import show_3d
 
 LOG = logging.getLogger(__name__)
 
 
-class Mesh(ClippableMixin, SurfaceIntegralsMixin, Abstract3DObject):
-    """A class to handle unstructured 2D meshes in a 3D space.
+class Mesh(AbstractMesh):
+    """Mesh class for representing and manipulating 3D surface meshes.
 
     Parameters
     ----------
-    vertices : array_like of shape (nv, 3)
-        Array of mesh vertices coordinates.Each line of the array represents one vertex
-        coordinates
-    faces : array_like of shape (nf, 4)
-        Arrays of mesh connectivities for faces. Each line of the array represents indices of
-        vertices that form the face, expressed in counterclockwise order to ensure outward normals
-        description.
+    vertices : np.ndarray, optional
+        Array of mesh vertices coordinates with shape (n_vertices, 3).
+        Each row represents one vertex's (x, y, z) coordinates.
+    faces : List[List[int]] or np.ndarray, optional
+        Array of mesh connectivities for panels. Each row contains indices
+        of vertices that form a face (triangles or quads).
+    faces_metadata: Dict[str, np.ndarray]
+        Some arrays with the same first dimension (should be the number of faces)
+        storing some fields defined on all the faces of the mesh.
     name : str, optional
-        The name of the mesh. If None, the mesh is given an automatic name based on its internal ID.
-    quadrature_method: None or str or Quadpy quadrature, optional
-        The method used to compute quadrature points in each cells.
-        By default: None, that is a one-point first order scheme is used.
-    """
-
-    _ids = count(0)  # A counter for automatic naming of new meshes.
+        Optional name for the mesh instance.
+    auto_clean : bool, optional
+        Whether to automatically clean the mesh upon initialization. Defaults to True.
+    auto_check : bool, optional
+        Whether to automatically check mesh quality upon initialization. Defaults to True.
 
-    def __init__(self, vertices=None, faces=None, name=None, *, quadrature_method=None):
+    Attributes
+    ----------
+    vertices : np.ndarray
+        Array of vertex coordinates with shape (n_vertices, 3).
+    name : str or None
+        Name of the mesh instance.
+    """
 
-        if vertices is None or len(vertices) == 0:
-            vertices = np.zeros((0, 3))
+    def __init__(
+        self,
+        vertices: np.ndarray = None,
+        faces: Union[List[List[int]], np.ndarray] = None,
+        *,
+        faces_metadata: Optional[Dict[str, np.ndarray]] = None,
+        quadrature_method: Optional[str] = None,
+        name: Optional[str] = None,
+        auto_clean: bool = True,
+        auto_check: bool = True,
+    ):
+        # --- Vertices: always a NumPy array with shape (n,3) ---
+        if vertices is None:
+            self.vertices = np.empty((0, 3), dtype=np.float64)
+        else:
+            self.vertices = np.array(vertices, dtype=np.float64)
 
-        if faces is None or len(faces) == 0:
-            faces = np.zeros((0, 4))
+        # --- Faces: process using helper method ---
+        self._faces: List[List[int]] = self._process_faces(faces)
 
-        if name is None:
-            self.name = f'mesh_{next(Mesh._ids)}'
+        if faces_metadata is None:
+            self.faces_metadata = {}
         else:
-            self.name = str(name)
+            self.faces_metadata = {k: np.asarray(faces_metadata[k]) for k in faces_metadata}
 
-        self.__internals__ = dict()
-        self.vertices = vertices  # Not a direct assignment, goes through the setter method below.
-        self.faces = faces  # Not a direct assignment, goes through the setter method below.
+        for m in self.faces_metadata:
+            assert self.faces_metadata[m].shape[0] == len(self._faces)
 
-        LOG.debug(f"New mesh: {repr(self)}")
+        # Optional name
+        self.name = str(name) if name is not None else None
 
         self.quadrature_method = quadrature_method
 
-    def __short_str__(self):
-        return (f"{self.__class__.__name__}(..., name=\"{self.name}\")")
+        # Cleaning/quality (unless mesh is completely empty)
+        if not (len(self.vertices) == 0 and len(self._faces) == 0):
+            if not _is_valid(vertices, faces):
+                raise ValueError(
+                    "Mesh is invalid: faces contain out-of-bounds or negative indices."
+                )
+
+            if np.any(np.isnan(vertices)):
+                raise ValueError(
+                    "Mesh is invalid: vertices coordinates contains NaN values."
+                )
+
+            if auto_clean:
+                self.vertices, self._faces, self.faces_metadata = clean_mesh(
+                    self.vertices, self._faces, self.faces_metadata, max_iter=5, tol=1e-8
+                )
+                LOG.debug("Cleaned %s", str(self))
+
+            if auto_check:
+                check_mesh_quality(self)
+                LOG.debug("Checked quality of %s", str(self))
+
+        LOG.debug("New %s", str(self))
+
+
+    ## MAIN METRICS AND DISPLAY
+
+    @property
+    def nb_vertices(self) -> int:
+        """Number of vertices in the mesh."""
+        return len(self.vertices)
+
+    @property
+    def nb_faces(self) -> int:
+        """Number of faces in the mesh."""
+        return len(self._faces)
+
+    @property
+    def nb_triangles(self) -> int:
+        """Number of triangular faces (3-vertex) in the mesh."""
+        return sum(1 for f in self._faces if len(f) == 3)
+
+    @property
+    def nb_quads(self) -> int:
+        """Number of quadrilateral faces (4-vertex) in the mesh."""
+        return sum(1 for f in self._faces if len(f) == 4)
+
+    def summary(self):
+        """Print a summary of the mesh properties.
 
-    def __str__(self):
-        return (f"{self.__class__.__name__}(vertices=[[... {self.nb_vertices} vertices ...]], "
-                f"faces=[[... {self.nb_faces} faces ...]], name=\"{self.name}\")")
+        Notes
+        -----
+        Displays the mesh name, vertex count, face count, and bounding box.
+        """
+        print("Mesh Summary")
+        print(f"  Name           : {self.name}")
+        print(f"  Vertices count : {self.nb_vertices}")
+        print(f"  Faces count    : {self.nb_faces}")
+        print(
+            f"  Bounding box     : {self.vertices.min(axis=0)} to {self.vertices.max(axis=0)}"
+        )
+        print(f"  Metadata keys  : {self.faces_metadata.keys()}")
+        print(f"  Quadrature     : {self.quadrature_method}")
+
+    def __str__(self) -> str:
+        return (
+                f"Mesh(vertices=[[... {self.nb_vertices} vertices ...]], "
+                + f"faces=[[... {self.nb_faces} faces ...]]"
+                + (f", quadrature_method={repr(self.quadrature_method)}" if self.quadrature_method is not None else "")
+                + (f", name={repr(self.name)}" if self.name is not None else "")
+                + ")"
+        )
+
+    def __short_str__(self) -> str:
+        if self.name is not None:
+            return f"Mesh(..., name={repr(self.name)})"
+        else:
+            return "Mesh(...)"
 
-    def __repr__(self):
-        # shift = len(self.__class__.__name__) + 1
-        # vert_str = np.array_repr(self.vertices).replace('\n', '\n' + (shift + 9)*' ')
-        # faces_str = np.array_repr(self.faces).replace('\n', '\n' + (shift + 6)*' ')
-        # return f"{self.__class__.__name__}(\n{' '*shift}vertices={vert_str},\n{' '*shift}faces={faces_str}\n{' '*shift}name=\"{self.name}\"\n)"
-        return (f"{self.__class__.__name__}(vertices=[[... {self.nb_vertices} vertices ...]], "
-                f"faces=[[... {self.nb_faces} faces ...]], name=\"{self.name}\")")
+    def __repr__(self) -> str:
+        return self.__str__()
 
     def _repr_pretty_(self, p, cycle):
         p.text(self.__str__())
@@ -89,677 +194,438 @@ class Mesh(ClippableMixin, SurfaceIntegralsMixin, Abstract3DObject):
                 return "[[... {} {} ...]]".format(self.n, self.kind)
         yield "vertices", CustomRepr(self.nb_vertices, "vertices")
         yield "faces", CustomRepr(self.nb_faces, "faces")
+        yield "quadrature_method", self.quadrature_method
         yield "name", self.name
 
-    @property
-    def nb_vertices(self) -> int:
-        """Get the number of vertices in the mesh."""
-        return self._vertices.shape[0]
+    def show(self, *, backend=None, **kwargs):
+        """Visualize the mesh using the specified backend.
 
-    @property
-    def vertices(self) -> np.ndarray:
-        """Get the vertices array coordinate of the mesh."""
-        return self._vertices
+        Parameters
+        ----------
+        backend : str, optional
+            Visualization backend to use. Options are 'pyvista' or 'matplotlib'.
+            By default, try several until an installed one is found.
+        normal_vectors: bool, optional
+            If True, display normal vectors on each face.
+        **kwargs
+            Additional keyword arguments passed to the visualization backend.
+            See :mod:`~capytaine.meshes.visualization`
 
-    @vertices.setter
-    def vertices(self, value) -> None:
-        self._vertices = np.array(value, dtype=float)
-        assert self._vertices.shape[1] == 3, \
-            "Vertices of a mesh should be provided as a sequence of 3-ple."
-        self.__internals__.clear()
+        Returns
+        -------
+        object
+            Visualization object returned by the backend (e.g., matplotlib figure).
 
-    @property
-    def nb_faces(self) -> int:
-        """Get the number of faces in the mesh."""
-        return self._faces.shape[0]
+        Raises
+        ------
+        NotImplementedError
+            If the specified backend is not supported.
+        """
+        return show_3d(self, backend=backend, **kwargs)
 
-    @property
-    def faces(self) -> np.ndarray:
-        """Get the faces connectivity array of the mesh."""
-        return self._faces
-
-    @faces.setter
-    def faces(self, faces):
-        faces = np.array(faces, dtype=int)
-        assert np.all(faces >= 0), \
-            "Faces of a mesh should be provided as positive integers (ids of vertices)"
-        assert faces.shape[1] == 4, \
-            "Faces of a mesh should be provided as a sequence of 4-ple."
-        assert len(faces) == 0 or faces.max()+1 <= self.nb_vertices, \
-            "The array of faces should only reference vertices that are in the mesh."
-        self._faces = faces
-        self.__internals__.clear()
-
-    def copy(self, name=None) -> 'Mesh':
-        """Get a copy of the current mesh instance.
+
+    ## INITIALISATION
+
+    @staticmethod
+    def _has_leading_count_column(arr: np.ndarray) -> bool:
+        """Check if a 2D array has a leading column containing vertex counts.
 
         Parameters
         ----------
-        name : string, optional
-            a name for the new mesh
+        arr : np.ndarray
+            2D array of face data
 
         Returns
         -------
-        Mesh
-            mesh instance copy
+        bool
+            True if the first column appears to be vertex counts
         """
-        from copy import deepcopy
-        new_mesh = deepcopy(self)
-        if name is not None:
-            new_mesh.name = name
-        return new_mesh
-
-    def merged(self):
-        """Dummy method to be generalized for collections of meshes."""
-        return self
-
-    def tree_view(self, **kwargs):
-        """Dummy method to be generalized for collections of meshes."""
-        return self.__short_str__()
-
-    def path_to_leaf(self):
-        """Dummy method to be generalized for collection of meshes."""
-        return [[]]
-
-    def to_meshmagick(self):
-        """Convert the Mesh object as a Mesh object from meshmagick.
-        Mostly for debugging."""
-        from meshmagick.mesh import Mesh
-        meshmagick_mesh = Mesh(self.vertices, self.faces, name=self.name)
-        meshmagick_mesh.heal_mesh()
-        return meshmagick_mesh
-
-    ##################
-    #  Extract face  #
-    ##################
-
-    def get_face(self, face_id):
-        """Get the face described by its vertices connectivity.
+        if arr.ndim != 2 or arr.shape[1] <= 3:
+            return False
+
+        expected_count = arr.shape[1] - 1
+        for row in arr:
+            # Check if first value could be a vertex count (3 or 4)
+            # and if it matches the expected count (total cols - 1)
+            if row[0] != expected_count and row[0] not in [3, 4]:
+                return False
+        return True
+
+    def _process_faces(self, faces: List[List[int]] | np.ndarray) -> List[List[int]]:
+        """Process the faces input for the Mesh class.
 
         Parameters
         ----------
-        face_id : int
-            Face id
+        faces : np.ndarray or list
+            The faces data to process.
 
         Returns
         -------
-        ndarray
-            If the face is a triangle, the array has 3 components, else it has 4 (quadrangle)
+        list
+            A list of faces, where each face is a list of vertex indices.
+
+        Notes
+        -----
+        If the input is a 2D array with a leading column containing face vertex counts
+        (e.g., [[3, v1, v2, v3], [4, v1, v2, v3, v4]]), the count column will be
+        automatically stripped. This is checked per-row to support mixed triangle/quad meshes.
         """
-        if self.is_triangle(face_id):
-            return self._faces[face_id, :3]
+        if faces is None:
+            return []
+        elif isinstance(faces, list):
+            # assume it's already a list of lists of ints
+            return [list(f) for f in faces]
         else:
-            return self._faces[face_id]
-
-    def extract_one_face(self, id_face):
-        vertices = self.vertices[self.faces[id_face, :], :]
-        mesh = Mesh(vertices=vertices, faces=np.array([[0, 1, 2, 3]]), name=f"single_face_from_{self.name}")
-
-        for prop in self.__internals__:
-            if prop[:4] == "face":
-                mesh.__internals__[prop] = self.__internals__[prop][[id_face]]
-
-        return mesh
-
-    def extract_faces(self, id_faces_to_extract, return_index=False, name=None):
+            # fallback: convert array → nested list
+            arr = np.asarray(faces, dtype=int)
+
+            # Detect & strip a leading "count" column if present
+            if self._has_leading_count_column(arr):
+                arr = arr[:, 1:]
+
+            return arr.tolist()
+
+    @classmethod
+    def from_list_of_faces(
+        cls,
+        list_faces,
+        *,
+        quadrature_method=None,
+        faces_metadata=None,
+        name=None,
+        auto_clean=True,
+        auto_check=True
+    ) -> "Mesh":
         """
-        Extracts a new mesh from a selection of faces ids
+        Create a Mesh instance from a list of faces defined by vertex coordinates.
 
         Parameters
         ----------
-        id_faces_to_extract : ndarray
-            Indices of faces that have to be extracted
-        return_index: bool, optional
-            Flag to output old indices
-        name: string, optional
-            Name for the new mesh
+        list_faces : list of list of list of float
+            Each face is defined by a list of 3D coordinates. For example:
+            [
+                [[x1, y1, z1], [x2, y2, z2], [x3, y3, z3]],
+                [[x4, y4, z4], [x5, y5, z5], [x6, y6, z6]]
+            ]
+        faces_metadata: Optional[Dict[str, np.ndarray]]
+        name: str, optional
+            A name for the new mesh.
+        auto_clean : bool, optional
+            Whether to automatically clean the mesh upon initialization. Defaults to True.
+        auto_check : bool, optional
+            Whether to automatically check mesh quality upon initialization. Defaults to True.
 
         Returns
         -------
         Mesh
-            A new Mesh instance composed of the extracted faces
+            An instance of Mesh with:
+            - unique vertices extracted from the input
+            - faces defined as indices into the vertex array
         """
-        nv = self.nb_vertices
-
-        # Determination of the vertices to keep
-        vertices_mask = np.zeros(nv, dtype=bool)
-        vertices_mask[self._faces[id_faces_to_extract].flatten()] = True
-        id_v = np.arange(nv)[vertices_mask]
+        unique_vertices = []
+        vertices_map = {}
+        indexed_faces = []
+
+        for face in list_faces:
+            indexed_face = []
+            for coord in face:
+                key = tuple(coord)
+                if key not in vertices_map:
+                    vertices_map[key] = len(unique_vertices)
+                    unique_vertices.append(coord)
+                indexed_face.append(vertices_map[key])
+            indexed_faces.append(indexed_face)
+
+        return cls(
+            vertices=np.array(unique_vertices),
+            faces=indexed_faces,
+            quadrature_method=quadrature_method,
+            faces_metadata=faces_metadata,
+            name=name
+        )
+
+    def as_list_of_faces(self) -> List[List[List[float]]]:
+        """
+        Convert the Mesh instance to a list of faces defined by vertex coordinates.
 
-        # Building up the vertex array
-        v_extracted = self._vertices[id_v]
-        new_id__v = np.arange(nv)
-        new_id__v[id_v] = np.arange(len(id_v))
+        Returns
+        -------
+        list of list of list of float
+            Each face is defined by a list of 3D coordinates. For example:
+            [
+                [[x1, y1, z1], [x2, y2, z2], [x3, y3, z3]],
+                [[x4, y4, z4], [x5, y5, z5], [x6, y6, z6]]
+            ]
+        """
+        list_faces = []
+        for face in self._faces:
+            face_coords = [self.vertices[idx].tolist() for idx in face]
+            list_faces.append(face_coords)
+        if len(self.faces_metadata) > 0:
+            LOG.debug(f"Dropping metadata of {self} to export as list of faces.")
+        return list_faces
+
+    def as_array_of_faces(self) -> np.ndarray:
+        """Similar to as_list_of_faces but returns an array of shape
+        (nb_faces, 3, 3) if only triangles, or (nb_faces, 4, 3) otherwise.
+        """
+        array = self.vertices[self.faces[:, :], :]
+        if self.nb_quads == 0:
+            array = array[:, :3, :]
+        return array
 
-        faces_extracted = self._faces[id_faces_to_extract]
-        faces_extracted = new_id__v[faces_extracted.flatten()].reshape((len(id_faces_to_extract), 4))
+    def export(self, format, **kwargs):
+        return export_mesh(self, format, **kwargs)
 
-        extracted_mesh = Mesh(v_extracted, faces_extracted)
+    ## INTERFACE FOR BEM SOLVER
 
-        for prop in self.__internals__:
-            if prop[:4] == "face":
-                extracted_mesh.__internals__[prop] = self.__internals__[prop][id_faces_to_extract]
+    @cached_property
+    def faces_vertices_centers(self) -> np.ndarray:
+        """Calculate the center of vertices that form the faces.
 
-        if name is None:
-            if self.name is not None and self.name.startswith("mesh_extracted_from_"):
-                extracted_mesh.name = self.name
+        Returns
+        -------
+        np.ndarray
+            Array of shape (n_faces, 3) containing the centroid of each face's vertices.
+        """
+        centers_vertices = []
+        for face in self._faces:
+            if face[3] != face[2]:
+                a, b, c, d = get_vertices_face(face, self.vertices)
+                mean = (a + b + c + d) / 4
+                centers_vertices.append(mean)
             else:
-                extracted_mesh.name = f"mesh_extracted_from_{self.name}"
-        else:
-            extracted_mesh.name = name
-
-        if return_index:
-            return extracted_mesh, id_v
-        else:
-            return extracted_mesh
-
-    def sliced_by_plane(self, plane: Plane):
-        from capytaine.meshes.collections import CollectionOfMeshes
-        faces_ids_on_one_side = np.where(plane.distance_to_point(self.faces_centers) < 0)[0]
-        if len(faces_ids_on_one_side) == 0 or len(faces_ids_on_one_side) == self.nb_faces:
-            return self.copy()
-        else:
-            mesh_part_1 = self.extract_faces(faces_ids_on_one_side)
-            mesh_part_2 = self.extract_faces(list(set(range(self.nb_faces)) - set(faces_ids_on_one_side)))
-            return CollectionOfMeshes([mesh_part_1, mesh_part_2],
-                                      name=f"{self.name}_splitted_by_{plane}")
+                a, b, c = get_vertices_face(face, self.vertices)
+                mean = (a + b + c) / 3
+                centers_vertices.append(mean)
+        return np.array(centers_vertices)
 
+    @cached_property
+    def faces_normals(self) -> np.ndarray:
+        """Normal vectors for each face.
 
-    #####################
-    #  Mean and radius  #
-    #####################
-
-    @property
-    def center_of_mass_of_nodes(self):
-        """(Non-weighted) center of mass of the nodes of the mesh."""
-        if 'center_of_mass_of_nodes' not in self.__internals__:
-            center_of_mass_of_nodes = np.mean(self.vertices, axis=0)
-            self.__internals__['center_of_mass_of_nodes'] = center_of_mass_of_nodes
-            return center_of_mass_of_nodes
-        return self.__internals__['center_of_mass_of_nodes']
-
-    @property
-    def diameter_of_nodes(self):
-        """Maximum distance between two nodes of the mesh."""
-        if 'diameter_of_nodes' not in self.__internals__:
-            diameter_of_nodes = 2*np.max(
-                np.linalg.norm(self.vertices - self.center_of_mass_of_nodes, axis=-1)
-            )
-            self.__internals__['diameter_of_nodes'] = diameter_of_nodes
-            return diameter_of_nodes
-        return self.__internals__['diameter_of_nodes']
-
-    ######################
-    #  Faces properties  #
-    ######################
+        Returns
+        -------
+        np.ndarray
+            Array of shape (n_faces, 3) containing unit normal vectors.
+        """
+        return compute_faces_normals(self.vertices, self._faces)
 
-    @property
+    @cached_property
     def faces_areas(self) -> np.ndarray:
-        """Get the array of faces areas of the mesh."""
-        if 'faces_areas' not in self.__internals__:
-            self.__internals__.update(compute_faces_properties(self))
-        return self.__internals__['faces_areas']
+        """Surface area of each face.
 
-    @property
+        Returns
+        -------
+        np.ndarray
+            Array of shape (n_faces,) containing the area of each face.
+        """
+        return compute_faces_areas(self.vertices, self._faces)
+
+    @cached_property
     def faces_centers(self) -> np.ndarray:
-        """Get the array of faces centers of the mesh."""
-        if 'faces_centers' not in self.__internals__:
-            self.__internals__.update(compute_faces_properties(self))
-        return self.__internals__['faces_centers']
+        """Geometric centers of each face.
 
-    @property
-    def faces_normals(self) -> np.ndarray:
-        """Get the array of faces normals of the mesh."""
-        if 'faces_normals' not in self.__internals__:
-            self.__internals__.update(compute_faces_properties(self))
-        return self.__internals__['faces_normals']
+        Returns
+        -------
+        np.ndarray
+            Array of shape (n_faces, 3) containing the center point of each face.
+        """
+        return compute_faces_centers(self.vertices, self._faces)
 
-    @property
+    @cached_property
     def faces_radiuses(self) -> np.ndarray:
-        """Get the array of faces radiuses of the mesh."""
-        if 'faces_radiuses' not in self.__internals__:
-            self.__internals__.update(compute_faces_properties(self))
-        return self.__internals__['faces_radiuses']
-
-    @property
-    def quadrature_points(self):
-        if 'quadrature' not in self.__internals__:
-            self.compute_quadrature(self.quadrature_method)
-        return self.__internals__['quadrature']
-
-    def compute_quadrature(self, method):
-        self.heal_triangles()
-        all_faces = self.vertices[self.faces[:, :], :]
-        if method is None:
-            points = self.faces_centers.reshape((self.nb_faces, 1, 3))
-            weights = self.faces_areas.reshape((self.nb_faces, 1))
-        else:
-            points, weights = compute_quadrature_on_faces(all_faces, method)
-        self.__internals__['quadrature'] = (points, weights)
-        self.quadrature_method = method
-        return points, weights
-
+        """Radii of each face (circumradius or characteristic size).
 
-    ###############################
-    #  Triangles and quadrangles  #
-    ###############################
-
-    def is_triangle(self, face_id) -> bool:
-        """Returns if a face is a triangle
-
-        Parameters
-        ----------
-        face_id : int
-            Face id
+        Returns
+        -------
+        np.ndarray
+            Array of shape (n_faces,) containing the radius of each face.
         """
-        assert 0 <= face_id < self.nb_faces
-        return self._faces[face_id, 0] == self._faces[face_id, -1]
-
-    def _compute_triangles_quadrangles(self):
-        triangle_mask = (self._faces[:, 0] == self._faces[:, -1])
-        quadrangles_mask = np.invert(triangle_mask)
-        triangles_quadrangles = {'triangles_ids': np.where(triangle_mask)[0],
-                                 'quadrangles_ids': np.where(quadrangles_mask)[0]}
-        self.__internals__.update(triangles_quadrangles)
+        return compute_faces_radii(self.vertices, self._faces)
 
-    @property
-    def triangles_ids(self) -> np.ndarray:
-        """Get the array of ids of triangle shaped faces."""
-        if 'triangles_ids' not in self.__internals__:
-            self._compute_triangles_quadrangles()
-        return self.__internals__['triangles_ids']
-
-    @property
-    def nb_triangles(self) -> int:
-        """Get the number of triangles in the mesh."""
-        if 'triangles_ids'not in self.__internals__:
-            self._compute_triangles_quadrangles()
-        return len(self.__internals__['triangles_ids'])
-
-    @property
-    def quadrangles_ids(self) -> np.ndarray:
-        """Get the array of ids of quadrangle shaped faces."""
-        if 'triangles_ids' not in self.__internals__:
-            self._compute_triangles_quadrangles()
-        return self.__internals__['quadrangles_ids']
-
-    @property
-    def nb_quadrangles(self) -> int:
-        """Get the number of quadrangles in the mesh."""
-        if 'triangles_ids' not in self.__internals__:
-            self._compute_triangles_quadrangles()
-        return len(self.__internals__['quadrangles_ids'])
-
-    #############
-    #  Display  #
-    #############
-
-    @property
-    def axis_aligned_bbox(self):
-        """Get the axis aligned bounding box of the mesh.
+    @cached_property
+    def faces(self) -> np.ndarray:
+        """Face connectivity as quadrilateral array.
 
         Returns
         -------
-        tuple
-            (xmin, xmax, ymin, ymax, zmin, zmax)
+        np.ndarray
+            Array of shape (n_faces, 4) where triangular faces are padded
+            by repeating the last vertex.
+
+        Notes
+        -----
+        This property converts all faces to a uniform quad representation
+        for compatibility with libraries expecting fixed-width face arrays.
         """
-        if self.nb_vertices > 0:
-            x, y, z = self._vertices.T
-            return (x.min(), x.max(),
-                    y.min(), y.max(),
-                    z.min(), z.max())
-        else:
-            return tuple(np.zeros(6))
+        faces_as_quad = [f if len(f) == 4 else f + [f[-1]] for f in self._faces]
+        return np.array(faces_as_quad, dtype=int)
 
-    @property
-    def squared_axis_aligned_bbox(self):
-        """Get a squared axis aligned bounding box of the mesh.
+    @cached_property
+    def quadrature_points(self) -> Tuple[np.ndarray, np.ndarray]:
+        """Quadrature points and weights for numerical integration.
 
         Returns
         -------
-        tuple
-            (xmin, xmax, ymin, ymax, zmin, zmax)
-
-        Note
-        ----
-        This method differs from `axis_aligned_bbox()` by the fact that
-        the bounding box that is returned is squared but have the same center as the `axis_aligned_bbox()`.
+        tuple[np.ndarray, np.ndarray]
+            (points, weights) where points has shape (n_faces, 1, 3) and
+            weights has shape (n_faces, 1), using face centers and areas.
         """
-        xmin, xmax, ymin, ymax, zmin, zmax = self.axis_aligned_bbox
-        (x0, y0, z0) = np.array([xmin+xmax, ymin+ymax, zmin+zmax]) * 0.5
-        d = (np.array([xmax-xmin, ymax-ymin, zmax-zmin]) * 0.5).max()
-
-        return x0-d, x0+d, y0-d, y0+d, z0-d, z0+d
-
-    def show(self, **kwargs):
-        self.show_vtk(**kwargs)
-
-    def show_vtk(self, **kwargs):
-        """Shows the mesh in the vtk viewer"""
-        from capytaine.ui.vtk.mesh_viewer import MeshViewer
-
-        viewer = MeshViewer()
-        viewer.add_mesh(self, **kwargs)
-        viewer.show()
-        viewer.finalize()
+        if self.quadrature_method is None:
+            return (self.faces_centers.reshape((-1, 1, 3)), self.faces_areas.reshape(-1, 1))
+        elif self.quadrature_method == "Gauss-Legendre 2":
+            return compute_gauss_legendre_2_quadrature(self.vertices, self.faces)
+        else:
+            raise ValueError(f"Unknown quadrature_method: {self.quadrature_method}")
+
+    ## TRANSFORMATIONS
+
+    def with_quadrature(self, quadrature_method):
+        return Mesh(
+                self.vertices,
+                self.faces,
+                faces_metadata=self.faces_metadata,
+                quadrature_method=quadrature_method,
+                name=self.name,
+                auto_clean=False,
+                auto_check=False
+                )
 
-    def show_matplotlib(self, ax=None,
-                        normal_vectors=False, scale_normal_vector=None,
-                        saveas=None, color_field=None, cmap=None,
-                        cbar_label=None,
-                        **kwargs):
-        """Poor man's viewer with matplotlib.
+    def extract_faces(self, faces_id, *, name=None) -> "Mesh":
+        """Extract a subset of faces by their indices and return a new Mesh instance.
 
         Parameters
         ----------
-        ax: matplotlib axis
-            The 3d axis in which to plot the mesh. If not provided, create a new one.
-        normal_vectors: bool
-            If True, print normal vector.
-        scale_normal_vector: array of shape (nb_faces, )
-            Scale separately each of the normal vectors.
-        saveas: str
-            File path where to save the image.
-        color_field: array of shape (nb_faces, )
-            Scalar field to be plot on the mesh (optional).
-        cmap: matplotlib colormap
-            Colormap to use for field plotting.
-        cbar_label: string
-            Label for colormap
-
-        Other parameters are passed to Poly3DCollection.
+        faces_id : array_like
+            Indices of faces to extract.
+        name: str, optional
+            A name for the new mesh
+
+        Returns
+        -------
+        Mesh
+            New mesh containing only the specified faces.
         """
-        matplotlib = import_optional_dependency("matplotlib")
-        import importlib
-        plt = importlib.import_module("matplotlib.pyplot")
-        cm = importlib.import_module("matplotlib.cm")
-
-        mpl_toolkits = import_optional_dependency("mpl_toolkits", package_name="matplotlib")
-        Poly3DCollection = mpl_toolkits.mplot3d.art3d.Poly3DCollection
-
-        default_axis = ax is None
-        if default_axis:
-            fig = plt.figure()
-            ax = fig.add_subplot(111, projection="3d")
-
-        faces = []
-        for face in self.faces:
-            vertices = []
-            for index_vertex in face:
-                vertices.append(self.vertices[int(index_vertex), :])
-            faces.append(vertices)
-
-        if color_field is None:
-            if 'facecolors' not in kwargs:
-                kwargs['facecolors'] = "yellow"
+        if isinstance(faces_id, np.ndarray):
+            faces_id = faces_id.ravel()
+        all_faces = self.as_list_of_faces()
+        selected_faces = [all_faces[i] for i in faces_id]
+        return Mesh.from_list_of_faces(
+            selected_faces,
+            faces_metadata={k: self.faces_metadata[k][selected_faces, ...] for k in self.faces_metadata},
+            name=name,
+            quadrature_method=self.quadrature_method,
+            auto_clean=False,
+            auto_check=False
+        )
+
+    def translated(self, shift, *, name=None) -> "Mesh":
+        """Return a new Mesh translated along vector-like `shift`."""
+        return Mesh(
+            vertices=self.vertices + np.asarray(shift),
+            faces=self._faces,
+            faces_metadata=self.faces_metadata,
+            name=name,
+            quadrature_method=self.quadrature_method,
+            auto_clean=False,
+            auto_check=False,
+        )
+
+    def rotated_with_matrix(self, R, *, name=None) -> "Mesh":
+        """Return a new Mesh rotated using the provided 3×3 rotation matrix."""
+        new_vertices = self.vertices @ R.T
+        return Mesh(
+            vertices=new_vertices,
+            faces=self._faces,
+            name=name,
+            faces_metadata=self.faces_metadata,
+            quadrature_method=self.quadrature_method,
+            auto_clean=False,
+            auto_check=False,
+        )
+
+    def mirrored(self, plane: Literal['xOz', 'yOz'], *, name=None) -> "Mesh":
+        new_vertices = self.vertices.copy()
+        if plane == "xOz":
+            new_vertices[:, 1] *= -1
+        elif plane == "yOz":
+            new_vertices[:, 0] *= -1
         else:
-            if cmap is None:
-                cmap = matplotlib.colormaps['coolwarm']
-            m = cm.ScalarMappable(cmap=cmap)
-            m.set_array([min(color_field), max(color_field)])
-            m.set_clim(vmin=min(color_field), vmax=max(color_field))
-            colors = m.to_rgba(color_field)
-            kwargs['facecolors'] = colors
-        if 'edgecolor' not in kwargs:
-            kwargs['edgecolor'] = 'k'
-
-        ax.add_collection3d(Poly3DCollection(faces, **kwargs))
-
-        if color_field is not None:
-            cbar = plt.colorbar(m, ax=ax)
-            if cbar_label is not None:
-                cbar.set_label(cbar_label)
-
-
-
-        # Plot normal vectors.
-        if normal_vectors:
-            if scale_normal_vector is not None:
-                vectors = (scale_normal_vector * self.faces_normals.T).T
-            else:
-                vectors = self.faces_normals
-            ax.quiver(*zip(*self.faces_centers), *zip(*vectors), length=0.2)
-
-
-        ax.set_xlabel("x")
-        ax.set_ylabel("y")
-        ax.set_zlabel("z")
-
-        xmin, xmax, ymin, ymax, zmin, zmax = self.squared_axis_aligned_bbox
-        ax.set_xlim(xmin, xmax)
-        ax.set_ylim(ymin, ymax)
-        ax.set_zlim(zmin, zmax)
-
-        if default_axis:
-            if saveas is not None:
-                plt.tight_layout()
-                plt.savefig(saveas)
-            else:
-                plt.show()
-
-    ################################
-    #  Transformation of the mesh  #
-    ################################
-
-    @inplace_transformation
-    def translate(self, vector) -> 'Mesh':
-        """Translates the mesh in 3D giving the 3 distances along coordinate axes.
+            raise ValueError(f"Unsupported value for plane: {plane}")
+        new_faces = [f[::-1] for f in self._faces]  # Invert normals
+        if name is None and self.name is not None:
+            name = f"mirrored_{self.name}"
+        return Mesh(
+            new_vertices,
+            new_faces,
+            faces_metadata=self.faces_metadata,
+            quadrature_method=self.quadrature_method,
+            name=name,
+            auto_clean=False,
+            auto_check=False
+        )
+
+    def join_meshes(*meshes: List["Mesh"], return_masks=False, name=None) -> "Mesh":
+        """Join several meshes and return a new Mesh instance.
 
         Parameters
         ----------
-        vector : array_like
-            translation vector
-        """
-        vector = np.asarray(vector, dtype=float)
-        assert vector.shape == (3,), "The translation vector should be given as a 3-ple of values."
-
-        self.vertices += vector
-
-        return self
+        meshes: List[Mesh]
+            Meshes to be joined
+        return_masks: bool, optional
+            If True, additionally return a list of numpy masks establishing the
+            origin of each face in the new mesh.
+            (Default: False)
+        name: str, optional
+            A name for the new object
 
-    @inplace_transformation
-    def rotate(self, axis, angle) -> 'Mesh':
-        """Rotate the mesh of a given angle around an axis.
+        Returns
+        -------
+        Mesh
+            New mesh containing vertices and faces from all meshes.
 
-        Parameters
-        ----------
-        axis : Axis
-        angle : float
+        See Also
+        --------
+        __add__ : Implements the + operator for mesh joining.
         """
+        if not all(isinstance(m, Mesh) for m in meshes):
+            raise TypeError("Only Mesh instances can be added together.")
 
-        self._vertices = axis.rotate_points(self._vertices, angle)
-
-        return self
+        faces = sum((m.as_list_of_faces() for m in meshes), [])
 
-    # OTHER
-    @inplace_transformation
-    def flip_normals(self) -> 'Mesh':
-        """Flips every normals of the mesh."""
+        if return_masks:
+            # Add a temporary metadata to keep track of the origin of each face
+            meshes = [m.with_metadata(origin_mesh_index=np.array([i]*m.nb_faces))
+                      for i, m in enumerate(meshes)]
 
-        self._faces = np.fliplr(self._faces)
+        faces_metadata = {k: np.concatenate([m.faces_metadata[k] for m in meshes], axis=0)
+                             for k in AbstractMesh._common_metadata_keys(*meshes)}
 
-        return self
-
-    @inplace_transformation
-    def mirror(self, plane) -> 'Mesh':
-        """Flip the mesh with respect to a plane.
-
-        Parameters
-        ----------
-        plane : Plane
-            The mirroring plane
-        """
-        self.vertices -= 2 * np.outer(np.dot(self.vertices, plane.normal) - plane.c, plane.normal)
-        self.flip_normals()
-        return self
-
-    def symmetrized(self, plane):
-        from capytaine.meshes.symmetric import ReflectionSymmetricMesh
-        half = self.clipped(plane, name=f"{self.name}_half")
-        return ReflectionSymmetricMesh(half, plane=plane, name=f"symmetrized_of_{self.name}")
-
-    @inplace_transformation
-    def clip(self, plane) -> 'Mesh':
-        from capytaine.meshes.clipper import clip
-        clipped_self = clip(self, plane=plane)
-        self.vertices = clipped_self.vertices
-        self.faces = clipped_self.faces
-        self._clipping_data = clipped_self._clipping_data
-        return self
-
-    @inplace_transformation
-    def triangulate_quadrangles(self) -> 'Mesh':
-        """Triangulates every quadrangles of the mesh by simple splitting.
-        Each quadrangle gives two triangles.
-
-        Note
-        ----
-        No checking on the triangle quality is done.
-        """
-        # Defining both triangles id lists to be generated from quadrangles
-        t1 = (0, 1, 2)
-        t2 = (0, 2, 3)
-
-        faces = self._faces
-
-        # Triangulation
-        new_faces = faces[self.quadrangles_ids].copy()
-        new_faces[:, :3] = new_faces[:, t1]
-        new_faces[:, -1] = new_faces[:, 0]
-
-        faces[self.quadrangles_ids, :3] = faces[:, t2][self.quadrangles_ids]
-        faces[self.quadrangles_ids, -1] = faces[self.quadrangles_ids, 0]
-
-        faces = np.concatenate((faces, new_faces))
-
-        LOG.info('\nTriangulating quadrangles')
-        if self.nb_quadrangles != 0:
-            LOG.info('\t-->{:d} quadrangles have been split in triangles'.format(self.nb_quadrangles))
-
-        self._faces = faces
-
-        return self
-
-    ####################
-    #  Combine meshes  #
-    ####################
-
-    def join_meshes(*meshes, name=None):
-        from capytaine.meshes.collections import CollectionOfMeshes
-        return CollectionOfMeshes(meshes, name=name).merged()
-
-    def __add__(self, mesh_to_add) -> 'Mesh':
-        return self.join_meshes(mesh_to_add)
-
-    ####################
-    #  Compare meshes  #
-    ####################
-    # The objective is to write a mesh as a set of faces in order to check for equality or to
-    # compute differences of meshes. Each face can be represented as a 4x3 array (4 triplets of
-    # coordinates).
-    # However, it is tricky on several aspects:
-    #   * The builtin set class compares the hashes of its objects. Since numpy ndarray are not
-    #   hashable, the 4x3 array can be transformed into a tuple of tuples (which is hashable).
-    #   * Two faces with different numbering of the faces (but the same ordering) are recorded as
-    #   different.
-    #   * Two vertices equal up to machine precision can be recorded as different, due to rounding
-    #   errors.
-    #
-    # A possible solution is to define a Face class and a Vertex class with the appropriate __eq__
-    # and __hash__.
-    #
-    # The current implementation below is a rough draft.
-    # However, the equality shall still be use for testing.
-
-    def as_set_of_faces(self):
-        return frozenset(frozenset(tuple(vertex) for vertex in face) for face in self.vertices[self.faces])
-
-    @staticmethod
-    def from_set_of_faces(set_of_faces):
-        faces = []
-        vertices = []
-        for face in set_of_faces:
-            ids_of_vertices_in_face = []
-
-            for vertex in face:
-                if vertex not in vertices:
-                    i = len(vertices)
-                    vertices.append(vertex)
-                else:
-                    i = vertices.index(vertex)
-                ids_of_vertices_in_face.append(i)
-
-            if len(ids_of_vertices_in_face) == 3:
-                # Add a fourth node identical to the first one
-                ids_of_vertices_in_face.append(ids_of_vertices_in_face[0])
-
-            faces.append(ids_of_vertices_in_face)
-        return Mesh(vertices=vertices, faces=faces)
-
-    def __eq__(self, other):
-        if not isinstance(other, Mesh):
-            return NotImplemented
+        if all(meshes[0].quadrature_method == m.quadrature_method for m in meshes[1:]):
+            quadrature_method = meshes[0].quadrature_method
         else:
-            return self.as_set_of_faces() == other.as_set_of_faces()
-
-    def __hash__(self):
-        if 'hash' not in self.__internals__:
-            self.__internals__['hash'] = hash(self.as_set_of_faces())
-        return self.__internals__['hash']
-
-    ##################
-    #  Mesh quality  #
-    ##################
-
-    def merge_duplicates(self, **kwargs):
-        return merge_duplicates(self, **kwargs)
-
-    def heal_normals(self, **kwargs):
-        return heal_normals(self, **kwargs)
-
-    def remove_unused_vertices(self, **kwargs):
-        return remove_unused_vertices(self, **kwargs)
-
-    def heal_triangles(self, **kwargs):
-        return heal_triangles(self, **kwargs)
-
-    def remove_degenerated_faces(self, **kwargs):
-        return remove_degenerated_faces(self, **kwargs)
-
-    @inplace_transformation
-    def heal_mesh(self, closed_mesh=True):
-        """Heals the mesh for different tests available.
-
-        It applies:
-
-        * Unused vertices removal
-        * Degenerate faces removal
-        * Duplicate vertices merging
-        * Triangles healing
-        * Normal healing
-        """
-        self.remove_unused_vertices()
-        self.remove_degenerated_faces()
-        self.merge_duplicates()
-        self.heal_triangles()
-        if closed_mesh:
-            self.heal_normals()
-        return self
-
-    ##########
-    #  Lids  #
-    ##########
-
-    def lowest_lid_position(self, omega_max, *, g=9.81):
-        z_lid = 0.0
-        for comp in connected_components(self):
-            for ccomp in connected_components_of_waterline(comp):
-                x_span = ccomp.vertices[:, 0].max() - ccomp.vertices[:, 0].min()
-                y_span = ccomp.vertices[:, 1].max() - ccomp.vertices[:, 1].min()
-                p = np.hypot(1/x_span, 1/y_span)
-                z_lid_comp = -np.arctanh(np.pi*g*p/omega_max**2) / (np.pi * p)
-                z_lid = min(z_lid, z_lid_comp)
-        return 0.9*z_lid  # Add a small safety margin
+            LOG.info("Dropping inconsistent quadrature method when joining meshes")
+            quadrature_method = None
+
+        if name is None and all(m.name is not None for m in meshes):
+            name = "+".join([m.name for m in meshes])
+
+        joined_mesh = Mesh.from_list_of_faces(
+            faces,
+            quadrature_method=quadrature_method,
+            faces_metadata=faces_metadata,
+            name=name,
+            auto_check=False,
+        )
+        # If list of faces is trimmed for some reason, metadata will be updated accordingly
+
+        if return_masks:
+            # Extract the temporary metadata
+            masks = [joined_mesh.faces_metadata['origin_mesh_index'] == i for i in range(len(meshes))]
+            return joined_mesh.without_metadata('origin_mesh_index'), masks
+        else:
+            return joined_mesh
 
     def generate_lid(self, z=0.0, faces_max_radius=None, name=None):
         """
@@ -782,12 +648,17 @@ class Mesh(ClippableMixin, SurfaceIntegralsMixin, Abstract3DObject):
         """
         from capytaine.meshes.predefined.rectangles import mesh_rectangle
 
-        clipped_hull_mesh = self.clipped(Plane(normal=(0, 0, 1), point=(0, 0, z)))
+        LOG.debug(f"Generating lid for {self.__str__()}")
+
+        if name is None and self.name is not None:
+            name = "lid for {}".format(self.name)
+
+        clipped_hull_mesh = self.clipped(normal=(0, 0, 1), origin=(0, 0, z))
         # Alternatively: could keep only faces below z without proper clipping,
         # and it would work similarly.
 
         if clipped_hull_mesh.nb_faces == 0:
-            return Mesh(None, None, name="lid for {}".format(self.name))
+            return Mesh(None, None, name=name)
 
         x_span = clipped_hull_mesh.vertices[:, 0].max() - clipped_hull_mesh.vertices[:, 0].min()
         y_span = clipped_hull_mesh.vertices[:, 1].max() - clipped_hull_mesh.vertices[:, 1].min()
@@ -808,6 +679,7 @@ class Mesh(ClippableMixin, SurfaceIntegralsMixin, Abstract3DObject):
                 faces_max_radius=faces_max_radius,
                 center=(x_mean, y_mean, z),
                 normal=(0.0, 0.0, -1.0),
+                name="candidate_lid_mesh"
                 )
 
         candidate_lid_points = candidate_lid_mesh.vertices[:, 0:2]
@@ -833,34 +705,13 @@ class Mesh(ClippableMixin, SurfaceIntegralsMixin, Abstract3DObject):
 
         lid_faces = candidate_lid_mesh.faces[np.all(np.isin(candidate_lid_mesh.faces, needs_lid), axis=-1), :]
 
-        if name is None:
-            name = "lid for {}".format(self.name)
-
         if len(lid_faces) == 0:
             return Mesh(None, None, name=name)
 
-        lid_mesh = Mesh(candidate_lid_mesh.vertices, lid_faces, name=name)
-        lid_mesh.heal_mesh()
-
+        lid_mesh = Mesh(candidate_lid_mesh.vertices, lid_faces, name=name, auto_check=False)
         return lid_mesh
 
-    @inplace_transformation
-    def with_normal_vector_going_down(self):
-        # For lid meshes for irregular frequencies removal
-        if np.allclose(self.faces_normals[:, 2], np.ones((self.nb_faces,))):
-            # The mesh is horizontal with normal vectors going up
-            LOG.warning(f"Inverting the direction of the normal vectors of {self} to be downward.")
-            self.faces = self.faces[:, ::-1]
-        else:
-            return self
-
-    def _face_on_plane(self, i_face, plane):
-        return (
-                self.faces_centers[i_face, :] in plane
-                and plane.is_orthogonal_to(self.faces_normals[i_face, :])
-                )
-
-    def extract_lid(self, plane=xOy_Plane):
+    def extract_lid(self, z=0.0):
         """
         Split the mesh into a mesh of the hull and a mesh of the lid.
         By default, the lid is composed of the horizontal faces on the z=0 plane.
@@ -875,7 +726,101 @@ class Mesh(ClippableMixin, SurfaceIntegralsMixin, Abstract3DObject):
         2-ple of Mesh
             hull mesh and lid mesh
         """
-        faces_on_plane = [i_face for i_face in range(self.nb_faces) if self._face_on_plane(i_face, plane)]
+        def is_on_plane(i_face):
+            return np.isclose(self.faces_centers[i_face, 2], z) and (\
+                    np.allclose(self.faces_normals[i_face, :], np.array([0.0, 0.0, 1.0])) or \
+                    np.allclose(self.faces_normals[i_face, :], np.array([0.0, 0.0, -1.0]))
+                                                                     )
+
+        faces_on_plane = [
+            i_face for i_face in range(self.nb_faces) if is_on_plane(i_face)
+        ]
         lid_mesh = self.extract_faces(faces_on_plane)
         hull_mesh = self.extract_faces(list(set(range(self.nb_faces)) - set(faces_on_plane)))
         return hull_mesh, lid_mesh
+
+    def with_normal_vector_going_down(self, **kwargs) -> "Mesh":
+        # Kwargs are for backward compatibility with former inplace implementation of this.
+        # It could be removed in the final release.
+        """Ensure normal vectors point downward (negative z-direction).
+
+        Returns
+        -------
+        Mesh
+            Self if normals already point down, otherwise modifies face orientation.
+
+        Notes
+        -----
+        Used for lid meshes to avoid irregular frequency issues by ensuring
+        consistent normal vector direction.
+        """
+        # For lid meshes for irregular frequencies removal
+        if np.allclose(self.faces_normals[:, 2], np.ones((self.nb_faces,))):
+            # The mesh is horizontal with normal vectors going up
+            LOG.warning(
+                f"Inverting the direction of the normal vectors of {self} to be downward."
+            )
+            return Mesh(
+                vertices=self.vertices,
+                faces=self.faces[:, ::-1],
+                faces_metadata=self.faces_metadata,
+                quadrature_method=self.quadrature_method,
+                name=self.name,
+                auto_clean=False,
+                auto_check=False,
+            )
+        else:
+            return self
+
+    def copy(self, *, faces_metadata=None, name=None) -> Mesh:
+        # No-op for backward compatibility
+        if faces_metadata is None:
+            faces_metadata = self.faces_metadata.copy()
+        if name is None:
+            name = self.name
+        return Mesh(
+            vertices=self.vertices,
+            faces=self._faces,
+            faces_metadata=faces_metadata,
+            quadrature_method=self.quadrature_method,
+            name=name,
+            auto_clean=False,
+            auto_check=False
+        )
+
+    def merged(self, *, name=None) -> Mesh:
+        # No-op to be extended to symmetries
+        return self.copy(name=name)
+
+    def clipped(self, *, origin, normal, name=None) -> "Mesh":
+        """
+        Clip the mesh by a plane defined by `origin` and `normal`.
+
+        Parameters
+        ----------
+        origin : np.ndarray
+            The point in space where the clipping plane intersects (3D point).
+        normal : np.ndarray
+            The normal vector defining the orientation of the clipping plane.
+        name: Optional[str]
+            A name for the newly created mesh
+
+        Returns
+        -------
+        Mesh
+            A new Mesh instance that has been clipped.
+        """
+        LOG.debug(f"Clipping {self.__str__()} with origin={origin} and normal={normal}")
+        new_vertices, new_faces, face_parent = \
+                clip_faces(self.vertices, self._faces, normal, origin)
+        new_metadata = {k: self.faces_metadata[k][face_parent] for k in self.faces_metadata}
+        if name is None and self.name is not None:
+            name = f"{self.name}_clipped"
+        return Mesh(
+            vertices=new_vertices,
+            faces=new_faces,
+            faces_metadata=new_metadata,
+            quadrature_method=self.quadrature_method,
+            name=name,
+            auto_check=False,
+        )