capytaine 2.3.1__cp314-cp314-macosx_14_0_arm64.whl → 3.0.0a1__cp314-cp314-macosx_14_0_arm64.whl

capytaine/meshes/collections.py

@@ -1,342 +0,0 @@
-"""A set of meshes that can be used as a Mesh."""
-# Copyright (C) 2017-2019 Matthieu Ancellin
-# See LICENSE file at <https://github.com/mancellin/capytaine>
-
-import logging
-from itertools import chain, accumulate
-from functools import lru_cache
-from typing import Iterable, Union
-
-import numpy as np
-
-from capytaine.meshes.geometry import Abstract3DObject, ClippableMixin, inplace_transformation
-from capytaine.meshes.surface_integrals import SurfaceIntegralsMixin
-from capytaine.meshes.meshes import Mesh
-
-LOG = logging.getLogger(__name__)
-
-
-class CollectionOfMeshes(ClippableMixin, SurfaceIntegralsMixin, Abstract3DObject):
-    """A tuple of meshes.
-    It gives access to all the vertices of all the sub-meshes as if it were a mesh itself.
-    Collections can be nested to store meshes in a tree structure.
-
-    Parameters
-    ----------
-    meshes: Iterable of Mesh or CollectionOfMeshes
-        meshes in the collection
-    name : str, optional
-        a name for the collection
-    """
-
-    def __init__(self, meshes: Iterable[Union[Mesh, 'CollectionOfMeshes']], name=None):
-
-        self._meshes = tuple(meshes)
-
-        for mesh in self._meshes:
-            assert isinstance(mesh, Mesh) or isinstance(mesh, CollectionOfMeshes)
-
-        if name is None:
-            self.name = f'collection_of_meshes_{next(Mesh._ids)}'
-        else:
-            self.name = str(name)
-
-        LOG.debug(f"New collection of meshes: {repr(self)}")
-
-    def __short_str__(self):
-        return (f"{self.__class__.__name__}(..., name=\"{self.name}\")")
-
-    def __str__(self):
-        if len(self._meshes) < 3:
-            meshes_str = ', '.join(m.__short_str__() for m in self._meshes)
-        else:
-            meshes_str = self._meshes[0].__short_str__() + ", ..., " + self._meshes[-1].__short_str__()
-        return f"{self.__class__.__name__}([{meshes_str}], name=\"{self.name}\")"
-
-    def __repr__(self):
-        return f"{self.__class__.__name__}({', '.join(str(m) for m in self._meshes)}, name=\"{self.name}\")"
-
-    def _repr_pretty_(self, p, cycle):
-        p.text(self.__str__())
-
-    def __rich_repr__(self):
-        class WrappedString:
-            def __init__(self, s):
-                self.s = s
-            def __repr__(self):
-                return self.s
-        for m in self._meshes:
-            yield m
-        yield "name", self.name
-
-    def __iter__(self):
-        return iter(self._meshes)
-
-    def __len__(self):
-        return len(self._meshes)
-
-    def __getitem__(self, item):
-        return self._meshes.__getitem__(item)
-
-    def __eq__(self, other):
-        if isinstance(other, CollectionOfMeshes):
-            return self._meshes == other._meshes
-        else:
-            return NotImplemented
-
-    def __hash__(self):
-        return hash(self._meshes)
-
-    def tree_view(self, **kwargs):
-        body_tree_views = []
-        for i, mesh in enumerate(self):
-            tree_view = mesh.tree_view(**kwargs)
-            if i == len(self)-1:
-                prefix = ' └─'
-                shift  = '   '
-            else:
-                prefix = ' ├─'
-                shift  = ' │ '
-            body_tree_views.append(prefix + tree_view.replace('\n', '\n' + shift))
-
-        return self.__short_str__() + '\n' + '\n'.join(body_tree_views)
-
-    def path_to_leaf(self):
-        """
-        Builds a list of lists of paths from the collection corresponding to the
-        root of the tree to the submeshes corresponding to the leaves
-        """
-        ptl = []
-        for i, mesh in enumerate(self):
-           for path in mesh.path_to_leaf():
-               ptl.append([i] + path)
-        return ptl
-
-    def copy(self, name=None):
-        from copy import deepcopy
-        new_mesh = deepcopy(self)
-        if name is not None:
-            new_mesh.name = name
-        return new_mesh
-
-    @inplace_transformation
-    def heal_mesh(self, closed_mesh=False):
-        for mesh in self:
-            mesh.heal_mesh(closed_mesh=closed_mesh)
-
-    @inplace_transformation
-    def with_normal_vector_going_down(self):
-        for mesh in self:
-            mesh.with_normal_vector_going_down()
-
-    ##############
-    # Properties #
-    ##############
-
-    @property
-    def nb_submeshes(self):
-        return len(self)
-
-    @property
-    def nb_vertices(self):
-        return sum(mesh.nb_vertices for mesh in self)
-
-    @property
-    def nb_faces(self):
-        return sum(mesh.nb_faces for mesh in self)
-
-    @property
-    def volume(self):
-        return sum(mesh.volume for mesh in self)
-
-    @property
-    def vertices(self):
-        return np.concatenate([mesh.vertices for mesh in self])
-
-    @property
-    def faces(self):
-        """Return the indices of the vertices forming each of the faces. For the
-        later submeshes, the indices of the vertices has to be shifted to
-        correspond to their index in the concatenated array self.vertices.
-        """
-        nb_vertices = accumulate(chain([0], (mesh.nb_vertices for mesh in self[:-1])))
-        return np.concatenate([mesh.faces + nbv for mesh, nbv in zip(self, nb_vertices)])
-
-    @property
-    def faces_normals(self):
-        return np.concatenate([mesh.faces_normals for mesh in self])
-
-    @property
-    def faces_areas(self):
-        return np.concatenate([mesh.faces_areas for mesh in self])
-
-    @property
-    def faces_centers(self):
-        return np.concatenate([mesh.faces_centers for mesh in self])
-
-    @property
-    def faces_radiuses(self):
-        return np.concatenate([mesh.faces_radiuses for mesh in self])
-
-    @property
-    def quadrature_points(self):
-        quad_submeshes = [mesh.quadrature_points for mesh in self]
-        return (
-            np.concatenate([quad[0] for quad in quad_submeshes]),  # Points
-            np.concatenate([quad[1] for quad in quad_submeshes])   # Weights
-        )
-
-    @property
-    def quadrature_method(self):
-        methods_submeshes = [mesh.quadrature_method for mesh in self]
-        if len(set(methods_submeshes)) == 1:
-            return methods_submeshes[0]  # All the same methods
-        else:
-            return "Mixed quadrature method"
-
-    def compute_quadrature(self, method):
-        for mesh in self:
-            mesh.compute_quadrature(method)
-
-    @property
-    def center_of_mass_of_nodes(self):
-        return sum([mesh.nb_vertices*mesh.center_of_mass_of_nodes for mesh in self])/self.nb_vertices
-
-    @property
-    @lru_cache(maxsize=1024)
-    def diameter_of_nodes(self):
-        return self.merged().diameter_of_nodes  # TODO: improve implementation
-
-    def indices_of_mesh(self, mesh_index: int) -> slice:
-        """Return the indices of the faces for the sub-mesh given as argument."""
-        start = sum((mesh.nb_faces for mesh in self[:mesh_index]))  # Number of faces in previous meshes
-        return slice(start, start + self[mesh_index].nb_faces)
-
-    def submesh_containing_face(self, id_face):
-        total_faces = 0
-        for id_mesh in range(self.nb_submeshes):
-            total_faces += self[id_mesh].nb_faces
-            if id_face < total_faces:
-                return id_mesh, id_face - (total_faces - self[id_mesh].nb_faces)
-
-    ##################
-    # Transformation #
-    ##################
-
-    def join_meshes(*meshes, name=None, return_masks=False):
-        coll = CollectionOfMeshes(meshes, name=name)
-        if return_masks:
-            masks = []
-            for i_mesh in range(len(meshes)):
-                mask = np.full((coll.nb_faces,), False)
-                mask[coll.indices_of_mesh(i_mesh)] = True
-                masks.append(mask)
-            return coll, masks
-        return coll
-
-    def __add__(self, mesh_to_add):
-        return self.join_meshes(mesh_to_add)
-
-    def merged(self, name=None) -> Mesh:
-        """Merge the sub-meshes and return a full mesh.
-        If the collection contains other collections, they are merged recursively.
-        Optionally, a new name can be given to the resulting mesh."""
-        if name is None:
-            name = self.name
-        merged = Mesh(self.vertices, self.faces, name=name)
-        merged.merge_duplicates()
-        merged.heal_triangles()
-        return merged
-
-    def extract_one_face(self, id_face):
-        id_mesh, relative_id_face = self.submesh_containing_face(id_face)
-        mesh = self[id_mesh]
-
-        extracted_mesh = mesh.extract_one_face(relative_id_face)
-
-        if hasattr(mesh, '__internals__'):
-            for prop in mesh.__internals__:
-                if prop[:4] == "face":
-                    extracted_mesh.__internals__[prop] = mesh.__internals__[prop][[relative_id_face]]
-
-        return extracted_mesh
-
-    def extract_faces(self, *args, **kwargs):
-        return self.merged().extract_faces(*args, **kwargs)
-
-    def sliced_by_plane(self, plane):
-        return CollectionOfMeshes([mesh.sliced_by_plane(plane) for mesh in self], name=self.name)
-
-    @inplace_transformation
-    def translate(self, vector):
-        for mesh in self:
-            mesh.translate(vector)
-
-    @inplace_transformation
-    def rotate(self, axis, angle):
-        for mesh in self:
-            mesh.rotate(axis, angle)
-
-    @inplace_transformation
-    def mirror(self, plane):
-        for mesh in self:
-            mesh.mirror(plane)
-
-    @inplace_transformation
-    def clip(self, plane):
-        self._clipping_data = {'faces_ids': []}
-        faces_shifts = list(accumulate(chain([0], (mesh.nb_faces for mesh in self[:-1]))))
-        for mesh, faces_shift in zip(self, faces_shifts):
-            mesh.clip(plane)
-            self._clipping_data['faces_ids'].extend([i + faces_shift for i in mesh._clipping_data['faces_ids']])
-        self._clipping_data['faces_ids'] = np.asarray(self._clipping_data['faces_ids'])
-        self.prune_empty_meshes()
-
-    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 prune_empty_meshes(self):
-        """Remove empty meshes from the collection."""
-        remaining_meshes = tuple(mesh for mesh in self if mesh.nb_faces > 0 and mesh.nb_vertices > 0)
-        if len(remaining_meshes) == 0:
-            self._meshes = (Mesh(name="empty_mesh"),)
-        else:
-            self._meshes = remaining_meshes
-
-    @property
-    def axis_aligned_bbox(self):
-        """Get the axis aligned bounding box of the mesh.
-
-        Returns
-        -------
-        tuple
-            (xmin, xmax, ymin, ymax, zmin, zmax)
-        """
-        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))
-
-    def show(self, **kwargs):
-        from capytaine.ui.vtk.mesh_viewer import MeshViewer
-
-        viewer = MeshViewer()
-        for mesh in self:
-            viewer.add_mesh(mesh.merged(), **kwargs)
-        viewer.show()
-        viewer.finalize()
-
-    def show_matplotlib(self, *args, **kwargs):
-        self.merged().show_matplotlib(*args, **kwargs)
-
-    def lowest_lid_position(self, *args, **kwargs):
-        return self.merged().lowest_lid_position(*args, **kwargs)
-
-    def generate_lid(self, *args, **kwargs):
-        return self.merged().generate_lid(*args, **kwargs)

capytaine/meshes/mesh_like_protocol.py

@@ -1,37 +0,0 @@
-from typing import Tuple, Protocol, runtime_checkable
-from numpy.typing import ArrayLike
-
-
-@runtime_checkable
-class MeshLike(Protocol):
-    """Minimal API that a class describing a mesh should implement to be
-    usable with the rest of Capytaine.
-
-    The goal is two-fold:
-       1. Use at runtime to identify a mesh for functions that behaves
-       differently depending on the type of the input (e.g. Delhommeau().evaluate).
-       2. Use as documentation for third-party mesh implementation.
-
-    In the future, it could also be used for static typing.
-    """
-    vertices: ArrayLike
-    faces: ArrayLike
-    nb_vertices: int
-    nb_faces: int
-    faces_centers: ArrayLike
-    faces_normals: ArrayLike
-    faces_areas: ArrayLike
-    faces_radiuses: ArrayLike
-    quadrature_points: Tuple[ArrayLike, ArrayLike]
-
-    def __short_str__(self) -> str:
-        ...
-
-    def extract_faces(self, faces_id):
-        ...
-
-    def join_meshes(*meshes, return_mask):
-        ...
-
-    def with_normal_vector_going_down(self, **kwargs):
-        ...

capytaine/meshes/properties.py

