b3dkit 0.1.0__py3-none-any.whl

b3dkit/point.py

@@ -0,0 +1,196 @@
+"""
+A minimal abstraction for a 2D point, allowing the x,y values to be interpreted from a tuple.
+Also has some utility functions for calculating various useful properties of points.
+"""
+
+from dataclasses import dataclass
+from math import atan2, cos, degrees, radians, sin, tan
+from typing import Union, Tuple
+from build123d import Axis
+
+
+@dataclass
+class Point:
+    """
+    A 2D point with x and y coordinates.
+    """
+
+    x: float
+    y: float
+
+    @property
+    def X(self):
+        """the x coordinate of the point
+        ----------
+        Returns:
+            - float: The x coordinate of the point"""
+        return self.x
+
+    @property
+    def Y(self):
+        """the y coordinate of the point
+        ----------
+        Returns:
+            - float: The y coordinate of the point"""
+        return self.y
+
+    def __init__(self, x: Union[float, list[float, float]] = None, y: float = None):
+        """initialize the point with x and y coordinates passed as a tuple or individual values
+        ----------
+        Arguments:
+            - x: Union[float, list[float, float]]
+                The x coordinate or a list containing [x, y] coordinates
+            - y: float
+                The y coordinate (ignored if x is a list)"""
+        if isinstance(x, list) and len(x) >= 2:
+            self.x, self.y = x
+        else:
+            self.x = x
+            self.y = y
+
+    def __iter__(self):
+        """iterate through the x and y coordinates of the point
+        ----------
+        Yields:
+            - float: The x coordinate, then the y coordinate"""
+        yield self.x
+        yield self.y
+
+    def __getitem__(self, index):
+        """return the x or y coordinate of the point
+        ----------
+        Arguments:
+            - index: int
+                0 for x coordinate, 1 for y coordinate
+        Returns:
+            - float: The requested coordinate"""
+        if index == 0:
+            return self.x
+        elif index == 1:
+            return self.y
+        else:
+            raise IndexError("Index out of range")
+
+    def angle_to(self, point: "Point") -> float:
+        """from the point, identify the angle to a second point
+        ----------
+        Arguments:
+            - point: Point
+                The target point to calculate angle to
+        Returns:
+            - float: The angle in degrees (0-360) from this point to the target point"""
+        return degrees(atan2(point.y - self.y, point.x - self.x)) % 360
+
+    def distance_to(self, point: "Point") -> float:
+        """from the point, identify the distance to a second point
+        ----------
+        Arguments:
+            - point: Point
+                The target point to calculate distance to
+        Returns:
+            - float: The Euclidean distance between the two points"""
+        return ((self.x - point.x) ** 2 + (self.y - point.y) ** 2) ** 0.5
+
+    def related_point(self, angle: float, distance: float) -> "Point":
+        """from the point, identify a second point at a specified angle and distance
+        ----------
+        Arguments:
+            - angle: float
+                The angle in degrees from this point (0° = positive x direction)
+            - distance: float
+                The distance from this point to the new point
+        Returns:
+            - Point: A new point at the specified angle and distance"""
+        angle_rad = radians(angle)
+        return Point(
+            self.x + distance * cos(angle_rad),
+            self.y + distance * sin(angle_rad),
+        )
+
+    def related_point_by_axis(
+        self, angle: float, axis_distance: float, axis: Axis = Axis.X
+    ) -> "Point":
+        """from the point, identify a second point at a specified angle with a given distance along x or y axis
+        ----------
+        Arguments:
+            - angle: float
+                The angle in degrees from this point (0° = positive x direction)
+            - axis_distance: float
+                The distance to travel along the specified axis
+            - axis: Axis
+                Either Axis.X or Axis.Y - the axis along which to measure the distance
+        Returns:
+            - Point: A new point at the specified angle with the given axis distance"""
+        angle_rad = radians(angle)
+
+        if axis == Axis.X:
+            # If we want to move axis_distance along x-axis at the given angle
+            # x_distance = axis_distance, so we need to find the corresponding y_distance
+            # cos(angle) = x_distance / hypotenuse, so hypotenuse = x_distance / cos(angle)
+            if abs(cos(angle_rad)) < 1e-10:
+                raise ValueError(
+                    f"Cannot move along x-axis at angle {angle} degrees (cos ≈ 0)"
+                )
+            hypotenuse = abs(axis_distance / cos(angle_rad))
+            return Point(
+                self.x + axis_distance,
+                self.y
+                + hypotenuse * sin(angle_rad) * (1 if cos(angle_rad) > 0 else -1),
+            )
+        elif axis == Axis.Y:
+            # If we want to move axis_distance along y-axis at the given angle
+            # y_distance = axis_distance, so we need to find the corresponding x_distance
+            # sin(angle) = y_distance / hypotenuse, so hypotenuse = y_distance / sin(angle)
+            if abs(sin(angle_rad)) < 1e-10:
+                raise ValueError(
+                    f"Cannot move along y-axis at angle {angle} degrees (sin ≈ 0)"
+                )
+            hypotenuse = abs(axis_distance / sin(angle_rad))
+            return Point(
+                self.x
+                + hypotenuse * cos(angle_rad) * (1 if sin(angle_rad) > 0 else -1),
+                self.y + axis_distance,
+            )
+        else:
+            raise ValueError("axis must be Axis.X or Axis.Y")
+
+
+def midpoint(point1: Point, point2: Point) -> Point:
+    """find the midpoint between two points
+    ----------
+    Arguments:
+        - point1: Point
+            The first point.
+        - point2: Point
+            The second point."""
+    midpoint = Point((point1.x + point2.x) / 2, (point1.y + point2.y) / 2)
+    return midpoint
+
+
+def shifted_midpoint(point1: Point, point2: Point, shift: float) -> Point:
+    """find the midpoint between two points, with an allowance to shift the
+    midpoint towards point2
+    ----------
+    Arguments:
+        - point1: Point
+            The first point.
+        - point2: Point
+            The second point.
+        - shift: float
+            The distance to shift the midpoint towards point2"""
+    mid_x = (point1.x + point2.x) / 2
+    mid_y = (point1.y + point2.y) / 2
+
+    direction_x = point2.x - point1.x
+    direction_y = point2.y - point1.y
+
+    # Normalize the direction vector
+    length = (direction_x**2 + direction_y**2) ** 0.5
+    direction_x /= length
+    direction_y /= length
+
+    # Shift the midpoint towards point2 by the specified amount
+    shifted_mid_x = mid_x + direction_x * shift
+    shifted_mid_y = mid_y + direction_y * shift
+
+    return Point(shifted_mid_x, shifted_mid_y)

b3dkit/slide_box.py

@@ -0,0 +1,210 @@
+from build123d import (
+    Align,
+    BuildPart,
+    Box,
+    add,
+    Color,
+    fillet,
+    offset,
+    Mode,
+    Plane,
+    Part,
+    Location,
+    BuildSketch,
+    extrude,
+    Axis,
+    Cylinder,
+    pack,
+    Compound,
+    section,
+    GridLocations,
+    Sketch,
+)
+
+
+from ocp_vscode import show, Camera
+from b3dkit import Divot
+
+
+def slider_template(
+    sketch: Sketch,
+    wall_thickness: float = 2,
+    tolerance=0.2,
+    top_offset: float = 0,
+    x_straighten_distance: float = 0,
+    divot_radius=0,
+    cut_template=True,
+) -> Part:
+    """
+    Create a slider part based on a sketch.
+    """
+    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)
+        cross_section = section(
+            obj=slider_part.part,
+            section_by=Plane.XZ.offset(
+                slider_part.part.bounding_box().max.Y
+                - x_straighten_distance
+                - wall_thickness
+            ),
+        )
+        add(
+            extrude(
+                cross_section, amount=x_straighten_distance * 2 + wall_thickness * 2
+            )
+        )
+        if divot_radius > 0:
+            with BuildPart(
+                Location(
+                    (
+                        0,
+                        sketch.bounding_box().min.Y + wall_thickness / 2,
+                        -wall_thickness,
+                    ),
+                    (180, 0, 0),
+                ),
+                mode=Mode.ADD,
+            ):
+                with GridLocations(
+                    sketch.bounding_box().size.X
+                    - x_straighten_distance * 2
+                    - wall_thickness * 2,
+                    0,
+                    2,
+                    1,
+                ):
+                    Divot(
+                        radius=divot_radius,
+                        positive=(not cut_template),
+                        extend_base=True,
+                    )
+
+    return slider_part.part
+
+
+def slide_lid(
+    part: Part,
+    wall_thickness: float = 2,
+    tolerance=0.15,
+    top_offset: float = 0,
+    thumb_radius: float = 5,
+    x_straighten_distance: float = 0,
+    divot_radius=0,
+) -> Part:
+
+    cross_section = section(
+        obj=part, section_by=Plane.XY.offset(part.bounding_box().max.Z - top_offset)
+    )
+    lid_template = slider_template(
+        cross_section,
+        wall_thickness,
+        tolerance=tolerance,
+        top_offset=top_offset,
+        x_straighten_distance=x_straighten_distance,
+        divot_radius=divot_radius,
+        cut_template=False,
+    )
+
+    extrusion_height = part.bounding_box().max.Z - wall_thickness
+    with BuildPart() as lid_part:
+        add(part)
+        add(
+            lid_template.move(Location((0, 0, extrusion_height + wall_thickness))),
+            mode=Mode.INTERSECT,
+        )
+
+        if thumb_radius > 0:
+            with BuildPart(
+                Location(
+                    (
+                        0,
+                        lid_part.part.bounding_box().min.Y
+                        + thumb_radius
+                        + wall_thickness,
+                        part.bounding_box().max.Z + wall_thickness / 4,
+                    )
+                ),
+                mode=Mode.SUBTRACT,
+            ):
+                Cylinder(
+                    radius=thumb_radius,
+                    arc_size=180,
+                    height=wall_thickness,
+                    rotation=(15, 0, 0),
+                )
+
+    lid_part.part.label = "lid"
+
+    return lid_part.part.move(Location((0, 0, 0), (0, 180, 0)))
+
+
+# todo - handle top_offset for big fat slinding bits
+# right now the logic works for the gobox because the top_offset (the height downward to get the fat bit)
+# is equal to the thinness of the top plane because it's a nice even chamfer, but I can't assume that generically
+def slide_box(
+    part: Part,
+    wall_thickness: float = 2,
+    top_offset: float = 0,
+    thumb_radius: float = 5,
+    x_straighten_distance: float = 0,
+    slide_tolerance=0.15,
+    divot_radius: float = 0,
+) -> Compound:
+
+    cross_section = section(
+        obj=part, section_by=Plane.XY.offset(part.bounding_box().max.Z - top_offset)
+    )
+    lid_cut_template = slider_template(
+        cross_section,
+        wall_thickness,
+        tolerance=0,
+        top_offset=top_offset,
+        x_straighten_distance=x_straighten_distance,
+        divot_radius=divot_radius,
+    )
+
+    extrusion_height = part.bounding_box().max.Z - wall_thickness
+    with BuildPart() as box_part:
+        add(part)
+        extrude(
+            offset(
+                box_part.faces().sort_by(Axis.Z)[-1],
+                amount=-abs(slide_tolerance) - abs(wall_thickness - top_offset),
+            ),
+            amount=-extrusion_height,
+            mode=Mode.SUBTRACT,
+        )
+        add(
+            lid_cut_template.move(Location((0, 0, extrusion_height + wall_thickness))),
+            mode=Mode.SUBTRACT,
+        )
+    box_part.part.label = "box"
+
+    lid = slide_lid(
+        part,
+        wall_thickness=wall_thickness,
+        tolerance=slide_tolerance,
+        top_offset=top_offset,
+        thumb_radius=thumb_radius,
+        x_straighten_distance=x_straighten_distance,
+        divot_radius=divot_radius,
+    )
+    lid.label = "lid"
+    lid.color = Color("red")
+
+    box_assembly = Compound(
+        label="slide box", children=pack([box_part.part, lid], padding=5, align_z=True)
+    )
+
+    return box_assembly
+
+
+if __name__ == "__main__":
+    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)
+    show(sb, reset_camera=Camera.KEEP)

b3dkit/twist_snap.py

@@ -0,0 +1,302 @@
+"""
+
+Twist & Snap Connector
+
+name: twist_snap.py
+by:   x0pherl
+date: May 19 2024
+
+desc: A parameterized twist and snap fitting.
+
+license:
+
+license:
+
+    Copyright 2024 x0pherl
+
+    Use of this source code is governed by an MIT-style
+    license that can be found in the LICENSE file or at
+    https://opensource.org/licenses/MIT.
+
+"""
+
+from dataclasses import dataclass
+from enum import Enum, Flag, auto
+from math import radians, cos, sin
+from typing import Union
+
+from build123d import (
+    Align,
+    Axis,
+    BasePartObject,
+    BuildPart,
+    BuildSketch,
+    Compound,
+    Cylinder,
+    GeomType,
+    Location,
+    Locations,
+    Mode,
+    PolarLocations,
+    Polygon,
+    RotationLike,
+    SortBy,
+    add,
+    fillet,
+    sweep,
+    tuplify,
+)
+
+from ocp_vscode import Camera, show
+
+
+class TwistSnapConnector(BasePartObject):
+
+    def __init__(
+        self,
+        connector_radius: float = 4.5,
+        tolerance: float = 0.12,
+        arc_percentage: float = 10,
+        snapfit_count: int = 4,
+        snapfit_radius_extension: float = 2 * 2 / 3,
+        wall_width: float = 2,
+        wall_depth: float = 2,
+        snapfit_height: float = 2,
+        rotation: RotationLike = (0, 0, 0),
+        align: Union[None, Align, tuple[Align, Align, Align]] = None,
+        mode: Mode = Mode.ADD,
+    ):
+        """
+        Returns a connector that locks into a socket with a twist.
+        ----------
+        Arguments:
+            - connector_radius: the base radius of the connector mechanism
+            - tolerance: the spacing between the connector and the socket
+            - arc_percentage: the percentage of the arc that the snapfit will cover
+            - snapfit_count: how many snapfit mechanisms to add
+            - snapfit_radius_extension: how far beyond the connector the snapfit extends
+            - wall_width: the thickness of the wall mechanism
+            - wall_depth: the depth of the wall mechanism
+            - snapfit_height: the height of the snapfit mechanism
+            - 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 twistbase:
+            Cylinder(
+                radius=connector_radius,
+                height=wall_depth * 2,
+                align=(Align.CENTER, Align.CENTER, Align.MIN),
+            )
+            path = (
+                twistbase.edges()
+                .filter_by(GeomType.CIRCLE)
+                .sort_by(Axis.Z, reverse=True)
+                .sort_by(SortBy.RADIUS)[-1]
+            )  # top edge of cylinder
+            path = path.trim(
+                arc_percentage / -200,
+                arc_percentage / 200,
+            )
+            with BuildPart(mode=Mode.PRIVATE) as snapfit:
+                path = path.rotate(Axis.Z, 90)
+                with BuildSketch(path ^ 0):
+                    Polygon(
+                        *[
+                            (0, 0),
+                            (snapfit_radius_extension, 0),
+                            (
+                                snapfit_radius_extension,
+                                snapfit_height,
+                            ),
+                            (0, snapfit_height / 2),
+                        ],
+                        align=(Align.MAX, Align.MIN),
+                    )
+                sweep(path=path)
+                with Locations(
+                    snapfit.part.center() + (0, snapfit_radius_extension / 2, 0)
+                ):
+                    Cylinder(
+                        radius=snapfit_radius_extension / 2,
+                        height=snapfit_height * 3,
+                        mode=Mode.SUBTRACT,
+                    )
+                fillet(
+                    snapfit.faces().sort_by(Axis.Y)[-2:].edges().filter_by(Axis.Z),
+                    min(
+                        snapfit_radius_extension / 8,
+                        snapfit.part.max_fillet(
+                            snapfit.faces()
+                            .sort_by(Axis.Y)[-2:]
+                            .edges()
+                            .filter_by(Axis.Z),
+                            max_iterations=40,
+                        ),
+                    ),
+                )
+
+            with PolarLocations(0, snapfit_count):
+                add(snapfit.part)
+        super().__init__(
+            twistbase.part, rotation=rotation, align=tuplify(align, 3), mode=mode
+        )
+
+
+class TwistSnapSocket(BasePartObject):
+
+    def __init__(
+        self,
+        connector_radius: float = 4.5,
+        tolerance: float = 0.12,
+        arc_percentage: float = 10,
+        snapfit_count: int = 4,
+        snapfit_radius_extension: float = 2 * 2 / 3,
+        wall_width: float = 2,
+        wall_depth: float = 2,
+        snapfit_height: float = 2,
+        rotation: RotationLike = (0, 0, 0),
+        align: Union[None, Align, tuple[Align, Align, Align]] = None,
+        mode: Mode = Mode.ADD,
+    ) -> Compound:
+        """
+        Returns a socket that locks into a connector with a twist.
+        ----------
+        Arguments:
+            - connector_radius: the base radius of the connector mechanism
+            - tolerance: the spacing between the connector and the socket
+            - arc_percentage: the percentage of the arc that the snapfit will cover
+            - snapfit_count: how many snapfit mechanisms to add
+            - snapfit_radius_extension: how far beyond the connector the snapfit extends
+            - wall_width: the thickness of the wall mechanism
+            - wall_depth: the depth of the wall mechanism
+            - snapfit_height: the height of the snapfit mechanism
+            - 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
+        """
+        outer_socket_radius = connector_radius + wall_width * 4 / 3
+        with BuildPart() as socket_fitting:
+            Cylinder(
+                radius=outer_socket_radius,
+                height=wall_depth,
+                align=(Align.CENTER, Align.CENTER, Align.MIN),
+            )
+            with BuildPart(socket_fitting.faces().sort_by(Axis.Z)[-1]) as snap_socket:
+                Cylinder(
+                    radius=outer_socket_radius,
+                    height=wall_depth * 2,
+                    align=(Align.CENTER, Align.CENTER, Align.MIN),
+                )
+                Cylinder(
+                    radius=connector_radius + tolerance,
+                    height=wall_depth * 2,
+                    align=(Align.CENTER, Align.CENTER, Align.MIN),
+                    mode=Mode.SUBTRACT,
+                )
+            trace_path = (
+                snap_socket.edges()
+                .filter_by(GeomType.CIRCLE)
+                .sort_by(Axis.Z, reverse=True)
+                .sort_by(SortBy.RADIUS, reverse=True)[-1]
+            )  # top edge of cylinder
+            path = trace_path.trim(
+                (arc_percentage / -200) * 1.1,
+                (arc_percentage / 200) * 1.1,
+            )
+            with BuildPart(mode=Mode.PRIVATE) as snapfit:
+                path = path.rotate(Axis.Z, 90)
+                with BuildSketch(path ^ 0):
+                    Polygon(
+                        *[
+                            (0, 0),
+                            (snapfit_radius_extension, 0),
+                            (
+                                snapfit_radius_extension,
+                                snapfit_height * 2,
+                            ),
+                            (0, snapfit_height * 2),
+                        ],
+                        align=(Align.MAX, Align.MIN),
+                    )
+                sweep(path=path)
+                fillet(
+                    snapfit.faces().sort_by(Axis.Y)[-1].edges().filter_by(Axis.Z),
+                    snapfit_radius_extension / 8,
+                )
+            with PolarLocations(0, snapfit_count):
+                add(snapfit.part, mode=Mode.SUBTRACT)
+
+            path = trace_path.trim(
+                (arc_percentage / -200) * 3.3,
+                (arc_percentage / 200) * 1.1,
+            )
+            with BuildPart(mode=Mode.PRIVATE) as snapfit:
+                path = path.rotate(Axis.Z, 90)
+                with BuildSketch(path ^ 0):
+                    Polygon(
+                        *[
+                            (0, 0),
+                            (
+                                snapfit_radius_extension + tolerance,
+                                0,
+                            ),
+                            (
+                                snapfit_radius_extension + tolerance,
+                                snapfit_height + tolerance,
+                            ),
+                            (
+                                0,
+                                snapfit_height / 2 + tolerance,
+                            ),
+                        ],
+                        align=(Align.MAX, Align.MIN),
+                    )
+                sweep(path=path)
+                fillet(
+                    snapfit.faces().sort_by(Axis.Y)[-1].edges().filter_by(Axis.Z),
+                    snapfit_radius_extension / 8,
+                )
+            with PolarLocations(0, snapfit_count):
+                add(snapfit.part, mode=Mode.SUBTRACT)
+            with PolarLocations(
+                connector_radius + snapfit_radius_extension + tolerance * 2,
+                snapfit_count,
+                start_angle=arc_percentage * -4,
+            ):
+                Cylinder(
+                    radius=snapfit_radius_extension / 2 - tolerance,
+                    height=snapfit_height * 2,
+                    align=(Align.CENTER, Align.CENTER, Align.MIN),
+                )
+        super().__init__(
+            socket_fitting.part, rotation=rotation, align=tuplify(align, 3), mode=mode
+        )
+
+
+if __name__ == "__main__":
+    connector = (
+        TwistSnapConnector(
+            connector_radius=4.5,
+            tolerance=0.12,
+            snapfit_height=2,
+            snapfit_radius_extension=2 * (2 / 3) - 0.06,
+            wall_width=2,
+            wall_depth=2,
+        )
+        .rotate(Axis.X, 180)
+        .move(Location((0, 0, 15)))
+    )
+    socket = TwistSnapSocket(
+        connector_radius=4.5,
+        tolerance=0.12,
+        snapfit_height=2,
+        snapfit_radius_extension=2 * (2 / 3) - 0.06,
+        wall_width=2,
+        wall_depth=2,
+    )
+
+    show(connector, socket, reset_camera=Camera.KEEP)