Slic3r::MeshBoolean::mcut Namespace Reference

Classes
struct	McutMesh
struct	McutMeshDeleter

Typedefs
using	McutMeshPtr = std::unique_ptr<McutMesh, McutMeshDeleter>

Functions
bool	empty (const McutMesh &mesh)
void	triangle_mesh_to_mcut (const TriangleMesh &src_mesh, McutMesh &srcMesh, const Transform3d &src_nm=Transform3d::Identity())
McutMeshPtr	triangle_mesh_to_mcut (const indexed_triangle_set &M)
TriangleMesh	mcut_to_triangle_mesh (const McutMesh &mcutmesh)
void	merge_mcut_meshes (McutMesh &src, const McutMesh &cut)
MCAPI_ATTR void MCAPI_CALL	mcDebugOutput (McDebugSource source, McDebugType type, unsigned int id, McDebugSeverity severity, size_t length, const char *message, const void *userParam)
bool	do_boolean_single (McutMesh &srcMesh, const McutMesh &cutMesh, const std::string &boolean_opts)
void	do_boolean (McutMesh &srcMesh, const McutMesh &cutMesh, const std::string &boolean_opts)
void	make_boolean (const TriangleMesh &src_mesh, const TriangleMesh &cut_mesh, std::vector< TriangleMesh > &dst_mesh, const std::string &boolean_opts)

---

Class Documentation

Slic3r::MeshBoolean::mcut::McutMesh

struct Slic3r::MeshBoolean::mcut::McutMesh

Collaboration diagram for Slic3r::MeshBoolean::mcut::McutMesh:

Class Members
vector< uint32_t >	faceIndicesArray
vector< uint32_t >	faceSizesArray
vector< double >	vertexCoordsArray

Typedef Documentation

McutMeshPtr

using Slic3r::MeshBoolean::mcut::McutMeshPtr = std::unique_ptr<McutMesh, McutMeshDeleter>

Function Documentation

do_boolean()

void Slic3r::MeshBoolean::mcut::do_boolean	(	McutMesh &	srcMesh,
		const McutMesh &	cutMesh,
		const std::string &	boolean_opts )

{
    TriangleMesh tri_src = mcut_to_triangle_mesh(srcMesh);
    std::vector<indexed_triangle_set> src_parts = its_split(tri_src.its);
 
    TriangleMesh tri_cut = mcut_to_triangle_mesh(cutMesh);
    std::vector<indexed_triangle_set> cut_parts = its_split(tri_cut.its);
 
    if (src_parts.empty() && boolean_opts == "UNION") {
        srcMesh = cutMesh;
        return;
    }
    if(cut_parts.empty()) return;
 
    // when src mesh has multiple connected components, mcut refuses to work.
    // But we can force it to work by spliting the src mesh into disconnected components,
    // and do booleans seperately, then merge all the results.
    indexed_triangle_set all_its;
    if (boolean_opts == "A_NOT_B") {
        // Each cut can leave the source with several disconnected components, which mcut rejects
        // in the next dispatch, so re-split after every cut part (e.g. each letter of a text).
        std::vector<indexed_triangle_set> parts = std::move(src_parts);
        for (size_t j = 0; j < cut_parts.size(); j++) {
            auto cut_part = triangle_mesh_to_mcut(cut_parts[j]);
            std::vector<indexed_triangle_set> next_parts;
            for (indexed_triangle_set &part : parts) {
                auto src_part = triangle_mesh_to_mcut(part);
                if (do_boolean_single(*src_part, *cut_part, boolean_opts)) {
                    TriangleMesh tri_part = mcut_to_triangle_mesh(*src_part);
                    std::vector<indexed_triangle_set> pieces = its_split(tri_part.its);
                    std::move(pieces.begin(), pieces.end(), std::back_inserter(next_parts));
                } else
                    next_parts.emplace_back(std::move(part));
            }
            parts = std::move(next_parts);
        }
        for (const indexed_triangle_set &part : parts)
            its_merge(all_its, part);
    }
    else if (boolean_opts == "UNION") {
        for (size_t i = 0; i < src_parts.size(); i++) {
            auto src_part = triangle_mesh_to_mcut(src_parts[i]);
            for (size_t j = 0; j < cut_parts.size(); j++) {
                auto cut_part = triangle_mesh_to_mcut(cut_parts[j]);
                do_boolean_single(*src_part, *cut_part, boolean_opts);
            }
            TriangleMesh tri_part = mcut_to_triangle_mesh(*src_part);
            its_merge(all_its, tri_part.its);
        }
    }
    else if (boolean_opts == "INTERSECTION") {
        for (size_t i = 0; i < src_parts.size(); i++) {
            for (size_t j = 0; j < cut_parts.size(); j++) {
                auto src_part = triangle_mesh_to_mcut(src_parts[i]);
                auto cut_part = triangle_mesh_to_mcut(cut_parts[j]);
                bool success = do_boolean_single(*src_part, *cut_part, boolean_opts);
                if (success) {
                    TriangleMesh tri_part = mcut_to_triangle_mesh(*src_part);
                    its_merge(all_its, tri_part.its);
                }
            }
        }
    }
    srcMesh = *triangle_mesh_to_mcut(all_its);
}

References do_boolean_single(), Slic3r::TriangleMesh::its, Slic3r::its_merge(), Slic3r::its_split(), mcut_to_triangle_mesh(), and triangle_mesh_to_mcut().

Referenced by make_boolean(), and Slic3r::csg::detail_mcut::perform_csg().

Here is the call graph for this function:

Here is the caller graph for this function:

do_boolean_single()

bool Slic3r::MeshBoolean::mcut::do_boolean_single	(	McutMesh &	srcMesh,
		const McutMesh &	cutMesh,
		const std::string &	boolean_opts )

{
    // create context
    McContext context = MC_NULL_HANDLE;
    McResult  err     = mcCreateContext(&context, 0);
    // add debug callback according to https://cutdigital.github.io/mcut.site/tutorials/debugging/
    mcDebugMessageCallback(context, mcDebugOutput, nullptr);
    mcDebugMessageControl(
        context,
        MC_DEBUG_SOURCE_ALL,
        MC_DEBUG_TYPE_ERROR,
        MC_DEBUG_SEVERITY_MEDIUM,
        true);
    // We can either let MCUT compute all possible meshes (including patches etc.), or we can
    // constrain the library to compute exactly the boolean op mesh we want. This 'constrained' case
    // is done with the following flags.
    // NOTE#1: you can extend these flags by bitwise ORing with additional flags (see `McDispatchFlags' in mcut.h)
    // NOTE#2: below order of columns MATTERS
    const std::map<std::string, McFlags> booleanOpts = {
        {"A_NOT_B", MC_DISPATCH_FILTER_FRAGMENT_SEALING_INSIDE | MC_DISPATCH_FILTER_FRAGMENT_LOCATION_ABOVE},
        {"B_NOT_A", MC_DISPATCH_FILTER_FRAGMENT_SEALING_OUTSIDE | MC_DISPATCH_FILTER_FRAGMENT_LOCATION_BELOW},
        {"UNION", MC_DISPATCH_FILTER_FRAGMENT_SEALING_OUTSIDE | MC_DISPATCH_FILTER_FRAGMENT_LOCATION_ABOVE},
        {"INTERSECTION", MC_DISPATCH_FILTER_FRAGMENT_SEALING_INSIDE | MC_DISPATCH_FILTER_FRAGMENT_LOCATION_BELOW},
    };
 
    std::map<std::string, McFlags>::const_iterator it          = booleanOpts.find(boolean_opts);
    McFlags                                        boolOpFlags = it->second;
 
    if (srcMesh.vertexCoordsArray.empty() && (boolean_opts == "UNION" || boolean_opts == "B_NOT_A")) {
        srcMesh = cutMesh;
        mcReleaseContext(context);
        return true;
    }
 
    err = mcDispatch(context,
                     MC_DISPATCH_VERTEX_ARRAY_DOUBLE |          // vertices are in array of doubles
                         MC_DISPATCH_ENFORCE_GENERAL_POSITION | // perturb if necessary
                         boolOpFlags,                           // filter flags which specify the type of output we want
                     // source mesh
                     reinterpret_cast<const void *>(srcMesh.vertexCoordsArray.data()), reinterpret_cast<const uint32_t *>(srcMesh.faceIndicesArray.data()),
                     srcMesh.faceSizesArray.data(), static_cast<uint32_t>(srcMesh.vertexCoordsArray.size() / 3), static_cast<uint32_t>(srcMesh.faceSizesArray.size()),
                     // cut mesh
                     reinterpret_cast<const void *>(cutMesh.vertexCoordsArray.data()), cutMesh.faceIndicesArray.data(), cutMesh.faceSizesArray.data(),
                     static_cast<uint32_t>(cutMesh.vertexCoordsArray.size() / 3), static_cast<uint32_t>(cutMesh.faceSizesArray.size()));
    if (err != MC_NO_ERROR) {
        BOOST_LOG_TRIVIAL(debug) << "MCUT mcDispatch fails! err=" << err;
        mcReleaseContext(context);
        if (boolean_opts == "UNION") {
            merge_mcut_meshes(srcMesh, cutMesh);
            return true;
        }
        return false;
    }
 
    // query the number of available connected component
    uint32_t numConnComps;
    err = mcGetConnectedComponents(context, MC_CONNECTED_COMPONENT_TYPE_FRAGMENT, 0, NULL, &numConnComps);
    if (err != MC_NO_ERROR || numConnComps==0) {
        BOOST_LOG_TRIVIAL(debug) << "MCUT mcGetConnectedComponents fails! err=" << err << ", numConnComps" << numConnComps;
        mcReleaseContext(context);
        if (numConnComps == 0 && boolean_opts == "UNION") {
            merge_mcut_meshes(srcMesh, cutMesh);
            return true;
        }
        return false;
    }
 
    std::vector<McConnectedComponent> connectedComponents(numConnComps, MC_NULL_HANDLE);
    err = mcGetConnectedComponents(context, MC_CONNECTED_COMPONENT_TYPE_FRAGMENT, (uint32_t) connectedComponents.size(), connectedComponents.data(), NULL);
 
    McutMesh outMesh;
    int N_vertices = 0;
    // traversal of all connected components
    for (int n = 0; n < numConnComps; ++n) {
        // query the data of each connected component from MCUT
        McConnectedComponent connComp = connectedComponents[n];
 
        // query the vertices
        McSize numBytes                  = 0;
        err                               = mcGetConnectedComponentData(context, connComp, MC_CONNECTED_COMPONENT_DATA_VERTEX_DOUBLE, 0, NULL, &numBytes);
        uint32_t            ccVertexCount = (uint32_t) (numBytes / (sizeof(double) * 3));
        std::vector<double> ccVertices((uint64_t) ccVertexCount * 3u, 0);
        err = mcGetConnectedComponentData(context, connComp, MC_CONNECTED_COMPONENT_DATA_VERTEX_DOUBLE, numBytes, (void *) ccVertices.data(), NULL);
 
        // query the faces
        numBytes = 0;
        err      = mcGetConnectedComponentData(context, connComp, MC_CONNECTED_COMPONENT_DATA_FACE_TRIANGULATION, 0, NULL, &numBytes);
        std::vector<uint32_t> ccFaceIndices(numBytes / sizeof(uint32_t), 0);
        err = mcGetConnectedComponentData(context, connComp, MC_CONNECTED_COMPONENT_DATA_FACE_TRIANGULATION, numBytes, ccFaceIndices.data(), NULL);
        std::vector<uint32_t> faceSizes(ccFaceIndices.size() / 3, 3);
 
        const uint32_t ccFaceCount = static_cast<uint32_t>(faceSizes.size());
 
        // Here we show, how to know when connected components, pertain particular boolean operations.
        McPatchLocation patchLocation = (McPatchLocation) 0;
        err                           = mcGetConnectedComponentData(context, connComp, MC_CONNECTED_COMPONENT_DATA_PATCH_LOCATION, sizeof(McPatchLocation), &patchLocation, NULL);
 
        McFragmentLocation fragmentLocation = (McFragmentLocation) 0;
        err = mcGetConnectedComponentData(context, connComp, MC_CONNECTED_COMPONENT_DATA_FRAGMENT_LOCATION, sizeof(McFragmentLocation), &fragmentLocation, NULL);
 
        outMesh.vertexCoordsArray.insert(outMesh.vertexCoordsArray.end(), ccVertices.begin(), ccVertices.end());
 
        // add offset to face index
        for (size_t i = 0; i < ccFaceIndices.size(); i++) {
            ccFaceIndices[i] += N_vertices;
        }
 
        int faceVertexOffsetBase = 0;
 
        // for each face in CC
        std::vector<Vec3i32> faces(ccFaceCount);
        for (uint32_t f = 0; f < ccFaceCount; ++f) {
            bool reverseWindingOrder = (fragmentLocation == MC_FRAGMENT_LOCATION_BELOW) && (patchLocation == MC_PATCH_LOCATION_OUTSIDE);
            int  faceSize            = faceSizes.at(f);
            if (reverseWindingOrder) {
                std::vector<uint32_t> faceIndex(faceSize);
                // for each vertex in face
                for (int v = faceSize - 1; v >= 0; v--) { faceIndex[v] = ccFaceIndices[(uint64_t) faceVertexOffsetBase + v]; }
                std::copy(faceIndex.begin(), faceIndex.end(), ccFaceIndices.begin() + faceVertexOffsetBase);
            }
            faceVertexOffsetBase += faceSize;
        }
 
        outMesh.faceIndicesArray.insert(outMesh.faceIndicesArray.end(), ccFaceIndices.begin(), ccFaceIndices.end());
        outMesh.faceSizesArray.insert(outMesh.faceSizesArray.end(), faceSizes.begin(), faceSizes.end());
 
        N_vertices += ccVertexCount;
    }
 
    // free connected component data
    err = mcReleaseConnectedComponents(context, 0, NULL);
    // destroy context
    err = mcReleaseContext(context);
 
    srcMesh = outMesh;
 
    return true;
}

