Fix of [2.3.0-alpha4] Crash - several models cause crash when slicing #5208
Fixed some issues in internal anchors of the Adaptive Cubic infill. The ugly and dangerous implicit casting operators in Line, MultiPoint, Polyline and Polygon were made explicit.
This commit is contained in:
Vojtech Bubnik
parent
10c41290fd
commit
62bdc192d8
25 changed files with 237 additions and 110 deletions
|
|
@ -1069,7 +1069,7 @@ Polygons variable_offset_inner(const ExPolygon &expoly, const std::vector<std::v
|
|||
ClipperLib::Paths holes;
|
||||
holes.reserve(expoly.holes.size());
|
||||
for (const Polygon& hole : expoly.holes)
|
||||
append(holes, fix_after_outer_offset(mittered_offset_path_scaled(hole, deltas[1 + &hole - expoly.holes.data()], miter_limit), ClipperLib::pftNegative, false));
|
||||
append(holes, fix_after_outer_offset(mittered_offset_path_scaled(hole.points, deltas[1 + &hole - expoly.holes.data()], miter_limit), ClipperLib::pftNegative, false));
|
||||
#ifndef NDEBUG
|
||||
for (auto &c : holes)
|
||||
assert(ClipperLib::Area(c) > 0.);
|
||||
|
|
@ -1113,7 +1113,7 @@ for (const std::vector<float>& ds : deltas)
|
|||
ClipperLib::Paths holes;
|
||||
holes.reserve(expoly.holes.size());
|
||||
for (const Polygon& hole : expoly.holes)
|
||||
append(holes, fix_after_inner_offset(mittered_offset_path_scaled(hole, deltas[1 + &hole - expoly.holes.data()], miter_limit), ClipperLib::pftPositive, true));
|
||||
append(holes, fix_after_inner_offset(mittered_offset_path_scaled(hole.points, deltas[1 + &hole - expoly.holes.data()], miter_limit), ClipperLib::pftPositive, true));
|
||||
#ifndef NDEBUG
|
||||
for (auto &c : holes)
|
||||
assert(ClipperLib::Area(c) > 0.);
|
||||
|
|
@ -1157,7 +1157,7 @@ for (const std::vector<float>& ds : deltas)
|
|||
ClipperLib::Paths holes;
|
||||
holes.reserve(expoly.holes.size());
|
||||
for (const Polygon& hole : expoly.holes)
|
||||
append(holes, fix_after_inner_offset(mittered_offset_path_scaled(hole, deltas[1 + &hole - expoly.holes.data()], miter_limit), ClipperLib::pftPositive, true));
|
||||
append(holes, fix_after_inner_offset(mittered_offset_path_scaled(hole.points, deltas[1 + &hole - expoly.holes.data()], miter_limit), ClipperLib::pftPositive, true));
|
||||
#ifndef NDEBUG
|
||||
for (auto &c : holes)
|
||||
assert(ClipperLib::Area(c) > 0.);
|
||||
|
|
@ -1205,7 +1205,7 @@ ExPolygons variable_offset_inner_ex(const ExPolygon &expoly, const std::vector<s
|
|||
ClipperLib::Paths holes;
|
||||
holes.reserve(expoly.holes.size());
|
||||
for (const Polygon& hole : expoly.holes)
|
||||
append(holes, fix_after_outer_offset(mittered_offset_path_scaled(hole, deltas[1 + &hole - expoly.holes.data()], miter_limit), ClipperLib::pftNegative, false));
|
||||
append(holes, fix_after_outer_offset(mittered_offset_path_scaled(hole.points, deltas[1 + &hole - expoly.holes.data()], miter_limit), ClipperLib::pftNegative, false));
|
||||
#ifndef NDEBUG
|
||||
for (auto &c : holes)
|
||||
assert(ClipperLib::Area(c) > 0.);
|
||||
|
|
|
|||
|
|
@ -350,23 +350,10 @@ void ExPolygon::get_trapezoids2(Polygons* polygons) const
|
|||
// find trapezoids by looping from first to next-to-last coordinate
|
||||
for (std::vector<coord_t>::const_iterator x = xx.begin(); x != xx.end()-1; ++x) {
|
||||
coord_t next_x = *(x + 1);
|
||||
if (*x == next_x) continue;
|
||||
|
||||
// build rectangle
|
||||
Polygon poly;
|
||||
poly.points.resize(4);
|
||||
poly[0](0) = *x;
|
||||
poly[0](1) = bb.min(1);
|
||||
poly[1](0) = next_x;
|
||||
poly[1](1) = bb.min(1);
|
||||
poly[2](0) = next_x;
|
||||
poly[2](1) = bb.max(1);
|
||||
poly[3](0) = *x;
|
||||
poly[3](1) = bb.max(1);
|
||||
|
||||
// intersect with this expolygon
|
||||
// append results to return value
|
||||
polygons_append(*polygons, intersection(poly, to_polygons(*this)));
|
||||
if (*x != next_x)
|
||||
// intersect with rectangle
|
||||
// append results to return value
|
||||
polygons_append(*polygons, intersection({ { { *x, bb.min.y() }, { next_x, bb.min.y() }, { next_x, bb.max.y() }, { *x, bb.max.y() } } }, to_polygons(*this)));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -14,12 +14,12 @@ namespace Slic3r {
|
|||
|
||||
void ExtrusionPath::intersect_expolygons(const ExPolygonCollection &collection, ExtrusionEntityCollection* retval) const
|
||||
{
|
||||
this->_inflate_collection(intersection_pl(this->polyline, (Polygons)collection), retval);
|
||||
this->_inflate_collection(intersection_pl((Polylines)polyline, to_polygons(collection.expolygons)), retval);
|
||||
}
|
||||
|
||||
void ExtrusionPath::subtract_expolygons(const ExPolygonCollection &collection, ExtrusionEntityCollection* retval) const
|
||||
{
|
||||
this->_inflate_collection(diff_pl(this->polyline, (Polygons)collection), retval);
|
||||
this->_inflate_collection(diff_pl((Polylines)this->polyline, to_polygons(collection.expolygons)), retval);
|
||||
}
|
||||
|
||||
void ExtrusionPath::clip_end(double distance)
|
||||
|
|
|
|||
|
|
@ -37,7 +37,8 @@ struct SurfaceFillParams
|
|||
bool dont_adjust = false;
|
||||
// Length of the infill anchor along the perimeter line.
|
||||
// 1000mm is roughly the maximum length line that fits into a 32bit coord_t.
|
||||
float anchor_length = 1000.f;
|
||||
float anchor_length = 1000.f;
|
||||
float anchor_length_max = 1000.f;
|
||||
|
||||
// width, height of extrusion, nozzle diameter, is bridge
|
||||
// For the output, for fill generator.
|
||||
|
|
@ -68,6 +69,7 @@ struct SurfaceFillParams
|
|||
RETURN_COMPARE_NON_EQUAL(density);
|
||||
RETURN_COMPARE_NON_EQUAL_TYPED(unsigned, dont_adjust);
|
||||
RETURN_COMPARE_NON_EQUAL(anchor_length);
|
||||
RETURN_COMPARE_NON_EQUAL(anchor_length_max);
|
||||
RETURN_COMPARE_NON_EQUAL(flow.width);
|
||||
RETURN_COMPARE_NON_EQUAL(flow.height);
|
||||
RETURN_COMPARE_NON_EQUAL(flow.nozzle_diameter);
|
||||
|
|
@ -85,7 +87,8 @@ struct SurfaceFillParams
|
|||
this->angle == rhs.angle &&
|
||||
this->density == rhs.density &&
|
||||
this->dont_adjust == rhs.dont_adjust &&
|
||||
this->anchor_length == rhs.anchor_length &&
|
||||
this->anchor_length == rhs.anchor_length &&
|
||||
this->anchor_length_max == rhs.anchor_length_max &&
|
||||
this->flow == rhs.flow &&
|
||||
this->extrusion_role == rhs.extrusion_role;
|
||||
}
|
||||
|
|
@ -171,8 +174,12 @@ std::vector<SurfaceFill> group_fills(const Layer &layer)
|
|||
// Anchor a sparse infill to inner perimeters with the following anchor length:
|
||||
params.anchor_length = float(region_config.infill_anchor);
|
||||
if (region_config.infill_anchor.percent)
|
||||
params.anchor_length *= 0.01 * params.spacing;
|
||||
params.anchor_length = float(params.anchor_length * 0.01 * params.spacing);
|
||||
params.anchor_length_max = float(region_config.infill_anchor_max);
|
||||
if (region_config.infill_anchor_max.percent)
|
||||
params.anchor_length_max = float(params.anchor_length_max * 0.01 * params.spacing);
|
||||
}
|
||||
params.anchor_length = std::min(params.anchor_length, params.anchor_length_max);
|
||||
|
||||
auto it_params = set_surface_params.find(params);
|
||||
if (it_params == set_surface_params.end())
|
||||
|
|
@ -376,9 +383,10 @@ void Layer::make_fills(FillAdaptive::Octree* adaptive_fill_octree, FillAdaptive:
|
|||
|
||||
// apply half spacing using this flow's own spacing and generate infill
|
||||
FillParams params;
|
||||
params.density = float(0.01 * surface_fill.params.density);
|
||||
params.dont_adjust = surface_fill.params.dont_adjust; // false
|
||||
params.anchor_length = surface_fill.params.anchor_length;
|
||||
params.density = float(0.01 * surface_fill.params.density);
|
||||
params.dont_adjust = surface_fill.params.dont_adjust; // false
|
||||
params.anchor_length = surface_fill.params.anchor_length;
|
||||
params.anchor_length_max = surface_fill.params.anchor_length_max;
|
||||
|
||||
for (ExPolygon &expoly : surface_fill.expolygons) {
|
||||
// Spacing is modified by the filler to indicate adjustments. Reset it for each expolygon.
|
||||
|
|
|
|||
|
|
@ -667,9 +667,26 @@ static inline rtree_segment_t mk_rtree_seg(const Line &l) {
|
|||
// Create a hook based on hook_line and append it to the begin or end of the polyline in the intersection
|
||||
static void add_hook(
|
||||
const Intersection &intersection, const double scaled_offset,
|
||||
const int hook_length, double scaled_trim_distance,
|
||||
const coordf_t hook_length, double scaled_trim_distance,
|
||||
const rtree_t &rtree, const Lines &lines_src)
|
||||
{
|
||||
if (hook_length < SCALED_EPSILON)
|
||||
// Ignore open hooks.
|
||||
return;
|
||||
|
||||
#ifndef NDEBUG
|
||||
{
|
||||
const Vec2d v = (intersection.closest_line->b - intersection.closest_line->a).cast<double>();
|
||||
const Vec2d va = (intersection.intersect_point - intersection.closest_line->a).cast<double>();
|
||||
const double l2 = v.squaredNorm(); // avoid a sqrt
|
||||
assert(l2 > 0.);
|
||||
const double t = va.dot(v) / l2;
|
||||
assert(t > 0. && t < 1.);
|
||||
const double d = (t * v - va).norm();
|
||||
assert(d < 1000.);
|
||||
}
|
||||
#endif // NDEBUG
|
||||
|
||||
// Trim the hook start by the infill line it will connect to.
|
||||
Point hook_start;
|
||||
bool intersection_found = intersection.intersect_line->intersection(
|
||||
|
|
@ -700,7 +717,7 @@ static void add_hook(
|
|||
const std::vector<std::pair<rtree_segment_t, size_t>> &hook_intersections,
|
||||
bool self_intersection, const std::optional<Line> &self_intersection_line, const Point &self_intersection_point) {
|
||||
// No hook is longer than hook_length, there shouldn't be any intersection closer than that.
|
||||
auto max_length = double(hook_length);
|
||||
auto max_length = hook_length;
|
||||
auto update_max_length = [&max_length](double d) {
|
||||
if (d < max_length)
|
||||
max_length = d;
|
||||
|
|
@ -757,15 +774,32 @@ static void add_hook(
|
|||
}
|
||||
}
|
||||
|
||||
static Polylines connect_lines_using_hooks(Polylines &&lines, const ExPolygon &boundary, const double spacing, const int hook_length)
|
||||
#ifndef NDEBUG
|
||||
bool validate_intersection_t_joint(const Intersection &intersection)
|
||||
{
|
||||
const Vec2d v = (intersection.closest_line->b - intersection.closest_line->a).cast<double>();
|
||||
const Vec2d va = (intersection.intersect_point - intersection.closest_line->a).cast<double>();
|
||||
const double l2 = v.squaredNorm(); // avoid a sqrt
|
||||
assert(l2 > 0.);
|
||||
const double t = va.dot(v);
|
||||
assert(t > SCALED_EPSILON && t < l2 - SCALED_EPSILON);
|
||||
const double d = ((t / l2) * v - va).norm();
|
||||
assert(d < 1000.);
|
||||
return true;
|
||||
}
|
||||
bool validate_intersections(const std::vector<Intersection> &intersections)
|
||||
{
|
||||
for (const Intersection& intersection : intersections)
|
||||
assert(validate_intersection_t_joint(intersection));
|
||||
return true;
|
||||
}
|
||||
#endif // NDEBUG
|
||||
|
||||
static Polylines connect_lines_using_hooks(Polylines &&lines, const ExPolygon &boundary, const double spacing, const coordf_t hook_length, const coordf_t hook_length_max)
|
||||
{
|
||||
rtree_t rtree;
|
||||
size_t poly_idx = 0;
|
||||
|
||||
Lines lines_src;
|
||||
lines_src.reserve(lines.size());
|
||||
std::transform(lines.begin(), lines.end(), std::back_inserter(lines_src), [](const Line& l) { return Polyline{ l.a, l.b }; });
|
||||
|
||||
// 19% overlap, slightly lower than the allowed overlap in Fill::connect_infill()
|
||||
const float scaled_offset = float(scale_(spacing) * 0.81);
|
||||
// 25% overlap
|
||||
|
|
@ -814,16 +848,19 @@ static Polylines connect_lines_using_hooks(Polylines &&lines, const ExPolygon &b
|
|||
}
|
||||
return std::make_pair(static_cast<Polyline*>(nullptr), false);
|
||||
};
|
||||
auto collinear_front = collinear_segment(poly.points.front(), poly.points.back(), &poly);
|
||||
auto collinear_front = collinear_segment(poly.points.front(), poly.points.back(), &poly);
|
||||
auto collinear_back = collinear_segment(poly.points.back(), poly.points.front(), &poly);
|
||||
assert(! collinear_front.first || ! collinear_back.first || collinear_front.first != collinear_back.first);
|
||||
if (collinear_front.first) {
|
||||
Polyline &other = *collinear_front.first;
|
||||
assert(&other != &poly);
|
||||
poly.points.front() = collinear_front.second ? other.points.back() : other.points.front();
|
||||
other.points.clear();
|
||||
}
|
||||
auto collinear_back = collinear_segment(poly.points.back(), poly.points.front(), &poly);
|
||||
if (collinear_back.first) {
|
||||
Polyline &other = *collinear_front.first;
|
||||
poly.points.back() = collinear_front.second ? other.points.back() : other.points.front();
|
||||
Polyline &other = *collinear_back.first;
|
||||
assert(&other != &poly);
|
||||
poly.points.back() = collinear_back.second ? other.points.back() : other.points.front();
|
||||
other.points.clear();
|
||||
}
|
||||
}
|
||||
|
|
@ -831,6 +868,12 @@ static Polylines connect_lines_using_hooks(Polylines &&lines, const ExPolygon &b
|
|||
}
|
||||
}
|
||||
|
||||
// Convert input polylines to lines_src after the colinear segments were merged.
|
||||
Lines lines_src;
|
||||
lines_src.reserve(lines.size());
|
||||
std::transform(lines.begin(), lines.end(), std::back_inserter(lines_src), [](const Polyline &pl) {
|
||||
return pl.empty() ? Line(Point(0, 0), Point(0, 0)) : Line(pl.points.front(), pl.points.back()); });
|
||||
|
||||
sort_remove_duplicates(lines_touching_at_endpoints);
|
||||
|
||||
std::vector<Intersection> intersections;
|
||||
|
|
@ -854,23 +897,38 @@ static Polylines connect_lines_using_hooks(Polylines &&lines, const ExPolygon &b
|
|||
// Find the nearest line from the start point of the line.
|
||||
std::optional<size_t> tjoint_front, tjoint_back;
|
||||
{
|
||||
auto has_tjoint = [&closest, line_idx, &rtree, &lines](const Point &pt) {
|
||||
auto filter_itself = [line_idx](const auto &item) { return item.second != line_idx; };
|
||||
auto has_tjoint = [&closest, line_idx, &rtree, &lines, &lines_src](const Point &pt) {
|
||||
auto filter_t_joint = [line_idx, &lines_src, pt](const auto &item) {
|
||||
if (item.second != line_idx) {
|
||||
// Verify that the point projects onto the line.
|
||||
const Line &line = lines_src[item.second];
|
||||
const Vec2d v = (line.b - line.a).cast<double>();
|
||||
const Vec2d va = (pt - line.a).cast<double>();
|
||||
const double l2 = v.squaredNorm(); // avoid a sqrt
|
||||
if (l2 > 0.) {
|
||||
const double t = va.dot(v);
|
||||
return t > SCALED_EPSILON && t < l2 - SCALED_EPSILON;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
};
|
||||
closest.clear();
|
||||
rtree.query(bgi::nearest(mk_rtree_point(pt), 1) && bgi::satisfies(filter_itself), std::back_inserter(closest));
|
||||
const Polyline &pl = lines[closest.front().second];
|
||||
rtree.query(bgi::nearest(mk_rtree_point(pt), 1) && bgi::satisfies(filter_t_joint), std::back_inserter(closest));
|
||||
std::optional<size_t> out;
|
||||
if (pl.points.empty()) {
|
||||
// The closest infill line was already dropped as it was too short.
|
||||
// Such an infill line should not make a T-joint anyways.
|
||||
#if 0 // #ifndef NDEBUG
|
||||
const auto &seg = closest.front().first;
|
||||
struct Linef { Vec2d a; Vec2d b; };
|
||||
Linef l { { bg::get<0, 0>(seg), bg::get<0, 1>(seg) }, { bg::get<1, 0>(seg), bg::get<1, 1>(seg) } };
|
||||
assert(line_alg::distance_to_squared(l, Vec2d(pt.cast<double>())) > 1000 * 1000);
|
||||
#endif // NDEBUG
|
||||
} else if (((Line)pl).distance_to_squared(pt) <= 1000 * 1000)
|
||||
out = closest.front().second;
|
||||
if (! closest.empty()) {
|
||||
const Polyline &pl = lines[closest.front().second];
|
||||
if (pl.points.empty()) {
|
||||
// The closest infill line was already dropped as it was too short.
|
||||
// Such an infill line should not make a T-joint anyways.
|
||||
#if 0 // #ifndef NDEBUG
|
||||
const auto &seg = closest.front().first;
|
||||
struct Linef { Vec2d a; Vec2d b; };
|
||||
Linef l { { bg::get<0, 0>(seg), bg::get<0, 1>(seg) }, { bg::get<1, 0>(seg), bg::get<1, 1>(seg) } };
|
||||
assert(line_alg::distance_to_squared(l, Vec2d(pt.cast<double>())) > 1000 * 1000);
|
||||
#endif // NDEBUG
|
||||
} else if (((Line)pl).distance_to_squared(pt) <= 1000 * 1000)
|
||||
out = closest.front().second;
|
||||
}
|
||||
return out;
|
||||
};
|
||||
// Refuse to create a T-joint if the infill lines touch at their ends.
|
||||
|
|
@ -912,12 +970,16 @@ static Polylines connect_lines_using_hooks(Polylines &&lines, const ExPolygon &b
|
|||
// A shorter line than spacing could produce a degenerate polyline.
|
||||
line.points.clear();
|
||||
} else if (anchor) {
|
||||
if (tjoint_front)
|
||||
if (tjoint_front) {
|
||||
// T-joint of line's front point with the 'closest' line.
|
||||
intersections.emplace_back(lines_src[*tjoint_front], lines_src[line_idx], &line, front_point, true);
|
||||
if (tjoint_back)
|
||||
assert(validate_intersection_t_joint(intersections.back()));
|
||||
}
|
||||
if (tjoint_back) {
|
||||
// T-joint of line's back point with the 'closest' line.
|
||||
intersections.emplace_back(lines_src[*tjoint_back], lines_src[line_idx], &line, back_point, false);
|
||||
assert(validate_intersection_t_joint(intersections.back()));
|
||||
}
|
||||
} else {
|
||||
if (tjoint_front)
|
||||
// T joint at the front at a 60 degree angle, the line is very short.
|
||||
|
|
@ -940,6 +1002,7 @@ static Polylines connect_lines_using_hooks(Polylines &&lines, const ExPolygon &b
|
|||
++ it;
|
||||
}
|
||||
}
|
||||
assert(validate_intersections(intersections));
|
||||
|
||||
#ifdef ADAPTIVE_CUBIC_INFILL_DEBUG_OUTPUT
|
||||
static int iRun = 0;
|
||||
|
|
@ -1106,7 +1169,7 @@ static Polylines connect_lines_using_hooks(Polylines &&lines, const ExPolygon &b
|
|||
}
|
||||
Points &first_points = first_i.intersect_pl->points;
|
||||
Points &second_points = nearest_i.intersect_pl->points;
|
||||
could_connect &= (nearest_i_point - first_i_point).cast<double>().squaredNorm() <= Slic3r::sqr(3. * hook_length);
|
||||
could_connect &= (nearest_i_point - first_i_point).cast<double>().squaredNorm() <= Slic3r::sqr(hook_length_max);
|
||||
if (could_connect) {
|
||||
// Both intersections are so close that their polylines can be connected.
|
||||
// Verify that no other infill line intersects this anchor line.
|
||||
|
|
@ -1219,7 +1282,7 @@ bool has_no_collinear_lines(const Polylines &polylines)
|
|||
const Point* operator()(const LineEnd &pt) const { return &pt.point(); }
|
||||
};
|
||||
typedef ClosestPointInRadiusLookup<LineEnd, LineEndAccessor> ClosestPointLookupType;
|
||||
ClosestPointLookupType closest_end_point_lookup(1001. * sqrt(2.));
|
||||
ClosestPointLookupType closest_end_point_lookup(coord_t(1001. * sqrt(2.)));
|
||||
for (const Polyline& pl : polylines) {
|
||||
// assert(pl.points.size() == 2);
|
||||
auto line_start = LineEnd(&pl, true);
|
||||
|
|
@ -1321,9 +1384,10 @@ void Filler::_fill_surface_single(
|
|||
}
|
||||
#endif /* ADAPTIVE_CUBIC_INFILL_DEBUG_OUTPUT */
|
||||
|
||||
const auto hook_length = coord_t(std::min(scale_(this->spacing * 5), scale_(params.anchor_length)));
|
||||
const auto hook_length = coordf_t(std::min<float>(std::numeric_limits<coord_t>::max(), scale_(params.anchor_length)));
|
||||
const auto hook_length_max = coordf_t(std::min<float>(std::numeric_limits<coord_t>::max(), scale_(params.anchor_length_max)));
|
||||
|
||||
Polylines all_polylines_with_hooks = all_polylines.size() > 1 ? connect_lines_using_hooks(std::move(all_polylines), expolygon, this->spacing, hook_length) : std::move(all_polylines);
|
||||
Polylines all_polylines_with_hooks = all_polylines.size() > 1 ? connect_lines_using_hooks(std::move(all_polylines), expolygon, this->spacing, hook_length, hook_length_max) : std::move(all_polylines);
|
||||
|
||||
#ifdef ADAPTIVE_CUBIC_INFILL_DEBUG_OUTPUT
|
||||
{
|
||||
|
|
|
|||
|
|
@ -200,10 +200,10 @@ struct ContourIntersectionPoint {
|
|||
|
||||
// Could extrude a complete segment from this to this->prev_on_contour.
|
||||
bool could_connect_prev() const throw()
|
||||
{ return ! this->consumed && this->prev_on_contour && ! this->prev_on_contour->consumed && ! this->prev_trimmed && ! this->prev_on_contour->next_trimmed; }
|
||||
{ return ! this->consumed && this->prev_on_contour != this && ! this->prev_on_contour->consumed && ! this->prev_trimmed && ! this->prev_on_contour->next_trimmed; }
|
||||
// Could extrude a complete segment from this to this->next_on_contour.
|
||||
bool could_connect_next() const throw()
|
||||
{ return ! this->consumed && this->next_on_contour && ! this->next_on_contour->consumed && ! this->next_trimmed && ! this->next_on_contour->prev_trimmed; }
|
||||
{ return ! this->consumed && this->next_on_contour != this && ! this->next_on_contour->consumed && ! this->next_trimmed && ! this->next_on_contour->prev_trimmed; }
|
||||
};
|
||||
|
||||
// Distance from param1 to param2 when going counter-clockwise.
|
||||
|
|
@ -390,7 +390,12 @@ static void take(Polyline &pl1, const Polyline &pl2, const Points &contour, size
|
|||
|
||||
static void take(Polyline &pl1, const Polyline &pl2, const Points &contour, ContourIntersectionPoint *cp_start, ContourIntersectionPoint *cp_end, bool clockwise)
|
||||
{
|
||||
assert(cp_start->prev_on_contour != nullptr);
|
||||
assert(cp_start->next_on_contour != nullptr);
|
||||
assert(cp_end ->prev_on_contour != nullptr);
|
||||
assert(cp_end ->next_on_contour != nullptr);
|
||||
assert(cp_start != cp_end);
|
||||
|
||||
take(pl1, pl2, contour, cp_start->point_idx, cp_end->point_idx, clockwise);
|
||||
|
||||
// Mark the contour segments in between cp_start and cp_end as consumed.
|
||||
|
|
@ -410,7 +415,12 @@ static void take_limited(
|
|||
ContourIntersectionPoint *cp_start, ContourIntersectionPoint *cp_end, bool clockwise, float take_max_length, float line_half_width)
|
||||
{
|
||||
#ifndef NDEBUG
|
||||
assert(cp_start != cp_end);
|
||||
// This is a valid case, where a single infill line connect to two different contours (outer contour + hole or two holes).
|
||||
// assert(cp_start != cp_end);
|
||||
assert(cp_start->prev_on_contour != nullptr);
|
||||
assert(cp_start->next_on_contour != nullptr);
|
||||
assert(cp_end ->prev_on_contour != nullptr);
|
||||
assert(cp_end ->next_on_contour != nullptr);
|
||||
assert(pl1.size() >= 2);
|
||||
assert(contour.size() + 1 == params.size());
|
||||
#endif /* NDEBUG */
|
||||
|
|
@ -438,8 +448,18 @@ static void take_limited(
|
|||
float length = params.back();
|
||||
float length_to_go = take_max_length;
|
||||
cp_start->consumed = true;
|
||||
if (clockwise) {
|
||||
if (cp_start == cp_end) {
|
||||
length_to_go = std::max(0.f, std::min(length_to_go, length - line_half_width));
|
||||
length_to_go = std::min(length_to_go, clockwise ? cp_start->contour_not_taken_length_prev : cp_start->contour_not_taken_length_next);
|
||||
cp_start->consume_prev();
|
||||
cp_start->consume_next();
|
||||
if (length_to_go > SCALED_EPSILON)
|
||||
clockwise ?
|
||||
take_cw_limited (pl1, contour, params, cp_start->point_idx, cp_start->point_idx, length_to_go) :
|
||||
take_ccw_limited(pl1, contour, params, cp_start->point_idx, cp_start->point_idx, length_to_go);
|
||||
} else if (clockwise) {
|
||||
// Going clockwise from cp_start to cp_end.
|
||||
assert(cp_start != cp_end);
|
||||
for (ContourIntersectionPoint *cp = cp_start; cp != cp_end; cp = cp->prev_on_contour) {
|
||||
// Length of the segment from cp to cp->prev_on_contour.
|
||||
float l = closed_contour_distance_cw(cp->param, cp->prev_on_contour->param, length);
|
||||
|
|
@ -461,6 +481,7 @@ static void take_limited(
|
|||
}
|
||||
}
|
||||
} else {
|
||||
assert(cp_start != cp_end);
|
||||
for (ContourIntersectionPoint *cp = cp_start; cp != cp_end; cp = cp->next_on_contour) {
|
||||
float l = closed_contour_distance_ccw(cp->param, cp->next_on_contour->param, length);
|
||||
length_to_go = std::min(length_to_go, cp->contour_not_taken_length_next);
|
||||
|
|
@ -869,6 +890,10 @@ void mark_boundary_segments_touching_infill(
|
|||
for (auto it_contour_and_segment = cell_data_range.first; it_contour_and_segment != cell_data_range.second; ++ it_contour_and_segment) {
|
||||
// End points of the line segment and their vector.
|
||||
auto segment = this->grid.segment(*it_contour_and_segment);
|
||||
std::vector<ContourIntersectionPoint*> &intersections = boundary_intersections[it_contour_and_segment->first];
|
||||
if (intersections.empty())
|
||||
// There is no infil line touching this contour, thus effort will be saved to calculate overlap with other infill lines.
|
||||
continue;
|
||||
const Vec2d seg_pt1 = segment.first.cast<double>();
|
||||
const Vec2d seg_pt2 = segment.second.cast<double>();
|
||||
std::pair<double, double> interval;
|
||||
|
|
@ -892,20 +917,23 @@ void mark_boundary_segments_touching_infill(
|
|||
const float param_overlap1 = param_seg_pt1 + interval.first;
|
||||
const float param_overlap2 = param_seg_pt1 + interval.second;
|
||||
// 2) Find the ContourIntersectionPoints before param_overlap1 and after param_overlap2.
|
||||
std::vector<ContourIntersectionPoint*> &intersections = boundary_intersections[it_contour_and_segment->first];
|
||||
// Find the span of ContourIntersectionPoints, that is trimmed by the interval (param_overlap1, param_overlap2).
|
||||
ContourIntersectionPoint *ip_low, *ip_high;
|
||||
{
|
||||
if (intersections.size() == 1) {
|
||||
// Only a single infill line touches this contour.
|
||||
ip_low = ip_high = intersections.front();
|
||||
} else {
|
||||
assert(intersections.size() > 1);
|
||||
auto it_low = Slic3r::lower_bound_by_predicate(intersections.begin(), intersections.end(), [param_overlap1](const ContourIntersectionPoint *l) { return l->param < param_overlap1; });
|
||||
auto it_high = Slic3r::lower_bound_by_predicate(intersections.begin(), intersections.end(), [param_overlap2](const ContourIntersectionPoint *l) { return l->param < param_overlap2; });
|
||||
ip_low = it_low == intersections.end() ? intersections.front() : *it_low;
|
||||
ip_high = it_high == intersections.end() ? intersections.front() : *it_high;
|
||||
if (ip_low->param != param_overlap1)
|
||||
ip_low = ip_low->prev_on_contour;
|
||||
assert(ip_low != ip_high);
|
||||
// Verify that the interval (param_overlap1, param_overlap2) is inside the interval (ip_low->param, ip_high->param).
|
||||
assert(cyclic_interval_inside_interval(ip_low->param, ip_high->param, param_overlap1, param_overlap2, contour_length));
|
||||
}
|
||||
assert(ip_low != ip_high);
|
||||
// Verify that the interval (param_overlap1, param_overlap2) is inside the interval (ip_low->param, ip_high->param).
|
||||
assert(cyclic_interval_inside_interval(ip_low->param, ip_high->param, param_overlap1, param_overlap2, contour_length));
|
||||
assert(validate_boundary_intersections(boundary_intersections));
|
||||
// Mark all ContourIntersectionPoints between ip_low and ip_high as consumed.
|
||||
if (ip_low->next_on_contour != ip_high)
|
||||
|
|
@ -1068,8 +1096,11 @@ void Fill::connect_infill(Polylines &&infill_ordered, const Polygons &boundary_s
|
|||
void Fill::connect_infill(Polylines &&infill_ordered, const std::vector<const Polygon*> &boundary_src, const BoundingBox &bbox, Polylines &polylines_out, const double spacing, const FillParams ¶ms)
|
||||
{
|
||||
assert(! infill_ordered.empty());
|
||||
assert(params.anchor_length >= 0.01f);
|
||||
const auto anchor_length = float(scale_(params.anchor_length));
|
||||
assert(params.anchor_length >= 0.f);
|
||||
assert(params.anchor_length_max >= 0.01f);
|
||||
assert(params.anchor_length_max >= params.anchor_length);
|
||||
const auto anchor_length = float(scale_(params.anchor_length));
|
||||
const auto anchor_length_max = float(scale_(params.anchor_length_max));
|
||||
|
||||
#if 0
|
||||
append(polylines_out, infill_ordered);
|
||||
|
|
@ -1097,7 +1128,7 @@ void Fill::connect_infill(Polylines &&infill_ordered, const std::vector<const Po
|
|||
EdgeGrid::Grid::ClosestPointResult cp = grid.closest_point(*pt, SCALED_EPSILON);
|
||||
if (cp.valid()) {
|
||||
// The infill end point shall lie on the contour.
|
||||
assert(cp.distance < 2.);
|
||||
assert(cp.distance <= 3.);
|
||||
intersection_points.emplace_back(cp, (&pl - infill_ordered.data()) * 2 + (pt == &pl.points.front() ? 0 : 1));
|
||||
}
|
||||
}
|
||||
|
|
@ -1154,7 +1185,7 @@ void Fill::connect_infill(Polylines &&infill_ordered, const std::vector<const Po
|
|||
//add new point here
|
||||
contour_dst.emplace_back(pt);
|
||||
}
|
||||
if (pprev != pfirst) {
|
||||
if (pfirst) {
|
||||
pprev->next_on_contour = pfirst;
|
||||
pfirst->prev_on_contour = pprev;
|
||||
}
|
||||
|
|
@ -1170,10 +1201,15 @@ void Fill::connect_infill(Polylines &&infill_ordered, const std::vector<const Po
|
|||
ip->param = contour_params[ip->point_idx];
|
||||
// and measure distance to the previous and next intersection point.
|
||||
const float contour_length = contour_params.back();
|
||||
for (ContourIntersectionPoint *ip : contour_intersection_points) {
|
||||
ip->contour_not_taken_length_prev = closed_contour_distance_ccw(ip->prev_on_contour->param, ip->param, contour_length);
|
||||
ip->contour_not_taken_length_next = closed_contour_distance_ccw(ip->param, ip->next_on_contour->param, contour_length);
|
||||
}
|
||||
for (ContourIntersectionPoint *ip : contour_intersection_points)
|
||||
if (ip->next_on_contour == ip) {
|
||||
assert(ip->prev_on_contour == ip);
|
||||
ip->contour_not_taken_length_prev = ip->contour_not_taken_length_next = contour_length;
|
||||
} else {
|
||||
assert(ip->prev_on_contour != ip);
|
||||
ip->contour_not_taken_length_prev = closed_contour_distance_ccw(ip->prev_on_contour->param, ip->param, contour_length);
|
||||
ip->contour_not_taken_length_next = closed_contour_distance_ccw(ip->param, ip->next_on_contour->param, contour_length);
|
||||
}
|
||||
}
|
||||
|
||||
assert(boundary.size() == boundary_src.size());
|
||||
|
|
@ -1277,7 +1313,7 @@ void Fill::connect_infill(Polylines &&infill_ordered, const std::vector<const Po
|
|||
idx_first = get_and_update_merged_with(idx_first);
|
||||
assert(idx_first < idx_second);
|
||||
assert(idx_second == merged_with[idx_second]);
|
||||
if (could_connect && length < anchor_length * 2.5) {
|
||||
if (could_connect && length < anchor_length_max) {
|
||||
// Take the complete contour.
|
||||
// Connect the two polygons using the boundary contour.
|
||||
take(infill_ordered[idx_first], infill_ordered[idx_second], boundary[cp1->contour_idx], cp1, cp2, connection_cost.reversed);
|
||||
|
|
@ -1299,10 +1335,11 @@ void Fill::connect_infill(Polylines &&infill_ordered, const std::vector<const Po
|
|||
std::vector<Arc> arches;
|
||||
arches.reserve(map_infill_end_point_to_boundary.size());
|
||||
for (ContourIntersectionPoint &cp : map_infill_end_point_to_boundary)
|
||||
if (! cp.contour_idx != boundary_idx_unconnected && cp.next_on_contour != &cp && cp.could_connect_next())
|
||||
if (cp.contour_idx != boundary_idx_unconnected && cp.next_on_contour != &cp && cp.could_connect_next())
|
||||
arches.push_back({ &cp, path_length_along_contour_ccw(&cp, cp.next_on_contour, boundary_params[cp.contour_idx].back()) });
|
||||
std::sort(arches.begin(), arches.end(), [](const auto &l, const auto &r) { return l.arc_length < r.arc_length; });
|
||||
|
||||
//FIXME improve the Traveling Salesman problem with 2-opt and 3-opt local optimization.
|
||||
for (Arc &arc : arches)
|
||||
if (! arc.intersection->consumed && ! arc.intersection->next_on_contour->consumed) {
|
||||
// Indices of the polylines to be connected by a perimeter segment.
|
||||
|
|
@ -1315,7 +1352,7 @@ void Fill::connect_infill(Polylines &&infill_ordered, const std::vector<const Po
|
|||
if (polyline_idx1 != polyline_idx2) {
|
||||
Polyline &polyline1 = infill_ordered[polyline_idx1];
|
||||
Polyline &polyline2 = infill_ordered[polyline_idx2];
|
||||
if (arc.arc_length < anchor_length * 2.5) {
|
||||
if (arc.arc_length < anchor_length_max) {
|
||||
// Not closing a loop, connecting the lines.
|
||||
assert(contour[cp1->point_idx] == polyline1.points.front() || contour[cp1->point_idx] == polyline1.points.back());
|
||||
if (contour[cp1->point_idx] == polyline1.points.front())
|
||||
|
|
@ -1333,7 +1370,7 @@ void Fill::connect_infill(Polylines &&infill_ordered, const std::vector<const Po
|
|||
polyline2.points.clear();
|
||||
merged_with[polyline_idx2] = merged_with[polyline_idx1];
|
||||
}
|
||||
} else {
|
||||
} else if (anchor_length > SCALED_EPSILON) {
|
||||
// Move along the perimeter, but don't take the whole arc.
|
||||
take_limited(polyline1, contour, contour_params, cp1, cp2, false, anchor_length, line_half_width);
|
||||
take_limited(polyline2, contour, contour_params, cp2, cp1, true, anchor_length, line_half_width);
|
||||
|
|
@ -1360,7 +1397,7 @@ void Fill::connect_infill(Polylines &&infill_ordered, const std::vector<const Po
|
|||
assert(contour[contour_point.point_idx] == polyline.points.front() || contour[contour_point.point_idx] == polyline.points.back());
|
||||
bool connected = false;
|
||||
for (float l : { std::min(lprev, lnext), std::max(lprev, lnext) }) {
|
||||
if (l == std::numeric_limits<float>::max() || l > anchor_length * 2.5)
|
||||
if (l == std::numeric_limits<float>::max() || l > anchor_length_max)
|
||||
break;
|
||||
// Take the complete contour.
|
||||
bool reversed = l == lprev;
|
||||
|
|
@ -1392,7 +1429,7 @@ void Fill::connect_infill(Polylines &&infill_ordered, const std::vector<const Po
|
|||
connected = true;
|
||||
break;
|
||||
}
|
||||
if (! connected) {
|
||||
if (! connected && anchor_length > SCALED_EPSILON) {
|
||||
// Which to take? One could optimize for:
|
||||
// 1) Shortest path
|
||||
// 2) Hook length
|
||||
|
|
|
|||
|
|
@ -34,14 +34,15 @@ struct FillParams
|
|||
{
|
||||
bool full_infill() const { return density > 0.9999f; }
|
||||
// Don't connect the fill lines around the inner perimeter.
|
||||
bool dont_connect() const { return anchor_length < 0.05f; }
|
||||
bool dont_connect() const { return anchor_length_max < 0.05f; }
|
||||
|
||||
// Fill density, fraction in <0, 1>
|
||||
float density { 0.f };
|
||||
|
||||
// Length of an infill anchor along the perimeter.
|
||||
// 1000mm is roughly the maximum length line that fits into a 32bit coord_t.
|
||||
float anchor_length { 1000.f };
|
||||
float anchor_length { 1000.f };
|
||||
float anchor_length_max { 1000.f };
|
||||
|
||||
// Don't adjust spacing to fill the space evenly.
|
||||
bool dont_adjust { true };
|
||||
|
|
|
|||
|
|
@ -39,7 +39,7 @@ void FillConcentric::_fill_surface_single(
|
|||
size_t iPathFirst = polylines_out.size();
|
||||
Point last_pos(0, 0);
|
||||
for (const Polygon &loop : loops) {
|
||||
polylines_out.push_back(loop.split_at_index(last_pos.nearest_point_index(loop)));
|
||||
polylines_out.push_back(loop.split_at_index(last_pos.nearest_point_index(loop.points)));
|
||||
last_pos = polylines_out.back().last_point();
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -49,7 +49,7 @@ Slic3r::arrangement::ArrangePolygon get_arrange_poly(const Model &model)
|
|||
std::copy(pts.begin(), pts.end(), std::back_inserter(apts));
|
||||
}
|
||||
|
||||
apts = Geometry::convex_hull(apts);
|
||||
apts = std::move(Geometry::convex_hull(apts).points);
|
||||
return ap;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -264,7 +264,7 @@ Point MotionPlannerEnv::nearest_env_point(const Point &from, const Point &to) co
|
|||
for (const ExPolygon &ex : m_env.expolygons) {
|
||||
for (const Polygon &hole : ex.holes)
|
||||
if (hole.contains(from))
|
||||
pp = hole;
|
||||
pp = hole.points;
|
||||
if (! pp.empty())
|
||||
break;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -17,8 +17,6 @@ class MultiPoint
|
|||
public:
|
||||
Points points;
|
||||
|
||||
operator Points() const { return this->points; }
|
||||
|
||||
MultiPoint() {}
|
||||
MultiPoint(const MultiPoint &other) : points(other.points) {}
|
||||
MultiPoint(MultiPoint &&other) : points(std::move(other.points)) {}
|
||||
|
|
|
|||
|
|
@ -158,7 +158,7 @@ static ExtrusionEntityCollection traverse_loops(const PerimeterGenerator &perime
|
|||
// get non-overhang paths by intersecting this loop with the grown lower slices
|
||||
extrusion_paths_append(
|
||||
paths,
|
||||
intersection_pl(loop.polygon, perimeter_generator.lower_slices_polygons()),
|
||||
intersection_pl((Polygons)loop.polygon, perimeter_generator.lower_slices_polygons()),
|
||||
role,
|
||||
is_external ? perimeter_generator.ext_mm3_per_mm() : perimeter_generator.mm3_per_mm(),
|
||||
is_external ? perimeter_generator.ext_perimeter_flow.width : perimeter_generator.perimeter_flow.width,
|
||||
|
|
@ -169,7 +169,7 @@ static ExtrusionEntityCollection traverse_loops(const PerimeterGenerator &perime
|
|||
// the loop centerline and original lower slices is >= half nozzle diameter
|
||||
extrusion_paths_append(
|
||||
paths,
|
||||
diff_pl(loop.polygon, perimeter_generator.lower_slices_polygons()),
|
||||
diff_pl((Polygons)loop.polygon, perimeter_generator.lower_slices_polygons()),
|
||||
erOverhangPerimeter,
|
||||
perimeter_generator.mm3_per_mm_overhang(),
|
||||
perimeter_generator.overhang_flow.width,
|
||||
|
|
|
|||
|
|
@ -16,8 +16,8 @@ typedef std::vector<Polygon> Polygons;
|
|||
class Polygon : public MultiPoint
|
||||
{
|
||||
public:
|
||||
operator Polygons() const { Polygons pp; pp.push_back(*this); return pp; }
|
||||
operator Polyline() const { return this->split_at_first_point(); }
|
||||
explicit operator Polygons() const { Polygons pp; pp.push_back(*this); return pp; }
|
||||
explicit operator Polyline() const { return this->split_at_first_point(); }
|
||||
Point& operator[](Points::size_type idx) { return this->points[idx]; }
|
||||
const Point& operator[](Points::size_type idx) const { return this->points[idx]; }
|
||||
|
||||
|
|
|
|||
|
|
@ -200,7 +200,7 @@ BoundingBox get_extents(const Polylines &polylines)
|
|||
if (! polylines.empty()) {
|
||||
bb = polylines.front().bounding_box();
|
||||
for (size_t i = 1; i < polylines.size(); ++ i)
|
||||
bb.merge(polylines[i]);
|
||||
bb.merge(polylines[i].points);
|
||||
}
|
||||
return bb;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -60,8 +60,8 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
operator Polylines() const;
|
||||
operator Line() const;
|
||||
explicit operator Polylines() const;
|
||||
explicit operator Line() const;
|
||||
const Point& last_point() const override { return this->points.back(); }
|
||||
|
||||
const Point& leftmost_point() const;
|
||||
|
|
|
|||
|
|
@ -427,7 +427,7 @@ const std::vector<std::string>& Preset::print_options()
|
|||
"infill_extruder", "solid_infill_extruder", "support_material_extruder", "support_material_interface_extruder",
|
||||
"ooze_prevention", "standby_temperature_delta", "interface_shells", "extrusion_width", "first_layer_extrusion_width",
|
||||
"perimeter_extrusion_width", "external_perimeter_extrusion_width", "infill_extrusion_width", "solid_infill_extrusion_width",
|
||||
"top_infill_extrusion_width", "support_material_extrusion_width", "infill_overlap", "infill_anchor", "bridge_flow_ratio", "clip_multipart_objects",
|
||||
"top_infill_extrusion_width", "support_material_extrusion_width", "infill_overlap", "infill_anchor", "infill_anchor_max", "bridge_flow_ratio", "clip_multipart_objects",
|
||||
"elefant_foot_compensation", "xy_size_compensation", "threads", "resolution", "wipe_tower", "wipe_tower_x", "wipe_tower_y",
|
||||
"wipe_tower_width", "wipe_tower_rotation_angle", "wipe_tower_bridging", "single_extruder_multi_material_priming",
|
||||
"wipe_tower_no_sparse_layers", "compatible_printers", "compatible_printers_condition", "inherits"
|
||||
|
|
|
|||
|
|
@ -1220,9 +1220,9 @@ static inline bool sequential_print_horizontal_clearance_valid(const Print &prin
|
|||
// instance.shift is a position of a centered object, while model object may not be centered.
|
||||
// Conver the shift from the PrintObject's coordinates into ModelObject's coordinates by removing the centering offset.
|
||||
convex_hull.translate(instance.shift - print_object->center_offset());
|
||||
if (! intersection(convex_hulls_other, convex_hull).empty())
|
||||
if (! intersection(convex_hulls_other, (Polygons)convex_hull).empty())
|
||||
return false;
|
||||
polygons_append(convex_hulls_other, convex_hull);
|
||||
convex_hulls_other.emplace_back(std::move(convex_hull));
|
||||
}
|
||||
}
|
||||
return true;
|
||||
|
|
|
|||
|
|
@ -1064,11 +1064,15 @@ void PrintConfigDef::init_fff_params()
|
|||
def->mode = comAdvanced;
|
||||
def->set_default_value(new ConfigOptionInt(1));
|
||||
|
||||
def = this->add("infill_anchor", coFloatOrPercent);
|
||||
auto def_infill_anchor_min = def = this->add("infill_anchor", coFloatOrPercent);
|
||||
def->label = L("Length of the infill anchor");
|
||||
def->category = L("Advanced");
|
||||
def->tooltip = L("Connect an infill line to an internal perimeter with a short segment of an additional perimeter. "
|
||||
"If expressed as percentage (example: 15%) it is calculated over infill extrusion width.");
|
||||
"If expressed as percentage (example: 15%) it is calculated over infill extrusion width. "
|
||||
"PrusaSlicer tries to connect two close infill lines to a short perimeter segment. If no such perimeter segment "
|
||||
"shorter than infill_anchor_max is found, the infill line is connected to a perimeter segment at just one side "
|
||||
"and the length of the perimeter segment taken is limited to this parameter, but no longer than anchor_length_max. "
|
||||
"Set this parameter to zero to disable anchoring perimeters connected to a single infill line.");
|
||||
def->sidetext = L("mm or %");
|
||||
def->ratio_over = "infill_extrusion_width";
|
||||
def->gui_type = "f_enum_open";
|
||||
|
|
@ -1078,15 +1082,36 @@ void PrintConfigDef::init_fff_params()
|
|||
def->enum_values.push_back("5");
|
||||
def->enum_values.push_back("10");
|
||||
def->enum_values.push_back("1000");
|
||||
def->enum_labels.push_back(L("0 (not anchored)"));
|
||||
def->enum_labels.push_back(L("0 (no open anchors)"));
|
||||
def->enum_labels.push_back("1 mm");
|
||||
def->enum_labels.push_back("2 mm");
|
||||
def->enum_labels.push_back("5 mm");
|
||||
def->enum_labels.push_back("10 mm");
|
||||
def->enum_labels.push_back(L("1000 (unlimited)"));
|
||||
def->mode = comAdvanced;
|
||||
// def->set_default_value(new ConfigOptionFloatOrPercent(300, true));
|
||||
def->set_default_value(new ConfigOptionFloatOrPercent(1000, false));
|
||||
def->set_default_value(new ConfigOptionFloatOrPercent(600, true));
|
||||
|
||||
def = this->add("infill_anchor_max", coFloatOrPercent);
|
||||
def->label = L("Maximum length of the infill anchor");
|
||||
def->category = def_infill_anchor_min->category;
|
||||
def->tooltip = L("Connect an infill line to an internal perimeter with a short segment of an additional perimeter. "
|
||||
"If expressed as percentage (example: 15%) it is calculated over infill extrusion width. "
|
||||
"PrusaSlicer tries to connect two close infill lines to a short perimeter segment. If no such perimeter segment "
|
||||
"shorter than this parameter is found, the infill line is connected to a perimeter segment at just one side "
|
||||
"and the length of the perimeter segment taken is limited to infill_anchor, but no longer than this parameter. "
|
||||
"Set this parameter to zero to disable anchoring.");
|
||||
def->sidetext = def_infill_anchor_min->sidetext;
|
||||
def->ratio_over = def_infill_anchor_min->ratio_over;
|
||||
def->gui_type = def_infill_anchor_min->gui_type;
|
||||
def->enum_values = def_infill_anchor_min->enum_values;
|
||||
def->enum_labels.push_back(L("0 (not anchored)"));
|
||||
def->enum_labels.push_back("1 mm");
|
||||
def->enum_labels.push_back("2 mm");
|
||||
def->enum_labels.push_back("5 mm");
|
||||
def->enum_labels.push_back("10 mm");
|
||||
def->enum_labels.push_back(L("1000 (unlimited)"));
|
||||
def->mode = def_infill_anchor_min->mode;
|
||||
def->set_default_value(new ConfigOptionFloatOrPercent(50, false));
|
||||
|
||||
def = this->add("infill_extruder", coInt);
|
||||
def->label = L("Infill extruder");
|
||||
|
|
|
|||
|
|
@ -532,6 +532,7 @@ public:
|
|||
ConfigOptionEnum<InfillPattern> fill_pattern;
|
||||
ConfigOptionFloat gap_fill_speed;
|
||||
ConfigOptionFloatOrPercent infill_anchor;
|
||||
ConfigOptionFloatOrPercent infill_anchor_max;
|
||||
ConfigOptionInt infill_extruder;
|
||||
ConfigOptionFloatOrPercent infill_extrusion_width;
|
||||
ConfigOptionInt infill_every_layers;
|
||||
|
|
@ -584,6 +585,7 @@ protected:
|
|||
OPT_PTR(fill_pattern);
|
||||
OPT_PTR(gap_fill_speed);
|
||||
OPT_PTR(infill_anchor);
|
||||
OPT_PTR(infill_anchor_max);
|
||||
OPT_PTR(infill_extruder);
|
||||
OPT_PTR(infill_extrusion_width);
|
||||
OPT_PTR(infill_every_layers);
|
||||
|
|
|
|||
|
|
@ -591,6 +591,7 @@ bool PrintObject::invalidate_state_by_config_options(const std::vector<t_config_
|
|||
|| opt_key == "fill_angle"
|
||||
|| opt_key == "fill_pattern"
|
||||
|| opt_key == "infill_anchor"
|
||||
|| opt_key == "infill_anchor_max"
|
||||
|| opt_key == "top_infill_extrusion_width"
|
||||
|| opt_key == "first_layer_extrusion_width") {
|
||||
steps.emplace_back(posInfill);
|
||||
|
|
|
|||
|
|
@ -369,7 +369,7 @@ bool add_cavity(Contour3D &pad, ExPolygon &top_poly, const PadConfig3D &cfg,
|
|||
|
||||
if (inner_base.empty() || middle_base.empty()) { logerr(); return false; }
|
||||
|
||||
ExPolygons pdiff = diff_ex(top_poly, middle_base.contour);
|
||||
ExPolygons pdiff = diff_ex((Polygons)top_poly, (Polygons)middle_base.contour);
|
||||
|
||||
if (pdiff.size() != 1) { logerr(); return false; }
|
||||
|
||||
|
|
|
|||
|
|
@ -2513,7 +2513,7 @@ void LoopInterfaceProcessor::generate(MyLayerExtruded &top_contact_layer, const
|
|||
Polygon &contour = (i_contour == 0) ? it_contact_expoly->contour : it_contact_expoly->holes[i_contour - 1];
|
||||
const Point *seg_current_pt = nullptr;
|
||||
coordf_t seg_current_t = 0.;
|
||||
if (! intersection_pl(contour.split_at_first_point(), overhang_with_margin).empty()) {
|
||||
if (! intersection_pl((Polylines)contour.split_at_first_point(), overhang_with_margin).empty()) {
|
||||
// The contour is below the overhang at least to some extent.
|
||||
//FIXME ideally one would place the circles below the overhang only.
|
||||
// Walk around the contour and place circles so their centers are not closer than circle_distance from each other.
|
||||
|
|
|
|||
|
|
@ -87,7 +87,7 @@ void Bed_2D::repaint(const std::vector<Vec2d>& shape)
|
|||
for (auto y = bb.min(1) - fmod(bb.min(1), step) + step; y < bb.max(1); y += step) {
|
||||
polylines.push_back(Polyline::new_scale({ Vec2d(bb.min(0), y), Vec2d(bb.max(0), y) }));
|
||||
}
|
||||
polylines = intersection_pl(polylines, bed_polygon);
|
||||
polylines = intersection_pl(polylines, (Polygons)bed_polygon);
|
||||
|
||||
dc.SetPen(wxPen(wxColour(230, 230, 230), 1, wxPENSTYLE_SOLID));
|
||||
for (auto pl : polylines)
|
||||
|
|
|
|||
|
|
@ -237,8 +237,11 @@ void ConfigManipulation::toggle_print_fff_options(DynamicPrintConfig* config)
|
|||
bool have_infill = config->option<ConfigOptionPercent>("fill_density")->value > 0;
|
||||
// infill_extruder uses the same logic as in Print::extruders()
|
||||
for (auto el : { "fill_pattern", "infill_every_layers", "infill_only_where_needed",
|
||||
"solid_infill_every_layers", "solid_infill_below_area", "infill_extruder" })
|
||||
"solid_infill_every_layers", "solid_infill_below_area", "infill_extruder", "infill_anchor_max" })
|
||||
toggle_field(el, have_infill);
|
||||
// Only allow configuration of open anchors if the anchoring is enabled.
|
||||
bool has_infill_anchors = have_infill && config->option<ConfigOptionFloatOrPercent>("infill_anchor_max")->value > 0;
|
||||
toggle_field("infill_anchor", has_infill_anchors);
|
||||
|
||||
bool has_spiral_vase = config->opt_bool("spiral_vase");
|
||||
bool has_top_solid_infill = config->opt_int("top_solid_layers") > 0;
|
||||
|
|
|
|||
|
|
@ -1423,6 +1423,7 @@ void TabPrint::build()
|
|||
optgroup->append_single_option_line("fill_density", category_path + "fill-density");
|
||||
optgroup->append_single_option_line("fill_pattern", category_path + "fill-pattern");
|
||||
optgroup->append_single_option_line("infill_anchor", category_path + "fill-pattern");
|
||||
optgroup->append_single_option_line("infill_anchor_max", category_path + "fill-pattern");
|
||||
optgroup->append_single_option_line("top_fill_pattern", category_path + "top-fill-pattern");
|
||||
optgroup->append_single_option_line("bottom_fill_pattern", category_path + "bottom-fill-pattern");
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue