MeshKernel/_mesh_kernel_8hpp_source.html

//---- GPL ---------------------------------------------------------------------

//

// Copyright (C)  Stichting Deltares, 2011-2021.

//

// This program is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation version 3.

//

// This program is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

//

// contact: delft3d.support@deltares.nl

// Stichting Deltares

// P.O. Box 177

// 2600 MH Delft, The Netherlands

//

// All indications and logos of, and references to, "Delft3D" and "Deltares"

// are registered trademarks of Stichting Deltares, and remain the property of

// Stichting Deltares. All rights reserved.

//

//------------------------------------------------------------------------------


#pragma once


#include <MeshKernel/Parameters.hpp>


#include <MeshKernelApi/Contacts.hpp>

#include <MeshKernelApi/CurvilinearGrid.hpp>

#include <MeshKernelApi/GeometryList.hpp>

#include <MeshKernelApi/GriddedSamples.hpp>

#include <MeshKernelApi/Mesh1D.hpp>

#include <MeshKernelApi/Mesh2D.hpp>


#if defined(_WIN32)

#if !defined(MKERNEL_API)

#define MKERNEL_API __declspec(dllexport)

#endif

#else

#define MKERNEL_API __attribute__((visibility("default")))

#endif


namespace meshkernelapi

{

    struct BoundingBox;

#ifdef __cplusplus

    extern "C"

