cadquery Documentation

apptainer run oras://ghcr.io/cadquery/cadquery-apptainer:master ipython -i -c"from cadquery.func import *; from cadquery.vis import show; show(box(1,1,1))"

podman run -i -v /tmp:/tmp -e DISPLAY=$DISPLAY  --userns=keep-id --user "$(id -u):$(id -g)" --device /dev/dri -t ghcr.io/cadquery/cadquery-docker:master ipython -i  -c"from cadquery.func import *; from cadquery.vis import show; show(box(1,1,1))"

# Set up a new environment
conda create -n cadquery

# Activate the new environment
conda activate cadquery

# Install the latest released version
mamba install -c conda-forge cadquery

# Or install the dev version to get the latest changes
mamba install -c conda-forge -c cadquery cadquery=master

python3 -m pip install --upgrade pip

pip install cadquery

pip install git+https://github.com/CadQuery/cadquery.git

from cadquery.func import box, fillet
from cadquery.vis import show

b = box(1,1,1)
show(fillet(b, b.edges("|Z"), 0.1))

from cadquery.func import box, fillet
from cadquery.fig import show

b = box(1,1,1)
show(fillet(b, b.edges("|Z"), 0.1))

conda install jinja2 constructor
python build.py  <github tag version>

build.py 2.2 master

# Under Windows
condabin\activate.bat

# Under Linux / MacOS
source ~/cadquery/bin/activate

NearestToPointSelector
BoxSelector
BaseDirSelector
ParallelDirSelector
DirectionSelector
DirectionNthSelector
LengthNthSelector
AreaNthSelector
RadiusNthSelector
PerpendicularDirSelector
TypeSelector
DirectionMinMaxSelector
CenterNthSelector
BinarySelector
AndSelector
SumSelector
SubtractSelector
InverseSelector
StringSyntaxSelector

Assembly
Assembly.add
Assembly.save
Assembly.constrain
Assembly.solve
Constraint
Color

# tag mating faces
   rv.faces(">X").tag("X").end()
   rv.faces(">Z").tag("Z").end()

   return rv

# tag mating edges
   rv.faces(">Y").edges("%CIRCLE").edges(">Z").tag("hole1")
   rv.faces(">Y").edges("%CIRCLE").edges("<Z").tag("hole2")

   return rv

path = cq.Workplane().polyline(pts)

   rv = (
       cq.Workplane("YZ")
       .rect(r, r)
       .sweep(path, transition="round")
       .tag("solid")
       .faces("<X")
       .workplane()
       .faces("<X", tag="solid")
       .hole(r / 1.5)
   )

   # tag mating faces
   rv.faces("<X").faces(">Y").tag("mate1")
   rv.faces("<X").faces("<Y").tag("mate2")

   return rv

.constrain("part1@faces@>Z", "part3@faces@<Z", "Axis")

.constrain("part1", part1.faces(">z").val(), "part3", part3.faces("<Z").val(), "Axis")

import cadquery as cq

# Parameters
H = 400
W = 200
D = 350

PROFILE = cq.importers.importDXF("vslot-2020_1.dxf").wires()

SLOT_D = 6
PANEL_T = 3

HANDLE_D = 20
HANDLE_L = 50
HANDLE_W = 4


def make_vslot(l):
    return PROFILE.toPending().extrude(l)


def make_connector():
    rv = (
        cq.Workplane()
        .box(20, 20, 20)
        .faces("<X")
        .workplane()
        .cboreHole(6, 15, 18)
        .faces("<Z")
        .workplane(centerOption="CenterOfMass")
        .cboreHole(6, 15, 18)
    )

    # tag mating faces
    rv.faces(">X").tag("X").end()
    rv.faces(">Z").tag("Z").end()

    return rv


def make_panel(w, h, t, cutout):
    rv = (
        cq.Workplane("XZ")
        .rect(w, h)
        .extrude(t)
        .faces(">Y")
        .vertices()
        .rect(2 * cutout, 2 * cutout)
        .cutThruAll()
        .faces("<Y")
        .workplane()
        .pushPoints([(-w / 3, HANDLE_L / 2), (-w / 3, -HANDLE_L / 2)])
        .hole(3)
    )

    # tag mating edges
    rv.faces(">Y").edges("%CIRCLE").edges(">Z").tag("hole1")
    rv.faces(">Y").edges("%CIRCLE").edges("<Z").tag("hole2")

    return rv


def make_handle(w, h, r):
    pts = ((0, 0), (w, 0), (w, h), (0, h))

    path = cq.Workplane().polyline(pts)

    rv = (
        cq.Workplane("YZ")
        .rect(r, r)
        .sweep(path, transition="round")
        .tag("solid")
        .faces("<X")
        .workplane()
        .faces("<X", tag="solid")
        .hole(r / 1.5)
    )

    # tag mating faces
    rv.faces("<X").faces(">Y").tag("mate1")
    rv.faces("<X").faces("<Y").tag("mate2")

    return rv


# define the elements
door = (
    cq.Assembly()
    .add(make_vslot(H), name="left")
    .add(make_vslot(H), name="right")
    .add(make_vslot(W), name="top")
    .add(make_vslot(W), name="bottom")
    .add(make_connector(), name="con_tl", color=cq.Color("black"))
    .add(make_connector(), name="con_tr", color=cq.Color("black"))
    .add(make_connector(), name="con_bl", color=cq.Color("black"))
    .add(make_connector(), name="con_br", color=cq.Color("black"))
    .add(
        make_panel(W + 2 * SLOT_D, H + 2 * SLOT_D, PANEL_T, SLOT_D),
        name="panel",
        color=cq.Color(0, 0, 1, 0.2),
    )
    .add(
        make_handle(HANDLE_D, HANDLE_L, HANDLE_W),
        name="handle",
        color=cq.Color("yellow"),
    )
)

