Function smoothSelection

source/MRVoxels/MRToolPath.cpp:1691–1775

}

FaceBitSet smoothSelection( Mesh& mesh, const FaceBitSet& region, float expandOffset, float shrinkOffset )
{
    auto innerVerts = getIncidentVerts( mesh.topology, region );
    auto dists = computeSurfaceDistances( mesh, innerVerts );
    BitSetParallelFor( getInnerVerts( mesh.topology, region ), [&] ( VertId v )
    {
        dists[v] = -dists[v];
    } );

    auto isolines = extractIsolines( mesh.topology, dists, expandOffset );

    HashMap<VertId, float> startVerticesWithDists;
    const auto components = MeshComponents::getAllComponentsVertsSeparatedByPaths( mesh, isolines );
    VertBitSet extendedVerts;
    for ( const auto& component : components )
    {
        if ( component.intersects( innerVerts ) )
            extendedVerts |= component;
    }

    for ( const auto& isoline : isolines )
    {
        Polyline3 polyline;
        polyline.addFromSurfacePath( mesh, isoline );

        for ( const auto& ep : isoline )
        {
            const VertId org = mesh.topology.org( ep.e );
            const VertId dest = mesh.topology.dest( ep.e );

            if ( ep.inVertex() )
            {
                startVerticesWithDists.insert_or_assign( org, 0.0f );
                continue;
            }

            auto proj = findProjectionOnPolyline( mesh.points[org], polyline );
            startVerticesWithDists.insert_or_assign( org, sqrt( proj.distSq ) );

            proj = findProjectionOnPolyline( mesh.points[dest], polyline );
            startVerticesWithDists.insert_or_assign( dest, sqrt( proj.distSq ) );
        }
    }

    dists = computeSurfaceDistances( mesh, startVerticesWithDists );

    BitSetParallelFor( extendedVerts, [&] ( VertId v )
    {
        dists[v] = -dists[v];
    } );

    isolines = extractIsolines( mesh.topology, dists, shrinkOffset );
       
    FaceBitSet res;

    const auto origMesh = mesh;

    const auto meshContours = convertSurfacePathsToMeshContours( mesh, isolines );