    {

#endif


        MKERNEL_API double mkernel_get_separator();


        MKERNEL_API double mkernel_get_inner_outer_separator();


        MKERNEL_API int mkernel_allocate_state(int projectionType, int& meshKernelId);


        MKERNEL_API int mkernel_is_valid_state(int meshKernelId, bool& isValid);


        MKERNEL_API int mkernel_set_undo_size(int undoStackSize);


        MKERNEL_API int mkernel_undo_state(bool& undone, int& meshKernelId);


        MKERNEL_API int mkernel_undo_state_count(int& committedCount, int& restoredCount);


        MKERNEL_API int mkernel_undo_state_count_for_id(int meshKernelId, int& committedCount, int& restoredCount);


        MKERNEL_API int mkernel_redo_state(bool& redone, int& meshKernelId);


        MKERNEL_API int mkernel_clear_state();


        MKERNEL_API int mkernel_clear_undo_state();


        MKERNEL_API int mkernel_clear_undo_state_for_id(int meshKernelId);


        MKERNEL_API int mkernel_contacts_compute_boundary(int meshKernelId,

                                                          const int* oneDNodeMask,

                                                          const GeometryList& polygons,

                                                          double searchRadius);


        MKERNEL_API int mkernel_contacts_compute_multiple(int meshKernelId,

                                                          const int* oneDNodeMask);


        MKERNEL_API int mkernel_contacts_compute_single(int meshKernelId,

                                                        const int* oneDNodeMask,

                                                        const GeometryList& polygons,

                                                        double projectionFactor);


        MKERNEL_API int mkernel_contacts_compute_with_points(int meshKernelId,

                                                             const int* oneDNodeMask,

                                                             const GeometryList& points);


        MKERNEL_API int mkernel_contacts_compute_with_polygons(int meshKernelId,

                                                               const int* oneDNodeMask,

                                                               const GeometryList& polygons);


        MKERNEL_API int mkernel_contacts_get_data(int meshKernelId, Contacts& contacts);


        MKERNEL_API int mkernel_contacts_get_dimensions(int meshKernelId, Contacts& contacts);


        MKERNEL_API int mkernel_contacts_set(int meshKernelId, const Contacts& contacts);


        MKERNEL_API int mkernel_curvilinear_compute_curvature(int meshKernelId, int direction, double* curvature);


        MKERNEL_API int mkernel_curvilinear_compute_orthogonal_grid_from_splines(int meshKernelId,

                                                                                 const GeometryList& geometryList,

                                                                                 const meshkernel::CurvilinearParameters& curvilinearParameters,

                                                                                 const meshkernel::SplinesToCurvilinearParameters& splinesToCurvilinearParameters);


        MKERNEL_API int mkernel_curvilinear_compute_grid_from_splines(int meshKernelId,

                                                                      const GeometryList& geometryList,

                                                                      const meshkernel::CurvilinearParameters& curvilinearParameters);


        MKERNEL_API int mkernel_curvilinear_compute_smoothness(int meshKernelId, int direction, double* smoothness);


        MKERNEL_API int mkernel_curvilinear_compute_transfinite_from_polygon(int meshKernelId,

                                                                             const GeometryList& polygons,

                                                                             int firstNode,

                                                                             int secondNode,

                                                                             int thirdNode,

                                                                             int useFourthSide);


        MKERNEL_API int mkernel_curvilinear_compute_transfinite_from_splines(int meshKernelId,

                                                                             const GeometryList& splines,

                                                                             const meshkernel::CurvilinearParameters& curvilinearParameters);


        MKERNEL_API int mkernel_curvilinear_compute_transfinite_from_triangle(int meshKernelId,

                                                                              const GeometryList& polygon,

                                                                              int firstNode,

                                                                              int secondNode,

                                                                              int thirdNode);


        MKERNEL_API int mkernel_curvilinear_convert_to_mesh2d(int meshKernelId);


        MKERNEL_API int mkernel_curvilinear_delete_exterior(int meshKernelId,

                                                            const BoundingBox& boundingBox);


        MKERNEL_API int mkernel_curvilinear_delete_interior(int meshKernelId,

                                                            const BoundingBox& boundingBox);


        MKERNEL_API int mkernel_curvilinear_delete_node(int meshKernelId,

                                                        double xPointCoordinate,

                                                        double yPointCoordinate);


        MKERNEL_API int mkernel_curvilinear_delete_orthogonal_grid_from_splines(int meshKernelId);


        MKERNEL_API int mkernel_curvilinear_finalize_line_shift(int meshKernelId);


        MKERNEL_API int mkernel_curvilinear_get_data(int meshKernelId, CurvilinearGrid& curvilinearGrid);


        MKERNEL_API int mkernel_curvilinear_get_boundaries_as_polygons(int meshKernelId, int lowerLeftN, int lowerLeftM, int upperRightN, int upperRightM, GeometryList& boundaryPolygons);


        MKERNEL_API int mkernel_curvilinear_count_boundaries_as_polygons(int meshKernelId, int lowerLeftN, int lowerLeftM, int upperRightN, int upperRightM, int& numberOfPolygonNodes);


        MKERNEL_API int mkernel_curvilinear_get_dimensions(int meshKernelId, CurvilinearGrid& curvilinearGrid);


        MKERNEL_API int mkernel_curvilinear_get_location_index(int meshKernelId,

                                                               double xCoordinate,

                                                               double yCoordinate,

                                                               int locationType,

                                                               const BoundingBox& boundingBox,

                                                               int& locationIndex);


        MKERNEL_API int mkernel_curvilinear_initialize_line_shift(int meshKernelId);


        MKERNEL_API int mkernel_curvilinear_initialize_orthogonal_grid_from_splines(int meshKernelId,

                                                                                    const GeometryList& geometryList,

                                                                                    const meshkernel::CurvilinearParameters& curvilinearParameters,

                                                                                    const meshkernel::SplinesToCurvilinearParameters& splinesToCurvilinearParameters);


        MKERNEL_API int mkernel_curvilinear_insert_face(int meshKernelId, double xCoordinate, double yCoordinate);


        MKERNEL_API int mkernel_curvilinear_iterate_orthogonal_grid_from_splines(int meshKernelId, int layer);


        MKERNEL_API int mkernel_curvilinear_line_attraction_repulsion(int meshKernelId,

                                                                      double repulsionParameter,

                                                                      double xFirstNodeOnTheLine,

                                                                      double yFirstNodeOnTheLine,

                                                                      double xSecondNodeOnTheLine,

                                                                      double ySecondNodeOnTheLine,

                                                                      double xLowerLeftCorner,

                                                                      double yLowerLeftCorner,

                                                                      double xUpperRightCorner,

                                                                      double yUpperRightCorner);


        MKERNEL_API int mkernel_curvilinear_line_mirror(int meshKernelId,

                                                        double mirroringFactor,

                                                        int numRowsToMirror,

                                                        double xFirstGridLineNode,

                                                        double yFirstGridLineNode,

                                                        double xSecondGridLineNode,

                                                        double ySecondGridLineNode);


        MKERNEL_API int mkernel_curvilinear_line_shift(int meshKernelId);


        MKERNEL_API int mkernel_curvilinear_compute_rectangular_grid(int meshKernelId,

                                                                     const meshkernel::MakeGridParameters& makeGridParameters);


        MKERNEL_API int mkernel_curvilinear_compute_rectangular_grid_from_polygon(int meshKernelId,

                                                                                  const meshkernel::MakeGridParameters& makeGridParameters,

                                                                                  const GeometryList& geometryList);


        MKERNEL_API int mkernel_curvilinear_compute_rectangular_grid_on_extension(int meshKernelId,

                                                                                  const meshkernel::MakeGridParameters& makeGridParameters);


        MKERNEL_API int mkernel_curvilinear_compute_circular_grid(int meshKernelId,

                                                                  const meshkernel::MakeGridParameters& parameters);


        MKERNEL_API int mkernel_curvilinear_move_node(int meshKernelId,

                                                      double xFromPoint,

                                                      double yFromPoint,

                                                      double xToPoint,

                                                      double yToPoint);


        MKERNEL_API int mkernel_curvilinear_move_node_line_shift(int meshKernelId,

                                                                 double xFromCoordinate,

                                                                 double yFromCoordinate,

                                                                 double xToCoordinate,

                                                                 double yToCoordinate);


        MKERNEL_API int mkernel_curvilinear_refine(int meshKernelId,

                                                   double xLowerLeftCorner,

                                                   double yLowerLeftCorner,

                                                   double xUpperRightCorner,

                                                   double yUpperRightCorner,

                                                   int refinement);


        MKERNEL_API int mkernel_curvilinear_refresh_orthogonal_grid_from_splines(int meshKernelId);


        MKERNEL_API int mkernel_curvilinear_full_refine(int meshKernelId,

                                                        int mRefinement,

                                                        int nRefinement);


        MKERNEL_API int mkernel_curvilinear_orthogonalize(int meshKernelId,

                                                          const meshkernel::OrthogonalizationParameters& orthogonalizationParameters,

                                                          double xLowerLeftCorner,

                                                          double yLowerLeftCorner,

                                                          double xUpperRightCorner,

                                                          double yUpperRightCorner);


        MKERNEL_API int mkernel_curvilinear_set(int meshKernelId, const CurvilinearGrid& grid);


        MKERNEL_API int mkernel_curvilinear_set_block_line_shift(int meshKernelId,

                                                                 double xLowerLeftCorner,

                                                                 double yLowerLeftCorner,

                                                                 double xUpperRightCorner,

                                                                 double yUpperRightCorner);


        MKERNEL_API int mkernel_curvilinear_frozen_line_is_valid(int meshKernelId, int frozenLineId, bool& isValid);


        MKERNEL_API int mkernel_curvilinear_frozen_line_delete(int meshKernelId,

                                                               int frozenLineId);


        MKERNEL_API int mkernel_curvilinear_frozen_line_add(int meshKernelId,

                                                            double xFirstGridLineNode,

                                                            double yFirstGridLineNode,

                                                            double xSecondGridLineNode,

                                                            double ySecondGridLineNode,

                                                            int& frozenLineId);


        MKERNEL_API int mkernel_curvilinear_frozen_line_get(int meshKernelId,

                                                            int frozenLineId,

                                                            double& xFirstFrozenLineCoordinate,

                                                            double& yFirstFrozenLineCoordinate,

                                                            double& xSecondFrozenLineCoordinate,

                                                            double& ySecondFrozenLineCoordinate);


        MKERNEL_API int mkernel_curvilinear_frozen_lines_get_count(int meshKernelId,

                                                                   int& numFrozenLines);


        MKERNEL_API int mkernel_curvilinear_frozen_lines_get_ids(int meshKernelId,

                                                                 int* frozenLinesIds);


        MKERNEL_API int mkernel_curvilinear_set_line_line_shift(int meshKernelId,

                                                                double xFirstGridLineNode,

                                                                double yFirstGridLineNode,

                                                                double xSecondGridLineNode,

                                                                double ySecondGridLineNode);


        MKERNEL_API int mkernel_curvilinear_smoothing(int meshKernelId,

                                                      int smoothingIterations,

                                                      double xLowerLeftCorner,

                                                      double yLowerLeftCorner,

                                                      double xUpperRightCorner,

                                                      double yUpperRightCorner);


        MKERNEL_API int mkernel_curvilinear_smoothing_directional(int meshKernelId,

                                                                  int smoothingIterations,

                                                                  double xFirstGridlineNode,

                                                                  double yFirstGridlineNode,

                                                                  double xSecondGridLineNode,

                                                                  double ySecondGridLineNode,

                                                                  double xLowerLeftCornerSmoothingArea,

                                                                  double yLowerLeftCornerSmoothingArea,

                                                                  double xUpperRightCornerSmootingArea,

                                                                  double yUpperRightCornerSmootingArea);


        MKERNEL_API int mkernel_curvilinear_snap_to_landboundary(int meshKernelId,

                                                                 const GeometryList& land,

                                                                 double sectionControlPoint1x,

                                                                 double sectionControlPoint1y,

                                                                 double sectionControlPoint2x,

                                                                 double sectionControlPoint2y,

                                                                 double regionControlPointX = mkernel_get_separator(),

                                                                 double regionControlPointY = mkernel_get_separator());


        MKERNEL_API int mkernel_curvilinear_snap_to_spline(int meshKernelId,

                                                           const GeometryList& spline,

                                                           double sectionControlPoint1x,

                                                           double sectionControlPoint1y,

                                                           double sectionControlPoint2x,

                                                           double sectionControlPoint2y,

                                                           double regionControlPointX = mkernel_get_separator(),

                                                           double regionControlPointY = mkernel_get_separator());


        MKERNEL_API int mkernel_deallocate_property(int meshKernelId, int propertyId);


        MKERNEL_API int mkernel_deallocate_state(int meshKernelId);


        MKERNEL_API int mkernel_expunge_state(int meshKernelId);


        MKERNEL_API int mkernel_get_averaging_method_closest_point(int& method);


        MKERNEL_API int mkernel_get_averaging_method_inverse_distance_weighting(int& method);


        MKERNEL_API int mkernel_get_averaging_method_max(int& method);


        MKERNEL_API int mkernel_get_averaging_method_min(int& method);


        MKERNEL_API int mkernel_get_averaging_method_min_absolute_value(int& method);


        MKERNEL_API int mkernel_get_averaging_method_simple_averaging(int& method);


        MKERNEL_API int mkernel_get_edges_location_type(int& type);


        MKERNEL_API int mkernel_get_error(char* errorMessage);


        MKERNEL_API int mkernel_get_exit_code_success(int& exitCode);


        MKERNEL_API int mkernel_get_exit_code_meshkernel_error(int& exitCode);


        MKERNEL_API int mkernel_get_exit_code_not_implemented_error(int& exitCode);


        MKERNEL_API int mkernel_get_exit_code_algorithm_error(int& exitCode);


        MKERNEL_API int mkernel_get_exit_code_constraint_error(int& exitCode);


        MKERNEL_API int mkernel_get_exit_code_mesh_geometry_error(int& exitCode);


        MKERNEL_API int mkernel_get_exit_code_linear_algebra_error(int& exitCode);


        MKERNEL_API int mkernel_get_exit_code_range_error(int& exitCode);


        MKERNEL_API int mkernel_get_exit_code_stdlib_exception(int& exitCode);


        MKERNEL_API int mkernel_get_exit_code_unknown_exception(int& exitCode);


        MKERNEL_API int mkernel_get_faces_location_type(int& type);


        MKERNEL_API int mkernel_get_geometry_error(int& invalidIndex, int& type);


        MKERNEL_API int mkernel_get_interpolation_type_short(int& type);


        MKERNEL_API int mkernel_get_interpolation_type_float(int& type);


        MKERNEL_API int mkernel_get_interpolation_type_int(int& type);


        MKERNEL_API int mkernel_get_interpolation_type_double(int& type);


        MKERNEL_API int mkernel_get_nodes_location_type(int& type);


        MKERNEL_API int mkernel_get_projection(int meshKernelId, int& projection);


        MKERNEL_API int mkernel_get_projection_cartesian(int& projection);


        MKERNEL_API int mkernel_get_projection_spherical(int& projection);


        MKERNEL_API int mkernel_get_projection_spherical_accurate(int& projection);


        MKERNEL_API int mkernel_get_splines(const GeometryList& geometryListIn,

                                            GeometryList& geometryListOut,

                                            int numberOfPointsBetweenNodes);


        MKERNEL_API int mkernel_get_version(char* version);


        MKERNEL_API int mkernel_mesh1d_get_data(int meshKernelId, Mesh1D& mesh1d);


        MKERNEL_API int mkernel_mesh1d_get_dimensions(int meshKernelId, Mesh1D& mesh1d);


        MKERNEL_API int mkernel_mesh1d_set(int meshKernelId, const Mesh1D& mesh1d);


        MKERNEL_API int mkernel_mesh1d_add(int meshKernelId, const Mesh1D& mesh1d);


        MKERNEL_API int mkernel_mesh2d_averaging_interpolation(int meshKernelId,

                                                               const GeometryList& samples,

                                                               int locationType,

                                                               int averagingMethodType,

                                                               double relativeSearchSize,

                                                               size_t minNumSamples,

                                                               GeometryList& results);


        MKERNEL_API int mkernel_mesh2d_compute_inner_ortogonalization_iteration(int meshKernelId);


        MKERNEL_API int mkernel_mesh2d_rotate(int meshKernelId, double centreX, double centreY, double theta);


        MKERNEL_API int mkernel_mesh2d_set_property(int meshKernelId,

                                                    const meshkernel::InterpolationParameters& interpolationParameters,

                                                    const GeometryList& sampleData,

                                                    int& propertyId);


        MKERNEL_API int mkernel_splines_snap_to_landboundary(int meshKernelId,

                                                             const GeometryList& land,

                                                             GeometryList& splines,

                                                             int startSplineIndex,

                                                             int endSplineIndex);


        MKERNEL_API int mkernel_mesh2d_translate(int meshKernelId, double translationX, double translationY);


        MKERNEL_API int mkernel_mesh2d_casulli_derefinement_elements(int meshKernelId, GeometryList& elements);


        MKERNEL_API int mkernel_mesh2d_casulli_derefinement_elements_on_polygon(int meshKernelId, const GeometryList& polygonGeometry, GeometryList& elements);


        MKERNEL_API int mkernel_mesh2d_casulli_derefinement(int meshKernelId);


        MKERNEL_API int mkernel_mesh2d_casulli_derefinement_on_polygon(int meshKernelId, const GeometryList& polygons);


        MKERNEL_API int mkernel_mesh2d_casulli_refinement(int meshKernelId);


        MKERNEL_API int mkernel_mesh2d_casulli_refinement_on_polygon(int meshKernelId, const GeometryList& polygons);


        MKERNEL_API int mkernel_mesh2d_casulli_refinement_based_on_depths(int meshKernelId,

                                                                          const GeometryList& polygons,

                                                                          int propertyId,

                                                                          const meshkernel::MeshRefinementParameters& meshRefinementParameters,

                                                                          const double minimumRefinementDepth);


        MKERNEL_API int mkernel_mesh2d_compute_orthogonalization(int meshKernelId,

                                                                 int projectToLandBoundaryOption,

                                                                 const meshkernel::OrthogonalizationParameters& orthogonalizationParameters,

                                                                 const GeometryList& selectingPolygon,

                                                                 const GeometryList& landBoundaries);


        MKERNEL_API int mkernel_mesh2d_connect_meshes(int meshKernelId, const Mesh2D& mesh2d, double searchFraction, bool connect);


        MKERNEL_API int mkernel_mesh2d_convert_projection(int meshKernelId, int projectionType, const char* const zoneString);


        MKERNEL_API int mkernel_mesh2d_convert_to_curvilinear(int meshKernelId, double xPointCoordinate, double yPointCoordinate);


        MKERNEL_API int mkernel_mesh2d_count_hanging_edges(int meshKernelId, int& numEdges);


        MKERNEL_API int mkernel_mesh2d_count_mesh_boundaries_as_polygons(int meshKernelId, GeometryList& selectionPolygon, int& numberOfPolygonNodes);


        MKERNEL_API int mkernel_mesh2d_count_nodes_in_polygons(int meshKernelId,

                                                               const GeometryList& geometryListIn,

                                                               int inside,

                                                               int& numberOfMeshNodes);


        MKERNEL_API int mkernel_mesh2d_count_obtuse_triangles(int meshKernelId, int& numObtuseTriangles);


        MKERNEL_API int mkernel_mesh2d_count_small_flow_edge_centers(int meshKernelId,

                                                                     double smallFlowEdgesLengthThreshold,

                                                                     int& numSmallFlowEdges);


        MKERNEL_API int mkernel_mesh2d_delete(int meshKernelId,

                                              const GeometryList& polygon,

                                              int deletionOption,

                                              int invertDeletion);


        MKERNEL_API int mkernel_mesh2d_delete_edge(int meshKernelId,

                                                   double xCoordinate,

                                                   double yCoordinate,

                                                   double xLowerLeftBoundingBox,

                                                   double yLowerLeftBoundingBox,

                                                   double xUpperRightBoundingBox,

                                                   double yUpperRightBoundingBox);


        MKERNEL_API int mkernel_mesh2d_delete_edge_by_index(int meshKernelId, int edgeIndex);


        MKERNEL_API int mkernel_mesh2d_delete_hanging_edges(int meshKernelId);


        MKERNEL_API int mkernel_mesh2d_delete_node(int meshKernelId, int nodeIndex);


        MKERNEL_API int mkernel_mesh2d_delete_orthogonalization(int meshKernelId);


        MKERNEL_API int mkernel_mesh2d_delete_small_flow_edges_and_small_triangles(int meshKernelId,

                                                                                   double smallFlowEdgesThreshold,

                                                                                   double minFractionalAreaTriangles);


        MKERNEL_API int mkernel_mesh2d_finalize_inner_ortogonalization_iteration(int meshKernelId);


        MKERNEL_API int mkernel_mesh2d_flip_edges(int meshKernelId,

                                                  int isTriangulationRequired,

                                                  int projectToLandBoundaryRequired,

                                                  const GeometryList& selectingPolygon,

                                                  const GeometryList& landBoundaries);


        MKERNEL_API int mkernel_mesh2d_get_closest_node(int meshKernelId,

                                                        double xCoordinateIn,

                                                        double yCoordinateIn,

                                                        double searchRadius,

                                                        double xLowerLeftBoundingBox,

                                                        double yLowerLeftBoundingBox,

                                                        double xUpperRightBoundingBox,

                                                        double yUpperRightBoundingBox,

                                                        double& xCoordinateOut,

                                                        double& yCoordinateOut);


        MKERNEL_API int mkernel_mesh2d_get_data(int meshKernelId, Mesh2D& mesh2d);


        MKERNEL_API int mkernel_mesh2d_get_orthogonality_property_type(int& type);


        MKERNEL_API int mkernel_mesh2d_get_node_edge_data(int meshKernelId, Mesh2D& mesh2d);


        MKERNEL_API int mkernel_mesh2d_get_dimensions(int meshKernelId,

                                                      Mesh2D& mesh2d);


        MKERNEL_API int mkernel_mesh2d_get_edge(int meshKernelId,

                                                double xCoordinate,

                                                double yCoordinate,

                                                double xLowerLeftBoundingBox,

                                                double yLowerLeftBoundingBox,

                                                double xUpperRightBoundingBox,

                                                double yUpperRightBoundingBox,

                                                int& edgeIndex);


        MKERNEL_API int mkernel_mesh2d_get_hanging_edges(int meshKernelId, int* edges);


        MKERNEL_API int mkernel_mesh2d_get_face_polygons(int meshKernelId, int numEdges, const GeometryList& facePolygons);


        MKERNEL_API int mkernel_mesh2d_get_face_polygons_dimension(int meshKernelId, int numEdges, int& geometryListDimension);


        MKERNEL_API int mkernel_mesh2d_get_filtered_face_polygons_dimension(int meshKernelId,

                                                                            int propertyValue,

                                                                            double minValue,

                                                                            double maxValue,

                                                                            int& geometryListDimension);


        MKERNEL_API int mkernel_mesh2d_get_filtered_face_polygons(int meshKernelId,

                                                                  int propertyValue,

                                                                  double minValue,

                                                                  double maxValue,

                                                                  const GeometryList& facePolygons);


        MKERNEL_API int mkernel_mesh2d_get_location_index(int meshKernelId,

                                                          double xCoordinate,

                                                          double yCoordinate,

                                                          int locationType,

                                                          const BoundingBox& boundingBox,

                                                          int& locationIndex);


        MKERNEL_API int mkernel_mesh2d_get_mesh_boundaries_as_polygons(int meshKernelId, GeometryList& selectionPolygon, GeometryList& boundaryPolygons);


        MKERNEL_API int mkernel_mesh2d_get_node_index(int meshKernelId,

                                                      double xCoordinate,

                                                      double yCoordinate,

                                                      double searchRadius,

                                                      double xLowerLeftBoundingBox,

                                                      double yLowerLeftBoundingBox,

                                                      double xUpperRightBoundingBox,

                                                      double yUpperRightBoundingBox,

                                                      int& nodeIndex);


        MKERNEL_API int mkernel_mesh2d_get_nodes_in_polygons(int meshKernelId,

                                                             const GeometryList& geometryListIn,

                                                             int inside,

                                                             int* selectedNodes);


        MKERNEL_API int mkernel_mesh2d_get_obtuse_triangles_mass_centers(int meshKernelId, GeometryList& result);


        MKERNEL_API int mkernel_mesh2d_get_orthogonality(int meshKernelId, GeometryList& geometryList);


        MKERNEL_API int mkernel_mesh2d_get_property(int meshKernelId, int propertyValue, int locationId, const GeometryList& geometrylist);


        MKERNEL_API int mkernel_mesh2d_get_property_dimension(int meshKernelId, int propertyValue, int& dimension);


        MKERNEL_API int mkernel_mesh2d_get_small_flow_edge_centers(int meshKernelId,

                                                                   double smallFlowEdgesThreshold,

                                                                   GeometryList& result);


        MKERNEL_API int mkernel_mesh2d_get_smoothness(int meshKernelId, GeometryList& geometryList);


        MKERNEL_API int mkernel_mesh2d_initialize_orthogonalization(int meshKernelId,

                                                                    int projectToLandBoundaryOption,

                                                                    meshkernel::OrthogonalizationParameters& orthogonalizationParameters,

                                                                    const GeometryList& selectingPolygon,

                                                                    const GeometryList& landBoundaries);


        MKERNEL_API int mkernel_mesh2d_insert_edge(int meshKernelId, int startNode, int endNode, int& newEdgeIndex);


        MKERNEL_API int mkernel_mesh2d_insert_edge_from_coordinates(int meshKernelId,

                                                                    double firstNodeX,

                                                                    double firstNodeY,

                                                                    double secondNodeX,

                                                                    double secondNodeY,

                                                                    int& firstNodeIndex,

                                                                    int& secondNodeIndex,

                                                                    int& edgeIndex);


        MKERNEL_API int mkernel_mesh2d_insert_node(int meshKernelId, double xCoordinate, double yCoordinate, int& nodeIndex);


        MKERNEL_API int mkernel_mesh2d_intersections_from_polygon(int meshKernelId,

                                                                  const GeometryList& boundaryPolygon,

                                                                  int* edgeNodes,

                                                                  int* edgeIndex,

                                                                  double* edgeDistances,

                                                                  double* segmentDistances,

                                                                  int* segmentIndexes,

                                                                  int* faceIndexes,

                                                                  int* faceNumEdges,

                                                                  int* faceEdgeIndex);


        MKERNEL_API int mkernel_mesh2d_is_valid_property(int meshKernelId, const int propertyId, const int locationId, bool& propertyIsAvailable);


        MKERNEL_API int mkernel_mesh2d_make_global(int meshKernelId, int numLongitudeNodes, int numLatitudeNodes);


        MKERNEL_API int mkernel_mesh2d_make_triangular_mesh_from_polygon(int meshKernelId, const GeometryList& polygonPoints);


        MKERNEL_API int mkernel_mesh2d_make_triangular_mesh_from_samples(int meshKernelId, const GeometryList& samples);


        MKERNEL_API int mkernel_mesh2d_make_rectangular_mesh(int meshKernelId,

                                                             const meshkernel::MakeGridParameters& makeGridParameters);


        MKERNEL_API int mkernel_mesh2d_make_rectangular_mesh_from_polygon(int meshKernelId,

                                                                          const meshkernel::MakeGridParameters& makeGridParameters,

                                                                          const GeometryList& geometryList);


        MKERNEL_API int mkernel_mesh2d_make_rectangular_mesh_on_extension(int meshKernelId,

                                                                          const meshkernel::MakeGridParameters& makeGridParameters);


        MKERNEL_API int mkernel_mesh2d_merge_nodes(int meshKernelId, const GeometryList& geometryListIn);


        MKERNEL_API int mkernel_mesh2d_merge_nodes_with_merging_distance(int meshKernelId, const GeometryList& geometryListIn, double mergingDistance);


        MKERNEL_API int mkernel_mesh2d_merge_two_nodes(int meshKernelId, int firstNode, int secondNode);


        MKERNEL_API int mkernel_mesh2d_move_node(int meshKernelId, double xCoordinate, double yCoordinate, int nodeIndex);


        MKERNEL_API int mkernel_mesh2d_prepare_outer_iteration_orthogonalization(int meshKernelId);


        MKERNEL_API int mkernel_mesh2d_refine_based_on_gridded_samples(int meshKernelId,

                                                                       const GriddedSamples& griddedSamples,

                                                                       const meshkernel::MeshRefinementParameters& meshRefinementParameters,

                                                                       bool useNodalRefinement);


        MKERNEL_API int mkernel_mesh2d_refine_based_on_polygon(int meshKernelId,

                                                               const GeometryList& geometryList,

                                                               const meshkernel::MeshRefinementParameters& meshRefinementParameters);


        MKERNEL_API int mkernel_mesh2d_refine_based_on_samples(int meshKernelId,

                                                               const GeometryList& samples,

                                                               double relativeSearchRadius,

                                                               int minimumNumSamples,

                                                               const meshkernel::MeshRefinementParameters& meshRefinementParameters);


        MKERNEL_API int mkernel_mesh2d_refine_ridges_based_on_gridded_samples(int meshKernelId,

                                                                              const GriddedSamples& griddedSamples,

                                                                              double relativeSearchRadius,

                                                                              int minimumNumSamples,

                                                                              int numberOfSmoothingIterations,

                                                                              const meshkernel::MeshRefinementParameters& meshRefinementParameters);


        MKERNEL_API int mkernel_mesh2d_remove_disconnected_regions(int meshKernelId);


        MKERNEL_API int mkernel_mesh2d_set(int meshKernelId, const Mesh2D& mesh2d);


        MKERNEL_API int mkernel_mesh2d_snap_to_landboundary(int meshKernelId, const GeometryList& selectingPolygon, const GeometryList& landBoundaries);


        MKERNEL_API int mkernel_mesh2d_split_row(int meshKernelId,

                                                 int firstNode,

                                                 int secondNode);


        MKERNEL_API int mkernel_mesh2d_add(int meshKernelId, const Mesh2D& mesh2d);


        MKERNEL_API int mkernel_mesh2d_triangulation_interpolation(int meshKernelId,

                                                                   const GeometryList& samples,

                                                                   int locationType,

                                                                   GeometryList& results);


        MKERNEL_API int mkernel_network1d_compute_fixed_chainages(int meshKernelId,

                                                                  double* fixedChainages,

                                                                  int sizeFixedChainages,

                                                                  double minFaceSize,

                                                                  double fixedChainagesOffset);


        MKERNEL_API int mkernel_network1d_compute_offsetted_chainages(int meshKernelId, double offset);


        MKERNEL_API int mkernel_network1d_set(int meshKernelId, const GeometryList& polylines);


        MKERNEL_API int mkernel_network1d_to_mesh1d(int meshKernelId, double minFaceSize);


        MKERNEL_API int mkernel_polygon_count_offset(int meshKernelId,

                                                     const GeometryList& geometryListIn,

                                                     int innerPolygon,

                                                     double distance,

                                                     int& numberOfPolygonNodes);


        MKERNEL_API int mkernel_polygon_count_refine(int meshKernelId,

                                                     const GeometryList& polygonToRefine,

                                                     int firstIndex,

                                                     int secondIndex,

                                                     double distance,

                                                     int& numberOfPolygonNodes);


        MKERNEL_API int mkernel_polygon_count_linear_refine(int meshKernelId,

                                                            const GeometryList& polygonToRefine,

                                                            int firstIndex,

                                                            int secondIndex,

                                                            int& numberOfPolygonNodes);


        MKERNEL_API int mkernel_polygon_get_included_points(int meshKernelId,

                                                            const GeometryList& selectingPolygon,

                                                            const GeometryList& polygonToSelect,

                                                            GeometryList& selectionResults);


        MKERNEL_API int mkernel_polygon_get_offset(int meshKernelId,

                                                   const GeometryList& geometryListIn,

                                                   int inWard,

                                                   double distance,

                                                   GeometryList& geometryListOut);


        MKERNEL_API int mkernel_polygon_refine(int meshKernelId,

                                               const GeometryList& polygonToRefine,

                                               int firstNodeIndex,

                                               int secondNodeIndex,

                                               double targetEdgeLength,

                                               GeometryList& refinedPolygon);


        MKERNEL_API int mkernel_polygon_linear_refine(int meshKernelId,

                                                      const GeometryList& polygonToRefine,

                                                      int firstNodeIndex,

                                                      int secondNodeIndex,

                                                      GeometryList& refinedPolygon);


        MKERNEL_API int mkernel_polygon_snap_to_landboundary(int meshKernelId,

                                                             const GeometryList& land,

                                                             GeometryList& polygon,

                                                             int startIndex,

                                                             int endIndex);


#ifdef __cplusplus

    }

#endif

} // namespace meshkernelapi

