Deprecate old version of MeshBuilder::fromTriangles

source/MRMesh/MRContoursCut.cpp

@@ -1627,12 +1627,12 @@ TEST( MRMesh, BooleanIntersectionsSort )
         { 8.92162418f, 14.4169340f,-0.203402281f },
         { 8.95297337f, 14.4501600f,-0.191835344f }
     };
-    std::vector<MeshBuilder::Triangle> trisA = 
+    Triangulation tA = 
     {
-        { 0_v, 1_v, 3_v, 0_f },
-        { 0_v, 3_v, 2_v, 1_f }
+        { 0_v, 1_v, 3_v },
+        { 0_v, 3_v, 2_v }
     };
-    meshA.topology = MeshBuilder::fromTriangles( trisA );
+    meshA.topology = MeshBuilder::fromTriangles( tA );
 
     Mesh meshB;
     meshB.points = std::vector<Vector3f>
@@ -1643,13 +1643,13 @@ TEST( MRMesh, BooleanIntersectionsSort )
         { 8.99934673f, 14.4161797f, -0.209171638f },
         { 8.91623878f, 14.3510427f, -0.205425277f }
     };
-    std::vector<MeshBuilder::Triangle> trisB =
+    Triangulation tB =
     {
-        { 0_v, 1_v, 2_v, 0_f },
-        { 0_v, 2_v, 4_v, 1_f },
-        { 2_v, 3_v, 4_v, 2_f }
+        { 0_v, 1_v, 2_v },
+        { 0_v, 2_v, 4_v },
+        { 2_v, 3_v, 4_v }
     };
-    meshB.topology = MeshBuilder::fromTriangles( trisB );
+    meshB.topology = MeshBuilder::fromTriangles( tB );
     auto converters = getVectorConverters( meshA, meshB );
     auto intersections = findCollidingEdgeTrisPrecise( meshA, meshB, converters.toInt );
     auto contours = orderIntersectionContours( meshA.topology, meshB.topology, intersections );

source/MRMesh/MRMeshBuilder.cpp

@@ -811,21 +811,14 @@ MeshTopology fromVertexTriples( const std::vector<VertId> & vertTriples )
 {
     MR_TIMER
     const size_t numTri = vertTriples.size() / 3;
-    std::vector<Triangle> tris;
-    tris.reserve( numTri );
-
-    for ( size_t t = 0; t < numTri; ++t )
+    Triangulation t;
+    t.reserve( numTri );
+    
+    for ( size_t f = 0; f < numTri; ++f )
     {
-        Triangle tri
-        {
-            vertTriples[3*t],
-            vertTriples[3*t+1], 
-            vertTriples[3*t+2],
-            FaceId( int( t ) )
-        };
-        tris.push_back( tri );
+        t.push_back( { vertTriples[3*f], vertTriples[3*f+1], vertTriples[3*f+2] } );
     }
-    return fromTriangles( tris );
+    return fromTriangles( t );
 }
 
 Mesh fromPointTriples( const std::vector<ThreePoints> & posTriples )

source/MRMesh/MRMeshBuilder.h

@@ -33,7 +33,7 @@ namespace MeshBuilder
 
 /// construct mesh topology from a set of triangles with given ids;
 /// if skippedTris is given then it receives all input triangles not added in the resulting topology
-/*[[deprecated]]*/ MRMESH_API MeshTopology fromTriangles( const std::vector<Triangle> & tris, std::vector<Triangle> * skippedTris = nullptr );
+[[deprecated]] MRMESH_API MeshTopology fromTriangles( const std::vector<Triangle> & tris, std::vector<Triangle> * skippedTris = nullptr );
 MRMESH_API MeshTopology fromTriangles( const Triangulation & t, const BuildSettings & settings = {} );
 
 struct VertDuplication

source/MRMesh/MRMeshDecimateParallel.cpp

@@ -167,23 +167,20 @@ DecimateResult decimateParallelMesh( MR::Mesh & mesh, const DecimateParallelSett
     // recombine mesh from parts
     MR::Vector<MR::QuadraticForm3f, MR::VertId> unitedVertForms( mesh.topology.vertSize() );
     VertBitSet bdOfSomePiece( mesh.topology.vertSize() );
-    std::vector<MR::MeshBuilder::Triangle> tris;
-    FaceId nextFace{ 0 };
+    Triangulation t;
     if ( settings.region )
         settings.region->clear();
     for ( const auto & submesh : submeshes )
     {
-        for ( auto t : submesh.m.topology.getValidFaces() )
+        for ( auto f : submesh.m.topology.getValidFaces() )
         {
-            MR::MeshBuilder::Triangle tri;
-            tri.f = nextFace;
-            ++nextFace;
-            submesh.m.topology.getTriVerts( t, tri.v );
+            ThreeVertIds tri;
+            submesh.m.topology.getTriVerts( f, tri );
             for ( int i = 0; i < 3; ++i )
-                tri.v[i] = submesh.subVertToOriginal[ tri.v[i] ];
-            tris.push_back( tri );
-            if ( settings.region && submesh.region.test( t ) )
-                settings.region->autoResizeSet( tri.f );
+                tri[i] = submesh.subVertToOriginal[ tri[i] ];
+            t.push_back( tri );
+            if ( settings.region && submesh.region.test( f ) )
+                settings.region->autoResizeSet( t.backId() );
         }
         for ( auto v : submesh.m.topology.getValidVerts() )
         {
@@ -204,7 +201,7 @@ DecimateResult decimateParallelMesh( MR::Mesh & mesh, const DecimateParallelSett
     if ( settings.progressCallback && !settings.progressCallback( 0.8f ) )
         return res;
 
-    mesh.topology = fromTriangles( tris );
+    mesh.topology = MeshBuilder::fromTriangles( t );
 
     if ( settings.progressCallback && !settings.progressCallback( 0.85f ) )
         return res;

source/MRMesh/MRMeshDiff.cpp

@@ -85,13 +85,13 @@ void MeshDiff::applyAndSwap( Mesh & m )
 
 TEST(MRMesh, MeshDiff) 
 {
-    std::vector<MeshBuilder::Triangle> tris
+    Triangulation t
     { 
-        { 0_v, 1_v, 2_v, 0_f },
-        { 0_v, 2_v, 3_v, 1_f }
+        { 0_v, 1_v, 2_v },
+        { 0_v, 2_v, 3_v }
     };
     Mesh mesh0;
-    mesh0.topology = MeshBuilder::fromTriangles( tris );
+    mesh0.topology = MeshBuilder::fromTriangles( t );
     mesh0.points.emplace_back( 0.f, 0.f, 0.f );
     mesh0.points.emplace_back( 1.f, 0.f, 0.f );
     mesh0.points.emplace_back( 1.f, 1.f, 0.f );

source/MRMesh/MRMeshEigen.cpp

@@ -13,13 +13,13 @@ MeshTopology topologyFromEigen( const Eigen::MatrixXi & F )
     MR_TIMER
     assert( F.cols() == 3 );
     int numTris = (int)F.rows();
-    std::vector<MeshBuilder::Triangle> tris;
-    tris.reserve( numTris );
+    Triangulation t;
+    t.reserve( numTris );
 
     for ( int r = 0; r < numTris; ++r )
-        tris.emplace_back( VertId( F(r, 0) ), VertId( F(r, 1) ), VertId( F(r, 2) ), FaceId( r ) );
+        t.push_back( { VertId( F(r, 0) ), VertId( F(r, 1) ), VertId( F(r, 2) ) } );
 
-    return fromTriangles( tris );
+    return MeshBuilder::fromTriangles( t );
 }
 
 Mesh meshFromEigen( const Eigen::MatrixXd & V, const Eigen::MatrixXi & F )

source/MRMesh/MRMeshLoad.cpp

@@ -87,25 +87,21 @@ tl::expected<Mesh, std::string> fromOff( std::istream& in, Vector<Color, VertId>
             return tl::make_unexpected( std::string( "Loading canceled" ) );
     }
 
-    std::vector<MeshBuilder::Triangle> tris;
-    tris.reserve( numPolygons );
+    Triangulation t;
+    t.reserve( numPolygons );
 
     for ( int i = 0; i < numPolygons; ++i )
     {
         int k, a, b, c;
         in >> k >> a >> b >> c;
         if ( !in || k != 3 )
             return tl::make_unexpected( std::string( "Polygons read error" ) );
-        tris.emplace_back( VertId( a ), VertId( b ), VertId( c ), FaceId( i ) );
+        t.push_back( { VertId( a ), VertId( b ), VertId( c ) } );
         if ( callback && !( i & 0x3FF ) && !callback( float( i ) / numPolygons* 0.5f + 0.5f ) )
             return tl::make_unexpected( std::string( "Loading canceled" ) );
     }
 
-    Mesh res;
-    res.topology = MeshBuilder::fromTriangles( tris );
-    res.points.vec_ = std::move( points );
-
-    return std::move( res );
+    return Mesh::fromTriangles( std::move( points ), t );
 }
 
 tl::expected<Mesh, std::string> fromObj( const std::filesystem::path & file, Vector<Color, VertId>*, ProgressCallback callback )
@@ -523,14 +519,14 @@ tl::expected<Mesh, std::string> fromCtm( std::istream & in, Vector<Color, VertId
     for ( VertId i{0}; i < (int)vertCount; ++i )
         mesh.points[i] = Vector3f( vertices[3*i], vertices[3*i+1], vertices[3*i+2] );
 
-    std::vector<MeshBuilder::Triangle> tris;
-    tris.reserve( triCount );
+    Triangulation t;
+    t.reserve( triCount );
     for ( FaceId i{0}; i < (int)triCount; ++i )
-        tris.emplace_back( VertId( (int)indices[3*i] ), VertId( (int)indices[3*i+1] ), VertId( (int)indices[3*i+2] ), i );
+        t.push_back( { VertId( (int)indices[3*i] ), VertId( (int)indices[3*i+1] ), VertId( (int)indices[3*i+2] ) } );
 
-    mesh.topology = MeshBuilder::fromTriangles( tris );
+    mesh.topology = MeshBuilder::fromTriangles( t );
 
-    return std::move( mesh );
+    return mesh;
 }
 
 tl::expected<Mesh, std::string> fromAnySupportedFormat( const std::filesystem::path & file, Vector<Color, VertId>* colors, ProgressCallback callback )