Extrusion entity visitor & 3D extrusion path

* Add a visitor class for extrusion entity
 * replace most of extrusionEntity* cast by a visitor
 * create a ExtrusionPath3D, subclass of ExtrusionPath
 * create a ExtrusionMultiPath3D, with a generic ExtrusionMultiEntity for the two one (note: need some more work to make it more generic)
 * modify gcode to allow the export of 3D path (minimum modification/effort: no validity check).

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<double>::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) {};
+
+};
+
 }

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<ExtrusionEntity*> 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); }
+    virtual ExtrusionPath* clone() const override { return new ExtrusionPath(*this); }
-    void reverse() { this->polyline.reverse(); }
+    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;
+    void polygons_covered_by_spacing(Polygons &out, const float scaled_epsilon) const override;
-    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; }
     // 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; }
+    double min_mm3_per_mm() const override { return this->mm3_per_mm; }
-    Polyline as_polyline() const { return this->polyline; }
+    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<double>(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<ExtrusionPath> ExtrusionPaths;
 
-// Single continuous extrusion path, possibly with varying extrusion thickness, extrusion height or bridging / non bridging.
+class ExtrusionPath3D : public ExtrusionPath {
-class ExtrusionMultiPath : public ExtrusionEntity
-{
 public:
-    ExtrusionPaths paths;
+    std::vector<coord_t> z_offsets;
-    
-    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); }
 
-    ExtrusionMultiPath& operator=(const ExtrusionMultiPath &rhs) { this->paths = rhs.paths; return *this; }
+    ExtrusionPath3D(ExtrusionRole role) : ExtrusionPath(role) { /*std::cout << "new path3D\n"; */};
-    ExtrusionMultiPath& operator=(ExtrusionMultiPath &&rhs) { this->paths = std::move(rhs.paths); return *this; }
+    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 "<<size()<<"?"<<z_offsets.size()<<"\n";*/ }
+    ExtrusionPath3D(ExtrusionPath &&rhs) : ExtrusionPath(rhs) { /*std::cout << "new path3D from path " << size() << "?" << z_offsets.size()<<"\n";*/ }
+    ExtrusionPath3D(const ExtrusionPath3D &rhs) : ExtrusionPath(rhs), z_offsets(rhs.z_offsets) { /*std::cout << "new path3D from path3D " << size() << "?" << z_offsets.size()<<"\n";*/ }
+    ExtrusionPath3D(ExtrusionPath3D &&rhs) : ExtrusionPath(rhs), z_offsets(std::move(rhs.z_offsets)) { /*std::cout << "new2 path3D from path3D " << size() << "?" << z_offsets.size()<<"\n";*/ }
+    //    ExtrusionPath(ExtrusionRole role, const Flow &flow) : m_role(role), mm3_per_mm(flow.mm3_per_mm()), width(flow.width), height(flow.height), feedrate(0.0f), extruder_id(0) {};
 
-    bool is_loop() const { return false; }
+    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; 
-    bool can_reverse() const { return true; }
+        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;
-    ExtrusionMultiPath* clone() const { return new ExtrusionMultiPath(*this); }
+    }
-    void reverse();
+    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; 
-    Point first_point() const override { return this->paths.front().polyline.points.front(); }
+        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;
-    Point last_point() const override { return this->paths.back().polyline.points.back(); }
+    }
-    double length() const override;
+    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<ExtrusionPath3D> ExtrusionPaths3D;
+
+// Single continuous extrusion path, possibly with varying extrusion thickness, extrusion height or bridging / non bridging.
+template <typename THING = ExtrusionEntity>
+class ExtrusionMultiEntity : public ExtrusionEntity {
+public:
+    std::vector<THING> paths;
+
+    ExtrusionMultiEntity() {};
+    ExtrusionMultiEntity(const ExtrusionMultiEntity &rhs) : paths(rhs.paths) {}
+    ExtrusionMultiEntity(ExtrusionMultiEntity &&rhs) : paths(std::move(rhs.paths)) {}
+    ExtrusionMultiEntity(const std::vector<THING> &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;
+    void polygons_covered_by_spacing(Polygons &out, const float scaled_epsilon) const override {
-    Polygons polygons_covered_by_width(const float scaled_epsilon = 0.f) const
+        for (const THING &entity : this->paths)
-        { Polygons out; this->polygons_covered_by_width(out, scaled_epsilon); return out; }
+            entity.polygons_covered_by_spacing(out, scaled_epsilon);
-    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.
-    double min_mm3_per_mm() const;
+    double min_mm3_per_mm() const override {
-    Polyline as_polyline() const;
+        double min_mm3_per_mm = std::numeric_limits<double>::max();
-    void   collect_polylines(Polylines &dst) const override { Polyline pl = this->as_polyline(); if (! pl.empty()) dst.emplace_back(std::move(pl)); }
+        for (const THING &entity : this->paths)
-    double total_volume() const override { double volume =0.; for (const auto& path : paths) volume += path.total_volume(); return volume; }
+            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<ExtrusionPath> {
+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<ExtrusionPath3D> {
+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

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());
 }

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); };
 };
 
 }

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))
+    gcode << "G1 X" << XYZF_NUM(point.x())
-          <<   " Y" << XYZF_NUM(point(1))
+          <<   " Y" << XYZF_NUM(point.y())
-          <<   " Z" << XYZF_NUM(point(2))
+          <<   " Z" << XYZF_NUM(point.z() + m_pos.z())
           <<    " " << m_extrusion_axis << E_NUM(m_extruder->E());
     COMMENT(comment);
     gcode << "\n";

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 &copy, GLVolume &volume)
+void _3DScene::extrusionentity_to_verts(const ExtrusionMultiPath &extrusion_multi_path, float print_z, const Point &copy, GLVolume &volume) {
-{
     Lines               lines;
     std::vector<double> widths;
     std::vector<double> 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 &copy, GLVolume &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 &copy, GLVolume &volume) {
-    for (const ExtrusionEntity *extrusion_entity : extrusion_entity_collection.entities)
+    Lines               lines;
-        extrusionentity_to_verts(extrusion_entity, print_z, copy, volume);
+    std::vector<double> widths;
+    std::vector<double> 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 &copy, 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 &copy, GLVolume &volume)
 {
-    if (extrusion_entity != nullptr) {
+    ExtrusionToVert visitor(print_z, copy, volume);
-        auto *extrusion_path = dynamic_cast<const ExtrusionPath*>(extrusion_entity);
+    extrusion_entity.visit(visitor);
-        if (extrusion_path != nullptr)
-            extrusionentity_to_verts(*extrusion_path, print_z, copy, volume);
-        else {
-            auto *extrusion_loop = dynamic_cast<const ExtrusionLoop*>(extrusion_entity);
-            if (extrusion_loop != nullptr)
-                extrusionentity_to_verts(*extrusion_loop, print_z, copy, volume);
-            else {
-                auto *extrusion_multi_path = dynamic_cast<const ExtrusionMultiPath*>(extrusion_entity);
-                if (extrusion_multi_path != nullptr)
-                    extrusionentity_to_verts(*extrusion_multi_path, print_z, copy, volume);
-                else {
-                    auto *extrusion_entity_collection = dynamic_cast<const ExtrusionEntityCollection*>(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()");
-                    }
-                }
-            }
-        }
-    }
 }
 
 void _3DScene::polyline3_to_verts(const Polyline3& polyline, double width, double height, GLVolume& volume)

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 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 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 &copy, 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

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<const ExtrusionEntityCollection*>(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<const SupportLayer*>(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 :