tfg.io.triangle_mesh.Trimesh

The Geometry3D object is the parent object of geometry objects

tfg.io.triangle_mesh.Trimesh(
    vertices=None, faces=None, face_normals=None, vertex_normals=None,
    face_colors=None, vertex_colors=None, face_attributes=None,
    vertex_attributes=None, metadata=None, process=True, validate=False,
    use_embree=True, initial_cache=None, visual=None, **kwargs
)

which are three dimensional, including Trimesh, PointCloud, and Scene objects.

Attributes
`area`	Summed area of all triangles in the current mesh. Returns area : float Surface area of mesh
`area_faces`	The area of each face in the mesh. Returns area_faces : (n, ) float Area of each face
`as_open3d`	Return an `open3d.geometry.TriangleMesh` version of the current mesh. Returns open3d : open3d.geometry.TriangleMesh Current mesh as an open3d object.
`body_count`	How many connected groups of vertices exist in this mesh. Note that this number may differ from result in mesh.split, which is calculated from FACE rather than vertex adjacency. Returns count : int Number of connected vertex groups
`bounding_box`	An axis aligned bounding box for the current mesh. Returns aabb : trimesh.primitives.Box Box object with transform and extents defined representing the axis aligned bounding box of the mesh
`bounding_box_oriented`	An oriented bounding box for the current mesh. Returns obb : trimesh.primitives.Box Box object with transform and extents defined representing the minimum volume oriented bounding box of the mesh
`bounding_cylinder`	A minimum volume bounding cylinder for the current mesh. Returns mincyl : trimesh.primitives.Cylinder Cylinder primitive containing current mesh
`bounding_primitive`	The minimum volume primitive (box, sphere, or cylinder) that bounds the mesh. Returns bounding_primitive : object Smallest primitive which bounds the mesh: trimesh.primitives.Sphere trimesh.primitives.Box trimesh.primitives.Cylinder
`bounding_sphere`	A minimum volume bounding sphere for the current mesh. Note that the Sphere primitive returned has an unpadded exact `sphere_radius` so while the distance of every vertex of the current mesh from sphere_center will be less than sphere_radius, the faceted sphere primitive may not contain every vertex. Returns minball : trimesh.primitives.Sphere Sphere primitive containing current mesh
`bounds`	The axis aligned bounds of the faces of the mesh. Returns bounds : (2, 3) float or None Bounding box with [min, max] coordinates If mesh is empty will return None
`center_mass`	The point in space which is the center of mass/volume. If the current mesh is not watertight this is meaningless garbage unless it was explicitly set. Returns center_mass : (3, ) float Volumetric center of mass of the mesh
`centroid`	The point in space which is the average of the triangle centroids weighted by the area of each triangle. This will be valid even for non-watertight meshes, unlike self.center_mass Returns centroid : (3, ) float The average vertex weighted by face area
`convex_hull`	Returns a Trimesh object representing the convex hull of the current mesh. Returns convex : trimesh.Trimesh Mesh of convex hull of current mesh
`density`	The density of the mesh. Returns density : float The density of the mesh.
`edges`	Edges of the mesh (derived from faces). Returns edges : (n, 2) int List of vertex indices making up edges
`edges_face`	Which face does each edge belong to. Returns edges_face : (n, ) int Index of self.faces
`edges_sorted`	Edges sorted along axis 1 Returns edges_sorted : (n, 2) Same as self.edges but sorted along axis 1
`edges_sorted_tree`	A KDTree for mapping edges back to edge index. Returns tree : scipy.spatial.cKDTree Tree when queried with edges will return their index in mesh.edges_sorted
`edges_sparse`	Edges in sparse bool COO graph format where connected vertices are True. Returns sparse: (len(self.vertices), len(self.vertices)) bool Sparse graph in COO format
`edges_unique`	The unique edges of the mesh. Returns edges_unique : (n, 2) int Vertex indices for unique edges
`edges_unique_inverse`	Return the inverse required to reproduce self.edges_sorted from self.edges_unique. Useful for referencing edge properties: mesh.edges_unique[mesh.edges_unique_inverse] == m.edges_sorted Returns inverse : (len(self.edges), ) int Indexes of self.edges_unique
`edges_unique_length`	How long is each unique edge. Returns length : (len(self.edges_unique), ) float Length of each unique edge
`euler_number`	Return the Euler characteristic (a topological invariant) for the mesh In order to guarantee correctness, this should be called after remove_unreferenced_vertices Returns euler_number : int Topological invariant
`extents`	The length, width, and height of the axis aligned bounding box of the mesh. Returns extents : (3, ) float or None Array containing axis aligned [length, width, height] If mesh is empty returns None
`face_adjacency`	Find faces that share an edge, which we call here 'adjacent'. Returns adjacency : (n, 2) int Pairs of faces which share an edge Examples In [1]: mesh = trimesh.load('models/featuretype.STL') In [2]: mesh.face_adjacency Out[2]: array([[ 0, 1], [ 2, 3], [ 0, 3], ..., [1112, 949], [3467, 3475], [1113, 3475]]) In [3]: mesh.faces[mesh.face_adjacency[0]] Out[3]: TrackedArray([[ 1, 0, 408], [1239, 0, 1]], dtype=int64) In [4]: import networkx as nx In [5]: graph = nx.from_edgelist(mesh.face_adjacency) In [6]: groups = nx.connected_components(graph)
`face_adjacency_angles`	Return the angle between adjacent faces Returns adjacency_angle : (n, ) float Angle between adjacent faces Each value corresponds with self.face_adjacency
`face_adjacency_convex`	Return faces which are adjacent and locally convex. What this means is that given faces A and B, the one vertex in B that is not shared with A, projected onto the plane of A has a projection that is zero or negative. Returns are_convex : (len(self.face_adjacency), ) bool Face pairs that are locally convex
`face_adjacency_edges`	Returns the edges that are shared by the adjacent faces. Returns edges : (n, 2) int Vertex indices which correspond to face_adjacency
`face_adjacency_edges_tree`	A KDTree for mapping edges back face adjacency index. Returns tree : scipy.spatial.cKDTree Tree when queried with SORTED edges will return their index in mesh.face_adjacency
`face_adjacency_projections`	The projection of the non-shared vertex of a triangle onto its adjacent face Returns projections : (len(self.face_adjacency), ) float Dot product of vertex onto plane of adjacent triangle.
`face_adjacency_radius`	The approximate radius of a cylinder that fits inside adjacent faces. Returns radii : (len(self.face_adjacency), ) float Approximate radius formed by triangle pair
`face_adjacency_span`	The approximate perpendicular projection of the non-shared vertices in a pair of adjacent faces onto the shared edge of the two faces. Returns span : (len(self.face_adjacency), ) float Approximate span between the non-shared vertices
`face_adjacency_tree`	An R-tree of face adjacencies. Returns tree: rtree.index Where each edge in self.face_adjacency has a rectangular cell
`face_adjacency_unshared`	Return the vertex index of the two vertices not in the shared edge between two adjacent faces Returns vid_unshared : (len(mesh.face_adjacency), 2) int Indexes of mesh.vertices
`face_angles`	Returns the angle at each vertex of a face. Returns angles : (len(self.faces), 3) float Angle at each vertex of a face
`face_angles_sparse`	A sparse matrix representation of the face angles. Returns sparse : scipy.sparse.coo_matrix Float sparse matrix with with shape: (len(self.vertices), len(self.faces))
`face_normals`	Return the unit normal vector for each face. If a face is degenerate and a normal can't be generated a zero magnitude unit vector will be returned for that face. Returns normals : (len(self.faces), 3) np.float64 Normal vectors of each face
`faces`	The faces of the mesh. This is regarded as core information which cannot be regenerated from cache, and as such is stored in self._data which tracks the array for changes and clears cached values of the mesh if this is altered. Returns faces : (n, 3) int Representing triangles which reference self.vertices
`faces_sparse`	A sparse matrix representation of the faces. Returns sparse : scipy.sparse.coo_matrix Has properties: dtype : bool shape : (len(self.vertices), len(self.faces))
`faces_unique_edges`	For each face return which indexes in mesh.unique_edges constructs that face. Returns faces_unique_edges : (len(self.faces), 3) int Indexes of self.edges_unique that construct self.faces Examples In [0]: mesh.faces[:2] Out[0]: TrackedArray([[ 1, 6946, 24224], [ 6946, 1727, 24225]]) In [1]: mesh.edges_unique[mesh.faces_unique_edges[:2]] Out[1]: array([[[ 1, 6946], [ 6946, 24224], [ 1, 24224]], [[ 1727, 6946], [ 1727, 24225], [ 6946, 24225]]])
`facets`	Return a list of face indices for coplanar adjacent faces. Returns facets : (n, ) sequence of (m, ) int Groups of indexes of self.faces
`facets_area`	Return an array containing the area of each facet. Returns area : (len(self.facets), ) float Total area of each facet (group of faces)
`facets_boundary`	Return the edges which represent the boundary of each facet Returns edges_boundary : sequence of (n, 2) int Indices of self.vertices
`facets_normal`	Return the normal of each facet Returns normals: (len(self.facets), 3) float A unit normal vector for each facet
`facets_on_hull`	Find which facets of the mesh are on the convex hull. Returns on_hull : (len(mesh.facets), ) bool is A facet on the meshes convex hull or not
`facets_origin`	Return a point on the facet plane. Returns origins : (len(self.facets), 3) float A point on each facet plane
`identifier`	Return a float vector which is unique to the mesh and is robust to rotation and translation. Returns identifier : (6, ) float Identifying properties of the current mesh
`identifier_md5`	An MD5 of the rotation invariant identifier vector Returns hashed : str MD5 hash of the identifier vector
`is_convex`	Check if a mesh is convex or not. Returns is_convex: bool Is mesh convex or not
`is_empty`	Does the current mesh have data defined. Returns empty : bool If True, no data is set on the current mesh
`is_volume`	Check if a mesh has all the properties required to represent a valid volume, rather than just a surface. These properties include being watertight, having consistent winding and outward facing normals. Returns valid : bool Does the mesh represent a volume
`is_watertight`	Check if a mesh is watertight by making sure every edge is included in two faces. Returns is_watertight : bool Is mesh watertight or not
`is_winding_consistent`	Does the mesh have consistent winding or not. A mesh with consistent winding has each shared edge going in an opposite direction from the other in the pair. Returns consistent : bool Is winding is consistent or not
`kdtree`	Return a scipy.spatial.cKDTree of the vertices of the mesh. Not cached as this lead to observed memory issues and segfaults. Returns tree : scipy.spatial.cKDTree Contains mesh.vertices
`mass`	Mass of the current mesh, based on specified density and volume. If the current mesh isn't watertight this is garbage. Returns mass : float Mass of the current mesh
`mass_properties`	Returns the mass properties of the current mesh. Assumes uniform density, and result is probably garbage if mesh isn't watertight. Returns properties : dict With keys: 'volume' : in global units^3 'mass' : From specified density 'density' : Included again for convenience (same as kwarg density) 'inertia' : Taken at the center of mass and aligned with global coordinate system 'center_mass' : Center of mass location, in global coordinate system
`moment_inertia`	Return the moment of inertia matrix of the current mesh. If mesh isn't watertight this is garbage. Returns inertia : (3, 3) float Moment of inertia of the current mesh
`principal_inertia_components`	Return the principal components of inertia Ordering corresponds to mesh.principal_inertia_vectors Returns components : (3, ) float Principal components of inertia
`principal_inertia_transform`	A transform which moves the current mesh so the principal inertia vectors are on the X,Y, and Z axis, and the centroid is at the origin. Returns transform : (4, 4) float Homogeneous transformation matrix
`principal_inertia_vectors`	Return the principal axis of inertia as unit vectors. The order corresponds to `mesh.principal_inertia_components`. Returns vectors : (3, 3) float Three vectors pointing along the principal axis of inertia directions
`referenced_vertices`	Which vertices in the current mesh are referenced by a face. Returns referenced : (len(self.vertices), ) bool Which vertices are referenced by a face
`scale`	A metric for the overall scale of the mesh, the length of the diagonal of the axis aligned bounding box of the mesh. Returns scale : float The length of the meshes AABB diagonal
`symmetry`	Check whether a mesh has rotational symmetry around an axis (radial) or point (spherical). Returns symmetry: None, 'radial', 'spherical' What kind of symmetry does the mesh have.
`symmetry_axis`	If a mesh has rotational symmetry, return the axis. Returns axis : (3, ) float Axis around which a 2D profile was revolved to create this mesh.
`symmetry_section`	If a mesh has rotational symmetry return the two vectors which make up a section coordinate frame. Returns section : (2, 3) float Vectors to take a section along
`triangles`	Actual triangles of the mesh (points, not indexes) Returns triangles : (n, 3, 3) float Points of triangle vertices
`triangles_center`	The center of each triangle (barycentric [1/3, 1/3, 1/3]) Returns triangles_center : (len(self.faces), 3) float Center of each triangular face
`triangles_cross`	The cross product of two edges of each triangle. Returns crosses : (n, 3) float Cross product of each triangle
`triangles_tree`	An R-tree containing each face of the mesh. Returns tree : rtree.index Each triangle in self.faces has a rectangular cell
`units`	Definition of units for the mesh. Returns units : str Unit system mesh is in, or None if not defined
`vertex_adjacency_graph`	Returns a networkx graph representing the vertices and their connections in the mesh. Returns graph: networkx.Graph Graph representing vertices and edges between them where vertices are nodes and edges are edges Examples This is useful for getting nearby vertices for a given vertex, potentially for some simple smoothing techniques. mesh = trimesh.primitives.Box() graph = mesh.vertex_adjacency_graph graph.neighbors(0) [1, 2, 3, 4]
`vertex_defects`	Return the vertex defects, or (2*pi) minus the sum of the angles of every face that includes that vertex. If a vertex is only included by coplanar triangles, this will be zero. For convex regions this is positive, and concave negative. Returns vertex_defect : (len(self.vertices), ) float Vertex defect at the every vertex
`vertex_degree`	Return the number of faces each vertex is included in. Returns degree : (len(self.vertices), ) int Number of faces each vertex is included in
`vertex_faces`	A representation of the face indices that correspond to each vertex. Returns vertex_faces : (n,m) int Each row contains the face indices that correspond to the given vertex, padded with -1 up to the max number of faces corresponding to any one vertex Where n == len(self.vertices), m == max number of faces for a single vertex
`vertex_neighbors`	The vertex neighbors of each vertex of the mesh, determined from the cached vertex_adjacency_graph, if already existent. Returns vertex_neighbors : (len(self.vertices), ) int Represents immediate neighbors of each vertex along the edge of a triangle Examples This is useful for getting nearby vertices for a given vertex, potentially for some simple smoothing techniques. `mesh = trimesh.primitives.Box()` `mesh.vertex_neighbors[0]` `[1, 2, 3, 4]`
`vertex_normals`	The vertex normals of the mesh. If the normals were loaded we check to make sure we have the same number of vertex normals and vertices before returning them. If there are no vertex normals defined or a shape mismatch we calculate the vertex normals from the mean normals of the faces the vertex is used in. Returns vertex_normals : (n, 3) float Represents the surface normal at each vertex. Where n == len(self.vertices)
`vertices`	The vertices of the mesh. This is regarded as core information which cannot be generated from cache and as such is stored in self._data which tracks the array for changes and clears cached values of the mesh if this is altered. Returns vertices : (n, 3) float Points in cartesian space referenced by self.faces
`visual`	Get the stored visuals for the current mesh. Returns visual : ColorVisuals or TextureVisuals Contains visual information about the mesh
`volume`	Volume of the current mesh calculated using a surface integral. If the current mesh isn't watertight this is garbage. Returns volume : float Volume of the current mesh

Methods

`apply_obb`

apply_obb()

Apply the oriented bounding box transform to the current mesh.

This will result in a mesh with an AABB centered at the origin and the same dimensions as the OBB.

Returns

matrix : (4, 4) float Transformation matrix that was applied to mesh to move it into OBB frame

`apply_scale`

apply_scale(
    scaling
)

Scale the mesh.

Parameters

scaling : float or (3,) float Scale factor to apply to the mesh

`apply_transform`

apply_transform(
    matrix
)

Transform mesh by a homogeneous transformation matrix.

Does the bookkeeping to avoid recomputing things so this function should be used rather than directly modifying self.vertices if possible.

Parameters

matrix : (4, 4) float Homogeneous transformation matrix

`apply_translation`

apply_translation(
    translation
)

Translate the current mesh.

Parameters

translation : (3,) float Translation in XYZ

`compute_stable_poses`

compute_stable_poses(
    center_mass=None, sigma=0.0, n_samples=1, threshold=0.0
)

Computes stable orientations of a mesh and their quasi-static probabilities.

This method samples the location of the center of mass from a multivariate gaussian (mean at com, cov equal to identity times sigma) over n_samples. For each sample, it computes the stable resting poses of the mesh on a a planar workspace and evaluates the probabilities of landing in each pose if the object is dropped onto the table randomly.

This method returns the 4x4 homogeneous transform matrices that place the shape against the planar surface with the z-axis pointing upwards and a list of the probabilities for each pose. The transforms and probabilties that are returned are sorted, with the most probable pose first.

Parameters

center_mass : (3, ) float The object center of mass (if None, this method assumes uniform density and watertightness and computes a center of mass explicitly) sigma : float The covariance for the multivariate gaussian used to sample center of mass locations n_samples : int The number of samples of the center of mass location threshold : float The probability value at which to threshold returned stable poses

Returns

transforms : (n, 4, 4) float The homogeneous matrices that transform the object to rest in a stable pose, with the new z-axis pointing upwards from the table and the object just touching the table.

probs : (n, ) float A probability ranging from 0.0 to 1.0 for each pose

`contains`

contains(
    points
)

Given an array of points determine whether or not they are inside the mesh. This raises an error if called on a non-watertight mesh.

Parameters

points : (n, 3) float Points in cartesian space

Returns

contains : (n, ) bool Whether or not each point is inside the mesh

`convert_units`

convert_units(
    desired, guess=False
)

Convert the units of the mesh into a specified unit.

Parameters

desired : string Units to convert to (eg 'inches') guess : boolean If self.units are not defined should we guess the current units of the document and then convert?

`convex_decomposition`

