refactor: update GeneralizeFences docs, _excute and tests

Author: nmaarnio

src/geogenalg/application/generalize_fences.py

@@ -20,7 +20,13 @@
 
 @dataclass(frozen=True)
 class GeneralizeFences(BaseAlgorithm):
-    """Generalize the LineString layer representing fences."""
+    """Generalize lines representing fences.
+
+    Reference data should contain a Point GeoDataFrame with the key
+    "masts".
+
+    Output contains the generalized line fences.
+    """
 
     closing_fence_area_threshold: float
     """Minimum area for a fence-enclosed region."""
@@ -38,7 +44,7 @@ class GeneralizeFences(BaseAlgorithm):
     """Name of the attribute to determine which line features can be merged."""
 
     @override
-    def execute(
+    def _execute(
         self,
         data: GeoDataFrame,
         reference_data: dict[str, GeoDataFrame],

test/application/test_generalize_fences.py

@@ -15,10 +15,26 @@
 
 from geogenalg.application.generalize_fences import GeneralizeFences
 from geogenalg.core.exceptions import GeometryTypeError
+from geogenalg.utility.dataframe_processing import read_gdf_from_file_and_set_index
 
+UNIQUE_ID_COLUMN = "mtk_id"
 
-def _instantiate_algorithm() -> GeneralizeFences:
-    return GeneralizeFences(
+
+def test_generalize_fences_50k(testdata_path: Path) -> None:
+    """Test generalizing fences with parameters to the 1: 50 000 scale."""
+    input_path = testdata_path / "fences_rovaniemi.gpkg"
+    input_data = read_gdf_from_file_and_set_index(
+        input_path,
+        UNIQUE_ID_COLUMN,
+        layer="mtk_fences",
+    )
+
+    masts_data = read_file(input_path, layer="mtk_masts")
+
+    temp_dir = TemporaryDirectory()
+    output_path = temp_dir.name + "/generalized_fences.gpkg"
+
+    algorithm = GeneralizeFences(
         closing_fence_area_threshold=2000,
         closing_fence_area_with_mast_threshold=8000,
         fence_length_threshold=80,
@@ -28,74 +44,89 @@ def _instantiate_algorithm() -> GeneralizeFences:
         attribute_for_line_merge="kohdeluokka",
     )
 
+    control = read_gdf_from_file_and_set_index(
+        input_path,
+        UNIQUE_ID_COLUMN,
+        layer="generalized_fences",
+    )
+    algorithm.execute(input_data, reference_data={"masts": masts_data}).to_file(
+        output_path, layer="result"
+    )
 
-def test_generalize_fences_50k(
-    testdata_path: Path,
-) -> None:
-    """
-    Test generalizing fences with parameters to the 1: 50 000 scale
-    """
-    source_path = testdata_path / "fences_rovaniemi.gpkg"
-
-    temp_dir = TemporaryDirectory()
-    output_path = temp_dir.name + "/generalized_fences.gpkg"
-
-    fences_gdf = read_file(source_path, layer="mtk_fences")
-    masts_gdf = read_file(source_path, layer="mtk_masts")
-
-    algorithm = _instantiate_algorithm()
-
-    result = algorithm.execute(fences_gdf, reference_data={"masts": masts_gdf})
-
-    assert result is not None
-
-    result.to_file(output_path, layer="fences_50k")
-
-    control_fences: GeoDataFrame = read_file(source_path, layer="generalized_fences")
-
-    result_fences = read_file(output_path, layer="fences_50k")
-
-    control_fences = control_fences.sort_values("geometry").reset_index(drop=True)
-    result_fences = result_fences.sort_values("geometry").reset_index(drop=True)
+    result = read_gdf_from_file_and_set_index(output_path, "index", layer="result")
 
-    assert_geodataframe_equal(control_fences, result_fences, check_index_type=False)
+    control = control.sort_values("geometry").reset_index(drop=True)
+    result = result.sort_values("geometry").reset_index(drop=True)
+    assert_geodataframe_equal(control, result)
 
 
 def test_generalize_fences_50k_invalid_geometry_type() -> None:
-    fences_gdf = GeoDataFrame({"id": [1]}, geometry=[Point(0, 0)])
+    input_data = GeoDataFrame({"id": [1]}, geometry=[Point(0, 0)])
 
-    algorithm = _instantiate_algorithm()
+    algorithm = GeneralizeFences(
+        closing_fence_area_threshold=2000,
+        closing_fence_area_with_mast_threshold=8000,
+        fence_length_threshold=80,
+        fence_length_threshold_in_closed_area=300,
+        simplification_tolerance=4,
+        gap_threshold=25,
+        attribute_for_line_merge="kohdeluokka",
+    )
 
     with pytest.raises(
         GeometryTypeError,
         match=r"GeneralizeFences works only with LineString geometries.",
     ):
-        algorithm.execute(data=fences_gdf, reference_data={})
+        algorithm.execute(data=input_data, reference_data={})
 
 
 def test_generalize_fences_50k_missing_masts_data(testdata_path: Path) -> None:
-    source_path = testdata_path / "fences_rovaniemi.gpkg"
-    fences_gdf = read_file(source_path, layer="mtk_fences")
+    input_path = testdata_path / "fences_rovaniemi.gpkg"
+    input_data = read_gdf_from_file_and_set_index(
+        input_path,
+        UNIQUE_ID_COLUMN,
+        layer="mtk_fences",
+    )
 
-    algorithm = _instantiate_algorithm()
+    algorithm = GeneralizeFences(
+        closing_fence_area_threshold=2000,
+        closing_fence_area_with_mast_threshold=8000,
+        fence_length_threshold=80,
+        fence_length_threshold_in_closed_area=300,
+        simplification_tolerance=4,
+        gap_threshold=25,
+        attribute_for_line_merge="kohdeluokka",
+    )
 
     with pytest.raises(
         KeyError,
         match=r"GeneralizeFences requires mast Point GeoDataFrame in reference_data with key 'masts'.",
     ):
-        algorithm.execute(data=fences_gdf, reference_data={})
+        algorithm.execute(data=input_data, reference_data={})
 
 
 def test_generalize_fences_50k_invalid_geometry_type_masts(testdata_path: Path) -> None:
-    source_path = testdata_path / "fences_rovaniemi.gpkg"
-    fences_gdf = read_file(source_path, layer="mtk_fences")
-    masts_gdf = GeoDataFrame(
+    input_path = testdata_path / "fences_rovaniemi.gpkg"
+    input_data = read_gdf_from_file_and_set_index(
+        input_path,
+        UNIQUE_ID_COLUMN,
+        layer="mtk_fences",
+    )
+    masts_data = GeoDataFrame(
         {"id": [1]}, geometry=[LineString((Point(0, 0), Point(1, 0)))]
     )
 
-    algorithm = _instantiate_algorithm()
+    algorithm = GeneralizeFences(
+        closing_fence_area_threshold=2000,
+        closing_fence_area_with_mast_threshold=8000,
+        fence_length_threshold=80,
+        fence_length_threshold_in_closed_area=300,
+        simplification_tolerance=4,
+        gap_threshold=25,
+        attribute_for_line_merge="kohdeluokka",
+    )
 
     with pytest.raises(
         GeometryTypeError, match=r"Masts data should be a Point GeoDataFrame."
     ):
-        algorithm.execute(data=fences_gdf, reference_data={"masts": masts_gdf})
+        algorithm.execute(data=input_data, reference_data={"masts": masts_data})