trimesh.path package

Submodules

trimesh.path.arc module

trimesh.path.arc.arc_center(points)

Given three points on an arc find: center, radius, normal, and angle.

This uses the fact that the intersection of the perp bisectors of the segments between the control points is the center of the arc.

points(3, dimension) float

Points in space, where dimension is either 2 or 3

Returns
resultdict
Has keys:

‘center’: (d,) float, cartesian center of the arc ‘radius’: float, radius of the arc ‘normal’: (3,) float, the plane normal. ‘angle’: (2,) float, angle of start and end, in radians ‘span’ : float, angle swept by the arc, in radians

trimesh.path.arc.discretize_arc(points, close=False, scale=1.0)

Returns a version of a three point arc consisting of line segments.

points(3, d) float

Points on the arc where d in [2,3]

closeboolean

If True close the arc into a circle

scalefloat

What is the approximate overall drawing scale Used to establish order of magnitude for precision

Returns
discrete(m, d) float

Connected points in space

trimesh.path.arc.to_threepoint(center, radius, angles=None)

For 2D arcs, given a center and radius convert them to three points on the arc.

Parameters
center(2,) float

Center point on the plane

radiusfloat

Radius of arc

angles(2,) float

Angles in radians for start and end angle if not specified, will default to (0.0, pi)

Returns
three(3, 2) float

Arc control points

trimesh.path.creation module

trimesh.path.creation.box_outline(extents=None, transform=None, **kwargs)

Return a cuboid.

Parameters
extentsfloat, or (3,) float

Edge lengths

transform: (4, 4) float

Transformation matrix

**kwargs:

passed to Trimesh to create box

Returns
geometrytrimesh.Path3D

Path outline of a cuboid geometry

trimesh.path.creation.circle(radius=None, center=None, **kwargs)

Create a Path2D containing a single or multiple rectangles with the specified bounds.

Parameters
bounds(2, 2) float, or (m, 2, 2) float

Minimum XY, Maximum XY

Returns
rectPath2D

Path containing specified rectangles

trimesh.path.creation.circle_pattern(pattern_radius, circle_radius, count, center=[0.0, 0.0], angle=None, **kwargs)

Create a Path2D representing a circle pattern.

Parameters
pattern_radiusfloat

Radius of circle centers

circle_radiusfloat

The radius of each circle

countint

Number of circles in the pattern

center(2,) float

Center of pattern

anglefloat

If defined pattern will span this angle If None, pattern will be evenly spaced

Returns
patterntrimesh.path.Path2D

Path containing circular pattern

trimesh.path.creation.rectangle(bounds, **kwargs)

Create a Path2D containing a single or multiple rectangles with the specified bounds.

Parameters
bounds(2, 2) float, or (m, 2, 2) float

Minimum XY, Maximum XY

Returns
rectPath2D

Path containing specified rectangles

trimesh.path.curve module

trimesh.path.curve.binomial(n)

Return all binomial coefficients for a given order.

For n > 5, scipy.special.binom is used, below we hardcode to avoid the scipy.special dependency.

Parameters
nint

Order

Returns
binom(n + 1,) int

Binomial coefficients of a given order

trimesh.path.curve.discretize_bezier(points, count=None, scale=1.0)
Parameters
points(order, dimension) float

Control points of the bezier curve For a 2D cubic bezier, order=3, dimension=2

countint, or None

Number of segments

scalefloat

Scale of curve

Returns
———-
discrete: (n,d) list of points, a polyline representation

of the bezier curve which respects constants.RES_LENGTH

trimesh.path.curve.discretize_bspline(control, knots, count=None, scale=1.0)

Given a B-Splines control points and knot vector, return a sampled version of the curve.

Parameters
control(o, d) float

Control points of the b- spline

knots(j,) float

B-spline knots

countint

Number of line segments to discretize the spline If not specified will be calculated as something reasonable

Returns
discrete(count, dimension) float

Points on a polyline version of the B-spline

trimesh.path.entities module

entities.py

Basic geometric primitives which only store references to vertex indices rather than vertices themselves.

class trimesh.path.entities.Arc(points, closed=None, layer=None, **kwargs)

Bases: trimesh.path.entities.Entity

Attributes
closed

A boolean flag for whether the arc is closed (a circle) or not.

end_points

Returns the first and last points.

is_valid

Is the current Arc entity valid.

nodes

Returns an (n,2) list of nodes, or vertices on the path.

Methods

bounds(vertices)

Return the AABB of the arc entity.

center(vertices)

Return the center information about the arc entity.

copy()

Return a copy of the current entity.

discrete(vertices[, scale])

Discretize the arc entity into line sections.

explode()

Split the entity into multiple entities.

length(vertices)

Return the total length of the entity.

reverse([direction])

Reverse the current entity in place.

to_dict()

Returns a dictionary with all of the information about the entity.

bounds(vertices)

Return the AABB of the arc entity.

Parameters
vertices: (n,dimension) float, vertices in space
Returns
bounds: (2, dimension) float, (min, max) coordinate of AABB
center(vertices)

Return the center information about the arc entity.

Parameters
vertices(n, dimension) float

Vertices in space

Returns
info: dict, with keys: ‘radius’

‘center’

closed

A boolean flag for whether the arc is closed (a circle) or not.

Returns
closedbool

If set True, Arc will be a closed circle

discrete(vertices, scale=1.0)

Discretize the arc entity into line sections.

Parameters
vertices(n, dimension) float

Points in space

scalefloat

Size of overall scene for numerical comparisons

Returns
discrete: (m, dimension) float, linear path in space
is_valid

Is the current Arc entity valid.

Returns
validbool

Does the current Arc have exactly 3 control points

class trimesh.path.entities.BSpline(points, knots, closed=None, layer=None, **kwargs)

Bases: trimesh.path.entities.Curve

An open or closed B- Spline.

Attributes
closed

If the first point is the same as the end point

end_points

Returns the first and last points.

is_valid

Is the current entity valid.

nodes

Returns an (n,2) list of nodes, or vertices on the path.

Methods

bounds(vertices)

Return the AABB of the current entity.

copy()

Return a copy of the current entity.

discrete(vertices[, count, scale])

Discretize the B-Spline curve.

explode()

Split the entity into multiple entities.

length(vertices)

Return the total length of the entity.

reverse([direction])

Reverse the current entity in place.

to_dict()

Returns a dictionary with all of the information about the entity.

discrete(vertices, count=None, scale=1.0)

Discretize the B-Spline curve.

Parameters
vertices(n, 2) or (n, 3) float

Points in space

scalefloat

Scale of overall drawings (for precision)

countint

Number of segments to return

Returns
discrete(m, 2) or (m, 3) float

Curve as line segments

to_dict()

Returns a dictionary with all of the information about the entity.

class trimesh.path.entities.Bezier(points, closed=None, layer=None, **kwargs)

Bases: trimesh.path.entities.Curve

An open or closed Bezier curve

Attributes
closed

If the first point is the same as the end point

end_points

Returns the first and last points.

is_valid

Is the current entity valid.

nodes

Returns an (n,2) list of nodes, or vertices on the path.

Methods

bounds(vertices)

Return the AABB of the current entity.

copy()

Return a copy of the current entity.

discrete(vertices[, scale, count])

Discretize the Bezier curve.

explode()

Split the entity into multiple entities.

length(vertices)

Return the total length of the entity.

reverse([direction])

Reverse the current entity in place.

to_dict()

Returns a dictionary with all of the information about the entity.

discrete(vertices, scale=1.0, count=None)

Discretize the Bezier curve.

Parameters
vertices(n, 2) or (n, 3) float

Points in space

scalefloat

Scale of overall drawings (for precision)

countint

Number of segments to return

Returns
discrete(m, 2) or (m, 3) float

Curve as line segments

class trimesh.path.entities.Curve(points, closed=None, layer=None, **kwargs)

Bases: trimesh.path.entities.Entity

The parent class for all wild curves in space.

Attributes
closed

If the first point is the same as the end point

end_points

Returns the first and last points.

is_valid

Is the current entity valid.

nodes

Returns an (n,2) list of nodes, or vertices on the path.

Methods

bounds(vertices)

Return the AABB of the current entity.

copy()

Return a copy of the current entity.

explode()

Split the entity into multiple entities.

length(vertices)

Return the total length of the entity.

reverse([direction])

Reverse the current entity in place.

to_dict()

Returns a dictionary with all of the information about the entity.

nodes

Returns an (n,2) list of nodes, or vertices on the path. Note that this generic class function assumes that all of the reference points are on the path which is true for lines and three point arcs.

If you were to define another class where that wasn’t the case (for example, the control points of a bezier curve), you would need to implement an entity- specific version of this function.

The purpose of having a list of nodes is so that they can then be added as edges to a graph so we can use functions to check connectivity, extract paths, etc.

The slicing on this function is essentially just tiling points so the first and last vertices aren’t repeated. Example:

self.points = [0,1,2] returns: [[0,1], [1,2]]

class trimesh.path.entities.Entity(points, closed=None, layer=None, **kwargs)

Bases: object

Attributes
closed

If the first point is the same as the end point

end_points

Returns the first and last points.

is_valid

Is the current entity valid.

nodes

Returns an (n,2) list of nodes, or vertices on the path.

Methods

bounds(vertices)

Return the AABB of the current entity.

copy()

Return a copy of the current entity.

explode()

Split the entity into multiple entities.

length(vertices)

Return the total length of the entity.

reverse([direction])

Reverse the current entity in place.

to_dict()

Returns a dictionary with all of the information about the entity.

bounds(vertices)

Return the AABB of the current entity.

Parameters
vertices: (n,dimension) float, vertices in space
Returns
bounds: (2, dimension) float, (min, max) coordinate of AABB
closed

If the first point is the same as the end point the entity is closed

copy()

Return a copy of the current entity.

end_points

Returns the first and last points. Also note that if you define a new entity class where the first and last vertices in self.points aren’t the endpoints of the curve you need to implement this function for your class.

self.points = [0,1,2] returns: [0,2]

explode()

Split the entity into multiple entities.

is_valid

Is the current entity valid.

Returns
validbool

Is the current entity well formed

length(vertices)

Return the total length of the entity.

Returns
lengthfloat

Total length of entity

nodes

Returns an (n,2) list of nodes, or vertices on the path. Note that this generic class function assumes that all of the reference points are on the path which is true for lines and three point arcs.

If you were to define another class where that wasn’t the case (for example, the control points of a bezier curve), you would need to implement an entity- specific version of this function.

The purpose of having a list of nodes is so that they can then be added as edges to a graph so we can use functions to check connectivity, extract paths, etc.

The slicing on this function is essentially just tiling points so the first and last vertices aren’t repeated. Example:

self.points = [0,1,2] returns: [[0,1], [1,2]]

reverse(direction=-1)

Reverse the current entity in place.

to_dict()

Returns a dictionary with all of the information about the entity.

class trimesh.path.entities.Line(points, closed=None, layer=None, **kwargs)

Bases: trimesh.path.entities.Entity

A line or poly-line entity

Attributes
closed

If the first point is the same as the end point

end_points

Returns the first and last points.

is_valid

Is the current entity valid.

nodes

Returns an (n,2) list of nodes, or vertices on the path.

Methods

bounds(vertices)

Return the AABB of the current entity.

copy()

Return a copy of the current entity.

discrete(vertices[, scale])

Discretize into a world- space path.

explode()

If the current Line entity consists of multiple line break it up into n Line entities.

length(vertices)

Return the total length of the entity.

reverse([direction])

Reverse the current entity in place.

to_dict()

Returns a dictionary with all of the information about the entity.

discrete(vertices, scale=1.0)

Discretize into a world- space path.

Parameters
vertices: (n, dimension) float

Points in space

scalefloat

Size of overall scene for numerical comparisons

Returns
discrete: (m, dimension) float

Path in space composed of line segments

explode()

If the current Line entity consists of multiple line break it up into n Line entities.

Returns
exploded: (n,) Line entities
is_valid

Is the current entity valid.

Returns
validbool

Is the current entity well formed

class trimesh.path.entities.Text(origin, text, height=None, vector=None, normal=None, align=None)

Bases: trimesh.path.entities.Entity

Text to annotate a 2D or 3D path.

Attributes
closed

If the first point is the same as the end point

end_points

Returns the first and last points.

is_valid

Is the current entity valid.

nodes

Returns an (n,2) list of nodes, or vertices on the path.

normal

A point representing the plane normal along the

origin

The origin point of the text.

vector

A point representing the text direction

Methods

angle(vertices)

If Text is 2D, get the rotation angle in radians.

bounds(vertices)

Return the AABB of the current entity.

copy()

Return a copy of the current entity.

explode()

Split the entity into multiple entities.

length(vertices)

Return the total length of the entity.

plot(vertices[, show])

Plot the text using matplotlib.

reverse([direction])

Reverse the current entity in place.

to_dict()

Returns a dictionary with all of the information about the entity.

discrete

angle(vertices)

If Text is 2D, get the rotation angle in radians.

Parameters
vertices(n, 2) float

Vertices in space referenced by self.points

Returns
anglefloat

Rotation angle in radians

closed

If the first point is the same as the end point the entity is closed

discrete(*args, **kwargs)
end_points

Returns the first and last points. Also note that if you define a new entity class where the first and last vertices in self.points aren’t the endpoints of the curve you need to implement this function for your class.

self.points = [0,1,2] returns: [0,2]

is_valid

Is the current entity valid.

Returns
validbool

Is the current entity well formed

length(vertices)

Return the total length of the entity.

Returns
lengthfloat

Total length of entity

nodes

Returns an (n,2) list of nodes, or vertices on the path. Note that this generic class function assumes that all of the reference points are on the path which is true for lines and three point arcs.

If you were to define another class where that wasn’t the case (for example, the control points of a bezier curve), you would need to implement an entity- specific version of this function.

The purpose of having a list of nodes is so that they can then be added as edges to a graph so we can use functions to check connectivity, extract paths, etc.

The slicing on this function is essentially just tiling points so the first and last vertices aren’t repeated. Example:

self.points = [0,1,2] returns: [[0,1], [1,2]]

normal

A point representing the plane normal along the vector: vertices[normal] - vertices[origin]

Returns
normalint

Index of vertex

origin

The origin point of the text.

Returns
originint

Index of vertices

plot(vertices, show=False)

Plot the text using matplotlib.

Parameters
vertices(n, 2) float

Vertices in space

showbool

If True, call plt.show()

vector

A point representing the text direction along the vector: vertices[vector] - vertices[origin]

Returns
vectorint

Index of vertex

trimesh.path.intersections module

trimesh.path.intersections.line_line(origins, directions, plane_normal=None)

Find the intersection between two lines. Uses terminology from: http://geomalgorithms.com/a05-_intersect-1.html

line 1: P(s) = p_0 + sU line 2: Q(t) = q_0 + tV

origins: (2, d) float, points on lines (d in [2,3]) directions: (2, d) float, direction vectors plane_normal: (3, ) float, if not passed computed from cross

Returns
intersects: boolean, whether the lines intersect.

In 2D, false if the lines are parallel In 3D, false if lines are not coplanar

intersection: if intersects: (d) length point of intersection

else: None

trimesh.path.packing module

class trimesh.path.packing.RectangleBin(bounds=None, size=None)

Bases: object

2D BSP tree node. http://www.blackpawn.com/texts/lightmaps/

Attributes
extents

Bounding box size.

Methods

insert(rectangle)

Insert a rectangle into the bin.

split(length[, vertical])

Returns two bounding boxes representing the current bounds split into two smaller boxes.

extents

Bounding box size.

Returns
extents: (2,) float, edge lengths of bounding box
insert(rectangle)

Insert a rectangle into the bin.

Parameters
rectangle: (2,) float, size of rectangle to insert
split(length, vertical=True)

Returns two bounding boxes representing the current bounds split into two smaller boxes.

Parameters
length: float, length to split
vertical: bool, if True will split box vertically
Returns
box: (2,4) float, two bounding boxes consisting of:

[minx, miny, maxx, maxy]

trimesh.path.packing.multipack(polygons, sheet_size=None, iterations=50, density_escape=0.95, spacing=0.094, quantity=None)

Pack polygons into a rectangle by taking each Polygon’s OBB and then packing that as a rectangle.

Parameters
polygons(n,) shapely.geometry.Polygon

Source geometry

sheet_size(2,) float

Size of rectangular sheet

iterationsint

Number of times to run the loop

density_escapefloat

When to exit early (0.0 - 1.0)

spacingfloat

How big a gap to leave between polygons

quantity(n,) int, or None

Quantity of each Polygon

Returns
overall_inserted(m,) int

Indexes of inserted polygons

packed(m, 3, 3) float

Homogeonous transforms from original frame to packed frame

trimesh.path.packing.pack_paths(paths, sheet_size=None)

Pack a list of Path2D objects into a rectangle.

Parameters
paths: (n,) Path2D

Geometry to be packed

Returns
packedtrimesh.path.Path2D

Object containing input geometry

inserted(m,) int

Indexes of paths inserted into result

trimesh.path.packing.pack_rectangles(rectangles, sheet_size, shuffle=False)

Pack smaller rectangles onto a larger rectangle, using a binary space partition tree.

Parameters
rectangles(n, 2) float

An array of (width, height) pairs representing the rectangles to be packed.

sheet_size(2,) float

Width, height of rectangular sheet

shufflebool

Whether or not to shuffle the insert order of the smaller rectangles, as the final packing density depends on insertion order.

Returns
densityfloat

Area filled over total sheet area

offset(m,2) float

Offsets to move rectangles to their packed location

inserted(n,) bool

Which of the original rectangles were packed

consumed_box(2,) float

Bounding box size of packed result

trimesh.path.path module

path.py

A library designed to work with vector paths.

class trimesh.path.path.Path(entities=None, vertices=None, metadata=None, process=True)

Bases: object

A Path object consists of:

vertices: (n,[2|3]) coordinates, stored in self.vertices

entities: geometric primitives (aka Lines, Arcs, etc.)

that reference indexes in self.vertices

Attributes
bounds

Return the axis aligned bounding box of the current path.

dangling

List of entities that aren’t included in a closed path

discrete

A sequence of connected vertices in space, corresponding to self.paths.

entities
extents

The size of the axis aligned bounding box.

is_closed

Are all entities connected to other entities.

is_empty

Are any entities defined for the current path.

kdtree

A KDTree object holding the vertices of the path.

layers

If entities have a layer defined, return it.

paths

Sequence of closed paths, encoded by entity index.

referenced_vertices

Which vertices are referenced by an entity.

scale

What is a representitive number that reflects the magnitude of the world holding the paths, for numerical comparisons.

units

If there are units defined in self.metadata return them.

vertex_graph

Return a networkx.Graph object for the entity connectiviy

vertex_nodes

Get a list of which vertex indices are nodes, which are either endpoints or points where the entity makes a direction change.

vertices

Methods

apply_layer(name)

Apply a layer name to every entity in the path.

apply_scale(scale)

Apply a transformation matrix to the current path in- place

apply_transform(transform)

Apply a transformation matrix to the current path in- place

apply_translation(offset)

Apply a transformation matrix to the current path in- place

convert_units(desired[, guess])

Convert the units of the current drawing in place.

copy()

Get a copy of the current mesh

crc()

A CRC of the current vertices and entities.

discretize_path(path)

Given a list of entities, return a list of connected points.