convex_decomposition(
    maxhulls=20, **kwargs
)

Compute an approximate convex decomposition of a mesh.

testVHACD Parameters which can be passed as kwargs:

Name Default

resolution 100000 max. concavity 0.001 plane down-sampling 4 convex-hull down-sampling 4 alpha 0.05 beta 0.05 maxhulls 10 pca 0 mode 0 max. vertices per convex-hull 64 min. volume to add vertices to convex-hulls 0.0001 convex-hull approximation 1 OpenCL acceleration 1 OpenCL platform ID 0 OpenCL device ID 0 output output.wrl log log.txt

Parameters

maxhulls : int Maximum number of convex hulls to return **kwargs : testVHACD keyword arguments

Returns

meshes : list of trimesh.Trimesh List of convex meshes that approximate the original

`copy`

copy(
    include_cache=False
)

Safely return a copy of the current mesh.

By default, copied meshes will have emptied cache to avoid memory issues and so may be slow on initial operations until caches are regenerated.

Current object will never have its cache cleared.

Parameters

include_cache : bool If True, will shallow copy cached data to new mesh

Returns

copied : trimesh.Trimesh Copy of current mesh

`crc`

crc()

A zlib.adler32 checksum for the current mesh data.

This is about 5x faster than an MD5, and the checksum is checked every time something is requested from the cache so it gets called a lot.

