Slic3r::ConflictChecker Struct Reference

#include <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 < (int)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() || (objs.size() == 1 && objs.front()->instances().size() == 1)) { return {}; }
 
    LinesBucketQueue conflictQueue;
    if (wtdptr.has_value()) { // wipe tower at 0 by default
        std::vector<ExtrusionPaths> wtpaths = (*wtdptr)->getFakeExtrusionPathsFromWipeTower();
        conflictQueue.emplace_back_bucket(std::move(wtpaths), *wtdptr, Points{Point((*wtdptr)->plate_origin)});
    }
    for (PrintObject *obj : objs) {
        std::pair<std::vector<ExtrusionPaths>, std::vector<ExtrusionPaths>> layers = getAllLayersExtrusionPathsFromObject(obj);
 
        Points instances_shifts;
        for (const PrintInstance& inst : obj->instances())
            instances_shifts.emplace_back(inst.shift);
 
        conflictQueue.emplace_back_bucket(std::move(layers.first), obj, instances_shifts);
        conflictQueue.emplace_back_bucket(std::move(layers.second), obj, instances_shifts);
    }
    conflictQueue.build_queue();
 
    std::vector<LineWithIDs> layersLines;
    std::vector<double>      heights;
    while (conflictQueue.valid()) {
        LineWithIDs lines     = conflictQueue.getCurLines();
        double      curHeight = conflictQueue.removeLowests();
        heights.push_back(curHeight);
        layersLines.push_back(std::move(lines));
    }
 
    bool                                   find = false;
    tbb::concurrent_vector<std::pair<ConflictComputeResult,double>> 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, heights[i]);
                break;
            }
        }
    });
 
    if (find) {
        std::sort(conflict.begin(), conflict.end(), [](const std::pair<ConflictComputeResult, double>& i1, const std::pair<ConflictComputeResult, double>& i2) {
            return i1.second < i2.second;
        });
 
        const void *ptr1           = conflictQueue.idToObjsPtr(conflict[0].first._obj1);
        const void *ptr2           = conflictQueue.idToObjsPtr(conflict[0].first._obj2);
        double      conflictHeight = conflict[0].second;
        if (wtdptr.has_value()) {
            const FakeWipeTower* wtdp = *wtdptr;
            if (ptr1 == wtdp || ptr2 == wtdp) {
                if (ptr2 == wtdp) { std::swap(ptr1, ptr2); }
                const PrintObject *obj2 = reinterpret_cast<const PrintObject *>(ptr2);
                return std::make_optional<ConflictResult>("WipeTower", obj2->model_object()->name, conflictHeight, nullptr, ptr2);
            }
        }
        const PrintObject *obj1 = reinterpret_cast<const PrintObject *>(ptr1);
        const PrintObject *obj2 = reinterpret_cast<const PrintObject *>(ptr2);
        return std::make_optional<ConflictResult>(obj1->model_object()->name, obj2->model_object()->name, conflictHeight, ptr1, ptr2);
    } else
        return {};
}

References Slic3r::LinesBucketQueue::build_queue(), Slic3r::LinesBucketQueue::emplace_back_bucket(), Slic3r::getAllLayersExtrusionPathsFromObject(), Slic3r::LinesBucketQueue::getCurLines(), Slic3r::range(), Slic3r::LinesBucketQueue::removeLowests(), and Slic3r::LinesBucketQueue::valid().

Referenced by Slic3r::Print::process().

Here is the call graph for this function:

Here is the caller graph for this function:

line_intersect()

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

static

{
    if (l1._obj_id == l2._obj_id && l1._inst_id == l2._inst_id) { return {}; } // lines are from same instance
 
    Point inter;
    bool  intersect = l1._line.intersection(l2._line, &inter);
    if (intersect) {
        auto dist1 = std::min(unscale(Point(l1._line.a - inter)).norm(), unscale(Point(l1._line.b - inter)).norm());
        auto dist2 = std::min(unscale(Point(l2._line.a - inter)).norm(), unscale(Point(l2._line.b - inter)).norm());
        auto dist  = std::min(dist1, dist2);
        if (dist > 0.01) { return std::make_optional<ConflictComputeResult>(l1._obj_id, l2._obj_id); } // the two lines intersects if dist>0.01mm
    }
    return {};
}

References Slic3r::LineWithID::_inst_id, Slic3r::LineWithID::_line, Slic3r::LineWithID::_obj_id, Slic3r::Line::a, Slic3r::Line::b, Slic3r::Line::intersection(), Slic3r::l2(), and Slic3r::unscale().

Referenced by find_inter_of_lines().

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:

• src/libslic3r/GCode/ConflictChecker.hpp
• src/libslic3r/GCode/ConflictChecker.cpp