refactor: update GeneralizeFences docs, _excute and tests

Author: nmaarnio

src/geogenalg/application/generalize_fences.py

@@ -20,25 +20,40 @@
 
 @dataclass(frozen=True)
 class GeneralizeFences(BaseAlgorithm):
-    """Generalize the LineString layer representing fences."""
+    """Generalize lines representing fences.
 
-    closing_fence_area_threshold: float
+    Reference data should contain a Point GeoDataFrame with the key
+    "masts".
+
+    Output contains the generalized line fences.
+
+    The algorithm does the following steps:
+    - Merges line segments
+    - Adds helper lines to close small gaps between lines
+    - Removes short lines within large enough enclosed areas
+    - Removes surrounding lines of small enough enclosed areas
+    - Removes close enough lines surrounding a mast
+    - Removes all short lines
+    - Simplifies all lines
+    """
+
+    closing_fence_area_threshold: float = 2000.0
     """Minimum area for a fence-enclosed region."""
-    closing_fence_area_with_mast_threshold: float
+    closing_fence_area_with_mast_threshold: float = 8000.0
     """Minimum area for a fence-enclosed region containing a mast."""
-    fence_length_threshold: float
+    fence_length_threshold: float = 80.0
     """Minimum length for a fence line."""
-    fence_length_threshold_in_closed_area: float
+    fence_length_threshold_in_closed_area: float = 300.0
     """Minimum length for a fence line within a closed area."""
-    simplification_tolerance: float
+    simplification_tolerance: float = 4.0
     """Tolerance used for geometry simplification."""
-    gap_threshold: float
+    gap_threshold: float = 25.0
     """Maximum gap between two fence lines to be connected with a helper line."""
-    attribute_for_line_merge: str
+    attribute_for_line_merge: str = "kohdeluokka"
     """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],
@@ -61,7 +76,8 @@ def execute(
                 GeoDataFrame with key "masts" in `reference_data` contains
                 non-point geometries.
             KeyError: If `reference_data` does not contain data with key
-                "masts".
+                "masts" or input data does not have specified
+                `attribute_for_line_merge`.
 
         """
         if not check_gdf_geometry_type(data, ["LineString"]):
@@ -76,6 +92,12 @@ def execute(
         if not check_gdf_geometry_type(reference_data["masts"], ["Point"]):
             msg = "Masts data should be a Point GeoDataFrame."
             raise GeometryTypeError(msg)
+        if self.attribute_for_line_merge not in data.columns:
+            msg = (
+                "Specified `attribute_for_line_merge` "
+                + f"({self.attribute_for_line_merge}) not found in input GeoDataFrame."
+            )
+            raise KeyError(msg)
 
         result_gdf = data.copy()
 

src/geogenalg/main.py

@@ -195,14 +195,6 @@ def get_class_attribute_docstrings(cls: type[Any]) -> dict[str, str]:
     ),
 ]
 
-GeoPackageOptionMandatory = Annotated[
-    GeoPackageURI,
-    typer.Option(
-        parser=geopackage_uri,
-        help=GEOPACKAGE_URI_HELP,
-    ),
-]
-
 ReferenceGeoPackageList = Annotated[
     list[NamedGeoPackageURI],
     typer.Option(

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})