Slic3r::ConflictChecker Struct Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/GCode/ConflictChecker.hpp>

Static Public Member Functions
static ConflictResultOpt	find_inter_of_lines_in_diff_objs (PrintObjectPtrs objs, std::optional< const FakeWipeTower * > wtdptr)
static ConflictComputeOpt	find_inter_of_lines (const LineWithIDs &lines)
static ConflictComputeOpt	line_intersect (const LineWithID &l1, const LineWithID &l2)

Detailed Description

Member Function Documentation

find_inter_of_lines()

ConflictComputeOpt Slic3r::ConflictChecker::find_inter_of_lines ( const LineWithIDs & lines )

static

{
    using namespace RasterizationImpl;
    std::map<IndexPair, std::vector<int>> indexToLine;
 
    for (int i = 0; i < lines.size(); ++i) {
        const LineWithID &l1      = lines[i];
        auto              indexes = line_rasterization(l1._line);
        for (auto index : indexes) {
            const auto &possibleIntersectIdxs = indexToLine[index];
            for (auto possibleIntersectIdx : possibleIntersectIdxs) {
                const LineWithID &l2 = lines[possibleIntersectIdx];
                if (auto interRes = line_intersect(l1, l2); interRes.has_value()) { return interRes; }
            }
            indexToLine[index].push_back(i);
        }
    }
    return {};
}

References Slic3r::LineWithID::_line, Slic3r::l2(), and line_intersect().

Here is the call graph for this function:

find_inter_of_lines_in_diff_objs()

ConflictResultOpt Slic3r::ConflictChecker::find_inter_of_lines_in_diff_objs ( PrintObjectPtrs objs, std::optional< const FakeWipeTower * > wtdptr )

static

{
    if (objs.empty() && !wtdptr) { return {}; }
    
    // Orca: check if we have enough items to potentially conflict (instances count)
    size_t total_instances = 0;
    for (auto obj : objs) total_instances += obj->instances().size();
    if (total_instances <= 1 && !wtdptr) return {};
 
    LinesBucketQueue conflictQueue;
 
    if (wtdptr.has_value()) { // wipe tower at 0 by default
        //auto            wtpaths = wtdptr.value()->getFakeExtrusionPathsFromWipeTower();
        ExtrusionLayers wtels = wtdptr.value()->getTrueExtrusionLayersFromWipeTower();
        //wtels.type = ExtrusionLayersType::WIPE_TOWER;
        //for (int i = 0; i < wtpaths.size(); ++i) { // assume that wipe tower always has same height
        //    ExtrusionLayer el;
        //    el.paths    = wtpaths[i];
        //    el.bottom_z = wtpaths[i].front().height * (float) i;
        //    el.layer    = nullptr;
        //    wtels.push_back(el);
        //}
        conflictQueue.emplace_back_bucket(std::move(wtels), wtdptr.value(), {wtdptr.value()->plate_origin.x(), wtdptr.value()->plate_origin.y()});
    }
    for (PrintObject *obj : objs) {
        auto layers = getAllLayersExtrusionPathsFromObject(obj);
        // Orca: check for collisions between all instances
        const auto& instances = obj->instances();
        for (size_t inst_idx = 0; inst_idx < instances.size(); ++inst_idx) {
            const PrintInstance& inst = instances[inst_idx];
            const bool is_last_instance = inst_idx + 1 == instances.size();
            if (is_last_instance) {
                conflictQueue.emplace_back_bucket(std::move(layers.perimeters), &inst, inst.shift);
                conflictQueue.emplace_back_bucket(std::move(layers.support), &inst, inst.shift);
            } else {
                conflictQueue.emplace_back_bucket(ExtrusionLayers(layers.perimeters), &inst, inst.shift);
                conflictQueue.emplace_back_bucket(ExtrusionLayers(layers.support), &inst, inst.shift);
            }
        }
    }
 
    std::vector<LineWithIDs> layersLines;
    std::vector<float>       bottomZs;
    while (conflictQueue.valid()) {
        LineWithIDs lines = conflictQueue.getCurLines();
        float curBottomZ = conflictQueue.getCurrBottomZ();
        bottomZs.push_back(curBottomZ);
        layersLines.push_back(std::move(lines));
    }
 
    bool                                                          find = false;
    tbb::concurrent_vector<std::pair<ConflictComputeResult, float>> conflict;
    tbb::parallel_for(tbb::blocked_range<size_t>(0, layersLines.size()), [&](tbb::blocked_range<size_t> range) {
        for (size_t i = range.begin(); i < range.end(); i++) {
            auto interRes = find_inter_of_lines(layersLines[i]);
            if (interRes.has_value()) {
                find = true;
                conflict.emplace_back(interRes.value(), bottomZs[i]);
                break;
            }
        }
    });
 
    if (find) {
        const void *ptr1           = conflict[0].first._obj1;
        const void *ptr2           = conflict[0].first._obj2;
        float       conflictPrintZ = conflict[0].second;
        if (wtdptr.has_value()) {
            const FakeWipeTower *wtdp = wtdptr.value();
            if (ptr1 == wtdp || ptr2 == wtdp) {
                if (ptr2 == wtdp) { std::swap(ptr1, ptr2); }
                // ptr1 is now wipe tower, ptr2 is PrintInstance*
                const PrintInstance *inst2 = reinterpret_cast<const PrintInstance *>(ptr2);
                const PrintObject *obj2 = inst2->print_object;
                return std::make_optional<ConflictResult>("WipeTower", obj2->model_object()->name, conflictPrintZ, nullptr, inst2);
            }
        }
        
        const PrintInstance *inst1 = reinterpret_cast<const PrintInstance *>(ptr1);
        const PrintInstance *inst2 = reinterpret_cast<const PrintInstance *>(ptr2);
        const PrintObject *obj1 = inst1->print_object;
        const PrintObject *obj2 = inst2->print_object;
        return std::make_optional<ConflictResult>(obj1->model_object()->name, obj2->model_object()->name, conflictPrintZ, inst1, inst2);
    } else
        return {};
}

