b3dkit 0.1.3__tar.gz → 0.1.5__tar.gz

{b3dkit-0.1.3 → b3dkit-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: b3dkit
-Version: 0.1.3
+Version: 0.1.5
 Summary: build123d libraries and utilities
 Project-URL: Homepage, https://github.com/x0pherl/b3dkit
 Project-URL: Issues, https://github.com/x0pherl/b3dkit/issues

{b3dkit-0.1.3 → b3dkit-0.1.5}/docs/point.md

@@ -41,6 +41,14 @@ p[1] # returns the y coordinate (3)
     Point(0,10).distance_to(Point(10,10)) # returns 10.0
     ```
 
+#### axial)distance_to
+- `axial_distance_to(point: Point, axis: Axis) -> float`
+  - Identifies the distance along a single Axis to a second point from the current point.
+    ```
+    Point(0,10).axial_distance_to(Point(10,-10), Axis.X) # returns 10.0
+    Point(0,10).axial_distance_to(Point(10,-10), Axis.Y) # returns 20.0
+    ```
+
 #### related_point
 - `related_point(angle: float, distance: float) -> Point`
   - Identifies a second point at a specified angle and distance from the current point.

{b3dkit-0.1.3 → b3dkit-0.1.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "b3dkit"
-version = "0.1.3"
+version = "0.1.5"
 authors = [
   { name="x0pherl"},
 ]

{b3dkit-0.1.3 → b3dkit-0.1.5}/src/b3dkit/hexwall.py

@@ -220,11 +220,10 @@ class HexCylindrical(BasePartObject):
 
 
 if __name__ == "__main__":
-    # cone = Cone(100, 50, 100, align=(Align.CENTER, Align.CENTER, Align.MIN))
-    # cylinder = Cylinder(100, 100)
+    cone = Cone(100, 50, 100, align=(Align.CENTER, Align.CENTER, Align.MIN))
+    cylinder = Cylinder(100, 100)
 
-    # part = cone
-    # hexsample = HexCylindrical(part, 1, 2, 20, 10, 2, 20)
+    part = cone
+    hexsample = HexCylindrical(part, 1, 2, 20, 10, 2, 20)
 
-    # show(part, hexsample)
-    show(HexWall(100, 200, 3, 4, 1))
+    show(part, hexsample)

{b3dkit-0.1.3 → b3dkit-0.1.5}/src/b3dkit/point.py

@@ -91,6 +91,22 @@ class Point:
             - float: The Euclidean distance between the two points"""
         return ((self.x - point.x) ** 2 + (self.y - point.y) ** 2) ** 0.5
 
+    def axial_distance_to(self, point: "Point", axis: Axis) -> float:
+        """from the point, identify the distance to a second point
+        ----------
+        Arguments:
+            - point: Point
+                The target point to calculate distance to
+            - axis: Axis
+                The Axis along which to measure the difference
+        Returns:
+            - float: The distance along the passed axis between the two points"""
+        return (
+            Point(self.X, 0).distance_to(Point(point.X, 0))
+            if axis == Axis.X
+            else Point(0, self.y).distance_to(Point(0, point.Y))
+        )
+
     def related_point(self, angle: float, distance: float) -> "Point":
         """from the point, identify a second point at a specified angle and distance
         ----------

{b3dkit-0.1.3 → b3dkit-0.1.5}/src/b3dkit/slide_box.py

@@ -1,3 +1,5 @@
+from math import radians, tan
+
 from build123d import (
     Align,
     BuildPart,
@@ -25,6 +27,45 @@ from build123d import (
 from ocp_vscode import show, Camera
 from b3dkit import Divot
 
+#: the draft applied to the sliding faces; the divot placement below depends on
+#: this matching the taper passed to extrude()
+SLIDER_TAPER_ANGLE = 22.5
+
+
+def _divot_spacing(
+    sketch_width: float,
+    wall_thickness: float,
+    tolerance: float,
+    x_straighten_distance: float,
+    divot_radius: float,
+) -> float:
+    """
+    Determine the x distance between the pair of divots on a slider template.
+
+    The divots would naturally sit one wall thickness inboard of the sketch, but
+    the sliding faces are tapered, so the widest part of a divot -- the top of its
+    extended base, one radius above the underside of the rail -- can graze the
+    tapered face. A grazing intersection leaves needle-thin slivers behind the
+    boolean, so pull the pair far enough inboard that a divot only ever meets the
+    flat underside.
+    """
+    half_width = sketch_width / 2
+    # depth below the top of the template at the widest point of the divot
+    widest_depth = max(wall_thickness - divot_radius, 0)
+    tapered_face = (
+        half_width
+        - wall_thickness
+        - abs(tolerance)
+        + widest_depth * tan(radians(SLIDER_TAPER_ANGLE))
+    )
+    return (
+        min(
+            half_width - x_straighten_distance - wall_thickness,
+            tapered_face - divot_radius - divot_radius / 5,
+        )
+        * 2
+    )
+
 
 def slider_template(
     sketch: Sketch,
@@ -41,7 +82,11 @@ def slider_template(
     with BuildPart() as slider_part:
         with BuildSketch() as top_sketch:
             offset(sketch, amount=-abs(tolerance) - (abs(wall_thickness)))
-        extrude(top_sketch.sketch, amount=-wall_thickness - abs(tolerance), taper=-22.5)
+        extrude(
+            top_sketch.sketch,
+            amount=-wall_thickness - abs(tolerance),
+            taper=-SLIDER_TAPER_ANGLE,
+        )
         cross_section = section(
             obj=slider_part.part,
             section_by=Plane.XZ.offset(
@@ -56,21 +101,26 @@ def slider_template(
             )
         )
         if divot_radius > 0:
+            # a divot wider than half the wall would overhang the open front of
+            # the template; keep it far enough back to meet only the underside
+            divot_y = max(
+                sketch.bounding_box().min.Y + wall_thickness / 2,
+                slider_part.part.bounding_box().min.Y
+                + divot_radius
+                + divot_radius / 5,
+            )
             with BuildPart(
-                Location(
-                    (
-                        0,
-                        sketch.bounding_box().min.Y + wall_thickness / 2,
-                        -wall_thickness,
-                    ),
-                    (180, 0, 0),
-                ),
+                Location((0, divot_y, -wall_thickness), (180, 0, 0)),
                 mode=Mode.ADD,
             ):
                 with GridLocations(
-                    sketch.bounding_box().size.X
-                    - x_straighten_distance * 2
-                    - wall_thickness * 2,
+                    _divot_spacing(
+                        sketch.bounding_box().size.X,
+                        wall_thickness,
+                        tolerance,
+                        x_straighten_distance,
+                        divot_radius,
+                    ),
                     0,
                     2,
                     1,

{b3dkit-0.1.3 → b3dkit-0.1.5}/tests/test_point.py

@@ -41,6 +41,11 @@ class TestPoint:
         angle = p1.angle_to(p2)
         assert angle == pytest.approx(45.0)
 
+    def test_axial_distance_to(self):
+        assert Point(20, 2).axial_distance_to(Point(-20, 2), Axis.X) == pytest.approx(
+            40.0
+        )
+
     def test_distance_to(self):
         p1 = Point(0, 0)
         p2 = Point(3, 4)

b3dkit-0.1.5/tests/test_slide_box.py

@@ -0,0 +1,85 @@
+from dataclasses import dataclass, field
+from enum import Enum, auto
+from importlib.machinery import SourceFileLoader
+from importlib.util import module_from_spec, spec_from_loader
+import pytest
+from unittest.mock import patch
+from pathlib import Path
+
+from build123d import Axis, BuildPart, Box, Align, Plane, fillet, section
+
+from b3dkit.slide_box import slide_box, slider_template
+
+
+class TestSlideBox:
+    def test_slide_box(self):
+        with BuildPart() as base_box:
+            Box(20, 44, 14, align=(Align.CENTER, Align.CENTER, Align.MIN))
+            fillet(base_box.part.edges().filter_by(Axis.Z), radius=1.5)
+
+        sb = slide_box(
+            base_box.part, wall_thickness=2, thumb_radius=3.5, divot_radius=0.5
+        )
+        assert sb.children[0].is_valid
+        assert sb.children[1].is_valid
+
+    def test_direct_run(self):
+
+        with (
+            patch("build123d.export_stl"),
+            patch("pathlib.Path.mkdir"),
+            patch("pathlib.Path.exists"),
+            patch("pathlib.Path.is_dir"),
+            patch("ocp_vscode.show"),
+            patch("ocp_vscode.save_screenshot"),
+        ):
+            loader = SourceFileLoader("__main__", "src/b3dkit/slide_box.py")
+            loader.exec_module(module_from_spec(spec_from_loader(loader.name, loader)))
+
+
+class TestSliderDivots:
+    """
+    The divots sit against the tapered sliding faces of the template. Placing one
+    so that it merely grazes a tapered face leaves needle-thin slivers behind the
+    boolean, which show up as a nick in the rail the lid slides through.
+
+    A pair of divots must therefore contribute exactly two solids, and each must
+    be a real divot rather than a sliver -- the two failure modes are a doubled
+    solid count and a solid orders of magnitude too small.
+    """
+
+    @pytest.fixture(scope="class")
+    def sketch(self):
+        with BuildPart() as blank:
+            Box(60, 100, 20, align=(Align.CENTER, Align.CENTER, Align.MIN))
+            fillet(blank.part.edges().filter_by(Axis.Z), radius=1.5)
+        return section(obj=blank.part, section_by=Plane.XY.offset(20))
+
+    @staticmethod
+    def _divot_solids(sketch, wall, radius, tolerance):
+        """the geometry the divots add to an otherwise identical template"""
+        with_divots = slider_template(
+            sketch, wall, tolerance=tolerance, divot_radius=radius, cut_template=True
+        )
+        without_divots = slider_template(
+            sketch, wall, tolerance=tolerance, divot_radius=0, cut_template=True
+        )
+        return (with_divots - without_divots).solids()
+
+    @pytest.mark.parametrize("wall", [2.0, 3.0, 4.0])
+    @pytest.mark.parametrize("radius", [0.5, 0.75, 0.9, 1.0, 1.25])
+    def test_divots_contribute_exactly_two_solids(self, sketch, wall, radius):
+        # the sweep matters -- the tangency only bites on some wall/radius
+        # combinations, so any single pairing passes on its own
+        solids = self._divot_solids(sketch, wall, radius, tolerance=0.2)
+
+        assert len(solids) == 2
+        assert min(s.volume for s in solids) > radius**3 * 1e-2
+
+    def test_wide_divot_clears_the_open_front(self, sketch):
+        # a divot wider than half the wall used to overhang the front face of
+        # the template, slivering against it the same way the taper did
+        solids = self._divot_solids(sketch, wall=1.5, radius=1.25, tolerance=0.3)
+
+        assert len(solids) == 2
+        assert min(s.volume for s in solids) > 1.25**3 * 1e-2

b3dkit-0.1.3/tests/test_slide_box.py

@@ -1,37 +0,0 @@
-from dataclasses import dataclass, field
-from enum import Enum, auto
-from importlib.machinery import SourceFileLoader
-from importlib.util import module_from_spec, spec_from_loader
-import pytest
-from unittest.mock import patch
-from pathlib import Path
-
-from build123d import Axis, BuildPart, Box, Align, fillet
-
-from b3dkit.slide_box import slide_box
-
-
-class TestSlideBox:
-    def test_slide_box(self):
-        with BuildPart() as base_box:
-            Box(20, 44, 14, align=(Align.CENTER, Align.CENTER, Align.MIN))
-            fillet(base_box.part.edges().filter_by(Axis.Z), radius=1.5)
-
-        sb = slide_box(
-            base_box.part, wall_thickness=2, thumb_radius=3.5, divot_radius=0.5
-        )
-        assert sb.children[0].is_valid
-        assert sb.children[1].is_valid
-
-    def test_direct_run(self):
-
-        with (
-            patch("build123d.export_stl"),
-            patch("pathlib.Path.mkdir"),
-            patch("pathlib.Path.exists"),
-            patch("pathlib.Path.is_dir"),
-            patch("ocp_vscode.show"),
-            patch("ocp_vscode.save_screenshot"),
-        ):
-            loader = SourceFileLoader("__main__", "src/b3dkit/slide_box.py")
-            loader.exec_module(module_from_spec(spec_from_loader(loader.name, loader)))