- Generated on Tue Jul 21 2026 02:18:12 for BRL-CAD by
1.9.8
|
BRL-CAD
|
Data Structures | |
| struct | bg_trimesh_halfedge |
| Algorithms related to 3D meshes built from triangles. More... | |
| struct | bg_trimesh_edges |
| struct | bg_trimesh_faces |
| struct | bg_trimesh_solid_errors |
| struct | bg_trimesh_decimation_settings |
| struct | bg_trimesh_optimization_settings |
| struct | bg_trimesh_repair_opts |
| struct | bg_trimesh_remesh_opts |
Macros | |
| #define | BG_TRIMESH_EDGES_INIT_NULL {0, NULL} |
| #define | BG_TRIMESH_FACES_INIT_NULL {0, NULL} |
| #define | BG_TRIMESH_SOLID_ERRORS_INIT_NULL {BG_TRIMESH_FACES_INIT_NULL, BG_TRIMESH_EDGES_INIT_NULL, BG_TRIMESH_EDGES_INIT_NULL, BG_TRIMESH_EDGES_INIT_NULL} |
| #define | BG_TRIMESH_DECIMATION_METHOD_DEFAULT 0 |
| #define | BG_TRIMESH_DECIMATION_SETTINGS_INIT {BG_TRIMESH_DECIMATION_METHOD_DEFAULT, 0.0, 0.0, 0, BU_VLS_INIT_ZERO} |
| #define | BG_TRIMESH_OPTIMIZATION_SETTINGS_INIT {0, 0.0, 0.0, 0} |
| #define | BG_TRIMESH_REPAIR_OPTS_DEFAULT {0.0, 5.0} |
| #define | BG_TRIMESH_REMESH_OPTS_DEFAULT {0, 10.0, 0.04, 5, 30} |
Typedefs | |
| typedef int(* | bg_face_error_func_t) (int face_idx, void *data) |
| typedef int(* | bg_edge_error_funct_t) (struct bg_trimesh_halfedge *edge, void *data) |
Functions | |
| void | bg_free_trimesh_edges (struct bg_trimesh_edges *edges) |
| void | bg_free_trimesh_faces (struct bg_trimesh_faces *faces) |
| void | bg_free_trimesh_solid_errors (struct bg_trimesh_solid_errors *errors) |
| int | bg_trimesh_manifold_closed (int vcnt, int fcnt, fastf_t *v, int *f) |
| int | bg_trimesh_oriented (int vcnt, int fcnt, fastf_t *v, int *f) |
| int | bg_trimesh_solid (int vcnt, int fcnt, fastf_t *v, int *f, int **bedges) |
| int | bg_trimesh_face_exit (int face_idx, void *data) |
| int | bg_trimesh_face_continue (int face_idx, void *data) |
| int | bg_trimesh_face_gather (int face_idx, void *data) |
| int | bg_trimesh_edge_exit (struct bg_trimesh_halfedge *edge, void *data) |
| int | bg_trimesh_edge_continue (struct bg_trimesh_halfedge *edge, void *data) |
| int | bg_trimesh_edge_gather (struct bg_trimesh_halfedge *edge, void *data) |
| int | bg_trimesh_degenerate_faces (int num_faces, int *fpoints, bg_face_error_func_t degenerate_func, void *data) |
| int | bg_trimesh_unmatched_edges (int num_edges, struct bg_trimesh_halfedge *edge_list, bg_edge_error_funct_t error_edge_func, void *data) |
| int | bg_trimesh_misoriented_edges (int num_edges, struct bg_trimesh_halfedge *edge_list, bg_edge_error_funct_t error_edge_func, void *data) |
| int | bg_trimesh_excess_edges (int num_edges, struct bg_trimesh_halfedge *edge_list, bg_edge_error_funct_t error_edge_func, void *data) |
| int | bg_trimesh_solid2 (int vcnt, int fcnt, fastf_t *v, int *f, struct bg_trimesh_solid_errors *errors) |
| int | bg_trimesh_hanging_nodes (int num_vertices, int num_faces, fastf_t *vertices, int *faces, struct bg_trimesh_solid_errors *errors) |
| struct bg_trimesh_halfedge * | bg_trimesh_generate_edge_list (int fcnt, int *f) |
| int | bg_trimesh_aabb (point_t *min, point_t *max, const int *faces, size_t num_faces, const point_t *p, size_t num_pnts) |
| Calculate an axis aligned bounding box (RPP) for a triangle mesh. | |
| fastf_t | bg_trimesh_area (const int *faces, size_t num_faces, const point_t *p, size_t num_pnts) |
| Calculate the surface area of a triangle mesh. | |
| fastf_t | bg_trimesh_volume (const int *faces, size_t num_faces, const point_t *p, size_t num_pnts) |
| int | bg_trimesh_decimate (int **ofaces, int *n_ofaces, int *ifaces, int n_ifaces, point_t *p, int n_p, struct bg_trimesh_decimation_settings *s) |
| Decimate a mesh and return the decimated faces. | |
| int | bg_trimesh_isect (int **faces_inside_1, int *num_faces_inside_1, int **faces_inside_2, int *num_faces_inside_2, int **faces_isect_1, int *num_faces_isect_1, int **faces_isect_2, int *num_faces_isect_2, int *faces_1, int num_faces_1, point_t *vertices_1, int num_vertices_1, int *faces_2, int num_faces_2, point_t *vertices_2, int num_vertices_2) |
| int | bg_trimesh_normals (vect_t **onorms, int *ifaces, int n_ifaces, point_t *p, int n_p) |
| Compute vertex normals for a mesh based on the connected faces. | |
| int | bg_trimesh_optimize (int **ofaces, int *n_ofaces, point_t **opnts, vect_t **onorms, int *n_opnts, const int *ifaces, int n_ifaces, const point_t *ipnts, const vect_t *inorms, struct bg_trimesh_optimization_settings *s) |
| Return trimesh information for a 3D mesh that contains just the date needed to represent in the mesh. Used to finalize intermediate processing meshes to generate a compact mesh for export or storage. | |
| int | bg_trimesh_2d_gc (int **ofaces, int *n_ofaces, point2d_t **opnts, int *n_opnts, const int *ifaces, int n_ifaces, const point2d_t *ipnts) |
| Return trimesh information for a planar (2D) mesh that contains just the set of points active in the mesh. | |
| int | bg_trimesh_3d_gc (int **ofaces, point_t **opnts, int *n_opnts, const int *faces, int num_faces, const point_t *in_pts) |
| Return trimesh information for a 3D mesh that contains just the set of points active in the mesh. | |
| int | bg_trimesh_sync (int *of, int *f, int fcnt) |
| Return a face set where all topologically connected faces are oriented consistently relative to their neighbors. | |
| int | bg_trimesh_split (int ***ofs, int **ofc, int *f, int fcnt) |
| Return a set of face sets where all topologically connected faces are grouped into common sets. | |
| int | bg_trimesh_2d_plot3 (const char *fname, const int *faces, size_t num_faces, const point2d_t *pnts, size_t num_pnts) |
| Return a set of face sets where all topologically connected faces are grouped into common sets. | |
| int | bg_trimesh_diff (const int *f1, size_t num_f1, const point_t *p1, size_t num_p1, const int *f2, size_t num_f2, const point_t *p2, size_t num_p2, fastf_t dist_tol) |
| Compare two trimeshes to determine if they (within tolerance) define the same mesh. | |
| unsigned long long | bg_trimesh_hash (const int *f, size_t num_f, const point_t *p, size_t num_p, fastf_t dist_tol) |
| Generate a hash from the mesh data, using the tolerance parameter to clamp the numerical values. Both vertex positions and face topology are considered, in a style similar to bg_trimesh_diff. | |
| int | bg_trimesh_repair (int **ofaces, int *n_ofaces, point_t **opnts, int *n_opnts, const int *ifaces, int n_ifaces, const point_t *ipnts, int n_ipnts, struct bg_trimesh_repair_opts *opts) |
| Attempt to repair a non-manifold triangle mesh so that it becomes a closed, consistently-oriented solid. | |
| int | bg_trimesh_remesh (int **ofaces, int *n_ofaces, point_t **opnts, int *n_opnts, const int *ifaces, int n_ifaces, const point_t *ipnts, int n_ipnts, struct bg_trimesh_remesh_opts *opts) |
| Remesh a triangle mesh to improve element quality and/or change density. | |
| #define BG_TRIMESH_SOLID_ERRORS_INIT_NULL {BG_TRIMESH_FACES_INIT_NULL, BG_TRIMESH_EDGES_INIT_NULL, BG_TRIMESH_EDGES_INIT_NULL, BG_TRIMESH_EDGES_INIT_NULL} |
| #define BG_TRIMESH_DECIMATION_SETTINGS_INIT {BG_TRIMESH_DECIMATION_METHOD_DEFAULT, 0.0, 0.0, 0, BU_VLS_INIT_ZERO} |
| #define BG_TRIMESH_OPTIMIZATION_SETTINGS_INIT {0, 0.0, 0.0, 0} |
| #define BG_TRIMESH_REPAIR_OPTS_DEFAULT {0.0, 5.0} |
| #define BG_TRIMESH_REMESH_OPTS_DEFAULT {0, 10.0, 0.04, 5, 30} |
| typedef int(* bg_edge_error_funct_t) (struct bg_trimesh_halfedge *edge, void *data) |
|
extern |
|
extern |
|
extern |
|
extern |
Check if a mesh is topologically closed and manifold. True if for every edge, there is exactly one other edge with the same two end vertices.
|
extern |
Check if a mesh is consistently oriented. True if for every edge that has exactly one matching edge, the two edges have opposite orientations. Note that an open mesh can be oriented, but a non-manifold mesh cannot.
|
extern |
Check if a mesh is topologically solid. Returns 1 if the mesh is NOT SOLID and 0 if the mesh is SOLID. A SOLID (0) outcome indicates the mesh satisfies all three criteria: Closed, Manifold, Oriented
|
extern |
|
extern |
|
extern |
|
extern |
|
extern |
|
extern |
|
extern |
|
extern |
|
extern |
|
extern |
|
extern |
|
extern |
|
extern |
|
extern |
Calculate an axis aligned bounding box (RPP) for a triangle mesh.
NOTE: This routine bounds only those points that are active in the triangle mesh, not all points present in the supplied points array.
| [out] | min | XYZ coordinate defining the minimum bbox point |
| [out] | max | XYZ coordinate defining the maximum bbox point |
| [in] | faces | array of trimesh faces |
| [in] | num_faces | size of faces array |
| [in] | p | array that holds the points defining the trimesh |
| [in] | num_pnts | size of pnts array |
|
extern |
Calculate the surface area of a triangle mesh.
| [in] | faces | array of trimesh faces |
| [in] | num_faces | size of faces array |
| [in] | p | array that holds the points defining the trimesh |
| [in] | num_pnts | size of pnts array |
|
extern |
Calculate the volume enclosed by a closed, consistently-oriented triangle mesh using the divergence theorem (signed-tetrahedra method).
The mesh must be closed and consistently oriented (all face normals pointing outward or all inward). Consistent orientation is guaranteed for meshes that pass bg_trimesh_solid2() with zero unmatched edges. The function returns the absolute value of the signed result, so it works correctly regardless of whether normals point inward or outward.
| [in] | faces | flat array of triangle indices (3 ints per face) |
| [in] | num_faces | number of triangles |
| [in] | p | array of vertex positions |
| [in] | num_pnts | number of vertices |
|
extern |
Decimate a mesh and return the decimated faces.
| [out] | ofaces | faces array for the new output mesh |
| [out] | n_ofaces | length of ofaces array |
| [in] | ifaces | array of input trimesh |
| [in] | n_ifaces | size of input faces array |
| [in] | p | array that holds the points defining the trimesh |
| [in] | n_p | size of points array |
| [in] | s | decimation settings |
NOTE: This routine will not produce a points array that includes only the points used in the decimated mesh - to generate that output, use the bg_trimesh_3d_gc routine with the ofaces set produced by this function.
|
extern |
|
extern |
Compute vertex normals for a mesh based on the connected faces.
| [out] | onorms | array of normals - will have the same length as the input points array |
| [in] | ifaces | array of input trimesh |
| [in] | n_ifaces | size of input faces array |
| [in] | p | array that holds the points defining the trimesh |
| [in] | n_p | size of points array |
NOTE: Any vertex point not used by the triangles in the trimesh will have a zero normal in the onorms array. This routine does not repack the data to eliminate unused vertices - for that use bg_trimesh_optimize
|
extern |
Return trimesh information for a 3D mesh that contains just the date needed to represent in the mesh. Used to finalize intermediate processing meshes to generate a compact mesh for export or storage.
| [out] | ofaces | faces array for the new output mesh with new indices based on opnts array. |
| [out] | n_ofaces | length of ofaces array |
| [out] | opnts | compact points array for the new output mesh. |
| [out] | onorms | (optional) compact normals array for the output mesh's points. |
| [out] | n_opnts | length of opnts array. |
| [in] | ifaces | array of input trimesh |
| [in] | n_ifaces | size of input faces array |
| [in] | ipnts | array that holds the points defining the original trimesh |
| [in] | inorms | (optional) array that holds the normals for the mesh vertices |
| [in] | s | (optional) settings to enable various additional processing steps |
|
extern |
Return trimesh information for a planar (2D) mesh that contains just the set of points active in the mesh.
| [out] | ofaces | faces array for the new output mesh |
| [out] | n_ofaces | length of ofaces array |
| [out] | opnts | points array for the new output mesh |
| [out] | n_opnts | length of opnts array |
| [in] | ifaces | array of input trimesh |
| [in] | n_ifaces | size of input faces array |
| [in] | ipnts | array that holds the points defining the original trimesh |
|
extern |
Return trimesh information for a 3D mesh that contains just the set of points active in the mesh.
| [out] | ofaces | faces array for the new output mesh. |
| [out] | opnts | points array for the new output mesh. |
| [out] | n_opnts | length of opnts array. |
| [in] | faces | array of input trimesh |
| [in] | num_faces | size of input faces array |
| [in] | in_pts | holds the points defining the original trimesh |
|
extern |
Return a face set where all topologically connected faces are oriented consistently relative to their neighbors.
| [out] | of | faces array for the new output mesh (of==f is valid). |
| [in] | f | input set of faces. |
| [in] | fcnt | input face count |
|
extern |
Return a set of face sets where all topologically connected faces are grouped into common sets.
| [out] | ofs | array of faces arrays containing the new output face sets. |
| [out] | ofc | array of face counts for the new output face sets. |
| [in] | f | input set of faces. |
| [in] | fcnt | input face count |
|
extern |
Return a set of face sets where all topologically connected faces are grouped into common sets.
| [in] | fname | plot file name |
| [in] | faces | face index array |
| [in] | num_faces | number of faces |
| [in] | pnts | points array |
| [in] | num_pnts | number of points |
|
extern |
Compare two trimeshes to determine if they (within tolerance) define the same mesh.
This is a fairly focused function whose purpose is to spot meshes that have potentially gone through numerical or topological reordering but still define the same volume (for example, meshes that have been rotated or translated and then returned to an origin with PCA.) By design it does not analyze the differences to report on why two meshes differ - it simply returns a yes/no decision. Different vertex or face counts are grounds for immediate declaration the meshes differ - no effort is made to look for duplicate vertices or degenerate faces. Any such clean-ups must be performed before calling this function.
The specification of a distance tolerance is used for vertex comparisons. Below the specified threshold, vertices that would otherwise be considered rejection criteria for being different will be considered the same. HOWEVER, that tolerance does NOT merge vertices - rather, when vertices are organized and sorted for comparison the candidate pairing vertices in the arrays are compared using the tolerance.
Both vertex positions and face topology must be compatible - faces may use a different starting vertex (i.e. 0->1->2 and 1->2->0 are considered to be the same) but the ordering must be consistent (i.e. 0->2->1 would not be considered the same.)
| [in] | f1 | face index array referencing points in p1 |
| [in] | num_f1 | number of faces in f1 |
| [in] | p1 | first points array |
| [in] | num_p1 | number of points in p1 |
| [in] | f2 | face index array referencing points in p2 |
| [in] | num_f2 | number of faces in f2 |
| [in] | p2 | second points array |
| [in] | num_p2 | number of points in p2 |
| [in] | dist_tol | distance in mm below which points are considered the same |
|
extern |
Generate a hash from the mesh data, using the tolerance parameter to clamp the numerical values. Both vertex positions and face topology are considered, in a style similar to bg_trimesh_diff.
The clamping needed to generate a hash value will increase the chances of two similar meshes having the same hash, but the nature of numerical clamping results in some very close but not exact values clamping in opposite directions. Without global awareness of all vertex points at play in a database it is not possible to establish a binning that will work for all meshes in the same way (and there are no guarantees it is possible even with that knowledge, strictly speaking.) For a proper distance-based comparison of two meshes, bg_trimesh_diff should be used rather than comparing hash values. However, if mesh hash values DO match then the associated meshes should be quite close to being the same geometry per the specified tolerance - and in practice there are situations where we can get enough matching hashes to be useful - trial runs of PCA oriented BoT object grouping on a large database were able to identify matching hashes for about 80% of the cases were bg_trimesh_diff was able to geometrically identify fuzzy matches.
Applications for this hash include looking up data associated with meshes via hash keys - if a large majority of duplicate meshes can be spotted in a .g database and indexed this way, it makes it possible to reduce the amount of duplicate data being stored. It is also possible to associated meshes with their hashes and then use a bg_trimesh_diff result to further map those hashes to unique data copies.
| [in] | f | face index array referencing points in p |
| [in] | num_f | number of faces in f |
| [in] | p | points array |
| [in] | num_p | number of points in p |
| [in] | dist_tol | tolerance used when clamping points |
|
extern |
Attempt to repair a non-manifold triangle mesh so that it becomes a closed, consistently-oriented solid.
The function:
opts.| [out] | ofaces | output face index array (caller must bu_free) |
| [out] | n_ofaces | number of faces in ofaces |
| [out] | opnts | output point array (caller must bu_free) |
| [out] | n_opnts | number of points in opnts |
| [in] | ifaces | input face index array (3 ints per face) |
| [in] | n_ifaces | number of faces in ifaces |
| [in] | ipnts | input point array |
| [in] | n_ipnts | number of points in ipnts |
| [in] | opts | repair options; NULL uses BG_TRIMESH_REPAIR_OPTS_DEFAULT |
ofaces / opnts are not set ofaces / opnts
|
extern |
Remesh a triangle mesh to improve element quality and/or change density.
A Geogram-based pre-repair pass is run on the input before remeshing so that degenerate or near-duplicate geometry does not confuse the CVT solver. The output mesh is a new triangulation of the same surface.
| [out] | ofaces | output face index array (caller must bu_free) |
| [out] | n_ofaces | number of faces in ofaces |
| [out] | opnts | output point array (caller must bu_free) |
| [out] | n_opnts | number of points in opnts |
| [in] | ifaces | input face index array (3 ints per face) |
| [in] | n_ifaces | number of faces in ifaces |
| [in] | ipnts | input point array |
| [in] | n_ipnts | number of points in ipnts |
| [in] | opts | remesh options; NULL uses BG_TRIMESH_REMESH_OPTS_DEFAULT |
ofaces / opnts 1.9.8