Welcome to mirror list, hosted at ThFree Co, Russian Federation.

github.com/supermerill/SuperSlicer.git - Unnamed repository; edit this file 'description' to name the repository.
summaryrefslogtreecommitdiff
path: root/xs/src/libslic3r
diff options
context:
space:
mode:
Diffstat (limited to 'xs/src/libslic3r')
-rw-r--r--xs/src/libslic3r/Fill/Fill3DHoneycomb.cpp37
-rw-r--r--xs/src/libslic3r/Fill/Fill3DHoneycomb.hpp13
-rw-r--r--xs/src/libslic3r/Fill/FillBase.cpp55
-rw-r--r--xs/src/libslic3r/Fill/FillBase.hpp55
-rw-r--r--xs/src/libslic3r/Fill/FillConcentric.cpp32
-rw-r--r--xs/src/libslic3r/Fill/FillConcentric.hpp8
-rw-r--r--xs/src/libslic3r/Fill/FillHoneycomb.cpp44
-rw-r--r--xs/src/libslic3r/Fill/FillHoneycomb.hpp12
-rw-r--r--xs/src/libslic3r/Fill/FillPlanePath.cpp26
-rw-r--r--xs/src/libslic3r/Fill/FillPlanePath.hpp10
-rw-r--r--xs/src/libslic3r/Fill/FillRectilinear.cpp51
-rw-r--r--xs/src/libslic3r/Fill/FillRectilinear.hpp10
-rw-r--r--xs/src/libslic3r/Fill/FillRectilinear2.cpp592
-rw-r--r--xs/src/libslic3r/Fill/FillRectilinear2.hpp5
14 files changed, 645 insertions, 305 deletions
diff --git a/xs/src/libslic3r/Fill/Fill3DHoneycomb.cpp b/xs/src/libslic3r/Fill/Fill3DHoneycomb.cpp
index ce3fa3c57..a4b8b53c5 100644
--- a/xs/src/libslic3r/Fill/Fill3DHoneycomb.cpp
+++ b/xs/src/libslic3r/Fill/Fill3DHoneycomb.cpp
@@ -87,7 +87,7 @@ static std::vector<Pointfs> makeNormalisedGrid(coordf_t z, size_t gridWidth, siz
// sawtooth wave function for range f($z) = [-$octagramGap .. $octagramGap]
coordf_t a = std::sqrt(coordf_t(2.)); // period
- coordf_t wave = abs(fmod(z, a) - a/2.)/a*4. - 1.;
+ coordf_t wave = fabs(fmod(z, a) - a/2.)/a*4. - 1.;
coordf_t offset = wave * octagramGap;
std::vector<Pointfs> points;
@@ -139,9 +139,14 @@ static Polylines makeGrid(coord_t z, coord_t gridSize, size_t gridWidth, size_t
return result;
}
-Polylines Fill3DHoneycomb::fill_surface(const Surface *surface, const FillParams &params)
+void Fill3DHoneycomb::_fill_surface_single(
+ const FillParams &params,
+ unsigned int thickness_layers,
+ const std::pair<float, Point> &direction,
+ ExPolygon &expolygon,
+ Polylines &polylines_out)
{
- ExPolygon expolygon = surface->expolygon;
+ // no rotation is supported for this infill pattern
BoundingBox bb = expolygon.contour.bounding_box();
Point size = bb.size();
coord_t distance = coord_t(scale_(this->spacing) / params.density);
@@ -149,9 +154,7 @@ Polylines Fill3DHoneycomb::fill_surface(const Surface *surface, const FillParams
// align bounding box to a multiple of our honeycomb grid module
// (a module is 2*$distance since one $distance half-module is
// growing while the other $distance half-module is shrinking)
- bb.merge(Point(
- bb.min.x - (bb.min.x % (2*distance)),
- bb.min.y - (bb.min.y % (2*distance))));
+ bb.merge(_align_to_grid(bb.min, Point(2*distance, 2*distance)));
// generate pattern
Polylines polylines = makeGrid(
@@ -159,7 +162,7 @@ Polylines Fill3DHoneycomb::fill_surface(const Surface *surface, const FillParams
distance,
ceil(size.x / distance) + 1,
ceil(size.y / distance) + 1,
- ((this->layer_id / surface->thickness_layers) % 2) + 1);
+ ((this->layer_id/thickness_layers) % 2) + 1);
// move pattern in place
for (Polylines::iterator it = polylines.begin(); it != polylines.end(); ++ it)
@@ -186,15 +189,11 @@ Polylines Fill3DHoneycomb::fill_surface(const Surface *surface, const FillParams
polylines,
#endif
PolylineCollection::leftmost_point(polylines), false); // reverse allowed
-#if SLIC3R_CPPVER >= 11
- assert(polylines.empty());
-#else
- polylines.clear();
-#endif
+ bool first = true;
for (Polylines::iterator it_polyline = chained.begin(); it_polyline != chained.end(); ++ it_polyline) {
- if (! polylines.empty()) {
+ if (! first) {
// Try to connect the lines.
- Points &pts_end = polylines.back().points;
+ Points &pts_end = polylines_out.back().points;
const Point &first_point = it_polyline->points.front();
const Point &last_point = pts_end.back();
// TODO: we should also check that both points are on a fill_boundary to avoid
@@ -208,16 +207,14 @@ Polylines Fill3DHoneycomb::fill_surface(const Surface *surface, const FillParams
}
// The lines cannot be connected.
#if SLIC3R_CPPVER >= 11
- polylines.push_back(std::move(*it_polyline));
+ polylines_out.push_back(std::move(*it_polyline));
#else
- polylines.push_back(Polyline());
- std::swap(polylines.back(), *it_polyline);
+ polylines_out.push_back(Polyline());
+ std::swap(polylines_out.back(), *it_polyline);
#endif
+ first = false;
}
}
-
- // TODO: return ExtrusionLoop objects to get better chained paths
- return polylines;
}
} // namespace Slic3r
diff --git a/xs/src/libslic3r/Fill/Fill3DHoneycomb.hpp b/xs/src/libslic3r/Fill/Fill3DHoneycomb.hpp
index 1410f5b55..fae5b3c60 100644
--- a/xs/src/libslic3r/Fill/Fill3DHoneycomb.hpp
+++ b/xs/src/libslic3r/Fill/Fill3DHoneycomb.hpp
@@ -9,14 +9,21 @@
namespace Slic3r {
-class Fill3DHoneycomb : public FillWithDirection
+class Fill3DHoneycomb : public Fill
{
public:
virtual ~Fill3DHoneycomb() {}
- virtual Polylines fill_surface(const Surface *surface, const FillParams &params);
-
+
// require bridge flow since most of this pattern hangs in air
virtual bool use_bridge_flow() const { return true; }
+
+protected:
+ virtual void _fill_surface_single(
+ const FillParams &params,
+ unsigned int thickness_layers,
+ const std::pair<float, Point> &direction,
+ ExPolygon &expolygon,
+ Polylines &polylines_out);
};
} // namespace Slic3r
diff --git a/xs/src/libslic3r/Fill/FillBase.cpp b/xs/src/libslic3r/Fill/FillBase.cpp
index c17f57185..a0b351535 100644
--- a/xs/src/libslic3r/Fill/FillBase.cpp
+++ b/xs/src/libslic3r/Fill/FillBase.cpp
@@ -1,3 +1,6 @@
+#include <stdio.h>
+
+#include "../ClipperUtils.hpp"
#include "../Surface.hpp"
#include "FillBase.hpp"
@@ -24,7 +27,8 @@ Fill* Fill::new_from_type(const std::string &type)
if (type == "line")
return new FillLine();
if (type == "grid")
- return new FillGrid();
+// return new FillGrid();
+ return new FillGrid2();
if (type == "archimedeanchords")
return new FillArchimedeanChords();
if (type == "hilbertcurve")
@@ -35,16 +39,39 @@ Fill* Fill::new_from_type(const std::string &type)
return NULL;
}
-coord_t Fill::adjust_solid_spacing(const coord_t width, const coord_t distance)
+Polylines Fill::fill_surface(const Surface *surface, const FillParams &params)
+{
+ // Perform offset.
+ Slic3r::ExPolygons expp;
+ offset(surface->expolygon, &expp, -0.5*scale_(this->spacing));
+ // Create the infills for each of the regions.
+ Polylines polylines_out;
+ for (size_t i = 0; i < expp.size(); ++ i)
+ _fill_surface_single(
+ params,
+ surface->thickness_layers,
+ _infill_direction(surface),
+ expp[i],
+ polylines_out);
+ return polylines_out;
+}
+
+// Calculate a new spacing to fill width with possibly integer number of lines,
+// the first and last line being centered at the interval ends.
+//FIXME Vojtech: This
+// This function possibly increases the spacing, never decreases,
+// and for a narrow width the increase in spacing may become severe!
+coord_t Fill::_adjust_solid_spacing(const coord_t width, const coord_t distance)
{
- coord_t number_of_lines = coord_t(coordf_t(width) / coordf_t(distance)) + 1;
- coord_t extra_space = width % distance;
- return (number_of_lines <= 1) ?
- distance :
- distance + extra_space / (number_of_lines - 1);
+ coord_t number_of_intervals = coord_t(coordf_t(width) / coordf_t(distance));
+ return (number_of_intervals == 0) ?
+ distance :
+ (width / number_of_intervals);
}
-std::pair<float, Point> FillWithDirection::infill_direction(const Surface *surface) const
+// Returns orientation of the infill and the reference point of the infill pattern.
+// For a normal print, the reference point is the center of a bounding box of the STL.
+std::pair<float, Point> Fill::_infill_direction(const Surface *surface) const
{
// set infill angle
float out_angle = this->angle;
@@ -55,10 +82,20 @@ std::pair<float, Point> FillWithDirection::infill_direction(const Surface *surfa
out_angle = 0.f;
}
+ // Bounding box is the bounding box of a perl object Slic3r::Print::Object (c++ object Slic3r::PrintObject)
+ // The bounding box is only undefined in unit tests.
Point out_shift = empty(this->bounding_box) ?
surface->expolygon.contour.bounding_box().center() :
this->bounding_box.center();
+#if 0
+ if (empty(this->bounding_box)) {
+ printf("Fill::_infill_direction: empty bounding box!");
+ } else {
+ printf("Fill::_infill_direction: reference point %d, %d\n", out_shift.x, out_shift.y);
+ }
+#endif
+
if (surface->bridge_angle >= 0) {
// use bridge angle
//FIXME Vojtech: Add a debugf?
@@ -71,7 +108,7 @@ std::pair<float, Point> FillWithDirection::infill_direction(const Surface *surfa
// alternate fill direction
out_angle += this->_layer_angle(this->layer_id / surface->thickness_layers);
} else {
- printf("Layer_ID undefined!\n");
+// printf("Layer_ID undefined!\n");
}
out_angle += float(M_PI/2.);
diff --git a/xs/src/libslic3r/Fill/FillBase.hpp b/xs/src/libslic3r/Fill/FillBase.hpp
index 8fa2bee42..f4c55cbc0 100644
--- a/xs/src/libslic3r/Fill/FillBase.hpp
+++ b/xs/src/libslic3r/Fill/FillBase.hpp
@@ -1,7 +1,9 @@
#ifndef slic3r_FillBase_hpp_
#define slic3r_FillBase_hpp_
+#include <memory.h>
#include <float.h>
+#include <stdint.h>
#include "../libslic3r.h"
#include "../BoundingBox.hpp"
@@ -61,7 +63,7 @@ public:
virtual bool no_sort() const { return false; }
// Perform the fill.
- virtual Polylines fill_surface(const Surface *surface, const FillParams &params) = 0;
+ virtual Polylines fill_surface(const Surface *surface, const FillParams &params);
protected:
Fill() :
@@ -75,7 +77,41 @@ protected:
bounding_box(Point(0, 0), Point(-1, -1))
{}
- static coord_t adjust_solid_spacing(const coord_t width, const coord_t distance);
+ // The expolygon may be modified by the method to avoid a copy.
+ virtual void _fill_surface_single(
+ const FillParams &params,
+ unsigned int thickness_layers,
+ const std::pair<float, Point> &direction,
+ ExPolygon &expolygon,
+ Polylines &polylines_out) {}
+
+ static coord_t _adjust_solid_spacing(const coord_t width, const coord_t distance);
+
+ virtual float _layer_angle(size_t idx) const {
+ bool odd = idx & 1;
+ return (idx & 1) ? float(M_PI/2.) : 0;
+ }
+
+ virtual std::pair<float, Point> _infill_direction(const Surface *surface) const;
+
+ // Align a coordinate to a grid. The coordinate may be negative,
+ // the aligned value will never be bigger than the original one.
+ static coord_t _align_to_grid(const coord_t coord, const coord_t spacing) {
+ // Current C++ standard defines the result of integer division to be rounded to zero,
+ // for both positive and negative numbers. Here we want to round down for negative
+ // numbers as well.
+ coord_t aligned = (coord < 0) ?
+ ((coord - spacing + 1) / spacing) * spacing :
+ (coord / spacing) * spacing;
+ assert(aligned <= coord);
+ return aligned;
+ }
+ static Point _align_to_grid(Point coord, Point spacing)
+ { return Point(_align_to_grid(coord.x, spacing.x), _align_to_grid(coord.y, spacing.y)); }
+ static coord_t _align_to_grid(coord_t coord, coord_t spacing, coord_t base)
+ { return base + _align_to_grid(coord - base, spacing); }
+ static Point _align_to_grid(Point coord, Point spacing, Point base)
+ { return Point(_align_to_grid(coord.x, spacing.x, base.x), _align_to_grid(coord.y, spacing.y, base.y)); }
};
// An interface class to Perl, aggregating an instance of a Fill and a FillData.
@@ -83,21 +119,14 @@ class Filler
{
public:
Filler() : fill(NULL) {}
- ~Filler() { delete fill; fill = NULL; }
+ ~Filler() {
+ delete fill;
+ fill = NULL;
+ }
Fill *fill;
FillParams params;
};
-class FillWithDirection : public Fill
-{
-public:
- virtual float _layer_angle(size_t idx) const {
- bool odd = idx & 1;
- return (idx & 1) ? float(M_PI/2.) : 0;
- }
- virtual std::pair<float, Point> infill_direction(const Surface *surface) const ;
-};
-
} // namespace Slic3r
#endif // slic3r_FillBase_hpp_
diff --git a/xs/src/libslic3r/Fill/FillConcentric.cpp b/xs/src/libslic3r/Fill/FillConcentric.cpp
index 30b34456d..27914866d 100644
--- a/xs/src/libslic3r/Fill/FillConcentric.cpp
+++ b/xs/src/libslic3r/Fill/FillConcentric.cpp
@@ -6,17 +6,21 @@
namespace Slic3r {
-Polylines FillConcentric::fill_surface(const Surface *surface, const FillParams &params)
+void FillConcentric::_fill_surface_single(
+ const FillParams &params,
+ unsigned int thickness_layers,
+ const std::pair<float, Point> &direction,
+ ExPolygon &expolygon,
+ Polylines &polylines_out)
{
// no rotation is supported for this infill pattern
- ExPolygon expolygon = surface->expolygon;
BoundingBox bounding_box = expolygon.contour.bounding_box();
coord_t min_spacing = scale_(this->spacing);
coord_t distance = coord_t(min_spacing / params.density);
if (params.density > 0.9999f && !params.dont_adjust) {
- distance = this->adjust_solid_spacing(bounding_box.size().x, distance);
+ distance = this->_adjust_solid_spacing(bounding_box.size().x, distance);
this->spacing = unscale(distance);
}
@@ -32,29 +36,27 @@ Polylines FillConcentric::fill_surface(const Surface *surface, const FillParams
union_pt_chained(loops, &loops, false);
// split paths using a nearest neighbor search
- Polylines paths;
+ size_t iPathFirst = polylines_out.size();
Point last_pos(0, 0);
for (Polygons::const_iterator it_loop = loops.begin(); it_loop != loops.end(); ++ it_loop) {
- paths.push_back(it_loop->split_at_index(last_pos.nearest_point_index(*it_loop)));
- last_pos = paths.back().last_point();
+ polylines_out.push_back(it_loop->split_at_index(last_pos.nearest_point_index(*it_loop)));
+ last_pos = polylines_out.back().last_point();
}
// clip the paths to prevent the extruder from getting exactly on the first point of the loop
// Keep valid paths only.
- size_t j = 0;
- for (size_t i = 0; i < paths.size(); ++ i) {
- paths[i].clip_end(this->loop_clipping);
- if (paths[i].is_valid()) {
+ size_t j = iPathFirst;
+ for (size_t i = iPathFirst; i < polylines_out.size(); ++ i) {
+ polylines_out[i].clip_end(this->loop_clipping);
+ if (polylines_out[i].is_valid()) {
if (j < i)
- std::swap(paths[j], paths[i]);
+ std::swap(polylines_out[j], polylines_out[i]);
++ j;
}
}
- if (j < paths.size())
- paths.erase(paths.begin() + j, paths.end());
-
+ if (j < polylines_out.size())
+ polylines_out.erase(polylines_out.begin() + j, polylines_out.end());
// TODO: return ExtrusionLoop objects to get better chained paths
- return paths;
}
} // namespace Slic3r
diff --git a/xs/src/libslic3r/Fill/FillConcentric.hpp b/xs/src/libslic3r/Fill/FillConcentric.hpp
index 6d58ec089..91f14908a 100644
--- a/xs/src/libslic3r/Fill/FillConcentric.hpp
+++ b/xs/src/libslic3r/Fill/FillConcentric.hpp
@@ -9,9 +9,15 @@ class FillConcentric : public Fill
{
public:
virtual ~FillConcentric() {}
- virtual Polylines fill_surface(const Surface *surface, const FillParams &params);
protected:
+ virtual void _fill_surface_single(
+ const FillParams &params,
+ unsigned int thickness_layers,
+ const std::pair<float, Point> &direction,
+ ExPolygon &expolygon,
+ Polylines &polylines_out);
+
virtual bool no_sort() const { return true; }
};
diff --git a/xs/src/libslic3r/Fill/FillHoneycomb.cpp b/xs/src/libslic3r/Fill/FillHoneycomb.cpp
index 408a5fa81..a8e38806c 100644
--- a/xs/src/libslic3r/Fill/FillHoneycomb.cpp
+++ b/xs/src/libslic3r/Fill/FillHoneycomb.cpp
@@ -6,10 +6,13 @@
namespace Slic3r {
-Polylines FillHoneycomb::fill_surface(const Surface *surface, const FillParams &params)
+void FillHoneycomb::_fill_surface_single(
+ const FillParams &params,
+ unsigned int thickness_layers,
+ const std::pair<float, Point> &direction,
+ ExPolygon &expolygon,
+ Polylines &polylines_out)
{
- std::pair<float, Point> rotate_vector = this->infill_direction(surface);
-
// cache hexagons math
CacheID cache_id(params.density, this->spacing);
Cache::iterator it_m = this->cache.find(cache_id);
@@ -38,20 +41,19 @@ Polylines FillHoneycomb::fill_surface(const Surface *surface, const FillParams &
// adjust actual bounding box to the nearest multiple of our hex pattern
// and align it so that it matches across layers
- BoundingBox bounding_box = surface->expolygon.contour.bounding_box();
+ BoundingBox bounding_box = expolygon.contour.bounding_box();
{
// rotate bounding box according to infill direction
Polygon bb_polygon = bounding_box.polygon();
- bb_polygon.rotate(rotate_vector.first, m.hex_center);
+ bb_polygon.rotate(direction.first, m.hex_center);
bounding_box = bb_polygon.bounding_box();
// extend bounding box so that our pattern will be aligned with other layers
// $bounding_box->[X1] and [Y1] represent the displacement between new bounding box offset and old one
- bounding_box.merge(Point(
- bounding_box.min.x - (bounding_box.min.x % m.hex_width),
- bounding_box.min.y - (bounding_box.min.y % m.pattern_height)));
+ // The infill is not aligned to the object bounding box, but to a world coordinate system. Supposedly good enough.
+ bounding_box.merge(_align_to_grid(bounding_box.min, Point(m.hex_width, m.pattern_height)));
}
-
+
coord_t x = bounding_box.min.x;
while (x <= bounding_box.max.x) {
Polygon p;
@@ -70,27 +72,27 @@ Polylines FillHoneycomb::fill_surface(const Surface *surface, const FillParams &
std::swap(ax[0], ax[1]); // draw symmetrical pattern
x += m.distance;
}
- p.rotate(-rotate_vector.first, m.hex_center);
+ p.rotate(-direction.first, m.hex_center);
polygons.push_back(p);
}
}
- Polylines paths;
if (params.complete || true) {
// we were requested to complete each loop;
// in this case we don't try to make more continuous paths
- Polygons polygons_trimmed = intersection((Polygons)*surface, polygons);
+ Polygons polygons_trimmed = intersection((Polygons)expolygon, polygons);
for (Polygons::iterator it = polygons_trimmed.begin(); it != polygons_trimmed.end(); ++ it)
- paths.push_back(it->split_at_first_point());
+ polylines_out.push_back(it->split_at_first_point());
} else {
// consider polygons as polylines without re-appending the initial point:
// this cuts the last segment on purpose, so that the jump to the next
// path is more straight
+ Polylines paths;
{
Polylines p;
for (Polygons::iterator it = polygons.begin(); it != polygons.end(); ++ it)
p.push_back((Polyline)(*it));
- paths = intersection(p, (Polygons)*surface);
+ intersection(p, (Polygons)expolygon, &paths);
}
// connect paths
@@ -119,15 +121,13 @@ Polylines FillHoneycomb::fill_surface(const Surface *surface, const FillParams &
}
// clip paths again to prevent connection segments from crossing the expolygon boundaries
- Polylines paths_trimmed = intersection(paths, to_polygons(offset_ex(surface->expolygon, SCALED_EPSILON)));
-#if SLIC3R_CPPVER >= 11
- paths = std::move(paths_trimmed);
-#else
- std::swap(paths, paths_trimmed);
-#endif
+ intersection(paths, to_polygons(offset_ex(expolygon, SCALED_EPSILON)), &paths);
+ // Move the polylines to the output, avoid a deep copy.
+ size_t j = polylines_out.size();
+ polylines_out.resize(j + paths.size(), Polyline());
+ for (size_t i = 0; i < paths.size(); ++ i)
+ std::swap(polylines_out[j ++], paths[i]);
}
-
- return paths;
}
} // namespace Slic3r
diff --git a/xs/src/libslic3r/Fill/FillHoneycomb.hpp b/xs/src/libslic3r/Fill/FillHoneycomb.hpp
index 63fe1f6f4..b4a987115 100644
--- a/xs/src/libslic3r/Fill/FillHoneycomb.hpp
+++ b/xs/src/libslic3r/Fill/FillHoneycomb.hpp
@@ -9,13 +9,19 @@
namespace Slic3r {
-class FillHoneycomb : public FillWithDirection
+class FillHoneycomb : public Fill
{
public:
virtual ~FillHoneycomb() {}
- virtual Polylines fill_surface(const Surface *surface, const FillParams &params);
protected:
+ virtual void _fill_surface_single(
+ const FillParams &params,
+ unsigned int thickness_layers,
+ const std::pair<float, Point> &direction,
+ ExPolygon &expolygon,
+ Polylines &polylines_out);
+
// Caching the
struct CacheID
{
@@ -42,7 +48,7 @@ protected:
typedef std::map<CacheID, CacheData> Cache;
Cache cache;
- virtual float _layer_angle(size_t idx) const { return 0.5f * float(M_PI) * (idx % 3); }
+ virtual float _layer_angle(size_t idx) const { return float(M_PI/3.) * (idx % 3); }
};
} // namespace Slic3r
diff --git a/xs/src/libslic3r/Fill/FillPlanePath.cpp b/xs/src/libslic3r/Fill/FillPlanePath.cpp
index 0a271cbd8..34e155a06 100644
--- a/xs/src/libslic3r/Fill/FillPlanePath.cpp
+++ b/xs/src/libslic3r/Fill/FillPlanePath.cpp
@@ -6,18 +6,20 @@
namespace Slic3r {
-Polylines FillPlanePath::fill_surface(const Surface *surface, const FillParams &params)
+void FillPlanePath::_fill_surface_single(
+ const FillParams &params,
+ unsigned int thickness_layers,
+ const std::pair<float, Point> &direction,
+ ExPolygon &expolygon,
+ Polylines &polylines_out)
{
- ExPolygon expolygon = surface->expolygon;
- std::pair<float, Point> rotate_vector = this->infill_direction(surface);
- expolygon.rotate(- rotate_vector.first);
+ expolygon.rotate(- direction.first);
coord_t distance_between_lines = scale_(this->spacing) / params.density;
// align infill across layers using the object's bounding box
- Polygon bb_polygon = this->bounding_box.polygon();
- bb_polygon.rotate(- rotate_vector.first);
- BoundingBox bounding_box = bb_polygon.bounding_box();
+ // Rotated bounding box of the whole object.
+ BoundingBox bounding_box = this->bounding_box.rotated(- direction.first);
Point shift = this->_centered() ?
bounding_box.center() :
@@ -61,11 +63,15 @@ Polylines FillPlanePath::fill_surface(const Surface *surface, const FillParams &
// paths must be repositioned and rotated back
for (Polylines::iterator it = polylines.begin(); it != polylines.end(); ++ it) {
it->translate(shift.x, shift.y);
- it->rotate(rotate_vector.first);
+ it->rotate(direction.first);
}
}
-
- return polylines;
+
+ // Move the polylines to the output, avoid a deep copy.
+ size_t j = polylines_out.size();
+ polylines_out.resize(j + polylines.size(), Polyline());
+ for (size_t i = 0; i < polylines.size(); ++ i)
+ std::swap(polylines_out[j ++], polylines[i]);
}
// Follow an Archimedean spiral, in polar coordinates: r=a+b\theta
diff --git a/xs/src/libslic3r/Fill/FillPlanePath.hpp b/xs/src/libslic3r/Fill/FillPlanePath.hpp
index 79e5522a9..6e9f45616 100644
--- a/xs/src/libslic3r/Fill/FillPlanePath.hpp
+++ b/xs/src/libslic3r/Fill/FillPlanePath.hpp
@@ -13,13 +13,19 @@ namespace Slic3r {
// http://user42.tuxfamily.org/math-planepath/
// http://user42.tuxfamily.org/math-planepath/gallery.html
-class FillPlanePath : public FillWithDirection
+class FillPlanePath : public Fill
{
public:
virtual ~FillPlanePath() {}
- virtual Polylines fill_surface(const Surface *surface, const FillParams &params);
protected:
+ virtual void _fill_surface_single(
+ const FillParams &params,
+ unsigned int thickness_layers,
+ const std::pair<float, Point> &direction,
+ ExPolygon &expolygon,
+ Polylines &polylines_out);
+
virtual float _layer_angle(size_t idx) const { return 0.f; }
virtual bool _centered() const = 0;
virtual Pointfs _generate(coord_t min_x, coord_t min_y, coord_t max_x, coord_t max_y) = 0;
diff --git a/xs/src/libslic3r/Fill/FillRectilinear.cpp b/xs/src/libslic3r/Fill/FillRectilinear.cpp
index e2f996e2a..5559a5437 100644
--- a/xs/src/libslic3r/Fill/FillRectilinear.cpp
+++ b/xs/src/libslic3r/Fill/FillRectilinear.cpp
@@ -7,15 +7,15 @@
namespace Slic3r {
-Polylines FillRectilinear::fill_surface(const Surface *surface, const FillParams &params)
+void FillRectilinear::_fill_surface_single(
+ const FillParams &params,
+ unsigned int thickness_layers,
+ const std::pair<float, Point> &direction,
+ ExPolygon &expolygon,
+ Polylines &polylines_out)
{
// rotate polygons so that we can work with vertical lines here
- ExPolygon expolygon = surface->expolygon;
- std::pair<float, Point> rotate_vector = this->infill_direction(surface);
- expolygon.rotate(- rotate_vector.first);
- // No need to translate the polygon anyhow for the infill.
- // The infill will be performed inside a bounding box of the expolygon and its absolute position does not matter.
-// expolygon.translate(rotate_vector.second.x, rotate_vector.second.y);
+ expolygon.rotate(- direction.first);
this->_min_spacing = scale_(this->spacing);
assert(params.density > 0.0001f && params.density <= 1.f);
@@ -26,13 +26,15 @@ Polylines FillRectilinear::fill_surface(const Surface *surface, const FillParams
// define flow spacing according to requested density
if (params.density > 0.9999f && !params.dont_adjust) {
- this->_line_spacing = this->adjust_solid_spacing(bounding_box.size().x, this->_line_spacing);
+ this->_line_spacing = this->_adjust_solid_spacing(bounding_box.size().x, this->_line_spacing);
this->spacing = unscale(this->_line_spacing);
} else {
// extend bounding box so that our pattern will be aligned with other layers
- bounding_box.merge(Point(
- bounding_box.min.x - (bounding_box.min.x % this->_line_spacing),
- bounding_box.min.y - (bounding_box.min.y % this->_line_spacing)));
+ // Transform the reference point to the rotated coordinate system.
+ bounding_box.merge(_align_to_grid(
+ bounding_box.min,
+ Point(this->_line_spacing, this->_line_spacing),
+ direction.second.rotated(- direction.first)));
}
// generate the basic pattern
@@ -65,6 +67,7 @@ Polylines FillRectilinear::fill_surface(const Surface *surface, const FillParams
// FIXME Vojtech: This is only performed for horizontal lines, not for the vertical lines!
const float INFILL_OVERLAP_OVER_SPACING = 0.3f;
+ // How much to extend an infill path from expolygon outside?
coord_t extra = coord_t(floor(this->_min_spacing * INFILL_OVERLAP_OVER_SPACING + 0.5f));
for (Polylines::iterator it_polyline = polylines.begin(); it_polyline != polylines.end(); ++ it_polyline) {
Point *first_point = &it_polyline->points.front();
@@ -75,6 +78,8 @@ Polylines FillRectilinear::fill_surface(const Surface *surface, const FillParams
last_point->y += extra;
}
+ size_t n_polylines_out_old = polylines_out.size();
+
// connect lines
if (! params.dont_connect && ! polylines.empty()) { // prevent calling leftmost_point() on empty collections
// offset the expolygon by max(min_spacing/2, extra)
@@ -94,15 +99,11 @@ Polylines FillRectilinear::fill_surface(const Surface *surface, const FillParams
polylines,
#endif
PolylineCollection::leftmost_point(polylines), false); // reverse allowed
-#if SLIC3R_CPPVER >= 11
- assert(polylines.empty());
-#else
- polylines.clear();
-#endif
+ bool first = true;
for (Polylines::iterator it_polyline = chained.begin(); it_polyline != chained.end(); ++ it_polyline) {
- if (! polylines.empty()) {
+ if (! first) {
// Try to connect the lines.
- Points &pts_end = polylines.back().points;
+ Points &pts_end = polylines_out.back().points;
const Point &first_point = it_polyline->points.front();
const Point &last_point = pts_end.back();
// Distance in X, Y.
@@ -118,21 +119,21 @@ Polylines FillRectilinear::fill_surface(const Surface *surface, const FillParams
}
// The lines cannot be connected.
#if SLIC3R_CPPVER >= 11
- polylines.push_back(std::move(*it_polyline));
+ polylines_out.push_back(std::move(*it_polyline));
#else
- polylines.push_back(Polyline());
- std::swap(polylines.back(), *it_polyline);
+ polylines_out.push_back(Polyline());
+ std::swap(polylines_out.back(), *it_polyline);
#endif
+ first = false;
}
}
// paths must be rotated back
- for (Polylines::iterator it = polylines.begin(); it != polylines.end(); ++ it) {
+ for (Polylines::iterator it = polylines_out.begin() + n_polylines_out_old; it != polylines_out.end(); ++ it) {
// No need to translate, the absolute position is irrelevant.
- // it->translate(- rotate_vector.second.x, - rotate_vector.second.y);
- it->rotate(rotate_vector.first);
+ // it->translate(- direction.second.x, - direction.second.y);
+ it->rotate(direction.first);
}
- return polylines;
}
} // namespace Slic3r
diff --git a/xs/src/libslic3r/Fill/FillRectilinear.hpp b/xs/src/libslic3r/Fill/FillRectilinear.hpp
index d10c4ea65..8c13b8bc1 100644
--- a/xs/src/libslic3r/Fill/FillRectilinear.hpp
+++ b/xs/src/libslic3r/Fill/FillRectilinear.hpp
@@ -9,13 +9,19 @@ namespace Slic3r {
class Surface;
-class FillRectilinear : public FillWithDirection
+class FillRectilinear : public Fill
{
public:
virtual ~FillRectilinear() {}
- virtual Polylines fill_surface(const Surface *surface, const FillParams &params);
protected:
+ virtual void _fill_surface_single(
+ const FillParams &params,
+ unsigned int thickness_layers,
+ const std::pair<float, Point> &direction,
+ ExPolygon &expolygon,
+ Polylines &polylines_out);
+
coord_t _min_spacing;
coord_t _line_spacing;
// distance threshold for allowing the horizontal infill lines to be connected into a continuous path
diff --git a/xs/src/libslic3r/Fill/FillRectilinear2.cpp b/xs/src/libslic3r/Fill/FillRectilinear2.cpp
index 40905de0d..4e741ab08 100644
--- a/xs/src/libslic3r/Fill/FillRectilinear2.cpp
+++ b/xs/src/libslic3r/Fill/FillRectilinear2.cpp
@@ -1,4 +1,5 @@
#include <assert.h>
+#include <stdlib.h>
#include <stdint.h>
#include <algorithm>
@@ -13,28 +14,14 @@
#include "FillRectilinear2.hpp"
+#define SLIC3R_DEBUG
+
#ifdef SLIC3R_DEBUG
#include "SVG.hpp"
#endif
-#if defined(SLIC3R_DEBUG) && defined(_WIN32)
-#include <Windows.h>
-#pragma comment(lib, "user32.lib")
- static inline void assert_fail(const char *assertion, const char *file, unsigned line, const char *function)
- {
- printf("Assert: %s in function %s\nfile %s:%d\n", assertion, function, file, line);
- if (IsDebuggerPresent()) {
- DebugBreak();
- } else {
- ExitProcess(-1);
- }
- }
- #undef assert
- #define assert(expr) \
- ((expr) \
- ? static_cast<void>(0) \
- : assert_fail (#expr, __FILE__, __LINE__, __FUNCTION__))
-#endif /* SLIC3R_DEBUG */
+// We want our version of assert.
+#include "../libslic3r.h"
namespace Slic3r {
@@ -81,7 +68,7 @@ enum Orientation
// which means, the coord_t types must not have some of the topmost bits utilized.
static inline Orientation orient(const Point &a, const Point &b, const Point &c)
{
- BOOST_STATIC_ASSERT(sizeof(coord_t) * 2 == sizeof(int64_t));
+ // BOOST_STATIC_ASSERT(sizeof(coord_t) * 2 == sizeof(int64_t));
int64_t u = int64_t(b.x) * int64_t(c.y) - int64_t(b.y) * int64_t(c.x);
int64_t v = int64_t(a.x) * int64_t(c.y) - int64_t(a.y) * int64_t(c.x);
int64_t w = int64_t(a.x) * int64_t(b.y) - int64_t(a.y) * int64_t(b.x);
@@ -94,7 +81,7 @@ static inline Orientation orient(const Point &a, const Point &b, const Point &c)
static inline bool is_ccw(const Polygon &poly)
{
// The polygon shall be at least a triangle.
- assert(poly.points.size() >= 3);
+ myassert(poly.points.size() >= 3);
if (poly.points.size() < 3)
return true;
@@ -113,7 +100,7 @@ static inline bool is_ccw(const Polygon &poly)
Orientation o = orient(poly.points[iPrev], poly.points[imin], poly.points[iNext]);
// The lowest bottom point must not be collinear if the polygon does not contain duplicate points
// or overlapping segments.
- assert(o != ORIENTATION_COLINEAR);
+ myassert(o != ORIENTATION_COLINEAR);
return o == ORIENTATION_CCW;
}
@@ -134,8 +121,8 @@ static inline coordf_t segment_length(const Polygon &poly, size_t seg1, const Po
std::swap(pa.x, pb.x);
if (pa.y > pb.y)
std::swap(pa.y, pb.y);
- assert(px.x >= pa.x && px.x <= pb.x);
- assert(px.y >= pa.y && px.y <= pb.y);
+ myassert(px.x >= pa.x && px.x <= pb.x);
+ myassert(px.y >= pa.y && px.y <= pb.y);
}
#endif /* SLIC3R_DEBUG */
const Point *pPrev = &p1;
@@ -262,45 +249,65 @@ public:
struct ExPolygonWithOffset
{
public:
- ExPolygonWithOffset(const ExPolygon &aexpolygon, coord_t aoffset) : expolygon(aexpolygon)
+ ExPolygonWithOffset(
+ const ExPolygon &expolygon,
+ float angle,
+ coord_t aoffset1,
+ coord_t aoffset2)
{
- polygons_inner = offset((Polygons)expolygon, aoffset,
- CLIPPER_OFFSET_SCALE,
- ClipperLib::jtMiter,
- // for the infill pattern, don't cut the corners.
- // default miterLimt = 3
- 10.);
- n_contours_outer = 1 + expolygon.holes.size();
+ // Copy and rotate the source polygons.
+ polygons_src = (Polygons)expolygon;
+ for (Polygons::iterator it = polygons_src.begin(); it != polygons_src.end(); ++ it)
+ it->rotate(angle);
+
+ double mitterLimit = 3.;
+ // for the infill pattern, don't cut the corners.
+ // default miterLimt = 3
+ //double mitterLimit = 10.;
+ myassert(aoffset1 < 0);
+ myassert(aoffset2 < 0);
+ myassert(aoffset2 < aoffset1);
+ polygons_outer = offset(polygons_src, aoffset1,
+ CLIPPER_OFFSET_SCALE,
+ ClipperLib::jtMiter,
+ mitterLimit);
+ polygons_inner = offset(polygons_src, aoffset2,
+ CLIPPER_OFFSET_SCALE,
+ ClipperLib::jtMiter,
+ mitterLimit);
+ n_contours_outer = polygons_outer.size();
n_contours_inner = polygons_inner.size();
n_contours = n_contours_outer + n_contours_inner;
- polygons_inner_ccw.assign(polygons_inner.size(), false);
- for (size_t i = 0; i < polygons_inner.size(); ++ i)
- polygons_inner_ccw[i] = is_ccw(polygons_inner[i]);
- #ifdef SLIC3R_DEBUG
- // Verify orientation of the expolygon.
- assert(is_ccw(expolygon.contour));
- for (size_t i = 0; i < expolygon.holes.size(); ++ i)
- assert(is_ccw(expolygon.holes[i]));
- #endif /* SLIC3R_DEBUG */
+ polygons_ccw.assign(n_contours, false);
+ for (size_t i = 0; i < n_contours; ++ i) {
+ contour(i).remove_duplicate_points();
+ myassert(! contour(i).has_duplicate_points());
+ polygons_ccw[i] = is_ccw(contour(i));
+ }
}
- // Outer contour of the expolygon.
- bool is_contour_external(size_t idx) const { return idx == 0; }
- // Any contour of the expolygon.
- bool is_contour_outer(size_t idx) const { return idx < n_contours_inner; }
- // Contour of the shrunk expolygon.
- bool is_contour_inner(size_t idx) const { return idx >= n_contours_inner; }
+ // Any contour with offset1
+ bool is_contour_outer(size_t idx) const { return idx < n_contours_outer; }
+ // Any contour with offset2
+ bool is_contour_inner(size_t idx) const { return idx >= n_contours_outer; }
- const Polygon& contour(size_t idx) const {
- return is_contour_external(idx) ? expolygon.contour :
- (is_contour_outer(idx) ? expolygon.holes[idx - 1] : polygons_inner[idx - n_contours_inner]);
- }
+ const Polygon& contour(size_t idx) const
+ { return is_contour_outer(idx) ? polygons_outer[idx] : polygons_inner[idx - n_contours_outer]; }
- bool is_contour_ccw(size_t idx) const {
- return is_contour_external(idx) || (is_contour_inner(idx) && polygons_inner_ccw[idx - n_contours_inner]);
- }
+ Polygon& contour(size_t idx)
+ { return is_contour_outer(idx) ? polygons_outer[idx] : polygons_inner[idx - n_contours_outer]; }
- const ExPolygon &expolygon;
+ bool is_contour_ccw(size_t idx) const { return polygons_ccw[idx]; }
+
+ BoundingBox bounding_box_src() const
+ { return _bounding_box_polygons(polygons_src); }
+ BoundingBox bounding_box_outer() const
+ { return _bounding_box_polygons(polygons_outer); }
+ BoundingBox bounding_box_inner() const
+ { return _bounding_box_polygons(polygons_inner); }
+
+ Polygons polygons_src;
+ Polygons polygons_outer;
Polygons polygons_inner;
size_t n_contours_outer;
@@ -308,11 +315,30 @@ public:
size_t n_contours;
protected:
-
// For each polygon of polygons_inner, remember its orientation.
- std::vector<unsigned char> polygons_inner_ccw;
+ std::vector<unsigned char> polygons_ccw;
+
+ static BoundingBox _bounding_box_polygons(const Polygons &poly) {
+ BoundingBox bbox;
+ if (! poly.empty()) {
+ bbox = poly.front().bounding_box();
+ for (size_t i = 1; i < poly.size(); ++ i)
+ bbox.merge(poly[i]);
+ }
+ return bbox;
+ }
};
+static inline int distance_of_segmens(const Polygon &poly, size_t seg1, size_t seg2, bool forward)
+{
+ int d = int(seg2) - int(seg1);
+ if (! forward)
+ d = - d;
+ if (d < 0)
+ d += int(poly.points.size());
+ return d;
+}
+
// For a vertical line, an inner contour and an intersection point,
// find an intersection point on the previous resp. next vertical line.
// The intersection point is connected with the prev resp. next intersection point with iInnerContour.
@@ -339,7 +365,8 @@ static inline int intersection_on_prev_next_vertical_line(
const SegmentIntersection &itsct = il.intersections[iIntersection];
const SegmentedIntersectionLine &il2 = segs[iVerticalLineOther];
const Polygon &poly = poly_with_offset.contour(iInnerContour);
- const bool ccw = poly_with_offset.is_contour_ccw(iInnerContour);
+// const bool ccw = poly_with_offset.is_contour_ccw(iInnerContour);
+ const bool forward = itsct.is_low() == dir_is_next;
// Resulting index of an intersection point on il2.
int out = -1;
// Find an intersection point on iVerticalLineOther, intersecting iInnerContour
@@ -349,13 +376,30 @@ static inline int intersection_on_prev_next_vertical_line(
for (size_t i = 0; i < il2.intersections.size(); ++ i) {
const SegmentIntersection &itsct2 = il2.intersections[i];
if (itsct.iContour == itsct2.iContour && itsct.type == itsct2.type) {
+ /*
+ if (itsct.is_low()) {
+ myassert(itsct.type == SegmentIntersection::INNER_LOW);
+ myassert(iIntersection > 0);
+ myassert(il.intersections[iIntersection-1].type == SegmentIntersection::OUTER_LOW);
+ myassert(i > 0);
+ if (il2.intersections[i-1].is_inner())
+ // Take only the lowest inner intersection point.
+ continue;
+ myassert(il2.intersections[i-1].type == SegmentIntersection::OUTER_LOW);
+ } else {
+ myassert(itsct.type == SegmentIntersection::INNER_HIGH);
+ myassert(iIntersection+1 < il.intersections.size());
+ myassert(il.intersections[iIntersection+1].type == SegmentIntersection::OUTER_HIGH);
+ myassert(i+1 < il2.intersections.size());
+ if (il2.intersections[i+1].is_inner())
+ // Take only the highest inner intersection point.
+ continue;
+ myassert(il2.intersections[i+1].type == SegmentIntersection::OUTER_HIGH);
+ }
+ */
// The intersection points lie on the same contour and have the same orientation.
// Find the intersection point with a shortest path in the direction of the contour.
- int d = int(itsct2.iSegment) - int(itsct.iSegment);
- if (ccw != dir_is_next)
- d = - d;
- if (d < 0)
- d += int(poly.points.size());
+ int d = distance_of_segmens(poly, itsct.iSegment, itsct2.iSegment, forward);
if (d < dmin) {
out = i;
dmin = d;
@@ -395,17 +439,26 @@ static inline int intersection_unused_on_prev_next_vertical_line(
size_t iIntersection,
bool dir_is_next)
{
+ //FIXME This routine will propose a connecting line even if the connecting perimeter segment intersects
+ // iVertical line multiple times before reaching iIntersectionOther.
int iIntersectionOther = intersection_on_prev_next_vertical_line(poly_with_offset, segs, iVerticalLine, iInnerContour, iIntersection, dir_is_next);
if (iIntersectionOther == -1)
return -1;
- //FIXME this routine will propose a connecting line even if the connecting perimeter segment intersects iVertical line multiple times before reaching iIntersectionOther.
- assert(dir_is_next ? (iVerticalLine + 1 < segs.size()) : (iVerticalLine > 0));
+ myassert(dir_is_next ? (iVerticalLine + 1 < segs.size()) : (iVerticalLine > 0));
const SegmentedIntersectionLine &il_this = segs[iVerticalLine];
const SegmentIntersection &itsct_this = il_this.intersections[iIntersection];
const SegmentedIntersectionLine &il_other = segs[dir_is_next ? (iVerticalLine+1) : (iVerticalLine-1)];
const SegmentIntersection &itsct_other = il_other.intersections[iIntersectionOther];
- assert(itsct_other.is_inner());
- assert(itsct_other.is_low() || iIntersectionOther > 1);
+ myassert(itsct_other.is_inner());
+ myassert(iIntersectionOther > 0);
+ myassert(iIntersectionOther + 1 < il_other.intersections.size());
+ // Is iIntersectionOther at the boundary of a vertical segment?
+ const SegmentIntersection &itsct_other2 = il_other.intersections[itsct_other.is_low() ? iIntersectionOther - 1 : iIntersectionOther + 1];
+ if (itsct_other2.is_inner())
+ // Cannot follow a perimeter segment into the middle of another vertical segment.
+ // Only perimeter segments connecting to the end of a vertical segment are followed.
+ return -1;
+ myassert(itsct_other.is_low() == itsct_other2.is_low());
if (dir_is_next ? itsct_this.consumed_perimeter_right : itsct_other.consumed_perimeter_right)
// This perimeter segment was already consumed.
return -1;
@@ -460,11 +513,11 @@ static inline coordf_t measure_perimeter_prev_next_segment_length(
const SegmentedIntersectionLine &il2 = segs[iVerticalLineOther];
const SegmentIntersection &itsct2 = il2.intersections[iIntersection2];
const Polygon &poly = poly_with_offset.contour(iInnerContour);
- const bool ccw = poly_with_offset.is_contour_ccw(iInnerContour);
- assert(itsct.type == itsct2.type);
- assert(itsct.iContour == itsct2.iContour);
- assert(itsct.is_inner());
- const bool forward = (itsct.is_low() == ccw) == dir_is_next;
+// const bool ccw = poly_with_offset.is_contour_ccw(iInnerContour);
+ myassert(itsct.type == itsct2.type);
+ myassert(itsct.iContour == itsct2.iContour);
+ myassert(itsct.is_inner());
+ const bool forward = itsct.is_low() == dir_is_next;
Point p1(il.pos, itsct.pos);
Point p2(il2.pos, itsct2.pos);
@@ -511,9 +564,9 @@ static inline void emit_perimeter_prev_next_segment(
size_t iVerticalLineOther = iVerticalLine;
if (dir_is_next) {
++ iVerticalLineOther;
- assert(iVerticalLineOther < segs.size());
+ myassert(iVerticalLineOther < segs.size());
} else {
- assert(iVerticalLineOther > 0);
+ myassert(iVerticalLineOther > 0);
-- iVerticalLineOther;
}
@@ -522,11 +575,11 @@ static inline void emit_perimeter_prev_next_segment(
const SegmentedIntersectionLine &il2 = segs[iVerticalLineOther];
const SegmentIntersection &itsct2 = il2.intersections[iIntersection2];
const Polygon &poly = poly_with_offset.contour(iInnerContour);
- const bool ccw = poly_with_offset.is_contour_ccw(iInnerContour);
- assert(itsct.type == itsct2.type);
- assert(itsct.iContour == itsct2.iContour);
- assert(itsct.is_inner());
- const bool forward = (itsct.is_low() == ccw) == dir_is_next;
+// const bool ccw = poly_with_offset.is_contour_ccw(iInnerContour);
+ myassert(itsct.type == itsct2.type);
+ myassert(itsct.iContour == itsct2.iContour);
+ myassert(itsct.is_inner());
+ const bool forward = itsct.is_low() == dir_is_next;
// Do not append the first point.
// out.points.push_back(Point(il.pos, itsct.pos));
if (forward)
@@ -537,71 +590,91 @@ static inline void emit_perimeter_prev_next_segment(
out.points.push_back(Point(il2.pos, itsct2.pos));
}
-Polylines FillRectilinear2::fill_surface(const Surface *surface, const FillParams &params)
+void FillRectilinear2::fill_surface_by_lines(const Surface *surface, const FillParams &params, float angleBase, Polylines &polylines_out)
{
- // rotate polygons so that we can work with vertical lines here
- ExPolygon expolygon = surface->expolygon;
- std::pair<float, Point> rotate_vector = this->infill_direction(surface);
- expolygon.rotate(- rotate_vector.first);
- // No need to translate the polygon anyhow for the infill.
- // The infill will be performed inside a bounding box of the expolygon and its absolute position does not matter.
-// expolygon.translate(rotate_vector.second.x, rotate_vector.second.y);
+ // At the end, only the new polylines will be rotated back.
+ size_t n_polylines_out_initial = polylines_out.size();
+
+ // Shrink the input polygon a bit first to not push the infill lines out of the perimeters.
+// const float INFILL_OVERLAP_OVER_SPACING = 0.3f;
+ const float INFILL_OVERLAP_OVER_SPACING = 0.45f;
+ myassert(INFILL_OVERLAP_OVER_SPACING > 0 && INFILL_OVERLAP_OVER_SPACING < 0.5f);
+
+ // Rotate polygons so that we can work with vertical lines here
+ std::pair<float, Point> rotate_vector = this->_infill_direction(surface);
+ rotate_vector.first += angleBase;
this->_min_spacing = scale_(this->spacing);
- assert(params.density > 0.0001f && params.density <= 1.f);
+ myassert(params.density > 0.0001f && params.density <= 1.f);
this->_line_spacing = coord_t(coordf_t(this->_min_spacing) / params.density);
this->_diagonal_distance = this->_line_spacing * 2;
- BoundingBox bounding_box = expolygon.contour.bounding_box();
-
+
+ // On the polygons of poly_with_offset, the infill lines will be connected.
+ ExPolygonWithOffset poly_with_offset(
+ surface->expolygon,
+ - rotate_vector.first,
+ scale_(- (0.5 - INFILL_OVERLAP_OVER_SPACING) * this->spacing),
+ scale_(- 0.5 * this->spacing));
+ if (poly_with_offset.n_contours_inner == 0) {
+ //FIXME maybe one shall trigger the gap fill here?
+ return;
+ }
+
+ BoundingBox bounding_box = poly_with_offset.bounding_box_outer();
+
// define flow spacing according to requested density
- if (params.density > 0.9999f && !params.dont_adjust) {
- this->_line_spacing = this->adjust_solid_spacing(bounding_box.size().x, this->_line_spacing);
- this->spacing = unscale(this->_line_spacing);
+ bool full_infill = params.density > 0.9999f;
+ if (full_infill && !params.dont_adjust) {
+// this->_min_spacing = this->_line_spacing = this->_adjust_solid_spacing(bounding_box.size().x, this->_line_spacing);
+// this->spacing = unscale(this->_line_spacing);
} else {
// extend bounding box so that our pattern will be aligned with other layers
- bounding_box.merge(Point(
- bounding_box.min.x - (bounding_box.min.x % this->_line_spacing),
- bounding_box.min.y - (bounding_box.min.y % this->_line_spacing)));
+ // Transform the reference point to the rotated coordinate system.
+ bounding_box.merge(_align_to_grid(
+ bounding_box.min,
+ Point(this->_line_spacing, this->_line_spacing),
+ rotate_vector.second.rotated(- rotate_vector.first)));
}
// Intersect a set of euqally spaced vertical lines wiht expolygon.
size_t n_vlines = (bounding_box.max.x - bounding_box.min.x + SCALED_EPSILON) / this->_line_spacing;
coord_t x0 = bounding_box.min.x + this->_line_spacing;
- // On these polygons the infill lines will be connected.
- ExPolygonWithOffset poly_with_offset(expolygon, - _min_spacing / 2);
#ifdef SLIC3R_DEBUG
char path[2048];
static int iRun = 0;
sprintf(path, "out/FillRectilinear2-%d.svg", iRun);
- BoundingBox bbox_svg = expolygon.contour.bounding_box();
- bbox_svg.min.x -= coord_t(1. / SCALING_FACTOR);
- bbox_svg.min.y -= coord_t(1. / SCALING_FACTOR);
- bbox_svg.max.x += coord_t(1. / SCALING_FACTOR);
- bbox_svg.max.y += coord_t(1. / SCALING_FACTOR);
- ::Slic3r::SVG svg(path, bbox_svg);
- svg.draw(expolygon.lines());
- svg.draw(poly_with_offset.polygons_inner);
+ BoundingBox bbox_svg = poly_with_offset.bounding_box_outer();
+ ::Slic3r::SVG svg(path, bbox_svg); // , scale_(1.));
+ for (size_t i = 0; i < poly_with_offset.polygons_src.size(); ++ i)
+ svg.draw(poly_with_offset.polygons_src[i].lines());
+ for (size_t i = 0; i < poly_with_offset.polygons_outer.size(); ++ i)
+ svg.draw(poly_with_offset.polygons_outer[i].lines(), "green");
+ for (size_t i = 0; i < poly_with_offset.polygons_inner.size(); ++ i)
+ svg.draw(poly_with_offset.polygons_inner[i].lines(), "brown");
{
char path2[2048];
sprintf(path2, "out/FillRectilinear2-initial-%d.svg", iRun);
- ::Slic3r::SVG svg(path2, bbox_svg);
- svg.draw(expolygon.lines());
- svg.draw(poly_with_offset.polygons_inner);
- svg.Close();
+ ::Slic3r::SVG svg(path2, bbox_svg); // , scale_(1.));
+ for (size_t i = 0; i < poly_with_offset.polygons_src.size(); ++ i)
+ svg.draw(poly_with_offset.polygons_src[i].lines());
+ for (size_t i = 0; i < poly_with_offset.polygons_outer.size(); ++ i)
+ svg.draw(poly_with_offset.polygons_outer[i].lines(), "green");
+ for (size_t i = 0; i < poly_with_offset.polygons_inner.size(); ++ i)
+ svg.draw(poly_with_offset.polygons_inner[i].lines(), "brown");
}
iRun ++;
#endif /* SLIC3R_DEBUG */
// For each contour
- // Allocate the storage for the segments.
+ // Allocate storage for the segments.
std::vector<SegmentedIntersectionLine> segs(n_vlines, SegmentedIntersectionLine());
for (size_t i = 0; i < n_vlines; ++ i) {
segs[i].idx = i;
segs[i].pos = x0 + i * this->_line_spacing;
}
for (size_t iContour = 0; iContour < poly_with_offset.n_contours; ++ iContour) {
- const Points &contour = poly_with_offset.contour(iContour);
+ const Points &contour = poly_with_offset.contour(iContour).points;
if (contour.size() < 2)
continue;
// For each segment
@@ -626,10 +699,14 @@ Polylines FillRectilinear2::fill_surface(const Surface *surface, const FillParam
if (il > ir)
// No vertical line intersects this segment.
continue;
- assert(il >= 0 && il < segs.size());
- assert(ir >= 0 && ir < segs.size());
+ myassert(il >= 0 && il < segs.size());
+ myassert(ir >= 0 && ir < segs.size());
if (l == r) {
// The segment is vertical.
+ // Don't insert vertical segments at all.
+ // If the contour is not degenerate, then this vertical line will be crossed
+ // by the non-vertical segments preceding resp. succeeding this vertical segment.
+ /*
SegmentIntersection is;
is.iContour = iContour;
is.iSegment = iSegment;
@@ -637,24 +714,25 @@ Polylines FillRectilinear2::fill_surface(const Surface *surface, const FillParam
segs[il].intersections.push_back(is);
is.pos = p2.y;
segs[il].intersections.push_back(is);
+ */
continue;
}
for (int i = il; i <= ir; ++ i) {
SegmentIntersection is;
is.iContour = iContour;
is.iSegment = iSegment;
- assert(l <= segs[i].pos);
- assert(r >= segs[i].pos);
+ myassert(l <= segs[i].pos);
+ myassert(r >= segs[i].pos);
// Calculate the intersection position in y axis. x is known.
double t = double(segs[i].pos - p1.x) / double(p2.x - p1.x);
- assert(t > -0.000001 && t < 1.000001);
+ myassert(t > -0.000001 && t < 1.000001);
t = clamp(0., 1., t);
coord_t lo = p1.y;
coord_t hi = p2.y;
if (lo > hi)
std::swap(lo, hi);
is.pos = p1.y + coord_t(t * double(p2.y - p1.y));
- assert(is.pos > lo - 0.000001 && is.pos < hi + 0.000001);
+ myassert(is.pos > lo - 0.000001 && is.pos < hi + 0.000001);
is.pos = clamp(lo, hi, is.pos);
segs[i].intersections.push_back(is);
}
@@ -674,8 +752,8 @@ Polylines FillRectilinear2::fill_surface(const Surface *surface, const FillParam
for (size_t i = 1; i < sil.intersections.size(); ++ i) {
size_t iContour1 = sil.intersections[i-1].iContour;
size_t iContour2 = sil.intersections[i].iContour;
- const Points &contour1 = poly_with_offset.contour(iContour1);
- const Points &contour2 = poly_with_offset.contour(iContour2);
+ const Points &contour1 = poly_with_offset.contour(iContour1).points;
+ const Points &contour2 = poly_with_offset.contour(iContour2).points;
size_t iSegment1 = sil.intersections[i-1].iSegment;
size_t iPrev1 = ((iSegment1 == 0) ? contour1.size() : iSegment1) - 1;
size_t iSegment2 = sil.intersections[i].iSegment;
@@ -683,7 +761,7 @@ Polylines FillRectilinear2::fill_surface(const Surface *surface, const FillParam
bool swap = false;
if (iContour1 == iContour2 && iSegment1 == iSegment2) {
// The same segment, it has to be vertical.
- assert(iPrev1 == iPrev2);
+ myassert(iPrev1 == iPrev2);
swap = contour1[iPrev1].y > contour1[iContour1].y;
#ifdef SLIC3R_DEBUG
if (swap)
@@ -706,27 +784,43 @@ Polylines FillRectilinear2::fill_surface(const Surface *surface, const FillParam
const Point x2(sil.pos, sil.intersections[i ].pos);
bool successive = false;
#endif /* SLIC3R_DEBUG */
+ // Sort the points in the two segments by x.
if (a->x > b->x)
std::swap(a, b);
if (c->x > d->x)
std::swap(c, d);
+ myassert(a->x <= sil.pos);
+ myassert(c->x <= sil.pos);
+ myassert(b->x >= sil.pos);
+ myassert(d->x >= sil.pos);
+ // Sort the two segments, so the segment <a,b> will be on the left of <c,d>.
bool upper_more_left = false;
if (a->x > c->x) {
upper_more_left = true;
std::swap(a, c);
std::swap(b, d);
}
- if (a == c || b == c) {
- assert(iContour1 == iContour2);
- assert(iSegment1 == iPrev2 || iPrev1 == iSegment2);
+ if (a == c) {
+ // The segments iSegment1 and iSegment2 are directly connected.
+ myassert(iContour1 == iContour2);
+ myassert(iSegment1 == iPrev2 || iPrev1 == iSegment2);
std::swap(c, d);
- assert(a != c && b != c);
+ myassert(a != c && b != c);
#ifdef SLIC3R_DEBUG
successive = true;
#endif /* SLIC3R_DEBUG */
}
+#ifdef SLIC3R_DEBUG
+ else if (b == d) {
+ // The segments iSegment1 and iSegment2 are directly connected.
+ myassert(iContour1 == iContour2);
+ myassert(iSegment1 == iPrev2 || iPrev1 == iSegment2);
+ myassert(a != c && b != c);
+ successive = true;
+ }
+#endif /* SLIC3R_DEBUG */
Orientation o = orient(*a, *b, *c);
- assert(! ORIENTATION_COLINEAR);
+ myassert(o != ORIENTATION_COLINEAR);
swap = upper_more_left != (o == ORIENTATION_CW);
#ifdef SLIC3R_DEBUG
if (swap)
@@ -737,7 +831,7 @@ Polylines FillRectilinear2::fill_surface(const Surface *surface, const FillParam
}
}
if (swap) {
- // Swap the intersection points, but keep the original positions, so they are sorted.
+ // Swap the intersection points, but keep the original positions, so they stay sorted by the y axis.
std::swap(sil.intersections[i-1], sil.intersections[i]);
std::swap(sil.intersections[i-1].pos, sil.intersections[i].pos);
modified = true;
@@ -745,19 +839,40 @@ Polylines FillRectilinear2::fill_surface(const Surface *surface, const FillParam
}
} while (modified);
// Assign the intersection types.
+ size_t j = 0;
for (size_t i = 0; i < sil.intersections.size(); ++ i) {
// What is the orientation of the segment at the intersection point?
size_t iContour = sil.intersections[i].iContour;
- const Points &contour = poly_with_offset.contour(iContour);
+ const Points &contour = poly_with_offset.contour(iContour).points;
size_t iSegment = sil.intersections[i].iSegment;
size_t iPrev = ((iSegment == 0) ? contour.size() : iSegment) - 1;
coord_t dir = contour[iSegment].x - contour[iPrev].x;
- bool ccw = poly_with_offset.is_contour_ccw(iContour);
- bool low = (dir > 0) == ccw;
+ // bool ccw = poly_with_offset.is_contour_ccw(iContour);
+ // bool low = (dir > 0) == ccw;
+ bool low = dir > 0;
sil.intersections[i].type = poly_with_offset.is_contour_outer(iContour) ?
(low ? SegmentIntersection::OUTER_LOW : SegmentIntersection::OUTER_HIGH) :
(low ? SegmentIntersection::INNER_LOW : SegmentIntersection::INNER_HIGH);
+ if (j > 0 &&
+ sil.intersections[i].pos == sil.intersections[j-1].pos &&
+ sil.intersections[i].type == sil.intersections[j-1].type &&
+ sil.intersections[i].iContour == sil.intersections[j-1].iContour) {
+ // This has to be a corner point crossing the vertical line.
+ // Remove the second intersection point.
+#ifdef SLIC3R_DEBUG
+ size_t iSegment2 = sil.intersections[j-1].iSegment;
+ size_t iPrev2 = ((iSegment2 == 0) ? contour.size() : iSegment2) - 1;
+ myassert(iSegment == iPrev2 || iSegment2 == iPrev);
+#endif /* SLIC3R_DEBUG */
+ } else {
+ if (j < i)
+ sil.intersections[j] = sil.intersections[i];
+ ++ j;
+ }
}
+ // Shrink the list of intersections, if any of the intersection was removed during the classification.
+ if (j < sil.intersections.size())
+ sil.intersections.erase(sil.intersections.begin() + j, sil.intersections.end());
}
#ifdef SLIC3R_DEBUG
@@ -765,18 +880,18 @@ Polylines FillRectilinear2::fill_surface(const Surface *surface, const FillParam
for (size_t i_seg = 0; i_seg < segs.size(); ++ i_seg) {
SegmentedIntersectionLine &sil = segs[i_seg];
// The intersection points have to be even.
- assert((sil.intersections.size() & 1) == 0);
+ myassert((sil.intersections.size() & 1) == 0);
for (size_t i = 0; i < sil.intersections.size();) {
// An intersection segment crossing the bigger contour may cross the inner offsetted contour even number of times.
- assert(sil.intersections[i].type == SegmentIntersection::OUTER_LOW);
+ myassert(sil.intersections[i].type == SegmentIntersection::OUTER_LOW);
size_t j = i + 1;
- assert(j < sil.intersections.size());
- assert(sil.intersections[j].type == SegmentIntersection::INNER_LOW || sil.intersections[j].type == SegmentIntersection::OUTER_HIGH);
+ myassert(j < sil.intersections.size());
+ myassert(sil.intersections[j].type == SegmentIntersection::INNER_LOW || sil.intersections[j].type == SegmentIntersection::OUTER_HIGH);
for (; j < sil.intersections.size() && sil.intersections[j].is_inner(); ++ j) ;
- assert(j < sil.intersections.size());
- assert((j & 1) == 1);
- assert(sil.intersections[j].type == SegmentIntersection::OUTER_HIGH);
- assert(i + 1 == j || sil.intersections[j - 1].type == SegmentIntersection::INNER_HIGH);
+ myassert(j < sil.intersections.size());
+ myassert((j & 1) == 1);
+ myassert(sil.intersections[j].type == SegmentIntersection::OUTER_HIGH);
+ myassert(i + 1 == j || sil.intersections[j - 1].type == SegmentIntersection::INNER_HIGH);
if (i + 1 == j) {
svg.draw(Line(Point(sil.pos, sil.intersections[i].pos), Point(sil.pos, sil.intersections[j].pos)), "blue");
} else {
@@ -788,6 +903,26 @@ Polylines FillRectilinear2::fill_surface(const Surface *surface, const FillParam
}
}
svg.Close();
+
+ // Verify the segments & paint them.
+ for (size_t i_seg = 0; i_seg < segs.size(); ++ i_seg) {
+ SegmentedIntersectionLine &sil = segs[i_seg];
+ // The intersection points have to be even.
+ myassert((sil.intersections.size() & 1) == 0);
+ for (size_t i = 0; i < sil.intersections.size();) {
+ // An intersection segment crossing the bigger contour may cross the inner offsetted contour even number of times.
+ myassert(sil.intersections[i].type == SegmentIntersection::OUTER_LOW);
+ size_t j = i + 1;
+ myassert(j < sil.intersections.size());
+ myassert(sil.intersections[j].type == SegmentIntersection::INNER_LOW || sil.intersections[j].type == SegmentIntersection::OUTER_HIGH);
+ for (; j < sil.intersections.size() && sil.intersections[j].is_inner(); ++ j) ;
+ myassert(j < sil.intersections.size());
+ myassert((j & 1) == 1);
+ myassert(sil.intersections[j].type == SegmentIntersection::OUTER_HIGH);
+ myassert(i + 1 == j || sil.intersections[j - 1].type == SegmentIntersection::INNER_HIGH);
+ i = j + 1;
+ }
+ }
#endif /* SLIC3R_DEBUG */
// Now construct a graph.
@@ -798,8 +933,9 @@ Polylines FillRectilinear2::fill_surface(const Surface *surface, const FillParam
// Follow the line, connect the lines into a graph.
// Until no new line could be added to the output path:
Point pointLast;
- Polylines polylines_out;
Polyline *polyline_current = NULL;
+ if (! polylines_out.empty())
+ pointLast = polylines_out.back().points.back();
for (;;) {
if (i_intersection == size_t(-1)) {
// The path has been interrupted. Find a next starting point, closest to the previous extruder position.
@@ -807,14 +943,14 @@ Polylines FillRectilinear2::fill_surface(const Surface *surface, const FillParam
for (size_t i_vline2 = 0; i_vline2 < segs.size(); ++ i_vline2) {
const SegmentedIntersectionLine &seg = segs[i_vline2];
if (! seg.intersections.empty()) {
- assert(seg.intersections.size() > 1);
+ myassert(seg.intersections.size() > 1);
// Even number of intersections with the loops.
- assert((seg.intersections.size() & 1) == 0);
- assert(seg.intersections.front().type == SegmentIntersection::OUTER_LOW);
+ myassert((seg.intersections.size() & 1) == 0);
+ myassert(seg.intersections.front().type == SegmentIntersection::OUTER_LOW);
for (size_t i = 0; i < seg.intersections.size(); ++ i) {
const SegmentIntersection &intrsctn = seg.intersections[i];
if (intrsctn.is_outer()) {
- assert(intrsctn.is_low() || i > 0);
+ myassert(intrsctn.is_low() || i > 0);
bool consumed = intrsctn.is_low() ?
intrsctn.consumed_vertical_up :
seg.intersections[i-1].consumed_vertical_up;
@@ -852,11 +988,11 @@ Polylines FillRectilinear2::fill_surface(const Surface *surface, const FillParam
bool going_up = intrsctn->is_low();
bool try_connect = false;
if (going_up) {
- assert(! intrsctn->consumed_vertical_up);
- assert(i_intersection + 1 < seg.intersections.size());
+ myassert(! intrsctn->consumed_vertical_up);
+ myassert(i_intersection + 1 < seg.intersections.size());
// Step back to the beginning of the vertical segment to mark it as consumed.
if (intrsctn->is_inner()) {
- assert(i_intersection > 0);
+ myassert(i_intersection > 0);
-- intrsctn;
-- i_intersection;
}
@@ -865,25 +1001,25 @@ Polylines FillRectilinear2::fill_surface(const Surface *surface, const FillParam
intrsctn->consumed_vertical_up = true;
++ intrsctn;
++ i_intersection;
- assert(i_intersection < seg.intersections.size());
+ myassert(i_intersection < seg.intersections.size());
} while (intrsctn->type != SegmentIntersection::OUTER_HIGH);
if ((intrsctn - 1)->is_inner()) {
// Step back.
-- intrsctn;
-- i_intersection;
- assert(intrsctn->type == SegmentIntersection::INNER_HIGH);
+ myassert(intrsctn->type == SegmentIntersection::INNER_HIGH);
try_connect = true;
}
} else {
// Going down.
- assert(intrsctn->is_high());
- assert(i_intersection > 0);
- assert(! (intrsctn - 1)->consumed_vertical_up);
+ myassert(intrsctn->is_high());
+ myassert(i_intersection > 0);
+ myassert(! (intrsctn - 1)->consumed_vertical_up);
// Consume the complete vertical segment up to the outer contour.
if (intrsctn->is_inner())
intrsctn->consumed_vertical_up = true;
do {
- assert(i_intersection > 0);
+ myassert(i_intersection > 0);
-- intrsctn;
-- i_intersection;
intrsctn->consumed_vertical_up = true;
@@ -892,7 +1028,7 @@ Polylines FillRectilinear2::fill_surface(const Surface *surface, const FillParam
// Step back.
++ intrsctn;
++ i_intersection;
- assert(intrsctn->type == SegmentIntersection::INNER_LOW);
+ myassert(intrsctn->type == SegmentIntersection::INNER_LOW);
try_connect = true;
}
}
@@ -901,31 +1037,81 @@ Polylines FillRectilinear2::fill_surface(const Surface *surface, const FillParam
int iPrev = intersection_unused_on_prev_vertical_line(poly_with_offset, segs, i_vline, intrsctn->iContour, i_intersection);
int iNext = intersection_unused_on_next_vertical_line(poly_with_offset, segs, i_vline, intrsctn->iContour, i_intersection);
if (iPrev != -1 || iNext != -1) {
- // Zig zag
- coord_t distPrev = (iPrev == -1) ? std::numeric_limits<coord_t>::max() :
- measure_perimeter_prev_segment_length(poly_with_offset, segs, i_vline, intrsctn->iContour, i_intersection, iPrev);
- coord_t distNext = (iNext == -1) ? std::numeric_limits<coord_t>::max() :
- measure_perimeter_next_segment_length(poly_with_offset, segs, i_vline, intrsctn->iContour, i_intersection, iNext);
- // Take the shorter path.
- bool take_next = (iPrev != -1 && iNext != -1) ? (distNext < distPrev) : distNext != -1;
- assert(intrsctn->is_inner());
- polyline_current->points.push_back(Point(seg.pos, intrsctn->pos));
- emit_perimeter_prev_next_segment(poly_with_offset, segs, i_vline, intrsctn->iContour, i_intersection, take_next ? iNext : iPrev, *polyline_current, take_next);
- // Mark both the left and right connecting segment as consumed, because one cannot go to this intersection point as it has been consumed.
- if (iPrev != -1)
- segs[i_vline-1].intersections[iPrev].consumed_perimeter_right = true;
- if (iNext != -1)
- intrsctn->consumed_perimeter_right = true;
- //FIXME consume the left / right connecting segments at the other end of this line? Currently it is not critical because a perimeter segment is not followed if the vertical segment at the other side has already been consumed.
- // Advance to the neighbor line.
- if (take_next) {
- ++ i_vline;
- i_intersection = iNext;
- } else {
- -- i_vline;
- i_intersection = iPrev;
+ // Does the perimeter intersect the current vertical line?
+ SegmentIntersection::SegmentIntersectionType type_crossing = (intrsctn->type == SegmentIntersection::INNER_LOW) ?
+ SegmentIntersection::INNER_HIGH : SegmentIntersection::INNER_LOW;
+ // Does the perimeter intersect the current vertical line above intrsctn?
+ int iSegAbove = -1;
+ for (size_t i = i_intersection + 1; i + 1 < seg.intersections.size(); ++ i)
+ if (seg.intersections[i].iContour == intrsctn->iContour &&
+ seg.intersections[i].type == type_crossing) {
+ iSegAbove = seg.intersections[i].iSegment;
+ break;
+ }
+ // Does the perimeter intersect the current vertical line below intrsctn?
+ int iSegBelow = -1;
+ for (size_t i = i_intersection - 1; i > 0; -- i)
+ if (seg.intersections[i].iContour == intrsctn->iContour &&
+ seg.intersections[i].type == type_crossing) {
+ iSegBelow = seg.intersections[i].iSegment;
+ break;
+ }
+ if (iSegBelow != -1 || iSegAbove != -1) {
+ // Invalidate iPrev resp. iNext, if the perimeter crosses the current vertical line earlier than iPrev resp. iNext.
+ // The perimeter contour orientation.
+ const bool forward = intrsctn->is_low(); // == poly_with_offset.is_contour_ccw(intrsctn->iContour);
+ const Polygon &poly = poly_with_offset.contour(intrsctn->iContour);
+ if (iPrev != -1) {
+ int d1 = distance_of_segmens(poly, segs[i_vline-1].intersections[iPrev].iSegment, intrsctn->iSegment, forward);
+ int d2 = (iSegBelow == -1) ? std::numeric_limits<int>::max() :
+ distance_of_segmens(poly, iSegBelow, intrsctn->iSegment, forward);
+ if (iSegAbove != -1)
+ d2 = std::min(d2, distance_of_segmens(poly, iSegAbove, intrsctn->iSegment, forward));
+ if (d2 < d1)
+ // The vertical crossing comes eralier than the prev crossing.
+ // Disable the perimeter going back.
+ iPrev = -1;
+ }
+ if (iNext != -1) {
+ int d1 = distance_of_segmens(poly, intrsctn->iSegment, segs[i_vline+1].intersections[iNext].iSegment, forward);
+ int d2 = (iSegBelow == -1) ? std::numeric_limits<int>::max() :
+ distance_of_segmens(poly, intrsctn->iSegment, iSegBelow, forward);
+ if (iSegAbove != -1)
+ d2 = std::min(d2, distance_of_segmens(poly, intrsctn->iSegment, iSegAbove, forward));
+ if (d2 < d1)
+ // The vertical crossing comes eralier than the prev crossing.
+ // Disable the perimeter going forward.
+ iNext = -1;
+ }
+ }
+ if (iPrev != -1 || iNext != -1) {
+ // Zig zag
+ coord_t distPrev = (iPrev == -1) ? std::numeric_limits<coord_t>::max() :
+ measure_perimeter_prev_segment_length(poly_with_offset, segs, i_vline, intrsctn->iContour, i_intersection, iPrev);
+ coord_t distNext = (iNext == -1) ? std::numeric_limits<coord_t>::max() :
+ measure_perimeter_next_segment_length(poly_with_offset, segs, i_vline, intrsctn->iContour, i_intersection, iNext);
+ // Take the shorter path.
+ bool take_next = (iPrev != -1 && iNext != -1) ? (distNext < distPrev) : iNext != -1;
+ myassert(intrsctn->is_inner());
+ pointLast = Point(seg.pos, intrsctn->pos);
+ polyline_current->points.push_back(pointLast);
+ emit_perimeter_prev_next_segment(poly_with_offset, segs, i_vline, intrsctn->iContour, i_intersection, take_next ? iNext : iPrev, *polyline_current, take_next);
+ // Mark both the left and right connecting segment as consumed, because one cannot go to this intersection point as it has been consumed.
+ if (iPrev != -1)
+ segs[i_vline-1].intersections[iPrev].consumed_perimeter_right = true;
+ if (iNext != -1)
+ intrsctn->consumed_perimeter_right = true;
+ //FIXME consume the left / right connecting segments at the other end of this line? Currently it is not critical because a perimeter segment is not followed if the vertical segment at the other side has already been consumed.
+ // Advance to the neighbor line.
+ if (take_next) {
+ ++ i_vline;
+ i_intersection = iNext;
+ } else {
+ -- i_vline;
+ i_intersection = iPrev;
+ }
+ continue;
}
- continue;
}
// Take the complete line up to the outer contour.
if (going_up)
@@ -935,21 +1121,69 @@ Polylines FillRectilinear2::fill_surface(const Surface *surface, const FillParam
}
// Finish the current vertical line,
// reset the current vertical line to pick a new starting point in the next round.
- assert(intrsctn->is_outer());
- assert(intrsctn->is_high() == going_up);
+ myassert(intrsctn->is_outer());
+ myassert(intrsctn->is_high() == going_up);
pointLast = Point(seg.pos, intrsctn->pos);
polyline_current->points.push_back(pointLast);
+ // Handle duplicate points and zero length segments.
+ polyline_current->remove_duplicate_points();
+ myassert(! polyline_current->has_duplicate_points());
+ // Handle nearly zero length edges.
+ if (polyline_current->points.size() <= 1 ||
+ (polyline_current->points.size() == 2 &&
+ std::abs(polyline_current->points.front().x - polyline_current->points.back().x) < SCALED_EPSILON &&
+ std::abs(polyline_current->points.front().y - polyline_current->points.back().y) < SCALED_EPSILON))
+ polylines_out.pop_back();
intrsctn = NULL;
i_intersection = -1;
polyline_current = NULL;
}
+#ifdef SLIC3R_DEBUG
+ {
+ sprintf(path, "out/FillRectilinear2-final-%d.svg", iRun);
+ ::Slic3r::SVG svg(path, bbox_svg); // , scale_(1.));
+ for (size_t i = 0; i < poly_with_offset.polygons_src.size(); ++ i)
+ svg.draw(poly_with_offset.polygons_src[i].lines());
+ for (size_t i = 0; i < poly_with_offset.polygons_outer.size(); ++ i)
+ svg.draw(poly_with_offset.polygons_outer[i].lines(), "green");
+ for (size_t i = 0; i < poly_with_offset.polygons_inner.size(); ++ i)
+ svg.draw(poly_with_offset.polygons_inner[i].lines(), "brown");
+ for (size_t i = n_polylines_out_initial; i < polylines_out.size(); ++ i)
+ svg.draw(polylines_out[i].lines(), "black");
+ }
+#endif /* SLIC3R_DEBUG */
+
// paths must be rotated back
- for (Polylines::iterator it = polylines_out.begin(); it != polylines_out.end(); ++ it) {
+ for (Polylines::iterator it = polylines_out.begin() + n_polylines_out_initial; it != polylines_out.end(); ++ it) {
// No need to translate, the absolute position is irrelevant.
// it->translate(- rotate_vector.second.x, - rotate_vector.second.y);
+ myassert(! it->has_duplicate_points());
it->rotate(rotate_vector.first);
+ //FIXME rather simplify the paths to avoid very short edges?
+ //myassert(! it->has_duplicate_points());
+ it->remove_duplicate_points();
}
+
+#ifdef SLIC3R_DEBUG
+ // Verify, that there are no duplicate points in the sequence.
+ for (Polylines::iterator it = polylines_out.begin(); it != polylines_out.end(); ++ it)
+ myassert(! it->has_duplicate_points());
+#endif /* SLIC3R_DEBUG */
+}
+
+Polylines FillRectilinear2::fill_surface(const Surface *surface, const FillParams &params)
+{
+ Polylines polylines_out;
+ fill_surface_by_lines(surface, params, 0.f, polylines_out);
+ return polylines_out;
+}
+
+Polylines FillGrid2::fill_surface(const Surface *surface, const FillParams &params)
+{
+ Polylines polylines_out;
+ fill_surface_by_lines(surface, params, 0.f, polylines_out);
+ fill_surface_by_lines(surface, params, float(M_PI / 2.), polylines_out);
return polylines_out;
}
diff --git a/xs/src/libslic3r/Fill/FillRectilinear2.hpp b/xs/src/libslic3r/Fill/FillRectilinear2.hpp
index 0c4473e4a..196563a2b 100644
--- a/xs/src/libslic3r/Fill/FillRectilinear2.hpp
+++ b/xs/src/libslic3r/Fill/FillRectilinear2.hpp
@@ -9,13 +9,15 @@ namespace Slic3r {
class Surface;
-class FillRectilinear2 : public FillWithDirection
+class FillRectilinear2 : public Fill
{
public:
virtual ~FillRectilinear2() {}
virtual Polylines fill_surface(const Surface *surface, const FillParams &params);
protected:
+ void fill_surface_by_lines(const Surface *surface, const FillParams &params, float angleBase, Polylines &polylines_out);
+
coord_t _min_spacing;
coord_t _line_spacing;
// distance threshold for allowing the horizontal infill lines to be connected into a continuous path
@@ -26,6 +28,7 @@ class FillGrid2 : public FillRectilinear2
{
public:
virtual ~FillGrid2() {}
+ virtual Polylines fill_surface(const Surface *surface, const FillParams &params);
protected:
// The grid fill will keep the angle constant between the layers, see the implementation of Slic3r::Fill::Base.
generated by cgit v1.2.3 (git 2.25.1) at 2024-09-08 04:40:40 +0300