Merge branch 'master' into sketch-distribute

Author: lorenzncode

cadquery/cq.py

@@ -63,6 +63,7 @@
 CQObject = Union[Vector, Location, Shape, Sketch]
 VectorLike = Union[Tuple[float, float], Tuple[float, float, float], Vector]
 CombineMode = Union[bool, Literal["cut", "a", "s"]]  # a : additive, s: subtractive
+TOL = 1e-6
 
 T = TypeVar("T", bound="Workplane")
 """A type variable used to make the return type of a method the same as the
@@ -1486,51 +1487,42 @@ def polarArray(
         rotate: bool = True,
     ) -> T:
         """
-        Creates an polar array of points and pushes them onto the stack.
-        The 0 degree reference angle is located along the local X-axis.
+        Creates a polar array of points and pushes them onto the stack.
+        The zero degree reference angle is located along the local X-axis.
 
         :param radius: Radius of the array.
-        :param startAngle: Starting angle (degrees) of array. 0 degrees is
-            situated along local X-axis.
+        :param startAngle: Starting angle (degrees) of array. Zero degrees is
+            situated along the local X-axis.
         :param angle: The angle (degrees) to fill with elements. A positive
             value will fill in the counter-clockwise direction. If fill is
-            false, angle is the angle between elements.
-        :param count: Number of elements in array. ( > 0 )
+            False, angle is the angle between elements.
+        :param count: Number of elements in array. (count >= 1)
         :param fill: Interpret the angle as total if True (default: True).
         :param rotate: Rotate every item (default: True).
         """
 
-        if count <= 0:
-            raise ValueError("No elements in array")
-
-        # First element at start angle, convert to cartesian coords
-        x = radius * math.sin(math.radians(startAngle))
-        y = radius * math.cos(math.radians(startAngle))
-
-        if rotate:
-            loc = Location(Vector(x, y), Vector(0, 0, 1), -startAngle)
-        else:
-            loc = Location(Vector(x, y))
-
-        locs = [loc]
+        if count < 1:
+            raise ValueError(f"At least 1 element required, requested {count}")
 
         # Calculate angle between elements
         if fill:
-            if angle % 360 == 0:
+            if abs(math.remainder(angle, 360)) < TOL:
                 angle = angle / count
-            elif count > 1:
+            else:
                 # Inclusive start and end
-                angle = angle / (count - 1)
+                angle = angle / (count - 1) if count > 1 else startAngle
+
+        locs = []
 
-        # Add additional elements
-        for i in range(1, count):
+        # Add elements
+        for i in range(0, count):
             phi_deg = startAngle + (angle * i)
             phi = math.radians(phi_deg)
-            x = radius * math.sin(phi)
-            y = radius * math.cos(phi)
+            x = radius * math.cos(phi)
+            y = radius * math.sin(phi)
 
             if rotate:
-                loc = Location(Vector(x, y), Vector(0, 0, 1), -phi_deg)
+                loc = Location(Vector(x, y), Vector(0, 0, 1), phi_deg)
             else:
                 loc = Location(Vector(x, y))
 

doc/examples.rst

@@ -1043,8 +1043,9 @@ A Parametric Enclosure
     lowerLid = lid.translate((0, 0, -p_lipHeight))
     cutlip = lowerLid.cut(bottom).translate((p_outerWidth + p_thickness, 0, p_thickness - p_outerHeight + p_lipHeight))
 
-    # compute centers for counterbore/countersink or counterbore
-    topOfLidCenters = cutlip.faces(">Z").workplane().rect(POSTWIDTH, POSTLENGTH, forConstruction=True).vertices()
+    # compute centers for screw holes
+    topOfLidCenters = (cutlip.faces(">Z").workplane(centerOption="CenterOfMass")
+        .rect(POSTWIDTH, POSTLENGTH, forConstruction=True).vertices())
 
     # add holes of the desired type
     if p_boreDiameter > 0 and p_boreDepth > 0:

doc/primer.rst

@@ -8,7 +8,7 @@ CadQuery Concepts
 3D BREP Topology Concepts
 ---------------------------
 Before talking about CadQuery, it makes sense to talk a little about 3D CAD topology. CadQuery is based upon the
-OpenCascade kernel, which uses Boundary Representations ( BREP ) for objects.  This just means that objects
+OpenCascade kernel, which uses Boundary Representations (BREP) for objects.  This just means that objects
 are defined by their enclosing surfaces.
 
 When working in a BREP system, these fundamental constructs exist to define a shape (working up the food chain):

tests/test_cadquery.py

@@ -1392,12 +1392,6 @@ def testRectArray(self):
     def testPolarArray(self):
         radius = 10
 
-        # Test for proper number of elements
-        s = Workplane("XY").polarArray(radius, 0, 180, 1)
-        self.assertEqual(1, s.size())
-        s = Workplane("XY").polarArray(radius, 0, 180, 6)
-        self.assertEqual(6, s.size())
-
         to_x = lambda l: l.wrapped.Transformation().TranslationPart().X()
         to_y = lambda l: l.wrapped.Transformation().TranslationPart().Y()
         to_angle = (
@@ -1408,23 +1402,27 @@ def testPolarArray(self):
 
         # Test for proper placement when fill == True
         s = Workplane("XY").polarArray(radius, 0, 180, 3)
-        self.assertAlmostEqual(0, to_y(s.objects[1]))
-        self.assertAlmostEqual(radius, to_x(s.objects[1]))
+        self.assertEqual(3, s.size())
+        self.assertAlmostEqual(radius, to_x(s.objects[0]))
+        self.assertAlmostEqual(0, to_y(s.objects[0]))
 
         # Test for proper placement when angle to fill is multiple of 360 deg
         s = Workplane("XY").polarArray(radius, 0, 360, 4)
-        self.assertAlmostEqual(0, to_y(s.objects[1]))
-        self.assertAlmostEqual(radius, to_x(s.objects[1]))
+        self.assertEqual(4, s.size())
+        self.assertAlmostEqual(radius, to_x(s.objects[0]))
+        self.assertAlmostEqual(0, to_y(s.objects[0]))
 
         # Test for proper placement when fill == False
         s = Workplane("XY").polarArray(radius, 0, 90, 3, fill=False)
-        self.assertAlmostEqual(0, to_y(s.objects[1]))
-        self.assertAlmostEqual(radius, to_x(s.objects[1]))
+        self.assertEqual(3, s.size())
+        self.assertAlmostEqual(-radius, to_x(s.objects[2]))
+        self.assertAlmostEqual(0, to_y(s.objects[2]))
 
         # Test for proper operation of startAngle
         s = Workplane("XY").polarArray(radius, 90, 180, 3)
-        self.assertAlmostEqual(radius, to_x(s.objects[0]))
-        self.assertAlmostEqual(0, to_y(s.objects[0]))
+        self.assertEqual(3, s.size())
+        self.assertAlmostEqual(0, to_x(s.objects[0]))
+        self.assertAlmostEqual(radius, to_y(s.objects[0]))
 
         # Test for local rotation
         s = Workplane().polarArray(radius, 0, 180, 3)
@@ -1435,6 +1433,21 @@ def testPolarArray(self):
         self.assertAlmostEqual(0, to_angle(s.objects[0]))
         self.assertAlmostEqual(0, to_angle(s.objects[1]))
 
+        with raises(ValueError):
+            Workplane().polarArray(radius, 20, 180, 0)
+
+        s = Workplane().polarArray(radius, 20, 0, 1)
+        assert s.size() == 1
+        assert Workplane().polarLine(radius, 20).val().positionAt(
+            1
+        ).toTuple() == approx(s.val().toTuple()[0])
+
+        s = Workplane().center(2, -4).polarArray(2, 10, 50, 3).rect(1.0, 0.5).extrude(1)
+        assert s.solids().size() == 3
+        assert s.vertices(">Y and >Z").val().toTuple() == approx(
+            (3.0334936490538906, -1.7099364905389036, 1.0)
+        )
+
     def testNestedCircle(self):
         s = (
             Workplane("XY")
@@ -2003,6 +2016,15 @@ def testPolarLines(self):
         self.assertEqual(1, r.wires().size())
         self.assertEqual(5, r.wires().edges().size())
 
+        r = Workplane().polarLineTo(1, 20)
+        assert r.val().positionAt(1).toTuple() == approx(
+            (0.9396926207859084, 0.3420201433256687, 0.0)
+        )
+        r = Workplane().move(1, 1).polarLine(1, 20)
+        assert r.val().positionAt(1).toTuple() == approx(
+            (1.9396926207859084, 1.3420201433256687, 0.0)
+        )
+
     def testLargestDimension(self):
         """
         Tests the largestDimension function when no solids are on the stack and when there are