findDirMinMaxBruteForce functions (#4478)

Author: Fedr

source/MRMesh/MRDirMaxBruteForce.cpp

@@ -77,4 +77,57 @@ VertId findDirMaxBruteForce( const Vector3f & dir, const MeshPart & mp )
     return pv.v;
 }
 
+MinMaxArg<float, VertId> findDirMinMaxBruteForce( const Vector3f & dir, const VertCoords & points, const VertBitSet * region )
+{
+    MR_TIMER;
+
+    return parallel_reduce( tbb::blocked_range( 0_v, points.endId(), 1024 ), MinMaxArg<float, VertId>{},
+        [&] ( const auto & range, MinMaxArg<float, VertId> curr )
+        {
+            for ( VertId v = range.begin(); v < range.end(); ++v )
+            {
+                if ( !contains( region, v ) )
+                    continue;
+                curr.include( dot( points[v], dir ), v );
+            }
+            return curr;
+        },
+        [] ( MinMaxArg<float, VertId> a, const MinMaxArg<float, VertId> & b ) { a.include( b ); return a; }
+    );
+}
+
+MinMaxArg<float, VertId> findDirMinMaxBruteForce( const Vector3f & dir, const PointCloud & cloud )
+{
+    return findDirMinMaxBruteForce( dir, cloud.points, &cloud.validPoints );
+}
+
+MinMaxArg<float, VertId> findDirMinMaxBruteForce( const Vector3f & dir, const Polyline3 & polyline )
+{
+    return findDirMinMaxBruteForce( dir, polyline.points, &polyline.topology.getValidVerts() );
+}
+
+MinMaxArg<float, VertId> findDirMinMaxBruteForce( const Vector3f & dir, const MeshPart & mp )
+{
+    if ( !mp.region )
+        return findDirMinMaxBruteForce( dir, mp.mesh.points, &mp.mesh.topology.getValidVerts() );
+
+    MR_TIMER;
+    return parallel_reduce( tbb::blocked_range( 0_f, FaceId( mp.mesh.topology.faceSize() ), 1024 ), MinMaxArg<float, VertId>{},
+        [&] ( const auto & range, MinMaxArg<float, VertId> curr )
+        {
+            for ( FaceId f = range.begin(); f < range.end(); ++f )
+            {
+                if ( !mp.region->test( f ) )
+                    continue;
+                VertId vs[3];
+                mp.mesh.topology.getTriVerts( f, vs );
+                for ( auto v : vs )
+                    curr.include( dot( mp.mesh.points[v], dir ), v );
+            }
+            return curr;
+        },
+        [] ( MinMaxArg<float, VertId> a, const MinMaxArg<float, VertId> & b ) { a.include( b ); return a; }
+    );
+}
+
 } //namespace MR

source/MRMesh/MRDirMaxBruteForce.h

@@ -1,11 +1,12 @@
 #pragma once
 
 #include "MRMeshFwd.h"
+#include "MRMinMaxArg.h"
 
 namespace MR
 {
 
-/// finds the points having the largest projection on given direction by traversing all region points
+/// finds the point having the largest projection on given direction by traversing all region points
 [[nodiscard]] MRMESH_API VertId findDirMaxBruteForce( const Vector3f & dir, const VertCoords & points, const VertBitSet * region = nullptr );
 
 /// finds the point in the cloud having the largest projection on given direction by traversing all valid points
@@ -17,4 +18,16 @@ namespace MR
 /// finds the vertex in the mesh part having the largest projection on given direction by traversing all (region) faces
 [[nodiscard]] MRMESH_API VertId findDirMaxBruteForce( const Vector3f & dir, const MeshPart & mp );
 
+/// finds the points having the smallest and the largest projections on given direction by traversing all region points
+[[nodiscard]] MRMESH_API MinMaxArg<float, VertId> findDirMinMaxBruteForce( const Vector3f & dir, const VertCoords & points, const VertBitSet * region = nullptr );
+
+/// finds the points in the cloud having the smallest and the largest projections on given direction by traversing all valid points
+[[nodiscard]] MRMESH_API MinMaxArg<float, VertId> findDirMinMaxBruteForce( const Vector3f & dir, const PointCloud & cloud );
+
+/// finds the vertex in the polyline having the smallest and the largest projections on given direction by traversing all valid vertices
+[[nodiscard]] MRMESH_API MinMaxArg<float, VertId> findDirMinMaxBruteForce( const Vector3f & dir, const Polyline3 & polyline );
+
+/// finds the vertices in the mesh part having the smallest and the largest projections on given direction by traversing all (region) faces
+[[nodiscard]] MRMESH_API MinMaxArg<float, VertId> findDirMinMaxBruteForce( const Vector3f & dir, const MeshPart & mp );
+
 } //namespace MR

source/MRMesh/MRMinMaxArg.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <limits>
+#include <utility>
 
 namespace MR
 {
@@ -13,6 +14,46 @@ struct MinMaxArg
     T min = std::numeric_limits<T>::max();
     T max = std::numeric_limits<T>::lowest();
     I minArg, maxArg;
+
+    auto minPair() const { return std::make_pair( min, minArg ); }
+    auto maxPair() const { return std::make_pair( max, maxArg ); }
+
+    /// changes min(Arg) and max(Arg) if necessary to include given point
+    void include( const std::pair<T,I>& p )
+    {
+        if ( p < minPair() )
+        {
+            min = p.first;
+            minArg = p.second;
+        }
+        if ( p > maxPair() )
+        {
+            max = p.first;
+            maxArg = p.second;
+        }
+    }
+
+    /// changes min(Arg) and max(Arg) if necessary to include given point
+    void include( T v, I arg )
+    {
+        return include( std::make_pair( v, arg ) );
+    }
+
+    /// changes min(Arg) and max(Arg) if necessary to include given segment
+    void include( const MinMaxArg & s )
+    {
+        // it shall work with default initialized this and s
+        if ( s.minPair() < minPair() )
+        {
+            min = s.min;
+            minArg = s.minArg;
+        }
+        if ( s.maxPair() > maxPair() )
+        {
+            max = s.max;
+            maxArg = s.maxArg;
+        }
+    }
 };
 
 } //namespace MR