capytaine 2.3__cp311-cp311-win_amd64.whl → 3.0.0a1__cp311-cp311-win_amd64.whl

capytaine/meshes/quality.py

@@ -1,448 +1,159 @@
-"""Tools for mesh quality and mesh healing.
-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.
 
 import logging
+from itertools import chain
 
 import numpy as np
 
-from capytaine.meshes.geometry import inplace_transformation
-from capytaine.meshes.properties import compute_connectivity
-
 LOG = logging.getLogger(__name__)
+SHOWED_PYVISTA_WARNING = False
 
 
-def merge_duplicates(mesh, atol=1e-8):
-    """Merges the duplicate vertices of the mesh in place.
-
-    Parameters
-    ----------
-    atol : float, optional
-        Absolute tolerance. default is 1e-8
-
-    Returns
-    -------
-    new_id : ndarray
-        Array of indices that merges the vertices.
+def check_mesh_quality(mesh, *, tol=1e-8):
     """
-    uniq, new_id = merge_duplicate_rows(mesh.vertices, atol=atol)
+    Perform a set of geometric and metric quality checks on mesh data.
 
-    nv_init = mesh.nb_vertices
-
-    # Updating mesh data
-    mesh.vertices = uniq
-    mesh.faces = new_id[mesh.faces] # Faces vertices ids are updated here
+    Checks performed:
+    - Non-coplanar faces
+    - Non-convex faces
+    - Aspect ratio via PyVista (if available)
+    """
+    non_coplanar = indices_of_non_coplanar_faces(mesh.vertices, mesh._faces)
+    if non_coplanar:
+        LOG.warning(f"{len(non_coplanar)} non-coplanar faces detected in {mesh}.")
+
+    non_convex = indices_of_non_convex_faces(mesh.vertices, mesh._faces)
+    if non_convex:
+        LOG.warning(f"{len(non_convex)} non-convex faces detected in {mesh}.")
+
+    try:
+        pv_mesh = mesh.export_to_pyvista()
+
+        try:
+            arq = pv_mesh.cell_quality("aspect_ratio").cell_data.get("aspect_ratio")
+        except AttributeError:  # Older version of PyVista
+            arq = pv_mesh.compute_cell_quality("aspect_ratio").cell_data.get("CellQuality")
+        if arq is not None:
+            ratio_ok = np.sum(arq < 5) / len(arq)
+            if ratio_ok < 0.9:
+                LOG.info(f"Aspect Ratio of {mesh}:")
+                LOG.info(
+                    f"  Min: {np.min(arq):.3f} | Max: {np.max(arq):.3f} | Mean: {np.mean(arq):.3f}"
+                )
+                LOG.info(f"  Elements with AR < 5: {ratio_ok*100:.1f}%")
+                LOG.warning(
+                    "Low quality: more than 10% of elements have aspect ratio higher than 5."
+                )
+    except ImportError:
+        global SHOWED_PYVISTA_WARNING
+        if LOG.isEnabledFor(logging.INFO) and not SHOWED_PYVISTA_WARNING:
+            LOG.info("PyVista not installed, skipping aspect ratio check.")
+            SHOWED_PYVISTA_WARNING = True
 
-    nv_final = mesh.nb_vertices
 
-    LOG.debug("* Merging duplicate vertices that lie in an absolute proximity of %.1E...", atol)
-    delta_n = nv_init - nv_final
-    if delta_n == 0:
-        LOG.debug("\t--> No duplicate vertices have been found")
-    else:
-        LOG.debug("\t--> Initial number of vertices : %u", nv_init)
-        LOG.debug("\t--> Final number of vertices   : %u", nv_final)
-        LOG.debug("\t--> %u vertices have been merged", delta_n)
+def extract_face_vertices(vertices, face):
+    return vertices[face]
 
-    # if mesh._has_connectivity():
-    #     mesh._remove_connectivity()
 
-    return new_id
+def is_non_coplanar(vertices):
+    a, b, c, d = vertices
+    normal = np.cross(b - a, c - a)
+    deviation = np.abs(np.dot(normal, d - a))
+    return deviation > 1e-8
 
 
-def merge_duplicate_rows(arr, atol=1e-8):
-    """Returns a new node array where close nodes have been merged into one node (following atol).
+def indices_of_non_coplanar_faces(vertices, faces):
+    """
+    Identify the indices of quadrilateral faces that are not coplanar.
 
     Parameters
     ----------
