Add mesh2d_get_filtered_face_polygons api and unit test

meshkernel/meshkernel.py

@@ -459,6 +459,52 @@ def mesh2d_get_face_polygons(self, num_edges: int) -> GeometryList:
 
         return face_polygons
 
+    def mesh2d_get_filtered_face_polygons(self,
+                                          filter: Mesh2d.Metric,
+                                          min_value: float,
+                                          max_value: float) -> GeometryList:
+        """Gets the polygons matching the metric value within the minimum and maximum value.
+
+        Args:
+
+            filter (Mesh2d.Metric): The metric used to filter the locations
+            min_value(float): The minimum value of the metric.
+            max_value(float): The maximum value of the metric.
+
+        Returns:
+            GeometryList: The resulting face polygons
+        """
+        c_geometry_list_dimension = c_int()
+
+        self._execute_function(
+            self.lib.mkernel_mesh2d_get_filtered_face_polygons_dimension,
+            self._meshkernelid,
+            c_int(filter),
+            c_double(min_value),
+            c_double(max_value),
+            byref(c_geometry_list_dimension),
+        )
+
+        n_coordinates = c_geometry_list_dimension.value
+        x_coordinates = np.empty(n_coordinates, dtype=np.double)
+        y_coordinates = np.empty(n_coordinates, dtype=np.double)
+
+        face_polygons = GeometryList(
+            x_coordinates=x_coordinates, y_coordinates=y_coordinates
+        )
+        c_face_polygons = CGeometryList.from_geometrylist(face_polygons)
+
+        self._execute_function(
+            self.lib.mkernel_mesh2d_get_filtered_face_polygons,
+            self._meshkernelid,
+            c_int(filter),
+            c_double(min_value),
+            c_double(max_value),
+            byref(c_face_polygons),
+        )
+
+        return face_polygons
+
     def mesh2d_get_node_index(self, x: float, y: float, search_radius: float) -> int:
         """Finds the node closest to a point within a given search radius.
 

meshkernel/py_structures.py

@@ -118,6 +118,12 @@ class Mesh2d:
 
     """
 
+    @unique
+    class Metric(IntEnum):
+        """Different filtering metrics on a 2D mesh."""
+
+        ORTHOGONALITY = 0
+
     def __init__(
         self,
         node_x=np.empty(0, dtype=np.double),

tests/test_mesh2d_basics.py

@@ -18,6 +18,7 @@
     MeshRefinementParameters,
     ProjectionType,
     RefinementType,
+    Mesh2dLocation,
 )
 
 cases_projection_constructor = [(ProjectionType.CARTESIAN), (ProjectionType.SPHERICAL)]
@@ -2305,3 +2306,39 @@ def test_mesh2d_deletion_and_get_orthogonality(
     values = values_at_locations_functions(mk).values
     mesh2d = mk.mesh2d_get()
     assert len(values) == len(mesh2d.edge_x)
+
+
+def test_mesh2d_get_filtered_face_polygons():
+
+    """Test mesh2d_get_filtered_face_polygons,
+    getting the polygons of faces with all edges having bad orthogonality values
+        """
+    mk = MeshKernel()
+
+    edge_nodes = np.array([0, 1,
+        1, 2,
+        2, 3,
+        0, 3,
+        1, 4,
+        0, 4,
+        0, 5,
+        3, 5,
+        3, 6,
+        2, 6,
+        2, 7,
+        1, 7], dtype=np.int32)
+
+    node_x = np.array([57.0, 49.1, 58.9, 66.7, 48.8, 65.9, 67.0, 49.1], dtype=np.double)
+    node_y = np.array([23.6, 14.0, 6.9, 16.2, 23.4, 24.0, 7.2, 6.7], dtype=np.double)
+
+    input_mesh2d = Mesh2d(node_x, node_y, edge_nodes)
+    mk.mesh2d_set(input_mesh2d)
+
+    face_polygons = mk.mesh2d_get_filtered_face_polygons(Mesh2d.Metric.ORTHOGONALITY, 0.04, 1.0)
+
+    expected_coordinates_x = np.array([57.0, 49.1, 58.9, 66.7, 57.0], dtype=np.double)
+    expected_coordinates_y = np.array([23.6, 14.0, 6.9, 16.2, 23.6], dtype=np.double)
+
+    assert face_polygons.x_coordinates == approx(expected_coordinates_x, abs=1e-6)
+    assert face_polygons.y_coordinates == approx(expected_coordinates_y, abs=1e-6)
+