b3dkit 0.1.0__py3-none-any.whl

b3dkit/__init__.py

@@ -0,0 +1,10 @@
+from b3dkit.basic_shapes import *
+from b3dkit.ball_socket import *
+from b3dkit.click_fit import *
+from b3dkit.dovetail import *
+from b3dkit.hexwall import *
+from b3dkit.high_top_slide_box import *
+from b3dkit.point import *
+from b3dkit.slide_box import *
+from b3dkit.twist_snap import *
+from b3dkit.antichamfer import *

b3dkit/antichamfer.py

@@ -0,0 +1,79 @@
+from build123d import (
+    Align,
+    Axis,
+    BasePartObject,
+    Box,
+    BuildPart,
+    Builder,
+    Compound,
+    Face,
+    Iterable,
+    Location,
+    Mode,
+    Part,
+    add,
+    extrude,
+    fillet,
+    flatten_sequence,
+    validate_inputs,
+)
+from math import atan, degrees, tan, radians
+from ocp_vscode import show, Camera
+
+
+def anti_chamfer(
+    face: Face | Iterable[Face],
+    length: float,
+    length2: float | None = None,
+) -> Part:
+    faces_list = flatten_sequence(face)
+    if len(faces_list) == 0:
+        raise ValueError("No faces provided to anti_chamfer")
+    if not all([isinstance(obj, Face) for obj in faces_list]):
+        raise ValueError("anti_chamfer operation takes only Faces")
+
+    context: Builder | None = Builder._get_context("chamfer")
+    validate_inputs(context, "chamfer", faces_list)
+
+    if length2 is None:
+        length2 = length
+
+    if context is not None:
+        target = context._obj
+    else:
+        target = faces_list[0].topo_parent
+    if target is None:
+        raise ValueError("face does not seem to belong to a Part")
+    # Convert BasePartObject in Part so casting into Part during construction works
+    target = Part(target.wrapped) if isinstance(target, BasePartObject) else target
+
+    if length == 0 or length2 == 0:
+        return target
+
+    with BuildPart() as new_part:
+        add(target)
+        for f in faces_list:
+            extrude(
+                f.offset(-length),
+                amount=length,
+                taper=-degrees(atan(length2 / length)),
+            )
+    if context is not None:
+        context._add_to_context(
+            Part(Compound([new_part.part]).wrapped), mode=Mode.REPLACE
+        )
+    return Part(Compound([new_part.part]).wrapped)
+
+
+if __name__ == "__main__":
+    with BuildPart(Location((33, 11, 0))) as bkt:
+        Box(
+            60,
+            10,
+            20,
+            rotation=(0, 0, 45),
+            align=(Align.CENTER, Align.CENTER, Align.MIN),
+        )
+        fillet(bkt.edges().filter_by(Axis.Z), 3)
+        anti_chamfer(bkt.faces().filter_by(Axis.Z), 1, 1)
+    show(bkt, reset_camera=Camera.KEEP)

b3dkit/ball_socket.py