-    arr : array_like
-        array of the coordinates of the mesh's nodes
-    atol : float, optional
-        the tolerance used to define nodes that are coincident and
-        that have to be merged
+    vertices : np.ndarray
+        Array of vertex coordinates (n_vertices, 3).
+    faces : np.ndarray
+        Array of face indices (n_faces, 4) or (n_faces, 3).
 
     Returns
     -------
-    arr : ndarray
-        array of the coordinates of the mesh's nodes where
-        every node is different
-    newID : ndarray
-        array of the new new vertices IDs
-    """
-    # This function is a bottleneck in the clipping routines
-    # TODO: use np.unique to cluster groups --> acceleration !!
-
-    # atol = pow(10, -decimals)
-
-    arr = np.asarray(arr)
-
-    nv, nbdim = arr.shape
-
-    levels = [0, nv]
-    iperm = np.arange(nv)
-
-    for dim in range(nbdim):
-        # Sorting the first dimension
-        values = arr[:, dim].copy()
-        if dim > 0:
-            values = values[iperm]
-        levels_tmp = []
-        for (ilevel, istart) in enumerate(levels[:-1]):
-            istop = levels[ilevel+1]
-
-            if istop-istart > 1:
-                level_values = values[istart:istop]
-                iperm_view = iperm[istart:istop]
-
-                iperm_tmp = level_values.argsort()
-
-                level_values[:] = level_values[iperm_tmp]
-                iperm_view[:] = iperm_view[iperm_tmp]
-
-                levels_tmp.append(istart)
-                vref = values[istart]
-
-                for idx in range(istart, istop):
-                    cur_val = values[idx]
-                    if np.abs(cur_val - vref) > atol:
-                        levels_tmp.append(idx)
-                        vref = cur_val
-
-            else:
-                levels_tmp.append(levels[ilevel])
-        if len(levels_tmp) == nv:
-            # No duplicate rows
-            # if verbose:
-            # LOG.debug "\t -> No duplicate _vertices detected :)"
-            newID = np.arange(nv)
-
-        levels_tmp.append(nv)
-        levels = levels_tmp
-
-    else:
-        # Building the new merged node list
-        arr_tmp = []
-        newID = np.arange(nv)
-        for (ilevel, istart) in enumerate(levels[:-1]):
-            istop = levels[ilevel+1]
-
-            arr_tmp.append(arr[iperm[istart]])
-            newID[iperm[list(range(istart, istop))]] = ilevel
-        arr = np.array(arr_tmp, dtype=float)
-        # Applying renumbering to cells
-        # if F is not None:
-        #     for cell in F:
-        #         cell[:] = newID[cell]
-
-        # if verbose:
-        # nv_new = arr.shape[0]
-        # LOG.debug "\t -> Initial number of nodes : {:d}".format(nv)
-        # LOG.debug "\t -> New number of nodes     : {:d}".format(nv_new)
-        # LOG.debug "\t -> {:d} nodes have been merged".format(nv-nv_new)
-
-    # if F is not None:
-    #     if return_index:
-    #         return arr, F, newID
-    #     else:
-    #         return arr, F
-    # else:
-    return arr, newID
-
-
-@inplace_transformation
-def heal_normals(mesh):
-    """Heals the mesh's normals orientations so that they have a consistent orientation and try to make them outward.
-    """
-    # TODO: return the different groups of a mesh in case it is made of several unrelated groups
-
-    nv = mesh.nb_vertices
-    nf = mesh.nb_faces
-    faces = mesh._faces
-
-    # Building connectivities
-    connectivities = compute_connectivity(mesh)
-    v_v = connectivities["v_v"]
-    v_f = connectivities["v_f"]
-    f_f = connectivities["f_f"]
-    boundaries = connectivities["boundaries"]
-
-    if len(boundaries) > 0:
-        mesh_closed = False
-    else:
-        mesh_closed = True
-
-    # Flooding the mesh to find inconsistent normals
-    type_cell = np.zeros(nf, dtype=np.int32)
-    type_cell[:] = 4
-    type_cell[mesh.triangles_ids] = 3
-
-    f_vis = np.zeros(nf, dtype=bool)
-    f_vis[0] = True
-    stack = [0]
-    nb_reversed = 0
-    while 1:
-        if len(stack) == 0:
-            if np.any(np.logical_not(f_vis)):
-                iface = np.where(np.logical_not(f_vis))[0][0]
-                stack.append(iface)
-                f_vis[iface] = True
-            else:
-                break
-
-        iface = stack.pop()
-        face = faces[iface]
-        s1 = set(face)
-
-        for iadj_f in f_f[iface]:
-            if f_vis[iadj_f]:
-                continue
-            f_vis[iadj_f] = True
-            # Removing the other pointer
-            f_f[iadj_f].remove(iface)  # So as it won't go from iadj_f to iface in the future
-
-            # Shared vertices
-            adjface = faces[iadj_f]
-            s2 = set(adjface)
-            # try:
-            common_vertices = list(s1 & s2)
-            if len(common_vertices) == 2:
-                i_v1, i_v2 = common_vertices
-            else:
-                LOG.warning('faces %u and %u have more than 2 vertices in common !', iface, iadj_f)
-                continue
-
-            # Checking normal consistency
-            face_ref = np.roll(face[:type_cell[iface]], -np.where(face == i_v1)[0][0])
-            adj_face_ref = np.roll(adjface[:type_cell[iadj_f]], -np.where(adjface == i_v1)[0][0])
-
-            if face_ref[1] == i_v2:
-                i = 1
-            else:
-                i = -1
-
-            if adj_face_ref[i] == i_v2:
-                # Reversing normal
-                nb_reversed += 1
-                faces[iadj_f] = np.flipud(faces[iadj_f])
-
-            # Appending to the stack
-            stack.append(iadj_f)
-
-    LOG.debug("* Healing normals to make them consistent and if possible outward")
-    if nb_reversed > 0:
-        LOG.debug('\t--> %u faces have been reversed to make normals consistent across the mesh' % (nb_reversed))
-    else:
-        LOG.debug("\t--> Normals orientations are consistent")
-
-    mesh._faces = faces
-
-    # Checking if the normals are outward
-    if mesh_closed:
-        zmax = np.max(mesh._vertices[:, 2])
-
-        areas = mesh.faces_areas
-        normals = mesh.faces_normals
-        centers = mesh.faces_centers
-        # areas, normals, centers = get_all_faces_properties(vertices, faces)
-
-        hs = (np.array([(centers[:, 2] - zmax) * areas, ] * 3).T * normals).sum(axis=0)
-
-        tol = 1e-9
-        if np.fabs(hs[0]) > tol or np.fabs(hs[1]) > tol:
-            LOG.warning("\t--> the mesh does not seem watertight although marked as closed...")
-
-        if hs[2] < 0:
-            flipped = True
-            mesh.flip_normals()
-        else:
-            flipped = False
-
-        if flipped:
-            LOG.debug('\t--> Every normals have been reversed to be outward')
-
-    else:
-        LOG.debug("\t--> Mesh is not closed, Capytaine cannot test if the normals are outward")
-
-    return mesh
-
-
-@inplace_transformation
-def remove_unused_vertices(mesh):
-    """Removes unused vertices in the mesh in place.
-
-    Those are vertices that are not used by any face connectivity.
+    list[int]
+        List of indices of non-coplanar quadrilateral faces.
     """
-    # TODO: implementer return_index !!
-    nv = mesh.nb_vertices
-    vertices, faces = mesh._vertices, mesh._faces
-
-    used_v = np.zeros(nv, dtype=bool)
-    used_v[sum(list(map(list, faces)), [])] = True
-    nb_used_v = sum(used_v)
-
-    if nb_used_v < nv:
-        new_id__v = np.arange(nv)
-        new_id__v[used_v] = np.arange(nb_used_v)
-        faces = new_id__v[faces]
-        vertices = vertices[used_v]
-
-    mesh._vertices, mesh._faces = vertices, faces
-
-    LOG.debug("* Removing unused vertices in the mesh:")
-    if nb_used_v < nv:
-        unused_v = np.where(np.logical_not(used_v))[0]
-        vlist_str = '[' + ', '.join(str(iV) for iV in unused_v) + ']'
-        LOG.debug("\t--> %u unused vertices have been removed" % (nv - nb_used_v))
-    else:
-        LOG.debug("\t--> No unused vertices")
+    indices = []
+    for i, face in enumerate(faces):
+        if len(face) != 4:
+            continue  # skip triangles or degenerate quads
+        verts = extract_face_vertices(vertices, face)
+        if is_non_coplanar(verts):
+            indices.append(i)
+    return indices
 
-    return mesh
 
+def is_face_convex(vertices):
+    a, b, c, d = vertices
+    edges = [b - a, c - b, d - c, a - d]
+    normals = [np.cross(edges[i], edges[(i + 1) % 4]) for i in range(4)]
+    dot_signs = [np.dot(normals[0], n) for n in normals[1:]]
+    return all(s >= -1e-10 for s in dot_signs)
 
-@inplace_transformation
-def heal_triangles(mesh):
-    """Makes the triangle connectivity consistent (in place).
 
-    A general face is stored internally as a 4 integer array. It allows to describe indices of a quadrangle's vertices. For triangles, the first index should be equal to the last. This method ensures that this rule is applied everywhere and correct bad triangles description.
+def indices_of_non_convex_faces(vertices, faces):
     """
-    faces = mesh._faces
-
-    quads = faces[:, 0] != faces[:, -1]
-    nquads_init = sum(quads)
-
-    faces[quads] = np.roll(faces[quads], 1, axis=1)
-    quads = faces[:, 0] != faces[:, -1]
-
-    faces[quads] = np.roll(faces[quads], 1, axis=1)
-    quads = faces[:, 0] != faces[:, -1]
-
-    faces[quads] = np.roll(faces[quads], 1, axis=1)
-    quads = faces[:, 0] != faces[:, -1]
-    nquads_final = sum(quads)
-
-    mesh._faces = faces
-
-    LOG.debug("* Ensuring consistent definition of triangles:")
-    if nquads_final < nquads_init:
-        LOG.debug("\t--> %u triangles were described the wrong way and have been corrected" % (
-        nquads_init - nquads_final))
-    else:
-        LOG.debug("\t--> Triangle description is consistent")
-
-    return mesh
-
-
-@inplace_transformation
-def remove_degenerated_faces(mesh, rtol=1e-5):
-    """Removes tiny triangles from the mesh (in place).
-
-    Tiny triangles are those whose area is lower than the mean triangle area in the mesh times the relative
-    tolerance given.
+    Identify indices of quadrilateral faces in the mesh that are not convex.
 
     Parameters
     ----------