References Slic3r::f(), Slic3r::MeshBoolean::mcut::McutMesh::faceIndicesArray, Slic3r::MeshBoolean::mcut::McutMesh::faceSizesArray, mcDebugOutput(), merge_mcut_meshes(), and Slic3r::MeshBoolean::mcut::McutMesh::vertexCoordsArray.

Referenced by do_boolean().

Here is the call graph for this function:

Here is the caller graph for this function:

empty()

bool Slic3r::MeshBoolean::mcut::empty

(

const McutMesh &

mesh

)

{ return mesh.vertexCoordsArray.empty() || mesh.faceIndicesArray.empty(); }

References Slic3r::MeshBoolean::mcut::McutMesh::faceIndicesArray, and Slic3r::MeshBoolean::mcut::McutMesh::vertexCoordsArray.

Referenced by Slic3r::csg::check_csgmesh_booleans().

Here is the caller graph for this function:

make_boolean()

void Slic3r::MeshBoolean::mcut::make_boolean	(	const TriangleMesh &	src_mesh,
		const TriangleMesh &	cut_mesh,
		std::vector< TriangleMesh > &	dst_mesh,
		const std::string &	boolean_opts )

{
    McutMesh srcMesh, cutMesh;
    triangle_mesh_to_mcut(src_mesh, srcMesh);
    triangle_mesh_to_mcut(cut_mesh, cutMesh);
    //dst_mesh = make_boolean(srcMesh, cutMesh, boolean_opts);
    do_boolean(srcMesh, cutMesh, boolean_opts);
    TriangleMesh tri_src = mcut_to_triangle_mesh(srcMesh);
    if (!tri_src.empty())
        dst_mesh.push_back(std::move(tri_src));
}

References Slic3r::cut_mesh(), do_boolean(), Slic3r::TriangleMesh::empty(), mcut_to_triangle_mesh(), and triangle_mesh_to_mcut().

Referenced by Slic3r::ModelObject::make_boolean(), and Slic3r::GUI::GLGizmoMeshBoolean::on_render_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

mcDebugOutput()

MCAPI_ATTR void MCAPI_CALL Slic3r::MeshBoolean::mcut::mcDebugOutput	(	McDebugSource	source,
		McDebugType	type,
		unsigned int	id,
		McDebugSeverity	severity,
		size_t	length,
		const char *	message,
		const void *	userParam )

{
    BOOST_LOG_TRIVIAL(debug)<<Slic3r::format("mcut mcDebugOutput message ( %d ): %s ", id, message);
 
    switch (source) {
        case MC_DEBUG_SOURCE_API:
            BOOST_LOG_TRIVIAL(debug)<<("Source: API");
            break;
        case MC_DEBUG_SOURCE_KERNEL:
            BOOST_LOG_TRIVIAL(debug)<<("Source: Kernel");
            break;
        }
 
    switch (type) {
        case MC_DEBUG_TYPE_ERROR:
            BOOST_LOG_TRIVIAL(debug)<<("Type: Error");
            break;
        case MC_DEBUG_TYPE_DEPRECATED_BEHAVIOR:
            BOOST_LOG_TRIVIAL(debug)<<("Type: Deprecated Behaviour");
            break;
        case MC_DEBUG_TYPE_OTHER:
            BOOST_LOG_TRIVIAL(debug)<<("Type: Other");
            break;
        }
 
    switch (severity) {
        case MC_DEBUG_SEVERITY_HIGH:
            BOOST_LOG_TRIVIAL(debug)<<("Severity: high");
            break;
        case MC_DEBUG_SEVERITY_MEDIUM:
            BOOST_LOG_TRIVIAL(debug)<<("Severity: medium");
            break;
        case MC_DEBUG_SEVERITY_LOW:
            BOOST_LOG_TRIVIAL(debug)<<("Severity: low");
            break;
        case MC_DEBUG_SEVERITY_NOTIFICATION:
            BOOST_LOG_TRIVIAL(debug)<<("Severity: notification");
            break;
        }
}

