Introduce curve.totalLength (#5699)

* Introduce `curve.totalLength`

 - CurveFunc argument is now expected [0,totalLength)
 - Bend function: curve time now has same "space" for stretched and non-stretched mode
 - Remove `unitLength` argument from some functions because it is not longer needed

* add include

* CR Fix

Author: Grantim

source/MRMesh/MRAlignContoursToMesh.cpp

@@ -11,6 +11,7 @@
 #include "MRMeshComponents.h"
 #include "MRParallelFor.h"
 #include "MRRegionBoundary.h"
+#include <cmath>
 
 namespace MR
 {
@@ -117,6 +118,12 @@ Expected<Mesh> bendContoursAlongCurve( const Contours2f& contours, const CurveFu
     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();
@@ -132,19 +139,21 @@ Expected<Mesh> bendContoursAlongCurve( const Contours2f& contours, const CurveFu
     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 xInBoxRelPivot = compCenter.x - pivotInBoxX;
+        float xInBox = compCenter.x - pivotInBoxX;
         if ( params.stretch )
-            xInBoxRelPivot /= diagonal.x;
+            xInBox *= stretchMod;
 
-        float curveTime = params.pivotCurveTime + xInBoxRelPivot;
+        float curveTime = startCurvePos + xInBox;
         if ( params.periodicCurve )
-            curveTime = curveTime - std::floor( curveTime );
-        const auto pos = curve( curveTime );
+            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;
@@ -188,19 +197,19 @@ Expected<Mesh> bendContoursAlongSurfacePath( const Contours2f& contours, const M
     const BendContoursAlongCurveParams& params )
 {
     MR_TIMER;
-    return curveFromPoints( meshPathCurvePoints( mesh, start, path, end ), params.stretch )
+    return curveFromPoints( meshPathCurvePoints( mesh, start, path, end ) )
         .and_then( [&]( auto && curve ) { return bendContoursAlongCurve( contours, curve, params ); } );
 }
 
 Expected<Mesh> bendContoursAlongSurfacePath( const Contours2f& contours, const Mesh& mesh, const SurfacePath& path,
     const BendContoursAlongCurveParams& params )
 {
     MR_TIMER;
-    return curveFromPoints( meshPathCurvePoints( mesh, path ), params.stretch )
+    return curveFromPoints( meshPathCurvePoints( mesh, path ) )
         .and_then( [&]( auto && curve ) { return bendContoursAlongCurve( contours, curve, params ); } );
 }
 
-Expected<std::vector<float>> findPartialLens( const CurvePoints& cp, bool unitLength, float * outCurveLen )
+Expected<std::vector<float>> findPartialLens( const CurvePoints& cp, float * outCurveLen )
 {
     MR_TIMER;
     if ( cp.size() < 2 )
@@ -220,13 +229,6 @@ Expected<std::vector<float>> findPartialLens( const CurvePoints& cp, bool unitLe
     if ( lens.back() <= 0 )
         return unexpected( "curve has zero length" );
 
-    if ( unitLength )
-    {
-        // to relative lengths
-        const auto factor = 1 / lens.back();
-        for ( auto & l : lens )
-            l *= factor;
-    }
     return lens;
 }
 
@@ -265,30 +267,36 @@ CurvePoint getCurvePoint( const CurvePoints& cp, const std::vector<float> & lens
     return res;
 }
 
-Expected<CurveFunc> curveFromPoints( const CurvePoints& cp, bool unitLength, float * outCurveLen )
+Expected<CurveFunc> curveFromPoints( const CurvePoints& cp, float* outCurveLen )
 {
     MR_TIMER;
-    auto maybeLens = findPartialLens( cp, unitLength, outCurveLen );
+    auto maybeLens = findPartialLens( cp, outCurveLen );
     if ( !maybeLens )
         return unexpected( std::move( maybeLens.error() ) );
 
-    return [&cp, lens = std::move( *maybeLens )]( float p )
+    CurveFunc res;
+    res.totalLength = maybeLens->back();
+    res.func = [&cp, lens = std::move( *maybeLens )] ( float p )
     {
         return getCurvePoint( cp, lens, p );
     };
+    return res;
 }
 
-Expected<CurveFunc> curveFromPoints( CurvePoints&& cp, bool unitLength, float * outCurveLen )
+Expected<CurveFunc> curveFromPoints( CurvePoints&& cp, float * outCurveLen )
 {
     MR_TIMER;
-    auto maybeLens = findPartialLens( cp, unitLength, outCurveLen );
+    auto maybeLens = findPartialLens( cp, outCurveLen );
     if ( !maybeLens )
         return unexpected( std::move( maybeLens.error() ) );
 
-    return [cp = std::move( cp ), lens = std::move( *maybeLens )]( float p )
+    CurveFunc res;
+    res.totalLength = maybeLens->back();
+    res.func = [&cp, lens = std::move( *maybeLens )] ( float p )
     {
         return getCurvePoint( cp, lens, p );
     };
+    return res;
 }
 
 CurvePoints meshPathCurvePoints( const Mesh& mesh, const MeshTriPoint & start, const SurfacePath& path, const MeshTriPoint & end )

source/MRMesh/MRAlignContoursToMesh.h

@@ -41,23 +41,21 @@ MRMESH_API Expected<Mesh> alignContoursToMesh( const Mesh& mesh, const Contours2
 struct BendContoursAlongCurveParams
 {
     /// Position on the curve, where bounding box's pivot point is mapped
+    /// (0) - start of the curve, (1) - end of the curve
     float pivotCurveTime = 0;
 
     /// Position of the curve(pivotCurveTime) in the contours' bounding box:
     /// (0, 0) - bottom left, (0, 1) - bottom right, (0.5, 0.5) - center, (1, 1) - top right
     Vector2f pivotBoxPoint{0.0f, 0.0f};
 
-    /// if true, curve parameter will be always within [0,1) with repetition: xr := x - floor(x)
+    /// if true, curve parameter will be always within [0,curve.totalLength) with repetition: xr := mod( x, curve.totalLength )
     bool periodicCurve = false;
 
-    /// stretch all contours along curve to fit in unit curve range
+    /// stretch all contours along curve to fit in curve.totalLength
     bool stretch = true;
 
     /// Contours extrusion outside of curve level
     float extrusion{ 1.0f };
-
-    /// To allow passing Python lambdas into `curve`.
-    MR_BIND_PREFER_UNLOCK_GIL_WHEN_USED_AS_PARAM
 };
 
 /// Converts contours in thick mesh, and deforms it along given path
@@ -73,9 +71,8 @@ MRMESH_API Expected<Mesh> bendContoursAlongSurfacePath( const Contours2f& contou
 
 /// given a polyline by its vertices, computes partial lengths along the polyline from the initial point;
 /// return an error if the polyline is less than 2 points or all points have exactly the same location
-/// \param unitLength if true, then the lengths are normalized for the last point to have unit length
-/// \param outCurveLen optional output of the total polyline length (before possible normalization)
-MRMESH_API Expected<std::vector<float>> findPartialLens( const CurvePoints& cp, bool unitLength = true, float * outCurveLen = nullptr );
+/// \param outCurveLen optional output of the total polyline length
+MRMESH_API Expected<std::vector<float>> findPartialLens( const CurvePoints& cp, float * outCurveLen = nullptr );
 
 /// given a polyline by its vertices, and partial lengths as computed by \ref findPartialLens,
 /// finds the location of curve point at the given parameter with extrapolation if p outside [0, lens.back()],
@@ -84,10 +81,9 @@ MRMESH_API Expected<std::vector<float>> findPartialLens( const CurvePoints& cp,
 
 /// given a polyline by its vertices, returns curve function representing it;
 /// return an error if the polyline is less than 2 points or all points have exactly the same location
-/// \param unitLength if true, then the lengths are normalized for the last point to have unit length
-/// \param outCurveLen optional output of the total polyline length (before possible normalization)
-MRMESH_API Expected<CurveFunc> curveFromPoints( const CurvePoints& cp, bool unitLength = true, float * outCurveLen = nullptr );
-MRMESH_API Expected<CurveFunc> curveFromPoints( CurvePoints&& cp, bool unitLength = true, float * outCurveLen = nullptr );
+/// \param outCurveLen optional output of the total polyline length
+MRMESH_API Expected<CurveFunc> curveFromPoints( const CurvePoints& cp, float * outCurveLen = nullptr );
+MRMESH_API Expected<CurveFunc> curveFromPoints( CurvePoints&& cp, float* outCurveLen = nullptr );
 
 /// converts polyline given as a number of MeshTriPoint/MeshEdgePoint into CurvePoints
 [[nodiscard]] MRMESH_API CurvePoints meshPathCurvePoints( const Mesh& mesh, const MeshTriPoint & start, const SurfacePath& path, const MeshTriPoint & end );

source/MRMesh/MRCurve.h

@@ -13,8 +13,17 @@ struct CurvePoint
     Vector3f snorm;///< the normal of the surface where the curve is located
 };
 
-/// curve given as a function: time -> point
-using CurveFunc = std::function<CurvePoint(float)>;
+struct CurveFunc
+{
+    /// curve given as a function: position along curve -> point
+    std::function<CurvePoint( float )> func;
+
+    /// total length of the given curve
+    float totalLength = 1.0f;
+
+    /// To allow passing Python lambdas into `func`.
+    MR_BIND_PREFER_UNLOCK_GIL_WHEN_USED_AS_PARAM
+};
 
 /// curve given as a number of points on it samples at arbitrary steps
 using CurvePoints = std::vector<CurvePoint>;

source/MRSymbolMesh/MRAlignTextToMesh.cpp

@@ -90,7 +90,7 @@ Expected<Mesh> alignTextToMesh(
 Expected<Mesh> bendTextAlongCurve( const CurveFunc& curve, const BendTextAlongCurveParams& params )
 {
     MR_TIMER;
-    if ( !curve )
+    if ( !curve.func )
     {
         assert( false );
         return unexpected( "No curve provided" );
@@ -139,7 +139,7 @@ Expected<Mesh> bendTextAlongCurve( const CurvePoints& cp, const BendTextAlongCur
     MR_TIMER;
 
     float curveLen = 0;
-    auto maybeCurveFunc = curveFromPoints( cp, params0.stretch, &curveLen );
+    auto maybeCurveFunc = curveFromPoints( cp, &curveLen );
     if ( !maybeCurveFunc )
         return unexpected( std::move( maybeCurveFunc.error() ) );
     assert( curveLen > 0 );

source/MRTest/MRBendTextAlongCurveTests.cpp

@@ -35,7 +35,7 @@ TEST( MRMesh, BendTextAlongCurve )
         };
     };
 
-    auto maybeText = bendTextAlongCurve( curve,
+    auto maybeText = bendTextAlongCurve( { .func = curve,.totalLength = 1.0f },
         BendTextAlongCurveParams{
             .symbolMesh = s,
             .fontHeight = 0.2f,