Returns

crc : int Checksum of current mesh data

`difference`

difference(
    other, engine=None, **kwargs
)

Boolean difference between this mesh and n other meshes

Parameters

other : trimesh.Trimesh, or list of trimesh.Trimesh objects Meshes to difference

Returns

difference : trimesh.Trimesh Difference between self and other Trimesh objects

`eval_cached`

eval_cached(
    statement, *args
)

Evaluate a statement and cache the result before returning.

Statements are evaluated inside the Trimesh object, and

Parameters

statement : str Statement of valid python code *args : list Available inside statement as args[0], etc

Returns

result : result of running eval on statement with args

Examples

r = mesh.eval_cached('np.dot(self.vertices, args[0])', [0, 0, 1])

`export`

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

Export the current mesh to a file object. If file_obj is a filename, file will be written there.

Supported formats are stl, off, ply, collada, json, dict, glb, dict64, msgpack.

Parameters

file_obj: open writeable file object str, file name where to save the mesh None, if you would like this function to return the export blob file_type: str Which file type to export as. If file name is passed this is not required

`fill_holes`

fill_holes()

Fill single triangle and single quad holes in the current mesh.

Returns

watertight : bool Is the mesh watertight after the function completes

`fix_normals`

fix_normals(
    *args, **kwargs
)

Find and fix problems with self.face_normals and self.faces winding direction.

For face normals ensure that vectors are consistently pointed outwards, and that self.faces is wound in the correct direction for all connected components.

Parameters

multibody : None or bool Fix normals across multiple bodies if None automatically pick from body_count

`intersection`

intersection(
    other, engine=None, **kwargs
)

Boolean intersection between this mesh and n other meshes

Parameters

other : trimesh.Trimesh, or list of trimesh.Trimesh objects Meshes to calculate intersections with

Returns

intersection : trimesh.Trimesh Mesh of the volume contained by all passed meshes

`invert`

invert()

Invert the mesh in-place by reversing the winding of every face and negating normals without dumping the cache.

Alters self.faces by reversing columns, and negating self.face_normals and self.vertex_normals.

`md5`

md5()

An MD5 of the core geometry information for the mesh, faces and vertices.

Generated from TrackedArray which subclasses np.ndarray to monitor array for changes and returns a correct lazily evaluated md5 so it only has to recalculate the hash occasionally, rather than on every call.

Returns

md5 : string MD5 of everything in the DataStore

`merge_vertices`

merge_vertices(
    **kwargs
)

Removes duplicate vertices, grouped by position and optionally texture coordinate and normal.

Parameters

mesh : Trimesh object Mesh to merge vertices on merge_tex : bool If True textured meshes with UV coordinates will have vertices merged regardless of UV coordinates merge_norm : bool If True, meshes with vertex normals will have vertices merged ignoring different normals digits_vertex : None or int Number of digits to consider for vertex position digits_norm : int Number of digits to consider for unit normals digits_uv : int Number of digits to consider for UV coordinates

`outline`

outline(
    face_ids=None, **kwargs
)

Given a list of face indexes find the outline of those faces and return it as a Path3D.

The outline is defined here as every edge which is only included by a single triangle.

Note that this implies a non-watertight mesh as the outline of a watertight mesh is an empty path.

Parameters

face_ids : (n, ) int Indices to compute the outline of. If None, outline of full mesh will be computed. **kwargs: passed to Path3D constructor

Returns

path : Path3D Curve in 3D of the outline

`process`

process(
    validate=False, **kwargs
)

Do processing to make a mesh useful.

Does this by:

1) removing NaN and Inf values 2) merging duplicate vertices

If validate:

3) Remove triangles which have one edge of their rectangular 2D oriented bounding box shorter than tol.merge 4) remove duplicated triangles 5) ensure triangles are consistently wound and normals face outwards

Parameters

validate : bool If True, remove degenerate and duplicate faces

Returns

self: trimesh.Trimesh Current mesh

`register`

register(
    other, **kwargs
)

Align a mesh with another mesh or a PointCloud using the principal axes of inertia as a starting point which is refined by iterative closest point.

Parameters

mesh : trimesh.Trimesh object Mesh to align with other other : trimesh.Trimesh or (n, 3) float Mesh or points in space samples : int Number of samples from mesh surface to align icp_first : int How many ICP iterations for the 9 possible combinations of icp_final : int How many ICP itertations for the closest candidate from the wider search

Returns

mesh_to_other : (4, 4) float Transform to align mesh to the other object cost : float Average square distance per point

`remove_degenerate_faces`

remove_degenerate_faces(
    height=tol.merge
)

Remove degenerate faces (faces without 3 unique vertex indices) from the current mesh.

If a height is specified, it will remove any face with a 2D oriented bounding box with one edge shorter than that height.

If not specified, it will remove any face with a zero normal.

Parameters

height : float If specified removes faces with an oriented bounding box shorter than this on one side.

Returns

nondegenerate : (len(self.faces), ) bool Mask used to remove faces

`remove_duplicate_faces`

remove_duplicate_faces()

On the current mesh remove any faces which are duplicates.

Alters self.faces to remove duplicate faces

`remove_infinite_values`

remove_infinite_values()

Ensure that every vertex and face consists of finite numbers. This will remove vertices or faces containing np.nan and np.inf

Alters self.faces and self.vertices

`remove_unreferenced_vertices`

remove_unreferenced_vertices()

Remove all vertices in the current mesh which are not referenced by a face.

`rezero`

rezero()

Translate the mesh so that all vertex vertices are positive.

Alters self.vertices.

`sample`

sample(
    count, return_index=False, face_weight=None
)

Return random samples distributed across the surface of the mesh

Parameters

count : int Number of points to sample return_index : bool If True will also return the index of which face each sample was taken from. face_weight : None or len(mesh.faces) float Weight faces by a factor other than face area. If None will be the same as face_weight=mesh.area

Returns

samples : (count, 3) float Points on surface of mesh face_index : (count, ) int Index of self.faces

`scene`

scene(
    **kwargs
)

Returns a Scene object containing the current mesh.

Returns

scene : trimesh.scene.scene.Scene Contains just the current mesh

`section`

section(
    plane_normal, plane_origin, **kwargs
)

Returns a 3D cross section of the current mesh and a plane defined by origin and normal.

Parameters

plane_normal: (3) vector for plane normal Normal vector of section plane plane_origin : (3, ) float Point on the cross section plane

Returns

intersections: Path3D or None Curve of intersection

`section_multiplane`

section_multiplane(
    plane_origin, plane_normal, heights
)

Return multiple parallel cross sections of the current mesh in 2D.

Parameters

plane_origin : (3, ) float Point on the cross section plane plane_normal: (3) vector for plane normal Normal vector of section plane heights : (n, ) float Each section is offset by height along the plane normal.

Returns

paths : (n, ) Path2D or None 2D cross sections at specified heights. path.metadata['to_3D'] contains transform to return 2D section back into 3D space.

`show`

show(
    **kwargs
)

Render the mesh in an opengl window. Requires pyglet.

Parameters

smooth : bool Run smooth shading on mesh or not, large meshes will be slow

Returns

scene : trimesh.scene.Scene Scene with current mesh in it

`simplify_quadratic_decimation`

simplify_quadratic_decimation(
    face_count
)

A thin wrapper around the open3d implementation of this: open3d.geometry.TriangleMesh.simplify_quadric_decimation

Parameters

face_count : int Number of faces desired in the resulting mesh.

Returns

simple : trimesh.Trimesh Simplified version of mesh.

`slice_plane`

slice_plane(
    plane_origin, plane_normal, cap=False, **kwargs
)

Slice the mesh with a plane, returning a new mesh that is the portion of the original mesh to the positive normal side of the plane

plane_origin : (3,) float Point on plane to intersect with mesh plane_normal : (3,) float Normal vector of plane to intersect with mesh cap : bool If True, cap the result with a triangulated polygon cached_dots : (n, 3) float If an external function has stored dot products pass them here to avoid recomputing

Returns

new_mesh: trimesh.Trimesh or None Subset of current mesh that intersects the half plane to the positive normal side of the plane

`smoothed`

smoothed(
    *args, **kwargs
)

Return a version of the current mesh which will render nicely, without changing source mesh.

Parameters

angle : float or None Angle in radians face pairs with angles smaller than this will appear smoothed facet_minarea : float or None Minimum area fraction to consider IE for facets_minarea=25 only facets larger than mesh.area / 25 will be considered.

Returns

smoothed : trimesh.Trimesh Non watertight version of current mesh which will render nicely with smooth shading

`split`

split(
    *args, **kwargs
)

Returns a list of Trimesh objects, based on face connectivity. Splits into individual components, sometimes referred to as 'bodies'

Parameters

only_watertight : bool Only return watertight meshes and discard remainder adjacency : None or (n, 2) int Override face adjacency with custom values

Returns

meshes : (n, ) trimesh.Trimesh Separate bodies from original mesh

`subdivide`

subdivide(
    face_index=None
)

Subdivide a mesh, with each subdivided face replaced with four smaller faces.

Parameters

