How to sweep a profile with holes along a path?

[jimcortez]

Hello all! I am working on a personal art project to build some models that represent interesting shapes and mathematical knots. I plan on 3d-printing these out and running LED's in them. I am very new to CADQuery and modeling in general.

In the example below, I have modeled out a complex face that looks like this:

I want to sweep a version of this face along complex paths so I create a channel that I can physically run LED's through. When I sweep along a straight wire, it works just fine (screenshot above). However, when I sweep along a more complex line, I get weird results.

Circle wire

Helix, I get this exception: OCP.OCP.Standard.Standard_Failure: BRepOffsetAPI_MakePipeShell::MakeSolid

Any guidance on how to accomplish this? Is this actually achievable with cadquery?

import cadquery as cq

def create_faces(outer_size = 14.5): 
    # Ring profile: outer ring + inner ring (half size, same thickness)
    
    inner_size = outer_size * 0.90  # outer ring hole 90% the size of the outer
    thickness = outer_size - inner_size
    connector_overlap = 0.15

    # Inner ring: half the size of outer, same thickness
    inner_ring_outer_r = outer_size / 2
    inner_ring_inner_r = inner_ring_outer_r - thickness

    # Gap between inner ring and outer ring (for rectangle width)
    gap = inner_size - inner_ring_outer_r

    wp = cq.Workplane("XZ").center(0.5, 0)

    # Outer ring wires
    outer_wire = wp.circle(outer_size).wires().val()
    outer_hole_wire = wp.circle(inner_size).wires().val()

    # Inner ring wires (same center)
    inner_ring_outer_wire = wp.circle(inner_ring_outer_r).wires().val()
    inner_ring_inner_wire = wp.rect(inner_ring_inner_r*1.75, inner_ring_outer_r).wires().val()

    # Create both ring faces
    outer_ring_face = cq.Face.makeFromWires(outer_wire, [outer_hole_wire])
    inner_ring_face = cq.Face.makeFromWires(inner_ring_outer_wire, [inner_ring_inner_wire])

    # Two rectangle sections either side of inner circle: same thickness, width = gap
    rect_mid = (inner_size + inner_ring_outer_r) / 2
    left_rect_wire = (
        cq.Workplane("XZ")
        .center(0.5 - rect_mid, 0)
        .rect(gap+connector_overlap, thickness)
        .wires()
        .val()
    )
    right_rect_wire = (
        cq.Workplane("XZ")
        .center(0.5 + rect_mid, 0)
        .rect(gap+connector_overlap, thickness)
        .wires()
        .val()
    )
    left_rect = cq.Face.makeFromWires(left_rect_wire)
    right_rect = cq.Face.makeFromWires(right_rect_wire)

    return cq.Workplane("XZ").newObject([outer_ring_face, inner_ring_face, left_rect, right_rect])

print('creating wire')
#straight
wire = cq.Workplane("XY").moveTo(0, 0).lineTo(0, 10).val()

# circle
# wire = cq.Wire.makeCircle(radius=15, center=cq.Vector(0, 0, 0), normal=cq.Vector(0, 0, 1))

# Helix
# wire = cq.Wire.makeHelix(pitch=0.4, height=30, radius=10)

print('creating profile')
profile = create_faces()

print('profile created')

path = cq.Workplane(obj=wire)

print('sweeping')
result = profile.sweep(path, isFrenet=True)

print('exporting')
cq.exporters.export(result.val(), "test2.stl")

# from yacv_server import yacv, show
# show(result.val(), names='test2')

[adam-urbanczyk]

Yes, you are likely using to small path and because of that getting weird results.

Working example:

from cadquery.func import *

def create_faces(outer_size = 14.5): 
    # Ring profile: outer ring + inner ring (half size, same thickness)
    
    inner_size = outer_size * 0.90  # outer ring hole 90% the size of the outer
    thickness = outer_size - inner_size

    # Inner ring: half the size of outer, same thickness
    inner_ring_outer_r = outer_size / 2
    inner_ring_inner_r = inner_ring_outer_r - thickness

    # Outer ring
    outer_full = face(circle(outer_size))
    outer = outer_full - face(circle(inner_size))

    # Inner ring
    inner = face(circle(inner_ring_outer_r))
    
    # Inner hole
    inner_hole = plane(inner_ring_inner_r*1.75, inner_ring_outer_r)

    # Bar
    rect = plane(2*outer_size, thickness) * outer_full

    # combine and return
    return clean(fuse(inner, outer, (rect)) - inner_hole)

f = create_faces()

path = spline([(0,0,0),(0,100,100)], tgts=[(0,0,1), (0,1,0)])

res = sweep(f, path)

[jimcortez]

Thank you for the response! I had to dig into the functional api to understand it better, but it seems easier than the main one. I was able to use your example to get a straight line, quarter circle, a jog bend, and a full circle to work. However, I am struggling with the helix path. I suspect it may have to do with the orientation of the face and the start of the helix path, but I am struggling to visualize the orientation.

Is there a better way to automatically orient my face to the path? Would significantly simplify my logic if I could orient the face to it always is perpendicular to the wire path before I sweep.

Here is some code that doesn't work, seems to hang before completing. I am guessing the face is in the wrong location and orientation and is causing erroneously complex shapes for the engine to process.

import cadquery as cq
from cadquery.func import *

def create_faces(outer_size = 14.5): 
    # Ring profile: outer ring + inner ring (half size, same thickness)
    
    inner_size = outer_size * 0.90  # outer ring hole 90% the size of the outer
    thickness = outer_size - inner_size

    # Inner ring: half the size of outer, same thickness
    inner_ring_outer_r = outer_size / 2
    inner_ring_inner_r = inner_ring_outer_r - thickness

    # Outer ring
    outer_full = face(circle(outer_size))
    outer = outer_full - face(circle(inner_size))

    # Inner ring
    inner = face(circle(inner_ring_outer_r))
    
    # Inner hole
    inner_hole = plane(inner_ring_inner_r*1.75, inner_ring_outer_r)

    # Bar
    rect = plane(2*outer_size, thickness) * outer_full

    # combine and return
    return clean(fuse(inner, outer, (rect)) - inner_hole)

print('creating profile')
outer_size = 14.5
#solid face
# faces = clean(face(circle(outer_size)))

#complex faces
faces = create_faces(outer_size)

print('creating path')
height = 100
width = 100

# straight
# path = spline([(0,0,0), (0,0,height)], tgts=[(0,0,1), (0,0,1)])

# quarter circle
# path = spline([(0,0,0),(0,width,width)], tgts=[(0,0,1), (0,1,0)])

# jog bend
# path = spline(
#     [
#         (0, 0, 0), 
#         (0, width / 2, height / 2),  # Middle of jog
#         (0, width, height)  # Final point
#     ], 
#     tgts=[(0, 0, 1), (0, 0, 1)]  # Start and end both pointing up in Z direction
# )

# circle - create a 3D circular path in the XY plane
# path = circle(width).move(rx=90).move(z=-width)
# faces = faces.move(ry=90)

# Helix
path = cq.Wire.makeHelix(pitch=0.9, height=height, radius=width/2).move(rx=90).move(z=-width)
faces = faces.move(ry=90)

print('profile created')

print('sweeping')
result = sweep(faces,path)

# print('exporting')
# cq.exporters.export(result, "test2.stl")
# print('export done')

# from yacv_server import yacv, show
# show(result, names='test2')

[lorenzncode]

Here is an example that creates a plane at the start of the path and applies the Location to the profile face.

from cadquery.func import *


def create_faces(outer_size=14.5):
    # Ring profile: outer ring + inner ring (half size, same thickness)

    inner_size = outer_size * 0.90  # outer ring hole 90% the size of the outer
    thickness = outer_size - inner_size

    # Inner ring: half the size of outer, same thickness
    inner_ring_outer_r = outer_size / 2
    inner_ring_inner_r = inner_ring_outer_r - thickness

    # Outer ring
    outer_full = face(circle(outer_size))
    outer = outer_full - face(circle(inner_size))

    # Inner ring
    inner = face(circle(inner_ring_outer_r))

    # Inner hole
    inner_hole = plane(inner_ring_inner_r * 1.75, inner_ring_outer_r)

    # Bar
    rect = plane(2 * outer_size, thickness) * outer_full

    # combine and return
    return clean(fuse(inner, outer, (rect)) - inner_hole)


f = create_faces()

height = 100
width = 100

path = Wire.makeHelix(pitch=height / 2, height=height, radius=width / 2)
plane = Plane(origin=path.startPoint(), normal=path.tangentAt(0))
f.move(Location(plane))
res = sweep(f, path)


from cadquery.vis import show

show(res, width=500, height=500)

[jimcortez]

That was definitely the missing piece! Thank you so much @lorenzncode !

[adam-urbanczyk]

For completeness, you can also use the positionAt or locationAt methods for positioning, and an aux spine to precisely control the orientation.

path = Wire.makeHelix(pitch=height/3, height=height, radius=width/2).move(rx=90).move(z=-width)
aux = Wire.makeHelix(pitch=height/3, height=height, radius=width).move(rx=90).move(z=-width)

res = sweep(f.moved(path.positionAt(0)), path, aux)

form caduqery.vis import show

show(res, aux)

[jimcortez]

What is the aux path doing here? It is just for visualizing?

[adam-urbanczyk]

In sweep(f.moved(path.positionAt(0)), path, aux) aux controls the rotation of f around the main spine.