@@ -0,0 +1,177 @@
+from math import sqrt
+from typing import Union
+
+from build123d import (
+    BasePartObject,
+    Box,
+    BuildPart,
+    BuildSketch,
+    Circle,
+    Cylinder,
+    Location,
+    Mode,
+    Part,
+    Plane,
+    PolarLocations,
+    RotationLike,
+    Sphere,
+    Align,
+    loft,
+    fillet,
+    Axis,
+    tuplify,
+)
+from ocp_vscode import show, Camera
+
+
+class BallMount(BasePartObject):
+
+    def __init__(
+        self,
+        ball_radius: float,
+        rotation: RotationLike = (0, 0, 0),
+        align: Union[None, Align, tuple[Align, Align, Align]] = None,
+        mode: Mode = Mode.ADD,
+    ) -> Part:
+        """
+        Creates a ball mount component for a ball-and-socket joint system.
+
+        The ball mount consists of a spherical ball attached to a tapered shaft. The shaft
+        is designed to be inserted into another part or component, while the ball mates
+        with a corresponding ball socket to create a flexible joint that allows rotation
+        in multiple axes. The shaft has a sophisticated tapered design that transitions from
+        the full ball radius at the base to approximately 36% of the ball radius at the
+        insertion point, providing strength while allowing for easy integration into
+        mounting systems.
+
+        args:
+            - ball_radius: the radius of the spherical ball in millimeters. This determines
+            the overall size of the joint system and must match the ball_radius used
+            for the corresponding ball_socket.
+            - rotation (RotationLike, optional): angles to rotate about axes. Defaults to (0, 0, 0)
+            - align (Align | tuple[Align, Align, Align] | None, optional): align MIN, CENTER,
+                or MAX of object. Defaults to (Align.CENTER, Align.CENTER, Align.CENTER)
+            - mode (Mode, optional): combine mode. Defaults to Mode.ADD
+        """
+        with BuildPart() as ballmount:
+            with BuildPart(Location((0, 0, ball_radius * 2.5))):
+                Sphere(
+                    radius=ball_radius, align=(Align.CENTER, Align.CENTER, Align.CENTER)
+                )
+            with BuildPart() as shaft:
+                with BuildSketch():
+                    Circle(
+                        radius=ball_radius,
+                        align=(Align.CENTER, Align.CENTER),
+                    )
+                with BuildSketch(Plane.XY.offset(ball_radius * 0.5)):
+                    Circle(
+                        radius=ball_radius / 2.75,
+                        align=(Align.CENTER, Align.CENTER),
+                    )
+                height_ratio = 0.25
+                with BuildSketch(Plane.XY.offset(ball_radius * (2 + height_ratio))):
+                    Circle(
+                        radius=ball_radius * (sqrt(1 - height_ratio**2)),
+                        align=(Align.CENTER, Align.CENTER),
+                    )
+                loft()
+
+        ballmount.part.label = "Ball Mount"
+        super().__init__(
+            part=ballmount.part, rotation=rotation, align=tuplify(align, 3), mode=mode
+        )
+
+
+class BallSocket(BasePartObject):
+
+    def __init__(
+        self,
+        ball_radius: float,
+        wall_thickness: float = 2,
+        tolerance: float = 0.1,
+        rotation: RotationLike = (0, 0, 0),
+        align: Union[None, Align, tuple[Align, Align, Align]] = None,
+        mode: Mode = Mode.ADD,
+    ):
+        """
+        Creates a ball socket component for a ball-and-socket joint system.
+
+        The ball socket is designed to receive and hold a ball mount, creating a flexible
+        joint that allows rotation in multiple axes. The socket features a hemispherical
+        cavity to house the ball, a cylindrical outer shell for strength, and flexible
+        cuts that allow the socket to grip the ball while still permitting smooth rotation.
+        The socket includes a flange at the top with a smooth filleted edge for comfortable
+        operation and four radial flex cuts that allow the socket walls to compress slightly
+        for ball retention while maintaining smooth rotation.
+
+        args:
+            - ball_radius: the radius of the spherical ball that will be inserted into
+            this socket, in millimeters. Must match the ball_radius of the corresponding
+            ball_mount for proper fit.
+            - wall_thickness: the thickness of the socket walls in millimeters. Affects
+            both strength and flexibility. Thicker walls provide more strength but may
+            reduce flexibility.
+            - tolerance: additional clearance around the ball in millimeters. Positive
+            values create looser fits, negative values create tighter fits.
+            - rotation (RotationLike, optional): angles to rotate about axes. Defaults to (0, 0, 0)
+            - align (Align | tuple[Align, Align, Align] | None, optional): align MIN, CENTER,
+                or MAX of object. Defaults to (Align.CENTER, Align.CENTER, Align.CENTER)
+            - mode (Mode, optional): combine mode. Defaults to Mode.ADD
+
+        """
+        with BuildPart() as socket:
+            Cylinder(
+                radius=ball_radius + wall_thickness,
+                height=ball_radius + wall_thickness * 2.5,
+                align=(Align.CENTER, Align.CENTER, Align.MIN),
+            )
+            with BuildPart(
+                Plane.XY.offset(wall_thickness), mode=Mode.SUBTRACT
+            ) as bowl_cut:
+                Sphere(
+                    radius=ball_radius + tolerance,
+                    align=(Align.CENTER, Align.CENTER, Align.MIN),
+                )
+            # Fillet the top edge if inner wires exist (after sphere subtraction they may not)
+            top_face = socket.faces().sort_by(Axis.Z)[-1]
+            if top_face.inner_wires():
+                fillet(
+                    top_face.inner_wires().edge(),
+                    min(wall_thickness * 0.4, ball_radius * 0.1),  # Limit fillet radius
+                )
+            with BuildPart(
+                Plane.XY.offset(ball_radius * 0.75 + wall_thickness), mode=Mode.SUBTRACT
+            ) as flexcuts:
+                with PolarLocations(0, 4):
+                    Box(
+                        ball_radius,
+                        (ball_radius + wall_thickness) * 2,
+                        ball_radius / 2 + wall_thickness,
+                        align=(Align.CENTER, Align.CENTER, Align.MIN),
+                    )
+                    Cylinder(
+                        radius=ball_radius / 2,
+                        height=(ball_radius + wall_thickness) * 2,
+                        align=(Align.CENTER, Align.CENTER, Align.CENTER),
+                        rotation=(90, 0, 0),
+                    )
+        socket.part.label = "Ball Socket"
+        super().__init__(
+            part=socket.part, rotation=rotation, align=tuplify(align, 3), mode=mode
+        )
+
+
+if __name__ == "__main__":
+    show(
+        BallMount(
+            24.24871131,
+        ),
+        BallSocket(
+            24.24871131,
+            # 15,
+            wall_thickness=2,
+            tolerance=-0.05,
+        ),
+        reset_camera=Camera.KEEP,
+    )

