GRIDEDIT-2189: Normalize spline direction

Author: RStolkerDeltares

libs/MeshKernel/include/MeshKernel/Splines.hpp

@@ -191,11 +191,14 @@ namespace meshkernel
         /// @param[in] splineIndex The index of the spline to delete
         void DeleteSpline(UInt splineIndex);
 
-        /// @brief Allocate spline properties vectors
-        void AllocateSplinesProperties();
-
         /// @brief Compute the second order derivative of the spline.
         static std::vector<Point> ComputeSplineDerivative(const std::vector<Point>& splinesNodes);
+
+        /// @brief Normalizes spline direction to ensure consistent orientation
+        /// @param[in,out] splinePoints The spline points to normalize
+        /// @details Ensures left-to-right for horizontal splines, bottom-to-top for vertical splines.
+        ///          This provides a consistent reference direction regardless of input point order.
+        static void NormalizeSplineDirection(std::vector<Point>& splinePoints);
     };
 
     /// @brief This structure is used to create a function for converting an adimensional distance on a spline to a dimensional one

libs/MeshKernel/src/Splines.cpp

@@ -31,7 +31,6 @@
 #include <MeshKernel/CurvilinearGrid/CurvilinearGrid.hpp>
 #include <MeshKernel/Entities.hpp>
 #include <MeshKernel/Exceptions.hpp>
-#include <MeshKernel/LandBoundaries.hpp>
 #include <MeshKernel/Operations.hpp>
 #include <MeshKernel/SplineAlgorithms.hpp>
 #include <MeshKernel/Splines.hpp>
@@ -75,13 +74,42 @@ void Splines::AddSpline(const std::vector<Point>& splines, UInt start, UInt size
         count++;
     }
 
+    NormalizeSplineDirection(splinesNodes);
+
     m_splineNodes.emplace_back(splinesNodes);
 
     // compute second order derivatives
     m_splineDerivatives.emplace_back(ComputeSplineDerivative(splinesNodes));
     m_splinesLength.emplace_back(ComputeSplineLength(GetNumSplines() - 1, 0.0, static_cast<double>(size - 1)));
 }
 
