How do I set a negative weight value in the official example [Mesh Weighted Offset]?

[gecpgecp]

Thank you so much for your help：
The example [Mesh Weighted Offset] provided by the management uses the meshShell method to offset mesh points. The code is as follows:

However, meshShell can only set positive weight values. I changed scalars[v] = std::fabs(mesh.points[v].x / 5.0f) to scalars[v] = mesh.points[v].x / 5.0f, hoping to achieve a positive weight causing the mesh points to move outwards and a negative weight causing the mesh to shrink inwards. However, I found that after setting it to negative, the areas that should have shrunk became damaged. Is there any way I can achieve this functionality?

Thank you very much for your help.

[Grantim]

Hello!

To use negative weights or offset you need to enable it using:

    params.dist.bidirectionalMode = false;

but unfortunately it seems that there are some bugs if weights are actually negative (we will fix them soon).

This mode still works if all weights are non-negative, so you can try code like this:

{
    // Create some mesh
    auto mesh = MR::makeTorus();

    // Create VertScalars obj with weights for every vertex
    auto vertSize = mesh.topology.vertSize();
    MR::VertScalars scalars( vertSize );
    MR::ParallelFor( scalars, [&] ( MR::VertId v )
    {
        scalars[v] = mesh.points[v].x / 5.0f; // Individual extra offset sizes for points
    } );

    auto params = MR::WeightedShell::ParametersMetric();
    // Algorithm is voxel based, voxel size affects performance and form of result mesh
    params.voxelSize = MR::suggestVoxelSize( mesh, 1000 );
    // common basic offset applied for all point
    // Vertex-specific weighted offsets applied after the basic one
    auto minmax = std::minmax_element( MR::begin( scalars ), MR::end( scalars ) );
    auto minW = *minmax.first;
    params.offset = 0.2f + minW; // compensate offset by adding minimum weight to it
    params.dist.maxWeight = *minmax.second - minW; // should always have maximum between weights provided
    MR::ParallelFor( scalars, [&] ( MR::VertId v )
    {
        scalars[v] -= minW; // compensate weights to be >= 0
    } );
    params.dist.bidirectionalMode = false;

    auto res = MR::WeightedShell::meshShell( mesh, scalars, params );
    if ( !res.has_value() )
    {
        std::cerr << res.error();
        return 1;
    }

    auto saveRes = MR::MeshSave::toAnySupportedFormat( *res, "offset_weighted_nobidir.stl" );
    if ( !saveRes.has_value() )
    {
        std::cerr << saveRes.error();
        return 1;
    }
    return 0;
}

Please note that here we normalize weights to be positive and shift offset to compensate it, so result should be the same.

[gecpgecp]

Thank you very much for your prompt reply.
I tested the method you mentioned above. It seems that this method only solves the assertion failure when the weights are negative. It still cannot cause the points where offset + scalars[v] < 0 to shrink inwards. Mesh breakage and missing parts appear at positions where offset + scalars[v] < 0.

I used a sphere model for testing, as shown in the image below. The broken areas on the left side of the mesh, represented by the black wireframe, correspond to offset + scalars[v] < 0.

My code is as follows，I eagerly await your solution.

int main()
{
    // Create some mesh
    auto mesh = MR::makeUVSphere(1,16,16);

    // Create VertScalars obj with weights for every vertex
    auto vertSize = mesh.topology.vertSize();
    MR::VertScalars scalars(vertSize);
    MR::ParallelFor(scalars, [&](MR::VertId v)
        {
            scalars[v] = mesh.points[v].x / 5.0f; // Individual extra offset sizes for points
        });

    auto params = MR::WeightedShell::ParametersMetric();
    // Algorithm is voxel based, voxel size affects performance and form of result mesh
    params.voxelSize = MR::suggestVoxelSize(mesh, 1000);
    // common basic offset applied for all point
    // Vertex-specific weighted offsets applied after the basic one
    auto minmax = std::minmax_element(MR::begin(scalars), MR::end(scalars));
    auto minW = *minmax.first;
    params.offset = 0.1 + minW; // compensate offset by adding minimum weight to it
    params.dist.maxWeight = *minmax.second - minW; // should always have maximum between weights provided
    MR::ParallelFor(scalars, [&](MR::VertId v)
        {
            scalars[v] -= minW; // compensate weights to be >= 0
        });
    params.dist.bidirectionalMode = false;

    auto res = MR::WeightedShell::meshShell(mesh, scalars, params);
    if (!res.has_value())
    {
        std::cerr << res.error();
        return 1;
    }

    auto saveRes = MR::MeshSave::toAnySupportedFormat(*res, "d:/2.ply");
    if (!saveRes.has_value())
    {
        std::cerr << saveRes.error();
        return 1;
    }
    return 0;
}

[Fedr]

Thanks for reporting this. We are working on a fix in the branch: #5506

In your case the result looks as follows:

[Fedr]

Merged in master, please give it a try.

[gecpgecp]

Thank you for the prompt reply and fix. The figure you mentioned is exactly what I needed. I will test the effect under more complex mesh.

[gecpgecp]

There is another question I would like to ask, can the meshShell interface be similar to MR:: generalizedOffsetMesh params.fwn = std::make_sharedMR::Cuda::FastWindingNumber(mesh); To set up the use of CUDA to accelerate FWN calculation, no such setting was found in the parameters of meshShell.

[Fedr]

For now we have no CUDA acceleration for weighted offset. But it is a good idea, we will think about it.

[gecpgecp]

Thank you, Really look forward to your updates.