Refactor geometry processing, constants handling, and docstrings (#40)

- Extract `COLUMN_NAME` to a dedicated `const.py` for reusability and cleaner code.
- Simplify field creation logic in `_create_output_fields` and update related references.
- Adjust parameter descriptions for better clarity in the algorithm's UI.
- Enhance rotation logic with tolerance checks, and improve test cases to address edge scenarios.
- Update docstrings across modules for consistency and precision.

Author: Elfpkck

PolygonsParallelToLine/src/algorithm.py

@@ -14,6 +14,7 @@
 )
 from qgis.PyQt.QtCore import QMetaType  # type: ignore
 
+from .const import COLUMN_NAME
 from .pptl import Params, PolygonsParallelToLine
 
 if TYPE_CHECKING:
@@ -46,8 +47,6 @@ class Algorithm(QgsProcessingAlgorithm):
     :type DISTANCE: str
     :ivar ANGLE: Parameter ID for specifying the maximum angle for rotation.
     :type ANGLE: str
-    :ivar COLUMN_NAME: Name of the attribute column used to store rotation status for each feature.
-    :type COLUMN_NAME: str
     """
 
     OUTPUT_LAYER = "OUTPUT"
@@ -57,7 +56,6 @@ class Algorithm(QgsProcessingAlgorithm):
     NO_MULTI = "NO_MULTI"
     DISTANCE = "DISTANCE"
     ANGLE = "ANGLE"
-    COLUMN_NAME = "_rotated"
 
     def createInstance(self) -> Algorithm:  # noqa: N802
         return self.__class__()
@@ -88,28 +86,19 @@ def initAlgorithm(self, config: dict | None = None) -> None:  # noqa: N802
             )
         )
         self.addParameter(
-            QgsProcessingParameterFeatureSource(self.LINE_LAYER, "Select line layer", [QgsProcessing.TypeVectorLine])
+            QgsProcessingParameterFeatureSource(self.LINE_LAYER, "Line layer", [QgsProcessing.TypeVectorLine])
         )
         self.addParameter(
-            QgsProcessingParameterFeatureSource(
-                self.POLYGON_LAYER, "Select polygon layer", [QgsProcessing.TypeVectorPolygon]
-            )
-        )
-        self.addParameter(
-            QgsProcessingParameterBoolean(
-                self.LONGEST,
-                "Rotate by the longest segment if both angles between polygon segments and line segment <="
-                " 'Angle value'",
-                defaultValue=False,
-            )
+            QgsProcessingParameterFeatureSource(self.POLYGON_LAYER, "Polygon layer", [QgsProcessing.TypeVectorPolygon])
         )
         self.addParameter(
-            QgsProcessingParameterBoolean(self.NO_MULTI, "Do not rotate multipolygons", defaultValue=False)
+            QgsProcessingParameterBoolean(self.LONGEST, "Rotate by the longest segment", defaultValue=False)
         )
+        self.addParameter(QgsProcessingParameterBoolean(self.NO_MULTI, "Skip multipolygons", defaultValue=False))
         self.addParameter(
             QgsProcessingParameterNumber(
                 self.DISTANCE,
-                "Distance from line",
+                "Max distance from line (in units of line layer CRS) (optional)",
                 type=QgsProcessingParameterNumber.Double,
                 minValue=0.0,
                 defaultValue=0.0,
@@ -118,7 +107,7 @@ def initAlgorithm(self, config: dict | None = None) -> None:  # noqa: N802
         self.addParameter(
             QgsProcessingParameterNumber(
                 self.ANGLE,
-                "Angle value",
+                "Max angle (in degrees) for rotation (optional)",
                 type=QgsProcessingParameterNumber.Double,
                 minValue=0.0,
                 maxValue=89.9,
@@ -128,24 +117,23 @@ def initAlgorithm(self, config: dict | None = None) -> None:  # noqa: N802
 
     def _create_output_fields(self, source_layer: QgsProcessingFeatureSource) -> QgsFields:
         """
-        Creates a new set of output fields for a given source layer by copying all fields from the source layer except
-        the rotation field if it exists, then adds the rotation field to store rotation status.
+        Creates output fields by appending a specific field if it does not already exist.
+
+        This function retrieves the fields from the input source layer, checks if a field with the specified name
+        exists, and appends it if missing. The new field has a Boolean type. The resulting set of fields is then
+        returned.
 
-        :param source_layer: The source layer from which fields are copied and processed.
+        :param source_layer: The input source layer from which fields are retrieved.
         :type source_layer: QgsProcessingFeatureSource
