GRIDEDIT-953 Added api function for generating curvilinear grid from …

…splines.

Added api unit tests

libs/MeshKernel/include/MeshKernel/CurvilinearGrid/CurvilinearGridSplineToGrid.hpp

@@ -39,12 +39,14 @@ namespace meshkernel
     class CurvilinearGridSplineToGrid
     {
     public:
+        /// @brief Generate the curvilinear grid from the set of splines
         void Compute(const Splines& splines,
                      const CurvilinearParameters& curvilinearParameters,
                      CurvilinearGrid& grid) const;
 
-        // CurvilinearGrid Compute(const Splines& splines,
-        //                         const CurvilinearParameters& curvilinearParameters) const;
+        /// @brief Generate the curvilinear grid from the set of splines
+        CurvilinearGrid Compute(const Splines& splines,
+                                const CurvilinearParameters& curvilinearParameters) const;
 
     private:
         /// @brief Maximum number of spline points allowed when doubling of the spline points.

libs/MeshKernel/src/CurvilinearGrid/CurvilinearGridSplineToGrid.cpp

@@ -38,6 +38,14 @@ void meshkernel::CurvilinearGridSplineToGrid::Compute(const Splines& splines,
     GenerateGrid(splinesCopy, splineIntersections, splineInteraction, numMSplines, mRefinement, nRefinement, grid);
 }
 
+meshkernel::CurvilinearGrid meshkernel::CurvilinearGridSplineToGrid::Compute(const Splines& splines,
+                                                                             const CurvilinearParameters& curvilinearParameters) const
+{
+    CurvilinearGrid grid(splines.m_projection);
+    Compute(splines, curvilinearParameters, grid);
+    return grid;
+}
+
 bool meshkernel::CurvilinearGridSplineToGrid::CheckSplines(const Splines& splines) const
 {
     for (UInt splineIndex = 0; splineIndex < splines.GetNumSplines(); ++splineIndex)

libs/MeshKernel/tests/src/CurvilinearGridFromSplinesTests.cpp

@@ -1219,19 +1219,19 @@ TEST(CurvilinearGridFromSplines, GenerateSimpleGridFromSplines)
     }
 }
 
-TEST(CurvilinearGridFromSplines, DISABLED_GridFromSplines4)
+TEST(CurvilinearGridFromSplines, DISABLED_GridFromSplines4) //
 {
     namespace mk = meshkernel;
     // mk::CurvilinearGrid interactorGrid(LoadCurvilinearGrid("/home/senior/MeshKernel/MeshKernel01/build_debug/splgrid2.grd"));
     // auto splines = std::make_shared<Splines>(LoadSplines("/home/senior/MeshKernel/MeshKernel01/build_debug/044.txt"));
 
-    mk::CurvilinearGrid interactorGrid(LoadCurvilinearGrid("/home/wcs1/MeshKernel/MeshKernel/build_deb/splgrid2.grd"));
+    mk::CurvilinearGrid interactorGrid(LoadCurvilinearGrid("/home/wcs1/MeshKernel/MeshKernel/build_deb/splgrid3.grd"));
     auto splines = std::make_shared<Splines>(LoadSplines("/home/wcs1/MeshKernel/MeshKernel/build_deb/044.txt"));
 
     mk::CurvilinearParameters curvilinearParameters;
 
     curvilinearParameters.m_refinement = 5;
-    curvilinearParameters.n_refinement = 10;
+    curvilinearParameters.n_refinement = 5;
 
     mk::CurvilinearGridSplineToGrid splinesToGrid;
     mk::CurvilinearGrid grid(Projection::cartesian);
@@ -1244,12 +1244,28 @@ TEST(CurvilinearGridFromSplines, DISABLED_GridFromSplines4)
     auto computedPoints = grid.ComputeNodes();
     auto computedEdges = grid.ComputeEdges();
 
+    std::cout << "grid size: " << grid.NumN() << " x " << grid.NumM() << std::endl;
+    std::cout << "grid size: " << interactorGrid.NumN() << " x " << interactorGrid.NumM() << std::endl;
+
     std::cout << interactorPoints.size() << "  " << computedPoints.size() << std::endl;
     std::cout << interactorEdges.size() << "  " << computedEdges.size() << std::endl;
 
     // meshkernel::Print(interactorGrid.ComputeNodes(), interactorGrid.ComputeEdges());
     // meshkernel::Print(grid.ComputeNodes(), grid.ComputeEdges());
 
+    // ASSERT_EQ(grid.NumM(), interactorGrid.NumN());
+    // ASSERT_EQ(grid.NumN(), interactorGrid.NumM());
+
+    constexpr double tolerance = 1.0e-5;
+
+    for (UInt i = 0; i < interactorGrid.NumN(); ++i)
+    {
+        for (UInt j = 0; j < interactorGrid.NumM(); ++j)
+        {
+            EXPECT_NEAR(grid.GetNode(i, j).x, interactorGrid.GetNode(j, i).x, tolerance);
+        }
+    }
+
     // std::cout << "size: " << numNodes, numEdges <<
 }
 

libs/MeshKernelApi/include/MeshKernelApi/MeshKernel.hpp

@@ -178,6 +178,15 @@ namespace meshkernelapi
                                                                                  const meshkernel::CurvilinearParameters& curvilinearParameters,
                                                                                  const meshkernel::SplinesToCurvilinearParameters& splinesToCurvilinearParameters);
 
+        /// @brief Generates curvilinear grid from splines.
+        /// @param[in] meshKernelId                   The id of the mesh state
+        /// @param[in] geometryList                   The input splines corners
+        /// @param[in] curvilinearParameters          The input parameters to generate the curvilinear grid
+        /// @returns Error code
+        MKERNEL_API int mkernel_curvilinear_compute_grid_from_splines(int meshKernelId,
+                                                                      const GeometryList& geometryList,
+                                                                      const meshkernel::CurvilinearParameters& curvilinearParameters);
+
         /// @brief Computes the smoothness of a curvilinear grid.
         /// @param[in] meshKernelId  The id of the mesh state
         /// @param[in] direction  The direction in which to compute the smoothness

libs/MeshKernelApi/src/MeshKernel.cpp

@@ -54,6 +54,7 @@
 #include <MeshKernel/CurvilinearGrid/CurvilinearGridSmoothness.hpp>
 #include <MeshKernel/CurvilinearGrid/CurvilinearGridSnapGridToLandBoundary.hpp>
 #include <MeshKernel/CurvilinearGrid/CurvilinearGridSnapGridToSpline.hpp>
+#include <MeshKernel/CurvilinearGrid/CurvilinearGridSplineToGrid.hpp>
 #include <MeshKernel/Definitions.hpp>
 #include <MeshKernel/Entities.hpp>
 #include <MeshKernel/Exceptions.hpp>
@@ -3203,6 +3204,33 @@ namespace meshkernelapi
         return lastExitCode;
     }
 
+    MKERNEL_API int mkernel_curvilinear_compute_grid_from_splines(int meshKernelId,
+                                                                  const GeometryList& geometryListIn,
+                                                                  const meshkernel::CurvilinearParameters& curvilinearParameters)
+    {
+        lastExitCode = meshkernel::ExitCode::Success;
+        try
+        {
+            if (!meshKernelState.contains(meshKernelId))
+            {
+                throw meshkernel::MeshKernelError("The selected mesh kernel id does not exist.");
+            }
+
+            meshkernel::Splines splines(meshKernelState[meshKernelId].m_projection);
+            SetSplines(geometryListIn, splines);
+
+            meshkernel::CurvilinearGridSplineToGrid splineToGrid;
+
+            //  the curvilinear grid
+            meshKernelState[meshKernelId].m_curvilinearGrid = std::make_unique<meshkernel::CurvilinearGrid>(splineToGrid.Compute(splines, curvilinearParameters));
+        }
+        catch (...)
+        {
+            lastExitCode = HandleException();
+        }
+        return lastExitCode;
+    }
+
     MKERNEL_API int mkernel_curvilinear_compute_curvature(int meshKernelId, int direction, double* curvature)
     {
         lastExitCode = meshkernel::ExitCode::Success;

libs/MeshKernelApi/tests/src/CurvilinearGridTests.cpp

@@ -593,6 +593,101 @@ TEST_F(CartesianApiTestFixture, CurvilinearComputeOrthogonalGridFromSplines_Shou
     ASSERT_GT(curvilinearGrid.num_n, 0);
 }
 
+TEST_F(CartesianApiTestFixture, CurvilinearGridFromSplines_ShouldMakeCurvilinearGrid)
+{
+    // Setup
+    meshkernelapi::GeometryList splines{};
+    double geometrySeparator = meshkernelapi::mkernel_get_separator();
+
+    std::vector<double> coordinatesX{
+        -1.0, 11.0,
+        geometrySeparator,
+        10.0, 10.0,
+        geometrySeparator,
+        11.0, -1.0,
+        geometrySeparator,
+        0.0, 0.0};
+
+    std::vector<double> coordinatesY{
+        0.0, 0.0,
+        geometrySeparator,
+        11.0, -1.0,
+        geometrySeparator,
+        10.0, 10.0,
+        geometrySeparator,
+        11.0, -1.0};
+
+    splines.coordinates_x = coordinatesX.data();
+    splines.coordinates_y = coordinatesY.data();
+    splines.num_coordinates = static_cast<int>(coordinatesX.size());
+
+    CurvilinearParameters curvilinearParameters{};
+
+    curvilinearParameters.m_refinement = 5;
+    curvilinearParameters.n_refinement = 10;
+
+    // Execute, with large length threshold
+    auto const meshKernelId = GetMeshKernelId();
+    auto errorCode = mkernel_curvilinear_compute_grid_from_splines(meshKernelId,
+                                                                   splines,
+                                                                   curvilinearParameters);
+    ASSERT_EQ(meshkernel::ExitCode::Success, errorCode);
+
+    // Assert
+    meshkernelapi::CurvilinearGrid curvilinearGrid{};
+    errorCode = mkernel_curvilinear_get_dimensions(meshKernelId, curvilinearGrid);
+    ASSERT_EQ(meshkernel::ExitCode::Success, errorCode);
+
+    // Expected size of the generated grid
+    EXPECT_EQ(curvilinearGrid.num_n, 11);
+    EXPECT_EQ(curvilinearGrid.num_m, 6);
+}
+
+TEST_F(CartesianApiTestFixture, CurvilinearGridFromSplines_ShouldThrowAlgorithmError)
+{
+    // Setup
+    meshkernelapi::GeometryList splines{};
+    double geometrySeparator = meshkernelapi::mkernel_get_separator();
+
+    std::vector<double> coordinatesX{
+        -1.0, 11.0,
+        geometrySeparator,
+        10.0, 10.0,
+        geometrySeparator,
+        11.0, -1.0,
+        geometrySeparator,
+        0.0, 0.0,
+        geometrySeparator,
+        15.0, 15.0};
+
+    std::vector<double> coordinatesY{
+        0.0, 0.0,
+        geometrySeparator,
+        11.0, -1.0,
+        geometrySeparator,
+        10.0, 10.0,
+        geometrySeparator,
+        11.0, -1.0,
+        geometrySeparator,
+        15.0, -1.0};
+
+    splines.coordinates_x = coordinatesX.data();
+    splines.coordinates_y = coordinatesY.data();
+    splines.num_coordinates = static_cast<int>(coordinatesX.size());
+
+    CurvilinearParameters curvilinearParameters{};
+
+    curvilinearParameters.m_refinement = 5;
+    curvilinearParameters.n_refinement = 5;
+
+    // Execute, with large length threshold
+    auto const meshKernelId = GetMeshKernelId();
+    auto errorCode = mkernel_curvilinear_compute_grid_from_splines(meshKernelId,
+                                                                   splines,
+                                                                   curvilinearParameters);
+    ASSERT_EQ(meshkernel::ExitCode::AlgorithmErrorCode, errorCode);
+}
+
 TEST_F(CartesianApiTestFixture, CurvilinearInsertFace_ShouldInsertAFace)
 {
     // Setup