Correct unit test

libs/MeshKernel/tests/src/MeshRefinementTests.cpp

@@ -934,7 +934,7 @@ TEST_P(RidgeRefinementTestCases, expectedResults)
     const double sampleDeltaX = deltaX / static_cast<double>(superSample);
     const double sampleDeltaY = deltaY / static_cast<double>(superSample);
 
-    const auto [sampleData, sampleDataMatrix] = generateSampleData(testCase, sampleNx, sampleNy, sampleDeltaX, sampleDeltaY);
+    const auto sampleData = generateSampleData(testCase, sampleNx, sampleNy, sampleDeltaX, sampleDeltaY);
 
     auto samplesHessian = SamplesHessianCalculator::ComputeSamplesHessian(sampleData, mesh->m_projection, 0, sampleNx, sampleNy);
 

libs/MeshKernelApi/include/MeshKernelApi/Utils.hpp

@@ -217,46 +217,52 @@ namespace meshkernelapi
             result.values[i] = values[i];
         }
     }
+
+
+
     /// @brief Converts the samples represented in gridded data in a vector of samples
     /// @param[in] griddedSamples The gridded data to convert
     /// @returns The converted vector of samples
+    template <meshkernel::InterpolatableType T>
     static std::vector<meshkernel::Sample> ConvertGriddedDataToSamples(const GriddedSamples& griddedSamples)
     {
         std::vector<meshkernel::Sample> result;
-        if (griddedSamples.num_x == 0 || griddedSamples.num_y == 0)
+        if (griddedSamples.num_x <= 0 || griddedSamples.num_y <= 0)
         {
             return result;
         }
 
         meshkernel::Point origin{griddedSamples.x_origin, griddedSamples.y_origin};
-        const auto numSamples = griddedSamples.num_x * griddedSamples.num_y;
+        const size_t numSamples = static_cast<size_t>(griddedSamples.num_x * griddedSamples.num_y);
         result.resize(numSamples);
-        std::span values(reinterpret_cast<double const* const>(griddedSamples.values), griddedSamples.num_x * griddedSamples.num_y);
-
+        const T* valuePtr = static_cast<T*>(griddedSamples.values);
         if (griddedSamples.x_coordinates == nullptr || griddedSamples.y_coordinates == nullptr)
         {
             meshkernel::UInt index = 0;
-            for (int i = 0; i < griddedSamples.num_y; ++i)
+
+            for (int j = 0; j < griddedSamples.num_x; ++j)
             {
-                for (int j = 0; j < griddedSamples.num_x; ++j)
+                for (int i = griddedSamples.num_y - 1; i >= 0; --i)
                 {
+                    const auto griddedIndex = griddedSamples.num_x * i + j;
                     result[index].x = origin.x + j * griddedSamples.cell_size;
                     result[index].y = origin.y + i * griddedSamples.cell_size;
-                    result[index].value = values[index];
+                    result[index].value = static_cast<double>(valuePtr[griddedIndex]);
                     index++;
                 }
             }
             return result;
         }
 
         meshkernel::UInt index = 0;
-        for (int i = 0; i < griddedSamples.num_y; ++i)
+        for (int j = 0; j < griddedSamples.num_x; ++j)
         {
-            for (int j = 0; j < griddedSamples.num_x; ++j)
+            for (int i = griddedSamples.num_y - 1; i >= 0; --i)
             {
-                result[index].x = origin.x + griddedSamples.x_coordinates[index];
-                result[index].y = origin.y + griddedSamples.y_coordinates[index];
-                result[index].value = values[index];
+                const auto griddedIndex = griddedSamples.num_x * i + j;
+                result[index].x = origin.x + griddedSamples.x_coordinates[griddedIndex];
+                result[index].y = origin.y + griddedSamples.y_coordinates[griddedIndex];
+                result[index].value = static_cast<double>(valuePtr[griddedIndex]);
                 index++;
             }
         }

libs/MeshKernelApi/src/MeshKernel.cpp

@@ -1793,8 +1793,12 @@ namespace meshkernelapi
             {
                 throw meshkernel::ConstraintError("The selected mesh has no nodes.");
             }
+            if (meshRefinementParameters.refinement_type != 3)
+            {
+                throw meshkernel::MeshKernelError("The mesh refinement type in MeshRefinementParameters must be set equal to ridge refinement.");
+            }
 
-            const auto samplesVector = ConvertGriddedDataToSamples(samples);
+            const auto samplesVector = ConvertGriddedDataToSamples<float>(samples);
 
             auto samplesHessian = meshkernel::SamplesHessianCalculator::ComputeSamplesHessian(samplesVector,
                                                                                               meshKernelState[meshKernelId].m_projection,

libs/MeshKernelApi/tests/src/Mesh2DRefinmentTests.cpp

@@ -632,10 +632,7 @@ TEST_F(CartesianApiTestFixture, RefineAMeshBasedOnRidgeRefinement_OnAUniformMesh
     const int numSamplesYCoordinates = (nRows * 1) * 2 + 1;
     const double deltaX = 5.0;
     const double deltaY = 5.0;
-    const auto [sampleData, sampleDataMatrix] = generateSampleData(FunctionTestCase::GaussianWave, numSamplesXCoordinates, numSamplesYCoordinates, deltaX, deltaY);
-
-    std::string filePath(TEST_FOLDER + "/data/MeshRefinementTests/GaussianBump.asc");
-    WriteSampleFileToAsc(sampleDataMatrix, deltaX, filePath);
+    const auto sampleData = generateSampleData(FunctionTestCase::GaussianBump, numSamplesXCoordinates, numSamplesYCoordinates, deltaX, deltaY);
 
     // Create an instance of gridded samples,
     meshkernelapi::GriddedSamples griddedSamples;
@@ -648,11 +645,12 @@ TEST_F(CartesianApiTestFixture, RefineAMeshBasedOnRidgeRefinement_OnAUniformMesh
     // Flatten the values before passing them to Mesh Kernel
     meshkernel::UInt index = 0;
     std::vector<float> values(numSamplesXCoordinates * numSamplesYCoordinates, 0.0);
-    for (int i = 0; i < numSamplesYCoordinates; ++i)
+    for (int j = 0; j < numSamplesYCoordinates; ++j)
     {
-        for (int j = 0; j < numSamplesXCoordinates; ++j)
+        for (int i = 0; i < numSamplesXCoordinates; ++i)
         {
-            values[index] = static_cast<float>(sampleData[index].value);
+            const auto griddedIndex = griddedSamples.num_y * i + j;
+            values[index] = static_cast<float>(sampleData[griddedIndex].value);
             index++;
         }
     }
@@ -671,6 +669,7 @@ TEST_F(CartesianApiTestFixture, RefineAMeshBasedOnRidgeRefinement_OnAUniformMesh
     meshRefinementParameters.account_for_samples_outside = 0;
     meshRefinementParameters.connect_hanging_nodes = 1;
     meshRefinementParameters.smoothing_iterations = 0;
+    meshRefinementParameters.refinement_type = 3;
 
     // Execute
     const auto meshKernelId = GetMeshKernelId();
@@ -681,6 +680,6 @@ TEST_F(CartesianApiTestFixture, RefineAMeshBasedOnRidgeRefinement_OnAUniformMesh
     meshkernelapi::Mesh2D mesh2d{};
     errorCode = mkernel_mesh2d_get_dimensions(meshKernelId, mesh2d);
     ASSERT_EQ(meshkernel::ExitCode::Success, errorCode);
-    ASSERT_EQ(943, mesh2d.num_nodes);
-    ASSERT_EQ(1928, mesh2d.num_edges);
+    ASSERT_EQ(956, mesh2d.num_nodes);
+    ASSERT_EQ(1872, mesh2d.num_edges);
 }

tools/test_utils/include/TestUtils/SampleGenerator.hpp

@@ -39,8 +39,9 @@ enum class FunctionTestCase
     ArctanFunction = 4,
 };
 
-std::tuple<std::vector<meshkernel::Sample>, std::vector<std::vector<double>>> generateSampleData(FunctionTestCase testcase,
-                                                   meshkernel::UInt nx = 10,
-                                                   meshkernel::UInt ny = 10,
-                                                   double deltaX = 10.0,
-                                                   double deltaY = 10.0);
+std::vector<meshkernel::Sample>
+generateSampleData(FunctionTestCase testcase,
+                   meshkernel::UInt nx = 10,
+                   meshkernel::UInt ny = 10,
+                   double deltaX = 10.0,
+                   double deltaY = 10.0);

tools/test_utils/src/SampleGenerator.cpp

@@ -1,10 +1,11 @@
 #include "SampleGenerator.hpp"
 
-std::tuple<std::vector<meshkernel::Sample>, std::vector<std::vector<double>>> generateSampleData(FunctionTestCase testcase,
-                                                                                                 meshkernel::UInt nx,
-                                                                                                 meshkernel::UInt ny,
-                                                                                                 double deltaX,
-                                                                                                 double deltaY)
+std::vector<meshkernel::Sample>
+generateSampleData(FunctionTestCase testcase,
+                   meshkernel::UInt nx,
+                   meshkernel::UInt ny,
+                   double deltaX,
+                   double deltaY)
 {
     meshkernel::UInt start = 0;
     meshkernel::UInt size = (nx - start) * (ny - start);
@@ -80,5 +81,5 @@ std::tuple<std::vector<meshkernel::Sample>, std::vector<std::vector<double>>> ge
         }
     }
 
-    return {sampleData, sampleDataMatrix};
+    return sampleData;
 }