Feedback on technique for positioning a tab and slot on a sliced box

[hartzell]

I'd like to slice a thing that I'm building and be able to snap them together with dovetail joints.

I've figured out (google searches, CadQuery docs, stubbornness) a way to locate the tabs and slots relative to the model, without relying on [too much] brute force knowledge of the model's measurements.

It boils down to identifying an edge on the face of the object of interest, then creating a workplane and building the tab/slot bit there.

I've put together a simplified demo of what I'm doing.

I'd love feedback about the method and/or hints about a better way of doing it. While this is a question about a concrete example, I'm more interested in general techniques.

Here's a screenshot of the example:

Here's the code that generated it:

import cadquery as cq

box = cq.Workplane().box(200, 100, 50)
box = box.faces(">Z").shell(20)


top = (
    box.workplane()
    .transformed(rotate=(0, 90, 0), offset=(-50, 0, 0))
    .split(keepTop=True)
)

bottom = (
    box.workplane()
    .transformed(rotate=(0, 90, 0), offset=(-50, 0, 0))
    .split(keepBottom=True)
)

origin = bottom.faces(">X")[0].edges(">Z")[0].val().Center()
normal_vector = cq.Vector(1, 0, 0)
x_direction_vector = cq.Vector(0, 1, 0)
custom_plane = cq.Plane(origin=origin, xDir=x_direction_vector, normal=normal_vector)
wp = cq.Workplane(custom_plane).transformed(offset=cq.Vector(0, -10, 0))

horn = wp.rect(10, 20).extrude(15.0)

bottom = bottom.union(horn)
top = top.cut(horn)
top = top.translate((18, 0, 0))

show_object(top, options={"alpha": 0.7, "color": (255, 0, 0)})
show_object(bottom, options={"alpha": 0.7, "color": (0, 0, 255)})

Any feedback would be welcome.

[lorenzncode]

Here is another way to create the box parts. I haven't tried the tab part yet.

• create box shape without using shell
• create both top, bottom with single call to split
• offset splitter from selected face instead of transform

import cadquery as cq

box1 = (
    cq.Workplane()
    .box(240, 140, 70)
    .edges("|Z")
    .fillet(20)
    .faces("<Z")
    .edges()
    .fillet(20)
    .faces(">Z")
    .rect(200, 100)
    .extrude(-50, "s")  # cut ("s" is subtractive mode)
)

box1 = box1.faces("<X").workplane(offset=-60).split(True, True)

top = box1.solids(">X")
bottom = box1.solids("<X")

[hartzell]

Thanks for the example.

• The alternate way of creating the box reminded me of the subtractive mode for extrude.

• The single split call is nice, but whenever I see it my first mental model is that it's separating solids on the minimum/maximum box1 face. There isn't a section in the docs for using selectors with solids (though they're mentioned as a type that can be selected) and the docs for "<" just say

  <: minimize (same as DirectionMinMaxSelector with directionMax=False )

  I suppose the way to think of it is that there are two solids, ">X" selects the one on the maximum X and "<X" selects the one with the minimum X. There's nothing else on the stack to deal with.

I appreciate the input.

I am interested in the other part, other ways to stick a something (like the horn in the example) onto a particular location (e.g. the center of the top of a face). It's kind of what assemblies do, but when building a single thingy.

[hartzell]

ps. Since my choice of which edge to use is under constrained (which is edge [0] and which is edge [1]), using your method of getting the top/bottom parts ends up putting the horn on the other side of the box....

[lorenzncode]

I suppose the way to think of it is that there are two solids, ">X" selects the one on the maximum X and "<X" selects the one with the minimum X.

Yes, select the solid with center farthest in the +x or -x direction. The same can be achieved with a custom sort function:

bottom, top = box1.solids().sort(lambda s: s.Center().x)

[lorenzncode]

normal_vector = cq.Vector(1, 0, 0)
x_direction_vector = cq.Vector(0, 1, 0)

The vectors can be automatically computed from face normal and edge tangents to simplify the code.

origin = bottom.faces(">X")[0].edges(">Z")[0].val().Center()

The orgin can also be computed from the edge. See the example below with positionAt(0.5) for edge midpoint.

which edge to use is under constrained

See example below to select a single edge:

e = f.edges("<X").edges(">Y")  # edge to orient dovetail

Here is a rough experimental example of a function that might be reused for this purpose.

from cadquery import Sketch, Workplane
from cadquery.func import *
from typing import Tuple


def dovetail(
    shapes: Tuple[Shape, Shape],
    dir: Vector,
    e: Edge,
    w: float = 10.0,
    l: float = 5.0,
    h: float = 10.0,
    x: float = 0.0,
    mirror: bool = False,
):
    """
    Experimental "dovetail" joint for discussion.

    Place a single tail/socket defined by direction and midpoint of edge on boundary of shapes.

    :param shapes: tuple of shapes of length 2; order is not important
    :param dir: dovetail direction
    :param e: edge defining joint (must be in plane of face f)
    :param w: tail width
    :param l: tail length
    :param h: tail depth
    :param x: position dovetail relative to edge midpoint; default 0
    :param mirror: mirror around joint edge
    """

    plane1 = Plane(
        e.positionAt(0.5),
        e.tangentAt().multiply(-1) if mirror else e.tangentAt(),
        normal=dir,
    )

    # tail
    sk1 = Sketch().rect(w, l)  # replace rect with dovetail shape
    tail = Workplane(plane1).move(x, l / 2.0).placeSketch(sk1).extrude(h).val()
    s1 = [s for s in shapes if not s.isInside(tail.Center())].pop() + tail

    # socket
    tol = 0.2
    sk2 = Sketch().rect(w + tol, l + tol / 2)  # replace rect with dovetail shape
    socket = (
        Workplane(plane1).move(x, l / 2 + tol / 4).placeSketch(sk2).extrude(h).val()
    )
    s2 = [s for s in shapes if s.isInside(socket.Center())].pop() - socket

    return (clean(s1), clean(s2))


box1 = (
    Workplane()
    .box(240, 140, 70)
    .edges("|Z")
    .fillet(20)
    .faces("<Z")
    .edges()
    .fillet(20)
    .faces(">Z")
    .rect(200, 100)
    .extrude(-50, "s")  # cut ("s" is subtractive mode)
)

box1 = box1.faces("<X").workplane(offset=-60).split(True, True)

top = box1.solids(">X").val()
bottom = box1.solids("<X").val()

f = top.faces(">Z")  # face at start of dovetail (top)
dir = f.normalAt().multiply(-1)  # direction of dovetail (cut direction)
e = f.edges("<X").edges(">Y")  # edge to orient dovetail

part1, part2 = dovetail((top, bottom), dir, e, 10.0, 15.0, 20.0, mirror=True)

# cq-editor
show_object(e)
show_object(part1, options={"alpha": 0.7, "color": (0, 0, 255)})
show_object(part2, options={"alpha": 0.7, "color": (255, 0, 0)})