How to use meshlib to obtain the closed contour （silhouette edges） of a mesh from a specific viewpoint direction?

[alpinebuster]

Refer to silhouette projection for a visualization example.

[Fedr]

It is relatively easy to find mesh's edges that are on the boundary between the triangles looking at the camera and the triangles looking away from the camera (see Select Camera-Facing tool in MeshInspector):

This will give us contours in 3D.

Then these edges can be projected on a plane orthogonal to camera view line. But resulting 2D contours can self-intersect. It will be necessary to clean them, by removing occluded parts of the contours. Is it what you would like to get?

[alpinebuster]

Yes, could you provide the C++ APIs that are needed to implement this process? Merci beaucoup🙇🏻‍♂️

[Grantim]

Hello!

Code like this should work:

#include "MRMesh/MRMesh.h"
#include "MRMesh/MRMeshLoad.h"
#include "MRMesh/MRVector3.h"
#include "MRMesh/MRBitSetParallelFor.h"
#include "MRMesh/MRRegionBoundary.h"
#include "MRMesh/MRParallelFor.h"
#include "MRMesh/MR2to3.h"
#include "MRMesh/MR2DContoursTriangulation.h"
#include "MRMesh/MRMeshSave.h"

int main()
{
    // Load mesh
    auto meshRes = MR::MeshLoad::fromAnySupportedFormat( "path/to/mesh.stl" );
    if ( !meshRes.has_value() )
    {
        std::cerr << meshRes.error();
        return 1;
    }

    // Specify projection direction
    MR::Vector3f lookDirection = MR::Vector3f( 0.0f, 0.0f, 1.0f );

    // Find faces that looks in this direction
    MR::FaceBitSet facesLookingInThisDirection( meshRes->topology.faceSize() );
    MR::BitSetParallelFor( meshRes->topology.getValidFaces(), [&] ( MR::FaceId f )
    {
        if ( MR::dot( meshRes->normal( f ), lookDirection ) > 0.0f )
            facesLookingInThisDirection.set( f );
    } );

    // Find boundaries of direction looking faces
    auto boundaries = MR::findRightBoundary( meshRes->topology, facesLookingInThisDirection );

    // Project boundaries to 2d plane
    auto [x, y] = lookDirection.perpendicular();
    auto fromPlaneRot = MR::Matrix3f::fromColumns( x, y, lookDirection );
    auto toPlaneRot = fromPlaneRot.inverse();

    MR::Contours2f contours( boundaries.size() );
    MR::ParallelFor( contours, [&] ( size_t i )
    {
        const auto& bound = boundaries[i];
        auto& cont = contours[i];
        cont.resize( bound.size() + 1 );
        MR::ParallelFor( bound, [&] ( size_t j )
        {
            cont[j] = MR::to2dim( toPlaneRot * meshRes->orgPnt( bound[j] ) );
        } );
        cont.back() = cont.front(); // close loops
    } );

    // Find silhouette outline
    auto outline = MR::PlanarTriangulation::getOutline( contours );
    // Triangulate outline
    auto projectedMesh = MR::PlanarTriangulation::triangulateContours( outline );

    // Project silhouette mesh back to original plane
    projectedMesh.transform( MR::AffineXf3f::linear( fromPlaneRot ) );

    // Save projected mesh
    auto saveRes = MR::MeshSave::toAnySupportedFormat( projectedMesh, "path/to/silhouette_mesh.stl" );
    if ( !saveRes.has_value() )
    {
        std::cerr << saveRes.error();
        return 1;
    }
    return 0;
}

[alpinebuster]

I understand how this works now, which will help me better comprehend how MeshLib works. Thank you again for taking the time to address the issue amidst your busy schedule 🖖 !