Function bendContoursAlongCurve

source/MRMesh/MRAlignContoursToMesh.cpp:114–195

}

Expected<Mesh> bendContoursAlongCurve( const Contours2f& contours, const CurveFunc& curve, const BendContoursAlongCurveParams& params )
{
    MR_TIMER;
    auto contoursMesh = PlanarTriangulation::triangulateContours( contours );
    auto bbox = contoursMesh.computeBoundingBox();
    if ( !bbox.valid() )
        return unexpected( "Contours mesh is empty" );

    if ( curve.totalLength <= 0.0f )
    {
        assert( !"invalid curve length" );
        return unexpected( "Invalid curve length" );
    }

    const float cStartDepth = bbox.diagonal() * 0.05f; // use relative depth to avoid floating errors
    addBaseToPlanarMesh( contoursMesh, -cStartDepth );
    contoursMesh.invalidateCaches();
    auto diagonal = bbox.size();
    diagonal.z = cStartDepth;
    const float pivotInBoxX = lerp( bbox.min.x, bbox.max.x, params.pivotBoxPoint.x );
    const float pivotInBoxY = lerp( bbox.min.y, bbox.max.y, params.pivotBoxPoint.y );

    const float plusOffset = std::abs( params.extrusion );
    const float minusOffset = cStartDepth - std::abs( params.extrusion );

    auto& contoursMeshPoints = contoursMesh.points;
    VertId firstBottomVert( contoursMeshPoints.size() / 2 );

    const auto components = MeshComponents::getAllComponents( contoursMesh );
    const auto stretchMod = curve.totalLength / diagonal.x;
    const auto startCurvePos = params.pivotCurveTime * curve.totalLength;
    // independently for each component of contoursMesh
    ParallelFor( components, [&]( size_t icomp )
    {
        const auto & compFaces = components[icomp];
        const auto compCenter = contoursMesh.computeBoundingBox( &compFaces ).center();
        float xInBox = compCenter.x - pivotInBoxX;
        if ( params.stretch )
            xInBox *= stretchMod;

        float curveTime = startCurvePos + xInBox;
        if ( params.periodicCurve )
            curveTime = curveTime - std::floor( curveTime / curve.totalLength ) * curve.totalLength;
        const auto pos = curve.func( curveTime );

        const auto vecx = pos.dir;
        const auto norm = pos.snorm;
        const auto vecy = cross( vecx, -norm ).normalized();

        auto rotQ = Quaternionf( Vector3f::plusX(), vecx );
        // handle degenerated case
        auto newY = rotQ( Vector3f::plusY() );
        auto dotY = dot( newY, vecy );
        if ( std::abs( std::abs( dotY ) - 1.0f ) < 10.0f * std::numeric_limits<float>::epsilon() )
        {
            if ( dotY < 0.0f )
                rotQ = Quaternionf( vecx, PI_F ) * rotQ;
        }