# Assemblies¶

## Assembly tutorial¶

The purpose of this section is to demonstrate how to use the assembly and constraints functionality to build a realistic model. It will be a enclosure door assembly made out of 20x20 v-slot profiles.

### Defining parameters¶

We want to start with defining the model parameters to allow for easy dimension changes later:

import cadquery as cq

# Parameters
H = 400
W = 200
D = 350

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

SLOT_D = 5
PANEL_T = 3

HANDLE_D = 20
HANDLE_L = 50
HANDLE_W = 4


It is interesting to note that the v-slot profile is imported from a DXF file. This way it is very easy to change to other aluminum extrusion type, e.g. Item or Bosch. Vendors usually provide DXF files.

### Defining reusable components¶

Next we want to define functions generating the assembly components based on the specified parameters.

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


### Initial assembly¶

Next we want to instantiate all the components and add them to the assembly.

# define the elements
door = (
cq.Assembly()
make_panel(W + SLOT_D, H + SLOT_D, PANEL_T, SLOT_D),
name="panel",
color=cq.Color(0, 0, 1, 0.2),
)
make_handle(HANDLE_D, HANDLE_L, HANDLE_W),
name="handle",
color=cq.Color("yellow"),
)
)


### Constraints definition¶

Then we want to define all the constraints

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


Should you need to do something unusual that is not possible with the string based selectors (e.g. use cadquery.selectors.BoxSelector or a user-defined selector class), it is possible to pass cadquery.Shape objects to the cadquery.Assembly.constrain() method directly. For example, the above

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


is equivalent to

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


This method requires a cadquery.Shape object, so remember to use the cadquery.Workplane.val() method to pass a single cadquery.Shape and not the whole cadquery.Workplane object.

### Final result¶

Below is the complete code including the final solve step.

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()
make_panel(W + 2*SLOT_D, H + 2*SLOT_D, PANEL_T, SLOT_D),
name="panel",
color=cq.Color(0, 0, 1, 0.2),
)
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')


### Data export¶

The resulting assembly can be exported as a STEP file or in a internal OCCT XML format.

STEP can be loaded in all CAD tool, e.g. in FreeCAD and the XML be used in other applications using OCCT.

 1 2  door.save('door.step') door.save('door.xml') 

In the case of STEP colors are preserved but not transparency.

## Object locations¶

Objects can be added to an assembly with initial locations supplied, such as:

import cadquery as cq

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

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

show_object(assy)


As an alternative to the user calculating locations, constraints and the method solve() can be used to position objects in an assembly.

If initial locations and the method solve() are used the solver will overwrite these initial locations with it’s solution, however initial locations can still affect the final solution. In an underconstrained system the solver may not move an object if it does not contribute to the cost function, or if multiple solutions exist (ie. multiple instances where the cost function is at a minimum) initial locations can cause the solver to converge on one particular solution. For very complicated assemblies setting approximately correct initial locations can also reduce the computational time requred.

## Constraints¶

Constraints are often a better representation of the real world relationship the user wants to model than directly supplying locations. In the above example the real world relationship is that the bottom face of each cone should touch, which can be modelled with a Plane constraint. When the user provides explicit locations (instead of constraints) then they are also reponsible for updating them when, for example, the location of cone1 changes.

When at least one constraint is supplied and the method solve() is run, an optimization problem is set up. Each constraint provides a cost function that depends on the position and orientation (represented by a Location) of the two objects specified when creating the constraint. The solver varies the location of the assembly’s children and attempts to minimize the sum of all cost functions. Hence by reading the formulae of the cost functions below, you can understand exactly what each constraint does.

### Point¶

The Point constraint is a frequently used constraint that minimizes the distance between two points. Some example uses are centering faces or aligning verticies, but it is also useful with dummy vertices to create offsets between two parts.

The cost function is:

$( param - \lvert \vec{ c_1 } - \vec{ c_2 } \rvert ) ^2$

Where:

• $$param$$ is the parameter of the constraint, which defaults to 0,

• $$\vec{ c_i }$$ is the center of the ith object, and

• $$\lvert \vec{ v } \rvert$$ is the modulus of $$\vec{ v }$$, ie. the length of $$\vec{ v }$$.

When creating a Point constraint, the param argument can be used to specify a desired offset between the two centers. This offset does not have a direction associated with it, if you want to specify an offset in a specific direction then you should use a dummy Vertex.

The Point constraint uses the Center() to find the center of the argument. Hence it will work with all subclasses of Shape.

import cadquery as cq

# Use the Point constraint to position boxes relative to an arc
box = cq.Workplane().box(1, 1, 1)

assy = cq.Assembly()

# position the red box on the center of the arc
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.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.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.constrain(
"line", cq.Vertex.makeVertex(*position1.toTuple()), "box3", box.val(), "Point",
)

assy.solve()
show_object(assy)


### Axis¶

The Axis constraint minimizes the angle between two vectors. It is frequently used to align faces and control the rotation of an object.

The cost function is:

$( k_{ dir } \times ( param - \vec{ d_1 } \angle \vec{ d_2 } ) ^2$

Where:

• $$k_{ dir }$$ is a scaling factor for directional constraints,

• $$param$$ is the parameter of the constraint, which defaults to $$\pi$$ radians,

• $$\vec{d_i}$$ is the direction created from the ith object argument as described below, and

• $$\vec{ d_1 } \angle \vec{ d_2 }$$ is the angle in radians between $$\vec{ d_1 }$$ and $$\vec{ d_2 }$$.

The argument param defaults to $$\pi$$ radians, which sets the two directions opposite to each other. This represents what is often called a “mate” relationship, where the external faces of two objects touch.

import cadquery as cq

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

assy = cq.Assembly()

If the param argument is set to zero, then the two objects will point in the same direction. This is often used when one object goes through another, such as a pin going into a hole in a plate: