CadQuery Class Summary 

cut(*toCut: Shape, tol: float | None = None) → Compound[source]

Remove the positional arguments from this Shape.

Parameters:

tol (float | None) – Fuzzy mode tolerance
toCut (Shape)

Return type:

fuse(*toFuse: Shape, glue: bool = False, tol: float | None = None) → Compound[source]

Fuse shapes together

Parameters:

toFuse (Shape)
glue (bool)
tol (float | None)

Return type:

intersect(*toIntersect: Shape, tol: float | None = None) → Compound[source]

Intersection of the positional arguments and this Shape.

Parameters:

tol (float | None) – Fuzzy mode tolerance
toIntersect (Shape)

Return type:

classmethod makeCompound(listOfShapes: Iterable[Shape]) → Compound[source]

Create a compound out of a list of shapes

Parameters:: listOfShapes (Iterable[Shape])
Return type:: Compound

classmethod makeText(text: str, size: float, height: float, font: str = 'Arial', fontPath: str | None = None, kind: Literal['regular', 'bold', 'italic'] = 'regular', halign: Literal['center', 'left', 'right'] = 'center', valign: Literal['center', 'top', 'bottom'] = 'center', position: Plane = Plane(origin=(0.0, 0.0, 0.0), xDir=(1.0, 0.0, 0.0), normal=(0.0, 0.0, 1.0))) → Shape[source]

Create a 3D text

Parameters:

text (str)
size (float)
height (float)
font (str)
fontPath (str | None)
kind (Literal['regular', 'bold', 'italic'])
halign (Literal['center', 'left', 'right'])
valign (Literal['center', 'top', 'bottom'])
position (Plane)

Return type:

remove(shape: Shape)[source]

Remove the specified shape.

Parameters:: shape (Shape)

siblings(shape: Shape, kind: Literal['Vertex', 'Edge', 'Wire', 'Face', 'Shell', 'Solid', 'CompSolid', 'Compound'], level: int = 1) → Compound[source]

Iterate over siblings, i.e. shapes within shape that share subshapes of kind with the elements of self.

Parameters:

shape (Shape)
kind (Literal['Vertex', 'Edge', 'Wire', 'Face', 'Shell', 'Solid', 'CompSolid', 'Compound'])
level (int)

Return type:

cadquery.Constraint: alias of ConstraintSpec

class cadquery.DirectionMinMaxSelector(vector: Vector, directionMax: bool = True, tolerance: float = 0.0001)[source]

Bases: CenterNthSelector

Selects objects closest or farthest in the specified direction.

Applicability:: All object types. for a vertex, its point is used. for all other kinds of objects, the center of mass of the object is used.

You can use the string shortcuts >(X|Y|Z) or <(X|Y|Z) if you want to select based on a cardinal direction.

For example this:

CQ(aCube).faces(DirectionMinMaxSelector((0, 0, 1), True))

Means to select the face having the center of mass farthest in the positive z direction, and is the same as:

CQ(aCube).faces(">Z")

Parameters:

vector (Vector)
directionMax (bool)
tolerance (float)

__init__(vector: Vector, directionMax: bool = True, tolerance: float = 0.0001)[source]

Parameters:

vector (Vector)
directionMax (bool)
tolerance (float)

class cadquery.DirectionSelector(vector: Vector, tolerance: float = 0.0001)[source]

Bases: BaseDirSelector

Selects objects aligned with the provided direction.

Applicability:: Linear Edges Planar Faces

Use the string syntax shortcut +/-(X|Y|Z) if you want to select based on a cardinal direction.

Example:

CQ(aCube).faces(DirectionSelector((0, 0, 1)))

selects faces with the normal in the z direction, and is equivalent to:

CQ(aCube).faces("+Z")

Parameters:

vector (Vector)
tolerance (float)

test(vec: Vector) → bool[source]

Test a specified vector. Subclasses override to provide other implementations

Parameters:: vec (Vector)
Return type:: bool

class cadquery.Edge(obj: TopoDS_Shape)[source]

Bases: Shape, Mixin1D

A trimmed curve that represents the border of a face

Parameters:: obj (TopoDS_Shape)

arcCenter() → Vector[source]

Center of an underlying circle or ellipse geometry.

Return type:: Vector

close() → Edge | Wire[source]

Close an Edge

Return type:: Edge | Wire

classmethod makeBezier(points: List[Vector]) → Edge[source]

Create a cubic Bézier Curve from the points.

Parameters:: points (List[Vector]) – a list of Vectors that represent the points. The edge will pass through the first and the last point, and the inner points are Bézier control points.
Returns:: An edge
Return type:: Edge

Makes an Ellipse centered at the provided point, having normal in the provided direction.

Parameters:

cls
x_radius (float) – x radius of the ellipse (along the x-axis of plane the ellipse should lie in)
y_radius (float) – y radius of the ellipse (along the y-axis of plane the ellipse should lie in)
pnt (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float]) – vector representing the center of the ellipse
dir (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float]) – vector representing the direction of the plane the ellipse should lie in
angle1 (float) – start angle of arc
angle2 (float) – end angle of arc (angle2 == angle1 return closed ellipse = default)
sense (Literal[-1, 1]) – clockwise (-1) or counter clockwise (1)
xdir (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float])

Returns:

an Edge

Return type:

Create a line between two points

Parameters:

v1 (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float]) – Vector that represents the first point
v2 (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float]) – Vector that represents the second point

Returns:

A linear edge between the two provided points

Return type:

classmethod makeSpline(listOfVector: List[Vector], tangents: Sequence[Vector] | None = None, periodic: bool = False, parameters: Sequence[float] | None = None, scale: bool = True, tol: float = 1e-06) → Edge[source]

Interpolate a spline through the provided points.

Parameters:

listOfVector (List[Vector]) – a list of Vectors that represent the points
tangents (Sequence[Vector] | None) – tuple of Vectors specifying start and finish tangent
periodic (bool) – creation of periodic curves
parameters (Sequence[float] | None) – the value of the parameter at each interpolation point. (The interpolated curve is represented as a vector-valued function of a scalar parameter.) If periodic == True, then len(parameters) must be len(intepolation points) + 1, otherwise len(parameters) must be equal to len(interpolation points).
scale (bool) – whether to scale the specified tangent vectors before interpolating. Each tangent is scaled, so it’s length is equal to the derivative of the Lagrange interpolated curve. I.e., set this to True, if you want to use only the direction of the tangent vectors specified by tangents, but not their magnitude.
tol (float) – tolerance of the algorithm (consult OCC documentation). Used to check that the specified points are not too close to each other, and that tangent vectors are not too short. (In either case interpolation may fail.)

Returns:

an Edge

Return type:

classmethod makeSplineApprox(listOfVector: List[Vector], tol: float = 0.001, smoothing: Tuple[float, float, float] | None = None, minDeg: int = 1, maxDeg: int = 6) → Edge[source]

Approximate a spline through the provided points.

Parameters:

listOfVector (List[Vector]) – a list of Vectors that represent the points
tol (float) – tolerance of the algorithm (consult OCC documentation).
smoothing (Tuple[float, float, float] | None) – optional tuple of 3 weights use for variational smoothing (default: None)
minDeg (int) – minimum spline degree. Enforced only when smothing is None (default: 1)
maxDeg (int) – maximum spline degree (default: 6)

Returns:

an Edge

Return type:

Makes a tangent arc from point v1, in the direction of v2 and ends at v3.

Parameters:

cls
v1 (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float]) – start vector
v2 (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float]) – tangent vector
v3 (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float]) – end vector

Returns:

an edge

Return type:

Makes a three point arc through the provided points

Parameters:

cls
v1 (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float]) – start vector
v2 (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float]) – middle vector
v3 (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float]) – end vector

Returns:

an edge object through the three points

Return type:

trim(u0: float | int, u1: float | int) → Edge[source]

Trim the edge in the parametric space to (u0, u1).

NB: this operation is done on the base geometry.

Parameters:

u0 (float | int)
u1 (float | int)

Return type:

class cadquery.Face(obj: TopoDS_Shape)[source]

Bases: Shape

a bounded surface that represents part of the boundary of a solid

Parameters:: obj (TopoDS_Shape)

Center() → Vector[source]

Returns:: The point of the center of mass of this Shape
Return type:: Vector

chamfer2D(d: float, vertices: Iterable[Vertex]) → Face[source]

Apply 2D chamfer to a face

Parameters:

d (float)
vertices (Iterable[Vertex])

Return type:

fillet2D(radius: float, vertices: Iterable[Vertex]) → Face[source]

Apply 2D fillet to a face

Parameters:

radius (float)
vertices (Iterable[Vertex])

Return type:

isoline(param: float | int, direction: Literal['u', 'v'] = 'v') → Edge[source]

Construct an isoline.

Parameters:

param (float | int)
direction (Literal['u', 'v'])

Return type:

isolines(params: Iterable[float | int], direction: Literal['u', 'v'] = 'v') → List[Edge][source]

Construct multiple isolines.

Parameters:

params (Iterable[float | int])
direction (Literal['u', 'v'])

Return type:

List[Edge]

classmethod makeFromWires(outerWire: Wire, innerWires: List[Wire] = []) → Face[source]

Makes a planar face from one or more wires

Parameters:

outerWire (Wire)
innerWires (List[Wire])

Return type:

classmethod makeNSidedSurface(edges: ~typing.Iterable[~cadquery.occ_impl.shapes.Edge | ~cadquery.occ_impl.shapes.Wire], constraints: ~typing.Iterable[~cadquery.occ_impl.shapes.Edge | ~cadquery.occ_impl.shapes.Wire | ~cadquery.occ_impl.geom.Vector | ~typing.Tuple[int | float, int | float] | ~typing.Tuple[int | float, int | float, int | float] | ~OCP.gp.gp_Pnt], continuity: ~OCP.GeomAbs.GeomAbs_Shape = <GeomAbs_Shape.GeomAbs_C0: 0>, degree: int = 3, nbPtsOnCur: int = 15, nbIter: int = 2, anisotropy: bool = False, tol2d: float = 1e-05, tol3d: float = 0.0001, tolAng: float = 0.01, tolCurv: float = 0.1, maxDeg: int = 8, maxSegments: int = 9) → Face[source]

Returns a surface enclosed by a closed polygon defined by ‘edges’ and ‘constraints’.

Parameters:

edges (list of edges or wires) – edges
constraints (list of points or edges) – constraints
continuity (GeomAbs_Shape) – OCC.Core.GeomAbs continuity condition
degree (int) – >=2
nbPtsOnCur (int) – number of points on curve >= 15
nbIter (int) – number of iterations >= 2
anisotropy (bool) – bool Anisotropy
tol2d (float) – 2D tolerance >0
tol3d (float) – 3D tolerance >0
tolAng (float) – angular tolerance
tolCurv (float) – tolerance for curvature >0
maxDeg (int) – highest polynomial degree >= 2
maxSegments (int) – greatest number of segments >= 2

Return type:

classmethod makeRuledSurface(edgeOrWire1: Edge, edgeOrWire2: Edge) → Face[source]
classmethod makeRuledSurface(edgeOrWire1: Wire, edgeOrWire2: Wire) → Face: makeRuledSurface(Edge|Wire,Edge|Wire) – Make a ruled surface Create a ruled surface out of two edges or wires. If wires are used then these must have the same number of edges

classmethod makeSplineApprox(points: List[List[Vector]], tol: float = 0.01, smoothing: Tuple[float, float, float] | None = None, minDeg: int = 1, maxDeg: int = 3) → Face[source]

Approximate a spline surface through the provided points.

Parameters:

points (List[List[Vector]]) – a 2D list of Vectors that represent the points
tol (float) – tolerance of the algorithm (consult OCC documentation).
smoothing (Tuple[float, float, float] | None) – optional tuple of 3 weights use for variational smoothing (default: None)
minDeg (int) – minimum spline degree. Enforced only when smothing is None (default: 1)
maxDeg (int) – maximum spline degree (default: 6)

Return type:

normalAt(u: float | int, v: float | int) → Tuple[Vector, Vector][source]

Computes the normal vector at the desired location on the face.

Returns:: a vector representing the direction
Parameters:: locationVector (a vector that lies on the surface.) – the location to compute the normal at. If none, the center of the face is used.
Return type:: Vector

Computes the normal vector at the desired location in the u,v parameter space.

Returns:

a vector representing the normal direction and the position

Parameters:

u – the u parametric location to compute the normal at.
v – the v parametric location to compute the normal at.
locationVector (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float] | None)

Return type:

Vector

normals(us: Iterable[float | int], vs: Iterable[float | int]) → Tuple[List[Vector], List[Vector]][source]

Computes the normal vectors at the desired locations in the u,v parameter space.

Returns:

a tuple of list of vectors representing the normal directions and the positions

Parameters:

us (Iterable[float | int]) – the u parametric locations to compute the normal at.
vs (Iterable[float | int]) – the v parametric locations to compute the normal at.

Return type:

Tuple[List[Vector], List[Vector]]

thicken(thickness: float) → Solid[source]

Return a thickened face

Parameters:: thickness (float)
Return type:: Solid

toArcs(tolerance: float = 0.001) → Face[source]

Approximate planar face with arcs and straight line segments.

Parameters:: tolerance (float) – Approximation tolerance.
Return type:: Face

toPln() → gp_Pln[source]

Convert this face to a gp_Pln.

Note the Location of the resulting plane may not equal the center of this face, however the resulting plane will still contain the center of this face.

Return type:: gp_Pln

Trim the face in the parametric space to (u0, u1).

NB: this operation is done on the base geometry.

Parameters:

u0 (float | int)
u1 (float | int)
v0 (float | int)
v1 (float | int)
tol (float | int)

Return type:

Bases: object

Location in 3D space. Depending on usage can be absolute or relative.

This class wraps the TopLoc_Location class from OCCT. It can be used to move Shape objects in both relative and absolute manner. It is the preferred type to locate objects in CQ.

Parameters:: t (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float])

__init__(T: gp_Trsf) → None[source]

__init__(T: TopLoc_Location) → None

__init__(t: Plane) → None

Location with translation t with respect to the original location.

Location with translation (x,y,z) and 3 rotation angles.

Location corresponding to the location of the Plane t.

Location corresponding to the angular location of the Plane t with translation v.

Location wrapping the low-level TopLoc_Location object t

Location wrapping the low-level gp_Trsf object t

Location with translation t and rotation around ax by angle
with respect to the original location.

Location with translation t and 3 rotation angles.

Parameters:: t (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float])
Return type:: None

__weakref__: list of weak references to the object (if defined)

toTuple() → Tuple[Tuple[float, float, float], Tuple[float, float, float]][source]

Convert the location to a translation, rotation tuple.

Return type:: Tuple[Tuple[float, float, float], Tuple[float, float, float]]

class cadquery.Matrix[source]

class cadquery.Matrix(matrix: gp_GTrsf | gp_Trsf)

class cadquery.Matrix(matrix: Sequence[Sequence[float]])

Bases: object

A 3d , 4x4 transformation matrix.

Used to move geometry in space.

The provided “matrix” parameter may be None, a gp_GTrsf, or a nested list of values.

If given a nested list, it is expected to be of the form:

[[m11, m12, m13, m14],
[m21, m22, m23, m24], [m31, m32, m33, m34]]

A fourth row may be given, but it is expected to be: [0.0, 0.0, 0.0, 1.0] since this is a transform matrix.

__getitem__(rc: Tuple[int, int]) → float[source]

Provide Matrix[r, c] syntax for accessing individual values. The row and column parameters start at zero, which is consistent with most python libraries, but is counter to gp_GTrsf(), which is 1-indexed.

Parameters:: rc (Tuple[int, int])
Return type:: float

__init__() → None[source]
__init__(matrix: gp_GTrsf | gp_Trsf) → None
__init__(matrix: Sequence[Sequence[float]]) → None

__repr__() → str[source]

Generate a valid python expression representing this Matrix

Return type:: str

__weakref__: list of weak references to the object (if defined)

transposed_list() → Sequence[float][source]

Needed by the cqparts gltf exporter

Return type:: Sequence[float]

class cadquery.NearestToPointSelector(pnt)[source]

Bases: Selector

Selects object nearest the provided point.

If the object is a vertex or point, the distance is used. For other kinds of shapes, the center of mass is used to to compute which is closest.

Applicability: All Types of Shapes

Example:

CQ(aCube).vertices(NearestToPointSelector((0, 1, 0)))

returns the vertex of the unit cube closest to the point x=0,y=1,z=0

__init__(pnt)[source]

filter(objectList: Sequence[Shape])[source]

Filter the provided list.

The default implementation returns the original list unfiltered.

Parameters:: objectList (list of OCCT primitives) – list to filter
Returns:: filtered list

class cadquery.ParallelDirSelector(vector: Vector, tolerance: float = 0.0001)[source]

Bases: BaseDirSelector

Selects objects parallel with the provided direction.

Applicability:: Linear Edges Planar Faces

Use the string syntax shortcut |(X|Y|Z) if you want to select based on a cardinal direction.

Example:

CQ(aCube).faces(ParallelDirSelector((0, 0, 1)))

selects faces with the normal parallel to the z direction, and is equivalent to:

CQ(aCube).faces("|Z")

Parameters:

vector (Vector)
tolerance (float)

test(vec: Vector) → bool[source]

Test a specified vector. Subclasses override to provide other implementations

Parameters:: vec (Vector)
Return type:: bool

class cadquery.PerpendicularDirSelector(vector: Vector, tolerance: float = 0.0001)[source]

Bases: BaseDirSelector

Selects objects perpendicular with the provided direction.

Applicability:: Linear Edges Planar Faces

Use the string syntax shortcut #(X|Y|Z) if you want to select based on a cardinal direction.

Example:

CQ(aCube).faces(PerpendicularDirSelector((0, 0, 1)))

selects faces with the normal perpendicular to the z direction, and is equivalent to:

CQ(aCube).faces("#Z")

Parameters:

vector (Vector)
tolerance (float)

test(vec: Vector) → bool[source]

Test a specified vector. Subclasses override to provide other implementations

Parameters:: vec (Vector)
Return type:: bool

class cadquery.Plane(origin: Tuple[float, float, float] | Vector, xDir: Tuple[float, float, float] | Vector | None = None, normal: Tuple[float, float, float] | Vector = (0, 0, 1))[source]

Bases: object

A 2D coordinate system in space

A 2D coordinate system in space, with the x-y axes on the plane, and a particular point as the origin.

A plane allows the use of 2D coordinates, which are later converted to global, 3d coordinates when the operations are complete.

Frequently, it is not necessary to create work planes, as they can be created automatically from faces.

Parameters:

origin (Tuple[float, float, float] | Vector)
xDir (Vector)
normal (Tuple[float, float, float] | Vector)

__eq__(other)[source]: Return self==value.

__hash__ = None

__init__(origin: Tuple[float, float, float] | Vector, xDir: Tuple[float, float, float] | Vector | None = None, normal: Tuple[float, float, float] | Vector = (0, 0, 1))[source]

Create a Plane with an arbitrary orientation

Parameters:

origin (Tuple[float, float, float] | Vector) – the origin in global coordinates
xDir (Tuple[float, float, float] | Vector | None) – an optional vector representing the xDirection.
normal (Tuple[float, float, float] | Vector) – the normal direction for the plane

Raises:

ValueError – if the specified xDir is not orthogonal to the provided normal

__ne__(other)[source]: Return self!=value.

__repr__()[source]: Return repr(self).

__weakref__: list of weak references to the object (if defined)

classmethod named(stdName: str, origin=(0, 0, 0)) → Plane[source]

Create a predefined Plane based on the conventional names.

Parameters:

stdName (string) – one of (XY|YZ|ZX|XZ|YX|ZY|front|back|left|right|top|bottom)
origin (3-tuple of the origin of the new plane, in global coordinates.) – the desired origin, specified in global coordinates

Return type:

Plane

Available named planes are as follows. Direction references refer to the global directions.

Name	xDir	yDir	zDir
XY	+x	+y	+z
YZ	+y	+z	+x
ZX	+z	+x	+y
XZ	+x	+z	-y
YX	+y	+x	-z
ZY	+z	+y	-x
front	+x	+y	+z
back	-x	+y	-z
left	+z	+y	-x
right	-z	+y	+x
top	+x	-z	+y
bottom	+x	+z	-y

rotated(rotate=(0, 0, 0))[source]

Returns a copy of this plane, rotated about the specified axes

Since the z axis is always normal the plane, rotating around Z will always produce a plane that is parallel to this one.

The origin of the workplane is unaffected by the rotation.

Rotations are done in order x, y, z. If you need a different order, manually chain together multiple rotate() commands.

Parameters:: rotate – Vector [xDegrees, yDegrees, zDegrees]
Returns:: a copy of this plane rotated as requested.

setOrigin2d(x, y)[source]

Set a new origin in the plane itself

Set a new origin in the plane itself. The plane’s orientation and xDrection are unaffected.

Parameters:

x (float) – offset in the x direction
y (float) – offset in the y direction

Returns:

void

The new coordinates are specified in terms of the current 2D system. As an example:

p = Plane.XY() p.setOrigin2d(2, 2) p.setOrigin2d(2, 2)

results in a plane with its origin at (x, y) = (4, 4) in global coordinates. Both operations were relative to local coordinates of the plane.

toLocalCoords(obj)[source]

Project the provided coordinates onto this plane

Parameters:: obj – an object or vector to convert
Returns:: an object of the same type, but converted to local coordinates

Most of the time, the z-coordinate returned will be zero, because most operations based on a plane are all 2D. Occasionally, though, 3D points outside of the current plane are transformed. One such example is Workplane.box(), where 3D corners of a box are transformed to orient the box in space correctly.

toWorldCoords(tuplePoint) → Vector[source]

Convert a point in local coordinates to global coordinates

Parameters:: tuplePoint (a 2 or three tuple of float. The third value is taken to be zero if not supplied.) – point in local coordinates to convert.
Returns:: a Vector in global coordinates
Return type:: Vector

class cadquery.Selector[source]

Bases: object

Filters a list of objects.

Filters must provide a single method that filters objects.

__weakref__: list of weak references to the object (if defined)

filter(objectList: Sequence[Shape]) → List[Shape][source]

Filter the provided list.

The default implementation returns the original list unfiltered.

Parameters:: objectList (list of OCCT primitives) – list to filter
Returns:: filtered list
Return type:: List[Shape]

class cadquery.Shape(obj: TopoDS_Shape)[source]

Bases: object

Represents a shape in the system. Wraps TopoDS_Shape.

Parameters:: obj (TopoDS_Shape)

Area() → float[source]

Returns:: The surface area of all faces in this Shape
Return type:: float

BoundingBox(tolerance: float | None = None) → BoundBox[source]

Create a bounding box for this Shape.

Parameters:: tolerance (float | None) – Tolerance value passed to BoundBox
Returns:: A BoundBox object for this Shape
Return type:: BoundBox

Center() → Vector[source]

Returns:: The point of the center of mass of this Shape
Return type:: Vector

CenterOfBoundBox(tolerance: float | None = None) → Vector[source]

Parameters:: tolerance (float | None) – Tolerance passed to the BoundingBox() method
Returns:: Center of the bounding box of this shape
Return type:: Vector

Closed() → bool[source]

Returns:: The closedness flag
Return type:: bool

static CombinedCenter(objects: Iterable[Shape]) → Vector[source]

Calculates the center of mass of multiple objects.

Parameters:: objects (Iterable[Shape]) – A list of objects with mass
Return type:: Vector

static CombinedCenterOfBoundBox(objects: List[Shape]) → Vector[source]

Calculates the center of a bounding box of multiple objects.

Parameters:: objects (List[Shape]) – A list of objects
Return type:: Vector

CompSolids() → List[CompSolid][source]

Returns:: All the compsolids in this Shape
Return type:: List[CompSolid]

Compounds() → List[Compound][source]

Returns:: All the compounds in this Shape
Return type:: List[Compound]

Edges() → List[Edge][source]

Returns:: All the edges in this Shape
Return type:: List[Edge]

Faces() → List[Face][source]

Returns:: All the faces in this Shape
Return type:: List[Face]

Shells() → List[Shell][source]

Returns:: All the shells in this Shape
Return type:: List[Shell]

Solids() → List[Solid][source]

Returns:: All the solids in this Shape
Return type:: List[Solid]

Vertices() → List[Vertex][source]

Returns:: All the vertices in this Shape
Return type:: List[Vertex]

Volume() → float[source]

Returns:: The volume of this Shape
Return type:: float

Wires() → List[Wire][source]

Returns:: All the wires in this Shape
Return type:: List[Wire]

__add__(other: Shape) → Shape[source]

Fuse self and other.

Parameters:: other (Shape)
Return type:: Shape

__eq__(other) → bool[source]

Return self==value.

Return type:: bool

__hash__() → int[source]

Return hash(self).

Return type:: int

__init__(obj: TopoDS_Shape)[source]

Parameters:: obj (TopoDS_Shape)

__iter__() → Iterator[Shape][source]

Iterate over subshapes.

Return type:: Iterator[Shape]

__mul__(other: Shape) → Shape[source]

Intersect self and other.

Parameters:: other (Shape)
Return type:: Shape

__sub__(other: Shape) → Shape[source]

Subtract other from self.

Parameters:: other (Shape)
Return type:: Shape

__truediv__(other: Shape) → Shape[source]

Split self with other.

Parameters:: other (Shape)
Return type:: Shape

__weakref__: list of weak references to the object (if defined)

ancestors(shape: Shape, kind: Literal['Vertex', 'Edge', 'Wire', 'Face', 'Shell', 'Solid', 'CompSolid', 'Compound']) → Compound[source]

Iterate over ancestors, i.e. shapes of same kind within shape that contain self.

Parameters:

shape (Shape)
kind (Literal['Vertex', 'Edge', 'Wire', 'Face', 'Shell', 'Solid', 'CompSolid', 'Compound'])

Return type:

classmethod cast(obj: TopoDS_Shape, forConstruction: bool = False) → Shape[source]

Returns the right type of wrapper, given a OCCT object

Parameters:

obj (TopoDS_Shape)
forConstruction (bool)

Return type:

static centerOfMass(obj: Shape) → Vector[source]

Calculates the center of ‘mass’ of an object.

Parameters:: obj (Shape) – Compute the center of mass of this object
Return type:: Vector

clean() → T[source]

Experimental clean using ShapeUpgrade

Parameters:: self (T)
Return type:: T

static computeMass(obj: Shape) → float[source]

Calculates the ‘mass’ of an object.

Parameters:: obj (Shape) – Compute the mass of this object
Return type:: float

copy(mesh: bool = False) → T[source]

Creates a new object that is a copy of this object.

Parameters:

self (T)
mesh (bool) – should I copy the triangulation too (default: False)

Returns:

a copy of the object

Return type:

T

cut(*toCut: Shape, tol: float | None = None) → Shape[source]

Remove the positional arguments from this Shape.

Parameters:

tol (float | None) – Fuzzy mode tolerance
toCut (Shape)

Return type:

distance(other: Shape) → float[source]

Minimal distance between two shapes

Parameters:: other (Shape)
Return type:: float

distances(*others: Shape) → Iterator[float][source]

Minimal distances to between self and other shapes

Parameters:: others (Shape)
Return type:: Iterator[float]

edges(selector: Selector | str | None = None) → Shape[source]

Select edges.

Parameters:: selector (Selector | str | None)
Return type:: Shape

export(fname: str, tolerance: float = 0.1, angularTolerance: float = 0.1, opt: Dict[str, Any] | None = None)[source]

Export Shape to file.

Parameters:

self (T)
fname (str)
tolerance (float)
angularTolerance (float)
opt (Dict[str, Any] | None)

exportBin(f: str | BytesIO) → bool[source]

Export this shape to a binary BREP file.

Parameters:: f (str | BytesIO)
Return type:: bool

exportBrep(f: str | BytesIO) → bool[source]

Export this shape to a BREP file

Parameters:: f (str | BytesIO)
Return type:: bool

exportStep(fileName: str, **kwargs) → IFSelect_ReturnStatus[source]

Export this shape to a STEP file.

kwargs is used to provide optional keyword arguments to configure the exporter.

Parameters:

fileName (str) – Path and filename for writing.
write_pcurves (bool) –
Enable or disable writing parametric curves to the STEP file. Default True.

If False, writes STEP file without pcurves. This decreases the size of the resulting STEP file.
precision_mode (int) – Controls the uncertainty value for STEP entities. Specify -1, 0, or 1. Default 0. See OCCT documentation.

Return type:

IFSelect_ReturnStatus

exportStl(fileName: str, tolerance: float = 0.001, angularTolerance: float = 0.1, ascii: bool = False, relative: bool = True, parallel: bool = True) → bool[source]

Exports a shape to a specified STL file.

Parameters:

fileName (str) – The path and file name to write the STL output to.
tolerance (float) – A linear deflection setting which limits the distance between a curve and its tessellation. Setting this value too low will result in large meshes that can consume computing resources. Setting the value too high can result in meshes with a level of detail that is too low. Default is 1e-3, which is a good starting point for a range of cases.
angularTolerance (float) – Angular deflection setting which limits the angle between subsequent segments in a polyline. Default is 0.1.
ascii (bool) – Export the file as ASCII (True) or binary (False) STL format. Default is binary.
relative (bool) – If True, tolerance will be scaled by the size of the edge being meshed. Default is True. Setting this value to True may cause large features to become faceted, or small features dense.
parallel (bool) – If True, OCCT will use parallel processing to mesh the shape. Default is True.

Return type:

bool

faces(selector: Selector | str | None = None) → Shape[source]

Select faces.

Parameters:: selector (Selector | str | None)
Return type:: Shape

Computes the intersections between the provided line and the faces of this Shape

Parameters:

point (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float]) – Base point for defining a line
axis (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float]) – Axis on which the line rests
tol (float) – Intersection tolerance
direction (Literal['AlongAxis', 'Opposite'] | None) – Valid values: “AlongAxis”, “Opposite”; If specified, will ignore all faces that are not in the specified direction including the face where the point lies if it is the case

Returns:

A list of intersected faces sorted by distance from point

fix() → T[source]

Try to fix shape if not valid

Parameters:: self (T)
Return type:: T

fuse(*toFuse: Shape, glue: bool = False, tol: float | None = None) → Shape[source]

Fuse the positional arguments with this Shape.

Parameters:

glue (bool) – Sets the glue option for the algorithm, which allows increasing performance of the intersection of the input shapes
tol (float | None) – Fuzzy mode tolerance
toFuse (Shape)

Return type:

geomType() → Literal['Vertex', 'Wire', 'Shell', 'Solid', 'Compound', 'PLANE', 'CYLINDER', 'CONE', 'SPHERE', 'TORUS', 'BEZIER', 'BSPLINE', 'REVOLUTION', 'EXTRUSION', 'OFFSET', 'OTHER', 'LINE', 'CIRCLE', 'ELLIPSE', 'HYPERBOLA', 'PARABOLA'][source]

Gets the underlying geometry type.

Implementations can return any values desired, but the values the user uses in type filters should correspond to these.

As an example, if a user does:

CQ(object).faces("%mytype")

The expectation is that the geomType attribute will return ‘mytype’

The return values depend on the type of the shape:

Vertex: always ‘Vertex’

Edge: LINE, CIRCLE, ELLIPSE, HYPERBOLA, PARABOLA, BEZIER,

BSPLINE, OFFSET, OTHER

Face: PLANE, CYLINDER, CONE, SPHERE, TORUS, BEZIER, BSPLINE,

REVOLUTION, EXTRUSION, OFFSET, OTHER

Solid: ‘Solid’

Shell: ‘Shell’

Compound: ‘Compound’

Wire: ‘Wire’

Returns:: A string according to the geometry type
Return type:: Literal[‘Vertex’, ‘Wire’, ‘Shell’, ‘Solid’, ‘Compound’, ‘PLANE’, ‘CYLINDER’, ‘CONE’, ‘SPHERE’, ‘TORUS’, ‘BEZIER’, ‘BSPLINE’, ‘REVOLUTION’, ‘EXTRUSION’, ‘OFFSET’, ‘OTHER’, ‘LINE’, ‘CIRCLE’, ‘ELLIPSE’, ‘HYPERBOLA’, ‘PARABOLA’]

hashCode() → int[source]

Returns a hashed value denoting this shape. It is computed from the TShape and the Location. The Orientation is not used.

Return type:: int

classmethod importBin(f: str | BytesIO) → Shape[source]

Import shape from a binary BREP file.

Parameters:: f (str | BytesIO)
Return type:: Shape

classmethod importBrep(f: str | BytesIO) → Shape[source]

Import shape from a BREP file

Parameters:: f (str | BytesIO)
Return type:: Shape

intersect(*toIntersect: Shape, tol: float | None = None) → Shape[source]

Intersection of the positional arguments and this Shape.

Parameters:

tol (float | None) – Fuzzy mode tolerance
toIntersect (Shape)

Return type:

isEqual(other: Shape) → bool[source]

Returns True if two shapes are equal, i.e. if they share the same TShape with the same Locations and Orientations. Also see isSame().

Parameters:: other (Shape)
Return type:: bool

isNull() → bool[source]

Returns true if this shape is null. In other words, it references no underlying shape with the potential to be given a location and an orientation.

Return type:: bool

isSame(other: Shape) → bool[source]

Returns True if other and this shape are same, i.e. if they share the same TShape with the same Locations. Orientations may differ. Also see isEqual()

Parameters:: other (Shape)
Return type:: bool

isValid() → bool[source]

Returns True if no defect is detected on the shape S or any of its subshapes. See the OCCT docs on BRepCheck_Analyzer::IsValid for a full description of what is checked.

Return type:: bool

locate(loc: Location) → T[source]

Apply a location in absolute sense to self.

Parameters:

self (T)
loc (Location)

Return type:

T

located(loc: Location) → T[source]

Apply a location in absolute sense to a copy of self.

Parameters:

self (T)
loc (Location)

Return type:

T

location() → Location[source]

Return the current location

Return type:: Location

static matrixOfInertia(obj: Shape) → List[List[float]][source]

Calculates the matrix of inertia of an object. Since the part’s density is unknown, this result is inertia/density with units of [1/length]. :param obj: Compute the matrix of inertia of this object

Parameters:: obj (Shape)
Return type:: List[List[float]]

mesh(tolerance: float, angularTolerance: float = 0.1)[source]

Generate triangulation if none exists.

Parameters:

tolerance (float)
angularTolerance (float)

Applies a mirror transform to this Shape. Does not duplicate objects about the plane.

Parameters:

mirrorPlane (Literal['XY', 'YX', 'XZ', 'ZX', 'YZ', 'ZY'] | ~cadquery.occ_impl.geom.Vector | ~typing.Tuple[int | float, int | float] | ~typing.Tuple[int | float, int | float, int | float]) – The direction of the plane to mirror about - one of ‘XY’, ‘XZ’ or ‘YZ’
basePointVector (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float]) – The origin of the plane to mirror about

Returns:

The mirrored shape

Return type:

move(loc: Location) → T

Apply a location in relative sense (i.e. update current location) to self.

Apply translation and rotation in relative sense (i.e. update current location) to self.

Apply a VectorLike in relative sense (i.e. update current location) to self.

Parameters:

self (T)
loc (Location)

Return type:

T

moved(loc1: Location, loc2: Location, *locs: Location) → T[source]

moved(locs: Sequence[Location]) → T

moved(loc: Location) → T

Apply a location in relative sense (i.e. update current location) to a copy of self.

Apply multiple locations.

Apply translation and rotation in relative sense to a copy of self.

Apply a VectorLike in relative sense to a copy of self.

Apply multiple VectorLikes in relative sense to a copy of self.

Parameters:

self (T)
loc (Location)

Return type:

T

Rotates a shape around an axis.

Parameters:

self (T)
startVector (either a 3-tuple or a Vector) – start point of rotation axis
endVector (either a 3-tuple or a Vector) – end point of rotation axis
angleDegrees (float) – angle to rotate, in degrees

Returns:

a copy of the shape, rotated

Return type:

T

scale(factor: float) → Shape[source]

Scales this shape through a transformation.

Parameters:: factor (float)
Return type:: Shape

shells(selector: Selector | str | None = None) → Shape[source]

Select shells.

Parameters:: selector (Selector | str | None)
Return type:: Shape

siblings(shape: Shape, kind: Literal['Vertex', 'Edge', 'Wire', 'Face', 'Shell', 'Solid', 'CompSolid', 'Compound'], level: int = 1) → Compound[source]

Iterate over siblings, i.e. shapes within shape that share subshapes of kind with self.

Parameters:

shape (Shape)
kind (Literal['Vertex', 'Edge', 'Wire', 'Face', 'Shell', 'Solid', 'CompSolid', 'Compound'])
level (int)

Return type:

solids(selector: Selector | str | None = None) → Shape[source]

Select solids.

Parameters:: selector (Selector | str | None)
Return type:: Shape

split(*splitters: Shape) → Shape[source]

Split this shape with the positional arguments.

Parameters:: splitters (Shape)
Return type:: Shape

toSplines(degree: int = 3, tolerance: float = 0.001, nurbs: bool = False) → T[source]

Approximate shape with b-splines of the specified degree.

Parameters:

self (T)
degree (int) – Maximum degree.
tolerance (float) – Approximation tolerance.
nurbs (bool) – Use rational splines.

Return type:

T

toVtkPolyData(tolerance: float | None = None, angularTolerance: float | None = None, normals: bool = False) → vtkPolyData[source]

Convert shape to vtkPolyData

Parameters:

tolerance (float | None)
angularTolerance (float | None)
normals (bool)

Return type:

vtkPolyData

transformGeometry(tMatrix: Matrix) → Shape[source]

Transforms this shape by tMatrix.

WARNING: transformGeometry will sometimes convert lines and circles to splines, but it also has the ability to handle skew and stretching transformations.

If your transformation is only translation and rotation, it is safer to use transformShape(), which doesn’t change the underlying type of the geometry, but cannot handle skew transformations.

Parameters:: tMatrix (Matrix) – The transformation matrix
Returns:: a copy of the object, but with geometry transformed instead of just rotated.
Return type:: Shape

transformShape(tMatrix: Matrix) → Shape[source]

Transforms this Shape by tMatrix. Also see transformGeometry().

Parameters:: tMatrix (Matrix) – The transformation matrix
Returns:: a copy of the object, transformed by the provided matrix, with all objects keeping their type
Return type:: Shape

Translates this shape through a transformation.

Parameters:

self (T)
vector (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float])

Return type:

T

vertices(selector: Selector | str | None = None) → Shape[source]

Select vertices.

Parameters:: selector (Selector | str | None)
Return type:: Shape

wires(selector: Selector | str | None = None) → Shape[source]

Select wires.

Parameters:: selector (Selector | str | None)
Return type:: Shape

class cadquery.Shell(obj: TopoDS_Shape)[source]

Bases: Shape

the outer boundary of a surface

Parameters:: obj (TopoDS_Shape)

classmethod makeShell(listOfFaces: Iterable[Face]) → Shell[source]

Makes a shell from faces.

Parameters:: listOfFaces (Iterable[Face])
Return type:: Shell

class cadquery.Sketch(parent: ~typing.Any = None, locs: ~typing.Iterable[~cadquery.occ_impl.geom.Location] = (<cadquery.occ_impl.geom.Location object>, ), obj: ~cadquery.occ_impl.shapes.Compound | None = None)[source]

Bases: object

2D sketch. Supports faces, edges and edges with constraints based construction.

Parameters:

parent (Any)
locs (List[Location])
obj (Compound | None)

__add__(other: Sketch) → T[source]

Fuse self and other.

Parameters:

self (T)
other (Sketch)

Return type:

T

__init__(parent: ~typing.Any = None, locs: ~typing.Iterable[~cadquery.occ_impl.geom.Location] = (<cadquery.occ_impl.geom.Location object>, ), obj: ~cadquery.occ_impl.shapes.Compound | None = None)[source]

Construct an empty sketch.

Parameters:

self (T)
parent (Any)
locs (Iterable[Location])
obj (Compound | None)

__iter__() → Iterator[Face][source]

Iterate over faces-locations combinations. If not faces are present iterate over edges:

Return type:: Iterator[Face]

__mul__(other: Sketch) → T[source]

Intersect self and other.

Parameters:

self (T)
other (Sketch)

Return type:

T

__sub__(other: Sketch) → T[source]

Subtract other from self.

Parameters:

self (T)
other (Sketch)

Return type:

T

__truediv__(other: Sketch) → T[source]

Split self with other.

Parameters:

self (T)
other (Sketch)

Return type:

T

__weakref__: list of weak references to the object (if defined)

add() → T[source]

Add selection to the underlying faces.

Parameters:: self (T)
Return type:: T

apply(f: Callable[[Iterable[Shape | Location]], Iterable[Shape | Location]])[source]

Apply a callable to all items at once.

Parameters:

self (T)
f (Callable[[Iterable[Shape | Location]], Iterable[Shape | Location]]) – Callable to be applied.

Returns:

Sketch object with f applied to all items.

Construct an arc.

Parameters:

self (T)
p1 (Vector | Tuple[int | float, int | float])
p2 (Vector | Tuple[int | float, int | float])
p3 (Vector | Tuple[int | float, int | float])
tag (str | None)
forConstruction (bool)

Return type:

T

assemble(mode: Literal['a', 's', 'i', 'c', 'r'] = 'a', tag: str | None = None) → T[source]

Assemble edges into faces.

Parameters:

self (T)
mode (Literal['a', 's', 'i', 'c', 'r'])
tag (str | None)

Return type:

T

bezier(pts: Iterable[Vector | Tuple[int | float, int | float]], tag: str | None = None, forConstruction: bool = False) → T[source]

Construct an bezier curve.

The edge will pass through the last points, and the inner points are bezier control points.

Parameters:

self (T)
pts (Iterable[Vector | Tuple[int | float, int | float]])
tag (str | None)
forConstruction (bool)

Return type:

T

chamfer(d: int | float) → T[source]

Add a chamfer based on current selection.

Parameters:

self (T)
d (int | float)

Return type:

T

circle(r: int | float, mode: Literal['a', 's', 'i', 'c', 'r'] = 'a', tag: str | None = None) → T[source]

Construct a circular face.

Parameters:

self (T)
r (int | float)
mode (Literal['a', 's', 'i', 'c', 'r'])
tag (str | None)

Return type:

T

clean() → T[source]

Remove internal wires.

Parameters:: self (T)
Return type:: T

close(tag: str | None = None) → T[source]

Connect last edge to the first one.

Parameters:

self (T)
tag (str | None)

Return type:

T

constrain(tag1: str, tag2: str, constraint: Literal['Fixed', 'FixedPoint', 'Coincident', 'Angle', 'Length', 'Distance', 'Radius', 'Orientation', 'ArcAngle'], arg: Any) → T[source]

constrain(tag: str, constraint: Literal['Fixed', 'FixedPoint', 'Coincident', 'Angle', 'Length', 'Distance', 'Radius', 'Orientation', 'ArcAngle'], arg: Any) → T

Add a constraint.

Parameters:

self (T)
tag (str)
constraint (Literal['Fixed', 'FixedPoint', 'Coincident', 'Angle', 'Length', 'Distance', 'Radius', 'Orientation', 'ArcAngle'])
arg (Any)

Return type:

T

copy() → T[source]

Create a partial copy of the sketch.

Parameters:: self (T)
Return type:: T

delete() → T[source]

Delete selected object.