# define the constraints
(
    door
    # left profile
    .constrain("left@faces@<Z", "con_bl?Z", "Plane")
    .constrain("left@faces@<X", "con_bl?X", "Axis")
    .constrain("left@faces@>Z", "con_tl?Z", "Plane")
    .constrain("left@faces@<X", "con_tl?X", "Axis")
    # top
    .constrain("top@faces@<Z", "con_tl?X", "Plane")
    .constrain("top@faces@<Y", "con_tl@faces@>Y", "Axis")
    # bottom
    .constrain("bottom@faces@<Y", "con_bl@faces@>Y", "Axis")
    .constrain("bottom@faces@>Z", "con_bl?X", "Plane")
    # right connectors
    .constrain("top@faces@>Z", "con_tr@faces@>X", "Plane")
    .constrain("bottom@faces@<Z", "con_br@faces@>X", "Plane")
    .constrain("left@faces@>Z", "con_tr?Z", "Axis")
    .constrain("left@faces@<Z", "con_br?Z", "Axis")
    # right profile
    .constrain("right@faces@>Z", "con_tr@faces@>Z", "Plane")
    .constrain("right@faces@<X", "left@faces@<X", "Axis")
    # panel
    .constrain("left@faces@>X[-4]", "panel@faces@<X", "Plane")
    .constrain("left@faces@>Z", "panel@faces@>Z", "Axis")
    # handle
    .constrain("panel?hole1", "handle?mate1", "Plane")
    .constrain("panel?hole2", "handle?mate2", "Point")
)

# solve
door.solve()

show_object(door, name="door")

import cadquery as cq

cone = cq.Solid.makeCone(1, 0, 2)

assy = cq.Assembly()
assy.add(
    cone,
    loc=cq.Location((0, 0, 0), (1, 0, 0), 180),
    name="cone0",
    color=cq.Color("green"),
)
assy.add(cone, name="cone1", color=cq.Color("blue"))

show_object(assy)

import cadquery as cq

# Use the Point constraint to position boxes relative to an arc
line = cq.Edge.makeCircle(radius=10, angle1=0, angle2=90)
box = cq.Workplane().box(1, 1, 1)

assy = cq.Assembly()
assy.add(line, name="line")

# position the red box on the center of the arc
assy.add(box, name="box0", color=cq.Color("red"))
assy.constrain("line", "box0", "Point")

# position the green box at a normalized distance of 0.8 along the arc
position0 = line.positionAt(0.8)
assy.add(box, name="box1", color=cq.Color("green"))
assy.constrain(
    "line",
    cq.Vertex.makeVertex(*position0.toTuple()),
    "box1",
    box.val(),
    "Point",
)

# position the orange box 2 units in any direction from the green box
assy.add(box, name="box2", color=cq.Color("orange"))
assy.constrain(
    "line",
    cq.Vertex.makeVertex(*position0.toTuple()),
    "box2",
    box.val(),
    "Point",
    param=2,
)

# position the blue box offset 2 units in the x direction from the green box
position1 = position0 + cq.Vector(2, 0, 0)
assy.add(box, name="box3", color=cq.Color("blue"))
assy.constrain(
    "line",
    cq.Vertex.makeVertex(*position1.toTuple()),
    "box3",
    box.val(),
    "Point",
)

assy.solve()
show_object(assy)

import cadquery as cq

cone = cq.Solid.makeCone(1, 0, 2)

assy = cq.Assembly()
assy.add(cone, name="cone0", color=cq.Color("green"))
assy.add(cone, name="cone1", color=cq.Color("blue"))
assy.constrain("cone0@faces@<Z", "cone1@faces@<Z", "Axis")

assy.solve()
show_object(assy)

import cadquery as cq

plate = cq.Workplane().box(10, 10, 1).faces(">Z").workplane().hole(2)
cone = cq.Solid.makeCone(0.8, 0, 4)

assy = cq.Assembly()
assy.add(plate, name="plate", color=cq.Color("green"))
assy.add(cone, name="cone", color=cq.Color("blue"))
# place the center of the flat face of the cone in the center of the upper face of the plate
assy.constrain("plate@faces@>Z", "cone@faces@<Z", "Point")

# set both the flat face of the cone and the upper face of the plate to point in the same direction
assy.constrain("plate@faces@>Z", "cone@faces@<Z", "Axis", param=0)

assy.solve()
show_object(assy)

import cadquery as cq
from math import cos, sin, pi

# Create a sinusoidal surface:
surf = cq.Workplane().parametricSurface(
    lambda u, v: (u, v, 5 * sin(pi * u / 10) * cos(pi * v / 10)),
    N=40,
    start=0,
    stop=20,
)

# Create a cone with a small, flat tip:
cone = (
    cq.Workplane()
    .add(cq.Solid.makeCone(1, 0.1, 2))
    # tag the tip for easy reference in the constraint:
    .faces(">Z")
    .tag("tip")
    .end()
)

assy = cq.Assembly()
assy.add(surf, name="surf", color=cq.Color("lightgray"))
assy.add(cone, name="cone", color=cq.Color("green"))
# set the Face on the tip of the cone to point in
# the opposite direction of the center of the surface:
assy.constrain("surf", "cone?tip", "Axis")
# to make the example clearer, move the cone to the center of the face:
assy.constrain("surf", "cone?tip", "Point")
assy.solve()

show_object(assy)

assy = cq.Assembly()
assy.add(surf, name="surf", color=cq.Color("lightgray"))
assy.add(cone, name="cone", color=cq.Color("green"))
-# set the Face on the tip of the cone to point in
-# the opposite direction of the center of the surface:
-assy.constrain("surf", "cone?tip", "Axis")
-# to make the example clearer, move the cone to the center of the face:
-assy.constrain("surf", "cone?tip", "Point")
+assy.constrain("surf", "cone?tip", "Plane")
assy.solve()

show_object(assy)

\operatorname{dist}( \vec{ c }, p_\text{ offset } ) ^2

import cadquery as cq

# Create an L-shaped object:
bracket = (
    cq.Workplane("YZ")
    .hLine(1)
    .vLine(0.1)
    .hLineTo(0.2)
    .vLineTo(1)
    .hLineTo(0)
    .close()
    .extrude(1)
    # tag some faces for easy reference:
    .faces(">Y[1]")
    .tag("inner_vert")
    .end()
    .faces(">Z[1]")
    .tag("inner_horiz")
    .end()
)

box = cq.Workplane().box(0.5, 0.5, 0.5)

assy = cq.Assembly()
assy.add(bracket, name="bracket", color=cq.Color("gray"))
assy.add(box, name="box", color=cq.Color("green"))

# lock bracket orientation:
assy.constrain("bracket@faces@>Z", "box@faces@>Z", "Axis", param=0)
assy.constrain("bracket@faces@>X", "box@faces@>X", "Axis", param=0)

# constrain the bottom of the box to be on the plane defined by inner_horiz:
assy.constrain("box@faces@<Z", "bracket?inner_horiz", "PointInPlane")
# constrain the side of the box to be 0.2 units from the plane defined by inner_vert
assy.constrain("box@faces@<Y", "bracket?inner_vert", "PointInPlane", param=0.2)
# constrain the end of the box to be 0.1 units inside the end of the bracket
assy.constrain("box@faces@>X", "bracket@faces@>X", "PointInPlane", param=-0.1)

assy.solve()
show_object(assy)

import cadquery as cq

b1 = cq.Workplane().box(1, 1, 1)
b2 = cq.Workplane().sphere(0.15)

assy = (
    cq.Assembly()
    .add(b1, name="b1")
    .add(b2, loc=cq.Location((0, 0, 4)), name="b2", color=cq.Color("red"))
)

# fix the position of b1
assy.constrain("b1", "Fixed")
# b2 on one of the edges of b1
assy.constrain("b2", "b1@edges@>>Z and >>Y", "PointOnLine")
# b2 on another of the edges of b1
assy.constrain("b2", "b1@edges@>>Z and >>X", "PointOnLine")
# effectively b2 will be constrained to be on the intersection of the two edges

assy.solve()
show_object(assy)

import cadquery as cq

b1 = cq.Workplane().box(1, 1, 1)
b2 = cq.Workplane().sphere(0.15)

assy = (
    cq.Assembly()
    .add(b1, name="b1")
    .add(b2, loc=cq.Location((0, 0, 4)), name="b2", color=cq.Color("red"))
    .add(b1, loc=cq.Location((-2, 0, 0)), name="b3", color=cq.Color("red"))
)

pnt = (0.5, 0.5, 0.5)

# fix the position of b1
assy.constrain("b1", "Fixed")
# fix b2 center at point
assy.constrain("b2", "FixedPoint", pnt)
# fix b3 vertex position at point
assy.constrain("b3@vertices@<X and <Y and <Z", "FixedPoint", pnt)

assy.solve()
show_object(assy)

import cadquery as cq

b1 = cq.Workplane().box(1, 1, 1)
b2 = cq.Workplane().rect(0.1, 0.1).extrude(1, taper=-15)

assy = (
    cq.Assembly()
    .add(b1, name="b1")
    .add(b2, loc=cq.Location((0, 0, 4)), name="b2", color=cq.Color("red"))
)

# fix the position of b1
assy.constrain("b1", "Fixed")
# fix b2 bottom face position (but not rotation)
assy.constrain("b2@faces@<Z", "FixedPoint", (0, 0, 0.5))
# fix b2 rotational degrees of freedom too
assy.constrain("b2", "FixedRotation", (45, 0, 45))

assy.solve()
show_object(assy)

import cadquery as cq

b1 = cq.Workplane().box(1, 1, 1)
b2 = cq.Workplane().rect(0.1, 0.1).extrude(1, taper=-15)

assy = (
    cq.Assembly()
    .add(b1, name="b1")
    .add(b2, loc=cq.Location((0, 0, 4)), name="b2", color=cq.Color("red"))
)

# fix the position of b1
assy.constrain("b1", "Fixed")
# fix b2 bottom face position (but not rotation)
assy.constrain("b2@faces@<Z", "FixedPoint", (0, 0, 0.5))
# fix b2 some rotational degrees of freedom too
assy.constrain("b2@faces@>Z", "FixedAxis", (1, 0, 2))

assy.solve()
show_object(assy)