-    rtol : float, optional
-        Positive relative tolerance
-    """
+    mesh : Mesh
+        The input mesh containing faces and vertices.
 
-    assert 0 < rtol
+    Returns
+    -------
+    list[int]
+        List of indices of non-convex quadrilateral faces.
+    """
+    indices = []
+    for i, face in enumerate(faces):
+        if len(face) != 4:
+            continue
 
-    # TODO: implementer un retour d'index des faces extraites
-    areas = mesh.faces_areas
-    area_threshold = areas.mean() * float(rtol)
+        verts = extract_face_vertices(vertices, face)
 
-    # Detecting faces that have null area
-    faces = mesh._faces[np.logical_not(areas < area_threshold)]
-    nb_removed = mesh.nb_faces - faces.shape[0]
-    LOG.debug('* Removing degenerated faces')
-    if nb_removed > 0:
-        LOG.debug('\t-->%u degenerated faces have been removed' % nb_removed)
-    else:
-        LOG.debug('\t--> No degenerated faces')
+        if not is_face_convex(verts):
+            indices.append(i)
 
-    mesh._faces = faces
+    return indices
 
-    return mesh
 
+def _is_valid(vertices, faces):
+    """
+    Check that every face index is valid for the given vertices.
+    Now: an empty face-list is considered valid (as long as vertices exist).
+    """
+    # If you have no vertices at all, only accept if also no faces
+    if len(vertices) == 0:
+        return len(faces) == 0
 
