Add convex hull algorithm for 2D contours (#4770)

* Add convex hull algorithm for 2D contours

* Add unit tests

* Don't compute angle values

* Don't allocate additional array

* Fix assert

* Update VS project files

Author: oitel

source/MRMesh/MRConvexHull.cpp

@@ -281,6 +281,52 @@ Mesh makeConvexHull( const PointCloud & in )
     return makeConvexHull( in.points, in.validPoints );
 }
 
+Contour2f makeConvexHull( Contour2f points )
+{
+    if ( points.size() < 2 )
+        return points;
+
+    auto minPointIt = std::min_element( points.begin(), points.end(), [] ( auto&& a, auto&& b )
+    {
+        return std::tie( a.y, a.x ) < std::tie( b.y, b.x );
+    } );
+    std::swap( *points.begin(), *minPointIt );
+    const auto& minPoint = points.front();
+
+    // sort points by polar angle and distance to the start point
+    std::sort( points.begin() + 1, points.end(), [&] ( const Vector2f& a, const Vector2f& b )
+    {
+        const auto va = a - minPoint, vb = b - minPoint;
+        if ( auto c = cross( va, vb ); c != 0.f )
+            return c > 0.f;
+        return va.lengthSq() > vb.lengthSq();
+    } );
+
+    size_t size = 2;
+    for ( auto i = 2; i < points.size(); ++i )
+    {
+        if ( cross( points[i - 1] - minPoint, points[i - 0] - minPoint ) == 0.f )
+        {
+            assert( ( points[i - 1] - minPoint ).lengthSq() >= ( points[i - 0] - minPoint ).lengthSq() );
+            continue;
+        }
+
+        const auto& p = points[i];
+        while ( size >= 2 )
+        {
+            const auto& a = points[size - 2];
+            const auto& b = points[size - 1];
+            if ( cross( b - a, p - a ) > 0.f )
+                break;
+            size--;
+        }
+        points[size++] = p;
+    }
+    points.erase( points.begin() + size, points.end() );
+
+    return points;
+}
+
 TEST( MRMesh, ConvexHull )
 {
     Mesh torus = makeTorus( 1.0f, 0.3f, 16, 16 );

source/MRMesh/MRConvexHull.h

@@ -10,4 +10,7 @@ MRMESH_API Mesh makeConvexHull( const VertCoords & points, const VertBitSet & va
 MRMESH_API Mesh makeConvexHull( const Mesh & in );
 MRMESH_API Mesh makeConvexHull( const PointCloud & in );
 
+// computes the contour of convex hull from given input points
+MRMESH_API Contour2f makeConvexHull( Contour2f points );
+
 } //namespace MR

source/MRTest/MRConvexHull.cpp

@@ -0,0 +1,89 @@
+#include "MRMesh/MRConvexHull.h"
+
+#include "MRMesh/MRGTest.h"
+
+namespace MR
+{
+
+// Test case for an empty set of points
+TEST(MakeConvexHullTest, EmptyInput) {
+    std::vector<Vector2f> points;
+    std::vector<Vector2f> hull = makeConvexHull(points);
+    ASSERT_TRUE(hull.empty());
+}
+
+// Test case for a single point
+TEST(MakeConvexHullTest, SinglePoint) {
+    std::vector<Vector2f> points = {{1.0f, 1.0f}};
+    std::vector<Vector2f> hull = makeConvexHull(points);
+    EXPECT_EQ(hull, points);
+}
+
+// Test case for two points
+TEST(MakeConvexHullTest, TwoPoints) {
+    std::vector<Vector2f> points = {{2.0f, 2.0f}, {1.0f, 1.0f} };
+    std::vector<Vector2f> hull = makeConvexHull(points);
+    ASSERT_EQ(hull.size(), 2);
+    // The hull should start from a minimal coords point.
+    EXPECT_EQ(hull[0], points[1]);
+    EXPECT_EQ(hull[1], points[0]);
+}
+
+// Test case for three collinear points
+TEST(MakeConvexHullTest, ThreeCollinearPoints) {
+    std::vector<Vector2f> points = {{1.0f, 1.0f}, {2.0f, 2.0f}, {3.0f, 3.0f}};
+    std::vector<Vector2f> hull = makeConvexHull(points);
+    ASSERT_EQ(hull.size(), 2);
+    // The hull should only contain the two extreme points
+    EXPECT_EQ(hull[0], points[0]);
+    EXPECT_EQ(hull[1], points[2]);
+}
+
+// Test case for a simple square
+TEST(MakeConvexHullTest, SimpleSquare) {
+    std::vector<Vector2f> points = {{0.0f, 0.0f}, {1.0f, 0.0f}, {0.0f, 1.0f}, {1.0f, 1.0f}};
+    std::vector<Vector2f> hull = makeConvexHull(points);
+    ASSERT_EQ(hull.size(), 4);
+
+    // The expected hull in counter-clockwise order
+    std::vector<Vector2f> expected_hull = {{0.0f, 0.0f}, {1.0f, 0.0f}, {1.0f, 1.0f}, {0.0f, 1.0f}};
+    EXPECT_EQ(hull, expected_hull);
+}
+
+// Test case with points inside the hull
+TEST(MakeConvexHullTest, PointsInside) {
+    std::vector<Vector2f> points = {
+        {0.0f, 0.0f}, {5.0f, 0.0f}, {0.0f, 5.0f}, {5.0f, 5.0f}, // The corners of the hull
+        {1.0f, 1.0f}, {2.0f, 3.0f}, {4.0f, 2.0f}               // Points inside
+    };
+    std::vector<Vector2f> hull = makeConvexHull(points);
+    ASSERT_EQ(hull.size(), 4);
+
+    std::vector<Vector2f> expected_hull = {{0.0f, 0.0f}, {5.0f, 0.0f}, {5.0f, 5.0f}, {0.0f, 5.0f}};
+    EXPECT_EQ(hull, expected_hull);
+}
+
+// Test case with duplicate points
+TEST(MakeConvexHullTest, DuplicatePoints) {
+    std::vector<Vector2f> points = {{0.0f, 0.0f}, {1.0f, 0.0f}, {0.0f, 1.0f}, {0.0f, 0.0f}};
+    std::vector<Vector2f> hull = makeConvexHull(points);
+    ASSERT_EQ(hull.size(), 3);
+
+    std::vector<Vector2f> expected_hull = {{0.0f, 0.0f}, {1.0f, 0.0f}, {0.0f, 1.0f}};
+    EXPECT_EQ(hull, expected_hull);
+}
+
+// A more complex test case with various points
+TEST(MakeConvexHullTest, ComplexShape) {
+    std::vector<Vector2f> points = {
+        {0, 3}, {1, 1}, {2, 2}, {4, 4},
+        {0, 0}, {1, 2}, {3, 1}, {3, 3}
+    };
+    std::vector<Vector2f> hull = makeConvexHull(points);
+    ASSERT_EQ(hull.size(), 4);
+
+    std::vector<Vector2f> expected_hull = {{0, 0}, {3, 1}, {4, 4}, {0, 3}};
+    EXPECT_EQ(hull, expected_hull);
+}
+
+} // namespace MR

source/MRTest/MRTest.vcxproj

@@ -44,6 +44,7 @@
     <ClCompile Include="MRVolumeToMeshByPartsTests.cpp" />
     <ClCompile Include="MRZlib.cpp" />
     <ClCompile Include="MRProgressCallback.cpp" />
+    <ClCompile Include="MRConvexHull.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\thirdparty\pybind11nonlimitedapi_stubs.vcxproj">