Inconsistent offset behaviour for mrmeshpy.thickenMesh

[emil-peters]

Hi,

I'm using mr.makeThickMesh to thicken a mesh, but I'm seeing inconsistent offset behavior. In some cases the offset follows the surface normals as expected, but in other cases, parts of the mesh appear to move in a fixed global direction (e.g. straight up) instead of along the local normals.

As can be seen in the image below, in this example the mesh shoots straight up. This leads to the blue connecting region being vertical.
For my use case, the ideal case is that this blue region would follow the normals (~ straight in this example).

Is there any way to better control the offset of mr.makeThickMesh?

(Below I've attached the code to reproduce my issue).

If this is not possible, I could solve my problem in a different way if there are either of these functions available: 1. a function to offset a 3D outline of a mesh so that it follows the normals of the mesh, or 2. project the outline of a mesh onto another mesh by following its normals without creating overlapping edges/loops. If they exist, could you point me in the correct direction?

Thanks in advance for looking into this!

from typing import Optional, Tuple

import meshlib.mrmeshnumpy as mrn
import meshlib.mrmeshpy as mr
import numpy as np
import numpy.typing as npt
import trimesh


def thicken_mesh(
    mesh: trimesh.Trimesh,
    inside_offset: float,
    outside_offset: float,
    return_labels: bool = True,
) -> Tuple[trimesh.Trimesh, Optional[npt.NDArray[np.int_]]]:
    """
    Thicken a mesh by offsetting it inward and outward, creating a solid volume.
    
    """
    # Convert input mesh to MeshLib format
    mr_input = mrn.meshFromFacesVerts(
        np.array(mesh.faces, dtype=np.int32),  # type: ignore
        np.array(mesh.vertices, dtype=np.float32)  # type: ignore
    )
    
    # Set up thickening parameters
    params = mr.ThickenParams()
    params.insideOffset = inside_offset
    params.outsideOffset = outside_offset
    
    # Create thickened mesh
    mr_thickened = mr.makeThickMesh(mr_input, params)
    
    # Convert back to trimesh
    thickened_mesh = trimesh.Trimesh(
        vertices=mrn.getNumpyVerts(mr_thickened),
        faces=mrn.getNumpyFaces(mr_thickened.topology)
    )
    
    # Compute regions
    face_labels = None
    if return_labels:
        num_faces = mr_thickened.topology.getValidFaces().size()
        num_original_faces = mr_input.topology.getValidFaces().count()
        
        # Initialize all faces as label 0 (outer surface)
        face_labels = np.zeros(num_faces, dtype=np.int32)
        
        # Get faces that were added (inner surface + connections)
        # These are all faces not present in the original mesh
        added_faces_bitset = (
            mr_thickened.topology.getValidFaces() - mr_input.topology.getValidFaces()
        )
        added_faces_mask = mrn.getNumpyBitSet(added_faces_bitset).astype(bool)
        
        # The original outer surface faces are NOT in the added set
        outer_surface_mask = ~added_faces_mask
        face_labels[outer_surface_mask] = 0
        
        # Create mask for inner surface faces
        # The inner surface is at the end of the face array (same count as original)
        inner_surface_mask = np.zeros(num_faces, dtype=bool)
        inner_surface_mask[-num_original_faces:] = True
        face_labels[inner_surface_mask] = 1
        
        # Connection faces are the added faces minus the inner surface
        connection_faces_bitset = added_faces_bitset - mrn.faceBitSetFromBools(
            inner_surface_mask
        )
        connection_mask = mrn.getNumpyBitSet(connection_faces_bitset).astype(bool)
        face_labels[connection_mask] = 2
    
    return thickened_mesh, face_labels

# Example usage
if __name__ == "__main__":
    mesh = trimesh.load_mesh("thicken_mesh_error_example.ply")

    thickened_mesh, labels = thicken_mesh(mesh, inside_offset=0, outside_offset=5.0)
    
    #Visualization logic ingnore
    if labels is not None:
        print(f"Face labels: {np.bincount(labels)}")
        print(f"  - Outer surface (0): {np.sum(labels == 0)} faces")
        print(f"  - Inner surface (1): {np.sum(labels == 1)} faces")
        print(f"  - Connections (2): {np.sum(labels == 2)} faces")
        
        # Example 2: Visualize different regions with distinct colors
        # Create separate meshes for each region to prevent color blending
        color_map = {
            0: [255, 0, 0, 255],    # Red: outer surface
            1: [0, 255, 0, 255],    # Green: inner surface
            2: [0, 0, 255, 255],    # Blue: connections
        }
        
        # Create separate meshes for each labeled region
        region_meshes = []
        for label, color in color_map.items():
            region_mask = labels == label
            if np.any(region_mask):
                # Extract faces for this region
                region_faces = thickened_mesh.faces[region_mask]
                # Create a submesh for this region
                region_mesh = trimesh.Trimesh(
                    vertices=thickened_mesh.vertices,
                    faces=region_faces
                )
                # Apply uniform color to all faces
                if hasattr(region_mesh, 'visual') and region_mesh.visual is not None:
                    region_mesh.visual.face_colors = color
                region_meshes.append(region_mesh)
        
        # Use the separate meshes for visualization (prevents color blending)
        scene = trimesh.Scene(region_meshes)
    else:
        # No labels, just show the mesh
        scene = trimesh.Scene([thickened_mesh])
    
    # Visualize
    scene.show()

thicken_mesh_error_example.zip

[Fedr]

Thanks for the question.

In some cases the offset follows the surface normals as expected, but in other cases, parts of the mesh appear to move in a fixed global direction (e.g. straight up) instead of along the local normals.

Yes, it was done intentionally. If we move closely located vertices along their normals by a large offset, self-intersections in this place appear. So we detect such situations, and replaces raw normals with a smoother field of offset directions to avoid self-intersections.

We will think how to give more control to the user here, if the current automatic solution is not always desirable.

As can be seen in the image below,

Could you please check the link and permissions, since I do not see it.

[emil-peters]

Sorry here is the image

[Grantim]

Thanks!

@Fedr have just merged #5636 into master, so this option should be available in next release:

MeshLib/source/MRMesh/MROffsetVerts.h

Lines 23 to 26 in 7f82956

	/// increasing this value will lead mesh vertices to shift in the directions closer to their raw pseudo-normals, but
	/// it will increase the probability of self-intersections as well;
	/// decreasing (to a positive value) will on the contrary make the field of shift directions smoother
	float normalsTrustFactor = 1;