-def print_quality(mesh):
-    """Returns data on the mesh quality.
-    Needs to be tested...
+    # If you have vertices but zero faces → that's fine
+    if len(faces) == 0:
+        return True
 
-    It uses VTK and is reproduced from
-    http://vtk.org/gitweb?p=VTK.git;a=blob;f=Filters/Verdict/Testing/Python/MeshQuality.py
-    """
-    # This function is reproduced from
-    # http://vtk.org/gitweb?p=VTK.git;a=blob;f=Filters/Verdict/Testing/Python/MeshQuality.py
-    polydata = mesh._vtk_polydata()
-    quality = vtk.vtkMeshQuality()
-    quality.SetInputData(polydata)
-
-    def DumpQualityStats(iq, arrayname):
-        an = iq.GetOutput().GetFieldData().GetArray(arrayname)
-        cardinality = an.GetComponent(0, 4)
-        range = list()
-        range.append(an.GetComponent(0, 0))
-        range.append(an.GetComponent(0, 2))
-        average = an.GetComponent(0, 1)
-        stdDev = math.sqrt(math.fabs(an.GetComponent(0, 3)))
-        outStr = '%s%g%s%g\n%s%g%s%g' % (
-            '    range: ', range[0], '  -  ', range[1],
-            '    average: ', average, '  , standard deviation: ', stdDev)
-        return outStr
-
-    # Here we define the various mesh types and labels for output.
-    meshTypes = [
-        ['Triangle', 'Triangle',
-         [['QualityMeasureToArea', ' Area Ratio:'],
-          ['QualityMeasureToEdgeRatio', ' Edge Ratio:'],
-          ['QualityMeasureToAspectRatio', ' Aspect Ratio:'],
-          ['QualityMeasureToRadiusRatio', ' Radius Ratio:'],
-          ['QualityMeasureToAspectFrobenius', ' Frobenius Norm:'],
-          ['QualityMeasureToMinAngle', ' Minimal Angle:']
-          ]
-         ],
-
-        ['Quad', 'Quadrilateral',
-         [['QualityMeasureToArea', ' Area Ratio:'],
-          ['QualityMeasureToEdgeRatio', ' Edge Ratio:'],
-          ['QualityMeasureToAspectRatio', ' Aspect Ratio:'],
-          ['QualityMeasureToRadiusRatio', ' Radius Ratio:'],
-          ['QualityMeasureToMedAspectFrobenius',
-           ' Average Frobenius Norm:'],
-          ['QualityMeasureToMaxAspectFrobenius',
-           ' Maximal Frobenius Norm:'],
-          ['QualityMeasureToMinAngle', ' Minimal Angle:']
-          ]
-         ]
-    ]
-    res = ''
-    if polydata.GetNumberOfCells() > 0:
-        for meshType in meshTypes:
-            res += '\n%s%s' % (meshType[1], ' quality of the mesh ')
-            quality.Update()
-            an = quality.GetOutput().GetFieldData().GetArray('Mesh ' + meshType[1] + ' Quality')
-            cardinality = an.GetComponent(0, 4)
-
-            res = ''.join((res, '(%u elements):\n' % cardinality))
-
-            # res += '('+str(cardinality) +meshType[1]+'):\n'
-
-            for measure in meshType[2]:
-                eval('quality.Set' + meshType[0] + measure[0] + '()')
-                quality.Update()
-                res += '\n%s\n%s' % (
-                    measure[1],
-                    DumpQualityStats(quality, 'Mesh ' + meshType[1] + ' Quality')
-                )
-            res += '\n'
+    # Otherwise, flatten all face‐indices and check bounds
+    all_idx = list(chain.from_iterable(faces))
+    if not all_idx:
+        return True
 
-    info = """\n\nDefinition of the different quality measures is given
-    in the verdict library manual :
-    http://www.vtk.org/Wiki/images/6/6b/VerdictManual-revA.pdf\n"""
+    if min(all_idx) < 0 or max(all_idx) >= len(vertices):
+        return False
 