aliceblue
  antiquewhite
  antiquewhite1
  antiquewhite2
  antiquewhite3
  antiquewhite4
  aquamarine1
  aquamarine2
  aquamarine4
  azure
  azure2
  azure3
  azure4
  beet
  beige
  bisque
  bisque2
  bisque3
  bisque4
  black
  blanchedalmond
  blue
  blue1
  blue2
  blue3
  blue4
  blueviolet
  brown
  brown1
  brown2
  brown3
  brown4
  burlywood
  burlywood1
  burlywood2
  burlywood3
  burlywood4
  cadetblue
  cadetblue1
  cadetblue2
  cadetblue3
  cadetblue4
  chartreuse
  chartreuse1
  chartreuse2
  chartreuse3
  chartreuse4
  chocolate
  chocolate1
  chocolate2
  chocolate3
  chocolate4
  coral
  coral1
  coral2
  coral3
  coral4
  cornflowerblue
  cornsilk1
  cornsilk2
  cornsilk3
  cornsilk4
  cyan
  cyan1
  cyan2
  cyan3
  cyan4
  darkgoldenrod
  darkgoldenrod1
  darkgoldenrod2
  darkgoldenrod3
  darkgoldenrod4
  darkgreen
  darkkhaki
  darkolivegreen
  darkolivegreen1
  darkolivegreen2
  darkolivegreen3
  darkolivegreen4
  darkorange
  darkorange1
  darkorange2
  darkorange3
  darkorange4
  darkorchid
  darkorchid1
  darkorchid2
  darkorchid3
  darkorchid4
  darksalmon
  darkseagreen
  darkseagreen1
  darkseagreen2
  darkseagreen3
  darkseagreen4
  darkslateblue
  darkslategray
  darkslategray1
  darkslategray2
  darkslategray3
  darkslategray4
  darkturquoise
  darkviolet
  deeppink
  deeppink2
  deeppink3
  deeppink4
  deepskyblue1
  deepskyblue2
  deepskyblue3
  deepskyblue4
  dodgerblue1
  dodgerblue2
  dodgerblue3
  dodgerblue4
  firebrick
  firebrick1
  firebrick2
  firebrick3
  firebrick4
  floralwhite
  forestgreen
  gainsboro
  ghostwhite
  gold
  gold1
  gold2
  gold3
  gold4
  goldenrod
  goldenrod1
  goldenrod2
  goldenrod3
  goldenrod4
  gray
  gray0
  gray1
  gray10
  gray11
  gray12
  gray13
  gray14
  gray15
  gray16
  gray17
  gray18
  gray19
  gray2
  gray20
  gray21
  gray22
  gray23
  gray24
  gray25
  gray26
  gray27
  gray28
  gray29
  gray3
  gray30
  gray31
  gray32
  gray33
  gray34
  gray35
  gray36
  gray37
  gray38
  gray39
  gray4
  gray40
  gray41
  gray42
  gray43
  gray44
  gray45
  gray46
  gray47
  gray48
  gray49
  gray5
  gray50
  gray51
  gray52
  gray53
  gray54
  gray55
  gray56
  gray57
  gray58
  gray59
  gray6
  gray60
  gray61
  gray62
  gray63
  gray64
  gray65
  gray66
  gray67
  gray68
  gray69
  gray7
  gray70
  gray71
  gray72
  gray73
  gray74
  gray75
  gray76
  gray77
  gray78
  gray79
  gray8
  gray80
  gray81
  gray82
  gray83
  gray85
  gray86
  gray87
  gray88
  gray89
  gray9
  gray90
  gray91
  gray92
  gray93
  gray94
  gray95
  gray97
  gray98
  gray99
  green
  green1
  green2
  green3
  green4
  greenyellow
  honeydew
  honeydew2
  honeydew3
  honeydew4
  hotpink
  hotpink1
  hotpink2
  hotpink3
  hotpink4
  indianred
  indianred1
  indianred2
  indianred3
  indianred4
  ivory
  ivory2
  ivory3
  ivory4
  khaki
  khaki1
  khaki2
  khaki3
  khaki4
  lavender
  lavenderblush1
  lavenderblush2
  lavenderblush3
  lavenderblush4
  lawngreen
  lemonchiffon1
  lemonchiffon2
  lemonchiffon3
  lemonchiffon4
  lightblue
  lightblue1
  lightblue2
  lightblue3
  lightblue4
  lightcoral
  lightcyan
  lightcyan1
  lightcyan2
  lightcyan3
  lightcyan4
  lightgoldenrod
  lightgoldenrod1
  lightgoldenrod2
  lightgoldenrod3
  lightgoldenrod4
  lightgoldenrodyellow
  lightgray
  lightpink
  lightpink1
  lightpink2
  lightpink3
  lightpink4
  lightsalmon1
  lightsalmon2
  lightsalmon3
  lightsalmon4
  lightseagreen
  lightskyblue
  lightskyblue1
  lightskyblue2
  lightskyblue3
  lightskyblue4
  lightslateblue
  lightslategray
  lightsteelblue
  lightsteelblue1
  lightsteelblue2
  lightsteelblue3
  lightsteelblue4
  lightyellow
  lightyellow2
  lightyellow3
  lightyellow4
  limegreen
  linen
  magenta
  magenta1
  magenta2
  magenta3
  magenta4
  maroon
  maroon1
  maroon2
  maroon3
  maroon4
  matrablue
  matragray
  mediumaquamarine
  mediumorchid
  mediumorchid1
  mediumorchid2
  mediumorchid3
  mediumorchid4
  mediumpurple
  mediumpurple1
  mediumpurple2
  mediumpurple3
  mediumpurple4
  mediumseagreen
  mediumslateblue
  mediumspringgreen
  mediumturquoise
  mediumvioletred
  midnightblue
  mintcream
  mistyrose
  mistyrose2
  mistyrose3
  mistyrose4
  moccasin
  navajowhite1
  navajowhite2
  navajowhite3
  navajowhite4
  navyblue
  oldlace
  olivedrab
  olivedrab1
  olivedrab2
  olivedrab3
  olivedrab4
  orange
  orange1
  orange2
  orange3
  orange4
  orangered
  orangered1
  orangered2
  orangered3
  orangered4
  orchid
  orchid1
  orchid2
  orchid3
  orchid4
  palegoldenrod
  palegreen
  palegreen1
  palegreen2
  palegreen3
  palegreen4
  paleturquoise
  paleturquoise1
  paleturquoise2
  paleturquoise3
  paleturquoise4
  palevioletred
  palevioletred1
  palevioletred2
  palevioletred3
  palevioletred4
  papayawhip
  peachpuff
  peachpuff2
  peachpuff3
  peachpuff4
  peru
  pink
  pink1
  pink2
  pink3
  pink4
  plum
  plum1
  plum2
  plum3
  plum4
  powderblue
  purple
  purple1
  purple2
  purple3
  purple4
  red
  red1
  red2
  red3
  red4
  rosybrown
  rosybrown1
  rosybrown2
  rosybrown3
  rosybrown4
  royalblue
  royalblue1
  royalblue2
  royalblue3
  royalblue4
  saddlebrown
  salmon
  salmon1
  salmon2
  salmon3
  salmon4
  sandybrown
  seagreen
  seagreen1
  seagreen2
  seagreen3
  seagreen4
  seashell
  seashell2
  seashell3
  seashell4
  sienna
  sienna1
  sienna2
  sienna3
  sienna4
  skyblue
  skyblue1
  skyblue2
  skyblue3
  skyblue4
  slateblue
  slateblue1
  slateblue2
  slateblue3
  slateblue4
  slategray
  slategray1
  slategray2
  slategray3
  slategray4
  snow
  snow2
  snow3
  snow4
  springgreen
  springgreen2
  springgreen3
  springgreen4
  steelblue
  steelblue1
  steelblue2
  steelblue3
  steelblue4
  tan
  tan1
  tan2
  tan3
  tan4
  teal
  thistle
  thistle1
  thistle2
  thistle3
  thistle4
  tomato
  tomato1
  tomato2
  tomato3
  tomato4
  turquoise
  turquoise1
  turquoise2
  turquoise3
  turquoise4
  violet
  violetred
  violetred1
  violetred2
  violetred3
  violetred4
  wheat
  wheat1
  wheat2
  wheat3
  wheat4
  white
  whitesmoke
  yellow
  yellow1
  yellow2
  yellow3
  yellow4
  yellowgreen

For a listing organized by functional area, see the :ref:`apireference`

Sketch
Workplane
Assembly
Constraint

Shape
Vertex
Edge
occ_impl.shapes.Mixin1D
Wire
Face
Shell
occ_impl.shapes.Mixin3D
Solid
Compound
occ_impl.shapes.History
occ_impl.shapes.Op

Vector
Matrix
Plane
Location

Selector
NearestToPointSelector
BoxSelector
BaseDirSelector
ParallelDirSelector
DirectionSelector
PerpendicularDirSelector
TypeSelector
RadiusNthSelector
CenterNthSelector
DirectionMinMaxSelector
DirectionNthSelector
LengthNthSelector
AreaNthSelector
BinarySelector
AndSelector
SumSelector
SubtractSelector
InverseSelector
StringSyntaxSelector

base_cube = cq.Workplane("XY").rect(1.0, 1.0).extrude(1.0)
top_of_cube_plane = base_cube.faces(">Z").workplane()
debug(
    top_of_cube_plane,
    {
        "color": "yellow",
    },
)
debug(top_of_cube_plane.center, {"color": "blue"})