-        :return: A new set of fields copied from the source layer, excluding the column matching the specified column
-            name, with an additional field added.
+        :return: The updated fields containing the original fields and the new field, if added.
         :rtype: QgsFields
         """
-        output_fields = QgsFields()
-
-        for field in source_layer.fields():
-            if self.COLUMN_NAME == field.name():
-                continue
-            output_fields.append(field)
+        fields = source_layer.fields()
+        field_idx = fields.indexFromName(COLUMN_NAME)
+        if field_idx == -1:
+            fields.append(QgsField(COLUMN_NAME, QMetaType.Bool))
 
-        output_fields.append(QgsField(self.COLUMN_NAME, QMetaType.Int))
-        return output_fields
+        return fields
 
     def processAlgorithm(  # noqa: N802
         self, parameters: dict[str, Any], context: QgsProcessingContext, feedback: QgsProcessingFeedback

PolygonsParallelToLine/src/const.py

@@ -0,0 +1,6 @@
+"""
+Constants:
+    COLUMN_NAME: Name of the attribute column used to store rotation status for each feature.
+"""
+
+COLUMN_NAME = "_rotated"

PolygonsParallelToLine/src/polygon.py

@@ -2,12 +2,12 @@
 
 from typing import TYPE_CHECKING
 
-from qgis.core import Qgis, QgsProcessingException
+from qgis.core import Qgis, QgsGeometry, QgsProcessingException
 
 from .line import Segment
 
 if TYPE_CHECKING:
-    from qgis.core import QgsFeature, QgsGeometry, QgsPoint, QgsPointXY
+    from qgis.core import QgsFeature, QgsPoint, QgsPointXY
 
     from .line import Line
 
@@ -57,22 +57,25 @@ def get_closest_vertex(self, closest_line: Line) -> QgsPoint:
 
     def get_adjacent_segments(self, target_vertex: QgsPoint) -> tuple[Segment, Segment]:
         """
-        Retrieve the segments adjacent to a specified target vertex within a geometry.
-
-        This method iterates through the geometries in a collection and identifies the vertex that matches the given
-        target. Upon locating the target vertex, it calculates the adjacent vertices and returns two segments, each
-        defined by the target vertex and one of the adjacent vertices. If the target vertex is not found within
-        the geometry, an error is raised.
-
-        :param target_vertex: The vertex within the geometry for which adjacent segments are to be determined.
-        :type target_vertex: QgsPoint
-        :return: A tuple containing two segments:
-            - The segment between the target vertex and the previous vertex.
-            - The segment between the target vertex and the next vertex.
+        Finds and retrieves the two segments adjacent to a given vertex within a geometry.
+
+        The method processes the geometry associated with a feature by cleaning it up, removing interior rings as
+        well as duplicate nodes, and then checking each geometry part for adjacency to the provided target vertex.
+        It identifies the indices of the vertices adjacent to the target vertex and constructs the corresponding
+        segments.
+
+        :param target_vertex: The vertex for which the adjacent segments need to be determined, represented as a
+            QgsPoint.
+        :return: A tuple containing two Segment objects. Each Segment represents a start and end vertex adjacent to
+            the passed target_vertex.
         :rtype: tuple[Segment, Segment]
-        :raises QgsProcessingException: If the specified target vertex is not found within the geometry of the feature.
+        :raises QgsProcessingException: If the target_vertex is not found within the geometry of the feature.
         """
-        for part_geom in self.geom.asGeometryCollection():
+        temp_geom = QgsGeometry(self.geom)
+        temp_geom.removeInteriorRings()
+        temp_geom.removeDuplicateNodes()
+
+        for part_geom in temp_geom.asGeometryCollection():
             for i, current_vertex in enumerate(part_geom.vertices()):
                 if current_vertex == target_vertex:
                     prev_vertex_idx, next_vertex_idx = part_geom.adjacentVertices(i)

PolygonsParallelToLine/src/pptl.py

@@ -11,6 +11,7 @@
     QgsProcessingFeatureSource,
 )
 
+from .const import COLUMN_NAME
 from .line import LineLayer
 from .polygon import Polygon
 from .rotator import PolygonRotator
@@ -148,24 +149,19 @@ def process_polygon(self, polygon: QgsFeature) -> QgsFeature:
 
     def create_new_feature(self, poly: Polygon) -> QgsFeature:
         """
-        Creates a new feature based on the given polygon.
+        Creates a new feature and sets its geometry and attribute based on the provided polygon.
 
-        This method initializes a new feature using predefined fields, sets its geometry based on the input polygon,
-        and transfers attributes from the polygon to the new feature. If the polygon was rotated, an additional
-        attribute with a value of 1 is appended to the attributes.
+        This method creates a new QgsFeature using the provided fields, sets the geometry of the new feature to
+        match the geometry of the provided polygon, and assigns the attribute value to indicate whether the polygon
+        is rotated. The created QgsFeature is then returned.
 