meshkernelapi
Contains all structs and functions exposed at the API level.
Definition BoundingBox.hpp:33

meshkernelapi::mkernel_mesh2d_count_hanging_edges
MKERNEL_API int mkernel_mesh2d_count_hanging_edges(int meshKernelId, int &numEdges)
Count the number of hanging edges in a mesh2d. An hanging edge is an edge where one of the two nodes ...

meshkernelapi::mkernel_expunge_state
MKERNEL_API int mkernel_expunge_state(int meshKernelId)
Deallocate mesh state and remove it completely, no undo for this meshKernelId will be possible after ...

meshkernelapi::mkernel_mesh2d_merge_nodes
MKERNEL_API int mkernel_mesh2d_merge_nodes(int meshKernelId, const GeometryList &geometryListIn)
Merges the mesh2d nodes within a distance of 0.001 m, effectively removing all small edges.

meshkernelapi::mkernel_mesh2d_delete_edge_by_index
MKERNEL_API int mkernel_mesh2d_delete_edge_by_index(int meshKernelId, int edgeIndex)
Deletes a mesh2d edge given the index of the edge. The coordinates of the edge middle points are used...

meshkernelapi::mkernel_mesh2d_get_filtered_face_polygons
MKERNEL_API int mkernel_mesh2d_get_filtered_face_polygons(int meshKernelId, int propertyValue, double minValue, double maxValue, const GeometryList &facePolygons)
Gets the geometry list containing the face polygons within the filtering range.