-    res += info
-    print(res)
-    return
+    return True

capytaine/meshes/surface_integrals.py

@@ -1,63 +1,82 @@
-"""Tools for surface integrals and hydrostatics."""
-# Copyright (C) 2017-2022 Matthieu Ancellin
-# See LICENSE file at <https://github.com/capytaine/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 abc import ABC
+from typing import Tuple, Union
+
 import numpy as np
 
 class SurfaceIntegralsMixin(ABC):
-    # These methods need to be defined for both Mesh and CollectionOfMeshes with the exact same definitions.
-    # To avoid redunduncy, they are defined here in a mixin inherited by both Mesh and CollectionOfMeshes.
+    # Defines some methods inherited by AbstractMesh.
+    # There are located in this other module just to make the code more tidy.
 
     def surface_integral(self, data, **kwargs):
         """Returns integral of given data along wet surface area."""
         return np.sum(data * self.faces_areas, **kwargs)
 
-    def waterplane_integral(self, data, **kwargs):
-        """Returns integral of given data along water plane area."""
-        return self.surface_integral(self.faces_normals[:,2] * data, **kwargs)
-
     @property
-    def wet_surface_area(self):
+    def wet_surface_area(self) -> float:
         """Returns wet surface area."""
-        return self.surface_integral(1)
+        return self.immersed_part().surface_integral(1)
 
     @property
-    def volumes(self):
-        """Returns volumes using x, y, z components of the mesh."""
+    def volumes(self) -> Tuple[float, float, float]:
+        """Returns volumes using x, y, z components of the mesh.
+        Should be the same for a regular mesh."""
         norm_coord = self.faces_normals * self.faces_centers
-        return self.surface_integral(norm_coord.T, axis=1)
+        return tuple(self.surface_integral(norm_coord.T, axis=1))
 
     @property
-    def volume(self):
+    def volume(self) -> float:
         """Returns volume of the mesh."""
         return np.mean(self.volumes)
 
-    def disp_mass(self, *, rho=1000):
-        return rho * self.volume
+    def waterplane_integral(self, data, **kwargs):
+        """Returns integral of given data along water plane area."""
+        immersed_self = self.immersed_part()
+        return immersed_self.surface_integral(immersed_self.faces_normals[:,2] * data, **kwargs)
+
+    @property
+    def disp_volume(self) -> float:
+        return self.immersed_part().volume
+
+    def disp_mass(self, *, rho=1000) -> float:
+        return rho * self.disp_volume
 
     @property
-    def center_of_buoyancy(self):
+    def center_of_buoyancy(self) -> np.ndarray:
         """Returns center of buoyancy of the mesh."""
-        coords_sq_norm = self.faces_normals * self.faces_centers**2
-        return self.surface_integral(coords_sq_norm.T, axis=1) / (2*self.volume)
+        immersed_self = self.immersed_part()
+        coords_sq_norm = immersed_self.faces_normals * immersed_self.faces_centers**2
+        return immersed_self.surface_integral(coords_sq_norm.T, axis=1) / (2*immersed_self.volume)
 
     @property
-    def waterplane_area(self):
+    def waterplane_area(self) -> float:
         """Returns water plane area of the mesh."""
-        waterplane_area = -self.waterplane_integral(1)
-        return waterplane_area
+        immersed_self = self.immersed_part()
+        return -immersed_self.waterplane_integral(1)
 
     @property
-    def waterplane_center(self):
+    def waterplane_center(self) -> Union[None, np.ndarray]:
         """Returns water plane center of the mesh.
-
-        Note: Returns None if the mesh is full submerged.
+        Returns None if the mesh is full submerged.
         """
-        waterplane_area = self.waterplane_area
+        immersed_self = self.immersed_part()
+        waterplane_area = immersed_self.waterplane_area
         if abs(waterplane_area) < 1e-10:
             return None
         else:
-            waterplane_center = -self.waterplane_integral(
-                self.faces_centers.T, axis=1) / waterplane_area
+            waterplane_center = -immersed_self.waterplane_integral(
+                immersed_self.faces_centers.T, axis=1) / waterplane_area
             return waterplane_center[:-1]