From 22637721a50ce310af778328ccf0e205ffa1eb38 Mon Sep 17 00:00:00 2001 From: thysson2701 Date: Tue, 21 Jul 2026 15:11:54 +0200 Subject: [PATCH] fix(build): replace ImageMap ExtrusionEntity.hpp with ZAA-compatible version The merge took the ImageMap version of ExtrusionEntity.hpp (2D Polyline) but the ZAA version of ExtrusionEntity.cpp (expects Polyline3, z_contoured, first_point3, etc.). Replace the header with the post-ZAA version from commit 95736445a4 so .hpp and .cpp are consistent. Update ExtrusionEntityCollection to return Point by value matching the new virtual signature. Also sync ExtrusionSimulator.cpp from ZAA commit. --- src/libslic3r/ExtrusionEntity.hpp | 138 +++++++++++++------- src/libslic3r/ExtrusionEntityCollection.hpp | 4 +- 2 files changed, 94 insertions(+), 48 deletions(-) diff --git a/src/libslic3r/ExtrusionEntity.hpp b/src/libslic3r/ExtrusionEntity.hpp index 3701f629815..ce74d93e9eb 100644 --- a/src/libslic3r/ExtrusionEntity.hpp +++ b/src/libslic3r/ExtrusionEntity.hpp @@ -116,8 +116,8 @@ public: virtual ExtrusionEntity* clone_move() = 0; virtual ~ExtrusionEntity() {} virtual void reverse() = 0; - virtual const Point& first_point() const = 0; - virtual const Point& last_point() const = 0; + virtual Point first_point() const = 0; + virtual Point last_point() const = 0; // 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. virtual void polygons_covered_by_width(Polygons &out, const float scaled_epsilon) const = 0; @@ -150,13 +150,17 @@ typedef std::vector ExtrusionEntitiesPtr; class ExtrusionPath : public ExtrusionEntity { public: - Polyline polyline; + Polyline3 polyline; + double overhang_degree = 0; + int curve_degree = 0; // Volumetric velocity. mm^3 of plastic per mm of linear head motion. Used by the G-code generator. double mm3_per_mm; // Width of the extrusion, used for visualization purposes. float width; // Height of the extrusion, used for visualization purposes. float height; + double smooth_speed = 0; + bool z_contoured = false; ExtrusionPath() : mm3_per_mm(-1), width(-1), height(-1), m_role(erNone), m_no_extrusion(false) {} ExtrusionPath(ExtrusionRole role) : mm3_per_mm(-1), width(-1), height(-1), m_role(role), m_no_extrusion(false) {} @@ -164,49 +168,68 @@ public: ExtrusionPath(const ExtrusionPath &rhs) : polyline(rhs.polyline) + , overhang_degree(rhs.overhang_degree) + , curve_degree(rhs.curve_degree) , mm3_per_mm(rhs.mm3_per_mm) , width(rhs.width) , height(rhs.height) + , smooth_speed(rhs.smooth_speed) + , z_contoured(rhs.z_contoured) , m_can_reverse(rhs.m_can_reverse) , m_role(rhs.m_role) , m_no_extrusion(rhs.m_no_extrusion) - { this->inset_idx = rhs.inset_idx; } + {} ExtrusionPath(ExtrusionPath &&rhs) : polyline(std::move(rhs.polyline)) + , overhang_degree(rhs.overhang_degree) + , curve_degree(rhs.curve_degree) , mm3_per_mm(rhs.mm3_per_mm) , width(rhs.width) , height(rhs.height) + , smooth_speed(rhs.smooth_speed) + , z_contoured(rhs.z_contoured) , m_can_reverse(rhs.m_can_reverse) , m_role(rhs.m_role) , m_no_extrusion(rhs.m_no_extrusion) - { this->inset_idx = rhs.inset_idx; } - ExtrusionPath(const Polyline &polyline, const ExtrusionPath &rhs) + {} + ExtrusionPath(const Polyline3 &polyline, const ExtrusionPath &rhs) : polyline(polyline) + , overhang_degree(rhs.overhang_degree) + , curve_degree(rhs.curve_degree) , mm3_per_mm(rhs.mm3_per_mm) , width(rhs.width) , height(rhs.height) + , smooth_speed(rhs.smooth_speed) + , z_contoured(rhs.z_contoured) , m_can_reverse(rhs.m_can_reverse) , m_role(rhs.m_role) , m_no_extrusion(rhs.m_no_extrusion) - { this->inset_idx = rhs.inset_idx; } - ExtrusionPath(Polyline &&polyline, const ExtrusionPath &rhs) + {} + ExtrusionPath(Polyline3 &&polyline, const ExtrusionPath &rhs) : polyline(std::move(polyline)) + , overhang_degree(rhs.overhang_degree) + , curve_degree(rhs.curve_degree) , mm3_per_mm(rhs.mm3_per_mm) , width(rhs.width) , height(rhs.height) + , smooth_speed(rhs.smooth_speed) + , z_contoured(rhs.z_contoured) , m_can_reverse(rhs.m_can_reverse) , m_role(rhs.m_role) , m_no_extrusion(rhs.m_no_extrusion) - { this->inset_idx = rhs.inset_idx; } + {} ExtrusionPath& operator=(const ExtrusionPath& rhs) { m_can_reverse = rhs.m_can_reverse; m_role = rhs.m_role; m_no_extrusion = rhs.m_no_extrusion; - inset_idx = rhs.inset_idx; this->mm3_per_mm = rhs.mm3_per_mm; this->width = rhs.width; this->height = rhs.height; + this->smooth_speed = rhs.smooth_speed; + this->z_contoured = rhs.z_contoured; + this->overhang_degree = rhs.overhang_degree; + this->curve_degree = rhs.curve_degree; this->polyline = rhs.polyline; return *this; } @@ -214,10 +237,13 @@ public: m_can_reverse = rhs.m_can_reverse; m_role = rhs.m_role; m_no_extrusion = rhs.m_no_extrusion; - inset_idx = rhs.inset_idx; this->mm3_per_mm = rhs.mm3_per_mm; this->width = rhs.width; this->height = rhs.height; + this->smooth_speed = rhs.smooth_speed; + this->z_contoured = rhs.z_contoured; + this->overhang_degree = rhs.overhang_degree; + this->curve_degree = rhs.curve_degree; this->polyline = std::move(rhs.polyline); return *this; } @@ -226,8 +252,10 @@ public: // Create a new object, initialize it with this object using the move semantics. ExtrusionEntity* clone_move() override { return new ExtrusionPath(std::move(*this)); } void reverse() override { this->polyline.reverse(); } - const Point& first_point() const override { return this->polyline.points.front(); } - const Point& last_point() const override { return this->polyline.points.back(); } + Point first_point() const override { return this->polyline.points.front().to_point(); } + Point3 first_point3() const { return this->polyline.points.front(); } + Point last_point() const override { return this->polyline.points.back().to_point(); } + Point3 last_point3() const { return this->polyline.points.back(); } size_t size() const { return this->polyline.size(); } bool empty() const { return this->polyline.empty(); } bool is_closed() const { return ! this->empty() && this->polyline.points.front() == this->polyline.points.back(); } @@ -238,7 +266,7 @@ public: // Currently not used. void subtract_expolygons(const ExPolygons &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; } // Produce a list of 2D polygons covered by the extruded paths, offsetted by the extrusion width. @@ -254,9 +282,10 @@ public: { 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 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); } - void collect_points(Points &dst) const override { append(dst, this->polyline.points); } + Polyline as_polyline() const override { return this->polyline.to_polyline(); } + void collect_polylines(Polylines &dst) const override { if (! this->polyline.empty()) dst.emplace_back(this->polyline.to_polyline()); } + void collect_points(Points &dst) const override; + void collect_points3(Points3 &dst) const { append(dst, this->polyline.points); } double total_volume() const override { return mm3_per_mm * unscale(length()); } //BBS: add new simplifing method by fitting arc @@ -276,6 +305,23 @@ private: bool m_no_extrusion = false; }; +class ExtrusionPathContoured : public ExtrusionPath { +public: + std::vector z_diffs; + + ExtrusionPathContoured(Polyline3 &&polyline, const ExtrusionPath &rhs, std::vector &&z_diffs) + : ExtrusionPath(std::move(polyline), rhs), z_diffs(std::move(z_diffs)) + {} + + virtual ExtrusionEntity *clone() const override; + virtual ExtrusionEntity *clone_move() override; + + void simplify(double tolerance) override; + virtual void simplify_by_fitting_arc(double tolerance); + + void reverse() override; +}; + class ExtrusionPathSloped : public ExtrusionPath { public: @@ -294,10 +340,10 @@ public: ExtrusionPathSloped(ExtrusionPath&& rhs, const Slope& begin, const Slope& end) : ExtrusionPath(std::move(rhs)), slope_begin(begin), slope_end(end) {} - ExtrusionPathSloped(const Polyline& polyline, const ExtrusionPath& rhs, const Slope& begin, const Slope& end) + ExtrusionPathSloped(const Polyline3& polyline, const ExtrusionPath& rhs, const Slope& begin, const Slope& end) : ExtrusionPath(polyline, rhs), slope_begin(begin), slope_end(end) {} - ExtrusionPathSloped(Polyline&& polyline, const ExtrusionPath& rhs, const Slope& begin, const Slope& end) + ExtrusionPathSloped(Polyline3&& polyline, const ExtrusionPath& rhs, const Slope& begin, const Slope& end) : ExtrusionPath(std::move(polyline), rhs), slope_begin(begin), slope_end(end) {} @@ -331,23 +377,21 @@ public: ExtrusionPaths paths; ExtrusionMultiPath() {} - ExtrusionMultiPath(const ExtrusionMultiPath &rhs) : paths(rhs.paths), m_can_reverse(rhs.m_can_reverse) { this->inset_idx = rhs.inset_idx; } - ExtrusionMultiPath(ExtrusionMultiPath &&rhs) : paths(std::move(rhs.paths)), m_can_reverse(rhs.m_can_reverse) { this->inset_idx = rhs.inset_idx; } - ExtrusionMultiPath(const ExtrusionPaths &paths) : paths(paths) { if (!this->paths.empty()) this->inset_idx = this->paths.front().inset_idx; } - ExtrusionMultiPath(const ExtrusionPath &path) {this->paths.push_back(path); m_can_reverse = path.can_reverse(); this->inset_idx = path.inset_idx; } + ExtrusionMultiPath(const ExtrusionMultiPath &rhs) : paths(rhs.paths), m_can_reverse(rhs.m_can_reverse) {} + ExtrusionMultiPath(ExtrusionMultiPath &&rhs) : paths(std::move(rhs.paths)), m_can_reverse(rhs.m_can_reverse) {} + ExtrusionMultiPath(const ExtrusionPaths &paths) : paths(paths) {} + ExtrusionMultiPath(const ExtrusionPath &path) {this->paths.push_back(path); m_can_reverse = path.can_reverse(); } ExtrusionMultiPath &operator=(const ExtrusionMultiPath &rhs) { this->paths = rhs.paths; m_can_reverse = rhs.m_can_reverse; - inset_idx = rhs.inset_idx; return *this; } ExtrusionMultiPath &operator=(ExtrusionMultiPath &&rhs) { this->paths = std::move(rhs.paths); m_can_reverse = rhs.m_can_reverse; - inset_idx = rhs.inset_idx; return *this; } @@ -358,8 +402,8 @@ public: // Create a new object, initialize it with this object using the move semantics. ExtrusionEntity* clone_move() override { return new ExtrusionMultiPath(std::move(*this)); } void reverse() override; - const Point& first_point() const override { return this->paths.front().polyline.points.front(); } - const Point& last_point() const override { return this->paths.back().polyline.points.back(); } + Point first_point() const override { return this->paths.front().polyline.points.front().to_point(); } + Point last_point() const override { return this->paths.back().polyline.points.back().to_point(); } size_t size() const { return this->paths.size(); } bool empty() const { return this->paths.empty(); } double length() const override; @@ -383,7 +427,7 @@ public: size_t n = std::accumulate(paths.begin(), paths.end(), 0, [](const size_t n, const ExtrusionPath &p){ return n + p.polyline.size(); }); dst.reserve(dst.size() + n); for (const ExtrusionPath &p : this->paths) - append(dst, p.polyline.points); + append(dst, to_points(p.polyline.points)); } double total_volume() const override { double volume =0.; for (const auto& path : paths) volume += path.total_volume(); return volume; } @@ -398,12 +442,12 @@ public: ExtrusionPaths paths; ExtrusionLoop(ExtrusionLoopRole role = elrDefault) : m_loop_role(role) {} - ExtrusionLoop(const ExtrusionPaths &paths, ExtrusionLoopRole role = elrDefault) : paths(paths), m_loop_role(role) { if (!this->paths.empty()) this->inset_idx = this->paths.front().inset_idx; } - ExtrusionLoop(ExtrusionPaths &&paths, ExtrusionLoopRole role = elrDefault) : paths(std::move(paths)), m_loop_role(role) { if (!this->paths.empty()) this->inset_idx = this->paths.front().inset_idx; } + ExtrusionLoop(const ExtrusionPaths &paths, ExtrusionLoopRole role = elrDefault) : paths(paths), m_loop_role(role) {} + ExtrusionLoop(ExtrusionPaths &&paths, ExtrusionLoopRole role = elrDefault) : paths(std::move(paths)), m_loop_role(role) {} ExtrusionLoop(const ExtrusionPath &path, ExtrusionLoopRole role = elrDefault) : m_loop_role(role) - { this->paths.push_back(path); this->inset_idx = path.inset_idx; } + { this->paths.push_back(path); } ExtrusionLoop(const ExtrusionPath &&path, ExtrusionLoopRole role = elrDefault) : m_loop_role(role) - { this->paths.emplace_back(std::move(path)); this->inset_idx = this->paths.back().inset_idx; } + { this->paths.emplace_back(std::move(path)); } bool is_loop() const override{ return true; } bool can_reverse() const override { return false; } ExtrusionEntity* clone() const override{ return new ExtrusionLoop (*this); } @@ -414,8 +458,8 @@ public: bool is_clockwise() { return this->polygon().is_clockwise(); } bool is_counter_clockwise() { return this->polygon().is_counter_clockwise(); } void reverse() override; - const Point& first_point() const override { return this->paths.front().polyline.points.front(); } - const Point& last_point() const override { assert(this->first_point() == this->paths.back().polyline.points.back()); return this->first_point(); } + Point first_point() const override { return this->paths.front().polyline.points.front().to_point(); } + Point last_point() const override { assert(this->first_point() == this->paths.back().polyline.points.back().to_point()); return this->first_point(); } Polygon polygon() const; double length() const override; bool split_at_vertex(const Point &point, const double scaled_epsilon = scaled(0.001)); @@ -453,7 +497,7 @@ public: size_t n = std::accumulate(paths.begin(), paths.end(), 0, [](const size_t n, const ExtrusionPath &p){ return n + p.polyline.size(); }); dst.reserve(dst.size() + n); for (const ExtrusionPath &p : this->paths) - append(dst, p.polyline.points); + append(dst, to_points(p.polyline.points)); } double total_volume() const override { double volume =0.; for (const auto& path : paths) volume += path.total_volume(); return volume; } // check if the loop is smooth, angle_threshold is in radians, default is 10 degrees @@ -499,7 +543,7 @@ inline void extrusion_paths_append(ExtrusionPaths &dst, Polylines &polylines, Ex for (Polyline &polyline : polylines) if (polyline.is_valid()) { dst.emplace_back(role, mm3_per_mm, width, height); - dst.back().polyline = polyline; + dst.back().polyline = Polyline3(polyline); } } @@ -509,7 +553,7 @@ inline void extrusion_paths_append(ExtrusionPaths &dst, Polylines &&polylines, E for (Polyline &polyline : polylines) if (polyline.is_valid()) { dst.emplace_back(role, mm3_per_mm, width, height); - dst.back().polyline = std::move(polyline); + dst.back().polyline = Polyline3(std::move(polyline)); } polylines.clear(); } @@ -519,7 +563,7 @@ inline void extrusion_paths_append(ExtrusionPaths &dst, Polyline &&polyline, Ext dst.reserve(dst.size() + 1); if (polyline.is_valid()) { dst.emplace_back(role, mm3_per_mm, width, height); - dst.back().polyline = std::move(polyline); + dst.back().polyline = Polyline3(std::move(polyline)); } } @@ -530,7 +574,7 @@ inline void extrusion_entities_append_paths(ExtrusionEntitiesPtr &dst, Polylines if (polyline.is_valid()) { ExtrusionPath *extrusion_path = can_reverse ? new ExtrusionPath(role, mm3_per_mm, width, height) : new ExtrusionPathOriented(role, mm3_per_mm, width, height); dst.push_back(extrusion_path); - extrusion_path->polyline = polyline; + extrusion_path->polyline = Polyline3(polyline); } } @@ -541,7 +585,7 @@ inline void extrusion_entities_append_paths(ExtrusionEntitiesPtr &dst, Polylines if (polyline.is_valid()) { ExtrusionPath *extrusion_path = can_reverse ? new ExtrusionPath(role, mm3_per_mm, width, height) : new ExtrusionPathOriented(role, mm3_per_mm, width, height); dst.push_back(extrusion_path); - extrusion_path->polyline = std::move(polyline); + extrusion_path->polyline = Polyline3(std::move(polyline)); } polylines.clear(); } @@ -561,7 +605,7 @@ inline void extrusion_entities_append_paths_with_wipe(ExtrusionEntitiesPtr &dst, Point temp = polyline.first_point() - last_end_point; if (Vec2d(temp.x(), temp.y()).norm() <= 3 * scaled(width)) { multi_path->paths.emplace_back(role, mm3_per_mm, width, height, true); - multi_path->paths.back().polyline = std::move(Polyline(last_end_point, polyline.first_point())); + multi_path->paths.back().polyline = Polyline3(Polyline(last_end_point, polyline.first_point())); } else { dst.push_back(multi_path); multi_path = new ExtrusionMultiPath(); @@ -569,9 +613,9 @@ inline void extrusion_entities_append_paths_with_wipe(ExtrusionEntitiesPtr &dst, } multi_path->paths.emplace_back(role, mm3_per_mm, width, height); - multi_path->paths.back().polyline = std::move(polyline); + multi_path->paths.back().polyline = Polyline3(std::move(polyline)); last_end_point_valid = true; - last_end_point = multi_path->paths.back().polyline.last_point(); + last_end_point = multi_path->paths.back().polyline.last_point().to_point(); } } if (!multi_path->empty()) @@ -586,7 +630,9 @@ inline void extrusion_entities_append_loops(ExtrusionEntitiesPtr &dst, Polygons for (Polygon &poly : loops) { if (poly.is_valid()) { ExtrusionPath path(role, mm3_per_mm, width, height); - path.polyline.points = std::move(poly.points); + path.polyline.points.reserve(poly.points.size() + 1); + for (const Point &pt : poly.points) + path.polyline.points.emplace_back(Point3(pt, 0)); path.polyline.points.push_back(path.polyline.points.front()); dst.emplace_back(new ExtrusionLoop(std::move(path))); } @@ -601,11 +647,11 @@ inline void extrusion_entities_append_loops_and_paths(ExtrusionEntitiesPtr &dst, if (polyline.is_valid()) { if (polyline.is_closed()) { ExtrusionPath extrusion_path(role, mm3_per_mm, width, height); - extrusion_path.polyline = std::move(polyline); + extrusion_path.polyline = Polyline3(std::move(polyline)); dst.emplace_back(new ExtrusionLoop(std::move(extrusion_path))); } else { ExtrusionPath *extrusion_path = new ExtrusionPath(role, mm3_per_mm, width, height); - extrusion_path->polyline = std::move(polyline); + extrusion_path->polyline = Polyline3(std::move(polyline)); dst.emplace_back(extrusion_path); } } diff --git a/src/libslic3r/ExtrusionEntityCollection.hpp b/src/libslic3r/ExtrusionEntityCollection.hpp index 26a220a3e87..5cb3d7783ef 100644 --- a/src/libslic3r/ExtrusionEntityCollection.hpp +++ b/src/libslic3r/ExtrusionEntityCollection.hpp @@ -157,8 +157,8 @@ public: ExtrusionEntityCollection chained_path_from(const Point &start_near, ExtrusionRole role = erMixed) const { return this->no_sort ? *this : chained_path_from(this->entities, start_near, role); } void reverse() override; - const Point& first_point() const override { return this->entities.front()->first_point(); } - const Point& last_point() const override { return this->entities.back()->last_point(); } + Point first_point() const override { return this->entities.front()->first_point(); } + Point last_point() const override { return this->entities.back()->last_point(); } // 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.