Parameters:: self (T)
Return type:: T

distribute(n: int, start: int | float = 0, stop: int | float = 1, rotate: bool = True) → T[source]

Distribute locations along selected edges or wires.

Parameters:

self (T)
n (int)
start (int | float)
stop (int | float)
rotate (bool)

Return type:

T

each(callback: Callable[[Location], Face | Sketch | Compound], mode: Literal['a', 's', 'i', 'c', 'r'] = 'a', tag: str | None = None, ignore_selection: bool = False) → T[source]

Apply a callback on all applicable entities.

Parameters:

self (T)
callback (Callable[[Location], Face | Sketch | Compound])
mode (Literal['a', 's', 'i', 'c', 'r'])
tag (str | None)
ignore_selection (bool)

Return type:

T

edge(val: Edge, tag: str | None = None, forConstruction: bool = False) → T[source]

Add an edge to the sketch.

Parameters:

self (T)
val (Edge)
tag (str | None)
forConstruction (bool)

Return type:

T

edges(s: str | Selector | None = None, tag: str | None = None) → T[source]

Select edges.

Parameters:

self (T)
s (str | Selector | None)
tag (str | None)

Return type:

T

ellipse(a1: int | float, a2: int | float, angle: int | float = 0, mode: Literal['a', 's', 'i', 'c', 'r'] = 'a', tag: str | None = None) → T[source]

Construct an elliptical face.

Parameters:

self (T)
a1 (int | float)
a2 (int | float)
angle (int | float)
mode (Literal['a', 's', 'i', 'c', 'r'])
tag (str | None)

Return type:

T

export(fname: str, tolerance: float = 0.1, angularTolerance: float = 0.1, opt: Dict[str, Any] | None = None) → T[source]

Export Sketch to file.

Parameters:

self (T)
path – Filename.
tolerance (float) – the deflection tolerance, in model units. Default 0.1.
angularTolerance (float) – the angular tolerance, in radians. Default 0.1.
opt (Dict[str, Any] | None) – additional options passed to the specific exporter. Default None.
fname (str)

Returns:

Self.

Return type:

T

Construct a face from a wire or edges.

Parameters:

self (T)
b (Wire | Iterable[Edge] | Shape | T)
angle (int | float)
mode (Literal['a', 's', 'i', 'c', 'r'])
tag (str | None)
ignore_selection (bool)

Return type:

T

faces(s: str | Selector | None = None, tag: str | None = None) → T[source]

Select faces.

Parameters:

self (T)
s (str | Selector | None)
tag (str | None)

Return type:

T

fillet(d: int | float) → T[source]

Add a fillet based on current selection.

Parameters:

self (T)
d (int | float)

Return type:

T

filter(f: Callable[[Shape | Location], bool]) → T[source]

Filter items using a boolean predicate.

Parameters:

self (T)
f (Callable[[Shape | Location], bool]) – Callable to be used for filtering.

Returns:

Sketch object with filtered items.

Return type:

T

finalize() → Any[source]

Finish sketch construction and return the parent.

Return type:: Any

hull(mode: Literal['a', 's', 'i', 'c', 'r'] = 'a', tag: str | None = None) → T[source]

Generate a convex hull from current selection or all objects.

Parameters:

self (T)
mode (Literal['a', 's', 'i', 'c', 'r'])
tag (str | None)

Return type:

T

importDXF(filename: str, tol: float = 1e-06, exclude: List[str] = [], include: List[str] = [], angle: int | float = 0, mode: Literal['a', 's', 'i', 'c', 'r'] = 'a', tag: str | None = None) → T[source]

Import a DXF file and construct face(s)

Parameters:

self (T)
filename (str)
tol (float)
exclude (List[str])
include (List[str])
angle (int | float)
mode (Literal['a', 's', 'i', 'c', 'r'])
tag (str | None)

Return type:

T

invoke(f: Callable[[T], T] | Callable[[T], None] | Callable[[], None])[source]

Invoke a callable mapping Sketch to Sketch or None. Supports also callables that take no arguments such as breakpoint. Returns self if callable returns None.

Parameters:

self (T)
f (Callable[[T], T] | Callable[[T], None] | Callable[[], None]) – Callable to be invoked.

Returns:

Sketch object.

located(loc: Location) → T[source]

Create a partial copy of the sketch with a new location.

Parameters:

self (T)
loc (Location)

Return type:

T

map(f: Callable[[Shape | Location], Shape | Location])[source]

Apply a callable to every item separately.

Parameters:

self (T)
f (Callable[[Shape | Location], Shape | Location]) – Callable to be applied to every item separately.

Returns:

Sketch object with f applied to all items.

moved(loc: Location) → T[source]
moved(loc1: Location, loc2: Location, *locs: Location) → T
moved(locs: Sequence[Location]) → T
moved(x: int | float = 0, y: int | float = 0, z: int | float = 0, rx: int | float = 0, ry: int | float = 0, rz: int | float = 0) → T
moved(loc: Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float]) → T
moved(loc1: Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float], loc2: Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float], *locs: Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float]) → T
moved(loc: Sequence[Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float]]) → T: Create a partial copy of the sketch with moved _faces.

offset(d: int | float, mode: Literal['a', 's', 'i', 'c', 'r'] = 'a', tag: str | None = None) → T[source]

Offset selected wires or edges.

Parameters:

self (T)
d (int | float)
mode (Literal['a', 's', 'i', 'c', 'r'])
tag (str | None)

Return type:

T

parray(r: int | float, a1: int | float, da: int | float, n: int, rotate: bool = True) → T[source]

Generate a polar array of locations.

Parameters:

self (T)
r (int | float)
a1 (int | float)
da (int | float)
n (int)
rotate (bool)

Return type:

T

Construct a polygonal face.

Parameters:

self (T)
pts (Iterable[Vector | Tuple[int | float, int | float]])
angle (int | float)
mode (Literal['a', 's', 'i', 'c', 'r'])
tag (str | None)

Return type:

T

Set current selection to given locations or points.

Parameters:

self (T)
locs (Iterable[Location | Vector | Tuple[int | float, int | float]])
tag (str | None)

Return type:

T

rarray(xs: int | float, ys: int | float, nx: int, ny: int) → T[source]

Generate a rectangular array of locations.

Parameters:

self (T)
xs (int | float)
ys (int | float)
nx (int)
ny (int)

Return type:

T

rect(w: int | float, h: int | float, angle: int | float = 0, mode: Literal['a', 's', 'i', 'c', 'r'] = 'a', tag: str | None = None) → T[source]

Construct a rectangular face.

Parameters:

self (T)
w (int | float)
h (int | float)
angle (int | float)
mode (Literal['a', 's', 'i', 'c', 'r'])
tag (str | None)

Return type:

T

regularPolygon(r: int | float, n: int, angle: int | float = 0, mode: Literal['a', 's', 'i', 'c', 'r'] = 'a', tag: str | None = None) → T[source]

Construct a regular polygonal face.

Parameters:

self (T)
r (int | float)
n (int)
angle (int | float)
mode (Literal['a', 's', 'i', 'c', 'r'])
tag (str | None)

Return type:

T

replace() → T[source]

Replace the underlying faces with the selection.

Parameters:: self (T)
Return type:: T

reset() → T[source]

Reset current selection.

Parameters:: self (T)
Return type:: T

segment(p2: Vector | Tuple[int | float, int | float], tag: str | None = None, forConstruction: bool = False) → T[source]

segment(l: int | float, a: int | float, tag: str | None = None, forConstruction: bool = False) → T

Construct a segment.

Parameters:

self (T)
p1 (Vector | Tuple[int | float, int | float])
p2 (Vector | Tuple[int | float, int | float])
tag (str | None)
forConstruction (bool)

Return type:

T

select(*tags: str) → T[source]

Select based on tags.

Parameters:

self (T)
tags (str)

Return type:

T

slot(w: int | float, h: int | float, angle: int | float = 0, mode: Literal['a', 's', 'i', 'c', 'r'] = 'a', tag: str | None = None) → T[source]

Construct a slot-shaped face.

Parameters:

self (T)
w (int | float)
h (int | float)
angle (int | float)
mode (Literal['a', 's', 'i', 'c', 'r'])
tag (str | None)

Return type:

T

solve() → T[source]

Solve current constraints and update edge positions.

Parameters:: self (T)
Return type:: T

sort(key: Callable[[Shape | Location], Any]) → T[source]

Sort items using a callable.

Parameters:

self (T)
key (Callable[[Shape | Location], Any]) – Callable to be used for sorting.

Returns:

Sketch object with items sorted.

Return type:

T

spline(pts: Iterable[Vector | Tuple[int | float, int | float]], tag: str | None = None, forConstruction: bool = False) → T

Construct a spline edge.

Parameters:

self (T)
pts (Iterable[Vector | Tuple[int | float, int | float]])
tangents (Iterable[Vector | Tuple[int | float, int | float]] | None)
periodic (bool)
tag (str | None)
forConstruction (bool)