References Slic3r::format(), and Slic3r::length().

Referenced by do_boolean_single().

Here is the call graph for this function:

Here is the caller graph for this function:

mcut_to_triangle_mesh()

TriangleMesh Slic3r::MeshBoolean::mcut::mcut_to_triangle_mesh

(

const McutMesh &

mcutmesh

)

{
    uint32_t ccVertexCount = mcutmesh.vertexCoordsArray.size() / 3;
    auto    &ccVertices    = mcutmesh.vertexCoordsArray;
    auto    &ccFaceIndices = mcutmesh.faceIndicesArray;
    auto    &faceSizes     = mcutmesh.faceSizesArray;
    uint32_t ccFaceCount   = faceSizes.size();
    // rearrange vertices/faces and save into result mesh
    std::vector<Vec3f> vertices(ccVertexCount);
    for (uint32_t i = 0; i < ccVertexCount; i++) {
        vertices[i][0] = (float) ccVertices[(uint64_t) i * 3 + 0];
        vertices[i][1] = (float) ccVertices[(uint64_t) i * 3 + 1];
        vertices[i][2] = (float) ccVertices[(uint64_t) i * 3 + 2];
    }
 
    // output faces
    int faceVertexOffsetBase = 0;
 
    // for each face in CC
    std::vector<Vec3i32> faces(ccFaceCount);
    for (uint32_t f = 0; f < ccFaceCount; ++f) {
        int faceSize = faceSizes.at(f);
 
        // for each vertex in face
        for (int v = 0; v < faceSize; v++) { faces[f][v] = ccFaceIndices[(uint64_t) faceVertexOffsetBase + v]; }
        faceVertexOffsetBase += faceSize;
    }
 
    TriangleMesh out(vertices, faces);
    return out;
}