circle = top_of_cube_plane.circle(0.5)
debug(circle, {"color": "red"})

show_object(circle.extrude(1.0))

from cadquery import cqgi

user_script = ...
build_result = cqgi.parse(user_script).build()

from cadquery import cqgi

user_script = ...
build_result = cqgi.parse(user_script).build(
    build_parameters={"param": 2}, build_options={}
)

h = 1.0
  w = 2.0
  foo = "bar"


  def some_function():
      x = 1

model = cqgi.parse(user_script)

   # a dictionary of InputParameter objects
   parameters = model.metadata.parameters

# Load CQGI
  import cadquery.cqgi as cqgi
  import cadquery as cq

  # load the cadquery script
  model = cqgi.parse(open("example.py").read())

  # run the script and store the result (from the show_object call in the script)
  build_result = model.build()

  # test to ensure the process worked.
  if build_result.success:
      # loop through all the shapes returned and export to STL
      for i, result in enumerate(build_result.results):
          cq.exporters.export(result.shape, f"example_output{i}.stl")
  else:
      print(f"BUILD FAILED: {build_result.exception}")

"A block 80mm square x 30mm thick , with countersunk holes for M2 socket head cap screws
 at the corners, and a circular pocket 22mm in diameter in the middle for a bearing"

* The countersunk holes are spaced a uniform distance from the edges
* The circular pocket is in the center of the block, no matter how big the block is

1. Easily re-using features between objects
2. Storing objects using version control systems
3. Computing the differences between objects by using source control tools
4. Share objects on the Internet
5. Automate testing and generation by allowing objects to be built from within libraries

We strongly recommend installing `CQ-editor <https://github.com/CadQuery/CQ-editor>`_,
so that you can work along with these examples interactively. See :ref:`installation` for more info.

If you do, make sure to take these steps so that they work:

   1. import cadquery as cq
   2. add the line ``show_object(result)``  at the end. The samples below are autogenerated, but they use a different
      syntax than the models on the website need to be.

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

.. hlist::
    :columns: 2

    * :py:meth:`Workplane` **!**
    * :py:meth:`Workplane.box` **!**

# 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)
    )

.. hlist::
    :columns: 2

    * :py:meth:`Workplane.hole` **!**
    * :py:meth:`Workplane.box`
    * :py:meth:`Workplane.box`

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

.. hlist::
    :columns: 2

    * :py:meth:`Workplane.circle` **!**
    * :py:meth:`Workplane.rect` **!**
    * :py:meth:`Workplane.extrude` **!**
    * :py:meth:`Workplane`

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)
)

.. hlist::
    :columns: 2

    * :py:meth:`Workplane.threePointArc` **!**
    * :py:meth:`Workplane.lineTo` **!**
    * :py:meth:`Workplane.extrude`
    * :py:meth:`Workplane`

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)

.. hlist::
    :columns: 2

    * :py:meth:`Workplane.center` **!**
    * :py:meth:`Workplane`
    * :py:meth:`Workplane.circle`
    * :py:meth:`Workplane.rect`
    * :py:meth:`Workplane.extrude`

.. hlist::
    :columns: 2

    * :py:meth:`Workplane.pushPoints` **!**
    * :py:meth:`Workplane`
    * :py:meth:`Workplane.circle`
    * :py:meth:`Workplane.extrude`

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

.. hlist::
    :columns: 2

    * :py:meth:`Workplane.polygon` **!**
    * :py:meth:`Workplane.pushPoints`
    * :py:meth:`Workplane.box`

(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)

.. hlist::
    :columns: 2

    * :py:meth:`Workplane.polyline` **!**
    * :py:meth:`Workplane`
    * :py:meth:`Workplane.mirrorY`
    * :py:meth:`Workplane.extrude`

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, includeCurrent=True).close()
result = r.extrude(0.5)

.. hlist::
    :columns: 2

    * :py:meth:`Workplane.spline` **!**
    * :py:meth:`Workplane`
    * :py:meth:`Workplane.close`
    * :py:meth:`Workplane.lineTo`
    * :py:meth:`Workplane.extrude`

.. hlist::
    :columns: 2

    * :py:meth:`Workplane.hLine` **!**
    * :py:meth:`Workplane.vLine` **!**
    * :py:meth:`Workplane.hLineTo` **!**
    * :py:meth:`Workplane.mirrorY` **!**
    * :py:meth:`Workplane.mirrorX` **!**
    * :py:meth:`Workplane`
    * :py:meth:`Workplane.extrude`

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)

.. hlist::
    :columns: 2

    * :py:meth:`Workplane.moveTo`
    * :py:meth:`Workplane.lineTo`
    * :py:meth:`Workplane.threePointArc`
    * :py:meth:`Workplane.extrude`
    * :py:meth:`Workplane.mirror`
    * :py:meth:`Workplane.union`
    * :py:meth:`Workplane.rotate`

result = cq.Workplane("XY").line(0, 1).line(1, 0).line(0, -0.5).close().extrude(1)

result = result.mirror(result.faces(">X"), union=True)

.. hlist::
    :columns: 2

    * :py:meth:`Workplane.line`
    * :py:meth:`Workplane.close`
    * :py:meth:`Workplane.extrude`
    * :py:meth:`Workplane.faces`
    * :py:meth:`Workplane.mirror`
    * :py:meth:`Workplane.union`

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

.. hlist::
    :columns: 2

    * :py:meth:`Workplane.faces` **!**
    * :py:meth:`StringSyntaxSelector` **!**
    * :ref:`selector_reference` **!**
    * :py:meth:`Workplane.workplane`
    * :py:meth:`Workplane.box`
    * :py:meth:`Workplane`

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

.. hlist::
    :columns: 2

    * :py:meth:`Workplane.cutThruAll` **!**

    * :ref:`selector_reference` **!**
    * :py:meth:`Workplane.vertices` **!**
    * :py:meth:`Workplane.box`
    * :py:meth:`Workplane`
    * :py:meth:`StringSyntaxSelector` **!**

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

.. hlist::
    :columns: 2

    * :py:meth:`Workplane.extrude`
    * :ref:`selector_reference` **!**
    * :py:meth:`Workplane.box`
    * :py:meth:`Workplane`