@@ -1,276 +0,0 @@
-"""Helper functions to compute some properties of the mesh.
-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>
-
-from functools import reduce
-from itertools import chain
-import numpy as np
-from typing import List
-from numpy.typing import NDArray
-
-
-def compute_faces_properties(mesh):
-    """Compute the faces properties of the mesh"""
-
-    # faces_areas, faces_normals, faces_centers = mm.get_all_faces_properties(mesh._vertices, mesh._faces)
-    nf = mesh.nb_faces
-
-    # triangle_mask = _faces[:, 0] == _faces[:, -1]
-    # nb_triangles = np.sum(triangle_mask)
-    # quads_mask = np.invert(triangle_mask)
-    # nb_quads = nf - nb_triangles
-
-    faces_areas = np.zeros(nf, dtype=float)
-    faces_normals = np.zeros((nf, 3), dtype=float)
-    faces_centers = np.zeros((nf, 3), dtype=float)
-
-    # Collectively dealing with triangles
-    # triangles = _faces[triangle_mask]
-    triangles_id = mesh.triangles_ids
-    triangles = mesh._faces[triangles_id]
-
-    triangles_normals = np.cross(mesh._vertices[triangles[:, 1]] - mesh._vertices[triangles[:, 0]],
-                                 mesh._vertices[triangles[:, 2]] - mesh._vertices[triangles[:, 0]])
-    triangles_normals_norm = np.linalg.norm(triangles_normals, axis=1)
-
-    degenerate_triangle = np.abs(triangles_normals_norm) < 1e-12
-    triangles_id = triangles_id[~degenerate_triangle]
-    triangles_normals = triangles_normals[~degenerate_triangle, :]
-    triangles_normals_norm = triangles_normals_norm[~degenerate_triangle]
-    triangles = triangles[~degenerate_triangle, :]
-    # Now, continue the computations without the degenerate triangles
-
-    faces_normals[triangles_id] = triangles_normals / triangles_normals_norm[:, np.newaxis]
-    faces_areas[triangles_id] = triangles_normals_norm / 2.
-    faces_centers[triangles_id] = np.sum(mesh._vertices[triangles[:, :3]], axis=1) / 3.
-
-    # Collectively dealing with quads
-    quads_id = mesh.quadrangles_ids
-    quads = mesh._faces[quads_id]
-    # quads = _faces[quads_mask]
-
-    quads_normals = np.cross(mesh._vertices[quads[:, 2]] - mesh._vertices[quads[:, 0]],
-                             mesh._vertices[quads[:, 3]] - mesh._vertices[quads[:, 1]])
-
-    quads_normals_norm = np.linalg.norm(quads_normals, axis=1)
-
-    degenerate_quad = np.abs(quads_normals_norm) < 1e-12
-    quads_id = quads_id[~degenerate_quad]
-    quads_normals = quads_normals[~degenerate_quad]
-    quads_normals_norm = quads_normals_norm[~degenerate_quad]
-    quads = quads[~degenerate_quad, :]
-    # Now, continue the computations without the degenerate quads
-
-    faces_normals[quads_id] = quads_normals / quads_normals_norm[:, np.newaxis]
-
-    a1 = np.linalg.norm(np.cross(mesh._vertices[quads[:, 1]] - mesh._vertices[quads[:, 0]],
-                                 mesh._vertices[quads[:, 2]] - mesh._vertices[quads[:, 0]]), axis=1) * 0.5
-    a2 = np.linalg.norm(np.cross(mesh._vertices[quads[:, 3]] - mesh._vertices[quads[:, 0]],
-                                 mesh._vertices[quads[:, 2]] - mesh._vertices[quads[:, 0]]), axis=1) * 0.5
-    faces_areas[quads_id] = a1 + a2
-
-    c1 = np.sum(mesh._vertices[quads[:, :3]], axis=1) / 3.
-    c2 = (np.sum(mesh._vertices[quads[:, 2:4]], axis=1) + mesh._vertices[quads[:, 0]]) / 3.
-
-    faces_centers[quads_id] = (np.array(([a1, ] * 3)).T * c1 + np.array(([a2, ] * 3)).T * c2)
-    faces_centers[quads_id] /= np.array(([faces_areas[quads_id], ] * 3)).T
-
-    faces_radiuses = compute_radiuses(mesh, faces_centers)
-
-    return {'faces_areas': faces_areas,
-            'faces_normals': faces_normals,
-            'faces_centers': faces_centers,
-            'faces_radiuses': faces_radiuses,
-            }
-
-
-def compute_radiuses(mesh, faces_centers):
-    """Compute the radiuses of the faces of the mesh.
-
-    The radius is defined here as the maximal distance between the center
-    of mass of a cell and one of its points."""
-
-    # Coordinates of all the vertices grouped by face
-    faces_vertices = mesh.vertices[mesh.faces, :]
-    # faces_vertices.shape == (nb_faces, 4, 3)
-
-    # Reorder the axes for array broadcasting below
-    faces_vertices = np.moveaxis(faces_vertices, 0, 1)
-    # faces_vertices.shape == (4, nb_faces, 3)
-
-    # Get all the vectors between the center of faces and their vertices.
-    radial_vector = faces_centers - faces_vertices
-    # radial_vector.shape == (4, nb_faces, 3)
-
-    # Keep the maximum length
-    faces_radiuses = np.max(np.linalg.norm(radial_vector, axis=2), axis=0)
-    # faces_radiuses.shape = (nb_faces)
-
-    return faces_radiuses
-
-
-def compute_connectivity(mesh):
-    """Compute the connectivities of the mesh.
-
-    It concerns further connectivity than simple faces/vertices connectivities. It computes the vertices / vertices, vertices / faces and faces / faces connectivities.
-
-    Note
-    ----
-    * Note that if the mesh is not conformal, the algorithm may not perform correctly
-
-    TODO: The computation of boundaries should be in the future computed with help of VTK
-    """
-
-    nv = mesh.nb_vertices
-    nf = mesh.nb_faces
-
-    mesh_closed = True
-
-    # Building connectivities
-
-    # Establishing v_v and v_f connectivities
-    v_v = dict([(i, set()) for i in range(nv)])
-    v_f = dict([(i, set()) for i in range(nv)])
-    for (iface, face) in enumerate(mesh._faces):
-        if face[0] == face[-1]:
-            face_w = face[:3]
-        else:
-            face_w = face
-        for (index, iV) in enumerate(face_w):
-            v_f[iV].add(iface)
-            v_v[face_w[index - 1]].add(iV)
-            v_v[iV].add(face_w[index - 1])
-
-    # Connectivity f_f
-    boundary_edges = dict()
-
-    f_f = dict([(i, set()) for i in range(nf)])
-    for ivertex in range(nv):
-        set1 = v_f[ivertex]
-        for iadj_v in v_v[ivertex]:
-            set2 = v_f[iadj_v]
-            intersection = list(set1 & set2)
-            if len(intersection) == 2:
-                f_f[intersection[0]].add(intersection[1])
-                f_f[intersection[1]].add(intersection[0])
-
-            elif len(intersection) == 1:
-                boundary_face = mesh._faces[intersection[0]]
-
-                if boundary_face[0] == boundary_face[-1]:
-                    boundary_face = boundary_face[:3]
-                ids = np.where((boundary_face == ivertex) + (boundary_face == iadj_v))[0]
-
-                if ids[1] != ids[0]+1:
-                    i_v_orig, i_v_target = boundary_face[ids]
-                else:
-                    i_v_target, i_v_orig = boundary_face[ids]
-
-                boundary_edges[i_v_orig] = i_v_target
-            else:
-                raise RuntimeError('Unexpected error while computing mesh connectivities')
-
-    # Computing boundaries
-    boundaries = list()
-    # TODO: calculer des boundaries fermees et ouvertes (closed_boundaries et open_boundaries) et mettre dans dict
-    while True:
-        try:
-            boundary = list()
-            i_v0_init, i_v1 = boundary_edges.popitem()
-            boundary.append(i_v0_init)
-            boundary.append(i_v1)
-            i_v0 = i_v1
-
-            while True:
-                try:
-                    i_v1 = boundary_edges.pop(i_v0)
-                    boundary.append(i_v1)
-                    i_v0 = i_v1
-                except KeyError:
-                    if boundary[0] != boundary[-1]:
-                        print('Boundary is not closed !!!')
-                    else:
-                        boundaries.append(boundary)
-                    break
-        except KeyError:
-            break
-
-    return {'v_v': v_v,
-            'v_f': v_f,
-            'f_f': f_f,
-            'boundaries': boundaries}
-
-def faces_in_group(faces: NDArray[np.integer], group: NDArray[np.integer]) -> NDArray[np.bool_]:
-    """Identification of faces with vertices within group.
-
-    Parameters
-    ----------
-    faces : NDArray[np.integer]
-        Mesh faces. Expecting a numpy array of shape N_faces x N_vertices_per_face.
-    group : NDArray[np.integer]
-        Group of connected vertices
-
-    Returns
-    -------
-    NDArray[np.bool]
-        Mask of faces containing vertices from the group
-    """
-    return np.any(np.isin(faces, group), axis=1)
-
-def clustering(faces: NDArray[np.integer]) -> List[NDArray[np.integer]]:
-    """Clustering of vertices per connected faces.
-
-    Parameters
-    ----------
-    faces : NDArray[np.integer]
-        Mesh faces. Expecting a numpy array of shape N_faces x N_vertices_per_face.
-
-    Returns
-    -------
-    list[NDArray[np.integer]]
-        Groups of connected vertices.
-    """
-    vert_groups: list[NDArray[np.integer]] = []
-    mask = np.ones(faces.shape[0], dtype=bool)
-    while np.any(mask):
-        # Consider faces whose vertices are not already identified in a group.
-        # Start new group by considering first face
-        remaining_faces = faces[mask]
-        group = remaining_faces[0]
-        rem_mask = np.ones(remaining_faces.shape[0], dtype=bool)
-        # Iterative update of vertices group. Output final result to frozenset
-        while not np.allclose(new:=faces_in_group(remaining_faces, group), rem_mask):
-            group = np.unique(remaining_faces[new])
-            rem_mask = new
-        else:
-            group = np.unique(remaining_faces[new])
-        vert_groups.append(group)
-        # Identify faces that have no vertices in current groups
-        mask = ~reduce(np.logical_or, [faces_in_group(faces, group) for group in vert_groups])
-    return vert_groups
-
-
-def connected_components(mesh):
-    """Returns a list of meshes that each corresponds to the a connected component in the original mesh.
-    Assumes the mesh is mostly conformal without duplicate vertices.
-    """
-    # Get connected vertices
-    vertices_components = clustering(mesh.faces)
-    # Verification
-    if sum(len(group) for group in vertices_components) != len(set(chain.from_iterable(vertices_components))):
-        raise ValueError("Error in connected components clustering. Some elements are duplicated")
-    # The components are found. The rest is just about retrieving the faces in each components.
-    faces_components = [np.argwhere(faces_in_group(mesh.faces, group)) for group in vertices_components]
-    components = [mesh.extract_faces(f) for f in faces_components]
-    return components
-
-
-def connected_components_of_waterline(mesh, z=0.0):
-    if np.any(mesh.vertices[:, 2] > z + 1e-8):
-        mesh = mesh.immersed_part(free_surface=z)
-    fs_vertices_indices = np.where(np.isclose(mesh.vertices[:, 2], z))[0]
-    fs_faces_indices = np.where(np.any(np.isin(mesh.faces, fs_vertices_indices), axis=1))[0]
-    crown_mesh = mesh.extract_faces(fs_faces_indices)
-    return connected_components(crown_mesh)