From 3e6d542cd7701272c9f415afef6605d5698fe593 Mon Sep 17 00:00:00 2001
From: Russell Johnson <47639332+Russ4262@users.noreply.github.com>
Date: Tue, 15 Mar 2022 23:20:26 -0500
Subject: [PATCH] Path: Fix roughly equal depth entries

Add code block to remove first of any two consecutive, roughly equal depth values (twin values).

Add two unit tests to support new code block and use cases.
---
 src/Mod/Path/PathScripts/PathUtils.py         | 66 ++++++++++++++++++-
 src/Mod/Path/PathTests/TestPathDepthParams.py | 40 +++++++++++
 2 files changed, 104 insertions(+), 2 deletions(-)

diff --git a/src/Mod/Path/PathScripts/PathUtils.py b/src/Mod/Path/PathScripts/PathUtils.py
index 419855bdb2..adaaa49112 100644
--- a/src/Mod/Path/PathScripts/PathUtils.py
+++ b/src/Mod/Path/PathScripts/PathUtils.py
@@ -609,7 +609,11 @@ class depth_params(object):
         self.__step_down = math.fabs(step_down)
         self.__z_finish_step = math.fabs(z_finish_step)
         self.__final_depth = final_depth
-        self.__user_depths = user_depths
+        self.__user_depths = (
+            None
+            if user_depths is None
+            else self.__filter_roughly_equal_depths(user_depths)
+        )
         self.data = self.__get_depths(equalstep=equalstep)
         self.index = 0
 
@@ -718,7 +722,65 @@ class depth_params(object):
             )[1:]
 
         depths.reverse()
-        return depths
+
+        if len(depths) < 2:
+            return depths
+
+        return self.__filter_roughly_equal_depths(depths)
+
+    def __filter_roughly_equal_depths(self, depths):
+        """Depths arrive sorted from largest to smallest, positive to negative.
+        Return unique list of depths, using PathGeom.isRoughly() method to determine
+        if the two values are equal.  Only one of two consecutive equals are removed.
+
+        The assumption is that there are not enough consecutively roughly-equal depths
+        to be removed, so as to eliminate an effective step-down depth with the removal
+        of repetitive roughly-equal values."""
+
+        if len(depths) == 2:
+            if PathGeom.isRoughly(depths[0], depths[1]):
+                return [depths[1]]
+            return depths
+
+        # print("raw depths: {}".format(depths))
+
+        uniqueDepths = depths
+        lastDepth = None
+        maxLoops = 0
+        while maxLoops < 10:
+            # print("\nStart scan... uniqueDepths: {}".format(uniqueDepths))
+            stop = True
+            keep = []
+            # Filter out unique values from consecutive pairs
+            for i in range(0, len(uniqueDepths) - 1):
+                dep1 = uniqueDepths[i]
+                dep2 = uniqueDepths[i + 1]
+                # print("comparing: {} and {}".format(dep1, dep2))
+                # print("lastDepth: {}".format(lastDepth))
+
+                if PathGeom.isRoughly(dep1, dep2):
+                    if PathGeom.isRoughly(lastDepth, dep2):
+                        keep.pop()
+                    keep.append(dep2)
+                    # Cycle again if a roughly-equal pair is found
+                    stop = False
+                else:
+                    if lastDepth is None:
+                        keep.append(dep1)
+                    else:
+                        if not PathGeom.isRoughly(lastDepth, dep1):
+                            keep.append(dep1)
+                    keep.append(dep2)
+
+                lastDepth = dep2
+            # Efor
+            uniqueDepths = keep
+            maxLoops += 1
+            if stop:
+                break
+
+        # print("uniqueDepths: {}".format(uniqueDepths))
+        return uniqueDepths
 
     def __equal_steps(self, start, stop, max_size):
         """returns a list of depths beginning with the bottom (included), ending
diff --git a/src/Mod/Path/PathTests/TestPathDepthParams.py b/src/Mod/Path/PathTests/TestPathDepthParams.py
index fed0779fc8..cc25ec0088 100644
--- a/src/Mod/Path/PathTests/TestPathDepthParams.py
+++ b/src/Mod/Path/PathTests/TestPathDepthParams.py
@@ -211,3 +211,43 @@ class depthTestCases(unittest.TestCase):
             "user_depths": None,
         }
         self.assertRaises(ValueError, PathUtils.depth_params, **args)
+
+    def test90(self):
+        """stepping down with single stepdown exactly equal to total depth"""
+        args = {
+            "clearance_height": 20.0,
+            "safe_height": 15.0,
+            "start_depth": 10.0,
+            "step_down": 10.0,
+            "z_finish_step": 0.0,
+            "final_depth": 0.0,
+            "user_depths": None,
+        }
+
+        expected = [0]
+
+        d = PathUtils.depth_params(**args)
+        r = [i for i in d]
+        self.assertListEqual(
+            r, expected, "Expected {}, but result of {}".format(expected, r)
+        )
+
+    def test100(self):
+        """stepping down with single stepdown roughly equal to total depth"""
+        args = {
+            "clearance_height": 20.0,
+            "safe_height": 15.0,
+            "start_depth": 10.000000001,
+            "step_down": 10.0,
+            "z_finish_step": 0.0,
+            "final_depth": 0.0,
+            "user_depths": None,
+        }
+
+        expected = [0]
+
+        d = PathUtils.depth_params(**args)
+        r = [i for i in d]
+        self.assertListEqual(
+            r, expected, "Expected {}, but result of {}".format(expected, r)
+        )