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:
result : dict
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]
close : boolean
If True close the arc into a circle
scale : float
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

radius : float

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.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:
rect : Path2D

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_radius : float

Radius of circle centers

circle_radius : float

The radius of each circle

count : int

Number of circles in the pattern

center : (2,) float

Center of pattern

angle : float

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

Returns:
pattern : trimesh.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:
rect : Path2D

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:
n : int

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

count : int, or None

Number of segments

scale : float

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

count : int

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:
closed : bool

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

scale : float

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:
valid : bool

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

scale : float

Scale of overall drawings (for precision)

count : int

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

scale : float

Scale of overall drawings (for precision)

count : int

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:
valid : bool

Is the current entity well formed

length(vertices)

Return the total length of the entity.

Returns:
length: float, 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

scale : float

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:
valid : bool

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:
angle : float

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:
valid : bool

Is the current entity well formed

length(vertices)

Return the total length of the entity.

Returns:
length: float, 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:
normal : int

Index of vertex

origin

The origin point of the text.

Returns:
origin : int

Index of vertices

plot(vertices, show=False)

Plot the text using matplotlib.

Parameters:
vertices : (n, 2) float

Vertices in space

show : bool

If True, call plt.show()

vector

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

Returns:
vector : int

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

iterations : int

Number of times to run the loop

density_escape : float

When to exit early (0.0 - 1.0)

spacing : float

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:
packed : trimesh.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

shuffle : bool

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

Returns:
density : float

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:
name : str

Apply layer name to every entity

apply_scale(scale)

Apply a transformation matrix to the current path in- place

Parameters:
scale : float 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:
offset : float 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_obj : None, str, or file object

File object or string to export to

file_type : None or str

Type of file: dxf, dict, svg

Returns:
exported : bytes 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:
distance : float

Connect vertices up to this distance

is_closed

Are all entities connected to other entities.

Returns:
closed : bool

Every entity is connected at its ends

is_empty

Are any entities defined for the current path.

Returns:
empty : bool

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:
digits : None, 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:
scale : float

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

graph : networkx.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.

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
connected_paths(path_id, include_self=False)

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

Parameters:
path_id : int

Index of self.paths

include_self : bool

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:
resolution : None or float

Distance between each sample on the polygon boundary

clip : None, or (2,) float

Min, max number of samples

Returns:
medial : Path2D 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:
count : int

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

factor : float

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

max_iter : int,

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:
simplified : Path2D 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

smooth : float

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:
**kwargs : dict

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:
show : bool

If False will not execute matplotlib.pyplot.show

plot_entities(show=False)

Plot discrete version of entities without regards for connectivity.

Parameters:
show : bool

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:
planar : trimesh.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

contains : networkx.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:
polygon : shapely.geometry.Polygon

The source geometry

resolution : float

Distance between each sample on the polygon boundary

clip : None, 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:
polygon : shapely.geometry.Polygon

Polygon to be plotted

show : bool

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.

polygon : shapely.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:
polygon : shapely.geometry.Polygon

Polygon that will contain points

count : int

Number of points to return

factor : float

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

max_iter : int,

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:
polygon : shapely.geometry.Polygon

2D polygon to be transformed.

matrix : (3, 3) float

2D homogenous transformation.

Returns:
result : shapely.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

radius : float

Maximum radius line origins can differ and be considered colinear

angle : float

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

length : None 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:
length : float

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

atol : float

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

digits : int

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:
path : trimesh.path.Path2D

Input geometry

smooth : float

Distance to smooth

Returns:
simplified : Path2D

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_paths : sequence 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

scale : float

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

count : int,

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

step : float

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:
self : trimesh.path.Path2D

Input geometry

Returns:
split : list 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:
entities : list

Objects with ‘closed’ and ‘nodes’ attributes

Returns:
graph : networkx.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

graph : nx.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