|
| 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.
|
| |
| 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.
|
| |
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.)
- Parameters
-
| [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 |
- Returns
- 0 if same, otherwise return 1.
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.
- Todo:
-
- Parameters
-
| [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 |
- Returns
- the bu_data_hash value of the mesh.
1.9.8