result = (
    cq.Workplane("front")
    .circle(1)
    .extrude(10)  # make a cylinder
    # We want to make a second cylinder perpendicular to the first,
    # but we have no face to base the workplane off
    .copyWorkplane(
        # create a temporary object with the required workplane
        cq.Workplane("right", origin=(-5, 0, 0))
    )
    .circle(1)
    .extrude(10)
)

.. hlist::
    :columns: 2

    * :py:meth:`Workplane.copyWorkplane` **!**
    * :py:meth:`Workplane.circle`
    * :py:meth:`Workplane.extrude`
    * :py:meth:`Workplane`

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)
)

.. hlist::
    :columns: 2

    * :py:meth:`Workplane.transformed` **!**
    * :py:meth:`Workplane.box`
    * :py:meth:`Workplane.rect`
    * :py:meth:`Workplane.faces`

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

.. hlist::
    :columns: 2

    * :py:meth:`Workplane.rect` (forConstruction=True)
    * :ref:`selector_reference`
    * :py:meth:`Workplane.workplane`
    * :py:meth:`Workplane.box`
    * :py:meth:`Workplane.hole`
    * :py:meth:`Workplane`

result = cq.Workplane("front").box(2, 2, 2).shell(-0.1)

result = cq.Workplane("front").box(2, 2, 2).shell(0.1)

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

.. hlist::
    :columns: 2

    * :py:meth:`Workplane.shell` **!**
    * :ref:`selector_reference`
    * :py:meth:`Workplane.box`
    * :py:meth:`Workplane.faces`
    * :py:meth:`Workplane`

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)
)

.. hlist::
    :columns: 2

    * :py:meth:`Workplane.loft` **!**
    * :py:meth:`Workplane.box`
    * :py:meth:`Workplane.faces`
    * :py:meth:`Workplane.circle`
    * :py:meth:`Workplane.rect`

result = (
    cq.Workplane(origin=(20, 0, 0))
    .circle(2)
    .revolve(180, (-20, 0, 0), (-20, -1, 0))
    .center(-20, 0)
    .workplane()
    .rect(20, 4)
    .extrude("next")
)

skyscrapers_locations = [(-16, 1), (-8, 0), (7, 0.2), (17, -1.2)]
angles = iter([15, 0, -8, 10])
skyscrapers = (
    cq.Workplane()
    .pushPoints(skyscrapers_locations)
    .eachpoint(
        lambda loc: (
            cq.Workplane()
            .rect(5, 16)
            .workplane(offset=10)
            .ellipse(3, 8)
            .workplane(offset=10)
            .slot2D(20, 5, 90)
            .loft()
            .rotateAboutCenter((0, 0, 1), next(angles))
            .val()
            .located(loc)
        )
    )
)

result = (
    skyscrapers.transformed((0, -90, 0))
    .moveTo(15, 0)
    .rect(3, 3, forConstruction=True)
    .vertices()
    .circle(1)
    .cutBlind("last")
)

import cadquery as cq

sphere = cq.Workplane().sphere(5)
base = cq.Workplane(origin=(0, 0, -2)).box(12, 12, 10).cut(sphere).edges("|Z").fillet(2)
sphere_face = base.faces(">>X[2] and (not |Z) and (not |Y)").val()
base = base.faces("<Z").workplane().circle(2).extrude(10)

shaft = cq.Workplane().sphere(4.5).circle(1.5).extrude(20)

spherical_joint = (
    base.union(shaft)
    .faces(">X")
    .workplane(centerOption="CenterOfMass")
    .move(0, 4)
    .slot2D(10, 2, 90)
    .cutBlind(sphere_face)
    .workplane(offset=10)
    .move(0, 2)
    .circle(0.9)
    .extrude("next")
)

result = spherical_joint

If the wire you want to extrude cannot be fully projected on the target surface, the result will
be unpredictable. Furthermore, the algorithm in charge of finding the candidate faces does its search by counting all the faces intersected
by a line created from your wire center along your
extrusion direction. So make sure your wire can be projected on your target face to avoid
unexpected behaviour.

.. hlist::
    :columns: 3

    * :py:meth:`Workplane.cutBlind` **!**
    * :py:meth:`Workplane.rect`
    * :py:meth:`Workplane.ellipse`
    * :py:meth:`Workplane.workplane`
    * :py:meth:`Workplane.slot2D`
    * :py:meth:`Workplane.loft`
    * :py:meth:`Workplane.rotateAboutCenter`
    * :py:meth:`Workplane.transformed`
    * :py:meth:`Workplane.moveTo`
    * :py:meth:`Workplane.circle`

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)
)

.. hlist::
    :columns: 2

    * :py:meth:`Workplane.cboreHole` **!**
    * :py:meth:`Workplane.cskHole` **!**
    * :py:meth:`Workplane.box`
    * :py:meth:`Workplane.rect`
    * :py:meth:`Workplane.workplane`
    * :py:meth:`Workplane.vertices`
    * :py:meth:`Workplane.faces`
    * :py:meth:`Workplane`

original = cq.Workplane().polygon(5, 10).extrude(0.1).translate((0, 0, 2))
arc = cq.Workplane().polygon(5, 10).offset2D(1, "arc").extrude(0.1).translate((0, 0, 1))
intersection = cq.Workplane().polygon(5, 10).offset2D(1, "intersection").extrude(0.1)
result = original.add(arc).add(intersection)

result = (
    cq.Workplane()
    .box(4, 2, 0.5)
    .faces(">Z")
    .edges()
    .toPending()
    .offset2D(-0.25, forConstruction=True)
    .vertices()
    .cboreHole(0.125, 0.25, 0.125, depth=None)
)

.. hlist::
    :columns: 2

    * :py:meth:`Workplane.offset2D` **!**
    * :py:meth:`Workplane.cboreHole`
    * :py:meth:`Workplane.cskHole`
    * :py:meth:`Workplane.box`
    * :py:meth:`Workplane.polygon`
    * :py:meth:`Workplane.workplane`
    * :py:meth:`Workplane.vertices`
    * :py:meth:`Workplane.edges`
    * :py:meth:`Workplane.faces`
    * :py:meth:`Workplane`

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

.. hlist::
    :columns: 2

    * :py:meth:`Workplane.fillet` **!**
    * :py:meth:`Workplane.box`
    * :py:meth:`Workplane.edges`
    * :py:meth:`Workplane`

