Improving geometry eq/hash to enable sets

Author: gumyr

src/build123d/build_common.py

@@ -1350,7 +1350,8 @@ def __call__(self, select: Select = Select.ALL) -> T2_covar: ...
 
 def __gen_context_component_getter(
     func: Callable[[Builder, Select], T2],
-) -> ContextComponentGetter[T2]:
+    # ) -> ContextComponentGetter[T2]:
+) -> Callable[[Select], T2]:
     """
     Wraps a Builder method to automatically provide the Builder context.
 

src/build123d/geometry.py

@@ -42,7 +42,7 @@
 import warnings
 
 from collections.abc import Iterable, Sequence
-from math import degrees, pi, radians, isclose
+from math import degrees, log10, pi, radians, isclose
 from typing import Any, overload, TypeAlias, TYPE_CHECKING
 
 import OCP.TopAbs as TopAbs_ShapeEnum
@@ -88,6 +88,7 @@
 logger = logging.getLogger("build123d")
 
 TOLERANCE = 1e-6
+TOL_DIGITS = abs(int(log10(TOLERANCE)))
 TOL = 1e-2
 DEG2RAD = pi / 180.0
 RAD2DEG = 180 / pi
@@ -445,11 +446,17 @@ def __eq__(self, other: object) -> bool:
         """Vectors equal operator =="""
         if not isinstance(other, Vector):
             return NotImplemented
-        return self.wrapped.IsEqual(other.wrapped, 0.00001, 0.00001)
+        return self.wrapped.IsEqual(other.wrapped, TOLERANCE, TOLERANCE)
 
     def __hash__(self) -> int:
         """Hash of Vector"""
-        return hash((round(self.X, 6), round(self.Y, 6), round(self.Z, 6)))
+        return hash(
+            (
+                round(self.X, TOL_DIGITS - 1),
+                round(self.Y, TOL_DIGITS - 1),
+                round(self.Z, TOL_DIGITS - 1),
+            )
+        )
 
     def __copy__(self) -> Vector:
         """Return copy of self"""
@@ -690,6 +697,16 @@ def __deepcopy__(self, _memo) -> Axis:
         """Return deepcopy of self"""
         return Axis(self.position, self.direction)
 
+    def __hash__(self) -> int:
+        """Hash of Axis"""
+        return hash(
+            (
+                round(v, TOL_DIGITS - 1)
+                for vector in [self.position, self.direction]
+                for v in vector
+            )
+        )
+
     def __repr__(self) -> str:
         """Display self"""
         return f"({self.position.to_tuple()},{self.direction.to_tuple()})"
@@ -1660,7 +1677,25 @@ def __eq__(self, other: object) -> bool:
             radians(other.orientation.Y),
             radians(other.orientation.Z),
         )
-        return self.position == other.position and quaternion1.IsEqual(quaternion2)
+        # Test quaternions with tolerance
+        q_values = [
+            [get_value() for get_value in (q.X, q.Y, q.Z, q.W)]
+            for q in (quaternion1, quaternion2)
+        ]
+        quaternion_eq = all(
+            isclose(v1, v2, abs_tol=TOLERANCE) for v1, v2 in zip(*q_values)
+        )
+        return self.position == other.position and quaternion_eq
+
+    def __hash__(self) -> int:
+        """Hash of Location"""
+        return hash(
+            (
+                round(v, TOL_DIGITS - 1)
+                for vector in [self.position, self.orientation]
+                for v in vector
+            )
+        )
 
     def __neg__(self) -> Location:
         """Flip the orientation without changing the position operator -"""
@@ -2563,8 +2598,8 @@ def __eq__(self, other: object):
             return NotImplemented
 
         # equality tolerances
-        eq_tolerance_origin = 1e-6
-        eq_tolerance_dot = 1e-6
+        eq_tolerance_origin = TOLERANCE
+        eq_tolerance_dot = TOLERANCE
 
         return (
             # origins are the same
@@ -2575,6 +2610,16 @@ def __eq__(self, other: object):
             and abs(self.x_dir.dot(other.x_dir) - 1) < eq_tolerance_dot
         )
 
+    def __hash__(self) -> int:
+        """Hash of Plane"""
+        return hash(
+            (
+                round(v, TOL_DIGITS - 1)
+                for vector in [self.origin, self.x_dir, self.z_dir]
+                for v in vector
+            )
+        )
+
     def __neg__(self) -> Plane:
         """Reverse z direction of plane operator -"""
         return Plane(self.origin, self.x_dir, -self.z_dir)

src/build123d/topology/shape_core.py

@@ -866,7 +866,7 @@ def __deepcopy__(self, memo) -> Self:
         if self.wrapped is not None:
             memo[id(self.wrapped)] = downcast(BRepBuilderAPI_Copy(self.wrapped).Shape())
         for key, value in self.__dict__.items():
-            if key == 'topo_parent':
+            if key == "topo_parent":
                 result.topo_parent = value
             else:
                 setattr(result, key, copy.deepcopy(value, memo))

src/build123d/topology/two_d.py

@@ -563,7 +563,10 @@ def _curvature_sign(self) -> float:
             float: The signed value; positive indicates convexity, negative indicates concavity.
                 Returns 0 if the geometry type is unsupported.
         """
-        if self.geom_type == GeomType.CYLINDER:
+        if (
+            self.geom_type == GeomType.CYLINDER
+            and type(self.geom_adaptor()) != Geom_RectangularTrimmedSurface
+        ):
             axis = self.axis_of_rotation
             if axis is None:
                 raise ValueError("Can't find curvature of empty object")

tests/test_direct_api/test_axis.py

@@ -230,6 +230,19 @@ def test_axis_not_equal(self):
         random_obj = object()
         self.assertNotEqual(Axis.X, random_obj)
 
+    def test_set(self):
+        a0 = Axis((0, 1, 2), (3, 4, 5))
+        for i in range(1, 8):
+            for j in range(1, 8):
+                a1 = Axis(
+                    (a0.position.X + 1.0 / (10**i), a0.position.Y, a0.position.Z),
+                    (a0.direction.X + 1.0 / (10**j), a0.direction.Y, a0.direction.Z),
+                )
+                if a0 == a1:
+                    self.assertEqual(len(set([a0, a1])), 1)
+                else:
+                    self.assertEqual(len(set([a0, a1])), 2)
+
     def test_position_property(self):
         axis = Axis.X
         axis.position = 1, 2, 3

tests/test_direct_api/test_location.py

@@ -266,6 +266,23 @@ def test_not_equal(self):
         self.assertNotEqual(loc, diff_orientation)
         self.assertNotEqual(loc, object())
 
+    def test_set(self):
+        l0 = Location((0, 1, 2), (3, 4, 5))
+        for i in range(1, 8):
+            for j in range(1, 8):
+                l1 = Location(
+                    (l0.position.X + 1.0 / (10**i), l0.position.Y, l0.position.Z),
+                    (
+                        l0.orientation.X + 1.0 / (10**j),
+                        l0.orientation.Y,
+                        l0.orientation.Z,
+                    ),
+                )
+                if l0 == l1:
+                    self.assertEqual(len(set([l0, l1])), 1)
+                else:
+                    self.assertEqual(len(set([l0, l1])), 2)
+
     def test_neg(self):
         loc = Location((1, 2, 3), (0, 35, 127))
         n_loc = -loc

tests/test_direct_api/test_plane.py

@@ -408,6 +408,21 @@ def test_plane_not_equal(self):
             Plane(origin=(0, 0, 0), x_dir=(1, 0, 0), z_dir=(0, 1, 1)),
         )
 
+    def test_set(self):
+        p0 = Plane((0, 1, 2), (3, 4, 5), (6, 7, 8))
+        for i in range(1, 8):
+            for j in range(1, 8):
+                for k in range(1, 8):
+                    p1 = Plane(
+                        (p0.origin.X + 1.0 / (10**i), p0.origin.Y, p0.origin.Z),
+                        (p0.x_dir.X + 1.0 / (10**j), p0.x_dir.Y, p0.x_dir.Z),
+                        (p0.z_dir.X + 1.0 / (10**k), p0.z_dir.Y, p0.z_dir.Z),
+                    )
+                    if p0 == p1:
+                        self.assertEqual(len(set([p0, p1])), 1)
+                    else:
+                        self.assertEqual(len(set([p0, p1])), 2)
+
     def test_to_location(self):
         loc = Plane(origin=(1, 2, 3), x_dir=(0, 1, 0), z_dir=(0, 0, 1)).location
         self.assertAlmostEqual(loc.position, (1, 2, 3), 5)

tests/test_direct_api/test_vector.py

@@ -156,6 +156,16 @@ def test_vector_not_equal(self):
         self.assertNotEqual(a, b)
         self.assertNotEqual(a, object())
 
+    def test_vector_sets(self):
+        # Check that equal and hash work the same way to enable sets
+        a = Vector(1, 2, 3)
+        for i in range(1, 8):
+            v = Vector(a.X + 1.0 / (10**i), a.Y, a.Z)
+            if v == a:
+                self.assertEqual(len(set([a, v])), 1)
+            else:
+                self.assertEqual(len(set([a, v])), 2)
+
     def test_vector_distance(self):
         """
         Test line distance from plane.