3D-printing/OrcaSlicer
1
0
Fork 0
mirror of https://github.com/SoftFever/OrcaSlicer.git synced 2025-07-18 20:28:08 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

ENH: add wipe tower into conflict check

Browse source 
Change-Id: I9684ec17ccbfdea39deae6e5089b74ce3124d57b
(cherry picked from commit f6ee82b4ecf8bf9de91d0043b514cdabb7284b7e)
This commit is contained in:
manch1n 2023-04-11 19:36:04 +08:00 • committed by Lane.Wei
parent 60c444f627
commit b5b7264e99
5 changed files with 123 additions and 37 deletions
Download patch file Download diff file Expand all files Collapse all files

32
src/libslic3r/GCode/ConflictChecker.cpp
View file

@ -89,10 +89,11 @@ inline Grids line_rasterization(const Line &line, int64_t xdist = RasteXDistance
}
} // namespace RasterizationImpl
void LinesBucketQueue::emplace_back_bucket(std::vector<ExtrusionPaths> &&paths, PrintObject *objPtr, Point offset)
void LinesBucketQueue::emplace_back_bucket(std::vector<ExtrusionPaths> &&paths, const void *objPtr, Point offset)
{
auto oldSize = _buckets.capacity();
_buckets.emplace_back(std::move(paths), objPtr, offset);
_buckets.emplace_back(std::move(paths), _objsPtrToId.size(), offset);
_objsPtrToId.push_back(objPtr);
_pq.push(&_buckets.back());
auto newSize = _buckets.capacity();
if (oldSize != newSize) { // pointers change
@ -199,10 +200,15 @@ ConflictRet ConflictChecker::find_inter_of_lines(const LineWithIDs &lines)
return {};
}
ConflictRet ConflictChecker::find_inter_of_lines_in_diff_objs(PrintObjectPtrs objs) // find the first intersection point of lines in different objects
ConflictObjName ConflictChecker::find_inter_of_lines_in_diff_objs(PrintObjectPtrs objs,
std::optional<const FakeWipeTower *> wtdptr) // find the first intersection point of lines in different objects
{
if (objs.size() <= 1) { return {}; }
LinesBucketQueue conflictQueue;
if (wtdptr.has_value()) { // wipe tower at 0 by default
auto wtpaths = wtdptr.value()->getFakeExtrusionPathsFromWipeTower();
conflictQueue.emplace_back_bucket(std::move(wtpaths), wtdptr.value(), {wtdptr.value()->plate_origin.x(),wtdptr.value()->plate_origin.y()});
}
for (PrintObject *obj : objs) {
auto layers = getAllLayersExtrusionPathsFromObject(obj);
conflictQueue.emplace_back_bucket(std::move(layers.first), obj, obj->instances().front().shift);
@ -219,7 +225,7 @@ ConflictRet ConflictChecker::find_inter_of_lines_in_diff_objs(PrintObjectPtrs ob
bool find = false;
tbb::concurrent_vector<ConflictResult> conflict;
tbb::parallel_for(tbb::blocked_range<size_t>( 0, layersLines.size()), [&](tbb::blocked_range<size_t> range) {
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()) {
@ -231,21 +237,33 @@ ConflictRet ConflictChecker::find_inter_of_lines_in_diff_objs(PrintObjectPtrs ob
});
if (find) {
return {conflict[0]};
const void *ptr1 = conflictQueue.idToObjsPtr(conflict[0]._obj1);
const void *ptr2 = conflictQueue.idToObjsPtr(conflict[0]._obj2);
if (wtdptr.has_value()) {
const FakeWipeTower *wtdp = wtdptr.value();
if (ptr1 == wtdp || ptr2 == wtdp) {
if (ptr2 == wtdp) { std::swap(ptr1, ptr2); }
const PrintObject *obj2 = reinterpret_cast<const PrintObject *>(ptr2);
return {std::make_pair("WipeTower", obj2->model_object()->name)};
}
}
const PrintObject *obj1 = reinterpret_cast<const PrintObject *>(ptr1);
const PrintObject *obj2 = reinterpret_cast<const PrintObject *>(ptr2);
return {std::make_pair(obj1->model_object()->name, obj2->model_object()->name)};
} else
return {};
}
ConflictRet ConflictChecker::line_intersect(const LineWithID &l1, const LineWithID &l2)
{
if (l1._objPtr == l2._objPtr) { return {}; } // return true if lines are from same object
if (l1._id == l2._id) { return {}; } // return true if lines are from same object
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<ConflictResult>(l1._objPtr, l2._objPtr); } // the two lines intersects if dist>0.01mm
if (dist > 0.01) { return std::make_optional<ConflictResult>(l1._id, l2._id); } // the two lines intersects if dist>0.01mm
}
return {};
}

45
src/libslic3r/GCode/ConflictChecker.hpp
View file

@ -14,11 +14,11 @@ namespace Slic3r {
struct LineWithID
{
Line _line;
PrintObject *_objPtr;
int _role;
Line _line;
int _id;
int _role;
LineWithID(const Line &line, PrintObject *objPtr, int role) : _line(line), _objPtr(objPtr), _role(role) {}
LineWithID(const Line &line, int id, int role) : _line(line), _id(id), _role(role) {}
};
using LineWithIDs = std::vector<LineWithID>;
@ -30,11 +30,11 @@ private:
unsigned _curPileIdx = 0;
std::vector<ExtrusionPaths> _piles;
PrintObject * _objPtr;
int _id;
Point _offset;
public:
LinesBucket(std::vector<ExtrusionPaths> &&paths, PrintObject *objPtr, Point offset) : _piles(paths), _objPtr(objPtr), _offset(offset) {}
LinesBucket(std::vector<ExtrusionPaths> &&paths, int id, Point offset) : _piles(paths), _id(id), _offset(offset) {}
LinesBucket(LinesBucket &&) = default;
bool valid() const { return _curPileIdx < _piles.size(); }
@ -52,9 +52,9 @@ public:
for (const ExtrusionPath &path : _piles[_curPileIdx]) {
if (path.is_force_no_extrusion() == false) {
Polyline check_polyline = path.polyline;
if (path.role() != ExtrusionRole::erBrim) { check_polyline.translate(_offset); }
check_polyline.translate(_offset);
Lines tmpLines = check_polyline.lines();
for (const Line &line : tmpLines) { lines.emplace_back(line, _objPtr, path.role()); }
for (const Line &line : tmpLines) { lines.emplace_back(line, _id, path.role()); }
}
}
return lines;
@ -75,11 +75,18 @@ class LinesBucketQueue
private:
std::vector<LinesBucket> _buckets;
std::priority_queue<LinesBucket *, std::vector<LinesBucket *>, LinesBucketPtrComp> _pq;
std::vector<const void *> _objsPtrToId;
public:
void emplace_back_bucket(std::vector<ExtrusionPaths> &&paths, PrintObject *objPtr, Point offset);
bool valid() const { return _pq.empty() == false; }
void emplace_back_bucket(std::vector<ExtrusionPaths> &&paths, const void *objPtr, Point offset);
bool valid() const { return _pq.empty() == false; }
const void *idToObjsPtr(int id)
{
if (id >= 0 && id < _objsPtrToId.size()) {
return _objsPtrToId[id];
} else
return nullptr;
}
void removeLowests();
LineWithIDs getCurLines() const;
};
@ -94,21 +101,21 @@ std::pair<std::vector<ExtrusionPaths>, std::vector<ExtrusionPaths>> getAllLayers
struct ConflictResult
{
PrintObject *_obj1;
PrintObject *_obj2;
ConflictResult(PrintObject *obj1, PrintObject *obj2) : _obj1(obj1), _obj2(obj2) {}
int _obj1;
int _obj2;
ConflictResult(int obj1, int obj2) : _obj1(obj1), _obj2(obj2) {}
ConflictResult() = default;
};
static_assert(std::is_trivial<ConflictResult>::value, "atomic value requires to be trival.");
using ConflictRet = std::optional<ConflictResult>;
using ConflictObjName = std::optional<std::pair<std::string, std::string>>;
struct ConflictChecker
{
static ConflictRet find_inter_of_lines_in_diff_objs(PrintObjectPtrs objs);
static ConflictRet find_inter_of_lines(const LineWithIDs &lines);
static ConflictRet line_intersect(const LineWithID &l1, const LineWithID &l2);
static ConflictObjName find_inter_of_lines_in_diff_objs(PrintObjectPtrs objs, std::optional<const FakeWipeTower *> wtdptr);
static ConflictRet find_inter_of_lines(const LineWithIDs &lines);
static ConflictRet line_intersect(const LineWithID &l1, const LineWithID &l2);
};
} // namespace Slic3r

2
src/libslic3r/GCode/WipeTower.hpp
View file

@ -156,6 +156,8 @@ public:
float get_depth() const { return m_wipe_tower_depth; }
float get_brim_width() const { return m_wipe_tower_brim_width_real; }
float get_height() const { return m_wipe_tower_height; }
float get_layer_height() const { return m_layer_height; }
void set_last_layer_extruder_fill(bool extruder_fill) {
if (!m_plan.empty()) {