result = (
    cq.Workplane("XY")
    # create and tag the base workplane
    .box(10, 10, 10)
    .faces(">Z")
    .workplane()
    .tag("baseplane")
    # extrude a cylinder
    .center(-3, 0)
    .circle(1)
    .extrude(3)
    # to reselect the base workplane, simply
    .workplaneFromTagged("baseplane")
    # extrude a second cylinder
    .center(3, 0)
    .circle(1)
    .extrude(2)
)

result = (
    cq.Workplane("XY")
    # create a triangular prism and tag it
    .polygon(3, 5)
    .extrude(4)
    .tag("prism")
    # create a sphere that obscures the prism
    .sphere(10)
    # create features based on the prism's faces
    .faces("<X", tag="prism")
    .workplane()
    .circle(1)
    .cutThruAll()
    .faces(">X", tag="prism")
    .faces(">Y")
    .workplane()
    .circle(1)
    .cutThruAll()
)

.. hlist::
    :columns: 2

    * :py:meth:`Workplane.tag` **!**
    * :py:meth:`Workplane.getTagged` **!**
    * :py:meth:`Workplane.workplaneFromTagged` **!**
    * :py:meth:`Workplane.extrude`
    * :py:meth:`Workplane.cutThruAll`
    * :py:meth:`Workplane.circle`
    * :py:meth:`Workplane.faces`
    * :py:meth:`Workplane`

(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)
    )

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)

.. hlist::
    :columns: 2

    * :py:meth:`Workplane.split` **!**
    * :py:meth:`Workplane.box`
    * :py:meth:`Workplane.circle`
    * :py:meth:`Workplane.cutThruAll`
    * :py:meth:`Workplane.workplane`
    * :py:meth:`Workplane`

(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 = p.faces(">Z").workplane(centerOption="CenterOfMass").circle(3.0).extrude(2.0, True)

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

.. hlist::
    :columns: 2

    * :py:meth:`Workplane.extrude`
    * :py:meth:`Workplane.mirrorX`
    * :py:meth:`Workplane.threePointArc`
    * :py:meth:`Workplane.workplane`
    * :py:meth:`Workplane.vertices`
    * :py:meth:`Workplane.vLine`
    * :py:meth:`Workplane.faces`
    * :py:meth:`Workplane`

# 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 box
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 screw posts should be place.
p_screwpostID = 4.0  # Inner Diameter of the screw post holes, should be roughly screw diameter not including threads
p_screwpostOD = 10.0  # Outer Diameter of the screw posts.\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 = oshell.edges("|Z").fillet(p_sideRadius)
    oshell = oshell.edges("#Z").fillet(p_topAndBottomRadius)
else:
    oshell = oshell.edges("#Z").fillet(p_topAndBottomRadius)
    oshell = 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 = ishell.edges("|Z").fillet(p_sideRadius - p_thickness)

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

# make the screw posts
POSTWIDTH = p_outerWidth - 2.0 * p_screwpostInset
POSTLENGTH = p_outerLength - 2.0 * p_screwpostInset

box = (
    box.faces(">Z")
    .workplane(-p_thickness)
    .rect(POSTWIDTH, POSTLENGTH, forConstruction=True)
    .vertices()
    .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 screw holes
topOfLidCenters = (
    cutlip.faces(">Z")
    .workplane(centerOption="CenterOfMass")
    .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 = topOfLid.rotateAboutCenter((1, 0, 0), 180)

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

.. hlist::
    :columns: 3

    * :py:meth:`Workplane.circle`
    * :py:meth:`Workplane.rect`
    * :py:meth:`Workplane.extrude`
    * :py:meth:`Workplane.box`
    * :py:meth:`Workplane.all`
    * :py:meth:`Workplane.faces`
    * :py:meth:`Workplane.vertices`
    * :py:meth:`Workplane.edges`
    * :py:meth:`Workplane.workplane`
    * :py:meth:`Workplane.fillet`
    * :py:meth:`Workplane.cut`
    * :py:meth:`Workplane.union`
    * :py:meth:`Workplane.rotateAboutCenter`
    * :py:meth:`Workplane.cboreHole`
    * :py:meth:`Workplane.cskHole`
    * :py:meth:`Workplane.hole`

#####
# 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

from collections import namedtuple


# text_lines is a list of text lines.
# 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
    )
    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
    )
    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))

result = make_embossed_plate(text_lines, _cell_geometry)

# The dimensions of the model. These can be modified rather than changing the
# object's code directly.
width = 400
height = 500
thickness = 2

# Create a plate with two polygons cut through it
result = cq.Workplane("front").box(width, height, thickness)

h_sep = 60
for idx in range(4):
    result = (
        result.workplane(offset=1, centerOption="CenterOfBoundBox")
        .center(157, 210 - idx * h_sep)
        .moveTo(-23.5, 0)
        .circle(1.6)
        .moveTo(23.5, 0)
        .circle(1.6)
        .moveTo(-17.038896, -5.7)
        .threePointArc((-19.44306, -4.70416), (-20.438896, -2.3))
        .lineTo(-21.25, 2.3)
        .threePointArc((-20.25416, 4.70416), (-17.85, 5.7))
        .lineTo(17.85, 5.7)
        .threePointArc((20.25416, 4.70416), (21.25, 2.3))
        .lineTo(20.438896, -2.3)
        .threePointArc((19.44306, -4.70416), (17.038896, -5.7))
        .close()
        .cutThruAll()
    )

for idx in range(4):
    result = (
        result.workplane(offset=1, centerOption="CenterOfBoundBox")
        .center(157, -30 - idx * h_sep)
        .moveTo(-16.65, 0)
        .circle(1.6)
        .moveTo(16.65, 0)
        .circle(1.6)
        .moveTo(-10.1889, -5.7)
        .threePointArc((-12.59306, -4.70416), (-13.5889, -2.3))
        .lineTo(-14.4, 2.3)
        .threePointArc((-13.40416, 4.70416), (-11, 5.7))
        .lineTo(11, 5.7)
        .threePointArc((13.40416, 4.70416), (14.4, 2.3))
        .lineTo(13.5889, -2.3)
        .threePointArc((12.59306, -4.70416), (10.1889, -5.7))
        .close()
        .cutThruAll()
    )

