Mesh to voxel (Inside 1 outside 0)

[pty0220]

Hi all,

I would like to convert a mesh into a voxel representation, where the inside of the mesh is represented as 1 and the outside as 0.

So far, I have been using HoleWindingRule to achieve this.

params = mm.MeshToDistanceVolumeParams()
params.origin = mm.Vector3f(origin[0], origin[1], origin[2])
params.voxelSize = mm.Vector3f(voxel_size_x, voxel_size_y, voxel_size_z)
params.dimensions = mm.Vector3i(int(voxel_dims[0]), int(voxel_dims[1]), int(voxel_dims[2]))
params.signMode = mm.SignDetectionMode.HoleWindingRule
params.maxDistSq = min(voxel_size_x, voxel_size_y, voxel_size_z)

start_time = time.time()
volume = mm.meshToDistanceVolume(mesh, params)
voxel_array = -mn.getNumpy3Darray(volume)

However, after reviewing MeshInspector, I realized that it is possible to accomplish this without using HoleWindingRule, where the inside of the mesh is represented as -1 and the outside as 1.

The reason I want to avoid using HoleWindingRule is due to performance issues.

Could you give a solution about this ?
I always appreciate your kindly answer!

Best,
Teayoung

[Fedr]

Hi Teayoung,

The purpose of meshToDistanceVolume function is to convert a mesh into 3D raster image with (possibly signed) distances to the mesh. There are several ways of computing the sign of each distance. SignDetectionMode.HoleWindingRule is the trickiest way of computation, but it is robust to the presence of any self-intersections or holes in the mesh. Fortunately, recently, we added CUDA acceleration for SignDetectionMode.HoleWindingRule computation even in Python API.

If your mesh is closed and it does not have any self-intersections, then please try SignDetectionMode.ProjectionNormal mode. It shall work mush faster.

Best reagrds,
Fedor

[pty0220]

Hi Fedor

Thank you for your response.

I have tried SignDetectionMode.ProjectionNormal, but it calculates the distance at the mesh boundaries, while regions completely inside and outside the mesh are computed as 0.

This makes it challenging to distinguish the inside of the mesh from the outside.

Would it be possible to code this in a way similar to the default parameters of the MeshInspector's mesh-to-voxel feature, where the inside of the mesh is assigned a value of -1 and the outside 1?

Our goal is to achieve fast results even in environments without CUDA, such as macOS.

My mesh is confirmed to be completely closed.

[Fedr]

My mesh is confirmed to be completely closed.

This is good. If in addition your mesh does not have self-intersections, then SignDetectionMode.ProjectionNormal is the best choice for you currently. It works rather fast even without CUDA acceleration.

I have tried SignDetectionMode.ProjectionNormal, but it calculates the distance at the mesh boundaries, while regions completely inside and outside the mesh are computed as 0.

It looks like the problem is in the line:

params.maxDistSq = min(voxel_size_x, voxel_size_y, voxel_size_z)

It actually limits distances computation to at most one voxel from the surface. Please try removing that line.

Would it be possible to code this in a way similar to the default parameters of the MeshInspector's mesh-to-voxel feature, where the inside of the mesh is assigned a value of -1 and the outside 1?

At this moment we return signed distances. So you need to take the sign from each value only.

Hope it helps.

[pty0220]

I tried running the code without the line:

params.maxDistSq = min(voxel_size_x, voxel_size_y, voxel_size_z)

It still works, but it seems to compute distances for the entire space. The inside of the mesh is calculated as a negative distance, while the outside is positive.

However, this approach appears to slow down the computation significantly. In comparison, the functionality provided by MeshInspector seems much faster.

[Fedr]

I see.

However, this approach appears to slow down the computation significantly. In comparison, the functionality provided by MeshInspector seems much faster.

What tool in MeshInspector do you mean exactly?

[pty0220]

This video shows what I exactly want to do.
I didn't make any change when I doing "mesh to voxel " function

Thank you for your kind response.

mesh.to.voxel.mp4

[Fedr]

Yes, I see.

Unfortunately, meshToDistanceVolume function does not support that mode yet. We are going to implement it soon.

Meanwhile, please try to call other function. Below C++ names are given, but they shall be available in python as well:

First:

MRVOXELS_API Expected<VdbVolume> meshToVolume( const Mesh& mesh, const MeshToVolumeParams& params = {} );

with MeshToVolumeParams.type = Type::Signed.

Then:

MRVOXELS_API Expected<SimpleVolumeMinMax> vdbVolumeToSimpleVolume(
    const VdbVolume& vdbVolume, const Box3i& activeBox = Box3i(), ProgressCallback cb = {} );

to get the same volume representation as above.

[pty0220]

Here's a revised version of your message with improved grammar and phrasing:

As per your advice, I tried the following code:

voxel_size_x, voxel_size_y, voxel_size_z = spacing
voxel_dims = np.array([bounds[0] / spacing[0], bounds[1] / spacing[1], bounds[2] / spacing[2]]).astype(np.int16)
voxel_dims = voxel_dims + 1

params = mm.MeshToVolumeParams()
params.voxelSize = mm.Vector3f(voxel_size_x, voxel_size_y, voxel_size_z)
params.type = mm.MeshToVolumeParamsType.Signed
params.worldXf = mm.AffineXf3f.translation(mm.Vector3f(origin[0], origin[1], origin[2]))

vdbVolume = mm.meshToVolume(mesh, params)

box = mm.Box3i(mm.Vector3i(0, 0, 0), mm.Vector3i(voxel_dims[0], voxel_dims[1], voxel_dims[2]))
volume = mm.vdbVolumeToSimpleVolume(vdbVolume, box)

The implementation is extremely fast, and the results are exactly what I want in terms of values.

However, the spatial coordinates of the generated volume do not align with the mesh. The object in the volume always appears centered within the volume.

It seems that params.worldXf is not working as intended (even when I input random numbers, it has no effect on the output).

Could you provide a solution to this issue?

[Grantim]

Hello!

In MeshLib "Voxels" or "Volumes" are always on positive space octet: actually, they are not "present" in space, voxels are just indexed by its own id.
So Voxel (0,0,0) is simply first voxel (0,0,1) next one by x axis, (0,1,0)-next by y and (1,0,0) - next by Z.
If you want to map 3d voxel id to world space you need to do following operation:

voxelSize3f = mm.Vector3f(voxel_size_x, voxel_size_y, voxel_size_z)
voxelCoord3f = mm.Vector3f( voxel_id_x, voxel_id_y, voxel_id_z )
worldCoord = mm.Vector3f(origin[0], origin[1], origin[2]) + mm.mult( voxelSize3f , voxelCoord3f  )
# optionally add half voxel size if you need center of the voxel
worldCoord += 0.5 * voxelSize3f