face_index: (m, ) int or None If None all faces of mesh will be subdivided If (m, ) int array of indices: only specified faces will be subdivided. Note that in this case the mesh will generally no longer be manifold, as the additional vertex on the midpoint will not be used by the adjacent faces to the faces specified, and an additional postprocessing step will be required to make resulting mesh watertight

`subdivide_to_size`

subdivide_to_size(
    max_edge, max_iter=10, return_index=False
)

Subdivide a mesh until every edge is shorter than a specified length.

Will return a triangle soup, not a nicely structured mesh.

Parameters

max_edge : float Maximum length of any edge in the result max_iter : int The maximum number of times to run subdivision return_index : bool If True, return index of original face for new faces

`submesh`

submesh(
    faces_sequence, **kwargs
)

Return a subset of the mesh.

Parameters

faces_sequence : sequence (m, ) int Face indices of mesh only_watertight : bool Only return submeshes which are watertight append : bool Return a single mesh which has the faces appended. if this flag is set, only_watertight is ignored

Returns

if append : trimesh.Trimesh object else : list of trimesh.Trimesh objects

`to_dict`

to_dict()

Return a dictionary representation of the current mesh, with keys that can be used as the kwargs for the Trimesh constructor, eg:

a = Trimesh(**other_mesh.to_dict())

Returns

result : dict With keys that match trimesh constructor

`union`

union(
    other, engine=None, **kwargs
)

Boolean union between this mesh and n other meshes

Parameters

other : Trimesh or (n, ) Trimesh Other meshes to union engine : None or str Which backend to use

Returns

union : trimesh.Trimesh Union of self and other Trimesh objects

`unmerge_vertices`

unmerge_vertices()

Removes all face references so that every face contains three unique vertex indices and no faces are adjacent.

`unwrap`

unwrap(
    image=None
)

Returns a Trimesh object equivalent to the current mesh where the vertices have been assigned uv texture coordinates. Vertices may be split into as many as necessary by the unwrapping algorithm, depending on how many uv maps they appear in.

Requires pip install xatlas

Parameters

image : None or PIL.Image Image to assign to the material

Returns

unwrapped : trimesh.Trimesh Mesh with unwrapped uv coordinates

`update_faces`

update_faces(
    mask
)

In many cases, we will want to remove specific faces. However, there is additional bookkeeping to do this cleanly. This function updates the set of faces with a validity mask, as well as keeping track of normals and colors.

Parameters

valid : (m) int or (len(self.faces)) bool Mask to remove faces

`update_vertices`

update_vertices(
    mask, inverse=None
)

Update vertices with a mask.

Parameters

vertex_mask : (len(self.vertices)) bool Array of which vertices to keep inverse : (len(self.vertices)) int Array to reconstruct vertex references such as output by np.unique

`voxelized`

voxelized(
    pitch, method='subdivide', **kwargs
)

Return a VoxelGrid object representing the current mesh discretized into voxels at the specified pitch

Parameters

pitch : float The edge length of a single voxel method: implementation key. See trimesh.voxel.creation.voxelizers **kwargs: additional kwargs passed to the specified implementation.

Returns

voxelized : VoxelGrid object Representing the current mesh

`add`

__add__(
    other
)

Concatenate the mesh with another mesh.

Parameters

other : trimesh.Trimesh object Mesh to be concatenated with self

Returns

concat : trimesh.Trimesh Mesh object of combined result

`radd`

__radd__(
    other
)

Concatenate the geometry allowing concatenation with built in sum() function: sum(Iterable[trimesh.Trimesh])

Parameters

other : Geometry Geometry or 0

Returns

concat : Geometry Geometry of combined result

tfg.io.triangle_mesh.Trimesh

Attributes

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Examples

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Examples

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Returns

Examples

Returns

Returns

Returns

Returns

`apply_obb`

`apply_scale`

`apply_transform`

`apply_translation`

`compute_stable_poses`

`contains`

`convert_units`

`convex_decomposition`

`copy`

`crc`

`difference`

`eval_cached`

`export`

`fill_holes`

`fix_normals`

`intersection`

`invert`

`md5`

`merge_vertices`

`outline`

`process`

`register`

`remove_degenerate_faces`

`remove_duplicate_faces`

`remove_infinite_values`

`remove_unreferenced_vertices`

`rezero`