h_sep4DB9 = 30
for idx in range(8):
    result = (
        result.workplane(offset=1, centerOption="CenterOfBoundBox")
        .center(91, 225 - idx * h_sep4DB9)
        .moveTo(-12.5, 0)
        .circle(1.6)
        .moveTo(12.5, 0)
        .circle(1.6)
        .moveTo(-6.038896, -5.7)
        .threePointArc((-8.44306, -4.70416), (-9.438896, -2.3))
        .lineTo(-10.25, 2.3)
        .threePointArc((-9.25416, 4.70416), (-6.85, 5.7))
        .lineTo(6.85, 5.7)
        .threePointArc((9.25416, 4.70416), (10.25, 2.3))
        .lineTo(9.438896, -2.3)
        .threePointArc((8.44306, -4.70416), (6.038896, -5.7))
        .close()
        .cutThruAll()
    )

for idx in range(4):
    result = (
        result.workplane(offset=1, centerOption="CenterOfBoundBox")
        .center(25, 210 - idx * h_sep)
        .moveTo(-23.5, 0)
        .circle(1.6)
        .moveTo(23.5, 0)
        .circle(1.6)
        .moveTo(-17.038896, -5.7)
        .threePointArc((-19.44306, -4.70416), (-20.438896, -2.3))
        .lineTo(-21.25, 2.3)
        .threePointArc((-20.25416, 4.70416), (-17.85, 5.7))
        .lineTo(17.85, 5.7)
        .threePointArc((20.25416, 4.70416), (21.25, 2.3))
        .lineTo(20.438896, -2.3)
        .threePointArc((19.44306, -4.70416), (17.038896, -5.7))
        .close()
        .cutThruAll()
    )

for idx in range(4):
    result = (
        result.workplane(offset=1, centerOption="CenterOfBoundBox")
        .center(25, -30 - idx * h_sep)
        .moveTo(-16.65, 0)
        .circle(1.6)
        .moveTo(16.65, 0)
        .circle(1.6)
        .moveTo(-10.1889, -5.7)
        .threePointArc((-12.59306, -4.70416), (-13.5889, -2.3))
        .lineTo(-14.4, 2.3)
        .threePointArc((-13.40416, 4.70416), (-11, 5.7))
        .lineTo(11, 5.7)
        .threePointArc((13.40416, 4.70416), (14.4, 2.3))
        .lineTo(13.5889, -2.3)
        .threePointArc((12.59306, -4.70416), (10.1889, -5.7))
        .close()
        .cutThruAll()
    )

for idx in range(8):
    result = (
        result.workplane(offset=1, centerOption="CenterOfBoundBox")
        .center(-41, 225 - idx * h_sep4DB9)
        .moveTo(-12.5, 0)
        .circle(1.6)
        .moveTo(12.5, 0)
        .circle(1.6)
        .moveTo(-6.038896, -5.7)
        .threePointArc((-8.44306, -4.70416), (-9.438896, -2.3))
        .lineTo(-10.25, 2.3)
        .threePointArc((-9.25416, 4.70416), (-6.85, 5.7))
        .lineTo(6.85, 5.7)
        .threePointArc((9.25416, 4.70416), (10.25, 2.3))
        .lineTo(9.438896, -2.3)
        .threePointArc((8.44306, -4.70416), (6.038896, -5.7))
        .close()
        .cutThruAll()
    )

for idx in range(4):
    result = (
        result.workplane(offset=1, centerOption="CenterOfBoundBox")
        .center(-107, 210 - idx * h_sep)
        .moveTo(-23.5, 0)
        .circle(1.6)
        .moveTo(23.5, 0)
        .circle(1.6)
        .moveTo(-17.038896, -5.7)
        .threePointArc((-19.44306, -4.70416), (-20.438896, -2.3))
        .lineTo(-21.25, 2.3)
        .threePointArc((-20.25416, 4.70416), (-17.85, 5.7))
        .lineTo(17.85, 5.7)
        .threePointArc((20.25416, 4.70416), (21.25, 2.3))
        .lineTo(20.438896, -2.3)
        .threePointArc((19.44306, -4.70416), (17.038896, -5.7))
        .close()
        .cutThruAll()
    )

for idx in range(4):
    result = (
        result.workplane(offset=1, centerOption="CenterOfBoundBox")
        .center(-107, -30 - idx * h_sep)
        .circle(14)
        .rect(24.7487, 24.7487, forConstruction=True)
        .vertices()
        .hole(3.2)
        .cutThruAll()
    )

for idx in range(8):
    result = (
        result.workplane(offset=1, centerOption="CenterOfBoundBox")
        .center(-173, 225 - idx * h_sep4DB9)
        .moveTo(-12.5, 0)
        .circle(1.6)
        .moveTo(12.5, 0)
        .circle(1.6)
        .moveTo(-6.038896, -5.7)
        .threePointArc((-8.44306, -4.70416), (-9.438896, -2.3))
        .lineTo(-10.25, 2.3)
        .threePointArc((-9.25416, 4.70416), (-6.85, 5.7))
        .lineTo(6.85, 5.7)
        .threePointArc((9.25416, 4.70416), (10.25, 2.3))
        .lineTo(9.438896, -2.3)
        .threePointArc((8.44306, -4.70416), (6.038896, -5.7))
        .close()
        .cutThruAll()
    )

for idx in range(4):
    result = (
        result.workplane(offset=1, centerOption="CenterOfBoundBox")
        .center(-173, -30 - idx * h_sep)
        .moveTo(-2.9176, -5.3)
        .threePointArc((-6.05, 0), (-2.9176, 5.3))
        .lineTo(2.9176, 5.3)
        .threePointArc((6.05, 0), (2.9176, -5.3))
        .close()
        .cutThruAll()
    )

import cadquery as cq
from math import sin, cos, pi, floor


# define the generating function
def hypocycloid(t, r1, r2):
    return (
        (r1 - r2) * cos(t) + r2 * cos(r1 / r2 * t - t),
        (r1 - r2) * sin(t) + r2 * sin(-(r1 / r2 * t - t)),
    )


def epicycloid(t, r1, r2):
    return (
        (r1 + r2) * cos(t) - r2 * cos(r1 / r2 * t + t),
        (r1 + r2) * sin(t) - r2 * sin(r1 / r2 * t + t),
    )


def gear(t, r1=4, r2=1):
    if (-1) ** (1 + floor(t / 2 / pi * (r1 / r2))) < 0:
        return epicycloid(t, r1, r2)
    else:
        return hypocycloid(t, r1, r2)


# create the gear profile and extrude it
result = (
    cq.Workplane("XY")
    .parametricCurve(lambda t: gear(t * 2 * pi, 6, 1))
    .twistExtrude(15, 90)
    .faces(">Z")
    .workplane()
    .circle(2)
    .cutThruAll()
)