mirror of
https://github.com/OrcaSlicer/OrcaSlicer.git
synced 2026-10-14 03:11:19 +00:00
Ian Bassi
6d35ff6b9a
* Add CGAL-based mesh repair, drop Netfabb remnants Add repair_mesh() in MeshRepair.cpp, a CGAL-based repair that replaces MeshBoolean::cgal::repair(). It welds cracks, cancels coincident triangles, fixes orientation, fills holes (including planar annular regions), removes local self-intersections, and unites crossing shells with libigl's exact boolean while following the nonzero winding rule used by slicing. FixModelByCgal now repairs each volume in place without splitting it into parts, and reports whether the mesh was modified so unchanged meshes keep their painting and ids. The texture import repair prompt no longer depends on the Windows SDK, and the FIX_THROUGH_CGAL_ALWAYS conditionals are removed. The commented-out Netfabb/WIN10SDK build code is deleted. libslic3r_cgal now builds with CGAL_LINKED_WITH_TBB and links TBB. Add docs/HLSD/mesh-repair.md and unit tests in test_mesh_repair.cpp. * Parallelize repair while preserving separate shells Repair connected mesh units and shells independently in parallel, keep crossing shells separate, and limit self-intersection remeshing to local defects. Update mesh-repair documentation and tests for the revised behavior. * Make mesh repair deterministic and report its progress Flags written from parallel loops were std::vector<bool>, whose neighbouring bits share a word, so shells could be kept or dropped at random; they are now std::vector<char>. Holes of up to 100 edges are filled with the search over all triangles: the search restricted to a 3D Delaunay triangulation picks between equally good fills differently from run to run. Shells of fewer than four faces are dropped, as the volumes of two triangles back to back need not cancel exactly, and a shell that self-intersection removal changed is split again so the pieces it cut off are dropped too. repair_mesh() takes a progress callback in place of the cancel callback, and Fix Model reports each stage. The object's bounding box is now invalidated even when a cancel or an error stops the repair after some volumes were replaced. The edge-use sort, union-find and box-overlap code shared by several stages is factored out, the topology analysed for welding is reused to build the work units, the orientation pass checks only the edges it cut, and the output is written from the shells without joining them first. * Fix Split to parts crashing on flat pieces and staying offered after a repair ModelVolume::split() added every piece to the object and then deleted the pieces without a convex hull. When the first piece was flat, as often in a triangle soup, that deleted the volume being split while split() and its caller kept using it. A part made only of flat pieces lost all its volumes, and a soup added thousands of pieces, saving a backup of the object for each one it deleted. Pieces without a convex hull are now dropped before any joins the object, the volume being split keeps the first remaining piece, and a part with no solid piece is left whole. Other parts of the object without a convex hull are no longer deleted as a side effect. ModelVolume caches whether its mesh can be split, and set_mesh() kept the cached value, so after Fix Model, Simplify or Emboss replaced a mesh, Split to parts could still be offered for a single piece. set_mesh() and reset_mesh() now clear the cache. * Import STEP surface models with Split compound enabled Splitting a compound kept only its solids, so a surface model, which OCCT reads as a compound of loose faces, gave nothing to mesh and the import failed with "Meshing of a model file failed or no valid shape". Each shell outside a solid now becomes a part too, and loose faces stay together as one part, as they do without splitting. * Add Fix All for plates and re-enable --repair on the command line ModelVolume::repair() applies repair_mesh() to a part and replaces the mesh only when the repair changed it. Fix Model, the new Fix All and Fix All Plates items of the plate context menu, and the command line's --repair option, which had been commented out since the Win10 SDK repair was dropped, all use it. With Keep painted feature after mesh change off, Fix Model cleared the painting of every part of an object before repairing. Now only a part whose mesh changes loses its painting, so fixing a whole project does not wipe it. The notification counts the models that needed no repair instead of listing them as repaired, and objects that did not change are not refreshed.
129 lines
5.1 KiB
C++
129 lines
5.1 KiB
C++
#ifndef libslic3r_MeshBoolean_hpp_
|
|
#define libslic3r_MeshBoolean_hpp_
|
|
|
|
#include <Eigen/Core>
|
|
#include "libslic3r/Point.hpp"
|
|
#include <memory>
|
|
#include <exception>
|
|
#include <optional>
|
|
#include <utility>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include <libslic3r/TriangleMesh.hpp>
|
|
#include <Eigen/Geometry>
|
|
|
|
namespace Slic3r {
|
|
|
|
namespace MeshBoolean {
|
|
|
|
using EigenMesh = std::pair<Eigen::MatrixXd, Eigen::MatrixXi>;
|
|
|
|
TriangleMesh eigen_to_triangle_mesh(const EigenMesh &emesh);
|
|
EigenMesh triangle_mesh_to_eigen(const TriangleMesh &mesh);
|
|
|
|
void minus(EigenMesh &A, const EigenMesh &B);
|
|
void self_union(EigenMesh &A);
|
|
|
|
void minus(TriangleMesh& A, const TriangleMesh& B);
|
|
void self_union(TriangleMesh& mesh);
|
|
|
|
namespace cgal {
|
|
|
|
struct CGALMesh;
|
|
struct CGALMeshDeleter { void operator()(CGALMesh *ptr); };
|
|
using CGALMeshPtr = std::unique_ptr<CGALMesh, CGALMeshDeleter>;
|
|
|
|
CGALMeshPtr clone(const CGALMesh &m);
|
|
|
|
void save_CGALMesh(const std::string& fname, const CGALMesh& cgal_mesh);
|
|
|
|
CGALMeshPtr triangle_mesh_to_cgal(
|
|
const std::vector<stl_vertex> &V,
|
|
const std::vector<stl_triangle_vertex_indices> &F);
|
|
|
|
inline CGALMeshPtr triangle_mesh_to_cgal(const indexed_triangle_set &M)
|
|
{
|
|
return triangle_mesh_to_cgal(M.vertices, M.indices);
|
|
}
|
|
inline CGALMeshPtr triangle_mesh_to_cgal(const TriangleMesh &M)
|
|
{
|
|
return triangle_mesh_to_cgal(M.its);
|
|
}
|
|
|
|
TriangleMesh cgal_to_triangle_mesh(const CGALMesh &cgalmesh);
|
|
indexed_triangle_set cgal_to_indexed_triangle_set(const CGALMesh &cgalmesh);
|
|
|
|
// Do boolean mesh difference with CGAL bypassing igl.
|
|
void minus(TriangleMesh &A, const TriangleMesh &B);
|
|
void plus(TriangleMesh &A, const TriangleMesh &B);
|
|
void intersect(TriangleMesh &A, const TriangleMesh &B);
|
|
|
|
void minus(indexed_triangle_set &A, const indexed_triangle_set &B);
|
|
void plus(indexed_triangle_set &A, const indexed_triangle_set &B);
|
|
void intersect(indexed_triangle_set &A, const indexed_triangle_set &B);
|
|
|
|
void minus(CGALMesh &A, CGALMesh &B);
|
|
void plus(CGALMesh &A, CGALMesh &B);
|
|
void intersect(CGALMesh &A, CGALMesh &B);
|
|
|
|
bool does_self_intersect(const TriangleMesh &mesh);
|
|
bool does_self_intersect(const CGALMesh &mesh);
|
|
|
|
//BBS
|
|
std::vector<TriangleMesh> segment(const TriangleMesh& src, double smoothing_alpha = 0.5, int segment_number = 5);
|
|
TriangleMesh merge(std::vector<TriangleMesh> meshes);
|
|
|
|
bool does_bound_a_volume(const CGALMesh &mesh);
|
|
bool empty(const CGALMesh &mesh);
|
|
|
|
// Real UV unwrap of an open mesh patch via CGAL's LSCM (Least Squares Conformal Maps) surface
|
|
// parameterization. Returns one UV coordinate per input vertex (same indexing as `mesh.vertices`),
|
|
// or nullopt if `mesh` isn't a single topological disk -- LSCM needs exactly one connected
|
|
// component with exactly one boundary loop, true for a typical single brush stroke/patch but not
|
|
// guaranteed for multiple disconnected painted islands merged into one mesh.
|
|
std::optional<std::vector<Vec2f>> parameterize_lscm(const indexed_triangle_set &mesh);
|
|
|
|
// Isotropic remeshing (CGAL): rebuilds the mesh so its triangles are close to a uniform target edge
|
|
// length, splitting oversized triangles and collapsing undersized ones. Used to even out a model with
|
|
// wildly varying triangle sizes so texture displacement has a consistent vertex density to work with.
|
|
// Edges whose dihedral angle exceeds `sharp_angle_deg`, and any open border, are held fixed so hard
|
|
// features survive instead of being eroded by the relaxation pass; pass 0 to remesh everything.
|
|
// Returns the input unchanged if remeshing fails (e.g. a non-manifold or self-intersecting input).
|
|
// `n_relaxation_steps` is the number of tangential relaxation passes run inside each iteration. That
|
|
// relaxation is what actually evens out the triangle distribution - splitting and collapsing alone
|
|
// only bring edge *lengths* near the target, leaving the vertices wherever they happened to land. CGAL
|
|
// defaults it to 1, which on a few iterations is not enough to look uniform.
|
|
indexed_triangle_set remesh_isotropic(const indexed_triangle_set &mesh, double target_edge_length,
|
|
unsigned n_iterations = 3, double sharp_angle_deg = 40.0,
|
|
unsigned n_relaxation_steps = 1);
|
|
}
|
|
|
|
namespace mcut {
|
|
struct McutMesh;
|
|
struct McutMeshDeleter
|
|
{
|
|
void operator()(McutMesh *ptr);
|
|
};
|
|
using McutMeshPtr = std::unique_ptr<McutMesh, McutMeshDeleter>;
|
|
bool empty(const McutMesh &mesh);
|
|
|
|
McutMeshPtr triangle_mesh_to_mcut(const indexed_triangle_set &M);
|
|
TriangleMesh mcut_to_triangle_mesh(const McutMesh &mcutmesh);
|
|
|
|
// do boolean and save result to srcMesh
|
|
// return true if sucessful
|
|
bool do_boolean_single(McutMesh& srcMesh, const McutMesh& cutMesh, const std::string& boolean_opts);
|
|
// do boolean of mesh with multiple volumes and save result to srcMesh
|
|
// Both srcMesh and cutMesh may have multiple volumes.
|
|
void do_boolean(McutMesh &srcMesh, const McutMesh &cutMesh, const std::string &boolean_opts);
|
|
|
|
|
|
// do boolean and convert result to TriangleMesh
|
|
void make_boolean(const TriangleMesh &src_mesh, const TriangleMesh &cut_mesh, std::vector<TriangleMesh> &dst_mesh, const std::string &boolean_opts);
|
|
} // namespace mcut
|
|
|
|
} // namespace MeshBoolean
|
|
} // namespace Slic3r
|
|
#endif // libslic3r_MeshBoolean_hpp_
|