+void Splines::NormalizeSplineDirection(std::vector<Point>& splinePoints)
+{
+    if (splinePoints.size() < 2)
+    {
+        return;
+    }
+
+    const auto& first = splinePoints.front();
+    const auto& last = splinePoints.back();
+
+    bool shouldReverse;
+
+    if (!IsEqual(first.x, last.x))
+    {
+        shouldReverse = first.x > last.x;
+    }
+    else
+    {
+        shouldReverse = first.y > last.y;
+    }
+
+    if (shouldReverse)
+    {
+        std::ranges::reverse(splinePoints);
+    }
+}
+
 std::vector<meshkernel::Point> Splines::ComputeSplineDerivative(const std::vector<Point>& splinesNodes)
 {
     std::vector<Point> splineDerivatives(splinesNodes.size());
@@ -108,6 +136,10 @@ void Splines::AddSpline(const std::vector<Point>& splines)
 
 void Splines::Replace(const UInt splineIndex, const std::vector<Point>& splinePoints)
 {
+    std::vector<Point> normalizedPoints = splinePoints;
+
+    NormalizeSplineDirection(normalizedPoints);
+
     m_splineNodes[splineIndex] = splinePoints;
     m_splineDerivatives[splineIndex] = ComputeSplineDerivative(splinePoints);
     m_splinesLength[splineIndex] = ComputeSplineLength(splineIndex, 0.0, static_cast<double>(splinePoints.size() - 1));

libs/MeshKernel/tests/src/SplineTests.cpp

@@ -48,6 +48,69 @@ TEST(Splines, SetSpline)
 
     ASSERT_EQ(1, splines.GetNumSplines());
     ASSERT_EQ(4, splines.m_splineNodes[0].size());
+
+    constexpr double tolerance = 1e-6;
+    ASSERT_NEAR(212.001953125000, splines.m_splineNodes[0][0].x, tolerance);
+    ASSERT_NEAR(529.253906250000, splines.m_splineNodes[0][1].x, tolerance);
+    ASSERT_NEAR(930.506469726562, splines.m_splineNodes[0][2].x, tolerance);
+    ASSERT_NEAR(1030.506469726562, splines.m_splineNodes[0][3].x, tolerance);
+
+    ASSERT_NEAR(155.627197265625, splines.m_splineNodes[0][0].y, tolerance);
+    ASSERT_NEAR(432.379974365234, splines.m_splineNodes[0][1].y, tolerance);
+    ASSERT_NEAR(453.380187988281, splines.m_splineNodes[0][2].y, tolerance);
+    ASSERT_NEAR(653.380187988281, splines.m_splineNodes[0][3].y, tolerance);
+}
+
+TEST(Splines, NormalizeHorizontalSplineDirection)
+{
+    std::vector<meshkernel::Point> splineNodes({{1000.0, 400.0},
+                                                {800.0, 300.0},
+                                                {500.0, 250.0},
+                                                {200.0, 100.0}});
+
+    meshkernel::Splines splines(meshkernel::Projection::cartesian);
+    splines.AddSpline(splineNodes, 0, static_cast<meshkernel::UInt>(splineNodes.size()));
+
+    ASSERT_EQ(1, splines.GetNumSplines());
+    ASSERT_EQ(4, splines.m_splineNodes[0].size());
+
+    constexpr double tolerance = 1e-6;
+
+    ASSERT_NEAR(200.0, splines.m_splineNodes[0][0].x, tolerance);
+    ASSERT_NEAR(500.0, splines.m_splineNodes[0][1].x, tolerance);
+    ASSERT_NEAR(800.0, splines.m_splineNodes[0][2].x, tolerance);
+    ASSERT_NEAR(1000.0, splines.m_splineNodes[0][3].x, tolerance);
+
+    ASSERT_NEAR(100.0, splines.m_splineNodes[0][0].y, tolerance);
+    ASSERT_NEAR(250.0, splines.m_splineNodes[0][1].y, tolerance);
+    ASSERT_NEAR(300.0, splines.m_splineNodes[0][2].y, tolerance);
+    ASSERT_NEAR(400.0, splines.m_splineNodes[0][3].y, tolerance);
+}
+
+TEST(Splines, NormalizeVerticalSplineDirection)
+{
+    std::vector<meshkernel::Point> splineNodes({{500.0, 800.0},
+                                                {500.0, 600.0},
+                                                {500.0, 400.0},
+                                                {500.0, 200.0}});
+
+    meshkernel::Splines splines(meshkernel::Projection::cartesian);
+    splines.AddSpline(splineNodes, 0, static_cast<meshkernel::UInt>(splineNodes.size()));
+
+    ASSERT_EQ(1, splines.GetNumSplines());
+    ASSERT_EQ(4, splines.m_splineNodes[0].size());
+
+    constexpr double tolerance = 1e-6;
+
+    ASSERT_NEAR(500.0, splines.m_splineNodes[0][0].x, tolerance);
+    ASSERT_NEAR(500.0, splines.m_splineNodes[0][1].x, tolerance);
+    ASSERT_NEAR(500.0, splines.m_splineNodes[0][2].x, tolerance);
+    ASSERT_NEAR(500.0, splines.m_splineNodes[0][3].x, tolerance);
+
+    ASSERT_NEAR(200.0, splines.m_splineNodes[0][0].y, tolerance);
+    ASSERT_NEAR(400.0, splines.m_splineNodes[0][1].y, tolerance);
+    ASSERT_NEAR(600.0, splines.m_splineNodes[0][2].y, tolerance);
+    ASSERT_NEAR(800.0, splines.m_splineNodes[0][3].y, tolerance);
 }
 
 TEST(Splines, CubicSplineInterpolation)