explode()

Turn every multi- segment entity into single segment entities, in- place

export([file_obj, file_type])

Export the path to a file object or return data.

fill_gaps([distance])

Find vertices without degree 2 and try to connect to other vertices.

md5()

An MD5 hash of the current vertices and entities.

merge_vertices([digits])

Merges vertices which are identical and replace references.

process()

Apply basic cleaning functions to the Path object, in- place.

remove_duplicate_entities()

Remove entities that are duplicated

remove_entities(entity_ids)

Remove entities by index.

remove_invalid()

Remove entities which declare themselves invalid

remove_unreferenced_vertices()

Removes all vertices which aren’t used by an entity.

replace_vertex_references(mask)

Replace the vertex index references in every entity.

rezero()

Translate so that every vertex is positive in the current mesh is positive.

scene()

Get a scene object containing the current Path3D object.

to_dict

apply_layer(name)

Apply a layer name to every entity in the path.

Parameters
namestr

Apply layer name to every entity

apply_scale(scale)

Apply a transformation matrix to the current path in- place

Parameters
scalefloat or (3,) float

Scale to be applied to mesh

apply_transform(transform)

Apply a transformation matrix to the current path in- place

Parameters
transform(d+1, d+1) float

Homogenous transformation for vertices

apply_translation(offset)

Apply a transformation matrix to the current path in- place

Parameters
offsetfloat or (3,) float

Translation to be applied to mesh

bounds

Return the axis aligned bounding box of the current path.

Returns
bounds: (2, dimension) float, (min, max) coordinates
convert_units(desired, guess=False)

Convert the units of the current drawing in place.

Parameters
desired: str, unit system to convert to
guess: bool, if True will attempt to guess units
copy()

Get a copy of the current mesh

Returns
copied: Path object, copy of self
crc()

A CRC of the current vertices and entities.

Returns
crc: int, CRC of entity points and vertices
dangling

List of entities that aren’t included in a closed path

Returns
dangling: (n,) int, index of self.entities
discrete

A sequence of connected vertices in space, corresponding to self.paths.

Returns
discrete(len(self.paths),)

A sequence of (m*, dimension) float

discretize_path(path)

Given a list of entities, return a list of connected points.

Parameters
path: (n,) int, indexes of self.entities
Returns
discrete: (m, dimension)
entities
explode()

Turn every multi- segment entity into single segment entities, in- place

export(file_obj=None, file_type=None, **kwargs)

Export the path to a file object or return data.

Parameters
file_objNone, str, or file object

File object or string to export to

file_typeNone or str

Type of file: dxf, dict, svg

Returns
exportedbytes or str

Exported as specified type

extents

The size of the axis aligned bounding box.

Returns
extents: (dimension,) float, edge length of AABB
fill_gaps(distance=0.025)

Find vertices without degree 2 and try to connect to other vertices. Operations are done in-place.

Parameters
distancefloat

Connect vertices up to this distance

is_closed

Are all entities connected to other entities.

Returns
closedbool

Every entity is connected at its ends

is_empty

Are any entities defined for the current path.

Returns
emptybool

True if no entities are defined

kdtree

A KDTree object holding the vertices of the path.

Returns
kdtree: scipy.spatial.cKDTree object holding self.vertices
layers

If entities have a layer defined, return it.

Returns
layers: (len(entities), ) list of str
md5()

An MD5 hash of the current vertices and entities.

Returns
md5: str, two appended MD5 hashes
merge_vertices(digits=None)

Merges vertices which are identical and replace references.

Parameters
digitsNone, or int

How many digits to consider when merging vertices

paths

Sequence of closed paths, encoded by entity index.

Returns
paths: (n,) sequence of (*,) int referencing self.entities
process()

Apply basic cleaning functions to the Path object, in- place.

referenced_vertices

Which vertices are referenced by an entity.

Returns
referenced_vertices: (n,) int, indexes of self.vertices
remove_duplicate_entities()

Remove entities that are duplicated

remove_entities(entity_ids)

Remove entities by index.

Parameters
entity_ids(n,) int

Indexes of self.entities to remove

remove_invalid()

Remove entities which declare themselves invalid

remove_unreferenced_vertices()

Removes all vertices which aren’t used by an entity.

replace_vertex_references(mask)

Replace the vertex index references in every entity.

Parameters
mask(len(self.vertices), ) int

Contains new vertex indexes

rezero()

Translate so that every vertex is positive in the current mesh is positive.

Returns
matrix(dimension + 1, dimension + 1) float

Homogenous transformation that was applied to the current Path object.

scale

What is a representitive number that reflects the magnitude of the world holding the paths, for numerical comparisons.

Returns
scalefloat

Approximate size of the world holding this path

scene()

Get a scene object containing the current Path3D object.

Returns
scene: trimesh.scene.Scene object containing current path
to_dict()
units

If there are units defined in self.metadata return them.

Returns
units: str, current unit system
vertex_graph

Return a networkx.Graph object for the entity connectiviy

graphnetworkx.Graph

Holds vertex indexes

vertex_nodes

Get a list of which vertex indices are nodes, which are either endpoints or points where the entity makes a direction change.

Returns
nodes(n, 2) int

Indexes of self.vertices which are nodes

vertices
class trimesh.path.path.Path2D(entities=None, vertices=None, metadata=None, process=True)

Bases: trimesh.path.path.Path

Attributes
area

Return the area of the polygons interior.

body_count
bounds

Return the axis aligned bounding box of the current path.

centroid

Return the centroid of the path object.

dangling

List of entities that aren’t included in a closed path

discrete

A sequence of connected vertices in space, corresponding to self.paths.

enclosure

Networkx Graph object of polygon enclosure.

enclosure_directed

Networkx DiGraph of polygon enclosure

enclosure_shell

A dictionary of path indexes which are ‘shell’ paths, and values of ‘hole’ paths.

entities
extents

The size of the axis aligned bounding box.

identifier

A unique identifier for the path.

identifier_md5

Return an MD5 of the identifier

is_closed

Are all entities connected to other entities.

is_empty

Are any entities defined for the current path.

kdtree

A KDTree object holding the vertices of the path.

layers

If entities have a layer defined, return it.

length

The total discretized length of every entity.

path_valid

Returns

paths

Sequence of closed paths, encoded by entity index.

polygons_closed

Cycles in the vertex graph, as shapely.geometry.Polygons.

polygons_full

A list of shapely.geometry.Polygon objects with interiors created by checking which closed polygons enclose which other polygons.

referenced_vertices

Which vertices are referenced by an entity.

root

Which indexes of self.paths/self.polygons_closed are root curves.

scale

What is a representitive number that reflects the magnitude of the world holding the paths, for numerical comparisons.

units

If there are units defined in self.metadata return them.

vertex_graph

Return a networkx.Graph object for the entity connectiviy

vertex_nodes

Get a list of which vertex indices are nodes, which are either endpoints or points where the entity makes a direction change.

vertices

Methods

apply_layer(name)

Apply a layer name to every entity in the path.

apply_obb()

Transform the current path so that its OBB is axis aligned and OBB center is at the origin.

apply_scale(scale)

Apply a transformation matrix to the current path in- place

apply_transform(transform)

Apply a transformation matrix to the current path in- place

apply_translation(offset)

Apply a transformation matrix to the current path in- place

connected_paths(path_id[, include_self])

Given an index of self.paths find other paths which overlap with that path.

convert_units(desired[, guess])

Convert the units of the current drawing in place.

copy()

Get a copy of the current mesh

crc()

A CRC of the current vertices and entities.

discretize_path(path)

Given a list of entities, return a list of connected points.

explode()

Turn every multi- segment entity into single segment entities, in- place

export([file_obj, file_type])

Export the path to a file object or return data.

extrude(height, **kwargs)

Extrude the current 2D path into a 3D mesh.

fill_gaps([distance])

Find vertices without degree 2 and try to connect to other vertices.

md5()

An MD5 hash of the current vertices and entities.

medial_axis([resolution, clip])

Find the approximate medial axis based on a voronoi diagram of evenly spaced points on the boundary of the polygon.

merge_vertices([digits])

Merges vertices which are identical and replace references.

plot_discrete([show, annotations])

Plot the closed curves of the path.

plot_entities([show, annotations, color])

Plot the entities of the path, with no notion of topology

process()

Apply basic cleaning functions to the Path object, in- place.

rasterize(pitch, origin[, resolution, fill, …])

Rasterize a Path2D object into a boolean image (“mode 1”).

remove_duplicate_entities()

Remove entities that are duplicated

remove_entities(entity_ids)

Remove entities by index.

remove_invalid()

Remove entities which declare themselves invalid

remove_unreferenced_vertices()

Removes all vertices which aren’t used by an entity.

replace_vertex_references(mask)

Replace the vertex index references in every entity.

rezero()

Translate so that every vertex is positive in the current mesh is positive.

sample(count, **kwargs)

Use rejection sampling to generate random points inside a polygon.

scene()

Get a scene object containing the current Path3D object.

show([annotations])

Plot the current Path2D object using matplotlib.

simplify(**kwargs)

Return a version of the current path with colinear segments merged, and circles entities replacing segmented circular paths.

simplify_spline([path_indexes, smooth])

Convert paths into b-splines.

split()

If the current Path2D consists of n ‘root’ curves, split them into a list of n Path2D objects

to_3D([transform])

Convert 2D path to 3D path on the XY plane.

triangulate(**kwargs)

Create a region- aware triangulation of the 2D path.

to_dict

apply_obb()

Transform the current path so that its OBB is axis aligned and OBB center is at the origin.

area

Return the area of the polygons interior.

Returns
area: float, total area of polygons minus interiors
body_count
centroid

Return the centroid of the path object.

Returns
centroid(d,) float

Approximate centroid of the path

connected_paths(path_id, include_self=False)

Given an index of self.paths find other paths which overlap with that path.

Parameters
path_idint

Index of self.paths

include_selfbool

Should the result include path_id or not

Returns
path_ids(n, ) int

Indexes of self.paths that overlap input path_id

enclosure

Networkx Graph object of polygon enclosure.

enclosure_directed

Networkx DiGraph of polygon enclosure

enclosure_shell

A dictionary of path indexes which are ‘shell’ paths, and values of ‘hole’ paths.

Returns
corresponding: dict, {index of self.paths of shell[indexes of holes]}
extrude(height, **kwargs)

Extrude the current 2D path into a 3D mesh.

Parameters
height: float, how far to extrude the profile
kwargs: passed directly to meshpy.triangle.build:
triangle.build(mesh_info,

verbose=False, refinement_func=None, attributes=False, volume_constraints=True, max_volume=None, allow_boundary_steiner=True, allow_volume_steiner=True, quality_meshing=True, generate_edges=None, generate_faces=False, min_angle=None)

Returns
——–
mesh: trimesh object representing extruded polygon
identifier

A unique identifier for the path.

Returns
identifier: (5,) float, unique identifier
identifier_md5

Return an MD5 of the identifier

length

The total discretized length of every entity.

Returns
length: float, summed length of every entity
medial_axis(resolution=None, clip=None)

Find the approximate medial axis based on a voronoi diagram of evenly spaced points on the boundary of the polygon.

Parameters
resolutionNone or float

Distance between each sample on the polygon boundary

clipNone, or (2,) float

Min, max number of samples

Returns
medialPath2D object

Contains only medial axis of Path

path_valid
Returns
path_valid: (n,) bool, indexes of self.paths self.polygons_closed

which are valid polygons

plot_discrete(show=False, annotations=True)

Plot the closed curves of the path.

plot_entities(show=False, annotations=True, color=None)

Plot the entities of the path, with no notion of topology

polygons_closed

Cycles in the vertex graph, as shapely.geometry.Polygons. These are polygon objects for every closed circuit, with no notion of whether a polygon is a hole or an area. Every polygon in this list will have an exterior, but NO interiors.

Returns
polygons_closed: (n,) list of shapely.geometry.Polygon objects
polygons_full

A list of shapely.geometry.Polygon objects with interiors created by checking which closed polygons enclose which other polygons.

Returns
full(len(self.root),) shapely.geometry.Polygon

Polygons containing interiors

rasterize(pitch, origin, resolution=None, fill=True, width=None, **kwargs)

Rasterize a Path2D object into a boolean image (“mode 1”).

Parameters
pitch: float, length in model space of a pixel edge
origin: (2,) float, origin position in model space
resolution: (2,) int, resolution in pixel space
fill: bool, if True will return closed regions as filled
width: int, if not None will draw outline this wide (pixels)
Returns
raster: PIL.Image object, mode 1
root

Which indexes of self.paths/self.polygons_closed are root curves. Also known as ‘shell’ or ‘exterior.

Returns
root: (n,) int, list of indexes
sample(count, **kwargs)

Use rejection sampling to generate random points inside a polygon.

Parameters
countint

Number of points to return If there are multiple bodies, there will be up to count * bodies points returned

factorfloat

How many points to test per loop IE, count * factor

max_iterint,

Maximum number of intersection loops to run, total points sampled is count * factor * max_iter

Returns
hit(n, 2) float

Random points inside polygon

show(annotations=True)

Plot the current Path2D object using matplotlib.

simplify(**kwargs)

Return a version of the current path with colinear segments merged, and circles entities replacing segmented circular paths.

Returns
simplifiedPath2D object
simplify_spline(path_indexes=None, smooth=0.0002)

Convert paths into b-splines.

Parameters
path_indexes(n) int

List of indexes of self.paths to convert

smoothfloat

How much the spline should smooth the curve

Returns
simplified: Path2D object
split()

If the current Path2D consists of n ‘root’ curves, split them into a list of n Path2D objects

Returns
split: (n,) list of Path2D objects

Each connected region and interiors

to_3D(transform=None)

Convert 2D path to 3D path on the XY plane.

Parameters
transform(4, 4) float

If passed, will transform vertices. If not passed and ‘to_3D’ is in metadata that transform will be used.

Returns
path_3D: Path3D version of current path
triangulate(**kwargs)

Create a region- aware triangulation of the 2D path.

Parameters
**kwargsdict

Passed to trimesh.creation.triangulate_polygon

Returns
vertices(n, 2) float

2D vertices of triangulation

faces(n, 3) int

Indexes of vertices for triangles

class trimesh.path.path.Path3D(entities=None, vertices=None, metadata=None, process=True)

Bases: trimesh.path.path.Path

Attributes
bounds

Return the axis aligned bounding box of the current path.

dangling

List of entities that aren’t included in a closed path

discrete

A sequence of connected vertices in space, corresponding to self.paths.

entities
extents

The size of the axis aligned bounding box.

is_closed

Are all entities connected to other entities.

is_empty

Are any entities defined for the current path.

kdtree

A KDTree object holding the vertices of the path.

layers

If entities have a layer defined, return it.

paths

Sequence of closed paths, encoded by entity index.

referenced_vertices

Which vertices are referenced by an entity.

scale

What is a representitive number that reflects the magnitude of the world holding the paths, for numerical comparisons.

units

If there are units defined in self.metadata return them.

vertex_graph

Return a networkx.Graph object for the entity connectiviy

vertex_nodes

Get a list of which vertex indices are nodes, which are either endpoints or points where the entity makes a direction change.

vertices

Methods

apply_layer(name)

Apply a layer name to every entity in the path.

apply_scale(scale)

Apply a transformation matrix to the current path in- place

apply_transform(transform)

Apply a transformation matrix to the current path in- place

apply_translation(offset)

Apply a transformation matrix to the current path in- place

convert_units(desired[, guess])

Convert the units of the current drawing in place.

copy()

Get a copy of the current mesh

crc()

A CRC of the current vertices and entities.

discretize_path(path)

Given a list of entities, return a list of connected points.

explode()

Turn every multi- segment entity into single segment entities, in- place

export([file_obj, file_type])

Export the path to a file object or return data.

fill_gaps([distance])

Find vertices without degree 2 and try to connect to other vertices.

md5()

An MD5 hash of the current vertices and entities.

merge_vertices([digits])

Merges vertices which are identical and replace references.

plot_discrete([show])

Plot closed curves

plot_entities([show])

Plot discrete version of entities without regards for connectivity.

process()

Apply basic cleaning functions to the Path object, in- place.

remove_duplicate_entities()

Remove entities that are duplicated

remove_entities(entity_ids)

Remove entities by index.

remove_invalid()

Remove entities which declare themselves invalid

remove_unreferenced_vertices()

Removes all vertices which aren’t used by an entity.

replace_vertex_references(mask)

Replace the vertex index references in every entity.

rezero()

Translate so that every vertex is positive in the current mesh is positive.

scene()

Get a scene object containing the current Path3D object.

show(**kwargs)

Show the current Path3D object.

to_planar([to_2D, normal, check])

Check to see if current vectors are all coplanar.

to_dict

plot_discrete(show=False)

Plot closed curves

Parameters
showbool

If False will not execute matplotlib.pyplot.show

plot_entities(show=False)

Plot discrete version of entities without regards for connectivity.

Parameters
showbool

If False will not execute matplotlib.pyplot.show

show(**kwargs)

Show the current Path3D object.

to_planar(to_2D=None, normal=None, check=True)

Check to see if current vectors are all coplanar.

If they are, return a Path2D and a transform which will transform the 2D representation back into 3 dimensions

Parameters
to_2D: (4,4) float

Homogenous transformation matrix to apply, If not passed a plane will be fitted to vertices.

normal: (3,) float, or None

Approximate normal of direction of plane If to_2D is not specified sign will be applied to fit plane normal

check: bool

If True: Raise a ValueError if points aren’t coplanar

Returns
planartrimesh.path.Path2D

Current path transformed onto plane

to_3D(4,4) float

Homeogenous transformation to move planar back into 3D space

trimesh.path.polygons module

trimesh.path.polygons.edges_to_polygons(edges, vertices)

Given an edge list of indices and associated vertices representing lines, generate a list of polygons.

Parameters
edges(n, 2) int

Indexes of vertices which represent lines

vertices(m, 2) float

Vertices in 2D space

Returns
polygons(p,) shapely.geometry.Polygon

Polygon objects with interiors

trimesh.path.polygons.enclosure_tree(polygons)

Given a list of shapely polygons with only exteriors, find which curves represent the exterior shell or root curve and which represent holes which penetrate the exterior.

This is done with an R-tree for rough overlap detection, and then exact polygon queries for a final result.

Parameters
polygons(n,) shapely.geometry.Polygon

Polygons which only have exteriors and may overlap

Returns
roots(m,) int

Index of polygons which are root

containsnetworkx.DiGraph

Edges indicate a polygon is contained by another polygon

trimesh.path.polygons.medial_axis(polygon, resolution=None, clip=None)

Given a shapely polygon, find the approximate medial axis using a voronoi diagram of evenly spaced points on the boundary of the polygon.

Parameters
polygonshapely.geometry.Polygon

The source geometry

resolutionfloat

Distance between each sample on the polygon boundary

clipNone, or (2,) int

Clip sample count to min of clip[0] and max of clip[1]

Returns
edges(n, 2) int

Vertex indices representing line segments on the polygon’s medial axis

vertices(m, 2) float

Vertex positions in space

trimesh.path.polygons.paths_to_polygons(paths, scale=None)

Given a sequence of connected points turn them into valid shapely Polygon objects.

Parameters
paths(n,) sequence

Of (m,2) float, closed paths

scale: float

Approximate scale of drawing for precision

Returns
polys: (p,) list

shapely.geometry.Polygon None

trimesh.path.polygons.plot_polygon(polygon, show=True, **kwargs)

Plot a shapely polygon using matplotlib.

Parameters
polygonshapely.geometry.Polygon

Polygon to be plotted

showbool

If True will display immediately

**kwargs

Passed to plt.plot

trimesh.path.polygons.polygon_hash(polygon)

Return a vector containing values representitive of a particular polygon.

polygonshapely.geometry.Polygon

Input geometry

Returns
hashed: (6), float

Representitive values representing input polygon

trimesh.path.polygons.polygon_obb(polygon)

Find the oriented bounding box of a Shapely polygon.

The OBB is always aligned with an edge of the convex hull of the polygon.

Parameters
polygons: shapely.geometry.Polygon
Returns
transform: (3,3) float, transformation matrix

which will move input polygon from its original position to the first quadrant where the AABB is the OBB

extents: (2,) float, extents of transformed polygon
trimesh.path.polygons.polygon_scale(polygon)

For a Polygon object, return the diagonal length of the AABB.

Parameters
polygon: shapely.geometry.Polygon object
Returns
scale: float, length of AABB diagonal
trimesh.path.polygons.polygons_obb(polygons)

Find the OBBs for a list of shapely.geometry.Polygons

trimesh.path.polygons.random_polygon(segments=8, radius=1.0)

Generate a random polygon with a maximum number of sides and approximate radius.

segments: int, the maximum number of sides the random polygon will have radius: float, the approximate radius of the polygon desired

Returns
polygon: shapely.geometry.Polygon object with random exterior, and no interiors.
trimesh.path.polygons.repair_invalid(polygon, scale=None, rtol=0.5)

Given a shapely.geometry.Polygon, attempt to return a valid version of the polygon through buffering tricks.

Parameters
polygon: shapely.geometry.Polygon object
rtol: float, how close does a perimeter have to be
scale: float, or None
Returns
repaired: shapely.geometry.Polygon object
Raises
ValueError: if polygon can’t be repaired
trimesh.path.polygons.resample_boundaries(polygon, resolution, clip=None)

Return a version of a polygon with boundaries resampled to a specified resolution.

Parameters
polygon: shapely.geometry.Polygon object
resolution: float, desired distance between points on boundary
clip: (2,) int, upper and lower bounds to clip

number of samples to (to avoid exploding counts)

Returns
kwargs: dict, keyword args for a Polygon(**kwargs)
trimesh.path.polygons.sample(polygon, count, factor=1.5, max_iter=10)

Use rejection sampling to generate random points inside a polygon.

Parameters
polygonshapely.geometry.Polygon

Polygon that will contain points

countint

Number of points to return

factorfloat

How many points to test per loop IE, count * factor

max_iterint,

Maximum number of intersection loops to run, total points sampled is count * factor * max_iter

Returns
hit(n, 2) float

Random points inside polygon where n <= count

trimesh.path.polygons.stack_boundaries(boundaries)

Stack the boundaries of a polygon into a single (n, 2) list of vertices.

Parameters
boundaries: dict, with keys ‘shell’, ‘holes’
Returns
stacked: (n, 2) float, list of vertices
trimesh.path.polygons.transform_polygon(polygon, matrix)

Transform a polygon by a a 2D homogenous transform.

Parameters
polygonshapely.geometry.Polygon

2D polygon to be transformed.

matrix(3, 3) float

2D homogenous transformation.

Returns
resultshapely.geometry.Polygon

Polygon transformed by matrix.

trimesh.path.raster module

raster.py

Turn 2D vector paths into raster images, using pillow

trimesh.path.raster.rasterize(path, pitch, origin, resolution=None, fill=True, width=None)

Rasterize a Path2D object into a boolean image (“mode 1”).

Parameters
path: Path2D object
pitch: float, length in model space of a pixel edge
origin: (2,) float, origin position in model space
resolution: (2,) int, resolution in pixel space
fill: bool, if True will return closed regions as filled
width: int, if not None will draw outline this wide (pixels)
Returns
raster: PIL.Image object, mode 1

trimesh.path.repair module

repair.py

Try to fix problems with closed regions.

trimesh.path.repair.fill_gaps(path, distance=0.025)

For 3D line segments defined by two points, turn them in to an origin defined as the closest point along the line to the zero origin as well as a direction vector and start and end parameter.

Parameters
segments(n, 2, 3) float

Line segments defined by start and end points

Returns
origins(n, 3) float

Point on line closest to [0, 0, 0]

vectors(n, 3) float

Unit line directions

parameters(n, 2) float

Start and end distance pairs for each line

trimesh.path.segments module

segments.py

Deal with (n, 2, 3) line segments.

trimesh.path.segments.colinear_pairs(segments, radius=0.01, angle=0.01, length=None)

Find pairs of segments which are colinear.

Parameters
segments(n, 2, (2, 3)) float

Two or three dimensional line segments

radiusfloat

Maximum radius line origins can differ and be considered colinear

anglefloat

Maximum angle in radians segments can differ and still be considered colinear

lengthNone or float

If specified, will additionally require that pairs have a mean vertex distance less than this value from each other to qualify.

Returns
pairs(m, 2) int

Indexes of segments which are colinear

trimesh.path.segments.overlap(origins, vectors, params)

Find the overlap of two parallel line segments.

Parameters
origins(2, 3) float

Origin points of lines in space

vectors(2, 3) float

Unit direction vectors of lines

params(2, 2) float

Two (start, end) distance pairs

Returns
lengthfloat

Overlapping length

overlap(n, 2, 3) float

Line segments for overlapping distance

trimesh.path.segments.parameters_to_segments(origins, vectors, parameters)

Convert a parametric line segment representation to a two point line segment representation

Parameters
origins(n, 3) float

Line origin point

vectors(n, 3) float

Unit line directions

parameters(n, 2) float

Start and end distance pairs for each line

Returns
segments(n, 2, 3) float

Line segments defined by start and end points

trimesh.path.segments.segments_to_parameters(segments)

For 3D line segments defined by two points, turn them in to an origin defined as the closest point along the line to the zero origin as well as a direction vector and start and end parameter.

Parameters
segments(n, 2, 3) float

Line segments defined by start and end points

Returns
origins(n, 3) float

Point on line closest to [0, 0, 0]

vectors(n, 3) float

Unit line directions

parameters(n, 2) float

Start and end distance pairs for each line

trimesh.path.segments.split(segments, points, atol=1e-05)

Find any points that lie on a segment (not an endpoint) and then split that segment into two segments.

We are basically going to find the distance between point and both segment vertex, and see if it is with tolerance of the segment length.

Parameters
segments(n, 2, (2, 3) float

Line segments in space

points(n, (2, 3)) float

Points in space

atolfloat

Absolute tolerance for distances

Returns
split(n, 2, (3 | 3) float

Line segments in space, split at vertices

trimesh.path.segments.unique(segments, digits=5)

Find unique line segments.

Parameters
segments(n, 2, (2|3)) float

Line segments in space

digitsint

How many digits to consider when merging vertices

Returns
unique(m, 2, (2|3)) float

Segments with duplicates merged

trimesh.path.simplify module

trimesh.path.simplify.fit_circle_check(points, scale, prior=None, final=False, verbose=False)

Fit a circle, and reject the fit if: * the radius is larger than tol.radius_min*scale or tol.radius_max*scale * any segment spans more than tol.seg_angle * any segment is longer than tol.seg_frac*scale * the fit deviates by more than tol.radius_frac*radius * the segments on the ends deviate from tangent by more than tol.tangent

points: (n, d) set of points which represent a path prior: (center, radius) tuple for best guess, or None if unknown scale: float, what is the overall scale of the set of points verbose: boolean, if True output log.debug messages for the reasons

for fit rejection. Potentially generates hundreds of thousands of messages so only suggested in manual debugging.

Returns
if fit is acceptable:

(center, radius) tuple

else:

None

trimesh.path.simplify.is_circle(points, scale, verbose=False)

Given a set of points, quickly determine if they represent a circle or not.

Parameters
points: (n,2) float, points in space
scale: float, scale of overall drawing
verbose: bool, print all fit messages or not
Returns
control: (3,2) float, points in space, OR

None, if not a circle

trimesh.path.simplify.merge_colinear(points, scale)

Given a set of points representing a path in space, merge points which are colinear.

Parameters
points: (n, d) set of points (where d is dimension)
scale: float, scale of drawing
Returns
merged: (j, d) set of points with colinear and duplicate

points merged, where (j < n)

trimesh.path.simplify.points_to_spline_entity(points, smooth=None, count=None)

Create a spline entity from a curve in space

Parameters
points: (n, dimension) float, points in space
smooth: float, smoothing amount
count: int, number of samples in result
Returns
entity: entities.BSpline object with points indexed at zero
control: (m, dimension) float, new vertices for entity
trimesh.path.simplify.resample_spline(points, smooth=0.001, count=None, degree=3)

Resample a path in space, smoothing along a b-spline.

Parameters
points: (n, dimension) float, points in space
smooth: float, smoothing amount
count: number of samples in output
degree: int, degree of spline polynomial
Returns
resampled: (count, dimension) float, points in space
trimesh.path.simplify.simplify_basic(drawing, process=False, **kwargs)

Merge colinear segments and fit circles.

Parameters
drawing: Path2D object, will not be modified.
Returns
simplified: Path2D with circles.
trimesh.path.simplify.simplify_spline(path, smooth=None, verbose=False)

Replace discrete curves with b-spline or Arc and return the result as a new Path2D object.

Parameters
pathtrimesh.path.Path2D

Input geometry

smoothfloat

Distance to smooth

Returns
simplifiedPath2D

Consists of Arc and BSpline entities

trimesh.path.traversal module

class trimesh.path.traversal.PathSample(points)

Bases: object

Methods

truncate(distance)

Return a truncated version of the path.

sample

sample(distances)
truncate(distance)

Return a truncated version of the path. Only one vertex (at the endpoint) will be added.

trimesh.path.traversal.closed_paths(entities, vertices)

Paths are lists of entity indices. We first generate vertex paths using graph cycle algorithms, and then convert them to entity paths.

This will also change the ordering of entity.points in place so a path may be traversed without having to reverse the entity.

Parameters
entities(n,) entity objects

Entity objects

vertices(m, dimension) float

Vertex points in space

Returns
entity_pathssequence of (n,) int

Ordered traversals of entities

trimesh.path.traversal.discretize_path(entities, vertices, path, scale=1.0)

Turn a list of entity indices into a path of connected points.

Parameters
entities(j,) entity objects

Objects like ‘Line’, ‘Arc’, etc.

vertices: (n, dimension) float

Vertex points in space.

path(m,) int

Indexes of entities

scalefloat

Overall scale of drawing used for numeric tolerances in certain cases

Returns
discrete(p, dimension) float

Connected points in space that lie on the path and can be connected with line segments.

trimesh.path.traversal.resample_path(points, count=None, step=None, step_round=True)

Given a path along (n,d) points, resample them such that the distance traversed along the path is constant in between each of the resampled points. Note that this can produce clipping at corners, as the original vertices are NOT guaranteed to be in the new, resampled path.

ONLY ONE of count or step can be specified Result can be uniformly distributed (np.linspace) by specifying count Result can have a specific distance (np.arange) by specifying step

Parameters
points: (n, d) float

Points in space

countint,

Number of points to sample evenly (aka np.linspace)

stepfloat

Distance each step should take along the path (aka np.arange)

Returns
resampled(j,d) float

Points on the path

trimesh.path.traversal.split(self)

Split a Path2D into multiple Path2D objects where each one has exactly one root curve.

Parameters
selftrimesh.path.Path2D

Input geometry

Returns
splitlist of trimesh.path.Path2D

Original geometry as separate paths

trimesh.path.traversal.vertex_graph(entities)

Given a set of entity objects generate a networkx.Graph that represents their vertex nodes.

Parameters
entitieslist

Objects with ‘closed’ and ‘nodes’ attributes

Returns
graphnetworkx.Graph

Graph where node indexes represent vertices

closed(n,) int

Indexes of entities which are ‘closed’

trimesh.path.traversal.vertex_to_entity_path(vertex_path, graph, entities, vertices=None)

Convert a path of vertex indices to a path of entity indices.

Parameters
vertex_path(n,) int

Ordered list of vertex indices representing a path

graphnx.Graph

Vertex connectivity

entities(m,) list

Entity objects

vertices(p, dimension) float

Vertex points in space

Returns
entity_path(q,) int

Entity indices which make up vertex_path

trimesh.path.util module

trimesh.path.util.concatenate(paths)

Concatenate multiple paths into a single path.

Parameters
paths: list of Path, Path2D, or Path3D objects
Returns
concat: Path, Path2D, or Path3D object
trimesh.path.util.is_ccw(points)

Check if connected planar points are counterclockwise.

Parameters
points: (n,2) float, connected points on a plane
Returns
ccw: bool, True if points are counterclockwise

Module contents