References Slic3r::f(), Slic3r::MeshBoolean::mcut::McutMesh::faceIndicesArray, Slic3r::MeshBoolean::mcut::McutMesh::faceSizesArray, and Slic3r::MeshBoolean::mcut::McutMesh::vertexCoordsArray.

Referenced by Slic3r::GUI::Plater::combine_mesh_fff(), do_boolean(), make_boolean(), and merge_mcut_meshes().

Here is the call graph for this function:

Here is the caller graph for this function:

merge_mcut_meshes()

void Slic3r::MeshBoolean::mcut::merge_mcut_meshes	(	McutMesh &	src,
		const McutMesh &	cut )

                                                           {
    indexed_triangle_set all_its;
    TriangleMesh tri_src = mcut_to_triangle_mesh(src);
    TriangleMesh tri_cut = mcut_to_triangle_mesh(cut);
    its_merge(all_its, tri_src.its);
    its_merge(all_its, tri_cut.its);
    src = *triangle_mesh_to_mcut(all_its);
    }

References Slic3r::TriangleMesh::its, Slic3r::its_merge(), mcut_to_triangle_mesh(), and triangle_mesh_to_mcut().

Referenced by do_boolean_single().

Here is the call graph for this function:

Here is the caller graph for this function:

triangle_mesh_to_mcut() [1/2]

McutMeshPtr Slic3r::MeshBoolean::mcut::triangle_mesh_to_mcut

(

const indexed_triangle_set &

M

)

{
    std::unique_ptr<McutMesh, McutMeshDeleter> out(new McutMesh{});
    TriangleMesh                               trimesh(M);
    triangle_mesh_to_mcut(trimesh, *out.get());
    return out;
}

References triangle_mesh_to_mcut().

Here is the call graph for this function:

triangle_mesh_to_mcut() [2/2]

void Slic3r::MeshBoolean::mcut::triangle_mesh_to_mcut	(	const TriangleMesh &	src_mesh,
		McutMesh &	srcMesh,
		const Transform3d &	src_nm = Transform3d::Identity() )

{
    // vertices precision convention and copy
    srcMesh.vertexCoordsArray.reserve(src_mesh.its.vertices.size() * 3);
    for (int i = 0; i < src_mesh.its.vertices.size(); ++i) {
        const Vec3d v = src_nm * src_mesh.its.vertices[i].cast<double>();
        srcMesh.vertexCoordsArray.push_back(v[0]);
        srcMesh.vertexCoordsArray.push_back(v[1]);
        srcMesh.vertexCoordsArray.push_back(v[2]);
    }
 
    // faces copy
    srcMesh.faceIndicesArray.reserve(src_mesh.its.indices.size() * 3);
    srcMesh.faceSizesArray.reserve(src_mesh.its.indices.size());
    for (int i = 0; i < src_mesh.its.indices.size(); ++i) {
        const int &f0 = src_mesh.its.indices[i][0];
        const int &f1 = src_mesh.its.indices[i][1];
        const int &f2 = src_mesh.its.indices[i][2];
        srcMesh.faceIndicesArray.push_back(f0);
        srcMesh.faceIndicesArray.push_back(f1);
        srcMesh.faceIndicesArray.push_back(f2);
 
        srcMesh.faceSizesArray.push_back((uint32_t) 3);
    }
}

References Slic3r::MeshBoolean::mcut::McutMesh::faceIndicesArray, Slic3r::MeshBoolean::mcut::McutMesh::faceSizesArray, Slic3r::TriangleMesh::its, and Slic3r::MeshBoolean::mcut::McutMesh::vertexCoordsArray.

Referenced by Slic3r::csg::check_csgmesh_booleans(), do_boolean(), Slic3r::csg::get_mcutmesh(), make_boolean(), merge_mcut_meshes(), Slic3r::csg::perform_csgmesh_booleans_mcut(), Slic3r::csg::perform_csgmesh_booleans_mcut(), and triangle_mesh_to_mcut().

Here is the caller graph for this function: