Revert "simplify smoothing (#212)" (#215)

This reverts commit 0c9d5d0.

Author: karelispanagiotis

src/iris/nodes/geometry_refinement/smoothing.py

@@ -91,23 +91,32 @@ def _cut_into_arcs(self, polygon: np.ndarray, center_xy: Tuple[float, float]) ->
         Returns:
             Tuple[List[np.ndarray], int]: Tuple with: (list of list of vertices, number of gaps detected in a contour).
         """
-        # sort points by phi angle
-        _, phi = math.cartesian2polar(polygon[:, 0], polygon[:, 1], *center_xy)
-        idx_order = np.argsort(phi)
-        phi = phi[idx_order]
-        polygon = polygon[idx_order]
-
-        # find gaps
-        dphi = phi - np.roll(phi, 1)
-        dphi[0] += 2 * np.pi
-        gap_idx = np.where(dphi > np.radians(self.params.gap_threshold))[0]
-
-        # cut into arcs - each gap index marks the start of an arc
-        if gap_idx.size == 0:
-            return [polygon], 0
-        arcs = [np.vstack([polygon[gap_idx[-1] :], polygon[: gap_idx[0]]])]
-        arcs.extend([polygon[gap_idx[i] : gap_idx[i + 1]] for i in range(0, len(gap_idx) - 1)])
-        return arcs, gap_idx.size
+        rho, phi = math.cartesian2polar(polygon[:, 0], polygon[:, 1], *center_xy)
+        phi, rho = self._sort_two_arrays(phi, rho)
+
+        differences = np.abs(phi - np.roll(phi, -1))
+        # True distance between first and last point
+        differences[-1] = 2 * np.pi - differences[-1]
+
+        gap_indices = np.argwhere(differences > np.radians(self.params.gap_threshold)).flatten()
+
+        if gap_indices.size < 2:
+            return [polygon], gap_indices.size
+
+        gap_indices += 1
+        phi, rho = np.split(phi, gap_indices), np.split(rho, gap_indices)
+
+        arcs = [
+            np.column_stack(math.polar2cartesian(rho_coords, phi_coords, *center_xy))
+            for rho_coords, phi_coords in zip(rho, phi)
+        ]
+
+        # Connect arc which lies between 0 and 2π.
+        if len(arcs) == gap_indices.size + 1:
+            arcs[0] = np.vstack([arcs[0], arcs[-1]])
+            arcs = arcs[:-1]
+
+        return arcs, gap_indices.size
 
     def _smooth_arc(self, vertices: np.ndarray, center_xy: Tuple[float, float]) -> np.ndarray:
         """Smooth a single contour arc.

tests/unit_tests/nodes/geometry_refinement/test_smoothing.py

@@ -16,39 +16,25 @@ def algorithm() -> Smoothing:
 @pytest.mark.parametrize(
     "arc,expected_num_gaps",
     [
-        # on arc - no gaps
         (generate_arc(10, 0.0, 0.0, 0.0, 2 * np.pi), 0),
-        # one arc - one gap
         (generate_arc(10, 0.0, 0.0, 0.0, np.pi), 1),
-        # one arc - one gap not at 0/2pi
         (generate_arc(10, 0.0, 0.0, np.pi, 2.5 * np.pi), 1),
-        # two arcs - two gaps
         (np.vstack([generate_arc(10, 0.0, 0.0, 0.0, np.pi / 4), generate_arc(10, 0.0, 0.0, np.pi, 4 / 3 * np.pi)]), 2),
-        # one arc in two parts - one gap
         (
             np.vstack(
                 [generate_arc(10, 0.0, 0.0, 0.0, np.pi / 4), generate_arc(10, 0.0, 0.0, 4 / 3 * np.pi, 2 * np.pi)]
             ),
             1,
         ),
-        # one arc shuffled - one gap
-        (np.random.permutation(generate_arc(10, 0.0, 0.0, 0.0, np.pi)), 1),
     ],
 )
 def test_cut_into_arcs(algorithm: Smoothing, arc: np.ndarray, expected_num_gaps: int) -> None:
     center_x, center_y = 0.0, 0.0
 
-    result_arcs, result_num_gaps = algorithm._cut_into_arcs(arc, (center_x, center_y))
+    _, result_num_gaps = algorithm._cut_into_arcs(arc, (center_x, center_y))
 
-    # Ensure number of gaps is as expected.
     assert result_num_gaps == expected_num_gaps
 
-    # Ensure that both arrays have the exact same elements.
-    arc_sorted = arc[np.lexsort(arc.T)]
-    result_stacked = np.vstack(result_arcs)
-    result_sorted = result_stacked[np.lexsort(result_stacked.T)]
-    np.testing.assert_equal(arc_sorted, result_sorted)
-
 
 @pytest.mark.parametrize(
     "phis, rhos, expected_result",