References Slic3r::LinesBucketQueue::emplace_back_bucket(), Slic3r::getAllLayersExtrusionPathsFromObject(), Slic3r::LinesBucketQueue::getCurLines(), Slic3r::LinesBucketQueue::getCurrBottomZ(), Slic3r::range(), Slic3r::PrintInstance::shift, and Slic3r::LinesBucketQueue::valid().

Here is the call graph for this function:

line_intersect()

ConflictComputeOpt Slic3r::ConflictChecker::line_intersect ( const LineWithID & l1, const LineWithID & l2 )

static

{
    constexpr double SUPPORT_THRESHOLD = 100;  // this large almost disables conflict check of supports
    constexpr double OTHER_THRESHOLD   = 0.01;
    if (l1._id == l2._id) { return {}; } // return true if lines are from same object
    double overlap_length = 0.;
    bool   overlap  = l1._line.overlap(l2._line, overlap_length);
    if (overlap && overlap_length > scaled(OTHER_THRESHOLD)) return std::make_optional<ConflictComputeResult>(l1._id, l2._id);
    Point inter;
    bool  intersect = l1._line.intersection(l2._line, &inter);
 
    if (intersect) {
        double dist1 = std::min(unscale(Point(l1._line.a - inter)).norm(), unscale(Point(l1._line.b - inter)).norm());
        double dist2 = std::min(unscale(Point(l2._line.a - inter)).norm(), unscale(Point(l2._line.b - inter)).norm());
        double dist  = std::min(dist1, dist2);
        ExtrusionRole r1        = l1._role;
        ExtrusionRole r2        = l2._role;
        bool          both_support = r1 == ExtrusionRole::erSupportMaterial || r1 == ExtrusionRole::erSupportMaterialInterface || r1 == ExtrusionRole::erSupportTransition;
        both_support = both_support && ( r2 == ExtrusionRole::erSupportMaterial || r2 == ExtrusionRole::erSupportMaterialInterface || r2 == ExtrusionRole::erSupportTransition);
        if (dist > (both_support ? SUPPORT_THRESHOLD:OTHER_THRESHOLD)) {
            // the two lines intersects if dist>0.01mm for regular lines, and if dist>1mm for both supports
            return std::make_optional<ConflictComputeResult>(l1._id, l2._id);
        }
    }
    return {};
}

References Slic3r::LineWithID::_id, Slic3r::LineWithID::_line, Slic3r::LineWithID::_role, Slic3r::Line::a, Slic3r::Line::b, Slic3r::Geometry::dist(), Slic3r::erSupportMaterial, Slic3r::erSupportMaterialInterface, Slic3r::erSupportTransition, Slic3r::Line::intersection(), Slic3r::l2(), line_intersect(), Slic3r::Line::overlap(), Slic3r::scaled(), and Slic3r::unscale().

Referenced by find_inter_of_lines(), and line_intersect().

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this struct was generated from the following files:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/GCode/ConflictChecker.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/GCode/ConflictChecker.cpp