Offset Mesh run times and CPU usage

[patman52]

I have been using the generalOffsetMesh method to repair and heal meshes to prep for our 3D printer. It has worked very well is is very fast. I have a computer with a 64 core CPU and it would generally use 100% of the CPU cores to quickly rebuild large mesh files.

I recently had to re do my Python environment and now when I run the same script with the same version of Python and meshlib, I am running into issues with very long repair times.

It will generally start using 100% of the CPU cores, but this % gradually decreases over time. This has lead to a repair time which typically would take a couple of minutes on a large file to take hours and hours.

I have checked the CPU for thermal throttling and have not witnessed anything.

This is the code, I give it a mesh file and a voxel size to run with:
oParams = mm.GeneralOffsetParameters() oParams.signDetectionMode = mm.SignDetectionMode.HoleWindingRule oParams.voxelSize = voxelSize resMesh = mm.generalOffsetMesh(mold_mesh, 0.0, oParams)

The CPU I am using is a Ryzen Threadripper and I have 256 GB of RAM.

I am using meshlib version 2.4.2.198.

[Grantim]

Hello!

In older versions of meshlib we used mm.suggestVoxelSize if voxel size was <= 0.0. In new versions we assume that user have provided valid voxelsize. What voxel size do you use?

(if it is actual reason of the issue - we should probably return error from the function, otherwise if voxel size is not related to it, please provide script and mesh so we could reproduce the issue on our side)

[patman52]

I'm currently using 0.35 as the value for voxel size. I will post the code and a mesh file when I get a chance. Appreciate the help!

[Grantim]

Thanks for update, it's hard to tell anything without files, so looking forward for them! (the symptoms point to too small voxel size but there still could be some bug)

Also have you tried latest versions of meshlib?

[patman52]

I'm sorry for not getting back to you sooner. I have been traveling for the holidays and have not had much time in front of my computer.

I have managed to run some tests and will get you some files and results soon. At a cursory glance, upgrading MeshLib to the newest version may have fixed the issue I was having, but I need to confirm.

When I have the final results, I'll report back, hopefully within the next couple of days.

Also, my repo uses numpy <= 2.0, and I have a couple of other packages that still require the older versions, but it appears that meshlib will automatically install numpy >= 2.0. Will that have any effect on the overall processing capabilities?

[Grantim]

I think it just takes latest numpy? We have numpy >= 1.19.0 in our requirements file https://github.com/MeshInspector/MeshLib/blob/master/requirements/python.txt (but actually I believe it should work fine even with older versions)

[patman52]

Updating to the latest version of MeshLib and reinstalling it seems to have fixed the issue. So you can close this issue if you wish,

Here is an example of what I was seeing for reference. The charts show the CPU% and core temperature of my computer over time. With the old version, it took more than three times longer to repair the same part using the same settings. As you can see, the CPU % stays at 100% for about the first 30 seconds or so, then drops to around 75%, before gradually leveling off.

With the new version, the CPU% stays at 100% until the part is fully repaired.

I've included the script here for you to look over. I can email a link to the file if necessary. Either thanks, thanks for the response!

"""
repair_mesh.py

Repair/heal meshes and decimate to reduce file size

"""

import os
import time
from pathlib import Path
from typing import Optional

# external libraries
from meshlib import mrmeshpy as mm

VOXEL_SIZE = 0.35


def heal(mesh_file_path: str, units: str, voxel_size: float = VOXEL_SIZE, decimate: bool = True) -> Optional[mm.Mesh]:
    """
    Reconstructs a mesh with potential geometry issues using voxel methodology and optionally decimates it.

    Parameters:
        mesh_file_path (str): Path to stl file to repair / decimate
        units (str): inches or mm
        voxel_size (float): The size of the voxels used for the rebuilding step. (default: 0.35 mm)
        decimate (bool, optional): If True, decimate the mesh to reduce file size (default: True).

    Returns:
        Optional[mm.Mesh]: The reconstructed and optionally decimated mesh object, or None if unsuccessful.

    Raises:
        Exception: If there is an error during the healing process.
    """

    if units == 'in':
        voxelSize = VOXEL_SIZE / 25.4
    elif units == 'mm':
        voxelSize = VOXEL_SIZE
    else:
        raise ValueError(f"units must be either 'in' or 'mm', unknown value: {units}")

    try:
        start = time.time()
        mold_mesh = mm.loadMesh(Path(mesh_file_path))
        oParams = mm.GeneralOffsetParameters()
        oParams.signDetectionMode = mm.SignDetectionMode.HoleWindingRule
        oParams.voxelSize = voxelSize
        resMesh = mm.generalOffsetMesh(mold_mesh, 0.0, oParams)

        # Decimate mesh to reduce file size while retaining detail
        if decimate:
            resMesh.packOptimally(False)
            dSettings = mm.DecimateSettings()
            dSettings.maxError = 0.1 * voxelSize
            dSettings.tinyEdgeLength = mold_mesh.computeBoundingBox().diagonal() * 1e-5
            dSettings.stabilizer = 1e-6
            dSettings.packMesh = True
            dSettings.subdivideParts = 64
            mm.decimateMesh(resMesh, dSettings)

        print(f'finished mesh rebuilt in {round((time.time() - start)/60, 2)} min(s)')
        return resMesh

    except Exception as e:
        print("Error in heal function: %s", e)
        return None


if __name__ == '__main__':
    mesh_file_path = r""    # path to mesh file
    units = "in"            # the units for the incoming file, either in or mm
    repaired_file_path = os.path.join(os.path.dirname(mesh_file_path),
                                 os.path.splitext(os.path.basename(mesh_file_path))[0] + '_repaired.stl')
    print(f'repairing mesh {os.path.basename(mesh_file_path)}...')
    repaired_mesh = heal(mesh_file_path, units=units)
    if repaired_mesh:
        mm.saveMesh(repaired_mesh, Path(repaired_file_path))
        print(f'Saved repaired mesh to {repaired_file_path}')
        

[Grantim]

Thanks for detailed response!

While there could be some bugs in older version, it seems that actually the reason behind this difference in performance is improvements that our team done and not bugs.

Also, please note that we have simplified function for healing with voxel based conversion:

MeshLib/python_scripts/mesh_rebuild.py

Lines 1 to 10 in c30f894

	from meshlib import mrmeshpy as mm
	from meshlib import mrcudapy as mc
	def rebuild( mesh : mm.Mesh, voxelSize : float, decimate : bool = True )->mm.Mesh:
	params = mm.RebuildMeshSettings()
	params.voxelSize = voxelSize # mm.suggestVoxelSize(mesh,5e7) # suggest amount of voxels to use
	if mc.isCudaAvailable():
	params.fwn = mc.FastWindingNumber(mesh) # only if cuda is available, for speedup
	params.decimate = decimate
	return mm.rebuildMesh(mesh,params) # it can leave some small components

Which can utilize CUDA and can use more performative sign detection mode if it is possible (for example if mesh is already closed)