b3dkit/basic_shapes.py

@@ -0,0 +1,397 @@
+"""
+Utility functions for creating and manipulating basic 3D shapes
+and geometric calculations. These functions extend build123d's
+capabilities with shapes and operations commonly used in 3D design.
+"""
+
+from math import sqrt, radians, cos, sin, tan
+from tempfile import template
+from typing import Union
+
+from build123d import (
+    Align,
+    Axis,
+    BasePartObject,
+    BaseSketchObject,
+    Box,
+    BuildLine,
+    BuildPart,
+    BuildSketch,
+    Builder,
+    Circle,
+    Compound,
+    Cylinder,
+    GridLocations,
+    JernArc,
+    Line,
+    Location,
+    Mode,
+    Part,
+    Plane,
+    PolarLocations,
+    RadiusArc,
+    RegularPolygon,
+    RotationLike,
+    Shape,
+    Sketch,
+    Sphere,
+    add,
+    extrude,
+    fillet,
+    loft,
+    make_face,
+    scale,
+    sweep,
+    tuplify,
+    validate_inputs,
+)
+from ocp_vscode import Camera, show
+
+
+def radius_to_apothem(radius: float, side_count: int = 6) -> float:
+    """
+    calculates the apothem of a regular polygon given its circumradius
+    -------
+    arguments:
+        - radius: the circumradius of the polygon
+    """
+    return radius * cos(radians(360 / (2 * side_count)))
+
+
+def apothem_to_radius(apothem: float, side_count: int = 6) -> float:
+    """
+    calculates the circumradius of a regular polygon given its apothem
+    -------
+    arguments:
+        - apothem: the apothem of the polygon
+    """
+    return apothem / cos(radians(360 / (2 * side_count)))
+
+
+def opposite_length(angle: float, adjacent_length: float) -> float:
+    """calculate the opposite side length of a right triangle given the angle and adjacent side length
+    ----------
+    Arguments:
+        - angle: float
+            The angle in degrees.
+        - adjacent_length: float
+            The length of the adjacent side."""
+    angle_rad = radians(angle)
+    return adjacent_length * tan(angle_rad)
+
+
+def adjacent_length(angle: float, opposite_length: float) -> float:
+    """calculate the adjacent side length of a right triangle given the angle and opposite side length
+    ----------
+    Arguments:
+        - angle: float
+            The angle in degrees.
+        - opposite_length: float
+            The length of the opposite side."""
+    angle_rad = radians(angle)
+    return opposite_length / tan(angle_rad)
+
+
+def distance_to_circle_edge(radius, point, angle) -> float:
+    """
+    for a circle with the given radius, find the distance from the
+    given point to the edge of the circle in the direction determined
+    by the given angle
+    """
+    x1, y1 = point
+    theta = radians(angle)
+
+    a = 1
+    b = 2 * (x1 * cos(theta) + y1 * sin(theta))
+    c = x1**2 + y1**2 - radius**2
+
+    discriminant = b**2 - 4 * a * c
+
+    if discriminant < 0:
+        raise ValueError(f"Error: discriminant calculated as < 0 ({discriminant})")
+    t1 = (-b + sqrt(discriminant)) / (2 * a)
+    t2 = (-b - sqrt(discriminant)) / (2 * a)
+
+    t = max(t1, t2)
+
+    return t
+
+
+def circular_intersection(radius: float, coordinate: float) -> float:
+    """
+    given a positive position along the axis of a circle, find the intersection
+    along the other axis of the perimeter of the circle
+    -------
+    arguments:
+        - radius: the radius of the circle
+        - coordinate: a coordinate along one axis of the circle (must be a
+            positive value less than the radius)
+    """
+    if 0 > coordinate > radius:
+        raise ValueError("The x-coordinate cannot be greater than the radius.")
+    return sqrt(radius**2 - coordinate**2)
+
+
+class DiamondTorus(BasePartObject):
+    def __init__(
+        self,
+        major_radius: float,
+        minor_radius: float,
+        stretch: tuple = (1, 1),
+        rotation: RotationLike = (0, 0, 0),
+        align: Union[None, Align, tuple[Align, Align, Align]] = None,
+        mode: Mode = Mode.ADD,
+    ):
+        """
+        sweeps a regular diamond along a circle defined by major_radius
+        -------
+        arguments:
+            - major_radius: the radius of the circle to sweep the diamond along
+            - minor_radius: the radius of the diamond
+            - stretch: scales the diamond shape
+            - rotation: the rotation of the torus
+            - align: the alignment of the torus
+            - mode: the mode of the torus
+        """
+
+        context: BuildPart = BuildPart._get_context()
+        validate_inputs(context, self)
+
+        with BuildPart() as torus:
+            with BuildLine():
+                l1 = JernArc(
+                    start=(major_radius, 0),
+                    tangent=(0, 1),
+                    radius=major_radius,
+                    arc_size=360,
+                )
+            with BuildSketch(l1 ^ 0):
+                RegularPolygon(radius=minor_radius, side_count=4)
+                scale(by=(stretch[0], stretch[1], 1))
+            sweep()
+        super().__init__(
+            part=torus.part, rotation=rotation, align=tuplify(align, 3), mode=mode
+        )
+
+
+class RoundedCylinder(BasePartObject):
+    def __init__(
+        self,
+        radius: float,
+        height: float,
+        rotation: RotationLike = (0, 0, 0),
+        align: Union[None, Align, tuple[Align, Align, Align]] = None,
+        mode: Mode = Mode.ADD,
+    ):
+        """
+        sweeps a regular diamond along a circle defined by major_radius
+        -------
+        arguments:
+            - radius: the radius of the cylinder
+            - height: the height of the cylinder
+            - rotation: the rotation of the cylinder
+            - align: the alignment of the cylinder
+            - mode: the mode of the cylinder
+        """
+
+        context: BuildPart = BuildPart._get_context()
+        validate_inputs(context, self)
+
+        if height <= radius * 2:
+            raise ValueError("height must be greater than radius * 2")
+        with BuildPart() as cylinder:
+            Cylinder(radius=radius, height=height, align=align)
+            fillet(
+                cylinder.faces().sort_by(Axis.Z)[-1].edges()
+                + cylinder.faces().sort_by(Axis.Z)[0].edges(),
+                radius=radius,
+            )
+        super().__init__(
+            part=cylinder.part, rotation=rotation, align=tuplify(align, 3), mode=mode
+        )
+
+
+class PolygonalCylinder(BasePartObject):
+
+    def __init__(
+        self,
+        radius: float,
+        height: float,
+        side_count: int = 6,
+        stretch: tuple = (1, 1, 1),
+        rotation: RotationLike = (0, 0, 0),
+        align: Union[None, Align, tuple[Align, Align, Align]] = None,
+        mode: Mode = Mode.ADD,
+    ):
+        """
+        creates an extruded polygon that behaves like a cylinder
+        -------
+        arguments:
+            - radius: the radius of the cylinder
+            - height: the height of the cylinder
+            - side_count: the number of sides of the polygonal base (default is 6)
+            - stretch: scales the base polygon
+            - rotation: the rotation of the cylinder
+            - align: the alignment of the cylinder
+            - mode: the mode to use when
+        """
+        context: BuildPart = BuildPart._get_context()
+        validate_inputs(context, self)
+
+        with BuildPart() as tube:
+            with BuildSketch():
+                RegularPolygon(
+                    radius=radius, side_count=side_count, align=tuplify(align, 2)
+                )
+            extrude(amount=height * stretch[2])
+        super().__init__(
+            part=tube.part, rotation=rotation, align=tuplify(align, 3), mode=mode
+        )
+
+
+class DiamondCylinder(PolygonalCylinder):
+
+    def __init__(
+        self,
+        radius: float,
+        height: float,
+        stretch: tuple = (1, 1, 1),
+        rotation: RotationLike = (0, 0, 0),
+        align: Union[None, Align, tuple[Align, Align, Align]] = None,
+        mode: Mode = Mode.ADD,
+    ):
+        """
+        creates an extruded diamond that behaves like a cylinder
+        -------
+        arguments:
+            - radius: the radius of the cylinder
+            - height: the height of the cylinder
+            - rotation: the rotation of the cylinder
+            - align: the alignment of the cylinder (default
+                    is (Align.CENTER, Align.CENTER, Align.CENTER) )
+            - mode: the mode to use when adding the part
+        """
+        super().__init__(
+            radius=radius,
+            height=height,
+            side_count=4,
+            stretch=stretch,
+            rotation=rotation,
+            align=align,
+            mode=mode,
+        )
+
+
+class Teardrop(BaseSketchObject):
+
+    def __init__(
+        self,
+        radius: float,
+        peak_distance: float,
+        rotation: RotationLike = (0, 0),
+        align: Union[None, Align, tuple[Align, Align]] = None,
+        mode: Mode = Mode.ADD,
+    ):
+        """
+        Create a teardrop shape sketch;
+        this can be useful when creating holes along the Z axis
+        to compensate for overhang issues with FDM printers.
+        ----------
+        Arguments:
+            - radius: float
+                The radius of the teardrop.
+            - peak_distance: float
+                The distance from the center of the teardrop circle to the peak of the
+                teardrop shape.
+            - align: tuple
+                The alignment of the teardrop. Note that the Y alignment is to the center of the cylinder, ignoring the peak distance
+            - mode: Mode
+                The mode of the teardrop.
+        """
+        context: BuildSketch = BuildSketch._get_context()
+        validate_inputs(context, self)
+
+        x = radius * sqrt(1 - (radius**2 / peak_distance**2))
+        y = radius**2 / peak_distance
+        with BuildSketch() as teardrop:
+            if peak_distance == radius:
+                Circle(radius)
+            else:
+                with BuildLine() as outline:
+                    Line((-x, -y), (0, -peak_distance))
+                    Line((0, -peak_distance), (x, -y))
+                    RadiusArc((x, -y), (-x, -y), radius, short_sagitta=False)
+                make_face()
+        super().__init__(
+            obj=teardrop.sketch,
+            rotation=rotation,
+            align=tuplify(align, 2),
+            mode=mode,
+        )
+
+
+class TeardropCylinder(BasePartObject):
+
+    def __init__(
+        self,
+        radius: float,
+        height: float,
+        peak_distance: float,
+        rotation: RotationLike = (0, 0, 0),
+        align: Union[None, Align, tuple[Align, Align, Align]] = None,
+        mode: Mode = Mode.ADD,
+    ):
+        """
+        Create a cylinder with a teardrop shape;
+        this can be useful when creating holes along the Z axis
+        to compensate for overhang issues with FDM printers.
+        ----------
+        Arguments:
+            - radius: float
+                The radius of the cylinder.
+            - height: float
+                The height of the cylinder.
+            - peak_distance: float
+                The distance from the center of the cylinder to the peak of the
+                teardrop shape.
+            - rotation: tuple
+                The rotation of the cylinder.
+            - align: tuple
+                The alignment of the cylinder.
+            - mode: Mode
+                The mode of the cylinder.
+        """
+        context: BuildPart = BuildPart._get_context()
+        validate_inputs(context, self)
+
+        with BuildPart() as cylinder:
+            with BuildSketch():
+                Teardrop(radius, peak_distance, align=tuplify(align, 2))
+            extrude(amount=height)
+        super().__init__(
+            part=cylinder.part,
+            rotation=rotation,
+            align=tuplify(align, 3),
+            mode=mode,
+        )
+
+
+if __name__ == "__main__":
+
+    show(
+        DiamondTorus(
+            50,
+            2,
+        ),
+        reset_camera=Camera.KEEP,
+    )
+    show(
+        DiamondCylinder(
+            radius=50,
+            height=200,
+            stretch=(1, 1, 1),
+            rotation=(0, 0, 0),
+            align=(Align.MIN, Align.MIN, Align.CENTER),
+        ),
+        reset_camera=Camera.KEEP,
+    )