-        :param poly: The input polygon containing geometry and attributes for creating the new feature.
+        :param poly: The polygon object whose geometry and rotation status are used to define the new feature's
+            properties.
         :type poly: Polygon
-        :return: A new feature with geometry derived from the polygon and attributes, including a flag for rotation if
-            applicable.
+        :return: The newly created QgsFeature with its geometry and attributes set accordingly.
         :rtype: QgsFeature
         """
         new_feature = QgsFeature(self.params.fields)
         new_feature.setGeometry(poly.geom)
-        attrs = poly.feature.attributes()
-
-        if poly.is_rotated:
-            attrs.append(1)  # Add 1 if the polygon was rotated
-
-        new_feature.setAttributes(attrs)
+        new_feature.setAttribute(COLUMN_NAME, poly.is_rotated)
         return new_feature

PolygonsParallelToLine/src/rotator.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import math
 from typing import TYPE_CHECKING
 
 from qgis.core import QgsPointXY
@@ -13,30 +14,33 @@
 
 class PolygonRotator:
     """
-    Handles rotation of polygon geometries based on specific geometric relationships and constraints.
+    Handles the behavior of rotating a polygon based on its segments and azimuth differences.
 
-    This class facilitates the rotation of a polygon based on the azimuth angles of its segments relative to a given
-    reference line. The rotation can be executed according to the smallest angle of adjustment or by prioritizing
-    the longest segment. Various geometric methods are utilized to determine the azimuths, angle differences, and
-    relevant polygon segments.
+    This class provides methods for determining and executing rotational adjustments on a polygon. The rotation logic
+    accounts for the relationship between a polygon's vertices, the adjacent segments, and the closest external line
+    segment. Decisions are based on calculated azimuth differences and configurable thresholds. Optional behavior
+    includes determining the rotation based on either the longest polygon segment or the smallest rotation angle.
 
-    :ivar poly: The polygon geometry to be rotated.
+    :ivar poly: The polygon object to be rotated.
     :type poly: Polygon
-    :ivar angle_threshold: The maximum angle deviation for permissible rotation.
+    :ivar angle_threshold: The angle threshold used to determine valid rotations.
     :type angle_threshold: float
-    :ivar by_longest: A flag indicating whether the rotation prioritizes the longest segment or smallest angle.
+    :ivar by_longest: Indicates whether rotation should be based on the longest segment.
     :type by_longest: bool
-    :ivar prev_poly_segment: The polygon segment preceding the closest vertex to the reference line.
+    :ivar prev_poly_segment: The polygon segment preceding the closest vertex.
     :type prev_poly_segment: Segment
-    :ivar next_poly_segment: The polygon segment following the closest vertex to the reference line.
+    :ivar next_poly_segment: The polygon segment following the closest vertex.
     :type next_poly_segment: Segment
-    :ivar prev_delta_azimuth: The azimuth difference between the previous polygon segment and the reference
-                              line segment.
+    :ivar prev_delta_azimuth: The azimuth difference between the line segment and the previous polygon segment.
     :type prev_delta_azimuth: float
-    :ivar next_delta_azimuth: The azimuth difference between the next polygon segment and the reference line segment.
+    :ivar next_delta_azimuth: The azimuth difference between the line segment and the next polygon segment.
     :type next_delta_azimuth: float
+    :ivar ABSOLUTE_TOLERANCE: Tolerance value for numerical closeness comparison in rotation.
+    :type ABSOLUTE_TOLERANCE: float
     """
 
+    ABSOLUTE_TOLERANCE = 1e-8
+
     def __init__(self, poly: Polygon, closest_line: Line, angle_threshold: float, by_longest: bool):
         self.poly = poly
         self.angle_threshold = angle_threshold
@@ -67,17 +71,18 @@ def rotate(self) -> None:
 
     def rotate_by_angle(self, angle: float) -> None:
         """
-        Rotates the polygon by a given angle.
+        Rotates a polygon by a specified angle if the angle is not close to zero.
 
-        This method updates the orientation of the polygon by rotating it around its center by the specified angle.
-        The rotation is applied in a clockwise direction if the angle is positive and counterclockwise if the angle is
-        negative. The angle is specified in degrees.
+        This method checks if the provided angle is approximately zero using a tolerance value. If the angle is not
+        close to zero, the method applies a rotation transformation to the polygon.
 
-        :param angle: The angle by which to rotate the polygon.
+        :param angle: The angle, in degrees, by which the polygon should be rotated.
         :type angle: float
         :return: None
         """
-        self.poly.rotate(angle)
+        is_close_to_zero = math.isclose(angle, 0.0, abs_tol=self.ABSOLUTE_TOLERANCE)
+        if not is_close_to_zero:
+            self.poly.rotate(angle)
 
     def rotate_by_longest_segment(self) -> None:
         """