mirror of
https://git.mirrors.martin98.com/https://github.com/slic3r/Slic3r.git
synced 2025-07-16 02:21:51 +08:00
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).
This commit is contained in:
supermerill
parent
9219781ce0
commit
edad0da724
@ -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) {};
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
@ -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); }
|
||||
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<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 ExtrusionMultiPath : public ExtrusionEntity
|
||||
{
|
||||
class ExtrusionPath3D : public ExtrusionPath {
|
||||
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); }
|
||||
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 "<<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) {};
|
||||
|
||||
ExtrusionMultiPath& operator=(const ExtrusionMultiPath &rhs) { this->paths = rhs.paths; return *this; }
|
||||
ExtrusionMultiPath& operator=(ExtrusionMultiPath &&rhs) { this->paths = std::move(rhs.paths); return *this; }
|
||||
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); };
|
||||
|
||||
bool is_loop() const { return false; }
|
||||
bool can_reverse() const { return true; }
|
||||
ExtrusionMultiPath* clone() const { return new ExtrusionMultiPath(*this); }
|
||||
void reverse();
|
||||
Point first_point() const override { return this->paths.front().polyline.points.front(); }
|
||||
Point last_point() const override { return this->paths.back().polyline.points.back(); }
|
||||
double length() const override;
|
||||
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;
|
||||
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;
|
||||
double min_mm3_per_mm() const override {
|
||||
double min_mm3_per_mm = std::numeric_limits<double>::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<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
|
||||
@ -256,6 +384,8 @@ public:
|
||||
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; }
|
||||
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
|
||||
|
||||
@ -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());
|
||||
}
|
||||
|
||||
@ -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); };
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
@ -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";
|
||||
|
||||
@ -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<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 ©, 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<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 ©, 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<const ExtrusionPath*>(extrusion_entity);
|
||||
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()");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
ExtrusionToVert visitor(print_z, copy, volume);
|
||||
extrusion_entity.visit(visitor);
|
||||
}
|
||||
|
||||
void _3DScene::polyline3_to_verts(const Polyline3& polyline, double width, double height, GLVolume& volume)
|
||||
|
||||
@ -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
|
||||
|
||||
@ -7317,6 +7317,7 @@ 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())
|
||||
if (fill != nullptr)
|
||||
_3DScene::extrusionentity_to_verts(*fill, float(layer->print_z), copy,
|
||||
*vols[ctxt.volume_idx(
|
||||
is_solid_infill(fill->entities.front()->role()) ?
|
||||
@ -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 :
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user