3D-printing/OrcaSlicer
1
0
Fork 0
mirror of https://github.com/SoftFever/OrcaSlicer.git synced 2025-10-23 00:31:11 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions 5

Merge branch 'master' into sender

Browse source 
Conflicts:
	Build.PL
	lib/Slic3r.pm
	xs/MANIFEST
	xs/src/libslic3r/PrintConfig.hpp
This commit is contained in:
Alessandro Ranellucci 2015-11-01 19:12:13 +01:00
commit 9b21ac877a
93 changed files with 3339 additions and 2050 deletions
Download patch file Download diff file Expand all files Collapse all files

2
xs/src/admesh/stl_io.c
View file

@ -269,7 +269,7 @@ stl_write_binary(stl_file *stl, const char *file, const char *label) {
if (stl->error) return;
/* Open the file */
fp = fopen(file, "w");
fp = fopen(file, "wb");
if(fp == NULL) {
error_msg = (char*)
malloc(81 + strlen(file)); /* Allow 80 chars+file size for message */

42
xs/src/admesh/stlinit.c
View file

@ -152,18 +152,19 @@ stl_count_facets(stl_file *stl, char *file) {
}
/* Find the number of facets */
j = 0;
for(i = 0; i < file_size ; i++) {
j++;
if(getc(stl->fp) == '\n') {
if(j > 4) { /* don't count short lines */
num_lines++;
}
j = 0;
}
char linebuf[100];
while (fgets(linebuf, 100, stl->fp) != NULL) {
/* don't count short lines */
if (strlen(linebuf) <= 4) continue;
/* skip solid/endsolid lines as broken STL file generators may put several of them */
if (strncmp(linebuf, "solid", 5) == 0 || strncmp(linebuf, "endsolid", 8) == 0) continue;
++num_lines;
}
rewind(stl->fp);
/* Get the header */
for(i = 0;
(i < 80) && (stl->stats.header[i] = getc(stl->fp)) != '\n'; i++);
@ -269,8 +270,6 @@ stl_read(stl_file *stl, int first_facet, int first) {
fseek(stl->fp, HEADER_SIZE, SEEK_SET);
} else {
rewind(stl->fp);
/* Skip the first line of the file */
while(getc(stl->fp) != '\n');
}
for(i = first_facet; i < stl->stats.number_of_facets; i++) {
@ -288,13 +287,18 @@ stl_read(stl_file *stl, int first_facet, int first) {
} else
/* Read a single facet from an ASCII .STL file */
{
if((fscanf(stl->fp, "%*s %*s %f %f %f\n", &facet.normal.x, &facet.normal.y, &facet.normal.z) + \
fscanf(stl->fp, "%*s %*s") + \
fscanf(stl->fp, "%*s %f %f %f\n", &facet.vertex[0].x, &facet.vertex[0].y, &facet.vertex[0].z) + \
fscanf(stl->fp, "%*s %f %f %f\n", &facet.vertex[1].x, &facet.vertex[1].y, &facet.vertex[1].z) + \
fscanf(stl->fp, "%*s %f %f %f\n", &facet.vertex[2].x, &facet.vertex[2].y, &facet.vertex[2].z) + \
fscanf(stl->fp, "%*s") + \
fscanf(stl->fp, "%*s")) != 12) {
// skip solid/endsolid
// (in this order, otherwise it won't work when they are paired in the middle of a file)
fscanf(stl->fp, "endsolid\n");
fscanf(stl->fp, "solid%*[^\n]\n"); // name might contain spaces so %*s doesn't work and it also can be empty (just "solid")
if((fscanf(stl->fp, " facet normal %f %f %f\n", &facet.normal.x, &facet.normal.y, &facet.normal.z) + \
fscanf(stl->fp, " outer loop\n") + \
fscanf(stl->fp, " vertex %f %f %f\n", &facet.vertex[0].x, &facet.vertex[0].y, &facet.vertex[0].z) + \
fscanf(stl->fp, " vertex %f %f %f\n", &facet.vertex[1].x, &facet.vertex[1].y, &facet.vertex[1].z) + \
fscanf(stl->fp, " vertex %f %f %f\n", &facet.vertex[2].x, &facet.vertex[2].y, &facet.vertex[2].z) + \
fscanf(stl->fp, " endloop\n") + \
fscanf(stl->fp, " endfacet\n")) != 12) {
perror("Something is syntactically very wrong with this ASCII STL!");
stl->error = 1;
return;

36
xs/src/libslic3r/BridgeDetector.cpp
View file

@ -185,16 +185,12 @@ BridgeDetector::detect_angle()
return true;
}
void
BridgeDetector::coverage(Polygons* coverage) const
{
if (this->angle == -1) return;
return this->coverage(angle, coverage);
}
void
BridgeDetector::coverage(double angle, Polygons* coverage) const
{
if (angle == -1) angle = this->angle;
if (angle == -1) return;
// Clone our expolygon and rotate it so that we work with vertical lines.
ExPolygon expolygon = this->expolygon;
expolygon.rotate(PI/2.0 - angle, Point(0,0));
@ -263,19 +259,23 @@ BridgeDetector::coverage(double angle, Polygons* coverage) const
*/
}
Polygons
BridgeDetector::coverage(double angle) const
{
Polygons pp;
this->coverage(angle, &pp);
return pp;
}
/* This method returns the bridge edges (as polylines) that are not supported
but would allow the entire bridge area to be bridged with detected angle
if supported too */
void
BridgeDetector::unsupported_edges(Polylines* unsupported) const
{
if (this->angle == -1) return;
return this->unsupported_edges(this->angle, unsupported);
}
void
BridgeDetector::unsupported_edges(double angle, Polylines* unsupported) const
{
if (angle == -1) angle = this->angle;
if (angle == -1) return;
// get bridge edges (both contour and holes)
Polylines bridge_edges;
{
@ -319,6 +319,14 @@ BridgeDetector::unsupported_edges(double angle, Polylines* unsupported) const
*/
}
Polylines
BridgeDetector::unsupported_edges(double angle) const
{
Polylines pp;
this->unsupported_edges(angle, &pp);
return pp;
}
#ifdef SLIC3RXS
REGISTER_CLASS(BridgeDetector, "BridgeDetector");
#endif

4
xs/src/libslic3r/BridgeDetector.hpp
View file

@ -18,10 +18,10 @@ class BridgeDetector {
BridgeDetector(const ExPolygon &_expolygon, const ExPolygonCollection &_lower_slices, coord_t _extrusion_width);
bool detect_angle();
void coverage(Polygons* coverage) const;
void coverage(double angle, Polygons* coverage) const;
void unsupported_edges(Polylines* unsupported) const;
Polygons coverage(double angle = -1) const;
void unsupported_edges(double angle, Polylines* unsupported) const;
Polylines unsupported_edges(double angle = -1) const;
private:
Polylines _edges; // representing the supporting edges

95
xs/src/libslic3r/ClipperUtils.cpp
View file

@ -136,6 +136,15 @@ offset(const Slic3r::Polygons &polygons, Slic3r::Polygons* retval, const float d
ClipperPaths_to_Slic3rMultiPoints(output, retval);
}
Slic3r::Polygons
offset(const Slic3r::Polygons &polygons, const float delta,
double scale, ClipperLib::JoinType joinType, double miterLimit)
{
Slic3r::Polygons pp;
offset(polygons, &pp, delta, scale, joinType, miterLimit);
return pp;
}
void
offset(const Slic3r::Polylines &polylines, ClipperLib::Paths* retval, const float delta,
double scale, ClipperLib::JoinType joinType, double miterLimit)
@ -203,6 +212,15 @@ offset(const Slic3r::Polygons &polygons, Slic3r::ExPolygons* retval, const float
ClipperPaths_to_Slic3rExPolygons(output, retval);
}
Slic3r::ExPolygons
offset_ex(const Slic3r::Polygons &polygons, const float delta,
double scale, ClipperLib::JoinType joinType, double miterLimit)
{
Slic3r::ExPolygons expp;
offset(polygons, &expp, delta, scale, joinType, miterLimit);
return expp;
}
void
offset2(const Slic3r::Polygons &polygons, ClipperLib::Paths* retval, const float delta1,
const float delta2, const double scale, const ClipperLib::JoinType joinType, const double miterLimit)
@ -248,6 +266,15 @@ offset2(const Slic3r::Polygons &polygons, Slic3r::Polygons* retval, const float
ClipperPaths_to_Slic3rMultiPoints(output, retval);
}
Slic3r::Polygons
offset2(const Slic3r::Polygons &polygons, const float delta1,
const float delta2, const double scale, const ClipperLib::JoinType joinType, const double miterLimit)
{
Slic3r::Polygons pp;
offset2(polygons, &pp, delta1, delta2, scale, joinType, miterLimit);
return pp;
}
void
offset2(const Slic3r::Polygons &polygons, Slic3r::ExPolygons* retval, const float delta1,
const float delta2, const double scale, const ClipperLib::JoinType joinType, const double miterLimit)
@ -260,6 +287,15 @@ offset2(const Slic3r::Polygons &polygons, Slic3r::ExPolygons* retval, const floa
ClipperPaths_to_Slic3rExPolygons(output, retval);
}
Slic3r::ExPolygons
offset2_ex(const Slic3r::Polygons &polygons, const float delta1,
const float delta2, const double scale, const ClipperLib::JoinType joinType, const double miterLimit)
{
Slic3r::ExPolygons expp;
offset2(polygons, &expp, delta1, delta2, scale, joinType, miterLimit);
return expp;
}
template <class T>
void _clipper_do(const ClipperLib::ClipType clipType, const Slic3r::Polygons &subject,
const Slic3r::Polygons &clip, T* retval, const ClipperLib::PolyFillType fillType, const bool safety_offset_)
@ -437,6 +473,25 @@ void diff(const SubjectType &subject, const Slic3r::ExPolygons &clip, ResultType
}
template void diff<Slic3r::Polygons, Slic3r::ExPolygons>(const Slic3r::Polygons &subject, const Slic3r::ExPolygons &clip, Slic3r::ExPolygons* retval, bool safety_offset_);
Slic3r::Polygons
diff(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_)
{
Slic3r::Polygons pp;
diff(subject, clip, &pp, safety_offset_);
return pp;
}
template <class SubjectType, class ClipType>
Slic3r::ExPolygons
diff_ex(const SubjectType &subject, const ClipType &clip, bool safety_offset_)
{
Slic3r::ExPolygons expp;
diff(subject, clip, &expp, safety_offset_);
return expp;
}
template Slic3r::ExPolygons diff_ex<Slic3r::Polygons, Slic3r::Polygons>(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_);
template Slic3r::ExPolygons diff_ex<Slic3r::Polygons, Slic3r::ExPolygons>(const Slic3r::Polygons &subject, const Slic3r::ExPolygons &clip, bool safety_offset_);
template <class SubjectType, class ResultType>
void intersection(const SubjectType &subject, const Slic3r::Polygons &clip, ResultType* retval, bool safety_offset_)
{
@ -448,6 +503,30 @@ template void intersection<Slic3r::Polygons, Slic3r::Polylines>(const Slic3r::Po
template void intersection<Slic3r::Polylines, Slic3r::Polylines>(const Slic3r::Polylines &subject, const Slic3r::Polygons &clip, Slic3r::Polylines* retval, bool safety_offset_);
template void intersection<Slic3r::Lines, Slic3r::Lines>(const Slic3r::Lines &subject, const Slic3r::Polygons &clip, Slic3r::Lines* retval, bool safety_offset_);
Slic3r::Polygons
intersection(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_)
{
Slic3r::Polygons pp;
intersection(subject, clip, &pp, safety_offset_);
return pp;
}
Slic3r::Polylines
intersection(const Slic3r::Polylines &subject, const Slic3r::Polygons &clip, bool safety_offset_)
{
Slic3r::Polylines pp;
intersection(subject, clip, &pp, safety_offset_);
return pp;
}
Slic3r::ExPolygons
intersection_ex(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_)
{
Slic3r::ExPolygons expp;
intersection(subject, clip, &expp, safety_offset_);
return expp;
}
template <class SubjectType>
bool intersects(const SubjectType &subject, const Slic3r::Polygons &clip, bool safety_offset_)
{
@ -474,6 +553,22 @@ void union_(const Slic3r::Polygons &subject, T* retval, bool safety_offset_)
template void union_<Slic3r::ExPolygons>(const Slic3r::Polygons &subject, Slic3r::ExPolygons* retval, bool safety_offset_);
template void union_<Slic3r::Polygons>(const Slic3r::Polygons &subject, Slic3r::Polygons* retval, bool safety_offset_);
Slic3r::Polygons
union_(const Slic3r::Polygons &subject, bool safety_offset)
{
Polygons pp;
union_(subject, &pp, safety_offset);
return pp;
}
Slic3r::ExPolygons
union_ex(const Slic3r::Polygons &subject, bool safety_offset)
{
ExPolygons expp;
union_(subject, &expp, safety_offset);
return expp;
}
void union_(const Slic3r::Polygons &subject1, const Slic3r::Polygons &subject2, Slic3r::Polygons* retval, bool safety_offset)
{
Polygons pp = subject1;

24
xs/src/libslic3r/ClipperUtils.hpp
View file

@ -40,6 +40,9 @@ void offset(const Slic3r::Polygons &polygons, ClipperLib::Paths* retval, const f
void offset(const Slic3r::Polygons &polygons, Slic3r::Polygons* retval, const float delta,
double scale = 100000, ClipperLib::JoinType joinType = ClipperLib::jtMiter,
double miterLimit = 3);
Slic3r::Polygons offset(const Slic3r::Polygons &polygons, const float delta,
double scale = 100000, ClipperLib::JoinType joinType = ClipperLib::jtMiter,
double miterLimit = 3);
// offset Polylines
void offset(const Slic3r::Polylines &polylines, ClipperLib::Paths* retval, const float delta,
@ -55,6 +58,9 @@ void offset(const Slic3r::Surface &surface, Slic3r::Surfaces* retval, const floa
void offset(const Slic3r::Polygons &polygons, Slic3r::ExPolygons* retval, const float delta,
double scale = 100000, ClipperLib::JoinType joinType = ClipperLib::jtMiter,
double miterLimit = 3);
Slic3r::ExPolygons offset_ex(const Slic3r::Polygons &polygons, const float delta,
double scale = 100000, ClipperLib::JoinType joinType = ClipperLib::jtMiter,
double miterLimit = 3);
void offset2(const Slic3r::Polygons &polygons, ClipperLib::Paths* retval, const float delta1,
const float delta2, double scale = 100000, ClipperLib::JoinType joinType = ClipperLib::jtMiter,
@ -62,9 +68,15 @@ void offset2(const Slic3r::Polygons &polygons, ClipperLib::Paths* retval, const
void offset2(const Slic3r::Polygons &polygons, Slic3r::Polygons* retval, const float delta1,
const float delta2, double scale = 100000, ClipperLib::JoinType joinType = ClipperLib::jtMiter,
double miterLimit = 3);
Slic3r::Polygons offset2(const Slic3r::Polygons &polygons, const float delta1,
const float delta2, double scale = 100000, ClipperLib::JoinType joinType = ClipperLib::jtMiter,
double miterLimit = 3);
void offset2(const Slic3r::Polygons &polygons, Slic3r::ExPolygons* retval, const float delta1,
const float delta2, double scale = 100000, ClipperLib::JoinType joinType = ClipperLib::jtMiter,
double miterLimit = 3);
Slic3r::ExPolygons offset2_ex(const Slic3r::Polygons &polygons, const float delta1,
const float delta2, double scale = 100000, ClipperLib::JoinType joinType = ClipperLib::jtMiter,
double miterLimit = 3);
template <class T>
void _clipper_do(ClipperLib::ClipType clipType, const Slic3r::Polygons &subject,
@ -86,9 +98,18 @@ void diff(const SubjectType &subject, const Slic3r::Polygons &clip, ResultType*
template <class SubjectType, class ResultType>
void diff(const SubjectType &subject, const Slic3r::ExPolygons &clip, ResultType* retval, bool safety_offset_ = false);
Slic3r::Polygons diff(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false);
template <class SubjectType, class ClipType>
Slic3r::ExPolygons diff_ex(const SubjectType &subject, const ClipType &clip, bool safety_offset_ = false);
template <class SubjectType, class ResultType>
void intersection(const SubjectType &subject, const Slic3r::Polygons &clip, ResultType* retval, bool safety_offset_ = false);
Slic3r::Polygons intersection(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false);
Slic3r::Polylines intersection(const Slic3r::Polylines &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false);
Slic3r::ExPolygons intersection_ex(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false);
template <class SubjectType>
bool intersects(const SubjectType &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false);
@ -98,6 +119,9 @@ void xor_(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, Slic3r:
template <class T>
void union_(const Slic3r::Polygons &subject, T* retval, bool safety_offset_ = false);
Slic3r::Polygons union_(const Slic3r::Polygons &subject, bool safety_offset = false);
Slic3r::ExPolygons union_ex(const Slic3r::Polygons &subject, bool safety_offset = false);
void union_(const Slic3r::Polygons &subject1, const Slic3r::Polygons &subject2, Slic3r::Polygons* retval, bool safety_offset = false);
void union_pt(const Slic3r::Polygons &subject, ClipperLib::PolyTree* retval, bool safety_offset_ = false);

50
xs/src/libslic3r/Config.cpp
View file

@ -1,4 +1,9 @@
#include "Config.hpp"
#include <stdlib.h> // for setenv()
#ifdef _WIN32
#define setenv(k, v, o) _putenv_s(k, v)
#endif
namespace Slic3r {
@ -10,8 +15,7 @@ ConfigBase::has(const t_config_option_key opt_key) {
void
ConfigBase::apply(const ConfigBase &other, bool ignore_nonexistent) {
// get list of option keys to apply
t_config_option_keys opt_keys;
other.keys(&opt_keys);
t_config_option_keys opt_keys = other.keys();
// loop through options and apply them
for (t_config_option_keys::const_iterator it = opt_keys.begin(); it != opt_keys.end(); ++it) {
@ -37,8 +41,7 @@ t_config_option_keys
ConfigBase::diff(ConfigBase &other) {
t_config_option_keys diff;
t_config_option_keys my_keys;
this->keys(&my_keys);
t_config_option_keys my_keys = this->keys();
for (t_config_option_keys::const_iterator opt_key = my_keys.begin(); opt_key != my_keys.end(); ++opt_key) {
if (other.has(*opt_key) && other.serialize(*opt_key) != this->serialize(*opt_key)) {
diff.push_back(*opt_key);
@ -98,14 +101,31 @@ ConfigBase::get_abs_value(const t_config_option_key opt_key, double ratio_over)
return opt->get_abs_value(ratio_over);
}
void
ConfigBase::setenv_()
{
t_config_option_keys opt_keys = this->keys();
for (t_config_option_keys::const_iterator it = opt_keys.begin(); it != opt_keys.end(); ++it) {
// prepend the SLIC3R_ prefix
std::ostringstream ss;
ss << "SLIC3R_";
ss << *it;
std::string envname = ss.str();
// capitalize environment variable name
for (size_t i = 0; i < envname.size(); ++i)
envname[i] = (envname[i] <= 'z' && envname[i] >= 'a') ? envname[i]-('a'-'A') : envname[i];
setenv(envname.c_str(), this->serialize(*it).c_str(), 1);
}
}
#ifdef SLIC3RXS
SV*
ConfigBase::as_hash() {
HV* hv = newHV();
t_config_option_keys opt_keys;
this->keys(&opt_keys);
t_config_option_keys opt_keys = this->keys();
for (t_config_option_keys::const_iterator it = opt_keys.begin(); it != opt_keys.end(); ++it)
(void)hv_store( hv, it->c_str(), it->length(), this->get(*it), 0 );
@ -368,10 +388,12 @@ DynamicConfig::option(const t_config_option_key opt_key) const {
return const_cast<DynamicConfig*>(this)->option(opt_key, false);
}
void
DynamicConfig::keys(t_config_option_keys *keys) const {
t_config_option_keys
DynamicConfig::keys() const {
t_config_option_keys keys;
for (t_options_map::const_iterator it = this->options.begin(); it != this->options.end(); ++it)
keys->push_back(it->first);
keys.push_back(it->first);
return keys;
}
void
@ -379,12 +401,14 @@ DynamicConfig::erase(const t_config_option_key opt_key) {
this->options.erase(opt_key);
}
void
StaticConfig::keys(t_config_option_keys *keys) const {
t_config_option_keys
StaticConfig::keys() const {
t_config_option_keys keys;
for (t_optiondef_map::const_iterator it = this->def->begin(); it != this->def->end(); ++it) {
const ConfigOption* opt = this->option(it->first);
if (opt != NULL) keys->push_back(it->first);
if (opt != NULL) keys.push_back(it->first);
}
return keys;
}
const ConfigOption*

7
xs/src/libslic3r/Config.hpp
View file

@ -515,7 +515,7 @@ class ConfigBase
bool has(const t_config_option_key opt_key);
virtual ConfigOption* option(const t_config_option_key opt_key, bool create = false) = 0;
virtual const ConfigOption* option(const t_config_option_key opt_key) const = 0;
virtual void keys(t_config_option_keys *keys) const = 0;
virtual t_config_option_keys keys() const = 0;
void apply(const ConfigBase &other, bool ignore_nonexistent = false);
bool equals(ConfigBase &other);
t_config_option_keys diff(ConfigBase &other);
@ -524,6 +524,7 @@ class ConfigBase
void set_ifndef(t_config_option_key opt_key, SV* value, bool deserialize = false);
double get_abs_value(const t_config_option_key opt_key);
double get_abs_value(const t_config_option_key opt_key, double ratio_over);
void setenv_();
#ifdef SLIC3RXS
SV* as_hash();
@ -545,7 +546,7 @@ class DynamicConfig : public ConfigBase
template<class T> T* opt(const t_config_option_key opt_key, bool create = false);
ConfigOption* option(const t_config_option_key opt_key, bool create = false);
const ConfigOption* option(const t_config_option_key opt_key) const;
void keys(t_config_option_keys *keys) const;
t_config_option_keys keys() const;
void erase(const t_config_option_key opt_key);
private:
@ -556,7 +557,7 @@ class DynamicConfig : public ConfigBase
class StaticConfig : public ConfigBase
{
public:
void keys(t_config_option_keys *keys) const;
t_config_option_keys keys() const;
virtual ConfigOption* option(const t_config_option_key opt_key, bool create = false) = 0;
const ConfigOption* option(const t_config_option_key opt_key) const;

24
xs/src/libslic3r/ExPolygon.cpp
View file

@ -122,6 +122,13 @@ ExPolygon::has_boundary_point(const Point &point) const
return false;
}
void
ExPolygon::simplify_p(double tolerance, Polygons* polygons) const
{
Polygons pp = this->simplify_p(tolerance);
polygons->insert(polygons->end(), pp.begin(), pp.end());
}
Polygons
ExPolygon::simplify_p(double tolerance) const
{
@ -180,16 +187,17 @@ ExPolygon::medial_axis(double max_width, double min_width, Polylines* polylines)
}
// compute the Voronoi diagram
ma.build(polylines);
Polylines pp;
ma.build(&pp);
// clip segments to our expolygon area
// (do this before extending endpoints as external segments coule be extended into
// expolygon, this leaving wrong things inside)
intersection(*polylines, *this, polylines);
pp = intersection(pp, *this);
// extend initial and final segments of each polyline (they will be clipped)
// unless they represent closed loops
for (Polylines::iterator polyline = polylines->begin(); polyline != polylines->end(); ++polyline) {
for (Polylines::iterator polyline = pp.begin(); polyline != pp.end(); ++polyline) {
if (polyline->points.front().distance_to(polyline->points.back()) < min_width) continue;
// TODO: we should *not* extend endpoints where other polylines start/end
// (such as T joints, which are returned as three polylines by MedialAxis)
@ -198,18 +206,20 @@ ExPolygon::medial_axis(double max_width, double min_width, Polylines* polylines)
}
// clip again after extending endpoints to prevent them from exceeding the expolygon boundaries
intersection(*polylines, *this, polylines);
pp = intersection(pp, *this);
// remove too short polylines
// (we can't do this check before endpoints extension and clipping because we don't
// know how long will the endpoints be extended since it depends on polygon thickness
// which is variable - extension will be <= max_width/2 on each side)
for (size_t i = 0; i < polylines->size(); ++i) {
if ((*polylines)[i].length() < max_width) {
polylines->erase(polylines->begin() + i);
for (size_t i = 0; i < pp.size(); ++i) {
if (pp[i].length() < max_width) {
pp.erase(pp.begin() + i);
--i;
}
}
polylines->insert(polylines->end(), pp.begin(), pp.end());
}
void

1
xs/src/libslic3r/ExPolygon.hpp
View file

@ -27,6 +27,7 @@ class ExPolygon
bool contains(const Point &point) const;
bool contains_b(const Point &point) const;
bool has_boundary_point(const Point &point) const;
void simplify_p(double tolerance, Polygons* polygons) const;
Polygons simplify_p(double tolerance) const;
ExPolygons simplify(double tolerance) const;
void simplify(double tolerance, ExPolygons &expolygons) const;

6
xs/src/libslic3r/ExPolygonCollection.cpp
View file

@ -122,6 +122,12 @@ ExPolygonCollection::contours() const
return contours;
}
void
ExPolygonCollection::append(const ExPolygons &expp)
{
this->expolygons.insert(this->expolygons.end(), expp.begin(), expp.end());
}
#ifdef SLIC3RXS
REGISTER_CLASS(ExPolygonCollection, "ExPolygon::Collection");
#endif

1
xs/src/libslic3r/ExPolygonCollection.hpp
View file

@ -31,6 +31,7 @@ class ExPolygonCollection
Polygon convex_hull() const;
Lines lines() const;
Polygons contours() const;
void append(const ExPolygons &expolygons);
};
}

66
xs/src/libslic3r/ExtrusionEntity.cpp
View file

@ -3,6 +3,7 @@
#include "ExPolygonCollection.hpp"
#include "ClipperUtils.hpp"
#include "Extruder.hpp"
#include <cmath>
#include <sstream>
namespace Slic3r {
@ -113,57 +114,6 @@ ExtrusionPath::_inflate_collection(const Polylines &polylines, ExtrusionEntityCo
REGISTER_CLASS(ExtrusionPath, "ExtrusionPath");
#endif
std::string
ExtrusionPath::gcode(Extruder* extruder, double e, double F,
double xofs, double yofs, std::string extrusion_axis,
std::string gcode_line_suffix) const
{
dSP;
std::stringstream stream;
stream.setf(std::ios::fixed);
double local_F = F;
Lines lines = this->polyline.lines();
for (Lines::const_iterator line_it = lines.begin();
line_it != lines.end(); ++line_it)
{
const double line_length = line_it->length() * SCALING_FACTOR;
// calculate extrusion length for this line
double E = 0;
if (e > 0) {
extruder->extrude(e * line_length);
E = extruder->E;
}
// compose G-code line
Point point = line_it->b;
const double x = point.x * SCALING_FACTOR + xofs;
const double y = point.y * SCALING_FACTOR + yofs;
stream.precision(3);
stream << "G1 X" << x << " Y" << y;
if (E != 0) {
stream.precision(5);
stream << " " << extrusion_axis << E;
}
if (local_F != 0) {
stream.precision(3);
stream << " F" << local_F;
local_F = 0;
}
stream << gcode_line_suffix;
stream << "\n";
}
return stream.str();
}
Polygons
ExtrusionPath::grow() const
{
@ -375,6 +325,20 @@ ExtrusionLoop::grow() const
return pp;
}
double
ExtrusionLoop::min_mm3_per_mm() const
{
double min_mm3_per_mm = 0;
for (ExtrusionPaths::const_iterator path = this->paths.begin(); path != this->paths.end(); ++path) {
if (min_mm3_per_mm == 0) {
min_mm3_per_mm = path->mm3_per_mm;
} else {
min_mm3_per_mm = fmin(min_mm3_per_mm, path->mm3_per_mm);
}
}
return min_mm3_per_mm;
}
#ifdef SLIC3RXS
REGISTER_CLASS(ExtrusionLoop, "ExtrusionLoop");
#endif

18
xs/src/libslic3r/ExtrusionEntity.hpp
View file

@ -13,6 +13,7 @@ class Extruder;
/* Each ExtrusionRole value identifies a distinct set of { extruder, speed } */
enum ExtrusionRole {
erNone,
erPerimeter,
erExternalPerimeter,
erOverhangPerimeter,
@ -50,6 +51,8 @@ class ExtrusionEntity
virtual Point first_point() const = 0;
virtual Point last_point() const = 0;
virtual Polygons grow() const = 0;
virtual double min_mm3_per_mm() const = 0;
virtual Polyline as_polyline() const = 0;
};
typedef std::vector<ExtrusionEntity*> ExtrusionEntitiesPtr;
@ -77,10 +80,13 @@ class ExtrusionPath : public ExtrusionEntity
bool is_infill() const;
bool is_solid_infill() const;
bool is_bridge() const;
std::string gcode(Extruder* extruder, double e, double F,
double xofs, double yofs, std::string extrusion_axis,
std::string gcode_line_suffix) const;
Polygons grow() const;
double min_mm3_per_mm() const {
return this->mm3_per_mm;
};
Polyline as_polyline() const {
return this->polyline;
};
private:
void _inflate_collection(const Polylines &polylines, ExtrusionEntityCollection* collection) const;
@ -95,6 +101,8 @@ class ExtrusionLoop : public ExtrusionEntity
ExtrusionLoopRole role;
ExtrusionLoop(ExtrusionLoopRole role = elrDefault) : role(role) {};
ExtrusionLoop(const ExtrusionPaths &paths, ExtrusionLoopRole role = elrDefault)
: paths(paths), role(role) {};
bool is_loop() const {
return true;
};
@ -117,6 +125,10 @@ class ExtrusionLoop : public ExtrusionEntity
bool is_infill() const;
bool is_solid_infill() const;
Polygons grow() const;
double min_mm3_per_mm() const;
Polyline as_polyline() const {
return this->polygon().split_at_first_point();
};
};
}

98
xs/src/libslic3r/ExtrusionEntityCollection.cpp
View file

@ -1,5 +1,6 @@
#include "ExtrusionEntityCollection.hpp"
#include <algorithm>
#include <cmath>
#include <map>
namespace Slic3r {
@ -7,9 +8,13 @@ namespace Slic3r {
ExtrusionEntityCollection::ExtrusionEntityCollection(const ExtrusionEntityCollection& collection)
: no_sort(collection.no_sort), orig_indices(collection.orig_indices)
{
this->entities.reserve(collection.entities.size());
for (ExtrusionEntitiesPtr::const_iterator it = collection.entities.begin(); it != collection.entities.end(); ++it)
this->entities.push_back((*it)->clone());
this->append(collection.entities);
}
ExtrusionEntityCollection::ExtrusionEntityCollection(const ExtrusionPaths &paths)
: no_sort(false)
{
this->append(paths);
}
ExtrusionEntityCollection& ExtrusionEntityCollection::operator= (const ExtrusionEntityCollection &other)
@ -27,10 +32,30 @@ ExtrusionEntityCollection::swap (ExtrusionEntityCollection &c)
std::swap(this->no_sort, c.no_sort);
}
ExtrusionEntityCollection::~ExtrusionEntityCollection()
{
for (ExtrusionEntitiesPtr::iterator it = this->entities.begin(); it != this->entities.end(); ++it)
delete *it;
}
ExtrusionEntityCollection::operator ExtrusionPaths() const
{
ExtrusionPaths paths;
for (ExtrusionEntitiesPtr::const_iterator it = this->entities.begin(); it != this->entities.end(); ++it) {
if (const ExtrusionPath* path = dynamic_cast<const ExtrusionPath*>(*it))
paths.push_back(*path);
}
return paths;
}
ExtrusionEntityCollection*
ExtrusionEntityCollection::clone() const
{
return new ExtrusionEntityCollection(*this);
ExtrusionEntityCollection* coll = new ExtrusionEntityCollection(*this);
for (size_t i = 0; i < coll->entities.size(); ++i) {
coll->entities[i] = this->entities[i]->clone();
}
return coll;
}
void
@ -56,6 +81,34 @@ ExtrusionEntityCollection::last_point() const
return this->entities.back()->last_point();
}
void
ExtrusionEntityCollection::append(const ExtrusionEntity &entity)
{
this->entities.push_back(entity.clone());
}
void
ExtrusionEntityCollection::append(const ExtrusionEntitiesPtr &entities)
{
for (ExtrusionEntitiesPtr::const_iterator ptr = entities.begin(); ptr != entities.end(); ++ptr)
this->append(**ptr);
}
void
ExtrusionEntityCollection::append(const ExtrusionPaths &paths)
{
for (ExtrusionPaths::const_iterator path = paths.begin(); path != paths.end(); ++path)
this->append(*path);
}
ExtrusionEntityCollection
ExtrusionEntityCollection::chained_path(bool no_reverse, std::vector<size_t>* orig_indices) const
{
ExtrusionEntityCollection coll;
this->chained_path(&coll, no_reverse, orig_indices);
return coll;
}
void
ExtrusionEntityCollection::chained_path(ExtrusionEntityCollection* retval, bool no_reverse, std::vector<size_t>* orig_indices) const
{
@ -137,6 +190,43 @@ ExtrusionEntityCollection::items_count() const
return count;
}
/* Returns a single vector of pointers to all non-collection items contained in this one */
void
ExtrusionEntityCollection::flatten(ExtrusionEntityCollection* retval) const
{
for (ExtrusionEntitiesPtr::const_iterator it = this->entities.begin(); it != this->entities.end(); ++it) {
if ((*it)->is_collection()) {
ExtrusionEntityCollection* collection = dynamic_cast<ExtrusionEntityCollection*>(*it);
retval->append(collection->flatten().entities);
} else {
retval->append(**it);
}
}
}
ExtrusionEntityCollection
ExtrusionEntityCollection::flatten() const
{
ExtrusionEntityCollection coll;
this->flatten(&coll);
return coll;
}
double
ExtrusionEntityCollection::min_mm3_per_mm() const
{
double min_mm3_per_mm = 0;
for (ExtrusionEntitiesPtr::const_iterator it = this->entities.begin(); it != this->entities.end(); ++it) {
double mm3_per_mm = (*it)->min_mm3_per_mm();
if (min_mm3_per_mm == 0) {
min_mm3_per_mm = mm3_per_mm;
} else {
min_mm3_per_mm = fmin(min_mm3_per_mm, mm3_per_mm);
}
}
return min_mm3_per_mm;
}
#ifdef SLIC3RXS
// there is no ExtrusionLoop::Collection or ExtrusionEntity::Collection
REGISTER_CLASS(ExtrusionEntityCollection, "ExtrusionPath::Collection");

23
xs/src/libslic3r/ExtrusionEntityCollection.hpp
View file

@ -10,19 +10,33 @@ class ExtrusionEntityCollection : public ExtrusionEntity
{
public:
ExtrusionEntityCollection* clone() const;
ExtrusionEntitiesPtr entities;
ExtrusionEntitiesPtr entities; // we own these entities
std::vector<size_t> orig_indices; // handy for XS
bool no_sort;
ExtrusionEntityCollection(): no_sort(false) {};
ExtrusionEntityCollection(const ExtrusionEntityCollection &collection);
ExtrusionEntityCollection(const ExtrusionPaths &paths);
ExtrusionEntityCollection& operator= (const ExtrusionEntityCollection &other);
~ExtrusionEntityCollection();
operator ExtrusionPaths() const;
bool is_collection() const {
return true;
};
bool can_reverse() const {
return !this->no_sort;
};
bool empty() const {
return this->entities.empty();
};
void clear() {
this->entities.clear();
};
void swap (ExtrusionEntityCollection &c);
void append(const ExtrusionEntity &entity);
void append(const ExtrusionEntitiesPtr &entities);
void append(const ExtrusionPaths &paths);
ExtrusionEntityCollection chained_path(bool no_reverse = false, std::vector<size_t>* orig_indices = NULL) const;
void chained_path(ExtrusionEntityCollection* retval, bool no_reverse = false, std::vector<size_t>* orig_indices = NULL) const;
void chained_path_from(Point start_near, ExtrusionEntityCollection* retval, bool no_reverse = false, std::vector<size_t>* orig_indices = NULL) const;
void reverse();
@ -30,6 +44,13 @@ class ExtrusionEntityCollection : public ExtrusionEntity
Point last_point() const;
Polygons grow() const;
size_t items_count() const;
void flatten(ExtrusionEntityCollection* retval) const;
ExtrusionEntityCollection flatten() const;
double min_mm3_per_mm() const;
Polyline as_polyline() const {
CONFESS("Calling as_polyline() on a ExtrusionEntityCollection");
return Polyline();
};
};
}

774
xs/src/libslic3r/GCode.cpp Normal file
View file

@ -0,0 +1,774 @@
#include "GCode.hpp"
#include "ExtrusionEntity.hpp"
#include <algorithm>
#include <cstdlib>
namespace Slic3r {
AvoidCrossingPerimeters::AvoidCrossingPerimeters()
: use_external_mp(false), use_external_mp_once(false), disable_once(true),
_external_mp(NULL), _layer_mp(NULL)
{
}
AvoidCrossingPerimeters::~AvoidCrossingPerimeters()
{
if (this->_external_mp != NULL)
delete this->_external_mp;
if (this->_layer_mp != NULL)
delete this->_layer_mp;
}
void
AvoidCrossingPerimeters::init_external_mp(const ExPolygons &islands)
{
if (this->_external_mp != NULL)
delete this->_external_mp;
this->_external_mp = new MotionPlanner(islands);
}
void
AvoidCrossingPerimeters::init_layer_mp(const ExPolygons &islands)
{
if (this->_layer_mp != NULL)
delete this->_layer_mp;
this->_layer_mp = new MotionPlanner(islands);
}
Polyline
AvoidCrossingPerimeters::travel_to(GCode &gcodegen, Point point)
{
if (this->use_external_mp || this->use_external_mp_once) {
// get current origin set in gcodegen
// (the one that will be used to translate the G-code coordinates by)
Point scaled_origin = Point::new_scale(gcodegen.origin.x, gcodegen.origin.y);
// represent last_pos in absolute G-code coordinates
Point last_pos = gcodegen.last_pos();
last_pos.translate(scaled_origin);
// represent point in absolute G-code coordinates
point.translate(scaled_origin);
// calculate path
Polyline travel = this->_external_mp->shortest_path(last_pos, point);
// translate the path back into the shifted coordinate system that gcodegen
// is currently using for writing coordinates
travel.translate(scaled_origin.negative());
return travel;
} else {
return this->_layer_mp->shortest_path(gcodegen.last_pos(), point);
}
}
#ifdef SLIC3RXS
REGISTER_CLASS(AvoidCrossingPerimeters, "GCode::AvoidCrossingPerimeters");
#endif
OozePrevention::OozePrevention()
: enable(false)
{
}
std::string
OozePrevention::pre_toolchange(GCode &gcodegen)
{
std::string gcode;
// move to the nearest standby point
if (!this->standby_points.empty()) {
// get current position in print coordinates
Pointf3 writer_pos = gcodegen.writer.get_position();
Point pos = Point::new_scale(writer_pos.x, writer_pos.y);
// find standby point
Point standby_point;
pos.nearest_point(this->standby_points, &standby_point);
/* We don't call gcodegen.travel_to() because we don't need retraction (it was already
triggered by the caller) nor avoid_crossing_perimeters and also because the coordinates
of the destination point must not be transformed by origin nor current extruder offset. */
gcode += gcodegen.writer.travel_to_xy(Pointf::new_unscale(standby_point),
"move to standby position");
}
if (gcodegen.config.standby_temperature_delta.value != 0) {
// we assume that heating is always slower than cooling, so no need to block
gcode += gcodegen.writer.set_temperature
(this->_get_temp(gcodegen) + gcodegen.config.standby_temperature_delta.value, false);
}
return gcode;
}
std::string
OozePrevention::post_toolchange(GCode &gcodegen)
{
std::string gcode;
if (gcodegen.config.standby_temperature_delta.value != 0) {
gcode += gcodegen.writer.set_temperature(this->_get_temp(gcodegen), true);
}
return gcode;
}
int
OozePrevention::_get_temp(GCode &gcodegen)
{
return (gcodegen.layer != NULL && gcodegen.layer->id() == 0)
? gcodegen.config.first_layer_temperature.get_at(gcodegen.writer.extruder()->id)
: gcodegen.config.temperature.get_at(gcodegen.writer.extruder()->id);
}
#ifdef SLIC3RXS
REGISTER_CLASS(OozePrevention, "GCode::OozePrevention");
#endif
Wipe::Wipe()
: enable(false)
{
}
bool
Wipe::has_path()
{
return !this->path.points.empty();
}
void
Wipe::reset_path()
{
this->path = Polyline();
}
std::string
Wipe::wipe(GCode &gcodegen, bool toolchange)
{
std::string gcode;
/* Reduce feedrate a bit; travel speed is often too high to move on existing material.
Too fast = ripping of existing material; too slow = short wipe path, thus more blob. */
double wipe_speed = gcodegen.writer.config.travel_speed.value * 0.8;
// get the retraction length
double length = toolchange
? gcodegen.writer.extruder()->retract_length_toolchange()
: gcodegen.writer.extruder()->retract_length();
if (length > 0) {
/* Calculate how long we need to travel in order to consume the required
amount of retraction. In other words, how far do we move in XY at wipe_speed
for the time needed to consume retract_length at retract_speed? */
double wipe_dist = scale_(length / gcodegen.writer.extruder()->retract_speed() * wipe_speed);
/* Take the stored wipe path and replace first point with the current actual position
(they might be different, for example, in case of loop clipping). */
Polyline wipe_path;
wipe_path.append(gcodegen.last_pos());
wipe_path.append(
this->path.points.begin() + 1,
this->path.points.end()
);
wipe_path.clip_end(wipe_path.length() - wipe_dist);
// subdivide the retraction in segments
double retracted = 0;
Lines lines = wipe_path.lines();
for (Lines::const_iterator line = lines.begin(); line != lines.end(); ++line) {
double segment_length = line->length();
/* Reduce retraction length a bit to avoid effective retraction speed to be greater than the configured one
due to rounding (TODO: test and/or better math for this) */
double dE = length * (segment_length / wipe_dist) * 0.95;
gcode += gcodegen.writer.set_speed(wipe_speed*60);
gcode += gcodegen.writer.extrude_to_xy(
gcodegen.point_to_gcode(line->b),
-dE,
(std::string)"wipe and retract" + (gcodegen.enable_cooling_markers ? ";_WIPE" : "")
);
retracted += dE;
}
gcodegen.writer.extruder()->retracted += retracted;
// prevent wiping again on same path
this->reset_path();
}
return gcode;
}
#ifdef SLIC3RXS
REGISTER_CLASS(Wipe, "GCode::Wipe");
#endif
#define EXTRUDER_CONFIG(OPT) this->config.OPT.get_at(this->writer.extruder()->id)
GCode::GCode()
: enable_loop_clipping(true), enable_cooling_markers(false), layer_count(0),
layer_index(-1), first_layer(false), elapsed_time(0), volumetric_speed(0),
_last_pos_defined(false), layer(NULL), placeholder_parser(NULL)
{
}
Point&
GCode::last_pos()
{
return this->_last_pos;
}
void
GCode::set_last_pos(const Point &pos)
{
this->_last_pos = pos;
this->_last_pos_defined = true;
}
bool
GCode::last_pos_defined() const
{
return this->_last_pos_defined;
}
void
GCode::apply_print_config(const PrintConfig &print_config)
{
this->writer.apply_print_config(print_config);
this->config.apply(print_config);
}
void
GCode::set_extruders(const std::vector<unsigned int> &extruder_ids)
{
this->writer.set_extruders(extruder_ids);
// enable wipe path generation if any extruder has wipe enabled
this->wipe.enable = false;
for (std::vector<unsigned int>::const_iterator it = extruder_ids.begin();
it != extruder_ids.end(); ++it) {
if (this->config.wipe.get_at(*it)) {
this->wipe.enable = true;
break;
}
}
}
void
GCode::set_origin(const Pointf &pointf)
{
// if origin increases (goes towards right), last_pos decreases because it goes towards left
Point translate(
scale_(this->origin.x - pointf.x),
scale_(this->origin.y - pointf.y)
);
this->_last_pos.translate(translate);
this->wipe.path.translate(translate);
this->origin = pointf;
}
std::string
GCode::preamble()
{
std::string gcode = this->writer.preamble();
/* Perform a *silent* move to z_offset: we need this to initialize the Z
position of our writer object so that any initial lift taking place
before the first layer change will raise the extruder from the correct
initial Z instead of 0. */
this->writer.travel_to_z(this->config.z_offset.value);
return gcode;
}
std::string
GCode::change_layer(const Layer &layer)
{
this->layer = &layer;
this->layer_index++;
this->first_layer = (layer.id() == 0);
// avoid computing islands and overhangs if they're not needed
if (this->config.avoid_crossing_perimeters) {
ExPolygons islands;
union_(layer.slices, &islands, true);
this->avoid_crossing_perimeters.init_layer_mp(islands);
}
std::string gcode;
if (this->layer_count > 0) {
gcode += this->writer.update_progress(this->layer_index, this->layer_count);
}
coordf_t z = layer.print_z + this->config.z_offset.value; // in unscaled coordinates
if (EXTRUDER_CONFIG(retract_layer_change) && this->writer.will_move_z(z)) {
gcode += this->retract();
}
{
std::ostringstream comment;
comment << "move to next layer (" << this->layer_index << ")";
gcode += this->writer.travel_to_z(z, comment.str());
}
// forget last wiping path as wiping after raising Z is pointless
this->wipe.reset_path();
return gcode;
}
std::string
GCode::extrude(ExtrusionLoop loop, std::string description, double speed)
{
// get a copy; don't modify the orientation of the original loop object otherwise
// next copies (if any) would not detect the correct orientation
// extrude all loops ccw
bool was_clockwise = loop.make_counter_clockwise();
// find the point of the loop that is closest to the current extruder position
// or randomize if requested
Point last_pos = this->last_pos();
if (this->config.spiral_vase) {
loop.split_at(last_pos);
} else if (this->config.seam_position == spNearest || this->config.seam_position == spAligned) {
Polygon polygon = loop.polygon();
// simplify polygon in order to skip false positives in concave/convex detection
// (loop is always ccw as polygon.simplify() only works on ccw polygons)
Polygons simplified = polygon.simplify(scale_(EXTRUDER_CONFIG(nozzle_diameter))/2);
// restore original winding order so that concave and convex detection always happens
// on the right/outer side of the polygon
if (was_clockwise) {
for (Polygons::iterator p = simplified.begin(); p != simplified.end(); ++p)
p->reverse();
}
// concave vertices have priority
Points candidates;
for (Polygons::const_iterator p = simplified.begin(); p != simplified.end(); ++p) {
Points concave = p->concave_points(PI*4/3);
candidates.insert(candidates.end(), concave.begin(), concave.end());
}
// if no concave points were found, look for convex vertices
if (candidates.empty()) {
for (Polygons::const_iterator p = simplified.begin(); p != simplified.end(); ++p) {
Points convex = p->convex_points(PI*2/3);
candidates.insert(candidates.end(), convex.begin(), convex.end());
}
}
// retrieve the last start position for this object
if (this->layer != NULL && this->_seam_position.count(this->layer->object()) > 0) {
last_pos = this->_seam_position[this->layer->object()];
}
Point point;
if (this->config.seam_position == spNearest) {
if (candidates.empty()) candidates = polygon.points;
last_pos.nearest_point(candidates, &point);
// On 32-bit Linux, Clipper will change some point coordinates by 1 unit
// while performing simplify_polygons(), thus split_at_vertex() won't
// find them anymore.
if (!loop.split_at_vertex(point)) loop.split_at(point);
} else if (!candidates.empty()) {
Points non_overhang;
for (Points::const_iterator p = candidates.begin(); p != candidates.end(); ++p) {
if (!loop.has_overhang_point(*p))
non_overhang.push_back(*p);
}
if (!non_overhang.empty())
candidates = non_overhang;
last_pos.nearest_point(candidates, &point);
if (!loop.split_at_vertex(point)) loop.split_at(point); // see note above
} else {
point = last_pos.projection_onto(polygon);
loop.split_at(point);
}
if (this->layer != NULL)
this->_seam_position[this->layer->object()] = point;
} else if (this->config.seam_position == spRandom) {
if (loop.role == elrContourInternalPerimeter) {
Polygon polygon = loop.polygon();
Point centroid = polygon.centroid();
last_pos = Point(polygon.bounding_box().max.x, centroid.y);
last_pos.rotate(rand() % 2*PI, centroid);
}
loop.split_at(last_pos);
}
// clip the path to avoid the extruder to get exactly on the first point of the loop;
// if polyline was shorter than the clipping distance we'd get a null polyline, so
// we discard it in that case
double clip_length = this->enable_loop_clipping
? scale_(EXTRUDER_CONFIG(nozzle_diameter)) * LOOP_CLIPPING_LENGTH_OVER_NOZZLE_DIAMETER
: 0;
// get paths
ExtrusionPaths paths;
loop.clip_end(clip_length, &paths);
if (paths.empty()) return "";
// apply the small perimeter speed
if (paths.front().is_perimeter() && loop.length() <= SMALL_PERIMETER_LENGTH) {
if (speed == -1) speed = this->config.get_abs_value("small_perimeter_speed");
}
// extrude along the path
std::string gcode;
for (ExtrusionPaths::const_iterator path = paths.begin(); path != paths.end(); ++path)
gcode += this->_extrude(*path, description, speed);
// reset acceleration
gcode += this->writer.set_acceleration(this->config.default_acceleration.value);
if (this->wipe.enable)
this->wipe.path = paths.front().polyline; // TODO: don't limit wipe to last path
// make a little move inwards before leaving loop
if (paths.back().role == erExternalPerimeter && this->layer != NULL && this->config.perimeters > 1) {
Polyline &last_path_polyline = paths.back().polyline;
// detect angle between last and first segment
// the side depends on the original winding order of the polygon (left for contours, right for holes)
Point a = paths.front().polyline.points[1]; // second point
Point b = *(paths.back().polyline.points.end()-3); // second to last point
if (was_clockwise) {
// swap points
Point c = a; a = b; b = c;
}
double angle = paths.front().first_point().ccw_angle(a, b) / 3;
// turn left if contour, turn right if hole
if (was_clockwise) angle *= -1;
// create the destination point along the first segment and rotate it
// we make sure we don't exceed the segment length because we don't know
// the rotation of the second segment so we might cross the object boundary
Line first_segment(
paths.front().polyline.points[0],
paths.front().polyline.points[1]
);
double distance = std::min(
scale_(EXTRUDER_CONFIG(nozzle_diameter)),
first_segment.length()
);
Point point = first_segment.point_at(distance);
point.rotate(angle, first_segment.a);
// generate the travel move
gcode += this->writer.travel_to_xy(this->point_to_gcode(point), "move inwards before travel");
}
return gcode;
}
std::string
GCode::extrude(const ExtrusionEntity &entity, std::string description, double speed)
{
if (const ExtrusionPath* path = dynamic_cast<const ExtrusionPath*>(&entity)) {
return this->extrude(*path, description, speed);
} else if (const ExtrusionLoop* loop = dynamic_cast<const ExtrusionLoop*>(&entity)) {
return this->extrude(*loop, description, speed);
} else {
CONFESS("Invalid argument supplied to extrude()");
return "";
}
}
std::string
GCode::extrude(const ExtrusionPath &path, std::string description, double speed)
{
std::string gcode = this->_extrude(path, description, speed);
// reset acceleration
gcode += this->writer.set_acceleration(this->config.default_acceleration.value);
return gcode;
}
std::string
GCode::_extrude(ExtrusionPath path, std::string description, double speed)
{
path.simplify(SCALED_RESOLUTION);
std::string gcode;
// go to first point of extrusion path
if (!this->_last_pos_defined || !this->_last_pos.coincides_with(path.first_point())) {
gcode += this->travel_to(
path.first_point(),
path.role,
"move to first " + description + " point"
);
}
// compensate retraction
gcode += this->unretract();
// adjust acceleration
{
double acceleration;
if (this->config.first_layer_acceleration.value > 0 && this->first_layer) {
acceleration = this->config.first_layer_acceleration.value;
} else if (this->config.perimeter_acceleration.value > 0 && path.is_perimeter()) {
acceleration = this->config.perimeter_acceleration.value;
} else if (this->config.bridge_acceleration.value > 0 && path.is_bridge()) {
acceleration = this->config.bridge_acceleration.value;
} else if (this->config.infill_acceleration.value > 0 && path.is_infill()) {
acceleration = this->config.infill_acceleration.value;
} else {
acceleration = this->config.default_acceleration.value;
}
gcode += this->writer.set_acceleration(acceleration);
}
// calculate extrusion length per distance unit
double e_per_mm = this->writer.extruder()->e_per_mm3 * path.mm3_per_mm;
if (this->writer.extrusion_axis().empty()) e_per_mm = 0;
// set speed
if (speed == -1) {
if (path.role == erPerimeter) {
speed = this->config.get_abs_value("perimeter_speed");
} else if (path.role == erExternalPerimeter) {
speed = this->config.get_abs_value("external_perimeter_speed");
} else if (path.role == erOverhangPerimeter || path.role == erBridgeInfill) {
speed = this->config.get_abs_value("bridge_speed");
} else if (path.role == erInternalInfill) {
speed = this->config.get_abs_value("infill_speed");
} else if (path.role == erSolidInfill) {
speed = this->config.get_abs_value("solid_infill_speed");
} else if (path.role == erTopSolidInfill) {
speed = this->config.get_abs_value("top_solid_infill_speed");
} else if (path.role == erGapFill) {
speed = this->config.get_abs_value("gap_fill_speed");
} else {
CONFESS("Invalid speed");
}
}
if (this->first_layer) {
speed = this->config.get_abs_value("first_layer_speed", speed);
}
if (this->volumetric_speed != 0 && speed == 0) {
speed = this->volumetric_speed / path.mm3_per_mm;
}
if (this->config.max_volumetric_speed.value > 0) {
// cap speed with max_volumetric_speed anyway (even if user is not using autospeed)
speed = std::min(
speed,
this->config.max_volumetric_speed.value / path.mm3_per_mm
);
}
double F = speed * 60; // convert mm/sec to mm/min
// extrude arc or line
if (path.is_bridge() && this->enable_cooling_markers)
gcode += ";_BRIDGE_FAN_START\n";
gcode += this->writer.set_speed(F);
double path_length = 0;
{
std::string comment = this->config.gcode_comments ? (" ; " + description) : "";
Lines lines = path.polyline.lines();
for (Lines::const_iterator line = lines.begin(); line != lines.end(); ++line) {
const double line_length = line->length() * SCALING_FACTOR;
path_length += line_length;
gcode += this->writer.extrude_to_xy(
this->point_to_gcode(line->b),
e_per_mm * line_length,
comment
);
}
}
if (this->wipe.enable) {
this->wipe.path = path.polyline;
this->wipe.path.reverse();
}
if (path.is_bridge() && this->enable_cooling_markers)
gcode += ";_BRIDGE_FAN_END\n";
this->set_last_pos(path.last_point());
if (this->config.cooling)
this->elapsed_time += path_length / F * 60;
return gcode;
}
// This method accepts &point in print coordinates.
std::string
GCode::travel_to(const Point &point, ExtrusionRole role, std::string comment)
{
/* Define the travel move as a line between current position and the taget point.
This is expressed in print coordinates, so it will need to be translated by
this->origin in order to get G-code coordinates. */
Polyline travel;
travel.append(this->last_pos());
travel.append(point);
// check whether a straight travel move would need retraction
bool needs_retraction = this->needs_retraction(travel, role);
// if a retraction would be needed, try to use avoid_crossing_perimeters to plan a
// multi-hop travel path inside the configuration space
if (needs_retraction
&& this->config.avoid_crossing_perimeters
&& !this->avoid_crossing_perimeters.disable_once) {
travel = this->avoid_crossing_perimeters.travel_to(*this, point);
// check again whether the new travel path still needs a retraction
needs_retraction = this->needs_retraction(travel, role);
}
// Re-allow avoid_crossing_perimeters for the next travel moves
this->avoid_crossing_perimeters.disable_once = false;
this->avoid_crossing_perimeters.use_external_mp_once = false;
// generate G-code for the travel move
std::string gcode;
if (needs_retraction) gcode += this->retract();
// use G1 because we rely on paths being straight (G0 may make round paths)
Lines lines = travel.lines();
for (Lines::const_iterator line = lines.begin(); line != lines.end(); ++line)
gcode += this->writer.travel_to_xy(this->point_to_gcode(line->b), comment);
return gcode;
}
bool
GCode::needs_retraction(const Polyline &travel, ExtrusionRole role)
{
if (travel.length() < scale_(EXTRUDER_CONFIG(retract_before_travel))) {
// skip retraction if the move is shorter than the configured threshold
return false;
}
if (role == erSupportMaterial) {
const SupportLayer* support_layer = dynamic_cast<const SupportLayer*>(this->layer);
if (support_layer != NULL && support_layer->support_islands.contains(travel)) {
// skip retraction if this is a travel move inside a support material island
return false;
}
}
if (this->config.only_retract_when_crossing_perimeters && this->layer != NULL) {
if (this->config.fill_density.value > 0
&& this->layer->any_internal_region_slice_contains(travel)) {
/* skip retraction if travel is contained in an internal slice *and*
internal infill is enabled (so that stringing is entirely not visible) */
return false;
} else if (this->layer->any_bottom_region_slice_contains(travel)
&& this->layer->upper_layer != NULL
&& this->layer->upper_layer->slices.contains(travel)
&& (this->config.bottom_solid_layers.value >= 2 || this->config.fill_density.value > 0)) {
/* skip retraction if travel is contained in an *infilled* bottom slice
but only if it's also covered by an *infilled* upper layer's slice
so that it's not visible from above (a bottom surface might not have an
upper slice in case of a thin membrane) */
return false;
}
}
// retract if only_retract_when_crossing_perimeters is disabled or doesn't apply
return true;
}
std::string
GCode::retract(bool toolchange)
{
std::string gcode;
if (this->writer.extruder() == NULL)
return gcode;
// wipe (if it's enabled for this extruder and we have a stored wipe path)
if (EXTRUDER_CONFIG(wipe) && this->wipe.has_path()) {
gcode += this->wipe.wipe(*this, toolchange);
}
/* The parent class will decide whether we need to perform an actual retraction
(the extruder might be already retracted fully or partially). We call these
methods even if we performed wipe, since this will ensure the entire retraction
length is honored in case wipe path was too short. */
gcode += toolchange ? this->writer.retract_for_toolchange() : this->writer.retract();
gcode += this->writer.reset_e();
if (this->writer.extruder()->retract_length() > 0 || this->config.use_firmware_retraction)
gcode += this->writer.lift();
return gcode;
}
std::string
GCode::unretract()
{
std::string gcode;
gcode += this->writer.unlift();
gcode += this->writer.unretract();
return gcode;
}
std::string
GCode::set_extruder(unsigned int extruder_id)
{
this->placeholder_parser->set("current_extruder", extruder_id);
if (!this->writer.need_toolchange(extruder_id))
return "";
// if we are running a single-extruder setup, just set the extruder and return nothing
if (!this->writer.multiple_extruders) {
return this->writer.toolchange(extruder_id);
}
// prepend retraction on the current extruder
std::string gcode = this->retract(true);
// append custom toolchange G-code
if (this->writer.extruder() != NULL && !this->config.toolchange_gcode.value.empty()) {
PlaceholderParser pp = *this->placeholder_parser;
pp.set("previous_extruder", this->writer.extruder()->id);
pp.set("next_extruder", extruder_id);
gcode += pp.process(this->config.toolchange_gcode.value) + '\n';
}
// if ooze prevention is enabled, park current extruder in the nearest
// standby point and set it to the standby temperature
if (this->ooze_prevention.enable && this->writer.extruder() != NULL)
gcode += this->ooze_prevention.pre_toolchange(*this);
// append the toolchange command
gcode += this->writer.toolchange(extruder_id);
// set the new extruder to the operating temperature
if (this->ooze_prevention.enable)
gcode += this->ooze_prevention.post_toolchange(*this);
return gcode;
}
// convert a model-space scaled point into G-code coordinates
Pointf
GCode::point_to_gcode(const Point &point)
{
Pointf extruder_offset = EXTRUDER_CONFIG(extruder_offset);
return Pointf(
unscale(point.x) + this->origin.x - extruder_offset.x,
unscale(point.y) + this->origin.y - extruder_offset.y
);
}
#ifdef SLIC3RXS
REGISTER_CLASS(GCode, "GCode");
#endif
}

114
xs/src/libslic3r/GCode.hpp
View file

@ -2,32 +2,112 @@
#define slic3r_GCode_hpp_
#include <myinit.h>
#include "ExPolygon.hpp"
#include "GCodeWriter.hpp"
#include "Layer.hpp"
#include "MotionPlanner.hpp"
#include "Point.hpp"
#include "PlaceholderParser.hpp"
#include "Print.hpp"
#include "PrintConfig.hpp"
#include <string>
namespace Slic3r {
// draft for a binary representation of a G-code line
class GCode;
enum GCodeCmdType {
gcctSyncMotion,
gcctExtrude,
gcctResetE,
gcctSetTemp,
gcctSetTempWait,
gcctToolchange,
gcctCustom
class AvoidCrossingPerimeters {
public:
// this flag triggers the use of the external configuration space
bool use_external_mp;
bool use_external_mp_once; // just for the next travel move
// this flag disables avoid_crossing_perimeters just for the next travel move
// we enable it by default for the first travel move in print
bool disable_once;
AvoidCrossingPerimeters();
~AvoidCrossingPerimeters();
void init_external_mp(const ExPolygons &islands);
void init_layer_mp(const ExPolygons &islands);
Polyline travel_to(GCode &gcodegen, Point point);
private:
MotionPlanner* _external_mp;
MotionPlanner* _layer_mp;
};
class GCodeCmd {
class OozePrevention {
public:
GCodeCmdType type;
float X, Y, Z, E, F;
unsigned short T, S;
std::string custom, comment;
float xy_dist; // cache
bool enable;
Points standby_points;
GCodeCmd(GCodeCmdType type)
: type(type), X(0), Y(0), Z(0), E(0), F(0), T(-1), S(0), xy_dist(-1) {};
OozePrevention();
std::string pre_toolchange(GCode &gcodegen);
std::string post_toolchange(GCode &gcodegen);
private:
int _get_temp(GCode &gcodegen);
};
class Wipe {
public:
bool enable;
Polyline path;
Wipe();
bool has_path();
void reset_path();
std::string wipe(GCode &gcodegen, bool toolchange = false);
};
class GCode {
public:
/* Origin of print coordinates expressed in unscaled G-code coordinates.
This affects the input arguments supplied to the extrude*() and travel_to()
methods. */
Pointf origin;
FullPrintConfig config;
GCodeWriter writer;
PlaceholderParser* placeholder_parser;
OozePrevention ooze_prevention;
Wipe wipe;
AvoidCrossingPerimeters avoid_crossing_perimeters;
bool enable_loop_clipping;
bool enable_cooling_markers;
size_t layer_count;
int layer_index; // just a counter
const Layer* layer;
std::map<const PrintObject*,Point> _seam_position;
bool first_layer; // this flag triggers first layer speeds
unsigned int elapsed_time; // seconds
double volumetric_speed;
GCode();
Point& last_pos();
void set_last_pos(const Point &pos);
bool last_pos_defined() const;
void apply_print_config(const PrintConfig &print_config);
void set_extruders(const std::vector<unsigned int> &extruder_ids);
void set_origin(const Pointf &pointf);
std::string preamble();
std::string change_layer(const Layer &layer);
std::string extrude(const ExtrusionEntity &entity, std::string description = "", double speed = -1);
std::string extrude(ExtrusionLoop loop, std::string description = "", double speed = -1);
std::string extrude(const ExtrusionPath &path, std::string description = "", double speed = -1);
std::string travel_to(const Point &point, ExtrusionRole role, std::string comment);
bool needs_retraction(const Polyline &travel, ExtrusionRole role = erNone);
std::string retract(bool toolchange = false);
std::string unretract();
std::string set_extruder(unsigned int extruder_id);
Pointf point_to_gcode(const Point &point);
private:
Point _last_pos;
bool _last_pos_defined;
std::string _extrude(ExtrusionPath path, std::string description = "", double speed = -1);
};
}

2
xs/src/libslic3r/Geometry.cpp
View file

@ -504,7 +504,7 @@ MedialAxis::is_valid_edge(const VD::edge_type& edge) const
//printf(" => too thin, skipping\n");
return false;
}
return true;
}

6
xs/src/libslic3r/Layer.cpp
View file

@ -53,6 +53,12 @@ Layer::object()
return this->_object;
}
const PrintObject*
Layer::object() const
{
return this->_object;
}
size_t
Layer::region_count()

7
xs/src/libslic3r/Layer.hpp
View file

@ -40,8 +40,7 @@ class LayerRegion
// collection of expolygons representing the bridged areas (thus not
// needing support material)
// (this could be just a Polygons object)
ExPolygonCollection bridged;
Polygons bridged;
// collection of polylines representing the unsupported bridge edges
PolylineCollection unsupported_bridge_edges;
@ -57,6 +56,9 @@ class LayerRegion
Flow flow(FlowRole role, bool bridge = false, double width = -1) const;
void merge_slices();
void prepare_fill_surfaces();
void make_perimeters(const SurfaceCollection &slices, SurfaceCollection* fill_surfaces);
void process_external_surfaces(const Layer* lower_layer);
double infill_area_threshold() const;
private:
Layer *_layer;
@ -76,6 +78,7 @@ class Layer {
size_t id() const;
void set_id(size_t id);
PrintObject* object();
const PrintObject* object() const;
Layer *upper_layer;
Layer *lower_layer;

181
xs/src/libslic3r/LayerRegion.cpp
View file

@ -1,5 +1,7 @@
#include "Layer.hpp"
#include "BridgeDetector.hpp"
#include "ClipperUtils.hpp"
#include "PerimeterGenerator.hpp"
#include "Print.hpp"
#include "Surface.hpp"
@ -53,6 +55,178 @@ LayerRegion::merge_slices()
this->slices.surfaces.push_back(Surface(stInternal, *expoly));
}
void
LayerRegion::make_perimeters(const SurfaceCollection &slices, SurfaceCollection* fill_surfaces)
{
this->perimeters.clear();
this->thin_fills.clear();
PerimeterGenerator g(
// input:
&slices,
this->layer()->height,
this->flow(frPerimeter),
&this->region()->config,
&this->layer()->object()->config,
&this->layer()->object()->print()->config,
// output:
&this->perimeters,
&this->thin_fills,
fill_surfaces
);
if (this->layer()->lower_layer != NULL)
g.lower_slices = &this->layer()->lower_layer->slices;
g.layer_id = this->layer()->id();
g.ext_perimeter_flow = this->flow(frExternalPerimeter);
g.overhang_flow = this->region()->flow(frPerimeter, -1, true, false, -1, *this->layer()->object());
g.solid_infill_flow = this->flow(frSolidInfill);
g.process();
}
void
LayerRegion::process_external_surfaces(const Layer* lower_layer)
{
const Surfaces &surfaces = this->fill_surfaces.surfaces;
const double margin = scale_(EXTERNAL_INFILL_MARGIN);
SurfaceCollection bottom;
for (Surfaces::const_iterator surface = surfaces.begin(); surface != surfaces.end(); ++surface) {
if (!surface->is_bottom()) continue;
ExPolygons grown = offset_ex(surface->expolygon, +margin);
/* detect bridge direction before merging grown surfaces otherwise adjacent bridges
would get merged into a single one while they need different directions
also, supply the original expolygon instead of the grown one, because in case
of very thin (but still working) anchors, the grown expolygon would go beyond them */
double angle = -1;
if (lower_layer != NULL) {
BridgeDetector bd(
surface->expolygon,
lower_layer->slices,
this->flow(frInfill, this->layer()->height, true).scaled_width()
);
#ifdef SLIC3R_DEBUG
printf("Processing bridge at layer %zu:\n", this->layer()->id();
#endif
if (bd.detect_angle() && this->layer()->object()->config.support_material) {
angle = bd.angle;
Polygons coverage = bd.coverage();
this->bridged.insert(this->bridged.end(), coverage.begin(), coverage.end());
this->unsupported_bridge_edges.append(bd.unsupported_edges());
}
}
for (ExPolygons::const_iterator it = grown.begin(); it != grown.end(); ++it) {
Surface s = *surface;
s.expolygon = *it;
s.bridge_angle = angle;
bottom.surfaces.push_back(s);
}
}
SurfaceCollection top;
for (Surfaces::const_iterator surface = surfaces.begin(); surface != surfaces.end(); ++surface) {
if (surface->surface_type != stTop) continue;
// give priority to bottom surfaces
ExPolygons grown = diff_ex(
offset(surface->expolygon, +margin),
(Polygons)bottom
);
for (ExPolygons::const_iterator it = grown.begin(); it != grown.end(); ++it) {
Surface s = *surface;
s.expolygon = *it;
top.surfaces.push_back(s);
}
}
/* if we're slicing with no infill, we can't extend external surfaces
over non-existent infill */
SurfaceCollection fill_boundaries;
if (this->region()->config.fill_density.value > 0) {
fill_boundaries = SurfaceCollection(surfaces);
} else {
for (Surfaces::const_iterator it = surfaces.begin(); it != surfaces.end(); ++it) {
if (it->surface_type != stInternal)
fill_boundaries.surfaces.push_back(*it);
}
}
// intersect the grown surfaces with the actual fill boundaries
SurfaceCollection new_surfaces;
{
// merge top and bottom in a single collection
SurfaceCollection tb = top;
tb.surfaces.insert(tb.surfaces.end(), bottom.surfaces.begin(), bottom.surfaces.end());
// group surfaces
std::vector<SurfacesPtr> groups;
tb.group(&groups);
for (std::vector<SurfacesPtr>::const_iterator g = groups.begin(); g != groups.end(); ++g) {
Polygons subject;
for (SurfacesPtr::const_iterator s = g->begin(); s != g->end(); ++s) {
Polygons pp = **s;
subject.insert(subject.end(), pp.begin(), pp.end());
}
ExPolygons expp = intersection_ex(
subject,
(Polygons)fill_boundaries,
true // to ensure adjacent expolygons are unified
);
for (ExPolygons::const_iterator ex = expp.begin(); ex != expp.end(); ++ex) {
Surface s = *g->front();
s.expolygon = *ex;
new_surfaces.surfaces.push_back(s);
}
}
}
/* subtract the new top surfaces from the other non-top surfaces and re-add them */
{
SurfaceCollection other;
for (Surfaces::const_iterator s = surfaces.begin(); s != surfaces.end(); ++s) {
if (s->surface_type != stTop && !s->is_bottom())
other.surfaces.push_back(*s);
}
// group surfaces
std::vector<SurfacesPtr> groups;
other.group(&groups);
for (std::vector<SurfacesPtr>::const_iterator g = groups.begin(); g != groups.end(); ++g) {
Polygons subject;
for (SurfacesPtr::const_iterator s = g->begin(); s != g->end(); ++s) {
Polygons pp = **s;
subject.insert(subject.end(), pp.begin(), pp.end());
}
ExPolygons expp = diff_ex(
subject,
(Polygons)new_surfaces
);
for (ExPolygons::const_iterator ex = expp.begin(); ex != expp.end(); ++ex) {
Surface s = *g->front();
s.expolygon = *ex;
new_surfaces.surfaces.push_back(s);
}
}
}
this->fill_surfaces = new_surfaces;
}
void
LayerRegion::prepare_fill_surfaces()
{
@ -90,6 +264,13 @@ LayerRegion::prepare_fill_surfaces()
}
}
double
LayerRegion::infill_area_threshold() const
{
double ss = this->flow(frSolidInfill).scaled_spacing();
return ss*ss;
}
#ifdef SLIC3RXS
REGISTER_CLASS(LayerRegion, "Layer::Region");
#endif

3
xs/src/libslic3r/Model.cpp
View file

@ -690,7 +690,8 @@ ModelVolume::assign_unique_material()
{
Model* model = this->get_object()->get_model();
this->_material_id = 1 + model->materials.size();
// as material-id "0" is reserved by the AMF spec we start from 1
this->_material_id = 1 + model->materials.size(); // watchout for implicit cast
return model->add_material(this->_material_id);
}

18
xs/src/libslic3r/MultiPoint.cpp
View file

@ -100,6 +100,24 @@ MultiPoint::remove_duplicate_points()
}
}
void
MultiPoint::append(const Point &point)
{
this->points.push_back(point);
}
void
MultiPoint::append(const Points &points)
{
this->append(points.begin(), points.end());
}
void
MultiPoint::append(const Points::const_iterator &begin, const Points::const_iterator &end)
{
this->points.insert(this->points.end(), begin, end);
}
Points
MultiPoint::_douglas_peucker(const Points &points, const double tolerance)
{

3
xs/src/libslic3r/MultiPoint.hpp
View file

@ -33,6 +33,9 @@ class MultiPoint
bool has_boundary_point(const Point &point) const;
BoundingBox bounding_box() const;
void remove_duplicate_points();
void append(const Point &point);
void append(const Points &points);
void append(const Points::const_iterator &begin, const Points::const_iterator &end);
static Points _douglas_peucker(const Points &points, const double tolerance);

525
xs/src/libslic3r/PerimeterGenerator.cpp Normal file
View file

@ -0,0 +1,525 @@
#include "PerimeterGenerator.hpp"
#include "ClipperUtils.hpp"
#include "ExtrusionEntityCollection.hpp"
namespace Slic3r {
void
PerimeterGenerator::process()
{
// other perimeters
this->_mm3_per_mm = this->perimeter_flow.mm3_per_mm();
coord_t pwidth = this->perimeter_flow.scaled_width();
coord_t pspacing = this->perimeter_flow.scaled_spacing();
// external perimeters
this->_ext_mm3_per_mm = this->ext_perimeter_flow.mm3_per_mm();
coord_t ext_pwidth = this->ext_perimeter_flow.scaled_width();
coord_t ext_pspacing = scale_(this->ext_perimeter_flow.spacing(this->perimeter_flow));
// overhang perimeters
this->_mm3_per_mm_overhang = this->overhang_flow.mm3_per_mm();
// solid infill
coord_t ispacing = this->solid_infill_flow.scaled_spacing();
coord_t gap_area_threshold = pwidth * pwidth;
// Calculate the minimum required spacing between two adjacent traces.
// This should be equal to the nominal flow spacing but we experiment
// with some tolerance in order to avoid triggering medial axis when
// some squishing might work. Loops are still spaced by the entire
// flow spacing; this only applies to collapsing parts.
coord_t min_spacing = pspacing * (1 - INSET_OVERLAP_TOLERANCE);
coord_t ext_min_spacing = ext_pspacing * (1 - INSET_OVERLAP_TOLERANCE);
// prepare grown lower layer slices for overhang detection
if (this->lower_slices != NULL && this->config->overhangs) {
// We consider overhang any part where the entire nozzle diameter is not supported by the
// lower layer, so we take lower slices and offset them by half the nozzle diameter used
// in the current layer
double nozzle_diameter = this->print_config->nozzle_diameter.get_at(this->config->perimeter_extruder-1);
this->_lower_slices_p = offset(*this->lower_slices, scale_(+nozzle_diameter/2));
}
// we need to process each island separately because we might have different
// extra perimeters for each one
for (Surfaces::const_iterator surface = this->slices->surfaces.begin();
surface != this->slices->surfaces.end(); ++surface) {
// detect how many perimeters must be generated for this island
signed short loop_number = this->config->perimeters + surface->extra_perimeters;
loop_number--; // 0-indexed loops
Polygons gaps;
Polygons last = surface->expolygon.simplify_p(SCALED_RESOLUTION);
if (loop_number >= 0) { // no loops = -1
std::vector<PerimeterGeneratorLoops> contours(loop_number+1); // depth => loops
std::vector<PerimeterGeneratorLoops> holes(loop_number+1); // depth => loops
Polylines thin_walls;
// we loop one time more than needed in order to find gaps after the last perimeter was applied
for (signed short i = 0; i <= loop_number+1; ++i) { // outer loop is 0
Polygons offsets;
if (i == 0) {
// the minimum thickness of a single loop is:
// ext_width/2 + ext_spacing/2 + spacing/2 + width/2
if (this->config->thin_walls) {
offsets = offset2(
last,
-(0.5*ext_pwidth + 0.5*ext_min_spacing - 1),
+(0.5*ext_min_spacing - 1)
);
} else {
offsets = offset(last, -0.5*ext_pwidth);
}
// look for thin walls
if (this->config->thin_walls) {
Polygons diffpp = diff(
last,
offset(offsets, +0.5*ext_pwidth),
true // medial axis requires non-overlapping geometry
);
// the following offset2 ensures almost nothing in @thin_walls is narrower than $min_width
// (actually, something larger than that still may exist due to mitering or other causes)
coord_t min_width = ext_pwidth / 2;
ExPolygons expp = offset2_ex(diffpp, -min_width/2, +min_width/2);
// the maximum thickness of our thin wall area is equal to the minimum thickness of a single loop
Polylines pp;
for (ExPolygons::const_iterator ex = expp.begin(); ex != expp.end(); ++ex)
ex->medial_axis(ext_pwidth + ext_pspacing, min_width, &pp);
double threshold = ext_pwidth * ext_pwidth;
for (Polylines::const_iterator p = pp.begin(); p != pp.end(); ++p) {
if (p->length() > threshold) {
thin_walls.push_back(*p);
}
}
#ifdef DEBUG
printf(" %zu thin walls detected\n", thin_walls.size());
#endif
/*
if (false) {
require "Slic3r/SVG.pm";
Slic3r::SVG::output(
"medial_axis.svg",
no_arrows => 1,
#expolygons => \@expp,
polylines => \@thin_walls,
);
}
*/
}
} else {
coord_t distance = (i == 1) ? ext_pspacing : pspacing;
if (this->config->thin_walls) {
offsets = offset2(
last,
-(distance + 0.5*min_spacing - 1),
+(0.5*min_spacing - 1)
);
} else {
offsets = offset(
last,
-distance
);
}
// look for gaps
if (this->config->gap_fill_speed.value > 0 && this->config->fill_density.value > 0) {
// not using safety offset here would "detect" very narrow gaps
// (but still long enough to escape the area threshold) that gap fill
// won't be able to fill but we'd still remove from infill area
ExPolygons diff_expp = diff_ex(
offset(last, -0.5*distance),
offset(offsets, +0.5*distance + 10) // safety offset
);
for (ExPolygons::const_iterator ex = diff_expp.begin(); ex != diff_expp.end(); ++ex) {
if (fabs(ex->area()) >= gap_area_threshold) {
Polygons pp = *ex;
gaps.insert(gaps.end(), pp.begin(), pp.end());
}
}
}
}
if (offsets.empty()) break;
if (i > loop_number) break; // we were only looking for gaps this time
last = offsets;
for (Polygons::const_iterator polygon = offsets.begin(); polygon != offsets.end(); ++polygon) {
PerimeterGeneratorLoop loop(*polygon, i);
loop.is_contour = polygon->is_counter_clockwise();
if (loop.is_contour) {
contours[i].push_back(loop);
} else {
holes[i].push_back(loop);
}
}
}
// nest loops: holes first
for (signed short d = 0; d <= loop_number; ++d) {
PerimeterGeneratorLoops &holes_d = holes[d];
// loop through all holes having depth == d
for (signed short i = 0; i < holes_d.size(); ++i) {
const PerimeterGeneratorLoop &loop = holes_d[i];
// find the hole loop that contains this one, if any
for (signed short t = d+1; t <= loop_number; ++t) {
for (signed short j = 0; j < holes[t].size(); ++j) {
PerimeterGeneratorLoop &candidate_parent = holes[t][j];
if (candidate_parent.polygon.contains(loop.polygon.first_point())) {
candidate_parent.children.push_back(loop);
holes_d.erase(holes_d.begin() + i);
--i;
goto NEXT_LOOP;
}
}
}
// if no hole contains this hole, find the contour loop that contains it
for (signed short t = loop_number; t >= 0; --t) {
for (signed short j = 0; j < contours[t].size(); ++j) {
PerimeterGeneratorLoop &candidate_parent = contours[t][j];
if (candidate_parent.polygon.contains(loop.polygon.first_point())) {
candidate_parent.children.push_back(loop);
holes_d.erase(holes_d.begin() + i);
--i;
goto NEXT_LOOP;
}
}
}
NEXT_LOOP: ;
}
}
// nest contour loops
for (signed short d = loop_number; d >= 1; --d) {
PerimeterGeneratorLoops &contours_d = contours[d];
// loop through all contours having depth == d
for (signed short i = 0; i < contours_d.size(); ++i) {
const PerimeterGeneratorLoop &loop = contours_d[i];
// find the contour loop that contains it
for (signed short t = d-1; t >= 0; --t) {
for (signed short j = 0; j < contours[t].size(); ++j) {
PerimeterGeneratorLoop &candidate_parent = contours[t][j];
if (candidate_parent.polygon.contains(loop.polygon.first_point())) {
candidate_parent.children.push_back(loop);
contours_d.erase(contours_d.begin() + i);
--i;
goto NEXT_CONTOUR;
}
}
}
NEXT_CONTOUR: ;
}
}
// at this point, all loops should be in contours[0]
ExtrusionEntityCollection entities = this->_traverse_loops(contours.front(), thin_walls);
// if brim will be printed, reverse the order of perimeters so that
// we continue inwards after having finished the brim
// TODO: add test for perimeter order
if (this->config->external_perimeters_first
|| (this->layer_id == 0 && this->print_config->brim_width.value > 0))
entities.reverse();
// append perimeters for this slice as a collection
if (!entities.empty())
this->loops->append(entities);
}
// fill gaps
if (!gaps.empty()) {
/*
if (false) {
require "Slic3r/SVG.pm";
Slic3r::SVG::output(
"gaps.svg",
expolygons => union_ex(\@gaps),
);
}
*/
// where $pwidth < thickness < 2*$pspacing, infill with width = 2*$pwidth
// where 0.1*$pwidth < thickness < $pwidth, infill with width = 1*$pwidth
std::vector<PerimeterGeneratorGapSize> gap_sizes;
gap_sizes.push_back(PerimeterGeneratorGapSize(pwidth, 2*pspacing, unscale(2*pwidth)));
gap_sizes.push_back(PerimeterGeneratorGapSize(0.1*pwidth, pwidth, unscale(1*pwidth)));
for (std::vector<PerimeterGeneratorGapSize>::const_iterator gap_size = gap_sizes.begin();
gap_size != gap_sizes.end(); ++gap_size) {
ExtrusionEntityCollection gap_fill = this->_fill_gaps(gap_size->min,
gap_size->max, gap_size->width, gaps);
this->gap_fill->append(gap_fill.entities);
// Make sure we don't infill narrow parts that are already gap-filled
// (we only consider this surface's gaps to reduce the diff() complexity).
// Growing actual extrusions ensures that gaps not filled by medial axis
// are not subtracted from fill surfaces (they might be too short gaps
// that medial axis skips but infill might join with other infill regions
// and use zigzag).
double dist = scale_(gap_size->width/2);
Polygons filled;
for (ExtrusionEntitiesPtr::const_iterator it = gap_fill.entities.begin();
it != gap_fill.entities.end(); ++it)
offset((*it)->as_polyline(), &filled, dist);
last = diff(last, filled);
gaps = diff(gaps, filled); // prevent more gap fill here
}
}
// create one more offset to be used as boundary for fill
// we offset by half the perimeter spacing (to get to the actual infill boundary)
// and then we offset back and forth by half the infill spacing to only consider the
// non-collapsing regions
coord_t inset = 0;
if (loop_number == 0) {
// one loop
inset += ext_pspacing/2;
} else if (loop_number > 0) {
// two or more loops
inset += pspacing/2;
}
// only apply infill overlap if we actually have one perimeter
if (inset > 0)
inset -= this->config->get_abs_value("infill_overlap", inset + ispacing/2);
{
ExPolygons expp = union_ex(last);
// simplify infill contours according to resolution
Polygons pp;
for (ExPolygons::const_iterator ex = expp.begin(); ex != expp.end(); ++ex)
ex->simplify_p(SCALED_RESOLUTION, &pp);
// collapse too narrow infill areas
coord_t min_perimeter_infill_spacing = ispacing * (1 - INSET_OVERLAP_TOLERANCE);
expp = offset2_ex(
pp,
-inset -min_perimeter_infill_spacing/2,
+min_perimeter_infill_spacing/2
);
// append infill areas to fill_surfaces
for (ExPolygons::const_iterator ex = expp.begin(); ex != expp.end(); ++ex)
this->fill_surfaces->surfaces.push_back(Surface(stInternal, *ex)); // use a bogus surface type
}
}
}
ExtrusionEntityCollection
PerimeterGenerator::_traverse_loops(const PerimeterGeneratorLoops &loops,
Polylines &thin_walls) const
{
// loops is an arrayref of ::Loop objects
// turn each one into an ExtrusionLoop object
ExtrusionEntityCollection coll;
for (PerimeterGeneratorLoops::const_iterator loop = loops.begin();
loop != loops.end(); ++loop) {
bool is_external = loop->is_external();
ExtrusionRole role;
ExtrusionLoopRole loop_role;
role = is_external ? erExternalPerimeter : erPerimeter;
if (loop->is_internal_contour()) {
// Note that we set loop role to ContourInternalPerimeter
// also when loop is both internal and external (i.e.
// there's only one contour loop).
loop_role = elrContourInternalPerimeter;
} else {
loop_role = elrDefault;
}
// detect overhanging/bridging perimeters
ExtrusionPaths paths;
if (this->config->overhangs && this->layer_id > 0
&& !(this->object_config->support_material && this->object_config->support_material_contact_distance.value == 0)) {
// get non-overhang paths by intersecting this loop with the grown lower slices
{
Polylines polylines;
intersection((Polygons)loop->polygon, this->_lower_slices_p, &polylines);
for (Polylines::const_iterator polyline = polylines.begin(); polyline != polylines.end(); ++polyline) {
ExtrusionPath path(role);
path.polyline = *polyline;
path.mm3_per_mm = is_external ? this->_ext_mm3_per_mm : this->_mm3_per_mm;
path.width = is_external ? this->ext_perimeter_flow.width : this->perimeter_flow.width;
path.height = this->layer_height;
paths.push_back(path);
}
}
// get overhang paths by checking what parts of this loop fall
// outside the grown lower slices (thus where the distance between
// the loop centerline and original lower slices is >= half nozzle diameter
{
Polylines polylines;
diff((Polygons)loop->polygon, this->_lower_slices_p, &polylines);
for (Polylines::const_iterator polyline = polylines.begin(); polyline != polylines.end(); ++polyline) {
ExtrusionPath path(erOverhangPerimeter);
path.polyline = *polyline;
path.mm3_per_mm = this->_mm3_per_mm_overhang;
path.width = this->overhang_flow.width;
path.height = this->overhang_flow.height;
paths.push_back(path);
}
}
// reapply the nearest point search for starting point
// We allow polyline reversal because Clipper may have randomly
// reversed polylines during clipping.
paths = ExtrusionEntityCollection(paths).chained_path();
} else {
ExtrusionPath path(role);
path.polyline = loop->polygon.split_at_first_point();
path.mm3_per_mm = is_external ? this->_ext_mm3_per_mm : this->_mm3_per_mm;
path.width = is_external ? this->ext_perimeter_flow.width : this->perimeter_flow.width;
path.height = this->layer_height;
paths.push_back(path);
}
coll.append(ExtrusionLoop(paths, loop_role));
}
// append thin walls to the nearest-neighbor search (only for first iteration)
if (!thin_walls.empty()) {
for (Polylines::const_iterator polyline = thin_walls.begin(); polyline != thin_walls.end(); ++polyline) {
ExtrusionPath path(erExternalPerimeter);
path.polyline = *polyline;
path.mm3_per_mm = this->_mm3_per_mm;
path.width = this->perimeter_flow.width;
path.height = this->layer_height;
coll.append(path);
}
thin_walls.clear();
}
// sort entities
ExtrusionEntityCollection sorted_coll;
coll.chained_path(&sorted_coll, false, &sorted_coll.orig_indices);
// traverse children
ExtrusionEntityCollection entities;
for (unsigned short i = 0; i < sorted_coll.orig_indices.size(); ++i) {
size_t idx = sorted_coll.orig_indices[i];
if (idx >= loops.size()) {
// this is a thin wall
// let's get it from the sorted collection as it might have been reversed
entities.append(*sorted_coll.entities[i]);
} else {
const PerimeterGeneratorLoop &loop = loops[i];
ExtrusionLoop eloop = *dynamic_cast<ExtrusionLoop*>(coll.entities[idx]);
ExtrusionEntityCollection children = this->_traverse_loops(loop.children, thin_walls);
if (loop.is_contour) {
eloop.make_counter_clockwise();
entities.append(children.entities);
entities.append(eloop);
} else {
eloop.make_clockwise();
entities.append(eloop);
entities.append(children.entities);
}
}
}
return entities;
}
ExtrusionEntityCollection
PerimeterGenerator::_fill_gaps(double min, double max, double w,
const Polygons &gaps) const
{
ExtrusionEntityCollection coll;
min *= (1 - INSET_OVERLAP_TOLERANCE);
ExPolygons curr = diff_ex(
offset2(gaps, -min/2, +min/2),
offset2(gaps, -max/2, +max/2),
true
);
Polylines polylines;
for (ExPolygons::const_iterator ex = curr.begin(); ex != curr.end(); ++ex)
ex->medial_axis(max, min/2, &polylines);
if (polylines.empty())
return coll;
#ifdef SLIC3R_DEBUG
if (!curr.empty())
printf(" %zu gaps filled with extrusion width = %f\n", curr.size(), w);
#endif
//my $flow = $layerm->flow(FLOW_ROLE_SOLID_INFILL, 0, $w);
Flow flow(
w, this->layer_height, this->solid_infill_flow.nozzle_diameter
);
double mm3_per_mm = flow.mm3_per_mm();
for (Polylines::const_iterator p = polylines.begin(); p != polylines.end(); ++p) {
ExtrusionPath path(erGapFill);
path.polyline = *p;
path.mm3_per_mm = mm3_per_mm;
path.width = flow.width;
path.height = this->layer_height;
if (p->is_valid() && p->first_point().coincides_with(p->last_point())) {
// since medial_axis() now returns only Polyline objects, detect loops here
ExtrusionLoop loop;
loop.paths.push_back(path);
coll.append(loop);
} else {
coll.append(path);
}
}
return coll;
}
#ifdef SLIC3RXS
REGISTER_CLASS(PerimeterGenerator, "Layer::PerimeterGenerator");
#endif
bool
PerimeterGeneratorLoop::is_external() const
{
return this->depth == 0;
}
bool
PerimeterGeneratorLoop::is_internal_contour() const
{
if (this->is_contour) {
// an internal contour is a contour containing no other contours
for (std::vector<PerimeterGeneratorLoop>::const_iterator loop = this->children.begin();
loop != this->children.end(); ++loop) {
if (loop->is_contour) {
return false;
}
}
return true;
}
return false;
}
}

84
xs/src/libslic3r/PerimeterGenerator.hpp Normal file
View file

@ -0,0 +1,84 @@
#ifndef slic3r_PerimeterGenerator_hpp_
#define slic3r_PerimeterGenerator_hpp_
#include <myinit.h>
#include <vector>
#include "ExPolygonCollection.hpp"
#include "Flow.hpp"
#include "Polygon.hpp"
#include "PrintConfig.hpp"
#include "SurfaceCollection.hpp"
namespace Slic3r {
class PerimeterGeneratorLoop;
typedef std::vector<PerimeterGeneratorLoop> PerimeterGeneratorLoops;
class PerimeterGeneratorLoop {
public:
Polygon polygon;
bool is_contour;
unsigned short depth;
std::vector<PerimeterGeneratorLoop> children;
PerimeterGeneratorLoop(Polygon polygon, unsigned short depth)
: polygon(polygon), depth(depth), is_contour(false)
{};
bool is_external() const;
bool is_internal_contour() const;
};
class PerimeterGenerator {
public:
const SurfaceCollection* slices;
const ExPolygonCollection* lower_slices;
double layer_height;
int layer_id;
Flow perimeter_flow;
Flow ext_perimeter_flow;
Flow overhang_flow;
Flow solid_infill_flow;
PrintRegionConfig* config;
PrintObjectConfig* object_config;
PrintConfig* print_config;
ExtrusionEntityCollection* loops;
ExtrusionEntityCollection* gap_fill;
SurfaceCollection* fill_surfaces;
PerimeterGenerator(const SurfaceCollection* slices, double layer_height, Flow flow,
PrintRegionConfig* config, PrintObjectConfig* object_config,
PrintConfig* print_config, ExtrusionEntityCollection* loops,
ExtrusionEntityCollection* gap_fill, SurfaceCollection* fill_surfaces)
: slices(slices), lower_slices(NULL), layer_height(layer_height),
perimeter_flow(flow), ext_perimeter_flow(flow), overhang_flow(flow),
solid_infill_flow(flow), layer_id(-1),
config(config), object_config(object_config), print_config(print_config),
loops(loops), gap_fill(gap_fill), fill_surfaces(fill_surfaces),
_ext_mm3_per_mm(-1), _mm3_per_mm(-1), _mm3_per_mm_overhang(-1)
{};
void process();
private:
double _ext_mm3_per_mm;
double _mm3_per_mm;
double _mm3_per_mm_overhang;
Polygons _lower_slices_p;
ExtrusionEntityCollection _traverse_loops(const PerimeterGeneratorLoops &loops,
Polylines &thin_walls) const;
ExtrusionEntityCollection _fill_gaps(double min, double max, double w,
const Polygons &gaps) const;
};
class PerimeterGeneratorGapSize {
public:
coord_t min;
coord_t max;
coord_t width;
PerimeterGeneratorGapSize(coord_t min, coord_t max, coord_t width)
: min(min), max(max), width(width) {};
};
}
#endif

87
xs/src/libslic3r/PlaceholderParser.cpp
View file

@ -2,14 +2,16 @@
#include <ctime>
#include <iomanip>
#include <sstream>
#include <unistd.h> // provides **environ
extern char **environ;
namespace Slic3r {
PlaceholderParser::PlaceholderParser()
{
this->_single["version"] = SLIC3R_VERSION;
// TODO: port these methods to C++, then call them here
// this->apply_env_variables();
this->set("version", SLIC3R_VERSION);
this->apply_env_variables();
this->update_timestamp();
}
@ -62,16 +64,32 @@ void PlaceholderParser::apply_config(DynamicPrintConfig &config)
if (const ConfigOptionVectorBase* optv = dynamic_cast<const ConfigOptionVectorBase*>(opt)) {
// set placeholders for options with multiple values
// TODO: treat [bed_shape] as single, not multiple
this->set(key, optv->vserialize());
} else if (const ConfigOptionPoint* optp = dynamic_cast<const ConfigOptionPoint*>(opt)) {
this->_single[key] = optp->serialize();
this->set(key, optp->serialize());
Pointf val = *optp;
this->_multiple[key + "_X"] = val.x;
this->_multiple[key + "_Y"] = val.y;
this->set(key + "_X", val.x);
this->set(key + "_Y", val.y);
} else {
// set single-value placeholders
this->_single[key] = opt->serialize();
this->set(key, opt->serialize());
}
}
}
void
PlaceholderParser::apply_env_variables()
{
for (char** env = environ; *env; env++) {
if (strncmp(*env, "SLIC3R_", 7) == 0) {
std::stringstream ss(*env);
std::string key, value;
std::getline(ss, key, '=');
ss >> value;
this->set(key, value);
}
}
}
@ -92,18 +110,57 @@ PlaceholderParser::set(const std::string &key, int value)
}
void
PlaceholderParser::set(const std::string &key, const std::vector<std::string> &values)
PlaceholderParser::set(const std::string &key, std::vector<std::string> values)
{
for (std::vector<std::string>::const_iterator v = values.begin(); v != values.end(); ++v) {
if (values.empty()) {
this->_multiple.erase(key);
this->_single.erase(key);
} else {
this->_multiple[key] = values;
this->_single[key] = values.front();
}
}
std::string
PlaceholderParser::process(std::string str) const
{
// replace single options, like [foo]
for (t_strstr_map::const_iterator it = this->_single.begin(); it != this->_single.end(); ++it) {
std::stringstream ss;
ss << key << "_" << (v - values.begin());
this->_multiple[ ss.str() ] = *v;
if (v == values.begin()) {
this->_multiple[key] = *v;
ss << '[' << it->first << ']';
this->find_and_replace(str, ss.str(), it->second);
}
// replace multiple options like [foo_0] by looping until we have enough values
// or until a previous match was found (this handles non-existing indices reasonably
// without a regex)
for (t_strstrs_map::const_iterator it = this->_multiple.begin(); it != this->_multiple.end(); ++it) {
const std::vector<std::string> &values = it->second;
bool found = false;
for (size_t i = 0; (i < values.size()) || found; ++i) {
std::stringstream ss;
ss << '[' << it->first << '_' << i << ']';
if (i < values.size()) {
found = this->find_and_replace(str, ss.str(), values[i]);
} else {
found = this->find_and_replace(str, ss.str(), values.front());
}
}
}
this->_single.erase(key);
return str;
}
bool
PlaceholderParser::find_and_replace(std::string &source, std::string const &find, std::string const &replace) const
{
bool found = false;
for (std::string::size_type i = 0; (i = source.find(find, i)) != std::string::npos; ) {
source.replace(i, find.length(), replace);
i += replace.length();
found = true;
}
return found;
}
#ifdef SLIC3RXS

16
xs/src/libslic3r/PlaceholderParser.hpp
View file

@ -11,18 +11,26 @@
namespace Slic3r {
typedef std::map<std::string, std::string> t_strstr_map;
typedef std::map<std::string, std::vector<std::string> > t_strstrs_map;
class PlaceholderParser
{
public:
std::map<std::string, std::string> _single;
std::map<std::string, std::string> _multiple;
t_strstr_map _single;
t_strstrs_map _multiple;
PlaceholderParser();
void update_timestamp();
void apply_config(DynamicPrintConfig &config);
void apply_env_variables();
void set(const std::string &key, const std::string &value);
void set(const std::string &key, int value);
void set(const std::string &key, const std::vector<std::string> &values);
void set(const std::string &key, std::vector<std::string> values);
std::string process(std::string str) const;
private:
bool find_and_replace(std::string &source, std::string const &find, std::string const &replace) const;
};
}

6
xs/src/libslic3r/Polygon.cpp
View file

@ -218,7 +218,8 @@ Polygon::wkt() const
return wkt.str();
}
// find all concave vertices (i.e. having an internal angle greater than the supplied angle) */
// find all concave vertices (i.e. having an internal angle greater than the supplied angle)
// (external = right side, thus we consider ccw orientation)
Points
Polygon::concave_points(double angle) const
{
@ -241,7 +242,8 @@ Polygon::concave_points(double angle) const
return points;
}
// find all convex vertices (i.e. having an internal angle smaller than the supplied angle) */
// find all convex vertices (i.e. having an internal angle smaller than the supplied angle)
// (external = right side, thus we consider ccw orientation)
Points
Polygon::convex_points(double angle) const
{

6
xs/src/libslic3r/PolylineCollection.cpp
View file

@ -50,6 +50,12 @@ PolylineCollection::leftmost_point() const
return p;
}
void
PolylineCollection::append(const Polylines &pp)
{
this->polylines.insert(this->polylines.end(), pp.begin(), pp.end());
}
#ifdef SLIC3RXS
REGISTER_CLASS(PolylineCollection, "Polyline::Collection");
#endif

1
xs/src/libslic3r/PolylineCollection.hpp
View file

@ -13,6 +13,7 @@ class PolylineCollection
void chained_path(PolylineCollection* retval, bool no_reverse = false) const;
void chained_path_from(Point start_near, PolylineCollection* retval, bool no_reverse = false) const;
Point leftmost_point() const;
void append(const Polylines &polylines);
};
}

3
xs/src/libslic3r/Print.hpp
View file

@ -61,7 +61,7 @@ class PrintRegion
private:
Print* _print;
PrintRegion(Print* print);
~PrintRegion();
};
@ -135,6 +135,7 @@ class PrintObject
bool invalidate_all_steps();
bool has_support_material() const;
void process_external_surfaces();
void bridge_over_infill();
private:

42
xs/src/libslic3r/PrintConfig.cpp
View file

@ -151,10 +151,11 @@ PrintConfigDef::build_def() {
Options["external_perimeter_speed"].type = coFloatOrPercent;
Options["external_perimeter_speed"].label = "External perimeters";
Options["external_perimeter_speed"].category = "Speed";
Options["external_perimeter_speed"].tooltip = "This separate setting will affect the speed of external perimeters (the visible ones). If expressed as percentage (for example: 80%) it will be calculated on the perimeters speed setting above.";
Options["external_perimeter_speed"].tooltip = "This separate setting will affect the speed of external perimeters (the visible ones). If expressed as percentage (for example: 80%) it will be calculated on the perimeters speed setting above. Set to zero for auto.";
Options["external_perimeter_speed"].sidetext = "mm/s or %";
Options["external_perimeter_speed"].cli = "external-perimeter-speed=s";
Options["external_perimeter_speed"].ratio_over = "perimeter_speed";
Options["external_perimeter_speed"].min = 0;
Options["external_perimeters_first"].type = coBool;
Options["external_perimeters_first"].label = "External perimeters first";
@ -300,6 +301,7 @@ PrintConfigDef::build_def() {
Options["fill_pattern"].cli = "fill-pattern=s";
Options["fill_pattern"].enum_keys_map = ConfigOptionEnum<InfillPattern>::get_enum_values();
Options["fill_pattern"].enum_values.push_back("rectilinear");
Options["fill_pattern"].enum_values.push_back("grid");
Options["fill_pattern"].enum_values.push_back("line");
Options["fill_pattern"].enum_values.push_back("concentric");
Options["fill_pattern"].enum_values.push_back("honeycomb");
@ -308,6 +310,7 @@ PrintConfigDef::build_def() {
Options["fill_pattern"].enum_values.push_back("archimedeanchords");
Options["fill_pattern"].enum_values.push_back("octagramspiral");
Options["fill_pattern"].enum_labels.push_back("Rectilinear");
Options["fill_pattern"].enum_labels.push_back("Grid");
Options["fill_pattern"].enum_labels.push_back("Line");
Options["fill_pattern"].enum_labels.push_back("Concentric");
Options["fill_pattern"].enum_labels.push_back("Honeycomb");
@ -350,6 +353,7 @@ PrintConfigDef::build_def() {
Options["first_layer_speed"].tooltip = "If expressed as absolute value in mm/s, this speed will be applied to all the print moves of the first layer, regardless of their type. If expressed as a percentage (for example: 40%) it will scale the default speeds.";
Options["first_layer_speed"].sidetext = "mm/s or %";
Options["first_layer_speed"].cli = "first-layer-speed=s";
Options["first_layer_speed"].min = 0;
Options["first_layer_temperature"].type = coInts;
Options["first_layer_temperature"].label = "First layer";
@ -448,7 +452,7 @@ PrintConfigDef::build_def() {
Options["infill_speed"].type = coFloat;
Options["infill_speed"].label = "Infill";
Options["infill_speed"].category = "Speed";
Options["infill_speed"].tooltip = "Speed for printing the internal fill.";
Options["infill_speed"].tooltip = "Speed for printing the internal fill. Set to zero for auto.";
Options["infill_speed"].sidetext = "mm/s";
Options["infill_speed"].cli = "infill-speed=f";
Options["infill_speed"].aliases.push_back("print_feed_rate");
@ -499,7 +503,20 @@ PrintConfigDef::build_def() {
Options["min_print_speed"].sidetext = "mm/s";
Options["min_print_speed"].cli = "min-print-speed=f";
Options["min_print_speed"].min = 0;
Options["min_print_speed"].max = 1000;
Options["max_print_speed"].type = coFloat;
Options["max_print_speed"].label = "Max print speed";
Options["max_print_speed"].tooltip = "When setting other speed settings to 0 Slic3r will autocalculate the optimal speed in order to keep constant extruder pressure. This experimental setting is used to set the highest print speed you want to allow.";
Options["max_print_speed"].sidetext = "mm/s";
Options["max_print_speed"].cli = "max-print-speed=f";
Options["max_print_speed"].min = 1;
Options["max_volumetric_speed"].type = coFloat;
Options["max_volumetric_speed"].label = "Max volumetric speed";
Options["max_volumetric_speed"].tooltip = "This experimental setting is used to set the maximum volumetric speed your extruder supports.";
Options["max_volumetric_speed"].sidetext = "mm³/s";
Options["max_volumetric_speed"].cli = "max-volumetric-speed=f";
Options["max_volumetric_speed"].min = 0;
Options["min_skirt_length"].type = coFloat;
Options["min_skirt_length"].label = "Minimum extrusion length";
@ -579,7 +596,7 @@ PrintConfigDef::build_def() {
Options["perimeter_speed"].type = coFloat;
Options["perimeter_speed"].label = "Perimeters";
Options["perimeter_speed"].category = "Speed";
Options["perimeter_speed"].tooltip = "Speed for perimeters (contours, aka vertical shells).";
Options["perimeter_speed"].tooltip = "Speed for perimeters (contours, aka vertical shells). Set to zero for auto.";
Options["perimeter_speed"].sidetext = "mm/s";
Options["perimeter_speed"].cli = "perimeter-speed=f";
Options["perimeter_speed"].aliases.push_back("perimeter_feed_rate");
@ -637,12 +654,14 @@ PrintConfigDef::build_def() {
Options["retract_length"].type = coFloats;
Options["retract_length"].label = "Length";
Options["retract_length"].full_label = "Retraction Length";
Options["retract_length"].tooltip = "When retraction is triggered, filament is pulled back by the specified amount (the length is measured on raw filament, before it enters the extruder).";
Options["retract_length"].sidetext = "mm (zero to disable)";
Options["retract_length"].cli = "retract-length=f@";
Options["retract_length_toolchange"].type = coFloats;
Options["retract_length_toolchange"].label = "Length";
Options["retract_length_toolchange"].full_label = "Retraction Length (Toolchange)";
Options["retract_length_toolchange"].tooltip = "When retraction is triggered before changing tool, filament is pulled back by the specified amount (the length is measured on raw filament, before it enters the extruder).";
Options["retract_length_toolchange"].sidetext = "mm (zero to disable)";
Options["retract_length_toolchange"].cli = "retract-length-toolchange=f@";
@ -667,10 +686,10 @@ PrintConfigDef::build_def() {
Options["retract_speed"].type = coInts;
Options["retract_speed"].label = "Speed";
Options["retract_speed"].full_label = "Retraction Speed";
Options["retract_speed"].tooltip = "The speed for retractions (it only applies to the extruder motor).";
Options["retract_speed"].sidetext = "mm/s";
Options["retract_speed"].cli = "retract-speed=f@";
Options["retract_speed"].max = 1000;
Options["seam_position"].type = coEnum;
Options["seam_position"].label = "Seam position";
@ -719,6 +738,7 @@ PrintConfigDef::build_def() {
Options["skirts"].type = coInt;
Options["skirts"].label = "Loops (minimum)";
Options["skirts"].full_label = "Skirt Loops";
Options["skirts"].tooltip = "Number of loops for the skirt. If the Minimum Extrusion Length option is set, the number of loops might be greater than the one configured here. Set this to zero to disable skirt completely.";
Options["skirts"].cli = "skirts=i";
Options["skirts"].min = 0;
@ -735,10 +755,11 @@ PrintConfigDef::build_def() {
Options["small_perimeter_speed"].type = coFloatOrPercent;
Options["small_perimeter_speed"].label = "Small perimeters";
Options["small_perimeter_speed"].category = "Speed";
Options["small_perimeter_speed"].tooltip = "This separate setting will affect the speed of perimeters having radius <= 6.5mm (usually holes). If expressed as percentage (for example: 80%) it will be calculated on the perimeters speed setting above.";
Options["small_perimeter_speed"].tooltip = "This separate setting will affect the speed of perimeters having radius <= 6.5mm (usually holes). If expressed as percentage (for example: 80%) it will be calculated on the perimeters speed setting above. Set to zero for auto.";
Options["small_perimeter_speed"].sidetext = "mm/s or %";
Options["small_perimeter_speed"].cli = "small-perimeter-speed=s";
Options["small_perimeter_speed"].ratio_over = "perimeter_speed";
Options["small_perimeter_speed"].min = 0;
Options["solid_infill_below_area"].type = coFloat;
Options["solid_infill_below_area"].label = "Solid infill threshold area";
@ -773,11 +794,12 @@ PrintConfigDef::build_def() {
Options["solid_infill_speed"].type = coFloatOrPercent;
Options["solid_infill_speed"].label = "Solid infill";
Options["solid_infill_speed"].category = "Speed";
Options["solid_infill_speed"].tooltip = "Speed for printing solid regions (top/bottom/internal horizontal shells). This can be expressed as a percentage (for example: 80%) over the default infill speed above.";
Options["solid_infill_speed"].tooltip = "Speed for printing solid regions (top/bottom/internal horizontal shells). This can be expressed as a percentage (for example: 80%) over the default infill speed above. Set to zero for auto.";
Options["solid_infill_speed"].sidetext = "mm/s or %";
Options["solid_infill_speed"].cli = "solid-infill-speed=s";
Options["solid_infill_speed"].ratio_over = "infill_speed";
Options["solid_infill_speed"].aliases.push_back("solid_infill_feed_rate");
Options["solid_infill_speed"].min = 0;
Options["solid_layers"].type = coInt;
Options["solid_layers"].label = "Solid layers";
@ -889,6 +911,7 @@ PrintConfigDef::build_def() {
Options["support_material_interface_speed"].sidetext = "mm/s or %";
Options["support_material_interface_speed"].cli = "support-material-interface-speed=s";
Options["support_material_interface_speed"].ratio_over = "support_material_speed";
Options["support_material_interface_speed"].min = 0;
Options["support_material_pattern"].type = coEnum;
Options["support_material_pattern"].label = "Pattern";
@ -970,10 +993,11 @@ PrintConfigDef::build_def() {
Options["top_solid_infill_speed"].type = coFloatOrPercent;
Options["top_solid_infill_speed"].label = "Top solid infill";
Options["top_solid_infill_speed"].category = "Speed";
Options["top_solid_infill_speed"].tooltip = "Speed for printing top solid layers (it only applies to the uppermost external layers and not to their internal solid layers). You may want to slow down this to get a nicer surface finish. This can be expressed as a percentage (for example: 80%) over the solid infill speed above.";
Options["top_solid_infill_speed"].tooltip = "Speed for printing top solid layers (it only applies to the uppermost external layers and not to their internal solid layers). You may want to slow down this to get a nicer surface finish. This can be expressed as a percentage (for example: 80%) over the solid infill speed above. Set to zero for auto.";
Options["top_solid_infill_speed"].sidetext = "mm/s or %";
Options["top_solid_infill_speed"].cli = "top-solid-infill-speed=s";
Options["top_solid_infill_speed"].ratio_over = "solid_infill_speed";
Options["top_solid_infill_speed"].min = 0;
Options["top_solid_layers"].type = coInt;
Options["top_solid_layers"].label = "Top";
@ -989,7 +1013,7 @@ PrintConfigDef::build_def() {
Options["travel_speed"].sidetext = "mm/s";
Options["travel_speed"].cli = "travel-speed=f";
Options["travel_speed"].aliases.push_back("travel_feed_rate");
Options["travel_speed"].min = 0;
Options["travel_speed"].min = 1;
Options["use_firmware_retraction"].type = coBool;
Options["use_firmware_retraction"].label = "Use firmware retraction";

271
xs/src/libslic3r/PrintConfig.hpp
View file

@ -3,6 +3,8 @@
#include "Config.hpp"
#define OPT_PTR(KEY) if (opt_key == #KEY) return &this->KEY
namespace Slic3r {
enum GCodeFlavor {
@ -10,7 +12,7 @@ enum GCodeFlavor {
};
enum InfillPattern {
ipRectilinear, ipLine, ipConcentric, ipHoneycomb, ip3DHoneycomb,
ipRectilinear, ipGrid, ipLine, ipConcentric, ipHoneycomb, ip3DHoneycomb,
ipHilbertCurve, ipArchimedeanChords, ipOctagramSpiral,
};
@ -37,6 +39,7 @@ template<> inline t_config_enum_values ConfigOptionEnum<GCodeFlavor>::get_enum_v
template<> inline t_config_enum_values ConfigOptionEnum<InfillPattern>::get_enum_values() {
t_config_enum_values keys_map;
keys_map["rectilinear"] = ipRectilinear;
keys_map["grid"] = ipGrid;
keys_map["line"] = ipLine;
keys_map["concentric"] = ipConcentric;
keys_map["honeycomb"] = ipHoneycomb;
@ -148,29 +151,29 @@ class PrintObjectConfig : public virtual StaticPrintConfig
};
ConfigOption* option(const t_config_option_key opt_key, bool create = false) {
if (opt_key == "dont_support_bridges") return &this->dont_support_bridges;
if (opt_key == "extrusion_width") return &this->extrusion_width;
if (opt_key == "first_layer_height") return &this->first_layer_height;
if (opt_key == "infill_only_where_needed") return &this->infill_only_where_needed;
if (opt_key == "interface_shells") return &this->interface_shells;
if (opt_key == "layer_height") return &this->layer_height;
if (opt_key == "raft_layers") return &this->raft_layers;
if (opt_key == "seam_position") return &this->seam_position;
if (opt_key == "support_material") return &this->support_material;
if (opt_key == "support_material_angle") return &this->support_material_angle;
if (opt_key == "support_material_contact_distance") return &this->support_material_contact_distance;
if (opt_key == "support_material_enforce_layers") return &this->support_material_enforce_layers;
if (opt_key == "support_material_extruder") return &this->support_material_extruder;
if (opt_key == "support_material_extrusion_width") return &this->support_material_extrusion_width;
if (opt_key == "support_material_interface_extruder") return &this->support_material_interface_extruder;
if (opt_key == "support_material_interface_layers") return &this->support_material_interface_layers;
if (opt_key == "support_material_interface_spacing") return &this->support_material_interface_spacing;
if (opt_key == "support_material_interface_speed") return &this->support_material_interface_speed;
if (opt_key == "support_material_pattern") return &this->support_material_pattern;
if (opt_key == "support_material_spacing") return &this->support_material_spacing;
if (opt_key == "support_material_speed") return &this->support_material_speed;
if (opt_key == "support_material_threshold") return &this->support_material_threshold;
if (opt_key == "xy_size_compensation") return &this->xy_size_compensation;
OPT_PTR(dont_support_bridges);
OPT_PTR(extrusion_width);
OPT_PTR(first_layer_height);
OPT_PTR(infill_only_where_needed);
OPT_PTR(interface_shells);
OPT_PTR(layer_height);
OPT_PTR(raft_layers);
OPT_PTR(seam_position);
OPT_PTR(support_material);
OPT_PTR(support_material_angle);
OPT_PTR(support_material_contact_distance);
OPT_PTR(support_material_enforce_layers);
OPT_PTR(support_material_extruder);
OPT_PTR(support_material_extrusion_width);
OPT_PTR(support_material_interface_extruder);
OPT_PTR(support_material_interface_layers);
OPT_PTR(support_material_interface_spacing);
OPT_PTR(support_material_interface_speed);
OPT_PTR(support_material_pattern);
OPT_PTR(support_material_spacing);
OPT_PTR(support_material_speed);
OPT_PTR(support_material_threshold);
OPT_PTR(xy_size_compensation);
return NULL;
};
@ -258,38 +261,38 @@ class PrintRegionConfig : public virtual StaticPrintConfig
};
ConfigOption* option(const t_config_option_key opt_key, bool create = false) {
if (opt_key == "bottom_solid_layers") return &this->bottom_solid_layers;
if (opt_key == "bridge_flow_ratio") return &this->bridge_flow_ratio;
if (opt_key == "bridge_speed") return &this->bridge_speed;
if (opt_key == "external_fill_pattern") return &this->external_fill_pattern;
if (opt_key == "external_perimeter_extrusion_width") return &this->external_perimeter_extrusion_width;
if (opt_key == "external_perimeter_speed") return &this->external_perimeter_speed;
if (opt_key == "external_perimeters_first") return &this->external_perimeters_first;
if (opt_key == "extra_perimeters") return &this->extra_perimeters;
if (opt_key == "fill_angle") return &this->fill_angle;
if (opt_key == "fill_density") return &this->fill_density;
if (opt_key == "fill_pattern") return &this->fill_pattern;
if (opt_key == "gap_fill_speed") return &this->gap_fill_speed;
if (opt_key == "infill_extruder") return &this->infill_extruder;
if (opt_key == "infill_extrusion_width") return &this->infill_extrusion_width;
if (opt_key == "infill_every_layers") return &this->infill_every_layers;
if (opt_key == "infill_overlap") return &this->infill_overlap;
if (opt_key == "infill_speed") return &this->infill_speed;
if (opt_key == "overhangs") return &this->overhangs;
if (opt_key == "perimeter_extruder") return &this->perimeter_extruder;
if (opt_key == "perimeter_extrusion_width") return &this->perimeter_extrusion_width;
if (opt_key == "perimeter_speed") return &this->perimeter_speed;
if (opt_key == "perimeters") return &this->perimeters;
if (opt_key == "small_perimeter_speed") return &this->small_perimeter_speed;
if (opt_key == "solid_infill_below_area") return &this->solid_infill_below_area;
if (opt_key == "solid_infill_extruder") return &this->solid_infill_extruder;
if (opt_key == "solid_infill_extrusion_width") return &this->solid_infill_extrusion_width;
if (opt_key == "solid_infill_every_layers") return &this->solid_infill_every_layers;
if (opt_key == "solid_infill_speed") return &this->solid_infill_speed;
if (opt_key == "thin_walls") return &this->thin_walls;
if (opt_key == "top_infill_extrusion_width") return &this->top_infill_extrusion_width;
if (opt_key == "top_solid_infill_speed") return &this->top_solid_infill_speed;
if (opt_key == "top_solid_layers") return &this->top_solid_layers;
OPT_PTR(bottom_solid_layers);
OPT_PTR(bridge_flow_ratio);
OPT_PTR(bridge_speed);
OPT_PTR(external_fill_pattern);
OPT_PTR(external_perimeter_extrusion_width);
OPT_PTR(external_perimeter_speed);
OPT_PTR(external_perimeters_first);
OPT_PTR(extra_perimeters);
OPT_PTR(fill_angle);
OPT_PTR(fill_density);
OPT_PTR(fill_pattern);
OPT_PTR(gap_fill_speed);
OPT_PTR(infill_extruder);
OPT_PTR(infill_extrusion_width);
OPT_PTR(infill_every_layers);
OPT_PTR(infill_overlap);
OPT_PTR(infill_speed);
OPT_PTR(overhangs);
OPT_PTR(perimeter_extruder);
OPT_PTR(perimeter_extrusion_width);
OPT_PTR(perimeter_speed);
OPT_PTR(perimeters);
OPT_PTR(small_perimeter_speed);
OPT_PTR(solid_infill_below_area);
OPT_PTR(solid_infill_extruder);
OPT_PTR(solid_infill_extrusion_width);
OPT_PTR(solid_infill_every_layers);
OPT_PTR(solid_infill_speed);
OPT_PTR(thin_walls);
OPT_PTR(top_infill_extrusion_width);
OPT_PTR(top_solid_infill_speed);
OPT_PTR(top_solid_layers);
return NULL;
};
@ -306,6 +309,8 @@ class GCodeConfig : public virtual StaticPrintConfig
ConfigOptionBool gcode_comments;
ConfigOptionEnum<GCodeFlavor> gcode_flavor;
ConfigOptionString layer_gcode;
ConfigOptionFloat max_print_speed;
ConfigOptionFloat max_volumetric_speed;
ConfigOptionFloat pressure_advance;
ConfigOptionFloats retract_length;
ConfigOptionFloats retract_length_toolchange;
@ -331,6 +336,8 @@ class GCodeConfig : public virtual StaticPrintConfig
this->gcode_comments.value = false;
this->gcode_flavor.value = gcfRepRap;
this->layer_gcode.value = "";
this->max_print_speed.value = 80;
this->max_volumetric_speed.value = 0;
this->pressure_advance.value = 0;
this->retract_length.values.resize(1);
this->retract_length.values[0] = 2;
@ -353,27 +360,29 @@ class GCodeConfig : public virtual StaticPrintConfig
};
ConfigOption* option(const t_config_option_key opt_key, bool create = false) {
if (opt_key == "before_layer_gcode") return &this->before_layer_gcode;
if (opt_key == "end_gcode") return &this->end_gcode;
if (opt_key == "extrusion_axis") return &this->extrusion_axis;
if (opt_key == "extrusion_multiplier") return &this->extrusion_multiplier;
if (opt_key == "filament_diameter") return &this->filament_diameter;
if (opt_key == "gcode_comments") return &this->gcode_comments;
if (opt_key == "gcode_flavor") return &this->gcode_flavor;
if (opt_key == "layer_gcode") return &this->layer_gcode;
if (opt_key == "pressure_advance") return &this->pressure_advance;
if (opt_key == "retract_length") return &this->retract_length;
if (opt_key == "retract_length_toolchange") return &this->retract_length_toolchange;
if (opt_key == "retract_lift") return &this->retract_lift;
if (opt_key == "retract_restart_extra") return &this->retract_restart_extra;
if (opt_key == "retract_restart_extra_toolchange") return &this->retract_restart_extra_toolchange;
if (opt_key == "retract_speed") return &this->retract_speed;
if (opt_key == "start_gcode") return &this->start_gcode;
if (opt_key == "toolchange_gcode") return &this->toolchange_gcode;
if (opt_key == "travel_speed") return &this->travel_speed;
if (opt_key == "use_firmware_retraction") return &this->use_firmware_retraction;
if (opt_key == "use_relative_e_distances") return &this->use_relative_e_distances;
if (opt_key == "use_volumetric_e") return &this->use_volumetric_e;
OPT_PTR(before_layer_gcode);
OPT_PTR(end_gcode);
OPT_PTR(extrusion_axis);
OPT_PTR(extrusion_multiplier);
OPT_PTR(filament_diameter);
OPT_PTR(gcode_comments);
OPT_PTR(gcode_flavor);
OPT_PTR(layer_gcode);
OPT_PTR(max_print_speed);
OPT_PTR(max_volumetric_speed);
OPT_PTR(pressure_advance);
OPT_PTR(retract_length);
OPT_PTR(retract_length_toolchange);
OPT_PTR(retract_lift);
OPT_PTR(retract_restart_extra);
OPT_PTR(retract_restart_extra_toolchange);
OPT_PTR(retract_speed);
OPT_PTR(start_gcode);
OPT_PTR(toolchange_gcode);
OPT_PTR(travel_speed);
OPT_PTR(use_firmware_retraction);
OPT_PTR(use_relative_e_distances);
OPT_PTR(use_volumetric_e);
return NULL;
};
@ -510,56 +519,56 @@ class PrintConfig : public GCodeConfig
};
ConfigOption* option(const t_config_option_key opt_key, bool create = false) {
if (opt_key == "avoid_crossing_perimeters") return &this->avoid_crossing_perimeters;
if (opt_key == "bed_shape") return &this->bed_shape;
if (opt_key == "bed_temperature") return &this->bed_temperature;
if (opt_key == "bridge_acceleration") return &this->bridge_acceleration;
if (opt_key == "bridge_fan_speed") return &this->bridge_fan_speed;
if (opt_key == "brim_width") return &this->brim_width;
if (opt_key == "complete_objects") return &this->complete_objects;
if (opt_key == "cooling") return &this->cooling;
if (opt_key == "default_acceleration") return &this->default_acceleration;
if (opt_key == "disable_fan_first_layers") return &this->disable_fan_first_layers;
if (opt_key == "duplicate_distance") return &this->duplicate_distance;
if (opt_key == "extruder_clearance_height") return &this->extruder_clearance_height;
if (opt_key == "extruder_clearance_radius") return &this->extruder_clearance_radius;
if (opt_key == "extruder_offset") return &this->extruder_offset;
if (opt_key == "fan_always_on") return &this->fan_always_on;
if (opt_key == "fan_below_layer_time") return &this->fan_below_layer_time;
if (opt_key == "filament_colour") return &this->filament_colour;
if (opt_key == "first_layer_acceleration") return &this->first_layer_acceleration;
if (opt_key == "first_layer_bed_temperature") return &this->first_layer_bed_temperature;
if (opt_key == "first_layer_extrusion_width") return &this->first_layer_extrusion_width;
if (opt_key == "first_layer_speed") return &this->first_layer_speed;
if (opt_key == "first_layer_temperature") return &this->first_layer_temperature;
if (opt_key == "gcode_arcs") return &this->gcode_arcs;
if (opt_key == "infill_acceleration") return &this->infill_acceleration;
if (opt_key == "infill_first") return &this->infill_first;
if (opt_key == "max_fan_speed") return &this->max_fan_speed;
if (opt_key == "min_fan_speed") return &this->min_fan_speed;
if (opt_key == "min_print_speed") return &this->min_print_speed;
if (opt_key == "min_skirt_length") return &this->min_skirt_length;
if (opt_key == "notes") return &this->notes;
if (opt_key == "nozzle_diameter") return &this->nozzle_diameter;
if (opt_key == "only_retract_when_crossing_perimeters") return &this->only_retract_when_crossing_perimeters;
if (opt_key == "ooze_prevention") return &this->ooze_prevention;
if (opt_key == "output_filename_format") return &this->output_filename_format;
if (opt_key == "perimeter_acceleration") return &this->perimeter_acceleration;
if (opt_key == "post_process") return &this->post_process;
if (opt_key == "resolution") return &this->resolution;
if (opt_key == "retract_before_travel") return &this->retract_before_travel;
if (opt_key == "retract_layer_change") return &this->retract_layer_change;
if (opt_key == "skirt_distance") return &this->skirt_distance;
if (opt_key == "skirt_height") return &this->skirt_height;
if (opt_key == "skirts") return &this->skirts;
if (opt_key == "slowdown_below_layer_time") return &this->slowdown_below_layer_time;
if (opt_key == "spiral_vase") return &this->spiral_vase;
if (opt_key == "standby_temperature_delta") return &this->standby_temperature_delta;
if (opt_key == "temperature") return &this->temperature;
if (opt_key == "threads") return &this->threads;
if (opt_key == "vibration_limit") return &this->vibration_limit;
if (opt_key == "wipe") return &this->wipe;
if (opt_key == "z_offset") return &this->z_offset;
OPT_PTR(avoid_crossing_perimeters);
OPT_PTR(bed_shape);
OPT_PTR(bed_temperature);
OPT_PTR(bridge_acceleration);
OPT_PTR(bridge_fan_speed);
OPT_PTR(brim_width);
OPT_PTR(complete_objects);
OPT_PTR(cooling);
OPT_PTR(default_acceleration);
OPT_PTR(disable_fan_first_layers);
OPT_PTR(duplicate_distance);
OPT_PTR(extruder_clearance_height);
OPT_PTR(extruder_clearance_radius);
OPT_PTR(extruder_offset);
OPT_PTR(fan_always_on);
OPT_PTR(fan_below_layer_time);
OPT_PTR(filament_colour);
OPT_PTR(first_layer_acceleration);
OPT_PTR(first_layer_bed_temperature);
OPT_PTR(first_layer_extrusion_width);
OPT_PTR(first_layer_speed);
OPT_PTR(first_layer_temperature);
OPT_PTR(gcode_arcs);
OPT_PTR(infill_acceleration);
OPT_PTR(infill_first);
OPT_PTR(max_fan_speed);
OPT_PTR(min_fan_speed);
OPT_PTR(min_print_speed);
OPT_PTR(min_skirt_length);
OPT_PTR(notes);
OPT_PTR(nozzle_diameter);
OPT_PTR(only_retract_when_crossing_perimeters);
OPT_PTR(ooze_prevention);
OPT_PTR(output_filename_format);
OPT_PTR(perimeter_acceleration);
OPT_PTR(post_process);
OPT_PTR(resolution);
OPT_PTR(retract_before_travel);
OPT_PTR(retract_layer_change);
OPT_PTR(skirt_distance);
OPT_PTR(skirt_height);
OPT_PTR(skirts);
OPT_PTR(slowdown_below_layer_time);
OPT_PTR(spiral_vase);
OPT_PTR(standby_temperature_delta);
OPT_PTR(temperature);
OPT_PTR(threads);
OPT_PTR(vibration_limit);
OPT_PTR(wipe);
OPT_PTR(z_offset);
// look in parent class
ConfigOption* opt;
@ -585,10 +594,10 @@ class HostConfig : public virtual StaticPrintConfig
};
ConfigOption* option(const t_config_option_key opt_key, bool create = false) {
if (opt_key == "octoprint_host") return &this->octoprint_host;
if (opt_key == "octoprint_apikey") return &this->octoprint_apikey;
if (opt_key == "serial_port") return &this->serial_port;
if (opt_key == "serial_speed") return &this->serial_speed;
OPT_PTR(octoprint_host);
OPT_PTR(octoprint_apikey);
OPT_PTR(serial_port);
OPT_PTR(serial_speed);
return NULL;
};

84
xs/src/libslic3r/PrintObject.cpp
View file

@ -340,39 +340,97 @@ PrintObject::has_support_material() const
|| this->config.support_material_enforce_layers > 0;
}
void
PrintObject::process_external_surfaces()
{
FOREACH_REGION(this->_print, region) {
size_t region_id = region - this->_print->regions.begin();
FOREACH_LAYER(this, layer_it) {
const Layer* lower_layer = (layer_it == this->layers.begin())
? NULL
: *(layer_it-1);
(*layer_it)->get_region(region_id)->process_external_surfaces(lower_layer);
}
}
}
/* This method applies bridge flow to the first internal solid layer above
sparse infill */
void
PrintObject::bridge_over_infill()
{
FOREACH_REGION(this->_print, region) {
size_t region_id = region - this->_print->regions.begin();
double fill_density = (*region)->config.fill_density.value;
if (fill_density == 100) continue;
// skip bridging in case there are no voids
if ((*region)->config.fill_density.value == 100) continue;
// get bridge flow
Flow bridge_flow = (*region)->flow(
frSolidInfill,
-1, // layer height, not relevant for bridge flow
true, // bridge
false, // first layer
-1, // custom width, not relevant for bridge flow
*this
);
FOREACH_LAYER(this, layer_it) {
// skip first layer
if (layer_it == this->layers.begin()) continue;
Layer* layer = *layer_it;
Layer* lower_layer = *(layer_it - 1);
LayerRegion* layerm = layer->get_region(region_id);
// compute the areas needing bridge math
Polygons internal_solid, lower_internal;
// extract the stInternalSolid surfaces that might be transformed into bridges
Polygons internal_solid;
layerm->fill_surfaces.filter_by_type(stInternalSolid, &internal_solid);
FOREACH_LAYERREGION(lower_layer, lower_layerm_it)
(*lower_layerm_it)->fill_surfaces.filter_by_type(stInternal, &lower_internal);
// check whether the lower area is deep enough for absorbing the extra flow
// (for obvious physical reasons but also for preventing the bridge extrudates
// from overflowing in 3D preview)
ExPolygons to_bridge;
intersection(internal_solid, lower_internal, &to_bridge);
if (to_bridge.empty()) continue;
ExPolygons not_to_bridge;
diff(internal_solid, to_bridge, &not_to_bridge, true);
{
Polygons to_bridge_pp = internal_solid;
// iterate through lower layers spanned by bridge_flow
double bottom_z = layer->print_z - bridge_flow.height;
for (int i = (layer_it - this->layers.begin()) - 1; i >= 0; --i) {
const Layer* lower_layer = this->layers[i];
// stop iterating if layer is lower than bottom_z
if (lower_layer->print_z < bottom_z) break;
// iterate through regions and collect internal surfaces
Polygons lower_internal;
FOREACH_LAYERREGION(lower_layer, lower_layerm_it)
(*lower_layerm_it)->fill_surfaces.filter_by_type(stInternal, &lower_internal);
// intersect such lower internal surfaces with the candidate solid surfaces
to_bridge_pp = intersection(to_bridge_pp, lower_internal);
}
// there's no point in bridging too thin/short regions
{
double min_width = bridge_flow.scaled_width() * 3;
to_bridge_pp = offset2(to_bridge_pp, -min_width, +min_width);
}
if (to_bridge_pp.empty()) continue;
// convert into ExPolygons
to_bridge = union_ex(to_bridge_pp);
}
#ifdef SLIC3R_DEBUG
printf("Bridging %zu internal areas at layer %d\n", to_bridge.size(), layer->id());
printf("Bridging %zu internal areas at layer %zu\n", to_bridge.size(), layer->id());
#endif
// compute the remaning internal solid surfaces as difference
ExPolygons not_to_bridge = diff_ex(internal_solid, to_bridge, true);
// build the new collection of fill_surfaces
{
Surfaces new_surfaces;

5
xs/src/libslic3r/Surface.cpp
View file

@ -2,6 +2,11 @@
namespace Slic3r {
Surface::operator Polygons() const
{
return this->expolygon;
}
double
Surface::area() const
{

1
xs/src/libslic3r/Surface.hpp
View file

@ -21,6 +21,7 @@ class Surface
: surface_type(_surface_type), expolygon(_expolygon),
thickness(-1), thickness_layers(1), bridge_angle(-1), extra_perimeters(0)
{};
operator Polygons() const;
double area() const;
bool is_solid() const;
bool is_external() const;

6
xs/src/libslic3r/SurfaceCollection.cpp
View file

@ -111,6 +111,12 @@ SurfaceCollection::filter_by_type(SurfaceType type, Polygons* polygons)
}
}
void
SurfaceCollection::append(const SurfaceCollection &coll)
{
this->surfaces.insert(this->surfaces.end(), coll.surfaces.begin(), coll.surfaces.end());
}
#ifdef SLIC3RXS
REGISTER_CLASS(SurfaceCollection, "Surface::Collection");
#endif

4
xs/src/libslic3r/SurfaceCollection.hpp
View file

@ -11,6 +11,9 @@ class SurfaceCollection
public:
Surfaces surfaces;
SurfaceCollection() {};
SurfaceCollection(const Surfaces &_surfaces)
: surfaces(_surfaces) {};
operator Polygons() const;
operator ExPolygons() const;
void simplify(double tolerance);
@ -19,6 +22,7 @@ class SurfaceCollection
template <class T> bool any_bottom_contains(const T &item) const;
SurfacesPtr filter_by_type(SurfaceType type);
void filter_by_type(SurfaceType type, Polygons* polygons);
void append(const SurfaceCollection &coll);
};
}

8
xs/src/libslic3r/libslic3r.h
View file

@ -6,11 +6,17 @@
#include <iostream>
#include <sstream>
#define SLIC3R_VERSION "1.2.8-dev"
#define SLIC3R_VERSION "1.2.10-dev"
#define EPSILON 1e-4
#define SCALING_FACTOR 0.000001
#define RESOLUTION 0.0125
#define SCALED_RESOLUTION (RESOLUTION / SCALING_FACTOR)
#define PI 3.141592653589793238
#define LOOP_CLIPPING_LENGTH_OVER_NOZZLE_DIAMETER 0.15
#define SMALL_PERIMETER_LENGTH (6.5 / SCALING_FACTOR) * 2 * PI
#define INSET_OVERLAP_TOLERANCE 0.4
#define EXTERNAL_INFILL_MARGIN 3
#define scale_(val) (val / SCALING_FACTOR)
#define unscale(val) (val * SCALING_FACTOR)
#define SCALED_EPSILON scale_(EPSILON)

1
xs/src/perlglue.hpp
View file

@ -44,6 +44,7 @@ class Ref {
public:
Ref() : val(NULL) {}
Ref(T* t) : val(t) {}
Ref(const T* t) : val(const_cast<T*>(t)) {}
operator T*() const { return val; }
static const char* CLASS() { return ClassTraits<T>::name_ref; }
};