Return type:

T

subtract() → T[source]

Subtract selection from the underlying faces.

Parameters:: self (T)
Return type:: T

tag(tag: str) → T[source]

Tag current selection.

Parameters:

self (T)
tag (str)

Return type:

T

Construct a trapezoidal face.

Parameters:

self (T)
w (int | float)
h (int | float)
a1 (int | float)
a2 (float | None)
angle (int | float)
mode (Literal['a', 's', 'i', 'c', 'r'])
tag (str | None)

Return type:

T

val() → Shape | Location[source]

Return the first selected item, underlying compound or first edge.

Parameters:: self (T)
Return type:: Shape | Location

vals() → List[Shape | Location][source]

Return all selected items, underlying compound or all edges.

Parameters:: self (T)
Return type:: List[Shape | Location]

vertices(s: str | Selector | None = None, tag: str | None = None) → T[source]

Select vertices.

Parameters:

self (T)
s (str | Selector | None)
tag (str | None)

Return type:

T

wires(s: str | Selector | None = None, tag: str | None = None) → T[source]

Select wires.

Parameters:

self (T)
s (str | Selector | None)
tag (str | None)

Return type:

T

class cadquery.Solid(obj: TopoDS_Shape)[source]

Bases: Shape, Mixin3D

a single solid

Parameters:: obj (TopoDS_Shape)

Attempt to extrude the list of wires into a prismatic solid in the provided direction

Parameters:

outerWire (Wire) – the outermost wire
innerWires (List[Wire]) – a list of inner wires
vecNormal (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float]) – a vector along which to extrude the wires
taper (float | int) – taper angle, default=0

Returns:

a Solid object

Return type:

The wires must not intersect

Extruding wires is very non-trivial. Nested wires imply very different geometry, and there are many geometries that are invalid. In general, the following conditions must be met:

all wires must be closed
there cannot be any intersecting or self-intersecting wires
wires must be listed from outside in
more than one levels of nesting is not supported reliably

This method will attempt to sort the wires, but there is much work remaining to make this method reliable.

Creates a ‘twisted prism’ by extruding, while simultaneously rotating around the extrusion vector.

Though the signature may appear to be similar enough to extrudeLinear to merit combining them, the construction methods used here are different enough that they should be separate.

At a high level, the steps followed are:

accept a set of wires
create another set of wires like this one, but which are transformed and rotated
create a ruledSurface between the sets of wires
create a shell and compute the resulting object

Parameters:

outerWire (Wire) – the outermost wire
innerWires (List[Wire]) – a list of inner wires
vecCenter (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float]) – the center point about which to rotate. the axis of rotation is defined by vecNormal, located at vecCenter.
vecNormal (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float]) – a vector along which to extrude the wires
angleDegrees (float | int) – the angle to rotate through while extruding

Returns:

a Solid object

Return type:

innerShells() → List[Shell][source]

Returns inner shells.

Return type:: List[Shell]

classmethod interpPlate(surf_edges, surf_pts, thickness, degree=3, nbPtsOnCur=15, nbIter=2, anisotropy=False, tol2d=1e-05, tol3d=0.0001, tolAng=0.01, tolCurv=0.1, maxDeg=8, maxSegments=9) → Solid | Face[source]

Returns a plate surface that is ‘thickness’ thick, enclosed by ‘surf_edge_pts’ points, and going through ‘surf_pts’ points.

Parameters:

surf_edges – list of [x,y,z] float ordered coordinates or list of ordered or unordered wires
surf_pts – list of [x,y,z] float coordinates (uses only edges if [])
thickness – thickness may be negative or positive depending on direction, (returns 2D surface if 0)
degree – >=2
nbPtsOnCur – number of points on curve >= 15
nbIter – number of iterations >= 2
anisotropy – bool Anisotropy
tol2d – 2D tolerance >0
tol3d – 3D tolerance >0
tolAng – angular tolerance
tolCurv – tolerance for curvature >0
maxDeg – highest polynomial degree >= 2
maxSegments – greatest number of segments >= 2

Return type:

Solid | Face

static isSolid(obj: Shape) → bool[source]

Returns true if the object is a solid, false otherwise

Parameters:: obj (Shape)
Return type:: bool

classmethod makeBox(length,width,height,[pnt,dir]) -- Make a box located in pnt with the dimensions (length,width,height)[source]

By default pnt=Vector(0,0,0) and dir=Vector(0,0,1)

Parameters:

length (float)
width (float)
height (float)
pnt (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float])
dir (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float])

Return type:

Make a cone with given radii and height By default pnt=Vector(0,0,0), dir=Vector(0,0,1) and angle=360

Parameters:

radius1 (float)
radius2 (float)
height (float)
pnt (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float])
dir (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float])
angleDegrees (float)

Return type:

makeCylinder(radius,height,[pnt,dir,angle]) – Make a cylinder with a given radius and height By default pnt=Vector(0,0,0),dir=Vector(0,0,1) and angle=360

Parameters:

radius (float)
height (float)
pnt (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float])
dir (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float])
angleDegrees (float)

Return type:

classmethod makeLoft(listOfWire: List[Wire], ruled: bool = False) → Solid[source]

makes a loft from a list of wires The wires will be converted into faces when possible– it is presumed that nobody ever actually wants to make an infinitely thin shell for a real FreeCADPart.

Parameters:

listOfWire (List[Wire])
ruled (bool)

Return type:

classmethod makeSolid(shell: Shell) → Solid[source]

Makes a solid from a single shell.

Parameters:: shell (Shell)
Return type:: Solid

Make a sphere with a given radius By default pnt=Vector(0,0,0), dir=Vector(0,0,1), angle1=0, angle2=90 and angle3=360

Parameters:

radius (float)
pnt (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float])
dir (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float])
angleDegrees1 (float)
angleDegrees2 (float)
angleDegrees3 (float)

Return type:

makeTorus(radius1,radius2,[pnt,dir,angle1,angle2,angle]) – Make a torus with a given radii and angles By default pnt=Vector(0,0,0),dir=Vector(0,0,1),angle1=0 ,angle1=360 and angle=360

Parameters:

radius1 (float)
radius2 (float)
pnt (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float])
dir (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float])
angleDegrees1 (float)
angleDegrees2 (float)

Return type:

Make a wedge located in pnt By default pnt=Vector(0,0,0) and dir=Vector(0,0,1)

Parameters:

dx (float)
dy (float)
dz (float)
xmin (float)
zmin (float)
xmax (float)
zmax (float)
pnt (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float])
dir (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float])

Return type:

outerShell() → Shell[source]

Returns outer shell.

Return type:: Shell

Attempt to revolve the list of wires into a solid in the provided direction

Parameters:

outerWire (Wire) – the outermost wire
innerWires (List[Wire]) – a list of inner wires
angleDegrees (float, anything less than 360 degrees will leave the shape open) – the angle to revolve through.
axisStart (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float]) – the start point of the axis of rotation
axisEnd (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float]) – the end point of the axis of rotation

Returns:

a Solid object

Return type:

The wires must not intersect

all wires must be closed
there cannot be any intersecting or self-intersecting wires
wires must be listed from outside in
more than one levels of nesting is not supported reliably
the wire(s) that you’re revolving cannot be centered

This method will attempt to sort the wires, but there is much work remaining to make this method reliable.

classmethod sweep(face: Face, path: Wire | Edge, makeSolid: bool = True, isFrenet: bool = False, mode: Vector | Wire | Edge | None = None, transitionMode: Literal['transformed', 'round', 'right'] = 'transformed') → Shape[source]

classmethod sweep(outerWire: Wire, innerWires: List[Wire], path: Wire | Edge, makeSolid: bool = True, isFrenet: bool = False, mode: Vector | Wire | Edge | None = None, transitionMode: Literal['transformed', 'round', 'right'] = 'transformed') → Shape

Attempt to sweep the list of wires into a prismatic solid along the provided path

Parameters:

outerWire (Wire) – the outermost wire
innerWires (List[Wire]) – a list of inner wires
path (Wire | Edge) – The wire to sweep the face resulting from the wires over
makeSolid (bool) – return Solid or Shell (default True)
isFrenet (bool) – Frenet mode (default False)
mode (Vector | Wire | Edge | None) – additional sweep mode parameters
transitionMode (Literal['transformed', 'round', 'right']) – handling of profile orientation at C1 path discontinuities. Possible values are {‘transformed’,’round’, ‘right’} (default: ‘right’).

Returns:

a Solid object

Return type:

Multi section sweep. Only single outer profile per section is allowed.

Parameters:

profiles (Iterable[Wire | Face]) – list of profiles
path (Wire | Edge) – The wire to sweep the face resulting from the wires over
mode (Vector | Wire | Edge | None) – additional sweep mode parameters.
makeSolid (bool)
isFrenet (bool)

Returns:

a Solid object

Return type:

class cadquery.StringSyntaxSelector(selectorString)[source]

Bases: Selector

Filter lists objects using a simple string syntax. All of the filters available in the string syntax are also available ( usually with more functionality ) through the creation of full-fledged selector objects. see Selector and its subclasses

Filtering works differently depending on the type of object list being filtered.

Parameters:: selectorString – A two-part selector string, [selector][axis]
Returns:: objects that match the specified selector

*Modifiers* are ('|','+','-','<','>','%')

|:

parallel to ( same as ParallelDirSelector ). Can return multiple objects.

#:

perpendicular to (same as PerpendicularDirSelector )

+:

positive direction (same as DirectionSelector )

-:

negative direction (same as DirectionSelector )

>:

maximize (same as DirectionMinMaxSelector with directionMax=True)

<:

minimize (same as DirectionMinMaxSelector with directionMax=False )

%:

curve/surface type (same as TypeSelector)

*axisStrings* are: X,Y,Z,XY,YZ,XZ or (x,y,z) which defines an arbitrary direction

It is possible to combine simple selectors together using logical operations. The following operations are supported

and:

Logical AND, e.g. >X and >Y

or:

Logical OR, e.g. |X or |Y

not:

Logical NOT, e.g. not #XY

exc(ept):

Set difference (equivalent to AND NOT): |X exc >Z

Finally, it is also possible to use even more complex expressions with nesting and arbitrary number of terms, e.g.

(not >X[0] and #XY) or >XY[0]

Selectors are a complex topic: see Selectors Reference for more information

__init__(selectorString)[source]: Feed the input string through the parser and construct an relevant complex selector object

filter(objectList: Sequence[Shape])[source]

Filter give object list through th already constructed complex selector object

Parameters:: objectList (Sequence[Shape])

class cadquery.TypeSelector(typeString: str)[source]

Bases: Selector

Selects objects having the prescribed geometry type.

Applicability:: Faces: PLANE, CYLINDER, CONE, SPHERE, TORUS, BEZIER, BSPLINE, REVOLUTION, EXTRUSION, OFFSET, OTHER Edges: LINE, CIRCLE, ELLIPSE, HYPERBOLA, PARABOLA, BEZIER, BSPLINE, OFFSET, OTHER

You can use the string selector syntax. For example this:

CQ(aCube).faces(TypeSelector("PLANE"))

will select 6 faces, and is equivalent to:

CQ(aCube).faces("%PLANE")

Parameters:: typeString (str)

__init__(typeString: str)[source]

Parameters:: typeString (str)

filter(objectList: Sequence[Shape]) → List[Shape][source]

Filter the provided list.

The default implementation returns the original list unfiltered.

Parameters:: objectList (list of OCCT primitives) – list to filter
Returns:: filtered list
Return type:: List[Shape]

class cadquery.Vector(x: float, y: float, z: float)[source]

class cadquery.Vector(x: float, y: float)

class cadquery.Vector(v: Vector)

class cadquery.Vector(v: Sequence[float])

class cadquery.Vector(v: gp_Vec | gp_Pnt | gp_Dir | gp_XYZ)

class cadquery.Vector

Bases: object

Create a 3-dimensional vector

Parameters:: args – a 3D vector, with x-y-z parts.

you can either provide:

nothing (in which case the null vector is return)
a gp_Vec
a vector ( in which case it is copied )
a 3-tuple
a 2-tuple (z assumed to be 0)
three float values: x, y, and z
two float values: x,y

Center() → Vector[source]

Return the vector itself

The center of myself is myself. Provided so that vectors, vertices, and other shapes all support a common interface, when Center() is requested for all objects on the stack.

Return type:: Vector

__eq__(other: Vector) → bool[source]

Return self==value.

Parameters:: other (Vector)
Return type:: bool

__hash__ = None

__init__(x: float, y: float, z: float) → None[source]
__init__(x: float, y: float) → None
__init__(v: Vector) → None
__init__(v: Sequence[float]) → None
__init__(v: gp_Vec | gp_Pnt | gp_Dir | gp_XYZ) → None
__init__() → None

__repr__() → str[source]

Return repr(self).

Return type:: str

__str__() → str[source]

Return str(self).

Return type:: str

__weakref__: list of weak references to the object (if defined)

multiply(scale: float) → Vector[source]

Return a copy multiplied by the provided scalar

Parameters:: scale (float)
Return type:: Vector

normalized() → Vector[source]

Return a normalized version of this vector

Return type:: Vector

projectToLine(line: Vector) → Vector[source]

Returns a new vector equal to the projection of this Vector onto the line represented by Vector <line>

Parameters:

args – Vector
line (Vector)

Return type:

Vector

Returns the projected vector.

projectToPlane(plane: Plane) → Vector[source]

Vector is projected onto the plane provided as input.

Parameters:

args – Plane object
plane (Plane)

Return type:

Vector

Returns the projected vector.

class cadquery.Vertex(obj: TopoDS_Shape, forConstruction: bool = False)[source]

Bases: Shape

A Single Point in Space

Parameters:

obj (TopoDS_Shape)
forConstruction (bool)

Center() → Vector[source]

The center of a vertex is itself!

Return type:: Vector

__init__(obj: TopoDS_Shape, forConstruction: bool = False)[source]

Create a vertex

Parameters:

obj (TopoDS_Shape)
forConstruction (bool)

class cadquery.Wire(obj: TopoDS_Shape)[source]

Bases: Shape, Mixin1D

A series of connected, ordered Edges, that typically bounds a Face

Parameters:: obj (TopoDS_Shape)

Vertices() → List[Vertex][source]

Ordered list of vertices of the wire.

Return type:: List[Vertex]

__iter__() → Iterator[Edge][source]

Iterate over edges in an ordered way.

Return type:: Iterator[Edge]

classmethod assembleEdges(listOfEdges: Iterable[Edge]) → Wire[source]

Attempts to build a wire that consists of the edges in the provided list

Parameters:

cls
listOfEdges (Iterable[Edge]) – a list of Edge objects. The edges are not to be consecutive.

Returns:

a wire with the edges assembled

Return type:

BRepBuilderAPI_MakeWire::Error() values:

BRepBuilderAPI_WireDone = 0
BRepBuilderAPI_EmptyWire = 1
BRepBuilderAPI_DisconnectedWire = 2
BRepBuilderAPI_NonManifoldWire = 3

chamfer2D(d: float, vertices: Iterable[Vertex]) → Wire[source]

Apply 2D chamfer to a wire

Parameters:

d (float)
vertices (Iterable[Vertex])

Return type:

close() → Wire[source]

Close a Wire

Return type:: Wire

classmethod combine(listOfWires: Iterable[Wire | Edge], tol: float = 1e-09) → List[Wire][source]

Attempt to combine a list of wires and edges into a new wire.

Parameters:

cls
listOfWires (Iterable[Wire | Edge])
tol (float) – default 1e-9

Returns:

List[Wire]

Return type:

List[Wire]

fillet(radius: float, vertices: Iterable[Vertex] | None = None) → Wire[source]

Apply 2D or 3D fillet to a wire

Parameters:

radius (float) – the radius of the fillet, must be > zero
vertices (Iterable[Vertex] | None) – the vertices to delete (where the fillet will be applied). By default all vertices are deleted except ends of open wires.

Returns:

A wire with filleted corners

Return type:

fillet2D(radius: float, vertices: Iterable[Vertex]) → Wire[source]

Apply 2D fillet to a wire

Parameters:

radius (float)
vertices (Iterable[Vertex])

Return type:

Makes a Circle centered at the provided point, having normal in the provided direction

Parameters:

radius (float) – floating point radius of the circle, must be > 0
center (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float]) – vector representing the center of the circle
normal (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float]) – vector representing the direction of the plane the circle should lie in

Return type:

Makes an Ellipse centered at the provided point, having normal in the provided direction

Parameters:

x_radius (float) – floating point major radius of the ellipse (x-axis), must be > 0
y_radius (float) – floating point minor radius of the ellipse (y-axis), must be > 0
center (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float]) – vector representing the center of the circle
normal (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float]) – vector representing the direction of the plane the circle should lie in
angle1 (float) – start angle of arc
angle2 (float) – end angle of arc
rotation_angle (float) – angle to rotate the created ellipse / arc
xDir (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float])
closed (bool)

Return type:

Make a helix with a given pitch, height and radius By default a cylindrical surface is used to create the helix. If the fourth parameter is set (the apex given in degree) a conical surface is used instead’

Parameters:

pitch (float)
height (float)
radius (float)
center (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float])
dir (Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float])
angle (float)
lefthand (bool)

Return type:

Construct a polygonal wire from points.

Parameters:

listOfVertices (Iterable[Vector | Tuple[int | float, int | float] | Tuple[int | float, int | float, int | float]])
forConstruction (bool)
close (bool)

Return type: