CadQuery Examples¶

result = cadquery.Workplane("front").box(2.0, 2.0, 0.5)
build_object(result)

# The dimensions of the box. These can be modified rather than changing the
# object's code directly.
length = 80.0
height = 60.0
thickness = 10.0
center_hole_dia = 22.0

# Create a box based on the dimensions above and add a 22mm center hole
result = cq.Workplane("XY").box(length, height, thickness) \
    .faces(">Z").workplane().hole(center_hole_dia)

build_object(result)

result = cq.Workplane("front").circle(2.0).rect(0.5, 0.75).extrude(0.5)
build_object(result)

result = cq.Workplane("front").lineTo(2.0, 0).lineTo(2.0, 1.0).threePointArc((1.0, 1.5),(0.0, 1.0))\
    .close().extrude(0.25)
build_object(result)

result = cq.Workplane("front").circle(3.0) #current point is the center of the circle, at (0,0)
result = result.center(1.5, 0.0).rect(0.5, 0.5) # new work center is  (1.5, 0.0)

result = result.center(-1.5, 1.5).circle(0.25) # new work center is ( 0.0, 1.5).
#the new center is specified relative to the previous center, not global coordinates!

result = result.extrude(0.25)
build_object(result)

r = cq.Workplane("front").circle(2.0)                       # make base
r = r.pushPoints( [ (1.5, 0),(0, 1.5),(-1.5, 0),(0, -1.5) ] )     # now four points are on the stack
r = r.circle( 0.25 )                                      # circle will operate on all four points
result = r.extrude(0.125 )                               # make prism
build_object(result)

result = cq.Workplane("front").box(3.0, 4.0, 0.25).pushPoints ( [ ( 0,0.75 ),(0, -0.75) ]) \
    .polygon(6, 1.0).cutThruAll()
build_object(result)

(L,H,W,t) = ( 100.0, 20.0, 20.0, 1.0)
pts = [
    (0,H/2.0),
    (W/2.0,H/2.0),
    (W/2.0,(H/2.0 - t)),
    (t/2.0,(H/2.0-t)),
    (t/2.0,(t - H/2.0)),
    (W/2.0,(t -H/2.0)),
    (W/2.0,H/-2.0),
    (0,H/-2.0)
]
result = cq.Workplane("front").polyline(pts).mirrorY().extrude(L)
build_object(result)

s = cq.Workplane("XY")
sPnts = [
    (2.75, 1.5),
    (2.5, 1.75),
    (2.0, 1.5),
    (1.5, 1.0),
    (1.0, 1.25),
    (0.5, 1.0),
    (0, 1.0)
]
r = s.lineTo(3.0, 0).lineTo(3.0, 1.0).spline(sPnts).close()
result = r.extrude(0.5)
build_object(result)

r = cq.Workplane("front").hLine(1.0)                            # 1.0 is the distance, not coordinate
r = r.vLine(0.5).hLine(-0.25).vLine(-0.25).hLineTo(0.0)      # hLineTo allows using xCoordinate not distance
result =r.mirrorY().extrude(0.25 )                           # mirror the geometry and extrude
build_object(result)

result0 = (cadquery.Workplane("XY")
           .moveTo(10,0)
           .lineTo(5,0)
           .threePointArc((3.9393,0.4393),(3.5,1.5))
           .threePointArc((3.0607,2.5607),(2,3))
           .lineTo(1.5,3)
           .threePointArc((0.4393,3.4393),(0,4.5))
           .lineTo(0,13.5)
           .threePointArc((0.4393,14.5607),(1.5,15))
           .lineTo(28,15)
           .lineTo(28,13.5)
           .lineTo(24,13.5)
           .lineTo(24,11.5)
           .lineTo(27,11.5)
           .lineTo(27,10)
           .lineTo(22,10)
           .lineTo(22,13.2)
           .lineTo(14.5,13.2)
           .lineTo(14.5,10)
           .lineTo(12.5,10 )
           .lineTo(12.5,13.2)
           .lineTo(5.5,13.2)
           .lineTo(5.5,2)
           .threePointArc((5.793,1.293),(6.5,1))
           .lineTo(10,1)
           .close())
result = result0.extrude(100)

result = result.rotate((0, 0, 0),(1, 0, 0), 90)

result = result.translate(result.val().BoundingBox().center.multiply(-1))

mirXY_neg = result.mirror(mirrorPlane="XY", basePointVector=(0, 0, -30))
mirXY_pos = result.mirror(mirrorPlane="XY", basePointVector=(0, 0, 30))
mirZY_neg = result.mirror(mirrorPlane="ZY", basePointVector=(-30,0,0))
mirZY_pos = result.mirror(mirrorPlane="ZY", basePointVector=(30,0,0))

result = result.union(mirXY_neg).union(mirXY_pos).union(mirZY_neg).union(mirZY_pos)

build_object(result)

result = cq.Workplane("front").box(2,3, 0.5)            #make a basic prism
result = result.faces(">Z").workplane().hole(0.5)   #find the top-most face and make a hole
build_object(result)

result = cq.Workplane("front").box(3,2, 0.5)                 #make a basic prism
result = result.faces(">Z").vertices("<XY").workplane()  #select the lower left vertex and make a workplane
result = result.circle(1.0).cutThruAll()                 #cut the corner out
build_object(result)

result = cq.Workplane("front").box(3, 2, 0.5)                 #make a basic prism
result = result.faces("<X").workplane(offset=0.75)       #workplane is offset from the object surface
result = result.circle(1.0).extrude(0.5)                 #disc
build_object(result)

result = cq.Workplane("front").box(4.0, 4.0, 0.25).faces(">Z").workplane()  \
     .transformed(offset=cq.Vector(0, -1.5, 1.0),rotate=cq.Vector(60, 0, 0)) \
     .rect(1.5,1.5,forConstruction=True).vertices().hole(0.25)
build_object(result)

result = cq.Workplane("front").box(2, 2, 0.5).faces(">Z").workplane() \
    .rect(1.5, 1.5, forConstruction=True).vertices().hole(0.125 )
build_object(result)

result = cq.Workplane("front").box(2, 2, 2).faces("+Z").shell(0.05)
build_object(result)

result = cq.Workplane("front").box(4.0, 4.0, 0.25).faces(">Z").circle(1.5) \
    .workplane(offset=3.0).rect(0.75, 0.5).loft(combine=True)

build_object(result)

result = cq.Workplane(cq.Plane.XY()).box(4,2, 0.5).faces(">Z").workplane().rect(3.5, 1.5, forConstruction=True)\
.vertices().cboreHole(0.125, 0.25, 0.125, depth=None)

build_object(result)

result = cq.Workplane("XY" ).box(3, 3, 0.5).edges("|Z").fillet(0.125)
build_object(result)

(length,height,bearing_diam, thickness,padding) = ( 30.0, 40.0, 22.0, 10.0, 8.0)

result = cq.Workplane("XY").box(length,height,thickness).faces(">Z").workplane().hole(bearing_diam) \
        .faces(">Z").workplane() \
        .rect(length-padding,height-padding,forConstruction=True) \
        .vertices().cboreHole(2.4, 4.4, 2.1)

build_object(result)

c = cq.Workplane("XY").box(1,1,1).faces(">Z").workplane().circle(0.25).cutThruAll()

#now cut it in half sideways
result = c.faces(">Y").workplane(-0.5).split(keepTop=True)
build_object(result)

(L,w,t) = (20.0, 6.0, 3.0)
s = cq.Workplane("XY")

#draw half the profile of the bottle and extrude it
p = s.center(-L/2.0, 0).vLine(w/2.0) \
    .threePointArc((L/2.0, w/2.0 + t),(L, w/2.0)).vLine(-w/2.0) \
    .mirrorX().extrude(30.0,True)

#make the neck
p.faces(">Z").workplane().circle(3.0).extrude(2.0,True)

#make a shell
result = p.faces(">Z").shell(0.3)
build_object(result)

#parameter definitions
p_outerWidth = 100.0 #Outer width of box enclosure
p_outerLength = 150.0 #Outer length of box enclosure
p_outerHeight = 50.0 #Outer height of box enclosure

p_thickness =  3.0 #Thickness of the box walls
p_sideRadius =  10.0 #Radius for the curves around the sides of the bo
p_topAndBottomRadius =  2.0 #Radius for the curves on the top and bottom edges of the box

p_screwpostInset = 12.0 #How far in from the edges the screwposts should be place.
p_screwpostID = 4.0 #nner Diameter of the screwpost holes, should be roughly screw diameter not including threads
p_screwpostOD = 10.0 #Outer Diameter of the screwposts.\nDetermines overall thickness of the posts

p_boreDiameter = 8.0 #Diameter of the counterbore hole, if any
p_boreDepth = 1.0 #Depth of the counterbore hole, if
p_countersinkDiameter = 0.0 #Outer diameter of countersink.  Should roughly match the outer diameter of the screw head
p_countersinkAngle = 90.0 #Countersink angle (complete angle between opposite sides, not from center to one side)
p_flipLid = True #Whether to place the lid with the top facing down or not.
p_lipHeight =  1.0 #Height of lip on the underside of the lid.\nSits inside the box body for a snug fit.

#outer shell
oshell = cq.Workplane("XY").rect(p_outerWidth,p_outerLength).extrude(p_outerHeight + p_lipHeight)

#weird geometry happens if we make the fillets in the wrong order
if p_sideRadius > p_topAndBottomRadius:
    oshell.edges("|Z").fillet(p_sideRadius)
    oshell.edges("#Z").fillet(p_topAndBottomRadius)
else:
    oshell.edges("#Z").fillet(p_topAndBottomRadius)
    oshell.edges("|Z").fillet(p_sideRadius)

#inner shell
ishell = oshell.faces("<Z").workplane(p_thickness,True)\
    .rect((p_outerWidth - 2.0* p_thickness),(p_outerLength - 2.0*p_thickness))\
    .extrude((p_outerHeight - 2.0*p_thickness),False) #set combine false to produce just the new boss
ishell.edges("|Z").fillet(p_sideRadius - p_thickness)

#make the box outer box
box = oshell.cut(ishell)

#make the screwposts
POSTWIDTH = (p_outerWidth - 2.0*p_screwpostInset)
POSTLENGTH = (p_outerLength  -2.0*p_screwpostInset)

postCenters = box.faces(">Z").workplane(-p_thickness)\
    .rect(POSTWIDTH,POSTLENGTH,forConstruction=True)\
    .vertices()

for v in postCenters.all():
   v.circle(p_screwpostOD/2.0).circle(p_screwpostID/2.0)\
        .extrude((-1.0)*(p_outerHeight + p_lipHeight -p_thickness ),True)

#split lid into top and bottom parts
(lid,bottom) = box.faces(">Z").workplane(-p_thickness -p_lipHeight ).split(keepTop=True,keepBottom=True).all()  #splits into two solids

#translate the lid, and subtract the bottom from it to produce the lid inset
lowerLid = lid.translate((0,0,-p_lipHeight))
cutlip = lowerLid.cut(bottom).translate((p_outerWidth + p_thickness ,0,p_thickness - p_outerHeight + p_lipHeight))

#compute centers for counterbore/countersink or counterbore
topOfLidCenters = cutlip.faces(">Z").workplane().rect(POSTWIDTH,POSTLENGTH,forConstruction=True).vertices()

#add holes of the desired type
if p_boreDiameter > 0 and p_boreDepth > 0:
    topOfLid = topOfLidCenters.cboreHole(p_screwpostID,p_boreDiameter,p_boreDepth,(2.0)*p_thickness)
elif p_countersinkDiameter > 0 and p_countersinkAngle > 0:
    topOfLid = topOfLidCenters.cskHole(p_screwpostID,p_countersinkDiameter,p_countersinkAngle,(2.0)*p_thickness)
else:
    topOfLid= topOfLidCenters.hole(p_screwpostID,(2.0)*p_thickness)

#flip lid upside down if desired
if p_flipLid:
    topOfLid.rotateAboutCenter((1,0,0),180)

#return the combined result
result =topOfLid.combineSolids(bottom)

build_object(result)

#####
# Inputs
######
lbumps = 6       # number of bumps long
wbumps = 2       # number of bumps wide
thin = True      # True for thin, False for thick

#
# Lego Brick Constants-- these make a lego brick a lego :)
#
pitch = 8.0
clearance = 0.1
bumpDiam = 4.8
bumpHeight = 1.8
if thin:
    height = 3.2
else:
    height = 9.6

t = (pitch - (2 * clearance) - bumpDiam) / 2.0
postDiam = pitch - t  # works out to 6.5
total_length = lbumps*pitch - 2.0*clearance
total_width = wbumps*pitch - 2.0*clearance

# make the base
s = cq.Workplane("XY").box(total_length, total_width, height)

# shell inwards not outwards
s = s.faces("<Z").shell(-1.0 * t)

# make the bumps on the top
s = s.faces(">Z").workplane(). \
    rarray(pitch, pitch, lbumps, wbumps, True).circle(bumpDiam / 2.0) \
    .extrude(bumpHeight)

# add posts on the bottom. posts are different diameter depending on geometry
# solid studs for 1 bump, tubes for multiple, none for 1x1
tmp = s.faces("<Z").workplane(invert=True)

if lbumps > 1 and wbumps > 1:
    tmp = tmp.rarray(pitch, pitch, lbumps - 1, wbumps - 1, center=True). \
        circle(postDiam / 2.0).circle(bumpDiam / 2.0).extrude(height - t)
elif lbumps > 1:
    tmp = tmp.rarray(pitch, pitch, lbumps - 1, 1, center=True). \
        circle(t).extrude(height - t)
elif wbumps > 1:
    tmp = tmp.rarray(pitch, pitch, 1, wbumps - 1, center=True). \
        circle(t).extrude(height - t)
else:
    tmp = s

# Render the solid
build_object(tmp)

from __future__ import unicode_literals, division
from collections import namedtuple


# text_lines is a list of text lines.
# FreeCAD in braille (converted with braille-converter:
# https://github.com/jpaugh/braille-converter.git).
text_lines = ['⠠ ⠋ ⠗ ⠑ ⠑ ⠠ ⠉ ⠠ ⠁ ⠠ ⠙']
# See http://www.tiresias.org/research/reports/braille_cell.htm for examples
# of braille cell geometry.
horizontal_interdot = 2.5
vertical_interdot = 2.5
horizontal_intercell = 6
vertical_interline = 10
dot_height = 0.5
dot_diameter = 1.3

base_thickness = 1.5

# End of configuration.
BrailleCellGeometry = namedtuple('BrailleCellGeometry',
                                 ('horizontal_interdot',
                                  'vertical_interdot',
                                  'intercell',
                                  'interline',
                                  'dot_height',
                                  'dot_diameter'))


class Point(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Point(self.x + other.x, self.y + other.y)

    def __len__(self):
        return 2

    def __getitem__(self, index):
        return (self.x, self.y)[index]

    def __str__(self):
        return '({}, {})'.format(self.x, self.y)


def brailleToPoints(text, cell_geometry):
    # Unicode bit pattern (cf. https://en.wikipedia.org/wiki/Braille_Patterns).
    mask1 = 0b00000001
    mask2 = 0b00000010
    mask3 = 0b00000100
    mask4 = 0b00001000
    mask5 = 0b00010000
    mask6 = 0b00100000
    mask7 = 0b01000000
    mask8 = 0b10000000
    masks = (mask1, mask2, mask3, mask4, mask5, mask6, mask7, mask8)

    # Corresponding dot position
    w = cell_geometry.horizontal_interdot
    h = cell_geometry.vertical_interdot
    pos1 = Point(0, 2 * h)
    pos2 = Point(0, h)
    pos3 = Point(0, 0)
    pos4 = Point(w, 2 * h)
    pos5 = Point(w, h)
    pos6 = Point(w, 0)
    pos7 = Point(0, -h)
    pos8 = Point(w, -h)
    pos = (pos1, pos2, pos3, pos4, pos5, pos6, pos7, pos8)

    # Braille blank pattern (u'\u2800').
    blank = '⠀'
    points = []
    # Position of dot1 along the x-axis (horizontal).
    character_origin = 0
    for c in text:
        for m, p in zip(masks, pos):
            delta_to_blank = ord(c) - ord(blank)
            if (m & delta_to_blank):
                points.append(p + Point(character_origin, 0))
        character_origin += cell_geometry.intercell
    return points


def get_plate_height(text_lines, cell_geometry):
    # cell_geometry.vertical_interdot is also used as space between base
    # borders and characters.
    return (2 * cell_geometry.vertical_interdot +
            2 * cell_geometry.vertical_interdot +
            (len(text_lines) - 1) * cell_geometry.interline)


def get_plate_width(text_lines, cell_geometry):
    # cell_geometry.horizontal_interdot is also used as space between base
    # borders and characters.
    max_len = max([len(t) for t in text_lines])
    return (2 * cell_geometry.horizontal_interdot +
            cell_geometry.horizontal_interdot +
            (max_len - 1) * cell_geometry.intercell)


def get_cylinder_radius(cell_geometry):
    """Return the radius the cylinder should have
    The cylinder have the same radius as the half-sphere make the dots (the
    hidden and the shown part of the dots).
    The radius is such that the spherical cap with diameter
    cell_geometry.dot_diameter has a height of cell_geometry.dot_height.
    """
    h = cell_geometry.dot_height
    r = cell_geometry.dot_diameter / 2
    return (r ** 2 + h ** 2) / 2 / h


def get_base_plate_thickness(plate_thickness, cell_geometry):
    """Return the height on which the half spheres will sit"""
    return (plate_thickness +
            get_cylinder_radius(cell_geometry) -
            cell_geometry.dot_height)


def make_base(text_lines, cell_geometry, plate_thickness):
    base_width = get_plate_width(text_lines, cell_geometry)
    base_height = get_plate_height(text_lines, cell_geometry)
    base_thickness = get_base_plate_thickness(plate_thickness, cell_geometry)
    base = cq.Workplane('XY').box(base_width, base_height, base_thickness,
                                  centered=(False, False, False))
    return base


def make_embossed_plate(text_lines, cell_geometry):
    """Make an embossed plate with dots as spherical caps
    Method:
        - make a thin plate on which sit cylinders
        - fillet the upper edge of the cylinders so to get pseudo half-spheres
        - make the union with a thicker plate so that only the sphere caps stay
          "visible".
    """
    base = make_base(text_lines, cell_geometry, base_thickness)

    dot_pos = []
    base_width = get_plate_width(text_lines, cell_geometry)
    base_height = get_plate_height(text_lines, cell_geometry)
    y = base_height - 3 * cell_geometry.vertical_interdot
    line_start_pos = Point(cell_geometry.horizontal_interdot, y)
    for text in text_lines:
        dots = brailleToPoints(text, cell_geometry)
        dots = [p + line_start_pos for p in dots]
        dot_pos += dots
        line_start_pos += Point(0, -cell_geometry.interline)

    r = get_cylinder_radius(cell_geometry)
    base = base.faces('>Z').vertices('<XY').workplane() \
        .pushPoints(dot_pos).circle(r) \
        .extrude(r)
    # Make a fillet almost the same radius to get a pseudo spherical cap.
    base = base.faces('>Z').edges() \
        .fillet(r - 0.001)
    hidding_box = cq.Workplane('XY').box(
        base_width, base_height, base_thickness, centered=(False, False, False))
    result = hidding_box.union(base)
    return result

_cell_geometry = BrailleCellGeometry(
    horizontal_interdot,
    vertical_interdot,
    horizontal_intercell,
    vertical_interline,
    dot_height,
    dot_diameter)

if base_thickness < get_cylinder_radius(_cell_geometry):
    raise ValueError('Base thickness should be at least {}'.format(dot_height))

build_object(make_embossed_plate(text_lines, _cell_geometry))