diff --git a/src/libslic3r/ExtrusionEntity.cpp b/src/libslic3r/ExtrusionEntity.cpp index 92f0d3669..b59ff6a4d 100644 --- a/src/libslic3r/ExtrusionEntity.cpp +++ b/src/libslic3r/ExtrusionEntity.cpp @@ -63,62 +63,6 @@ void ExtrusionPath::polygons_covered_by_spacing(Polygons &out, const float scale polygons_append(out, offset(this->polyline, 0.5f * float(flow.scaled_spacing()) + scaled_epsilon)); } -void ExtrusionMultiPath::reverse() -{ - for (ExtrusionPaths::iterator path = this->paths.begin(); path != this->paths.end(); ++path) - path->reverse(); - std::reverse(this->paths.begin(), this->paths.end()); -} - -double ExtrusionMultiPath::length() const -{ - double len = 0; - for (ExtrusionPaths::const_iterator path = this->paths.begin(); path != this->paths.end(); ++path) - len += path->polyline.length(); - return len; -} - -void ExtrusionMultiPath::polygons_covered_by_width(Polygons &out, const float scaled_epsilon) const -{ - for (ExtrusionPaths::const_iterator path = this->paths.begin(); path != this->paths.end(); ++path) - path->polygons_covered_by_width(out, scaled_epsilon); -} - -void ExtrusionMultiPath::polygons_covered_by_spacing(Polygons &out, const float scaled_epsilon) const -{ - for (ExtrusionPaths::const_iterator path = this->paths.begin(); path != this->paths.end(); ++path) - path->polygons_covered_by_spacing(out, scaled_epsilon); -} - -double ExtrusionMultiPath::min_mm3_per_mm() const -{ - double min_mm3_per_mm = std::numeric_limits::max(); - for (ExtrusionPaths::const_iterator path = this->paths.begin(); path != this->paths.end(); ++path) - min_mm3_per_mm = std::min(min_mm3_per_mm, path->mm3_per_mm); - return min_mm3_per_mm; -} - -Polyline ExtrusionMultiPath::as_polyline() const -{ - Polyline out; - if (! paths.empty()) { - size_t len = 0; - for (size_t i_path = 0; i_path < paths.size(); ++ i_path) { - assert(! paths[i_path].polyline.points.empty()); - assert(i_path == 0 || paths[i_path - 1].polyline.points.back() == paths[i_path].polyline.points.front()); - len += paths[i_path].polyline.points.size(); - } - // The connecting points between the segments are equal. - len -= paths.size() - 1; - assert(len > 0); - out.points.reserve(len); - out.points.push_back(paths.front().polyline.points.front()); - for (size_t i_path = 0; i_path < paths.size(); ++ i_path) - out.points.insert(out.points.end(), paths[i_path].polyline.points.begin() + 1, paths[i_path].polyline.points.end()); - } - return out; -} - bool ExtrusionLoop::make_clockwise() { @@ -318,4 +262,61 @@ ExtrusionLoop::min_mm3_per_mm() const return min_mm3_per_mm; } +void ExtrusionPrinter::use(const ExtrusionPath &path) { + ss << "Path_" << path.polyline.size(); + for (const Point &p : path.polyline.points) + ss << "->" << (int)(100 * unscale_(p.x())) << ":" << (int)(100 * unscale_(p.y())); +} +void ExtrusionPrinter::use(const ExtrusionPath3D &path3D) { + ss << "Path3D_" << path3D.polyline.size(); + for (int i = 0; i < path3D.polyline.points.size();i++) + ss << "->" << (int)(100 * unscale_(path3D.polyline.points[i].x())) << ":" << (int)(100 * unscale_(path3D.polyline.points[i].y())) << ":" << (path3D.z_offsets.size()>i ? unscale_(path3D.z_offsets[i]) : -1); +} +void ExtrusionPrinter::use(const ExtrusionMultiPath &multipath) { + ss << "multipath:{"; + for (int i = 0; i < multipath.paths.size(); i++) { + if (i != 0) ss << ","; + multipath.paths[i].visit(*this); + } + ss << "}"; +} +void ExtrusionPrinter::use(const ExtrusionMultiPath3D &multipath3D) { + ss << "multipath3D:{"; + for (int i = 0; i < multipath3D.paths.size(); i++) { + if (i != 0) ss << ","; + multipath3D.paths[i].visit(*this); + } + ss << "}"; +} +void ExtrusionPrinter::use(const ExtrusionLoop &loop) { ss << "loop_" << loop.paths.size(); } +void ExtrusionPrinter::use(const ExtrusionEntityCollection &collection) { + ss << "collection:{"; + for (int i = 0; i < collection.entities.size(); i++) { + if (i != 0) ss << ","; + collection.entities[i]->visit(*this); + } + ss << "}"; +} + + +class ExtrusionTreeVisitor : ExtrusionVisitor { +public: + //virtual void use(ExtrusionEntity &entity) { assert(false); }; + virtual void use(ExtrusionPath &path) override { const ExtrusionPath &constpath = path; use(constpath); }; + virtual void use(ExtrusionPath3D &path3D) override { const ExtrusionPath3D &constpath3D = path3D; use(constpath3D); }; + virtual void use(ExtrusionMultiPath &multipath) override { const ExtrusionMultiPath &constmultipath = multipath; use(constmultipath); }; + virtual void use(ExtrusionMultiPath3D &multipath3D) override { const ExtrusionMultiPath3D &constmultipath3D = multipath3D; use(constmultipath3D); }; + virtual void use(ExtrusionLoop &loop) override { const ExtrusionLoop &constloop = loop; use(constloop); }; + virtual void use(ExtrusionEntityCollection &collection) { const ExtrusionEntityCollection &constcollection = collection; use(constcollection); }; + virtual void use(const ExtrusionPath &path) override { assert(false); }; + virtual void use(const ExtrusionPath3D &path3D) override { assert(false); }; + virtual void use(const ExtrusionMultiPath &multipath) override { assert(false); }; + virtual void use(const ExtrusionMultiPath3D &multipath3D) { assert(false); }; + virtual void use(const ExtrusionLoop &loop) override { assert(false); }; + virtual void use(const ExtrusionEntityCollection &collection) { assert(false); }; + virtual void use_default(ExtrusionEntity &entity) { const ExtrusionEntity &constentity = entity; use_default(constentity); }; + virtual void use_default(const ExtrusionEntity &entity) {}; + +}; + } diff --git a/src/libslic3r/ExtrusionEntity.hpp b/src/libslic3r/ExtrusionEntity.hpp index 7c9495207..274f842cd 100644 --- a/src/libslic3r/ExtrusionEntity.hpp +++ b/src/libslic3r/ExtrusionEntity.hpp @@ -65,6 +65,30 @@ enum ExtrusionLoopRole { elrSkirt, }; + +class ExtrusionPath; +class ExtrusionPath3D; +class ExtrusionMultiPath; +class ExtrusionMultiPath3D; +class ExtrusionLoop; +class ExtrusionVisitor { +public: + //virtual void use(ExtrusionEntity &entity) { assert(false); }; + virtual void use(ExtrusionPath &path) { const ExtrusionPath &constpath = path; use(constpath); }; + virtual void use(ExtrusionPath3D &path3D) { const ExtrusionPath3D &constpath3D = path3D; use(constpath3D); }; + virtual void use(ExtrusionMultiPath &multipath) { const ExtrusionMultiPath &constmultipath = multipath; use(constmultipath); }; + virtual void use(ExtrusionMultiPath3D &multipath3D) { const ExtrusionMultiPath3D &constmultipath3D = multipath3D; use(constmultipath3D); }; + virtual void use(ExtrusionLoop &loop) { const ExtrusionLoop &constloop = loop; use(constloop); }; + virtual void use(ExtrusionEntityCollection &collection) { const ExtrusionEntityCollection &constcollection = collection; use(constcollection); }; + virtual void use(const ExtrusionPath &path) { assert(false); }; + virtual void use(const ExtrusionPath3D &path3D) { assert(false); }; + virtual void use(const ExtrusionMultiPath &multipath) { assert(false); }; + virtual void use(const ExtrusionMultiPath3D &multipath3D) { assert(false); }; + virtual void use(const ExtrusionLoop &loop) { assert(false); }; + virtual void use(const ExtrusionEntityCollection &collection) { assert(false); }; + +}; + class ExtrusionEntity { public: @@ -84,9 +108,9 @@ public: // Increase the offset by scaled_epsilon to achieve an overlap, so a union will produce no gaps. // Useful to calculate area of an infill, which has been really filled in by a 100% rectilinear infill. virtual void polygons_covered_by_spacing(Polygons &out, const float scaled_epsilon) const = 0; - Polygons polygons_covered_by_width(const float scaled_epsilon = 0.f) const + virtual Polygons polygons_covered_by_width(const float scaled_epsilon = 0.f) const { Polygons out; this->polygons_covered_by_width(out, scaled_epsilon); return out; } - Polygons polygons_covered_by_spacing(const float scaled_epsilon = 0.f) const + virtual Polygons polygons_covered_by_spacing(const float scaled_epsilon = 0.f) const { Polygons out; this->polygons_covered_by_spacing(out, scaled_epsilon); return out; } // Minimum volumetric velocity of this extrusion entity. Used by the constant nozzle pressure algorithm. virtual double min_mm3_per_mm() const = 0; @@ -95,6 +119,8 @@ public: virtual Polylines as_polylines() const { Polylines dst; this->collect_polylines(dst); return dst; } virtual double length() const = 0; virtual double total_volume() const = 0; + virtual void visit(ExtrusionVisitor &visitor) = 0; + virtual void visit(ExtrusionVisitor &visitor) const = 0; }; typedef std::vector ExtrusionEntitiesPtr; @@ -125,8 +151,8 @@ public: ExtrusionPath& operator=(const ExtrusionPath &rhs) { m_role = rhs.m_role; this->mm3_per_mm = rhs.mm3_per_mm; this->width = rhs.width; this->height = rhs.height; this->feedrate = rhs.feedrate, this->extruder_id = rhs.extruder_id, this->cp_color_id = rhs.cp_color_id, this->polyline = rhs.polyline; return *this; } ExtrusionPath& operator=(ExtrusionPath &&rhs) { m_role = rhs.m_role; this->mm3_per_mm = rhs.mm3_per_mm; this->width = rhs.width; this->height = rhs.height; this->feedrate = rhs.feedrate, this->extruder_id = rhs.extruder_id, this->cp_color_id = rhs.cp_color_id, this->polyline = std::move(rhs.polyline); return *this; } - ExtrusionPath* clone() const { return new ExtrusionPath (*this); } - void reverse() { this->polyline.reverse(); } + virtual ExtrusionPath* clone() const override { return new ExtrusionPath(*this); } + void reverse() override { this->polyline.reverse(); } Point first_point() const override { return this->polyline.points.front(); } Point last_point() const override { return this->polyline.points.back(); } size_t size() const { return this->polyline.size(); } @@ -139,75 +165,177 @@ public: // Currently not used. void subtract_expolygons(const ExPolygonCollection &collection, ExtrusionEntityCollection* retval) const; void clip_end(double distance); - void simplify(double tolerance); + virtual void simplify(double tolerance); double length() const override; ExtrusionRole role() const override { return m_role; } + void set_role(ExtrusionRole new_role) { m_role = new_role; } // Produce a list of 2D polygons covered by the extruded paths, offsetted by the extrusion width. // Increase the offset by scaled_epsilon to achieve an overlap, so a union will produce no gaps. - void polygons_covered_by_width(Polygons &out, const float scaled_epsilon) const; + void polygons_covered_by_width(Polygons &out, const float scaled_epsilon) const override; // Produce a list of 2D polygons covered by the extruded paths, offsetted by the extrusion spacing. // Increase the offset by scaled_epsilon to achieve an overlap, so a union will produce no gaps. // Useful to calculate area of an infill, which has been really filled in by a 100% rectilinear infill. - void polygons_covered_by_spacing(Polygons &out, const float scaled_epsilon) const; - Polygons polygons_covered_by_width(const float scaled_epsilon = 0.f) const - { Polygons out; this->polygons_covered_by_width(out, scaled_epsilon); return out; } - Polygons polygons_covered_by_spacing(const float scaled_epsilon = 0.f) const - { Polygons out; this->polygons_covered_by_spacing(out, scaled_epsilon); return out; } + void polygons_covered_by_spacing(Polygons &out, const float scaled_epsilon) const override; // Minimum volumetric velocity of this extrusion entity. Used by the constant nozzle pressure algorithm. - double min_mm3_per_mm() const { return this->mm3_per_mm; } - Polyline as_polyline() const { return this->polyline; } + double min_mm3_per_mm() const override { return this->mm3_per_mm; } + Polyline as_polyline() const override { return this->polyline; } void collect_polylines(Polylines &dst) const override { if (! this->polyline.empty()) dst.emplace_back(this->polyline); } double total_volume() const override { return mm3_per_mm * unscale(length()); } + virtual void visit(ExtrusionVisitor &visitor) override { visitor.use(*this); }; + virtual void visit(ExtrusionVisitor &visitor) const override { visitor.use(*this); }; -private: +protected: void _inflate_collection(const Polylines &polylines, ExtrusionEntityCollection* collection) const; ExtrusionRole m_role; }; - typedef std::vector ExtrusionPaths; -// Single continuous extrusion path, possibly with varying extrusion thickness, extrusion height or bridging / non bridging. -class ExtrusionMultiPath : public ExtrusionEntity -{ +class ExtrusionPath3D : public ExtrusionPath { public: - ExtrusionPaths paths; - - ExtrusionMultiPath() {}; - ExtrusionMultiPath(const ExtrusionMultiPath &rhs) : paths(rhs.paths) {} - ExtrusionMultiPath(ExtrusionMultiPath &&rhs) : paths(std::move(rhs.paths)) {} - ExtrusionMultiPath(const ExtrusionPaths &paths) : paths(paths) {}; - ExtrusionMultiPath(const ExtrusionPath &path) { this->paths.push_back(path); } + std::vector z_offsets; - ExtrusionMultiPath& operator=(const ExtrusionMultiPath &rhs) { this->paths = rhs.paths; return *this; } - ExtrusionMultiPath& operator=(ExtrusionMultiPath &&rhs) { this->paths = std::move(rhs.paths); return *this; } + ExtrusionPath3D(ExtrusionRole role) : ExtrusionPath(role) { /*std::cout << "new path3D\n"; */}; + ExtrusionPath3D(ExtrusionRole role, double mm3_per_mm, float width, float height) : ExtrusionPath(role, mm3_per_mm, width, height) { /*std::cout << "new path3D++\n";*/ }; + ExtrusionPath3D(const ExtrusionPath &rhs) : ExtrusionPath(rhs) { /*std::cout << "new path3D from path "<paths.front().polyline.points.front(); } - Point last_point() const override { return this->paths.back().polyline.points.back(); } - double length() const override; + ExtrusionPath3D& operator=(const ExtrusionPath3D &rhs) { m_role = rhs.m_role; this->mm3_per_mm = rhs.mm3_per_mm; this->width = rhs.width; this->height = rhs.height; + this->feedrate = rhs.feedrate, this->extruder_id = rhs.extruder_id, this->cp_color_id = rhs.cp_color_id, this->polyline = rhs.polyline; z_offsets = rhs.z_offsets; return *this; + } + ExtrusionPath3D& operator=(ExtrusionPath3D &&rhs) { m_role = rhs.m_role; this->mm3_per_mm = rhs.mm3_per_mm; this->width = rhs.width; this->height = rhs.height; + this->feedrate = rhs.feedrate, this->extruder_id = rhs.extruder_id, this->cp_color_id = rhs.cp_color_id, this->polyline = std::move(rhs.polyline); z_offsets = std::move(rhs.z_offsets); return *this; + } + ExtrusionPath3D* clone() const { return new ExtrusionPath3D(*this); } + virtual void visit(ExtrusionVisitor &visitor) override { visitor.use(*this); }; + virtual void visit(ExtrusionVisitor &visitor) const override { visitor.use(*this); }; + + void push_back(Point p, coord_t z_offset) { polyline.points.push_back(p); z_offsets.push_back(z_offset); } + + //TODO: simplify only for points that have the same z-offset + void simplify(double tolerance) override {} +}; +typedef std::vector ExtrusionPaths3D; + +// Single continuous extrusion path, possibly with varying extrusion thickness, extrusion height or bridging / non bridging. +template +class ExtrusionMultiEntity : public ExtrusionEntity { +public: + std::vector paths; + + ExtrusionMultiEntity() {}; + ExtrusionMultiEntity(const ExtrusionMultiEntity &rhs) : paths(rhs.paths) {} + ExtrusionMultiEntity(ExtrusionMultiEntity &&rhs) : paths(std::move(rhs.paths)) {} + ExtrusionMultiEntity(const std::vector &paths) : paths(paths) {}; + ExtrusionMultiEntity(const THING &path) { this->paths.push_back(path); } + + ExtrusionMultiEntity& operator=(const ExtrusionMultiEntity &rhs) { this->paths = rhs.paths; return *this; } + ExtrusionMultiEntity& operator=(ExtrusionMultiEntity &&rhs) { this->paths = std::move(rhs.paths); return *this; } + + bool is_loop() const override { return false; } ExtrusionRole role() const override { return this->paths.empty() ? erNone : this->paths.front().role(); } + virtual Point first_point() const override { return this->paths.back().as_polyline().points.back(); } + virtual Point last_point() const override { return this->paths.back().as_polyline().points.back(); } + + virtual void reverse() override { + for (THING &entity : this->paths) + entity.reverse(); + std::reverse(this->paths.begin(), this->paths.end()); + } + + double length() const override { + double len = 0; + for (const THING &entity : this->paths) + len += entity.length(); + return len; + } + // Produce a list of 2D polygons covered by the extruded paths, offsetted by the extrusion width. // Increase the offset by scaled_epsilon to achieve an overlap, so a union will produce no gaps. - void polygons_covered_by_width(Polygons &out, const float scaled_epsilon) const; + void polygons_covered_by_width(Polygons &out, const float scaled_epsilon) const override { + for (const THING &entity : this->paths) + entity.polygons_covered_by_width(out, scaled_epsilon); + } + // Produce a list of 2D polygons covered by the extruded paths, offsetted by the extrusion spacing. // Increase the offset by scaled_epsilon to achieve an overlap, so a union will produce no gaps. // Useful to calculate area of an infill, which has been really filled in by a 100% rectilinear infill. - void polygons_covered_by_spacing(Polygons &out, const float scaled_epsilon) const; - Polygons polygons_covered_by_width(const float scaled_epsilon = 0.f) const - { Polygons out; this->polygons_covered_by_width(out, scaled_epsilon); return out; } - Polygons polygons_covered_by_spacing(const float scaled_epsilon = 0.f) const - { Polygons out; this->polygons_covered_by_spacing(out, scaled_epsilon); return out; } + void polygons_covered_by_spacing(Polygons &out, const float scaled_epsilon) const override { + for (const THING &entity : this->paths) + entity.polygons_covered_by_spacing(out, scaled_epsilon); + } + // Minimum volumetric velocity of this extrusion entity. Used by the constant nozzle pressure algorithm. - double min_mm3_per_mm() const; - Polyline as_polyline() const; - void collect_polylines(Polylines &dst) const override { Polyline pl = this->as_polyline(); if (! pl.empty()) dst.emplace_back(std::move(pl)); } - double total_volume() const override { double volume =0.; for (const auto& path : paths) volume += path.total_volume(); return volume; } + double min_mm3_per_mm() const override { + double min_mm3_per_mm = std::numeric_limits::max(); + for (const THING &entity : this->paths) + min_mm3_per_mm = std::min(min_mm3_per_mm, entity.min_mm3_per_mm()); + return min_mm3_per_mm; + } + + Polyline as_polyline() const override { + Polyline out; + if (!paths.empty()) { + size_t len = 0; + for (size_t i_path = 0; i_path < paths.size(); ++i_path) { + assert(!paths[i_path].as_polyline().points.empty()); + assert(i_path == 0 || paths[i_path - 1].polyline.points.back() == paths[i_path].as_polyline().points.front()); + len += paths[i_path].as_polyline().points.size(); + } + // The connecting points between the segments are equal. + len -= paths.size() - 1; + assert(len > 0); + out.points.reserve(len); + out.points.push_back(paths.front().as_polyline().points.front()); + for (size_t i_path = 0; i_path < paths.size(); ++i_path) + out.points.insert(out.points.end(), paths[i_path].as_polyline().points.begin() + 1, paths[i_path].as_polyline().points.end()); + } + return out; + } + Polygons polygons_covered_by_width(const float scaled_epsilon = 0.f) const override{ Polygons out; this->polygons_covered_by_width(out, scaled_epsilon); return out; } + Polygons polygons_covered_by_spacing(const float scaled_epsilon = 0.f) const override { Polygons out; this->polygons_covered_by_spacing(out, scaled_epsilon); return out; } + void collect_polylines(Polylines &dst) const override { Polyline pl = this->as_polyline(); if (!pl.empty()) dst.emplace_back(std::move(pl)); } + double total_volume() const override { double volume = 0.; for (const auto& path : paths) volume += path.total_volume(); return volume; } }; +// Single continuous extrusion path, possibly with varying extrusion thickness, extrusion height or bridging / non bridging. +class ExtrusionMultiPath : public ExtrusionMultiEntity { +public: + + ExtrusionMultiPath() {}; + ExtrusionMultiPath(const ExtrusionMultiPath &rhs) : ExtrusionMultiEntity(rhs) {} + ExtrusionMultiPath(ExtrusionMultiPath &&rhs) : ExtrusionMultiEntity(rhs) {} + ExtrusionMultiPath(const ExtrusionPaths &paths) : ExtrusionMultiEntity(paths) {}; + ExtrusionMultiPath(const ExtrusionPath &path) :ExtrusionMultiEntity(path) {} + + virtual ExtrusionMultiPath* clone() const override { return new ExtrusionMultiPath(*this); } + + virtual void visit(ExtrusionVisitor &visitor) override { visitor.use(*this); }; + virtual void visit(ExtrusionVisitor &visitor) const override { visitor.use(*this); }; +}; +// Single continuous extrusion path, possibly with varying extrusion thickness, extrusion height or bridging / non bridging. +class ExtrusionMultiPath3D : public ExtrusionMultiEntity { +public: + + ExtrusionMultiPath3D() {}; + ExtrusionMultiPath3D(const ExtrusionMultiPath3D &rhs) : ExtrusionMultiEntity(rhs) {} + ExtrusionMultiPath3D(ExtrusionMultiPath3D &&rhs) : ExtrusionMultiEntity(rhs) {} + ExtrusionMultiPath3D(const ExtrusionPaths3D &paths) : ExtrusionMultiEntity(paths) {}; + ExtrusionMultiPath3D(const ExtrusionPath3D &path) :ExtrusionMultiEntity(path) {} + + virtual ExtrusionMultiPath3D* clone() const override { return new ExtrusionMultiPath3D(*this); } + + virtual void visit(ExtrusionVisitor &visitor) override { visitor.use(*this); }; + virtual void visit(ExtrusionVisitor &visitor) const override { visitor.use(*this); }; + + virtual bool can_reverse() const override { return false; } + virtual void reverse() override { + std::cout << "I SAID NO REVERSE§§§FFFS\n"; + } +}; // Single continuous extrusion loop, possibly with varying extrusion thickness, extrusion height or bridging / non bridging. class ExtrusionLoop : public ExtrusionEntity @@ -255,7 +383,9 @@ public: double min_mm3_per_mm() const; Polyline as_polyline() const { return this->polygon().split_at_first_point(); } void collect_polylines(Polylines &dst) const override { Polyline pl = this->as_polyline(); if (! pl.empty()) dst.emplace_back(std::move(pl)); } - double total_volume() const override { double volume =0.; for (const auto& path : paths) volume += path.total_volume(); return volume; } + double total_volume() const override { double volume = 0.; for (const auto& path : paths) volume += path.total_volume(); return volume; } + virtual void visit(ExtrusionVisitor &visitor) override { visitor.use(*this); }; + virtual void visit(ExtrusionVisitor &visitor) const override { visitor.use(*this); }; private: ExtrusionLoopRole m_loop_role; @@ -343,6 +473,19 @@ inline void extrusion_entities_append_loops(ExtrusionEntitiesPtr &dst, Polygons loops.clear(); } +class ExtrusionPrinter : public ExtrusionVisitor { + std::stringstream ss; +public: + virtual void use(const ExtrusionPath &path); + virtual void use(const ExtrusionPath3D &path3D); + virtual void use(const ExtrusionMultiPath &multipath); + virtual void use(const ExtrusionMultiPath3D &multipath); + virtual void use(const ExtrusionLoop &loop); + virtual void use(const ExtrusionEntityCollection &collection); + std::string str() { return ss.str(); } +// void clear() { return ss.clear(); } +}; + } #endif diff --git a/src/libslic3r/ExtrusionEntityCollection.cpp b/src/libslic3r/ExtrusionEntityCollection.cpp index c54541a7d..77faf1569 100644 --- a/src/libslic3r/ExtrusionEntityCollection.cpp +++ b/src/libslic3r/ExtrusionEntityCollection.cpp @@ -61,7 +61,7 @@ ExtrusionEntityCollection::reverse() for (ExtrusionEntitiesPtr::iterator it = this->entities.begin(); it != this->entities.end(); ++it) { // Don't reverse it if it's a loop, as it doesn't change anything in terms of elements ordering // and caller might rely on winding order - if (!(*it)->is_loop()) (*it)->reverse(); + if (!(*it)->can_reverse()) (*it)->reverse(); } std::reverse(this->entities.begin(), this->entities.end()); } diff --git a/src/libslic3r/ExtrusionEntityCollection.hpp b/src/libslic3r/ExtrusionEntityCollection.hpp index d65d307ef..f6dcfe566 100644 --- a/src/libslic3r/ExtrusionEntityCollection.hpp +++ b/src/libslic3r/ExtrusionEntityCollection.hpp @@ -103,6 +103,8 @@ public: throw std::runtime_error("Calling length() on a ExtrusionEntityCollection"); return 0.; } + virtual void visit(ExtrusionVisitor &visitor) { visitor.use(*this); }; + virtual void visit(ExtrusionVisitor &visitor) const { visitor.use(*this); }; }; } diff --git a/src/libslic3r/GCodeWriter.cpp b/src/libslic3r/GCodeWriter.cpp index 6ef17f4f4..e1c2d3888 100644 --- a/src/libslic3r/GCodeWriter.cpp +++ b/src/libslic3r/GCodeWriter.cpp @@ -375,14 +375,15 @@ std::string GCodeWriter::extrude_to_xy(const Vec2d &point, double dE, const std: std::string GCodeWriter::extrude_to_xyz(const Vec3d &point, double dE, const std::string &comment) { - m_pos = point; + m_pos(0) = point(0); + m_pos(1) = point(1); m_lifted = 0; m_extruder->extrude(dE); std::ostringstream gcode; - gcode << "G1 X" << XYZF_NUM(point(0)) - << " Y" << XYZF_NUM(point(1)) - << " Z" << XYZF_NUM(point(2)) + gcode << "G1 X" << XYZF_NUM(point.x()) + << " Y" << XYZF_NUM(point.y()) + << " Z" << XYZF_NUM(point.z() + m_pos.z()) << " " << m_extrusion_axis << E_NUM(m_extruder->E()); COMMENT(comment); gcode << "\n"; diff --git a/src/slic3r/GUI/3DScene.cpp b/src/slic3r/GUI/3DScene.cpp index 6b1df6ab3..f8b717d69 100644 --- a/src/slic3r/GUI/3DScene.cpp +++ b/src/slic3r/GUI/3DScene.cpp @@ -1604,8 +1604,7 @@ void _3DScene::extrusionentity_to_verts(const ExtrusionLoop &extrusion_loop, flo } // Fill in the qverts and tverts with quads and triangles for the extrusion_multi_path. -void _3DScene::extrusionentity_to_verts(const ExtrusionMultiPath &extrusion_multi_path, float print_z, const Point ©, GLVolume &volume) -{ +void _3DScene::extrusionentity_to_verts(const ExtrusionMultiPath &extrusion_multi_path, float print_z, const Point ©, GLVolume &volume) { Lines lines; std::vector widths; std::vector heights; @@ -1621,37 +1620,34 @@ void _3DScene::extrusionentity_to_verts(const ExtrusionMultiPath &extrusion_mult thick_lines_to_verts(lines, widths, heights, false, print_z, volume); } -void _3DScene::extrusionentity_to_verts(const ExtrusionEntityCollection &extrusion_entity_collection, float print_z, const Point ©, GLVolume &volume) -{ - for (const ExtrusionEntity *extrusion_entity : extrusion_entity_collection.entities) - extrusionentity_to_verts(extrusion_entity, print_z, copy, volume); +// Fill in the qverts and tverts with quads and triangles for the extrusion_multi_path. +void _3DScene::extrusionentity_to_verts(const ExtrusionMultiPath3D &extrusion_multi_path, float print_z, const Point ©, GLVolume &volume) { + Lines lines; + std::vector widths; + std::vector heights; + for (const ExtrusionPath3D &extrusion_path : extrusion_multi_path.paths) { + Polyline polyline = extrusion_path.polyline; + polyline.remove_duplicate_points(); + polyline.translate(copy); + Lines lines_this = polyline.lines(); + append(lines, lines_this); + widths.insert(widths.end(), lines_this.size(), extrusion_path.width); + heights.insert(heights.end(), lines_this.size(), extrusion_path.height); + } + thick_lines_to_verts(lines, widths, heights, false, print_z, volume); } -void _3DScene::extrusionentity_to_verts(const ExtrusionEntity *extrusion_entity, float print_z, const Point ©, GLVolume &volume) +void ExtrusionToVert::use(const ExtrusionPath &path) { _3DScene::extrusionentity_to_verts(path, print_z, copy, volume); } +void ExtrusionToVert::use(const ExtrusionPath3D &path3D) { _3DScene::extrusionentity_to_verts(path3D, print_z, copy, volume); } +void ExtrusionToVert::use(const ExtrusionMultiPath &multipath) { _3DScene::extrusionentity_to_verts(multipath, print_z, copy, volume); } +void ExtrusionToVert::use(const ExtrusionMultiPath3D &multipath3D) { _3DScene::extrusionentity_to_verts(multipath3D, print_z, copy, volume); } +void ExtrusionToVert::use(const ExtrusionLoop &loop) { _3DScene::extrusionentity_to_verts(loop, print_z, copy, volume); } +void ExtrusionToVert::use(const ExtrusionEntityCollection &collection) { for (const ExtrusionEntity *extrusion_entity : collection.entities) extrusion_entity->visit(*this); } + +void _3DScene::extrusionentity_to_verts(const ExtrusionEntity &extrusion_entity, float print_z, const Point ©, GLVolume &volume) { - if (extrusion_entity != nullptr) { - auto *extrusion_path = dynamic_cast(extrusion_entity); - if (extrusion_path != nullptr) - extrusionentity_to_verts(*extrusion_path, print_z, copy, volume); - else { - auto *extrusion_loop = dynamic_cast(extrusion_entity); - if (extrusion_loop != nullptr) - extrusionentity_to_verts(*extrusion_loop, print_z, copy, volume); - else { - auto *extrusion_multi_path = dynamic_cast(extrusion_entity); - if (extrusion_multi_path != nullptr) - extrusionentity_to_verts(*extrusion_multi_path, print_z, copy, volume); - else { - auto *extrusion_entity_collection = dynamic_cast(extrusion_entity); - if (extrusion_entity_collection != nullptr) - extrusionentity_to_verts(*extrusion_entity_collection, print_z, copy, volume); - else { - throw std::runtime_error("Unexpected extrusion_entity type in to_verts()"); - } - } - } - } - } + ExtrusionToVert visitor(print_z, copy, volume); + extrusion_entity.visit(visitor); } void _3DScene::polyline3_to_verts(const Polyline3& polyline, double width, double height, GLVolume& volume) diff --git a/src/slic3r/GUI/3DScene.hpp b/src/slic3r/GUI/3DScene.hpp index 2732b5a13..a02497116 100644 --- a/src/slic3r/GUI/3DScene.hpp +++ b/src/slic3r/GUI/3DScene.hpp @@ -36,6 +36,7 @@ class ModelObject; class DynamicPrintConfig; class ExtrusionPath; class ExtrusionMultiPath; +class ExtrusionMultiPath3D; class ExtrusionLoop; class ExtrusionEntity; class ExtrusionEntityCollection; @@ -589,12 +590,27 @@ public: static void extrusionentity_to_verts(const ExtrusionPath& extrusion_path, float print_z, const Point& copy, GLVolume& volume); static void extrusionentity_to_verts(const ExtrusionLoop& extrusion_loop, float print_z, const Point& copy, GLVolume& volume); static void extrusionentity_to_verts(const ExtrusionMultiPath& extrusion_multi_path, float print_z, const Point& copy, GLVolume& volume); - static void extrusionentity_to_verts(const ExtrusionEntityCollection& extrusion_entity_collection, float print_z, const Point& copy, GLVolume& volume); - static void extrusionentity_to_verts(const ExtrusionEntity* extrusion_entity, float print_z, const Point& copy, GLVolume& volume); + static void extrusionentity_to_verts(const ExtrusionMultiPath3D& extrusion_multi_path, float print_z, const Point& copy, GLVolume& volume); + static void extrusionentity_to_verts(const ExtrusionEntity &extrusion_entity, float print_z, const Point& copy, GLVolume& volume); static void polyline3_to_verts(const Polyline3& polyline, double width, double height, GLVolume& volume); static void point3_to_verts(const Vec3crd& point, double width, double height, GLVolume& volume); }; + +class ExtrusionToVert : public ExtrusionVisitor { + float print_z; + const Point © + GLVolume &volume; +public: + ExtrusionToVert(float print_z, const Point ©, GLVolume &volume) : print_z(print_z), copy(copy), volume(volume) {} + virtual void use(const ExtrusionPath &path) override; + virtual void use(const ExtrusionPath3D &path3D) override; + virtual void use(const ExtrusionMultiPath &multipath) override; + virtual void use(const ExtrusionMultiPath3D &multipath) override; + virtual void use(const ExtrusionLoop &loop) override; + virtual void use(const ExtrusionEntityCollection &collection) override; +}; + } #endif diff --git a/src/slic3r/GUI/GLCanvas3D.cpp b/src/slic3r/GUI/GLCanvas3D.cpp index 43cfa38ed..5f51596bb 100644 --- a/src/slic3r/GUI/GLCanvas3D.cpp +++ b/src/slic3r/GUI/GLCanvas3D.cpp @@ -7317,7 +7317,8 @@ void GLCanvas3D::_load_print_object_toolpaths(const PrintObject& print_object, c // fill represents infill extrusions of a single island. const auto *fill = dynamic_cast(ee); if (!fill->entities.empty()) - _3DScene::extrusionentity_to_verts(*fill, float(layer->print_z), copy, + if (fill != nullptr) + _3DScene::extrusionentity_to_verts(*fill, float(layer->print_z), copy, *vols[ctxt.volume_idx( is_solid_infill(fill->entities.front()->role()) ? layerm->region()->config().solid_infill_extruder : @@ -7330,7 +7331,8 @@ void GLCanvas3D::_load_print_object_toolpaths(const PrintObject& print_object, c const SupportLayer *support_layer = dynamic_cast(layer); if (support_layer) { for (const ExtrusionEntity *extrusion_entity : support_layer->support_fills.entities) - _3DScene::extrusionentity_to_verts(extrusion_entity, float(layer->print_z), copy, + if (extrusion_entity != nullptr) + _3DScene::extrusionentity_to_verts(*extrusion_entity, float(layer->print_z), copy, *vols[ctxt.volume_idx( (extrusion_entity->role() == erSupportMaterial) ? support_layer->object()->config().support_material_extruder :