meshkernelapi::mkernel_get_interpolation_type_short
MKERNEL_API int mkernel_get_interpolation_type_short(int &type)
Get the integer indicating the interpolation type short.

meshkernelapi::mkernel_get_averaging_method_min_absolute_value
MKERNEL_API int mkernel_get_averaging_method_min_absolute_value(int &method)
Gets an int indicating the minimum absolute value averaging method type.

meshkernelapi::mkernel_mesh2d_delete_edge
MKERNEL_API int mkernel_mesh2d_delete_edge(int meshKernelId, double xCoordinate, double yCoordinate, double xLowerLeftBoundingBox, double yLowerLeftBoundingBox, double xUpperRightBoundingBox, double yUpperRightBoundingBox)
Deletes the closest mesh2d edge to a point. The coordinates of the edge middle points are used for ca...

meshkernelapi::mkernel_curvilinear_get_location_index
MKERNEL_API int mkernel_curvilinear_get_location_index(int meshKernelId, double xCoordinate, double yCoordinate, int locationType, const BoundingBox &boundingBox, int &locationIndex)
Gets the grid location closet to a specific coordinate.

meshkernelapi::mkernel_get_separator
MKERNEL_API double mkernel_get_separator()
Gets the double value used in the back-end library as separator and missing value.

meshkernelapi::mkernel_get_splines
MKERNEL_API int mkernel_get_splines(const GeometryList &geometryListIn, GeometryList &geometryListOut, int numberOfPointsBetweenNodes)
Get the computed spline points between two corner nodes.

meshkernelapi::mkernel_network1d_to_mesh1d
MKERNEL_API int mkernel_network1d_to_mesh1d(int meshKernelId, double minFaceSize)
Convert network chainages to mesh1d nodes and edges.

meshkernelapi::mkernel_curvilinear_compute_circular_grid
MKERNEL_API int mkernel_curvilinear_compute_circular_grid(int meshKernelId, const meshkernel::MakeGridParameters &parameters)
Compute a rectangular or circular curvilinear grid.

meshkernelapi::mkernel_mesh2d_compute_orthogonalization
MKERNEL_API int mkernel_mesh2d_compute_orthogonalization(int meshKernelId, int projectToLandBoundaryOption, const meshkernel::OrthogonalizationParameters &orthogonalizationParameters, const GeometryList &selectingPolygon, const GeometryList &landBoundaries)

meshkernelapi::mkernel_mesh2d_get_data
MKERNEL_API int mkernel_mesh2d_get_data(int meshKernelId, Mesh2D &mesh2d)
Gets the Mesh2D dimensions data.

meshkernelapi::mkernel_undo_state_count_for_id
MKERNEL_API int mkernel_undo_state_count_for_id(int meshKernelId, int &committedCount, int &restoredCount)
Count the number of undo actions for a particular meshKernelId.

meshkernelapi::mkernel_curvilinear_initialize_orthogonal_grid_from_splines
MKERNEL_API int mkernel_curvilinear_initialize_orthogonal_grid_from_splines(int meshKernelId, const GeometryList &geometryList, const meshkernel::CurvilinearParameters &curvilinearParameters, const meshkernel::SplinesToCurvilinearParameters &splinesToCurvilinearParameters)
Generates a curvilinear grid from splines with the advancing front method. Initialization step (inter...

meshkernelapi::mkernel_curvilinear_orthogonalize
MKERNEL_API int mkernel_curvilinear_orthogonalize(int meshKernelId, const meshkernel::OrthogonalizationParameters &orthogonalizationParameters, double xLowerLeftCorner, double yLowerLeftCorner, double xUpperRightCorner, double yUpperRightCorner)
Define a block on the curvilinear grid where to perform orthogonalization.

meshkernelapi::mkernel_mesh1d_get_data
MKERNEL_API int mkernel_mesh1d_get_data(int meshKernelId, Mesh1D &mesh1d)
Gets the Mesh1D data.

meshkernelapi::mkernel_curvilinear_insert_face
MKERNEL_API int mkernel_curvilinear_insert_face(int meshKernelId, double xCoordinate, double yCoordinate)
Inserts a new face on a curvilinear grid. The new face will be inserted on top of the closest edge by...

meshkernelapi::mkernel_polygon_count_linear_refine
MKERNEL_API int mkernel_polygon_count_linear_refine(int meshKernelId, const GeometryList &polygonToRefine, int firstIndex, int secondIndex, int &numberOfPolygonNodes)
Counts the number of polygon nodes resulting from polygon refinement with mkernel_polygon_linear_refi...

meshkernelapi::mkernel_mesh2d_averaging_interpolation
MKERNEL_API int mkernel_mesh2d_averaging_interpolation(int meshKernelId, const GeometryList &samples, int locationType, int averagingMethodType, double relativeSearchSize, size_t minNumSamples, GeometryList &results)
AveragingInterpolation interpolation (ec_module)

meshkernelapi::mkernel_mesh2d_count_nodes_in_polygons
MKERNEL_API int mkernel_mesh2d_count_nodes_in_polygons(int meshKernelId, const GeometryList &geometryListIn, int inside, int &numberOfMeshNodes)
Counts the number of selected mesh node indices.

meshkernelapi::mkernel_mesh2d_get_mesh_boundaries_as_polygons
MKERNEL_API int mkernel_mesh2d_get_mesh_boundaries_as_polygons(int meshKernelId, GeometryList &selectionPolygon, GeometryList &boundaryPolygons)
Retrieves the boundaries of a mesh as a series of separated polygons.

meshkernelapi::mkernel_contacts_compute_boundary
MKERNEL_API int mkernel_contacts_compute_boundary(int meshKernelId, const int *oneDNodeMask, const GeometryList &polygons, double searchRadius)
Computes 1d-2d contacts, where 1d nodes are connected to the closest 2d faces at the boundary (ggeo_m...

meshkernelapi::mkernel_mesh2d_delete_orthogonalization
MKERNEL_API int mkernel_mesh2d_delete_orthogonalization(int meshKernelId)
Cleans the orthogonalization algorithm state, allocated in mkernel_mesh2d_initialize_orthogonalizatio...

meshkernelapi::mkernel_mesh2d_get_hanging_edges
MKERNEL_API int mkernel_mesh2d_get_hanging_edges(int meshKernelId, int *edges)
Gets the indices of hanging edges. An hanging edge is an edge where one of the two nodes is not conne...

meshkernelapi::mkernel_get_projection_cartesian
MKERNEL_API int mkernel_get_projection_cartesian(int &projection)
Gets an int indicating the cartesian projection.

meshkernelapi::mkernel_polygon_count_offset
MKERNEL_API int mkernel_polygon_count_offset(int meshKernelId, const GeometryList &geometryListIn, int innerPolygon, double distance, int &numberOfPolygonNodes)
Counts the number of polygon nodes resulting from polygon offset.

meshkernelapi::mkernel_curvilinear_compute_rectangular_grid_on_extension
MKERNEL_API int mkernel_curvilinear_compute_rectangular_grid_on_extension(int meshKernelId, const meshkernel::MakeGridParameters &makeGridParameters)
Computes a rectangular curvilinear grid on a defined extension.

meshkernelapi::mkernel_curvilinear_convert_to_mesh2d
MKERNEL_API int mkernel_curvilinear_convert_to_mesh2d(int meshKernelId)
Converts a curvilinear grid to an unstructured mesh.

meshkernelapi::mkernel_mesh2d_connect_meshes
MKERNEL_API int mkernel_mesh2d_connect_meshes(int meshKernelId, const Mesh2D &mesh2d, double searchFraction, bool connect)
Connect two or more disconnected regions along boundary.

meshkernelapi::mkernel_curvilinear_frozen_line_add
MKERNEL_API int mkernel_curvilinear_frozen_line_add(int meshKernelId, double xFirstGridLineNode, double yFirstGridLineNode, double xSecondGridLineNode, double ySecondGridLineNode, int &frozenLineId)
Sets a new frozen line in the meshkernel state.

meshkernelapi::mkernel_mesh2d_delete_node
MKERNEL_API int mkernel_mesh2d_delete_node(int meshKernelId, int nodeIndex)
Deletes a mesh2d node.

meshkernelapi::mkernel_curvilinear_compute_orthogonal_grid_from_splines
MKERNEL_API int mkernel_curvilinear_compute_orthogonal_grid_from_splines(int meshKernelId, const GeometryList &geometryList, const meshkernel::CurvilinearParameters &curvilinearParameters, const meshkernel::SplinesToCurvilinearParameters &splinesToCurvilinearParameters)
Generates curvilinear grid from splines with the advancing front method.

meshkernelapi::mkernel_clear_undo_state
MKERNEL_API int mkernel_clear_undo_state()
Clear the undo state for all mesh kernel ids, no undo is possible after this.

meshkernelapi::mkernel_get_inner_outer_separator
MKERNEL_API double mkernel_get_inner_outer_separator()
Gets the double value used to separate the inner part of a polygon from its outer part.

meshkernelapi::mkernel_mesh2d_make_triangular_mesh_from_samples
MKERNEL_API int mkernel_mesh2d_make_triangular_mesh_from_samples(int meshKernelId, const GeometryList &samples)
Makes a triangular mesh from a set of samples, triangulating the sample points.

meshkernelapi::mkernel_get_interpolation_type_float
MKERNEL_API int mkernel_get_interpolation_type_float(int &type)
Get the integer indicating the interpolation type float.

meshkernelapi::mkernel_curvilinear_get_boundaries_as_polygons
MKERNEL_API int mkernel_curvilinear_get_boundaries_as_polygons(int meshKernelId, int lowerLeftN, int lowerLeftM, int upperRightN, int upperRightM, GeometryList &boundaryPolygons)
Gets the boundary polygon of a curvilinear grid, nodes with invalid coordinates are excluded.

meshkernelapi::mkernel_network1d_compute_fixed_chainages
MKERNEL_API int mkernel_network1d_compute_fixed_chainages(int meshKernelId, double *fixedChainages, int sizeFixedChainages, double minFaceSize, double fixedChainagesOffset)
Compute the network chainages from fixed point locations.

meshkernelapi::mkernel_polygon_get_offset
MKERNEL_API int mkernel_polygon_get_offset(int meshKernelId, const GeometryList &geometryListIn, int inWard, double distance, GeometryList &geometryListOut)
Generate a new polygon from an existing one by offsetting the perimeter by a given distance.

meshkernelapi::mkernel_mesh2d_casulli_derefinement_on_polygon
MKERNEL_API int mkernel_mesh2d_casulli_derefinement_on_polygon(int meshKernelId, const GeometryList &polygons)
De-refine mesh using the Casulli de-refinement algorithm.

meshkernelapi::mkernel_polygon_count_refine
MKERNEL_API int mkernel_polygon_count_refine(int meshKernelId, const GeometryList &polygonToRefine, int firstIndex, int secondIndex, double distance, int &numberOfPolygonNodes)
Counts the number of polygon nodes resulting from polygon refinement with mkernel_polygon_refine.

meshkernelapi::mkernel_get_exit_code_mesh_geometry_error
MKERNEL_API int mkernel_get_exit_code_mesh_geometry_error(int &exitCode)
Gets the exit code of an exception of type MeshGeometryexitCode.

meshkernelapi::mkernel_mesh2d_count_mesh_boundaries_as_polygons
MKERNEL_API int mkernel_mesh2d_count_mesh_boundaries_as_polygons(int meshKernelId, GeometryList &selectionPolygon, int &numberOfPolygonNodes)
Counts the number of polygon nodes contained in the mesh boundary polygons computed in function mkern...

meshkernelapi::mkernel_mesh2d_prepare_outer_iteration_orthogonalization
MKERNEL_API int mkernel_mesh2d_prepare_outer_iteration_orthogonalization(int meshKernelId)
Prepares an outer orthogonalization iteration, computing the new orthogonalization and smoothing weig...

meshkernelapi::mkernel_mesh2d_get_edge
MKERNEL_API int mkernel_mesh2d_get_edge(int meshKernelId, double xCoordinate, double yCoordinate, double xLowerLeftBoundingBox, double yLowerLeftBoundingBox, double xUpperRightBoundingBox, double yUpperRightBoundingBox, int &edgeIndex)
Gets the closest mesh2d edge to a point in a bounding box.

meshkernelapi::mkernel_redo_state
MKERNEL_API int mkernel_redo_state(bool &redone, int &meshKernelId)
Attempt to redo by one undo-action.

meshkernelapi::mkernel_mesh2d_delete_small_flow_edges_and_small_triangles
MKERNEL_API int mkernel_mesh2d_delete_small_flow_edges_and_small_triangles(int meshKernelId, double smallFlowEdgesThreshold, double minFractionalAreaTriangles)
Deletes all small mesh2d flow edges and small triangles. The flow edges are the edges connecting face...

meshkernelapi::mkernel_curvilinear_snap_to_spline
MKERNEL_API int mkernel_curvilinear_snap_to_spline(int meshKernelId, const GeometryList &spline, double sectionControlPoint1x, double sectionControlPoint1y, double sectionControlPoint2x, double sectionControlPoint2y, double regionControlPointX=mkernel_get_separator(), double regionControlPointY=mkernel_get_separator())
Sets the curvilinear grid.

meshkernelapi::mkernel_mesh2d_intersections_from_polygon
MKERNEL_API int mkernel_mesh2d_intersections_from_polygon(int meshKernelId, const GeometryList &boundaryPolygon, int *edgeNodes, int *edgeIndex, double *edgeDistances, double *segmentDistances, int *segmentIndexes, int *faceIndexes, int *faceNumEdges, int *faceEdgeIndex)
Gets the edges intersected by a polygon, with additional information on the intersections.

meshkernelapi::mkernel_mesh2d_count_small_flow_edge_centers
MKERNEL_API int mkernel_mesh2d_count_small_flow_edge_centers(int meshKernelId, double smallFlowEdgesLengthThreshold, int &numSmallFlowEdges)
Counts the number of small mesh2d flow edges. The flow edges are the edges connecting faces circumcen...

meshkernelapi::mkernel_get_projection_spherical_accurate
MKERNEL_API int mkernel_get_projection_spherical_accurate(int &projection)
Gets an int indicating the spherical accurate projection.

meshkernelapi::mkernel_mesh2d_get_obtuse_triangles_mass_centers
MKERNEL_API int mkernel_mesh2d_get_obtuse_triangles_mass_centers(int meshKernelId, GeometryList &result)
Gets the mass centers of obtuse mesh2d triangles. Obtuse triangles are those having one edge longer t...

meshkernelapi::mkernel_get_version
MKERNEL_API int mkernel_get_version(char *version)
Gets pointer to version string.

meshkernelapi::mkernel_curvilinear_set_line_line_shift
MKERNEL_API int mkernel_curvilinear_set_line_line_shift(int meshKernelId, double xFirstGridLineNode, double yFirstGridLineNode, double xSecondGridLineNode, double ySecondGridLineNode)
Sets the start and end nodes of the line to shift.

meshkernelapi::mkernel_mesh2d_get_closest_node
MKERNEL_API int mkernel_mesh2d_get_closest_node(int meshKernelId, double xCoordinateIn, double yCoordinateIn, double searchRadius, double xLowerLeftBoundingBox, double yLowerLeftBoundingBox, double xUpperRightBoundingBox, double yUpperRightBoundingBox, double &xCoordinateOut, double &yCoordinateOut)
Gets the closest mesh2d node coordinates to a point, searching within a radius.

meshkernelapi::mkernel_mesh2d_merge_two_nodes
MKERNEL_API int mkernel_mesh2d_merge_two_nodes(int meshKernelId, int firstNode, int secondNode)
Merges two mesh2d nodes into one.

meshkernelapi::mkernel_get_exit_code_stdlib_exception
MKERNEL_API int mkernel_get_exit_code_stdlib_exception(int &exitCode)
Gets the exit code of an exception of type std::exception.

meshkernelapi::mkernel_mesh2d_get_small_flow_edge_centers
MKERNEL_API int mkernel_mesh2d_get_small_flow_edge_centers(int meshKernelId, double smallFlowEdgesThreshold, GeometryList &result)
Gets the small mesh2d flow edges. The flow edges are the edges connecting faces circumcenters.

meshkernelapi::mkernel_mesh2d_remove_disconnected_regions
MKERNEL_API int mkernel_mesh2d_remove_disconnected_regions(int meshKernelId)
Remove any disconnected regions from a mesh2d.

meshkernelapi::mkernel_curvilinear_compute_grid_from_splines
MKERNEL_API int mkernel_curvilinear_compute_grid_from_splines(int meshKernelId, const GeometryList &geometryList, const meshkernel::CurvilinearParameters &curvilinearParameters)
Generates curvilinear grid from splines.

meshkernelapi::mkernel_curvilinear_compute_smoothness
MKERNEL_API int mkernel_curvilinear_compute_smoothness(int meshKernelId, int direction, double *smoothness)
Computes the smoothness of a curvilinear grid.

meshkernelapi::mkernel_curvilinear_line_attraction_repulsion
MKERNEL_API int mkernel_curvilinear_line_attraction_repulsion(int meshKernelId, double repulsionParameter, double xFirstNodeOnTheLine, double yFirstNodeOnTheLine, double xSecondNodeOnTheLine, double ySecondNodeOnTheLine, double xLowerLeftCorner, double yLowerLeftCorner, double xUpperRightCorner, double yUpperRightCorner)
Attracts/repulses grid lines in a block towards another set grid line.

meshkernelapi::mkernel_deallocate_state
MKERNEL_API int mkernel_deallocate_state(int meshKernelId)
Deallocate mesh state.

meshkernelapi::mkernel_mesh2d_get_property_dimension
MKERNEL_API int mkernel_mesh2d_get_property_dimension(int meshKernelId, int propertyValue, int &dimension)
The dimension of a specified property of a 2D mesh.

meshkernelapi::mkernel_get_averaging_method_inverse_distance_weighting
MKERNEL_API int mkernel_get_averaging_method_inverse_distance_weighting(int &method)
Gets an int indicating the inverse distance weights averaging method type.

meshkernelapi::mkernel_get_geometry_error
MKERNEL_API int mkernel_get_geometry_error(int &invalidIndex, int &type)
Gets the index of the erroneous entity.

meshkernelapi::mkernel_curvilinear_initialize_line_shift
MKERNEL_API int mkernel_curvilinear_initialize_line_shift(int meshKernelId)
Initializes the curvilinear line shift algorithm.

meshkernelapi::mkernel_get_averaging_method_closest_point
MKERNEL_API int mkernel_get_averaging_method_closest_point(int &method)
Gets an int indicating the closest point averaging method type.

meshkernelapi::mkernel_clear_state
MKERNEL_API int mkernel_clear_state()
Clear all internal mesh kernel state and undo actions, no undo will be possible after this.

meshkernelapi::mkernel_curvilinear_compute_rectangular_grid_from_polygon
MKERNEL_API int mkernel_curvilinear_compute_rectangular_grid_from_polygon(int meshKernelId, const meshkernel::MakeGridParameters &makeGridParameters, const GeometryList &geometryList)
Computes a rectangular curvilinear grid from polygon.

meshkernelapi::mkernel_mesh2d_make_rectangular_mesh_from_polygon
MKERNEL_API int mkernel_mesh2d_make_rectangular_mesh_from_polygon(int meshKernelId, const meshkernel::MakeGridParameters &makeGridParameters, const GeometryList &geometryList)
Makes a rectangular mesh from a polygon.

meshkernelapi::mkernel_curvilinear_get_data
MKERNEL_API int mkernel_curvilinear_get_data(int meshKernelId, CurvilinearGrid &curvilinearGrid)
Gets the curvilinear grid data as a CurvilinearGrid struct (converted as set of edges and nodes)

meshkernelapi::mkernel_mesh2d_get_dimensions
MKERNEL_API int mkernel_mesh2d_get_dimensions(int meshKernelId, Mesh2D &mesh2d)
Gets the Mesh2D dimensions.

meshkernelapi::mkernel_mesh2d_make_rectangular_mesh
MKERNEL_API int mkernel_mesh2d_make_rectangular_mesh(int meshKernelId, const meshkernel::MakeGridParameters &makeGridParameters)
Makes a rectangular mesh.

meshkernelapi::mkernel_get_exit_code_algorithm_error
MKERNEL_API int mkernel_get_exit_code_algorithm_error(int &exitCode)
Gets the exit code of an exception of type AlgorithmexitCode.

meshkernelapi::mkernel_mesh2d_make_rectangular_mesh_on_extension
MKERNEL_API int mkernel_mesh2d_make_rectangular_mesh_on_extension(int meshKernelId, const meshkernel::MakeGridParameters &makeGridParameters)
Makes a rectangular mesh on a defined extension.

meshkernelapi::mkernel_curvilinear_move_node_line_shift
MKERNEL_API int mkernel_curvilinear_move_node_line_shift(int meshKernelId, double xFromCoordinate, double yFromCoordinate, double xToCoordinate, double yToCoordinate)
Moves a node of the line to shift, the operation can be performed multiple times.

meshkernelapi::mkernel_mesh2d_flip_edges
MKERNEL_API int mkernel_mesh2d_flip_edges(int meshKernelId, int isTriangulationRequired, int projectToLandBoundaryRequired, const GeometryList &selectingPolygon, const GeometryList &landBoundaries)
Flips mesh2d edges, to optimize the mesh smoothness. This operation is usually performed after mkerne...

meshkernelapi::mkernel_mesh2d_get_face_polygons
MKERNEL_API int mkernel_mesh2d_get_face_polygons(int meshKernelId, int numEdges, const GeometryList &facePolygons)
Gets the faces polygons with a number of edges larger or equal to numEdges.

meshkernelapi::mkernel_mesh2d_make_triangular_mesh_from_polygon
MKERNEL_API int mkernel_mesh2d_make_triangular_mesh_from_polygon(int meshKernelId, const GeometryList &polygonPoints)
Generates a triangular mesh2d grid within a polygon. The size of the triangles is determined from the...

meshkernelapi::mkernel_mesh2d_casulli_refinement_on_polygon
MKERNEL_API int mkernel_mesh2d_casulli_refinement_on_polygon(int meshKernelId, const GeometryList &polygons)
Refine mesh using the Casulli refinement algorithm.

meshkernelapi::mkernel_mesh2d_get_node_index
MKERNEL_API int mkernel_mesh2d_get_node_index(int meshKernelId, double xCoordinate, double yCoordinate, double searchRadius, double xLowerLeftBoundingBox, double yLowerLeftBoundingBox, double xUpperRightBoundingBox, double yUpperRightBoundingBox, int &nodeIndex)
Finds the mesh2d node closest to a point, within a search radius.

meshkernelapi::mkernel_mesh2d_move_node
MKERNEL_API int mkernel_mesh2d_move_node(int meshKernelId, double xCoordinate, double yCoordinate, int nodeIndex)
Moves a mesh2d node to a new position.

meshkernelapi::mkernel_get_interpolation_type_int
MKERNEL_API int mkernel_get_interpolation_type_int(int &type)
Get the integer indicating the interpolation type int.

meshkernelapi::mkernel_mesh2d_convert_to_curvilinear
MKERNEL_API int mkernel_mesh2d_convert_to_curvilinear(int meshKernelId, double xPointCoordinate, double yPointCoordinate)
Converts a mesh to a curvilinear mesh.

meshkernelapi::mkernel_contacts_get_dimensions
MKERNEL_API int mkernel_contacts_get_dimensions(int meshKernelId, Contacts &contacts)
Gets the number of 1d-2d contacts.

meshkernelapi::mkernel_get_nodes_location_type
MKERNEL_API int mkernel_get_nodes_location_type(int &type)
Gets an int indicating the node location type.

meshkernelapi::mkernel_mesh1d_get_dimensions
MKERNEL_API int mkernel_mesh1d_get_dimensions(int meshKernelId, Mesh1D &mesh1d)
Gets the Mesh1D data dimensions.

meshkernelapi::mkernel_get_exit_code_constraint_error
MKERNEL_API int mkernel_get_exit_code_constraint_error(int &exitCode)
Gets the exit code of an exception of type ConstraintexitCode.

meshkernelapi::mkernel_mesh2d_refine_based_on_samples
MKERNEL_API int mkernel_mesh2d_refine_based_on_samples(int meshKernelId, const GeometryList &samples, double relativeSearchRadius, int minimumNumSamples, const meshkernel::MeshRefinementParameters &meshRefinementParameters)
Refines a mesh2d based on samples. Refinement is achieved by successive splits of the face edges.

meshkernelapi::mkernel_get_projection_spherical
MKERNEL_API int mkernel_get_projection_spherical(int &projection)
Gets an int indicating the spherical projection.

meshkernelapi::mkernel_mesh2d_get_property
MKERNEL_API int mkernel_mesh2d_get_property(int meshKernelId, int propertyValue, int locationId, const GeometryList &geometrylist)
Retrieves a specified property of a 2D mesh.

meshkernelapi::mkernel_curvilinear_get_dimensions
MKERNEL_API int mkernel_curvilinear_get_dimensions(int meshKernelId, CurvilinearGrid &curvilinearGrid)
Gets the curvilinear grid dimensions as a CurvilinearGrid struct (converted as set of edges and nodes...

meshkernelapi::mkernel_mesh2d_casulli_derefinement
MKERNEL_API int mkernel_mesh2d_casulli_derefinement(int meshKernelId)
De-refine mesh using the Casulli de-refinement algorithm.

meshkernelapi::mkernel_mesh2d_delete_hanging_edges
MKERNEL_API int mkernel_mesh2d_delete_hanging_edges(int meshKernelId)
Deletes all hanging edges. An hanging edge is an edge where one of the two nodes is not connected.

meshkernelapi::mkernel_mesh2d_translate
MKERNEL_API int mkernel_mesh2d_translate(int meshKernelId, double translationX, double translationY)
Translate a mesh2d.

meshkernelapi::mkernel_mesh2d_casulli_refinement
MKERNEL_API int mkernel_mesh2d_casulli_refinement(int meshKernelId)
Refine mesh using the Casulli refinement algorithm.

meshkernelapi::mkernel_mesh2d_refine_ridges_based_on_gridded_samples
MKERNEL_API int mkernel_mesh2d_refine_ridges_based_on_gridded_samples(int meshKernelId, const GriddedSamples &griddedSamples, double relativeSearchRadius, int minimumNumSamples, int numberOfSmoothingIterations, const meshkernel::MeshRefinementParameters &meshRefinementParameters)
Refines a mesh2d based on samples with ridge refinement. This method automatically detects the ridges...

meshkernelapi::mkernel_curvilinear_line_mirror
MKERNEL_API int mkernel_curvilinear_line_mirror(int meshKernelId, double mirroringFactor, int numRowsToMirror, double xFirstGridLineNode, double yFirstGridLineNode, double xSecondGridLineNode, double ySecondGridLineNode)
Mirrors a boundary gridline outwards. The boundary grid line is defined by its starting and ending po...

meshkernelapi::mkernel_get_exit_code_range_error
MKERNEL_API int mkernel_get_exit_code_range_error(int &exitCode)
Gets the exit code of an exception of type RangeexitCode.

meshkernelapi::mkernel_curvilinear_delete_node
MKERNEL_API int mkernel_curvilinear_delete_node(int meshKernelId, double xPointCoordinate, double yPointCoordinate)
Delete the node closest to a point.

meshkernelapi::mkernel_mesh2d_convert_projection
MKERNEL_API int mkernel_mesh2d_convert_projection(int meshKernelId, int projectionType, const char *const zoneString)
Converts the projection of a mesh2d.

meshkernelapi::mkernel_mesh2d_insert_edge_from_coordinates
MKERNEL_API int mkernel_mesh2d_insert_edge_from_coordinates(int meshKernelId, double firstNodeX, double firstNodeY, double secondNodeX, double secondNodeY, int &firstNodeIndex, int &secondNodeIndex, int &edgeIndex)
Insert a new mesh2d edge from 2 coordinates.

meshkernelapi::mkernel_curvilinear_iterate_orthogonal_grid_from_splines
MKERNEL_API int mkernel_curvilinear_iterate_orthogonal_grid_from_splines(int meshKernelId, int layer)
One advancement of the front in curvilinear grid from splines (interactive)

meshkernelapi::mkernel_allocate_state
MKERNEL_API int mkernel_allocate_state(int projectionType, int &meshKernelId)
Creates a new mesh state and returns the generated meshKernelId.

meshkernelapi::mkernel_mesh2d_insert_node
MKERNEL_API int mkernel_mesh2d_insert_node(int meshKernelId, double xCoordinate, double yCoordinate, int &nodeIndex)
Insert a new mesh2d node at a specific coordinate.

meshkernelapi::mkernel_curvilinear_snap_to_landboundary
MKERNEL_API int mkernel_curvilinear_snap_to_landboundary(int meshKernelId, const GeometryList &land, double sectionControlPoint1x, double sectionControlPoint1y, double sectionControlPoint2x, double sectionControlPoint2y, double regionControlPointX=mkernel_get_separator(), double regionControlPointY=mkernel_get_separator())
Sets the curvilinear grid.

meshkernelapi::mkernel_mesh2d_rotate
MKERNEL_API int mkernel_mesh2d_rotate(int meshKernelId, double centreX, double centreY, double theta)
Rotate a mesh2d about a point.

meshkernelapi::mkernel_mesh2d_triangulation_interpolation
MKERNEL_API int mkernel_mesh2d_triangulation_interpolation(int meshKernelId, const GeometryList &samples, int locationType, GeometryList &results)
Triangle interpolation (ec_module)

meshkernelapi::mkernel_get_interpolation_type_double
MKERNEL_API int mkernel_get_interpolation_type_double(int &type)
Get the integer indicating the interpolation type double.

meshkernelapi::mkernel_curvilinear_refine
MKERNEL_API int mkernel_curvilinear_refine(int meshKernelId, double xLowerLeftCorner, double yLowerLeftCorner, double xUpperRightCorner, double yUpperRightCorner, int refinement)
Directional curvilinear grid refinement or de-refinement. Additional gridlines are added or removed p...

meshkernelapi::mkernel_curvilinear_compute_transfinite_from_triangle
MKERNEL_API int mkernel_curvilinear_compute_transfinite_from_triangle(int meshKernelId, const GeometryList &polygon, int firstNode, int secondNode, int thirdNode)
Computes a curvilinear grid in a triangle. 3 separate polygon nodes need to be selected.

meshkernelapi::mkernel_curvilinear_delete_interior
MKERNEL_API int mkernel_curvilinear_delete_interior(int meshKernelId, const BoundingBox &boundingBox)
Delete the interior part of a curvilinear grid.

meshkernelapi::mkernel_contacts_compute_with_points
MKERNEL_API int mkernel_contacts_compute_with_points(int meshKernelId, const int *oneDNodeMask, const GeometryList &points)
Computes 1d-2d contacts, where 1d nodes are connected to the 2d faces mass centers containing the inp...

meshkernelapi::mkernel_curvilinear_set_block_line_shift
MKERNEL_API int mkernel_curvilinear_set_block_line_shift(int meshKernelId, double xLowerLeftCorner, double yLowerLeftCorner, double xUpperRightCorner, double yUpperRightCorner)
Defines a block on the curvilinear where the shifting is distributed.

meshkernelapi::mkernel_contacts_compute_with_polygons
MKERNEL_API int mkernel_contacts_compute_with_polygons(int meshKernelId, const int *oneDNodeMask, const GeometryList &polygons)
Computes 1d-2d contacts, where a 2d face per polygon is connected to the closest 1d node (ggeo_make1D...

meshkernelapi::mkernel_get_averaging_method_min
MKERNEL_API int mkernel_get_averaging_method_min(int &method)
Gets an int indicating the minimum averaging method type.

meshkernelapi::mkernel_curvilinear_finalize_line_shift
MKERNEL_API int mkernel_curvilinear_finalize_line_shift(int meshKernelId)
Resets the instance of the line shift algorithm in MeshKernelState.

meshkernelapi::mkernel_curvilinear_delete_exterior
MKERNEL_API int mkernel_curvilinear_delete_exterior(int meshKernelId, const BoundingBox &boundingBox)
Delete the exterior part of a curvilinear grid.

meshkernelapi::mkernel_deallocate_property
MKERNEL_API int mkernel_deallocate_property(int meshKernelId, int propertyId)
Deallocate property calculator.

meshkernelapi::mkernel_mesh1d_set
MKERNEL_API int mkernel_mesh1d_set(int meshKernelId, const Mesh1D &mesh1d)
Sets the meshkernel::Mesh1D state.

meshkernelapi::mkernel_mesh2d_insert_edge
MKERNEL_API int mkernel_mesh2d_insert_edge(int meshKernelId, int startNode, int endNode, int &newEdgeIndex)
Insert a new mesh2d edge connecting two nodes.

meshkernelapi::mkernel_mesh2d_compute_inner_ortogonalization_iteration
MKERNEL_API int mkernel_mesh2d_compute_inner_ortogonalization_iteration(int meshKernelId)
Performs inner orthogonalization iteration, by slowly moving the mesh nodes to new optimal positions ...

meshkernelapi::mkernel_mesh2d_refine_based_on_gridded_samples
MKERNEL_API int mkernel_mesh2d_refine_based_on_gridded_samples(int meshKernelId, const GriddedSamples &griddedSamples, const meshkernel::MeshRefinementParameters &meshRefinementParameters, bool useNodalRefinement)
Refine based on gridded samples.

meshkernelapi::mkernel_mesh2d_refine_based_on_polygon
MKERNEL_API int mkernel_mesh2d_refine_based_on_polygon(int meshKernelId, const GeometryList &geometryList, const meshkernel::MeshRefinementParameters &meshRefinementParameters)
Refines a mesh2d within a polygon. Refinement is achieved by splitting the edges contained in the pol...

meshkernelapi::mkernel_curvilinear_compute_rectangular_grid
MKERNEL_API int mkernel_curvilinear_compute_rectangular_grid(int meshKernelId, const meshkernel::MakeGridParameters &makeGridParameters)
Computes a rectangular curvilinear grid.

meshkernelapi::mkernel_mesh2d_count_obtuse_triangles
MKERNEL_API int mkernel_mesh2d_count_obtuse_triangles(int meshKernelId, int &numObtuseTriangles)
Gets the number of obtuse mesh2d triangles. Obtuse triangles are those having one edge longer than th...

meshkernelapi::mkernel_curvilinear_frozen_line_is_valid
MKERNEL_API int mkernel_curvilinear_frozen_line_is_valid(int meshKernelId, int frozenLineId, bool &isValid)
Checks if a curvilinear frozen line is valid.

meshkernelapi::mkernel_mesh2d_set
MKERNEL_API int mkernel_mesh2d_set(int meshKernelId, const Mesh2D &mesh2d)
Sets the meshkernel::Mesh2D state.

meshkernelapi::mkernel_mesh2d_get_location_index
MKERNEL_API int mkernel_mesh2d_get_location_index(int meshKernelId, double xCoordinate, double yCoordinate, int locationType, const BoundingBox &boundingBox, int &locationIndex)
Gets the mesh location closet to a specific coordinate.

meshkernelapi::mkernel_mesh2d_merge_nodes_with_merging_distance
MKERNEL_API int mkernel_mesh2d_merge_nodes_with_merging_distance(int meshKernelId, const GeometryList &geometryListIn, double mergingDistance)
Merges the mesh2d nodes within a distance of 0.001 m, effectively removing all small edges.

meshkernelapi::mkernel_polygon_snap_to_landboundary
MKERNEL_API int mkernel_polygon_snap_to_landboundary(int meshKernelId, const GeometryList &land, GeometryList &polygon, int startIndex, int endIndex)
Snaps the polygon to the land boundary.

meshkernelapi::mkernel_curvilinear_move_node
MKERNEL_API int mkernel_curvilinear_move_node(int meshKernelId, double xFromPoint, double yFromPoint, double xToPoint, double yToPoint)
Moves a point of a curvilinear grid from one location to another.

meshkernelapi::mkernel_get_faces_location_type
MKERNEL_API int mkernel_get_faces_location_type(int &type)
Gets an int indicating the faces location type.

meshkernelapi::mkernel_mesh2d_delete
MKERNEL_API int mkernel_mesh2d_delete(int meshKernelId, const GeometryList &polygon, int deletionOption, int invertDeletion)
Deletes a mesh in a polygon using several options.

meshkernelapi::mkernel_contacts_compute_single
MKERNEL_API int mkernel_contacts_compute_single(int meshKernelId, const int *oneDNodeMask, const GeometryList &polygons, double projectionFactor)
Computes 1d-2d contacts, where each single 1d node is connected to one mesh2d face circumcenter (ggeo...

meshkernelapi::mkernel_curvilinear_compute_transfinite_from_splines
MKERNEL_API int mkernel_curvilinear_compute_transfinite_from_splines(int meshKernelId, const GeometryList &splines, const meshkernel::CurvilinearParameters &curvilinearParameters)
Generates curvilinear grid from splines with transfinite interpolation.

meshkernelapi::mkernel_mesh2d_set_property
MKERNEL_API int mkernel_mesh2d_set_property(int meshKernelId, const meshkernel::InterpolationParameters &interpolationParameters, const GeometryList &sampleData, int &propertyId)
Sets the property data for the mesh, the sample data points do not have to match the mesh2d nodes.

meshkernelapi::mkernel_curvilinear_frozen_lines_get_ids
MKERNEL_API int mkernel_curvilinear_frozen_lines_get_ids(int meshKernelId, int *frozenLinesIds)
Gets the ids of the frozen lines.

meshkernelapi::mkernel_contacts_set
MKERNEL_API int mkernel_contacts_set(int meshKernelId, const Contacts &contacts)
Sets the 1d-2d contacts.

meshkernelapi::mkernel_mesh2d_get_filtered_face_polygons_dimension
MKERNEL_API int mkernel_mesh2d_get_filtered_face_polygons_dimension(int meshKernelId, int propertyValue, double minValue, double maxValue, int &geometryListDimension)
Retrieves the dimension of the geometry list containing the face polygons within the filtering range.

meshkernelapi::mkernel_mesh2d_casulli_derefinement_elements
MKERNEL_API int mkernel_mesh2d_casulli_derefinement_elements(int meshKernelId, GeometryList &elements)
Get list of elements that will be removed after the Casulli de-refinement algorithm.

meshkernelapi::mkernel_mesh2d_snap_to_landboundary
MKERNEL_API int mkernel_mesh2d_snap_to_landboundary(int meshKernelId, const GeometryList &selectingPolygon, const GeometryList &landBoundaries)
Snaps a mesh to a land boundary.

meshkernelapi::mkernel_contacts_get_data
MKERNEL_API int mkernel_contacts_get_data(int meshKernelId, Contacts &contacts)
Gets the 1d-2d contacts indices (from index / to indices)

meshkernelapi::mkernel_network1d_set
MKERNEL_API int mkernel_network1d_set(int meshKernelId, const GeometryList &polylines)
Sets the meshkernel::Network1D state.

meshkernelapi::mkernel_get_averaging_method_simple_averaging
MKERNEL_API int mkernel_get_averaging_method_simple_averaging(int &method)
Gets an int indicating the simple averaging method type.

meshkernelapi::mkernel_curvilinear_refresh_orthogonal_grid_from_splines
MKERNEL_API int mkernel_curvilinear_refresh_orthogonal_grid_from_splines(int meshKernelId)
Converts curvilinear grid to mesh and refreshes the state (interactive)

meshkernelapi::mkernel_contacts_compute_multiple
MKERNEL_API int mkernel_contacts_compute_multiple(int meshKernelId, const int *oneDNodeMask)
Computes 1d-2d contacts, where a single 1d node is connected to multiple 2d face circumcenters (ggeo_...

meshkernelapi::mkernel_mesh2d_get_node_edge_data
MKERNEL_API int mkernel_mesh2d_get_node_edge_data(int meshKernelId, Mesh2D &mesh2d)
Gets only the node and edge Mesh2D data.

meshkernelapi::mkernel_mesh2d_initialize_orthogonalization
MKERNEL_API int mkernel_mesh2d_initialize_orthogonalization(int meshKernelId, int projectToLandBoundaryOption, meshkernel::OrthogonalizationParameters &orthogonalizationParameters, const GeometryList &selectingPolygon, const GeometryList &landBoundaries)
Initialization of the meshkernel::OrthogonalizationAndSmoothing algorithm.

meshkernelapi::mkernel_mesh2d_is_valid_property
MKERNEL_API int mkernel_mesh2d_is_valid_property(int meshKernelId, const int propertyId, const int locationId, bool &propertyIsAvailable)
Determine if the property data for the mesh can be computed.

meshkernelapi::mkernel_mesh2d_casulli_derefinement_elements_on_polygon
MKERNEL_API int mkernel_mesh2d_casulli_derefinement_elements_on_polygon(int meshKernelId, const GeometryList &polygonGeometry, GeometryList &elements)
Get list of elements that will be removed after the Casulli de-refinement algorithm.

meshkernelapi::mkernel_mesh2d_get_orthogonality_property_type
MKERNEL_API int mkernel_mesh2d_get_orthogonality_property_type(int &type)
Gets an int indicating the orthogonality property type for mesh2d.

meshkernelapi::mkernel_set_undo_size
MKERNEL_API int mkernel_set_undo_size(int undoStackSize)
Set the maximum size of the undo stack.

meshkernelapi::mkernel_mesh1d_add
MKERNEL_API int mkernel_mesh1d_add(int meshKernelId, const Mesh1D &mesh1d)
Adds a mesh to the meshkernel::Mesh1D state.

meshkernelapi::mkernel_curvilinear_set
MKERNEL_API int mkernel_curvilinear_set(int meshKernelId, const CurvilinearGrid &grid)
Sets the curvilinear grid.

meshkernelapi::mkernel_curvilinear_compute_transfinite_from_polygon
MKERNEL_API int mkernel_curvilinear_compute_transfinite_from_polygon(int meshKernelId, const GeometryList &polygons, int firstNode, int secondNode, int thirdNode, int useFourthSide)
Computes a curvilinear grid in a polygon. 3 separate polygon nodes need to be selected.

meshkernelapi::mkernel_curvilinear_smoothing_directional
MKERNEL_API int mkernel_curvilinear_smoothing_directional(int meshKernelId, int smoothingIterations, double xFirstGridlineNode, double yFirstGridlineNode, double xSecondGridLineNode, double ySecondGridLineNode, double xLowerLeftCornerSmoothingArea, double yLowerLeftCornerSmoothingArea, double xUpperRightCornerSmootingArea, double yUpperRightCornerSmootingArea)
Smooths a curvilinear grid along the direction specified by a segment.

meshkernelapi::mkernel_network1d_compute_offsetted_chainages
MKERNEL_API int mkernel_network1d_compute_offsetted_chainages(int meshKernelId, double offset)
Compute the network chainages at a regular offset.

meshkernelapi::mkernel_get_exit_code_not_implemented_error
MKERNEL_API int mkernel_get_exit_code_not_implemented_error(int &exitCode)
Gets the exit code of an exception of type NotImplementedCode.

meshkernelapi::mkernel_mesh2d_finalize_inner_ortogonalization_iteration
MKERNEL_API int mkernel_mesh2d_finalize_inner_ortogonalization_iteration(int meshKernelId)
Finalizes the orthogonalization outer iteration, computing the new coefficients for grid adaption and...

meshkernelapi::mkernel_is_valid_state
MKERNEL_API int mkernel_is_valid_state(int meshKernelId, bool &isValid)
Determine if the meshKernelId is valid.

meshkernelapi::mkernel_curvilinear_line_shift
MKERNEL_API int mkernel_curvilinear_line_shift(int meshKernelId)
Computes the new grid, shifting the line towards the moved nodes and distributing the shifting in blo...

meshkernelapi::mkernel_curvilinear_frozen_line_delete
MKERNEL_API int mkernel_curvilinear_frozen_line_delete(int meshKernelId, int frozenLineId)
Deletes an existing frozen line in the meshkernel state.

meshkernelapi::mkernel_mesh2d_casulli_refinement_based_on_depths
MKERNEL_API int mkernel_mesh2d_casulli_refinement_based_on_depths(int meshKernelId, const GeometryList &polygons, int propertyId, const meshkernel::MeshRefinementParameters &meshRefinementParameters, const double minimumRefinementDepth)
Refine mesh using the Casulli refinement algorithm based on the depth values.

meshkernelapi::mkernel_polygon_linear_refine
MKERNEL_API int mkernel_polygon_linear_refine(int meshKernelId, const GeometryList &polygonToRefine, int firstNodeIndex, int secondNodeIndex, GeometryList &refinedPolygon)
Linear refines the polygon perimeter between two nodes.

meshkernelapi::mkernel_curvilinear_frozen_lines_get_count
MKERNEL_API int mkernel_curvilinear_frozen_lines_get_count(int meshKernelId, int &numFrozenLines)
Gets the number of stored frozen lines in the meshkernel state.

meshkernelapi::mkernel_mesh2d_get_smoothness
MKERNEL_API int mkernel_mesh2d_get_smoothness(int meshKernelId, GeometryList &geometryList)
Gets the smoothness, expressed as the ratio between the values of two neighboring faces areas.

meshkernelapi::mkernel_get_exit_code_linear_algebra_error
MKERNEL_API int mkernel_get_exit_code_linear_algebra_error(int &exitCode)
Gets the exit code of an exception of type LinearAlgebraexitCode.

meshkernelapi::mkernel_mesh2d_get_nodes_in_polygons
MKERNEL_API int mkernel_mesh2d_get_nodes_in_polygons(int meshKernelId, const GeometryList &geometryListIn, int inside, int *selectedNodes)
Gets the indices of the mesh2d nodes selected with a polygon.

meshkernelapi::mkernel_get_exit_code_success
MKERNEL_API int mkernel_get_exit_code_success(int &exitCode)
Gets the success exit code.

meshkernelapi::mkernel_curvilinear_compute_curvature
MKERNEL_API int mkernel_curvilinear_compute_curvature(int meshKernelId, int direction, double *curvature)
Computes the curvature of a curvilinear grid.

meshkernelapi::mkernel_get_exit_code_meshkernel_error
MKERNEL_API int mkernel_get_exit_code_meshkernel_error(int &exitCode)
Gets the exit code of an exception of type MeshKernelError.

meshkernelapi::mkernel_curvilinear_frozen_line_get
MKERNEL_API int mkernel_curvilinear_frozen_line_get(int meshKernelId, int frozenLineId, double &xFirstFrozenLineCoordinate, double &yFirstFrozenLineCoordinate, double &xSecondFrozenLineCoordinate, double &ySecondFrozenLineCoordinate)
Sets a new frozen line in the meshkernel state.

meshkernelapi::mkernel_curvilinear_delete_orthogonal_grid_from_splines
MKERNEL_API int mkernel_curvilinear_delete_orthogonal_grid_from_splines(int meshKernelId)
Finalizes curvilinear grid from splines algorithm.

meshkernelapi::mkernel_get_projection
MKERNEL_API int mkernel_get_projection(int meshKernelId, int &projection)
Gets the coordinate projection of the meshkernel state.

meshkernelapi::mkernel_get_edges_location_type
MKERNEL_API int mkernel_get_edges_location_type(int &type)
Gets an int indicating the edge location type.

meshkernelapi::mkernel_curvilinear_count_boundaries_as_polygons
MKERNEL_API int mkernel_curvilinear_count_boundaries_as_polygons(int meshKernelId, int lowerLeftN, int lowerLeftM, int upperRightN, int upperRightM, int &numberOfPolygonNodes)
Count the number of nodes in curvilinear grid boundary polygons.

meshkernelapi::mkernel_polygon_refine
MKERNEL_API int mkernel_polygon_refine(int meshKernelId, const GeometryList &polygonToRefine, int firstNodeIndex, int secondNodeIndex, double targetEdgeLength, GeometryList &refinedPolygon)
Refines the polygon perimeter between two nodes. This interval is refined to achieve a target edge le...

meshkernelapi::mkernel_clear_undo_state_for_id
MKERNEL_API int mkernel_clear_undo_state_for_id(int meshKernelId)
Clear the undo state for particular mesh kernel id, no undo for the id is possible after this.

meshkernelapi::mkernel_get_averaging_method_max
MKERNEL_API int mkernel_get_averaging_method_max(int &method)
Gets an int indicating the max value averaging method type.

meshkernelapi::mkernel_mesh2d_add
MKERNEL_API int mkernel_mesh2d_add(int meshKernelId, const Mesh2D &mesh2d)
Adds a mesh to the meshkernel::Mesh2D state.

meshkernelapi::mkernel_mesh2d_get_face_polygons_dimension
MKERNEL_API int mkernel_mesh2d_get_face_polygons_dimension(int meshKernelId, int numEdges, int &geometryListDimension)
Gets the dimension of faces polygons with a number of edges larger or equal to numNodes.

meshkernelapi::mkernel_mesh2d_get_orthogonality
MKERNEL_API int mkernel_mesh2d_get_orthogonality(int meshKernelId, GeometryList &geometryList)
Gets the mesh orthogonality, expressed as the ratio between the edges and the segments connecting the...

meshkernelapi::mkernel_undo_state_count
MKERNEL_API int mkernel_undo_state_count(int &committedCount, int &restoredCount)
Count the number of undo actions.

meshkernelapi::mkernel_splines_snap_to_landboundary
MKERNEL_API int mkernel_splines_snap_to_landboundary(int meshKernelId, const GeometryList &land, GeometryList &splines, int startSplineIndex, int endSplineIndex)
Snaps the spline (or splines) to the land boundary.

meshkernelapi::mkernel_undo_state
MKERNEL_API int mkernel_undo_state(bool &undone, int &meshKernelId)
Attempt to undo by one undo-action.

meshkernelapi::mkernel_mesh2d_split_row
MKERNEL_API int mkernel_mesh2d_split_row(int meshKernelId, int firstNode, int secondNode)
An-isotropically refines the elements along a row or column, given a starting edge.

meshkernelapi::mkernel_get_exit_code_unknown_exception
MKERNEL_API int mkernel_get_exit_code_unknown_exception(int &exitCode)
Gets the exit code of an exception of unknown type.

meshkernelapi::mkernel_curvilinear_smoothing
MKERNEL_API int mkernel_curvilinear_smoothing(int meshKernelId, int smoothingIterations, double xLowerLeftCorner, double yLowerLeftCorner, double xUpperRightCorner, double yUpperRightCorner)
Smooths a curvilinear grid.

meshkernelapi::mkernel_mesh2d_make_global
MKERNEL_API int mkernel_mesh2d_make_global(int meshKernelId, int numLongitudeNodes, int numLatitudeNodes)
Compute the global mesh with a given number of points along the longitude and latitude directions.

meshkernelapi::mkernel_get_error
MKERNEL_API int mkernel_get_error(char *errorMessage)
Gets pointer to error message.

meshkernelapi::mkernel_curvilinear_full_refine
MKERNEL_API int mkernel_curvilinear_full_refine(int meshKernelId, int mRefinement, int nRefinement)
Curvilinear grid refinement. Additional gridlines are added in both directions, over the entire grid.

meshkernelapi::mkernel_polygon_get_included_points
MKERNEL_API int mkernel_polygon_get_included_points(int meshKernelId, const GeometryList &selectingPolygon, const GeometryList &polygonToSelect, GeometryList &selectionResults)
Selects the polygon nodes within another polygon.

meshkernel::CurvilinearParameters
A struct used to describe parameters for generating a curvilinear grid in a C-compatible manner.
Definition Parameters.hpp:111

meshkernel::InterpolationParameters
Parameters used by the sample interpolation.
Definition Parameters.hpp:270

meshkernel::MakeGridParameters
This struct describes the necessary parameters to create a new curvilinear grid in a C-compatible man...
Definition Parameters.hpp:38

meshkernel::MeshRefinementParameters
A struct used to describe the mesh refinement parameters in a C-compatible manner.
Definition Parameters.hpp:187

meshkernel::OrthogonalizationParameters
A struct used to describe the orthogonalization parameters in a C-compatible manner.
Definition Parameters.hpp:238

meshkernel::SplinesToCurvilinearParameters
A struct used to describe the spline to curvilinear grid parameters in a C-compatible manner.
Definition Parameters.hpp:139

meshkernelapi::BoundingBox
A struct describing a bounding box.
Definition BoundingBox.hpp:36

meshkernelapi::Contacts
A struct used to describe contacts between a 1d and a 2d mesh.
Definition Contacts.hpp:34

meshkernelapi::CurvilinearGrid
A struct used to describe the values of a curvilinear grid in a C-compatible manner.
Definition CurvilinearGrid.hpp:34

meshkernelapi::GeometryList
A struct used to describe a list of geometries in a C-compatible manner.
Definition GeometryList.hpp:34

meshkernelapi::GriddedSamples
A struct describing gridded samples.
Definition GriddedSamples.hpp:34

meshkernelapi::Mesh1D
A struct used to describe the values of a mesh 1d in a C-compatible manner.
Definition Mesh1D.hpp:34

meshkernelapi::Mesh2D
A struct used to describe the values of an unstructured, two-dimensional mesh in a C-compatible manne...
Definition Mesh2D.hpp:34