///|/ Copyright (c) Prusa Research 2016 - 2023 Lukáš Matěna @lukasmatena, Vojtěch Bubník @bubnikv, Pavel Mikuš @Godrak, Lukáš Hejl @hejllukas ///|/ Copyright (c) SuperSlicer 2023 Remi Durand @supermerill ///|/ Copyright (c) 2016 Sakari Kapanen @Flannelhead ///|/ Copyright (c) Slic3r 2011 - 2015 Alessandro Ranellucci @alranel ///|/ Copyright (c) 2013 Mark Hindess ///|/ Copyright (c) 2011 Michael Moon ///|/ ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher ///|/ #include #include #include #include "../ClipperUtils.hpp" #include "../Geometry.hpp" #include "../Layer.hpp" #include "../Print.hpp" #include "../PrintConfig.hpp" #include "../Surface.hpp" #include "FillBase.hpp" #include "FillRectilinear.hpp" #include "FillLightning.hpp" #include "FillConcentricInternal.hpp" #include "FillConcentric.hpp" namespace Slic3r { struct SurfaceFillParams { // Zero based extruder ID. unsigned int extruder = 0; // Infill pattern, adjusted for the density etc. InfillPattern pattern = InfillPattern(0); // FillBase // in unscaled coordinates coordf_t spacing = 0.; // infill / perimeter overlap, in unscaled coordinates coordf_t overlap = 0.; // Angle as provided by the region config, in radians. float angle = 0.f; // Is bridging used for this fill? Bridging parameters may be used even if this->flow.bridge() is not set. bool bridge; // Non-negative for a bridge. float bridge_angle = 0.f; // FillParams float density = 0.f; // Don't adjust spacing to fill the space evenly. // 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_max = 1000.f; // width, height of extrusion, nozzle diameter, is bridge // For the output, for fill generator. Flow flow; // For the output ExtrusionRole extrusion_role = ExtrusionRole(0); // Various print settings? // Index of this entry in a linear vector. size_t idx = 0; bool operator<(const SurfaceFillParams &rhs) const { #define RETURN_COMPARE_NON_EQUAL(KEY) if (this->KEY < rhs.KEY) return true; if (this->KEY > rhs.KEY) return false; #define RETURN_COMPARE_NON_EQUAL_TYPED(TYPE, KEY) if (TYPE(this->KEY) < TYPE(rhs.KEY)) return true; if (TYPE(this->KEY) > TYPE(rhs.KEY)) return false; // Sort first by decreasing bridging angle, so that the bridges are processed with priority when trimming one layer by the other. if (this->bridge_angle > rhs.bridge_angle) return true; if (this->bridge_angle < rhs.bridge_angle) return false; RETURN_COMPARE_NON_EQUAL(extruder); RETURN_COMPARE_NON_EQUAL_TYPED(unsigned, pattern); RETURN_COMPARE_NON_EQUAL(spacing); RETURN_COMPARE_NON_EQUAL(overlap); RETURN_COMPARE_NON_EQUAL(angle); 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()); RETURN_COMPARE_NON_EQUAL_TYPED(unsigned, bridge); RETURN_COMPARE_NON_EQUAL_TYPED(unsigned, extrusion_role); return false; } bool operator==(const SurfaceFillParams &rhs) const { return this->extruder == rhs.extruder && this->pattern == rhs.pattern && this->spacing == rhs.spacing && this->overlap == rhs.overlap && this->angle == rhs.angle && this->bridge == rhs.bridge && this->bridge_angle == rhs.bridge_angle && this->density == rhs.density && // this->dont_adjust == rhs.dont_adjust && this->anchor_length == rhs.anchor_length && this->anchor_length_max == rhs.anchor_length_max && this->flow == rhs.flow && this->extrusion_role == rhs.extrusion_role; } }; struct SurfaceFill { SurfaceFill(const SurfaceFillParams& params) : region_id(size_t(-1)), surface(stCount, ExPolygon()), params(params) {} size_t region_id; Surface surface; ExPolygons expolygons; SurfaceFillParams params; // BBS std::vector region_id_group; ExPolygons no_overlap_expolygons; }; // Detect narrow infill regions // Based on the anti-vibration algorithm from PrusaSlicer: // https://github.com/prusa3d/PrusaSlicer/blob/94290e09d75f23719c3d2ab2398737c8be4c3fd6/src/libslic3r/Fill/FillEnsuring.cpp#L100-L289 void split_solid_surface(size_t layer_id, const SurfaceFill &fill, ExPolygons &normal_infill, ExPolygons &narrow_infill) { assert(fill.surface.surface_type == stInternalSolid); switch (fill.params.pattern) { case ipRectilinear: case ipMonotonic: case ipMonotonicLine: case ipAlignedRectilinear: // Only support straight line based infill break; default: // For all other types, don't split return; } Polygons normal_fill_areas; // Areas that filled with normal infill constexpr double connect_extrusions = true; auto segments_overlap = [](coord_t alow, coord_t ahigh, coord_t blow, coord_t bhigh) { return (alow >= blow && alow <= bhigh) || (ahigh >= blow && ahigh <= bhigh) || (blow >= alow && blow <= ahigh) || (bhigh >= alow && bhigh <= ahigh); }; const coord_t scaled_spacing = scaled(fill.params.spacing); double distance_limit_reconnection = 2.0 * double(scaled_spacing); double squared_distance_limit_reconnection = distance_limit_reconnection * distance_limit_reconnection; // Calculate infill direction, see Fill::_infill_direction double base_angle = fill.params.angle + float(M_PI / 2.); // For pattern other than ipAlignedRectilinear, the angle are alternated if (fill.params.pattern != ipAlignedRectilinear) { size_t idx = layer_id / fill.surface.thickness_layers; base_angle += (idx & 1) ? float(M_PI / 2.) : 0; } const double aligning_angle = -base_angle + PI; for (const ExPolygon &expolygon : fill.expolygons) { Polygons filled_area = to_polygons(expolygon); polygons_rotate(filled_area, aligning_angle); BoundingBox bb = get_extents(filled_area); Polygons inner_area = intersection(filled_area, opening(filled_area, 2 * scaled_spacing, 3 * scaled_spacing)); inner_area = shrink(inner_area, scaled_spacing * 0.5 - scaled(fill.params.overlap)); AABBTreeLines::LinesDistancer area_walls{to_lines(inner_area)}; const size_t n_vlines = (bb.max.x() - bb.min.x() + scaled_spacing - 1) / scaled_spacing; std::vector vertical_lines(n_vlines); coord_t y_min = bb.min.y(); coord_t y_max = bb.max.y(); for (size_t i = 0; i < n_vlines; i++) { coord_t x = bb.min.x() + i * double(scaled_spacing); vertical_lines[i].a = Point{x, y_min}; vertical_lines[i].b = Point{x, y_max}; } if (vertical_lines.size() > 0) { vertical_lines.push_back(vertical_lines.back()); vertical_lines.back().a = Point{coord_t(bb.min.x() + n_vlines * double(scaled_spacing) + scaled_spacing * 0.5), y_min}; vertical_lines.back().b = Point{vertical_lines.back().a.x(), y_max}; } std::vector> polygon_sections(n_vlines); for (size_t i = 0; i < n_vlines; i++) { const auto intersections = area_walls.intersections_with_line(vertical_lines[i]); for (int intersection_idx = 0; intersection_idx < int(intersections.size()) - 1; intersection_idx++) { const auto &a = intersections[intersection_idx]; const auto &b = intersections[intersection_idx + 1]; if (area_walls.outside((a.first + b.first) / 2) < 0) { if (std::abs(a.first.y() - b.first.y()) > scaled_spacing) { polygon_sections[i].emplace_back(a.first, b.first); } } } } struct Node { int section_idx; int line_idx; int skips_taken = 0; bool neighbours_explored = false; std::vector> neighbours{}; }; coord_t length_filter = scale_(4); size_t skips_allowed = 2; size_t min_removal_conut = 5; for (int section_idx = 0; section_idx < int(polygon_sections.size()); ++section_idx) { for (int line_idx = 0; line_idx < int(polygon_sections[section_idx].size()); ++line_idx) { if (const Line &line = polygon_sections[section_idx][line_idx]; line.a != line.b && line.length() < length_filter) { std::set> to_remove{{section_idx, line_idx}}; std::vector to_visit{{section_idx, line_idx}}; bool initial_touches_long_lines = false; if (section_idx > 0) { for (int prev_line_idx = 0; prev_line_idx < int(polygon_sections[section_idx - 1].size()); ++prev_line_idx) { if (const Line &nl = polygon_sections[section_idx - 1][prev_line_idx]; nl.a != nl.b && segments_overlap(line.a.y(), line.b.y(), nl.a.y(), nl.b.y())) { initial_touches_long_lines = true; } } } while (!to_visit.empty()) { Node curr = to_visit.back(); const Line &curr_l = polygon_sections[curr.section_idx][curr.line_idx]; if (curr.neighbours_explored) { bool is_valid_for_removal = (curr_l.length() < length_filter) && ((int(to_remove.size()) - curr.skips_taken > int(min_removal_conut)) || (curr.neighbours.empty() && !initial_touches_long_lines)); if (!is_valid_for_removal) { for (const auto &n : curr.neighbours) { if (to_remove.find(n) != to_remove.end()) { is_valid_for_removal = true; break; } } } if (!is_valid_for_removal) { to_remove.erase({curr.section_idx, curr.line_idx}); } to_visit.pop_back(); } else { to_visit.back().neighbours_explored = true; int curr_index = to_visit.size() - 1; bool can_use_skip = curr_l.length() <= length_filter && curr.skips_taken < int(skips_allowed); if (curr.section_idx + 1 < int(polygon_sections.size())) { for (int lidx = 0; lidx < int(polygon_sections[curr.section_idx + 1].size()); ++lidx) { if (const Line &nl = polygon_sections[curr.section_idx + 1][lidx]; nl.a != nl.b && segments_overlap(curr_l.a.y(), curr_l.b.y(), nl.a.y(), nl.b.y()) && (nl.length() < length_filter || can_use_skip)) { to_visit[curr_index].neighbours.push_back({curr.section_idx + 1, lidx}); to_remove.insert({curr.section_idx + 1, lidx}); Node next_node{curr.section_idx + 1, lidx, curr.skips_taken + (nl.length() >= length_filter)}; to_visit.push_back(next_node); } } } } } for (const auto &pair : to_remove) { Line &l = polygon_sections[pair.first][pair.second]; l.a = l.b; } } } } for (size_t section_idx = 0; section_idx < polygon_sections.size(); section_idx++) { polygon_sections[section_idx].erase(std::remove_if(polygon_sections[section_idx].begin(), polygon_sections[section_idx].end(), [](const Line &s) { return s.a == s.b; }), polygon_sections[section_idx].end()); std::sort(polygon_sections[section_idx].begin(), polygon_sections[section_idx].end(), [](const Line &a, const Line &b) { return a.a.y() < b.b.y(); }); } Polygons reconstructed_area{}; // reconstruct polygon from polygon sections { struct TracedPoly { Points lows; Points highs; }; std::vector> polygon_sections_w_width = polygon_sections; for (auto &slice : polygon_sections_w_width) { for (Line &l : slice) { l.a -= Point{0.0, 0.5 * scaled_spacing}; l.b += Point{0.0, 0.5 * scaled_spacing}; } } std::vector current_traced_polys; for (const auto &polygon_slice : polygon_sections_w_width) { std::unordered_set used_segments; for (TracedPoly &traced_poly : current_traced_polys) { auto candidates_begin = std::upper_bound(polygon_slice.begin(), polygon_slice.end(), traced_poly.lows.back(), [](const Point &low, const Line &seg) { return seg.b.y() > low.y(); }); auto candidates_end = std::upper_bound(polygon_slice.begin(), polygon_slice.end(), traced_poly.highs.back(), [](const Point &high, const Line &seg) { return seg.a.y() > high.y(); }); bool segment_added = false; for (auto candidate = candidates_begin; candidate != candidates_end && !segment_added; candidate++) { if (used_segments.find(&(*candidate)) != used_segments.end()) { continue; } if (connect_extrusions && (traced_poly.lows.back() - candidates_begin->a).cast().squaredNorm() < squared_distance_limit_reconnection) { traced_poly.lows.push_back(candidates_begin->a); } else { traced_poly.lows.push_back(traced_poly.lows.back() + Point{scaled_spacing / 2, 0}); traced_poly.lows.push_back(candidates_begin->a - Point{scaled_spacing / 2, 0}); traced_poly.lows.push_back(candidates_begin->a); } if (connect_extrusions && (traced_poly.highs.back() - candidates_begin->b).cast().squaredNorm() < squared_distance_limit_reconnection) { traced_poly.highs.push_back(candidates_begin->b); } else { traced_poly.highs.push_back(traced_poly.highs.back() + Point{scaled_spacing / 2, 0}); traced_poly.highs.push_back(candidates_begin->b - Point{scaled_spacing / 2, 0}); traced_poly.highs.push_back(candidates_begin->b); } segment_added = true; used_segments.insert(&(*candidates_begin)); } if (!segment_added) { // Zero or multiple overlapping segments. Resolving this is nontrivial, // so we just close this polygon and maybe open several new. This will hopefully happen much less often traced_poly.lows.push_back(traced_poly.lows.back() + Point{scaled_spacing / 2, 0}); traced_poly.highs.push_back(traced_poly.highs.back() + Point{scaled_spacing / 2, 0}); Polygon &new_poly = reconstructed_area.emplace_back(std::move(traced_poly.lows)); new_poly.points.insert(new_poly.points.end(), traced_poly.highs.rbegin(), traced_poly.highs.rend()); traced_poly.lows.clear(); traced_poly.highs.clear(); } } current_traced_polys.erase(std::remove_if(current_traced_polys.begin(), current_traced_polys.end(), [](const TracedPoly &tp) { return tp.lows.empty(); }), current_traced_polys.end()); for (const auto &segment : polygon_slice) { if (used_segments.find(&segment) == used_segments.end()) { TracedPoly &new_tp = current_traced_polys.emplace_back(); new_tp.lows.push_back(segment.a - Point{scaled_spacing / 2, 0}); new_tp.lows.push_back(segment.a); new_tp.highs.push_back(segment.b - Point{scaled_spacing / 2, 0}); new_tp.highs.push_back(segment.b); } } } // add not closed polys for (TracedPoly &traced_poly : current_traced_polys) { Polygon &new_poly = reconstructed_area.emplace_back(std::move(traced_poly.lows)); new_poly.points.insert(new_poly.points.end(), traced_poly.highs.rbegin(), traced_poly.highs.rend()); } } polygons_append(normal_fill_areas, reconstructed_area); } polygons_rotate(normal_fill_areas, -aligning_angle); // Do the split ExPolygons normal_fill_areas_ex = union_safety_offset_ex(normal_fill_areas); ExPolygons narrow_fill_areas = diff_ex(fill.expolygons, normal_fill_areas_ex); // Merge very small areas that is smaller than a single line width to the normal infill if they touches for (auto iter = narrow_fill_areas.begin(); iter != narrow_fill_areas.end();) { auto shrinked_expoly = offset_ex(*iter, -scaled_spacing * 0.5); if (shrinked_expoly.empty()) { // Too small! Check if it touches any normal infills auto expanede_exploy = offset_ex(*iter, scaled_spacing * 0.3); Polygons normal_fill_area_clipped = ClipperUtils::clip_clipper_polygons_with_subject_bbox(normal_fill_areas_ex, get_extents(expanede_exploy)); auto touch_check = intersection_ex(normal_fill_area_clipped, expanede_exploy); if (!touch_check.empty()) { normal_fill_areas_ex.emplace_back(*iter); iter = narrow_fill_areas.erase(iter); continue; } } iter++; } if (narrow_fill_areas.empty()) { // No split needed return; } // Expand the normal infills a little bit to avoid gaps between normal and narrow infills normal_infill = intersection_ex(offset_ex(normal_fill_areas_ex, scaled_spacing * 0.1), fill.expolygons); narrow_infill = narrow_fill_areas; #ifdef DEBUG_SURFACE_SPLIT { BoundingBox bbox = get_extents(fill.expolygons); bbox.offset(scale_(1.)); ::Slic3r::SVG svg(debug_out_path("surface_split_%d.svg", layer_id), bbox); svg.draw(to_lines(fill.expolygons), "red", scale_(0.1)); svg.draw(normal_infill, "blue", 0.5); svg.draw(narrow_infill, "green", 0.5); svg.Close(); } #endif } std::vector group_fills(const Layer &layer) { std::vector surface_fills; // Fill in a map of a region & surface to SurfaceFillParams. std::set set_surface_params; std::vector> region_to_surface_params(layer.regions().size(), std::vector()); SurfaceFillParams params; bool has_internal_voids = false; const PrintObjectConfig& object_config = layer.object()->config(); for (size_t region_id = 0; region_id < layer.regions().size(); ++ region_id) { const LayerRegion &layerm = *layer.regions()[region_id]; region_to_surface_params[region_id].assign(layerm.fill_surfaces.size(), nullptr); for (const Surface &surface : layerm.fill_surfaces.surfaces) if (surface.surface_type == stInternalVoid) has_internal_voids = true; else { const PrintRegionConfig ®ion_config = layerm.region().config(); FlowRole extrusion_role = surface.is_top() ? frTopSolidInfill : (surface.is_solid() ? frSolidInfill : frInfill); bool is_bridge = layer.id() > 0 && surface.is_bridge(); params.extruder = layerm.region().extruder(extrusion_role); params.pattern = region_config.sparse_infill_pattern.value; params.density = float(region_config.sparse_infill_density); if (surface.is_solid()) { params.density = 100.f; //FIXME for non-thick bridges, shall we allow a bottom surface pattern? if (surface.is_solid_infill()) params.pattern = region_config.internal_solid_infill_pattern.value; else if (surface.is_external() && ! is_bridge) { if(surface.is_top()) params.pattern = region_config.top_surface_pattern.value; else params.pattern = region_config.bottom_surface_pattern.value; } else { if(region_config.top_surface_pattern == ipMonotonic || region_config.top_surface_pattern == ipMonotonicLine) params.pattern = ipMonotonic; else params.pattern = ipRectilinear; } } else if (params.density <= 0) continue; params.extrusion_role = erInternalInfill; if (is_bridge) { if (surface.is_internal_bridge()) params.extrusion_role = erInternalBridgeInfill; else params.extrusion_role = erBridgeInfill; } else if (surface.is_solid()) { if (surface.is_top()) { params.extrusion_role = erTopSolidInfill; } else if (surface.is_bottom()) { params.extrusion_role = erBottomSurface; } else { params.extrusion_role = erSolidInfill; } } params.bridge_angle = float(surface.bridge_angle); params.angle = float(Geometry::deg2rad(region_config.infill_direction.value)); // Calculate the actual flow we'll be using for this infill. params.bridge = is_bridge || Fill::use_bridge_flow(params.pattern); params.flow = params.bridge ? //BBS: always enable thick bridge for internal bridge layerm.bridging_flow(extrusion_role, (surface.is_bridge() && !surface.is_external()) || object_config.thick_bridges) : layerm.flow(extrusion_role, (surface.thickness == -1) ? layer.height : surface.thickness); // Calculate flow spacing for infill pattern generation. if (surface.is_solid() || is_bridge) { params.spacing = params.flow.spacing(); // Don't limit anchor length for solid or bridging infill. params.anchor_length = 1000.f; params.anchor_length_max = 1000.f; } else { // Internal infill. Calculating infill line spacing independent of the current layer height and 1st layer status, // so that internall infill will be aligned over all layers of the current region. params.spacing = layerm.region().flow(*layer.object(), frInfill, layer.object()->config().layer_height, false).spacing(); // 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 = 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()) it_params = set_surface_params.insert(it_params, params); region_to_surface_params[region_id][&surface - &layerm.fill_surfaces.surfaces.front()] = &(*it_params); } } surface_fills.reserve(set_surface_params.size()); for (const SurfaceFillParams ¶ms : set_surface_params) { const_cast(params).idx = surface_fills.size(); surface_fills.emplace_back(params); } for (size_t region_id = 0; region_id < layer.regions().size(); ++ region_id) { const LayerRegion &layerm = *layer.regions()[region_id]; for (const Surface &surface : layerm.fill_surfaces.surfaces) if (surface.surface_type != stInternalVoid) { const SurfaceFillParams *params = region_to_surface_params[region_id][&surface - &layerm.fill_surfaces.surfaces.front()]; if (params != nullptr) { SurfaceFill &fill = surface_fills[params->idx]; if (fill.region_id == size_t(-1)) { fill.region_id = region_id; fill.surface = surface; fill.expolygons.emplace_back(std::move(fill.surface.expolygon)); //BBS fill.region_id_group.push_back(region_id); fill.no_overlap_expolygons = layerm.fill_no_overlap_expolygons; } else { fill.expolygons.emplace_back(surface.expolygon); //BBS auto t = find(fill.region_id_group.begin(), fill.region_id_group.end(), region_id); if (t == fill.region_id_group.end()) { fill.region_id_group.push_back(region_id); fill.no_overlap_expolygons = union_ex(fill.no_overlap_expolygons, layerm.fill_no_overlap_expolygons); } } } } } { Polygons all_polygons; for (SurfaceFill &fill : surface_fills) if (! fill.expolygons.empty()) { if (fill.expolygons.size() > 1 || ! all_polygons.empty()) { Polygons polys = to_polygons(std::move(fill.expolygons)); // Make a union of polygons, use a safety offset, subtract the preceding polygons. // Bridges are processed first (see SurfaceFill::operator<()) fill.expolygons = all_polygons.empty() ? union_safety_offset_ex(polys) : diff_ex(polys, all_polygons, ApplySafetyOffset::Yes); append(all_polygons, std::move(polys)); } else if (&fill != &surface_fills.back()) append(all_polygons, to_polygons(fill.expolygons)); } } // we need to detect any narrow surfaces that might collapse // when adding spacing below // such narrow surfaces are often generated in sloping walls // by bridge_over_infill() and combine_infill() as a result of the // subtraction of the combinable area from the layer infill area, // which leaves small areas near the perimeters // we are going to grow such regions by overlapping them with the void (if any) // TODO: detect and investigate whether there could be narrow regions without // any void neighbors if (has_internal_voids) { // Internal voids are generated only if "infill_only_where_needed" or "infill_every_layers" are active. coord_t distance_between_surfaces = 0; Polygons surfaces_polygons; Polygons voids; int region_internal_infill = -1; int region_solid_infill = -1; int region_some_infill = -1; for (SurfaceFill &surface_fill : surface_fills) if (! surface_fill.expolygons.empty()) { distance_between_surfaces = std::max(distance_between_surfaces, surface_fill.params.flow.scaled_spacing()); append((surface_fill.surface.surface_type == stInternalVoid) ? voids : surfaces_polygons, to_polygons(surface_fill.expolygons)); if (surface_fill.surface.surface_type == stInternalSolid) region_internal_infill = (int)surface_fill.region_id; if (surface_fill.surface.is_solid()) region_solid_infill = (int)surface_fill.region_id; if (surface_fill.surface.surface_type != stInternalVoid) region_some_infill = (int)surface_fill.region_id; } if (! voids.empty() && ! surfaces_polygons.empty()) { // First clip voids by the printing polygons, as the voids were ignored by the loop above during mutual clipping. voids = diff(voids, surfaces_polygons); // Corners of infill regions, which would not be filled with an extrusion path with a radius of distance_between_surfaces/2 Polygons collapsed = diff( surfaces_polygons, opening(surfaces_polygons, float(distance_between_surfaces /2), float(distance_between_surfaces / 2 + ClipperSafetyOffset))); //FIXME why the voids are added to collapsed here? First it is expensive, second the result may lead to some unwanted regions being // added if two offsetted void regions merge. // polygons_append(voids, collapsed); ExPolygons extensions = intersection_ex(expand(collapsed, float(distance_between_surfaces)), voids, ApplySafetyOffset::Yes); // Now find an internal infill SurfaceFill to add these extrusions to. SurfaceFill *internal_solid_fill = nullptr; unsigned int region_id = 0; if (region_internal_infill != -1) region_id = region_internal_infill; else if (region_solid_infill != -1) region_id = region_solid_infill; else if (region_some_infill != -1) region_id = region_some_infill; const LayerRegion& layerm = *layer.regions()[region_id]; for (SurfaceFill &surface_fill : surface_fills) if (surface_fill.surface.surface_type == stInternalSolid && std::abs(layer.height - surface_fill.params.flow.height()) < EPSILON) { internal_solid_fill = &surface_fill; break; } if (internal_solid_fill == nullptr) { // Produce another solid fill. params.extruder = layerm.region().extruder(frSolidInfill); const auto top_pattern = layerm.region().config().top_surface_pattern; if(top_pattern == ipMonotonic || top_pattern == ipMonotonicLine) params.pattern = top_pattern; else params.pattern = ipRectilinear; params.density = 100.f; params.extrusion_role = erInternalInfill; params.angle = float(Geometry::deg2rad(layerm.region().config().infill_direction.value)); // calculate the actual flow we'll be using for this infill params.flow = layerm.flow(frSolidInfill); params.spacing = params.flow.spacing(); surface_fills.emplace_back(params); surface_fills.back().surface.surface_type = stInternalSolid; surface_fills.back().surface.thickness = layer.height; surface_fills.back().expolygons = std::move(extensions); } else { append(extensions, std::move(internal_solid_fill->expolygons)); internal_solid_fill->expolygons = union_ex(extensions); } } } // BBS: detect narrow internal solid infill area and use ipConcentricInternal pattern instead if (layer.object()->config().detect_narrow_internal_solid_infill) { size_t surface_fills_size = surface_fills.size(); for (size_t i = 0; i < surface_fills_size; i++) { if (surface_fills[i].surface.surface_type != stInternalSolid) continue; ExPolygons normal_infill; ExPolygons narrow_infill; split_solid_surface(layer.id(), surface_fills[i], normal_infill, narrow_infill); if (narrow_infill.empty()) { // BBS: has no narrow expolygon continue; } else if (normal_infill.empty()) { // BBS: all expolygons are narrow, directly change the fill pattern surface_fills[i].params.pattern = ipConcentricInternal; } else { // BBS: some expolygons are narrow, spilit surface_fills[i] and rearrange the expolygons params = surface_fills[i].params; params.pattern = ipConcentricInternal; surface_fills.emplace_back(params); surface_fills.back().region_id = surface_fills[i].region_id; surface_fills.back().surface.surface_type = stInternalSolid; surface_fills.back().surface.thickness = surface_fills[i].surface.thickness; surface_fills.back().region_id_group = surface_fills[i].region_id_group; surface_fills.back().no_overlap_expolygons = surface_fills[i].no_overlap_expolygons; // BBS: move the narrow expolygons to new surface_fills.back(); surface_fills.back().expolygons = std::move(narrow_infill); // BBS: delete the narrow expolygons from old surface_fills surface_fills[i].expolygons = std::move(normal_infill); } } } return surface_fills; } #ifdef SLIC3R_DEBUG_SLICE_PROCESSING void export_group_fills_to_svg(const char *path, const std::vector &fills) { BoundingBox bbox; for (const auto &fill : fills) for (const auto &expoly : fill.expolygons) bbox.merge(get_extents(expoly)); Point legend_size = export_surface_type_legend_to_svg_box_size(); Point legend_pos(bbox.min(0), bbox.max(1)); bbox.merge(Point(std::max(bbox.min(0) + legend_size(0), bbox.max(0)), bbox.max(1) + legend_size(1))); SVG svg(path, bbox); const float transparency = 0.5f; for (const auto &fill : fills) for (const auto &expoly : fill.expolygons) svg.draw(expoly, surface_type_to_color_name(fill.surface.surface_type), transparency); export_surface_type_legend_to_svg(svg, legend_pos); svg.Close(); } #endif // friend to Layer void Layer::make_fills(FillAdaptive::Octree* adaptive_fill_octree, FillAdaptive::Octree* support_fill_octree, FillLightning::Generator* lightning_generator) { for (LayerRegion *layerm : m_regions) layerm->fills.clear(); #ifdef SLIC3R_DEBUG_SLICE_PROCESSING // this->export_region_fill_surfaces_to_svg_debug("10_fill-initial"); #endif /* SLIC3R_DEBUG_SLICE_PROCESSING */ std::vector surface_fills = group_fills(*this); const Slic3r::BoundingBox bbox = this->object()->bounding_box(); const auto resolution = this->object()->print()->config().resolution.value; #ifdef SLIC3R_DEBUG_SLICE_PROCESSING { static int iRun = 0; export_group_fills_to_svg(debug_out_path("Layer-fill_surfaces-10_fill-final-%d.svg", iRun ++).c_str(), surface_fills); } #endif /* SLIC3R_DEBUG_SLICE_PROCESSING */ for (SurfaceFill &surface_fill : surface_fills) { // Create the filler object. std::unique_ptr f = std::unique_ptr(Fill::new_from_type(surface_fill.params.pattern)); f->set_bounding_box(bbox); f->layer_id = this->id(); f->z = this->print_z; f->angle = surface_fill.params.angle; f->adapt_fill_octree = (surface_fill.params.pattern == ipSupportCubic) ? support_fill_octree : adaptive_fill_octree; f->print_config = &this->object()->print()->config(); f->print_object_config = &this->object()->config(); if (surface_fill.params.pattern == ipLightning) dynamic_cast(f.get())->generator = lightning_generator; // calculate flow spacing for infill pattern generation bool using_internal_flow = ! surface_fill.surface.is_solid() && ! surface_fill.params.bridge; double link_max_length = 0.; if (! surface_fill.params.bridge) { #if 0 link_max_length = layerm.region()->config().get_abs_value(surface.is_external() ? "external_fill_link_max_length" : "fill_link_max_length", flow.spacing()); // printf("flow spacing: %f, is_external: %d, link_max_length: %lf\n", flow.spacing(), int(surface.is_external()), link_max_length); #else if (surface_fill.params.density > 80.) // 80% link_max_length = 3. * f->spacing; #endif } LayerRegion* layerm = this->m_regions[surface_fill.region_id]; // Maximum length of the perimeter segment linking two infill lines. f->link_max_length = (coord_t)scale_(link_max_length); // Used by the concentric infill pattern to clip the loops to create extrusion paths. f->loop_clipping = coord_t(scale_(layerm->region().config().seam_gap.get_abs_value(surface_fill.params.flow.nozzle_diameter()))); // 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 = false; // surface_fill.params.dont_adjust; params.anchor_length = surface_fill.params.anchor_length; params.anchor_length_max = surface_fill.params.anchor_length_max; params.resolution = resolution; params.use_arachne = surface_fill.params.pattern == ipConcentric || surface_fill.params.pattern == ipConcentricInternal; params.layer_height = layerm->layer()->height; // BBS params.flow = surface_fill.params.flow; params.extrusion_role = surface_fill.params.extrusion_role; params.using_internal_flow = using_internal_flow; params.no_extrusion_overlap = surface_fill.params.overlap; params.config = &layerm->region().config(); if (surface_fill.params.pattern == ipGrid) params.can_reverse = false; for (ExPolygon& expoly : surface_fill.expolygons) { f->no_overlap_expolygons = intersection_ex(surface_fill.no_overlap_expolygons, ExPolygons() = {expoly}, ApplySafetyOffset::Yes); // Spacing is modified by the filler to indicate adjustments. Reset it for each expolygon. f->spacing = surface_fill.params.spacing; surface_fill.surface.expolygon = std::move(expoly); if(surface_fill.params.bridge && surface_fill.surface.is_external() && surface_fill.params.density > 99.0){ params.density = layerm->region().config().bridge_density.get_abs_value(1.0); params.dont_adjust = true; } // BBS: make fill f->fill_surface_extrusion(&surface_fill.surface, params, m_regions[surface_fill.region_id]->fills.entities); } } // add thin fill regions // Unpacks the collection, creates multiple collections per path. // The path type could be ExtrusionPath, ExtrusionLoop or ExtrusionEntityCollection. // Why the paths are unpacked? for (LayerRegion *layerm : m_regions) for (const ExtrusionEntity *thin_fill : layerm->thin_fills.entities) { ExtrusionEntityCollection &collection = *(new ExtrusionEntityCollection()); layerm->fills.entities.push_back(&collection); collection.entities.push_back(thin_fill->clone()); } #ifndef NDEBUG for (LayerRegion *layerm : m_regions) for (size_t i = 0; i < layerm->fills.entities.size(); ++ i) assert(dynamic_cast(layerm->fills.entities[i]) != nullptr); #endif } Polylines Layer::generate_sparse_infill_polylines_for_anchoring(FillAdaptive::Octree* adaptive_fill_octree, FillAdaptive::Octree* support_fill_octree, FillLightning::Generator* lightning_generator) const { std::vector surface_fills = group_fills(*this); const Slic3r::BoundingBox bbox = this->object()->bounding_box(); const auto resolution = this->object()->print()->config().resolution.value; Polylines sparse_infill_polylines{}; for (SurfaceFill &surface_fill : surface_fills) { if (surface_fill.surface.surface_type != stInternal) { continue; } switch (surface_fill.params.pattern) { case ipCount: continue; break; case ipSupportBase: continue; break; case ipConcentricInternal: continue; break; case ipLightning: case ipAdaptiveCubic: case ipSupportCubic: case ipRectilinear: case ipMonotonic: case ipMonotonicLine: case ipAlignedRectilinear: case ipGrid: case ipTriangles: case ipStars: case ipCubic: case ipLine: case ipConcentric: case ipHoneycomb: case ip3DHoneycomb: case ipGyroid: case ipHilbertCurve: case ipArchimedeanChords: case ipOctagramSpiral: break; } // Create the filler object. std::unique_ptr f = std::unique_ptr(Fill::new_from_type(surface_fill.params.pattern)); f->set_bounding_box(bbox); f->layer_id = this->id() - this->object()->get_layer(0)->id(); // We need to subtract raft layers. f->z = this->print_z; f->angle = surface_fill.params.angle; f->adapt_fill_octree = (surface_fill.params.pattern == ipSupportCubic) ? support_fill_octree : adaptive_fill_octree; f->print_config = &this->object()->print()->config(); f->print_object_config = &this->object()->config(); if (surface_fill.params.pattern == ipLightning) dynamic_cast(f.get())->generator = lightning_generator; // calculate flow spacing for infill pattern generation double link_max_length = 0.; if (!surface_fill.params.bridge) { #if 0 link_max_length = layerm.region()->config().get_abs_value(surface.is_external() ? "external_fill_link_max_length" : "fill_link_max_length", flow.spacing()); // printf("flow spacing: %f, is_external: %d, link_max_length: %lf\n", flow.spacing(), int(surface.is_external()), link_max_length); #else if (surface_fill.params.density > 80.) // 80% link_max_length = 3. * f->spacing; #endif } LayerRegion &layerm = *m_regions[surface_fill.region_id]; // Maximum length of the perimeter segment linking two infill lines. f->link_max_length = (coord_t) scale_(link_max_length); // Used by the concentric infill pattern to clip the loops to create extrusion paths. f->loop_clipping = coord_t(scale_(layerm.region().config().seam_gap.get_abs_value(surface_fill.params.flow.nozzle_diameter()))); // 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 = false; // surface_fill.params.dont_adjust; params.anchor_length = surface_fill.params.anchor_length; params.anchor_length_max = surface_fill.params.anchor_length_max; params.resolution = resolution; params.use_arachne = false; params.layer_height = layerm.layer()->height; for (ExPolygon &expoly : surface_fill.expolygons) { // Spacing is modified by the filler to indicate adjustments. Reset it for each expolygon. f->spacing = surface_fill.params.spacing; surface_fill.surface.expolygon = std::move(expoly); try { Polylines polylines = f->fill_surface(&surface_fill.surface, params); sparse_infill_polylines.insert(sparse_infill_polylines.end(), polylines.begin(), polylines.end()); } catch (InfillFailedException &) {} } } return sparse_infill_polylines; } // Create ironing extrusions over top surfaces. void Layer::make_ironing() { // LayerRegion::slices contains surfaces marked with SurfaceType. // Here we want to collect top surfaces extruded with the same extruder. // A surface will be ironed with the same extruder to not contaminate the print with another material leaking from the nozzle. // First classify regions based on the extruder used. struct IroningParams { InfillPattern pattern; int extruder = -1; bool just_infill = false; // Spacing of the ironing lines, also to calculate the extrusion flow from. double line_spacing; // Height of the extrusion, to calculate the extrusion flow from. double height; double speed; double angle; bool operator<(const IroningParams &rhs) const { if (this->extruder < rhs.extruder) return true; if (this->extruder > rhs.extruder) return false; if (int(this->just_infill) < int(rhs.just_infill)) return true; if (int(this->just_infill) > int(rhs.just_infill)) return false; if (this->line_spacing < rhs.line_spacing) return true; if (this->line_spacing > rhs.line_spacing) return false; if (this->height < rhs.height) return true; if (this->height > rhs.height) return false; if (this->speed < rhs.speed) return true; if (this->speed > rhs.speed) return false; if (this->angle < rhs.angle) return true; if (this->angle > rhs.angle) return false; return false; } bool operator==(const IroningParams &rhs) const { return this->extruder == rhs.extruder && this->just_infill == rhs.just_infill && this->line_spacing == rhs.line_spacing && this->height == rhs.height && this->speed == rhs.speed && this->angle == rhs.angle && this->pattern == rhs.pattern; } LayerRegion *layerm = nullptr; // IdeaMaker: ironing // ironing flowrate (5% percent) // ironing speed (10 mm/sec) // Kisslicer: // iron off, Sweep, Group // ironing speed: 15 mm/sec // Cura: // Pattern (zig-zag / concentric) // line spacing (0.1mm) // flow: from normal layer height. 10% // speed: 20 mm/sec }; std::vector by_extruder; double default_layer_height = this->object()->config().layer_height; for (LayerRegion *layerm : m_regions) if (! layerm->slices.empty()) { IroningParams ironing_params; const PrintRegionConfig &config = layerm->region().config(); if (config.ironing_type != IroningType::NoIroning && (config.ironing_type == IroningType::AllSolid || (config.top_shell_layers > 0 && (config.ironing_type == IroningType::TopSurfaces || (config.ironing_type == IroningType::TopmostOnly && layerm->layer()->upper_layer == nullptr))))) { if (config.wall_filament == config.solid_infill_filament || config.wall_loops == 0) { // Iron the whole face. ironing_params.extruder = config.solid_infill_filament; } else { // Iron just the infill. ironing_params.extruder = config.solid_infill_filament; } } if (ironing_params.extruder != -1) { //TODO just_infill is currently not used. ironing_params.just_infill = false; ironing_params.line_spacing = config.ironing_spacing; ironing_params.height = default_layer_height * 0.01 * config.ironing_flow; ironing_params.speed = config.ironing_speed; ironing_params.angle = (config.ironing_angle >= 0 ? config.ironing_angle : config.infill_direction) * M_PI / 180.; ironing_params.pattern = config.ironing_pattern; ironing_params.layerm = layerm; by_extruder.emplace_back(ironing_params); } } std::sort(by_extruder.begin(), by_extruder.end()); FillParams fill_params; fill_params.density = 1.; fill_params.monotonic = true; InfillPattern f_pattern = ipRectilinear; std::unique_ptr f = std::unique_ptr(Fill::new_from_type(f_pattern)); f->set_bounding_box(this->object()->bounding_box()); f->layer_id = this->id(); f->z = this->print_z; f->overlap = 0; for (size_t i = 0; i < by_extruder.size();) { // Find span of regions equivalent to the ironing operation. IroningParams &ironing_params = by_extruder[i]; // Create the filler object. if( f_pattern != ironing_params.pattern ) { f_pattern = ironing_params.pattern; f = std::unique_ptr(Fill::new_from_type(f_pattern)); f->set_bounding_box(this->object()->bounding_box()); f->layer_id = this->id(); f->z = this->print_z; f->overlap = 0; } size_t j = i; for (++ j; j < by_extruder.size() && ironing_params == by_extruder[j]; ++ j) ; // Create the ironing extrusions for regions object()->print()->config().nozzle_diameter.get_at(ironing_params.extruder - 1); if (ironing_params.just_infill) { //TODO just_infill is currently not used. // Just infill. } else { // Infill and perimeter. // Merge top surfaces with the same ironing parameters. Polygons polys; Polygons infills; for (size_t k = i; k < j; ++ k) { const IroningParams &ironing_params = by_extruder[k]; const PrintRegionConfig ®ion_config = ironing_params.layerm->region().config(); bool iron_everything = region_config.ironing_type == IroningType::AllSolid; bool iron_completely = iron_everything; if (iron_everything) { // Check whether there is any non-solid hole in the regions. bool internal_infill_solid = region_config.sparse_infill_density.value > 95.; for (const Surface &surface : ironing_params.layerm->fill_surfaces.surfaces) if ((!internal_infill_solid && surface.surface_type == stInternal) || surface.surface_type == stInternalBridge || surface.surface_type == stInternalVoid) { // Some fill region is not quite solid. Don't iron over the whole surface. iron_completely = false; break; } } if (iron_completely) { // Iron everything. This is likely only good for solid transparent objects. for (const Surface &surface : ironing_params.layerm->slices.surfaces) polygons_append(polys, surface.expolygon); } else { for (const Surface &surface : ironing_params.layerm->slices.surfaces) if ((surface.surface_type == stTop && region_config.top_shell_layers > 0) || (iron_everything && surface.surface_type == stBottom && region_config.bottom_shell_layers > 0)) // stBottomBridge is not being ironed on purpose, as it would likely destroy the bridges. polygons_append(polys, surface.expolygon); } if (iron_everything && ! iron_completely) { // Add solid fill surfaces. This may not be ideal, as one will not iron perimeters touching these // solid fill surfaces, but it is likely better than nothing. for (const Surface &surface : ironing_params.layerm->fill_surfaces.surfaces) if (surface.surface_type == stInternalSolid) polygons_append(infills, surface.expolygon); } } if (! infills.empty() || j > i + 1) { // Ironing over more than a single region or over solid internal infill. if (! infills.empty()) // For IroningType::AllSolid only: // Add solid infill areas for layers, that contain some non-ironable infil (sparse infill, bridge infill). append(polys, std::move(infills)); polys = union_safety_offset(polys); } // Trim the top surfaces with half the nozzle diameter. ironing_areas = intersection_ex(polys, offset(this->lslices, - float(scale_(0.5 * nozzle_dmr)))); } // Create the filler object. f->spacing = ironing_params.line_spacing; f->angle = float(ironing_params.angle + 0.25 * M_PI); f->link_max_length = (coord_t) scale_(3. * f->spacing); double extrusion_height = ironing_params.height * f->spacing / nozzle_dmr; float extrusion_width = Flow::rounded_rectangle_extrusion_width_from_spacing(float(nozzle_dmr), float(extrusion_height)); double flow_mm3_per_mm = nozzle_dmr * extrusion_height; Surface surface_fill(stTop, ExPolygon()); for (ExPolygon &expoly : ironing_areas) { surface_fill.expolygon = std::move(expoly); Polylines polylines; try { polylines = f->fill_surface(&surface_fill, fill_params); } catch (InfillFailedException &) { } if (! polylines.empty()) { // Save into layer. ExtrusionEntityCollection *eec = nullptr; ironing_params.layerm->fills.entities.push_back(eec = new ExtrusionEntityCollection()); // Don't sort the ironing infill lines as they are monotonicly ordered. eec->no_sort = true; extrusion_entities_append_paths( eec->entities, std::move(polylines), erIroning, flow_mm3_per_mm, extrusion_width, float(extrusion_height)); } } // Regions up to j were processed. i = j; } } } // namespace Slic3r