Slic3r::PerimeterGenerator Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/PerimeterGenerator.hpp>

Collaboration diagram for Slic3r::PerimeterGenerator:

Public Member Functions
	PerimeterGenerator (const SurfaceCollection *slices, const LayerRegionPtrs *compatible_regions, double layer_height, coordf_t slice_z, Flow flow, const PrintRegionConfig *config, const PrintObjectConfig *object_config, const PrintConfig *print_config, const bool spiral_mode, const double model_rotation_rad, ExtrusionEntityCollection *loops, ExtrusionEntityCollection *gap_fill, SurfaceCollection *fill_surfaces, ExPolygons *fill_no_overlap)
void	process_classic ()
void	process_arachne ()
void	add_infill_contour_for_arachne (ExPolygons infill_contour, int loops, coord_t ext_perimeter_spacing, coord_t perimeter_spacing, coord_t min_perimeter_infill_spacing, coord_t spacing, bool is_inner_part)
double	ext_mm3_per_mm () const
double	mm3_per_mm () const
double	mm3_per_mm_overhang () const
double	smaller_width_ext_mm3_per_mm () const
Polygons	lower_slices_polygons () const
ExPolygons	printable_slices (const ExPolygons &slices) const
bool	outer_walls_first_for_brim () const

Public Attributes
const SurfaceCollection *	slices
const LayerRegionPtrs *	compatible_regions
const ExPolygons *	upper_slices
const SurfaceCollection *	upper_slices_same_region
const ExPolygons *	lower_slices
double	layer_height
int	layer_id
coordf_t	slice_z
Flow	perimeter_flow
Flow	ext_perimeter_flow
Flow	overhang_flow
Flow	solid_infill_flow
const PrintRegionConfig *	config
const PrintObjectConfig *	object_config
const PrintConfig *	print_config
ExtrusionEntityCollection *	loops
ExtrusionEntityCollection *	gap_fill
SurfaceCollection *	fill_surfaces
ExPolygons *	fill_no_overlap
Flow	smaller_ext_perimeter_flow
std::vector< Polygons >	m_lower_polygons_series
std::vector< Polygons >	m_external_lower_polygons_series
std::vector< Polygons >	m_smaller_external_lower_polygons_series
bool	has_fuzzy_skin = false
bool	has_fuzzy_hole = false
std::vector< std::pair< FuzzySkinConfig, ExPolygons > >	regions_by_fuzzify
std::optional< ExPolygons >	fuzzy_supported_area

Private Member Functions
std::vector< Polygons >	generate_lower_polygons_series (float width)
void	split_top_surfaces (const ExPolygons &orig_polygons, ExPolygons &top_fills, ExPolygons &non_top_polygons, ExPolygons &fill_clip) const
void	apply_extra_perimeters (ExPolygons &infill_area)
void	process_no_bridge (Surfaces &all_surfaces, coord_t perimeter_spacing, coord_t ext_perimeter_width)

Private Attributes
bool	m_spiral_vase
double	m_scaled_resolution
double	m_model_rotation_rad
double	m_ext_mm3_per_mm
double	m_mm3_per_mm
double	m_mm3_per_mm_overhang
double	m_ext_mm3_per_mm_smaller_width
Polygons	m_lower_slices_polygons

Detailed Description

Constructor & Destructor Documentation

PerimeterGenerator()

Slic3r::PerimeterGenerator::PerimeterGenerator ( const SurfaceCollection * slices, const LayerRegionPtrs * compatible_regions, double layer_height, coordf_t slice_z, Flow flow, const PrintRegionConfig * config, const PrintObjectConfig * object_config, const PrintConfig * print_config, const bool spiral_mode, const double model_rotation_rad, ExtrusionEntityCollection * loops, ExtrusionEntityCollection * gap_fill, SurfaceCollection * fill_surfaces, ExPolygons * fill_no_overlap )

inline

        : slices(slices), compatible_regions(compatible_regions), upper_slices(nullptr), lower_slices(nullptr), layer_height(layer_height),
            slice_z(slice_z), layer_id(-1), perimeter_flow(flow), ext_perimeter_flow(flow),
            overhang_flow(flow), solid_infill_flow(flow),
            config(config), object_config(object_config), print_config(print_config),
            m_spiral_vase(spiral_mode),
            m_scaled_resolution(scaled<double>(print_config->resolution.value > EPSILON ? print_config->resolution.value : EPSILON)),
            m_model_rotation_rad(model_rotation_rad),
            loops(loops), gap_fill(gap_fill), fill_surfaces(fill_surfaces), fill_no_overlap(fill_no_overlap),
            m_ext_mm3_per_mm(-1), m_mm3_per_mm(-1), m_mm3_per_mm_overhang(-1), m_ext_mm3_per_mm_smaller_width(-1)
        {}

References compatible_regions, config, EPSILON, ext_perimeter_flow, fill_no_overlap, fill_surfaces, gap_fill, layer_height, layer_id, loops, lower_slices, m_ext_mm3_per_mm, m_ext_mm3_per_mm_smaller_width, m_mm3_per_mm, m_mm3_per_mm_overhang, m_model_rotation_rad, m_scaled_resolution, m_spiral_vase, object_config, overhang_flow, perimeter_flow, print_config, Slic3r::PrintObjectConfig, Slic3r::PrintRegionConfig, Slic3r::resolution(), Slic3r::scaled(), slice_z, slices, solid_infill_flow, and upper_slices.

Here is the call graph for this function:

Member Function Documentation

add_infill_contour_for_arachne()

void Slic3r::PerimeterGenerator::add_infill_contour_for_arachne	(	ExPolygons	infill_contour,
		int	loops,
		coord_t	ext_perimeter_spacing,
		coord_t	perimeter_spacing,
		coord_t	min_perimeter_infill_spacing,
		coord_t	spacing,
		bool	is_inner_part )

{
    if( offset_ex(infill_contour, -float(spacing / 2.)).empty() )
    {
        infill_contour.clear(); // Infill region is too small, so let's filter it out.
    }
 
    // create one more offset to be used as boundary for fill
    // we offset by half the perimeter spacing (to get to the actual infill boundary)
    // and then we offset back and forth by half the infill spacing to only consider the
    // non-collapsing regions
    coord_t insert = (loops < 0) ? 0: ext_perimeter_spacing;
    if (is_inner_part || loops > 0)
        insert = perimeter_spacing;
 
    insert = coord_t(scale_(this->config->infill_wall_overlap.get_abs_value(unscale<double>(insert))));
 
    Polygons inner_pp;
    for (ExPolygon &ex : infill_contour)
        ex.simplify_p(m_scaled_resolution, &inner_pp);
 
    this->fill_surfaces->append(offset2_ex(union_ex(inner_pp), float(-min_perimeter_infill_spacing / 2.), float(insert + min_perimeter_infill_spacing / 2.)), stInternal);
 
    append(*this->fill_no_overlap, offset2_ex(union_ex(inner_pp), float(-min_perimeter_infill_spacing / 2.), float(+min_perimeter_infill_spacing / 2.)));
}

References add_infill_contour_for_arachne(), Slic3r::append(), config, Slic3r::empty(), fill_no_overlap, fill_surfaces, loops, m_scaled_resolution, Slic3r::offset2_ex(), Slic3r::offset_ex(), scale_, Slic3r::stInternal, Slic3r::union_ex(), and Slic3r::unscale().

Referenced by add_infill_contour_for_arachne().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_extra_perimeters()

void Slic3r::PerimeterGenerator::apply_extra_perimeters ( ExPolygons & infill_area )

private

{
    if (!m_spiral_vase && this->lower_slices != nullptr && this->config->detect_overhang_wall && this->config->extra_perimeters_on_overhangs &&
        this->config->wall_loops > 0 && this->layer_id > this->object_config->raft_layers) {
        // Generate extra perimeters on overhang areas, and cut them to these parts only, to save print time and material
        auto [extra_perimeters, filled_area] = generate_extra_perimeters_over_overhangs(infill_area, this->lower_slices_polygons(),
                                                                                        this->config->wall_loops, this->overhang_flow,
                                                                                        this->m_scaled_resolution, *this->object_config,
                                                                                        *this->print_config);
        if (!extra_perimeters.empty()) {
            ExtrusionEntityCollection *this_islands_perimeters = static_cast<ExtrusionEntityCollection *>(this->loops->entities.back());
            ExtrusionEntityCollection  new_perimeters{};
            new_perimeters.no_sort = this_islands_perimeters->no_sort;
            for (const ExtrusionPaths &paths : extra_perimeters) {
                new_perimeters.append(paths);
            }
            new_perimeters.append(this_islands_perimeters->entities);
            this_islands_perimeters->swap(new_perimeters);
 
            SurfaceCollection orig_surfaces = *this->fill_surfaces;
            this->fill_surfaces->clear();
            for (const auto &surface : orig_surfaces.surfaces) {
                auto new_surfaces = diff_ex({surface.expolygon}, filled_area);
                this->fill_surfaces->append(new_surfaces, surface);
            }
        }
    }
}

References Slic3r::ExtrusionEntityCollection::append(), config, Slic3r::diff_ex(), Slic3r::ExtrusionEntityCollection::entities, fill_surfaces, Slic3r::generate_extra_perimeters_over_overhangs(), loops, lower_slices, lower_slices_polygons(), m_spiral_vase, Slic3r::ExtrusionEntityCollection::no_sort, Slic3r::SurfaceCollection::surfaces, and Slic3r::ExtrusionEntityCollection::swap().

Referenced by process_classic().

Here is the call graph for this function:

Here is the caller graph for this function:

ext_mm3_per_mm()

double Slic3r::PerimeterGenerator::ext_mm3_per_mm ( ) const

inline

{ return m_ext_mm3_per_mm; }

References m_ext_mm3_per_mm.

Referenced by Slic3r::traverse_loops().

Here is the caller graph for this function:

generate_lower_polygons_series()

std::vector< Polygons > Slic3r::PerimeterGenerator::generate_lower_polygons_series ( float width )

private

{
    float nozzle_diameter = print_config->nozzle_diameter.get_at(config->outer_wall_filament_id - 1);
    float start_offset = -0.5 * width;
    float end_offset = 0.5 * nozzle_diameter;
 
    assert(overhang_sampling_number >= 3);
    // generate offsets
    std::vector<float> offset_series;
    offset_series.reserve(2);
 
     offset_series.push_back(start_offset + 0.5 * (end_offset - start_offset) / (overhang_sampling_number - 1));
     offset_series.push_back(end_offset);
    std::vector<Polygons> lower_polygons_series;
    if (this->lower_slices == NULL) {
        return lower_polygons_series;
    }
 
    // offset expolygon to generate series of polygons
    for (int i = 0; i < offset_series.size(); i++) {
        lower_polygons_series.emplace_back(offset(*this->lower_slices, float(scale_(offset_series[i]))));
    }
    return lower_polygons_series;
}

References config, generate_lower_polygons_series(), lower_slices, Slic3r::nozzle_diameter(), Slic3r::offset(), overhang_sampling_number, print_config, and scale_.

Referenced by generate_lower_polygons_series(), and process_classic().

Here is the call graph for this function:

Here is the caller graph for this function:

lower_slices_polygons()

Polygons Slic3r::PerimeterGenerator::lower_slices_polygons ( ) const

inline

{ return m_lower_slices_polygons; }

References m_lower_slices_polygons.

Referenced by apply_extra_perimeters(), and Slic3r::traverse_extrusions().

Here is the caller graph for this function:

mm3_per_mm()

double Slic3r::PerimeterGenerator::mm3_per_mm ( ) const

inline

{ return m_mm3_per_mm; }

References m_mm3_per_mm.

Referenced by Slic3r::traverse_loops().

Here is the caller graph for this function:

mm3_per_mm_overhang()

double Slic3r::PerimeterGenerator::mm3_per_mm_overhang ( ) const

inline

{ return m_mm3_per_mm_overhang; }

References m_mm3_per_mm_overhang.

Referenced by Slic3r::traverse_loops().

Here is the caller graph for this function:

outer_walls_first_for_brim()

bool Slic3r::PerimeterGenerator::outer_walls_first_for_brim

(

)

const

{
    return layer_id == 0 && brim_puts_outer_walls_first(object_config->brim_type.value, object_config->brim_width.value);
}

References Slic3r::brim_puts_outer_walls_first(), layer_id, object_config, and outer_walls_first_for_brim().

Referenced by outer_walls_first_for_brim(), process_classic(), and Slic3r::traverse_extrusions().

Here is the call graph for this function:

Here is the caller graph for this function:

printable_slices()

ExPolygons Slic3r::PerimeterGenerator::printable_slices

(

const ExPolygons &

slices

)

const

{
    double min_width = *std::min_element(print_config->nozzle_diameter.values.begin(),
                                         print_config->nozzle_diameter.values.end()) / 3.;
    if (object_config->wall_generator.value == PerimeterGeneratorType::Arachne) {
        const double min_feature_size = Arachne::make_paths_params(layer_id, *object_config, *print_config).min_feature_size;
        // Spiral vase can put a classic layer under an Arachne one, so there both limits apply.
        min_width = print_config->spiral_mode ? std::min(min_width, min_feature_size) : min_feature_size;
    }
    return min_width > EPSILON ? opening_ex(slices, float(scale_(min_width / 2.))) : slices;
}

References Slic3r::Arachne, EPSILON, layer_id, Slic3r::Arachne::make_paths_params(), object_config, Slic3r::opening_ex(), print_config, printable_slices(), scale_, and slices.

Referenced by Slic3r::LayerRegion::make_perimeters(), and printable_slices().

Here is the call graph for this function:

Here is the caller graph for this function:

process_arachne()

void Slic3r::PerimeterGenerator::process_arachne

(

)

{
    group_region_by_fuzzify(*this);
 
    // other perimeters
    m_mm3_per_mm = this->perimeter_flow.mm3_per_mm();
    coord_t perimeter_spacing = this->perimeter_flow.scaled_spacing();
 
    // external perimeters
    m_ext_mm3_per_mm = this->ext_perimeter_flow.mm3_per_mm();
    coord_t ext_perimeter_width = this->ext_perimeter_flow.scaled_width();
    coord_t ext_perimeter_spacing = this->ext_perimeter_flow.scaled_spacing();
    coord_t ext_perimeter_spacing2 = scaled<coord_t>(0.5f * (this->ext_perimeter_flow.spacing() + this->perimeter_flow.spacing()));
    // overhang perimeters
    m_mm3_per_mm_overhang = this->overhang_flow.mm3_per_mm();
 
    // solid infill
    coord_t solid_infill_spacing = this->solid_infill_flow.scaled_spacing();
 
    // prepare grown lower layer slices for overhang detection
    if (this->lower_slices != nullptr && this->config->detect_overhang_wall) {
        // We consider overhang any part where the entire nozzle diameter is not supported by the
        // lower layer, so we take lower slices and offset them by half the nozzle diameter used
        // in the current layer
        double nozzle_diameter = this->print_config->nozzle_diameter.get_at(this->config->outer_wall_filament_id - 1);
        m_lower_slices_polygons = offset(*this->lower_slices, float(scale_(+nozzle_diameter / 2)));
    }
 
    Surfaces all_surfaces = this->slices->surfaces;
 
    process_no_bridge(all_surfaces, perimeter_spacing, ext_perimeter_width);
    // BBS: don't simplify too much which influence arc fitting when export gcode if arc_fitting is enabled
    double surface_simplify_resolution = (print_config->enable_arc_fitting.value == ArcFittingMode::Enabled && !this->has_fuzzy_skin) ? 0.2 * m_scaled_resolution : m_scaled_resolution;
    // ORCA: neither one-wall option has a surface to act on without the shell behind it, see
    // has_top_shell_layers() / has_bottom_shell_layers(). Gated here so every use below - including the
    // topmost and first layers - sees the same answer.
    const bool only_one_wall_top         = this->config->only_one_wall_top && has_top_shell_layers(*this->config);
    const bool only_one_wall_first_layer = this->config->only_one_wall_first_layer && has_bottom_shell_layers(*this->config);
    // we need to process each island separately because we might have different
    // extra perimeters for each one
    // Each island is independent up to its outputs, so they are generated in parallel - a layer split into thousands
    // of islands (e.g. by colour painting) otherwise ran on one thread - and the outputs are then committed in the
    // original island order, which is what the extra overhang perimeters (applied to the last island's loops and to
    // all fill surfaces so far) depend on.
    struct ArachneSurfaceResult
    {
        ExtrusionEntityCollection loops;
        bool                      has_loops = false;
        ExPolygons                infill;
        ExPolygons                no_overlap;
    };
    std::vector<ArachneSurfaceResult> results(all_surfaces.size());
    tbb::parallel_for(tbb::blocked_range<size_t>(0, all_surfaces.size()), [&](const tbb::blocked_range<size_t> &range) {
      for (size_t surface_idx = range.begin(); surface_idx < range.end(); ++surface_idx) {
        const Surface        &surface = all_surfaces[surface_idx];
        ArachneSurfaceResult &result  = results[surface_idx];
            coord_t bead_width_0 = ext_perimeter_spacing;
            // detect how many perimeters must be generated for this island
            int loop_number = this->config->wall_loops + surface.extra_perimeters - 1; // 0-indexed loops
            int sparse_infill_density = this->config->sparse_infill_density.value;
            if (this->config->alternate_extra_wall && this->layer_id % 2 == 1 && !m_spiral_vase && sparse_infill_density > 0) // add alternating extra wall
                loop_number++;
 
            // Set the bottommost layer to be one wall
            const bool is_bottom_layer = (this->layer_id == object_config->raft_layers) ? true : false;
            if (is_bottom_layer && only_one_wall_first_layer)
                loop_number = 0;
 
            // Orca: set the topmost layer to be one wall according to the config
            const bool is_topmost_layer = (this->upper_slices == nullptr) ? true : false;
            if (is_topmost_layer && loop_number > 0 && only_one_wall_top)
                loop_number = 0;
        
            auto apply_precise_outer_wall = config->precise_outer_wall && config->wall_sequence == WallSequence::InnerOuter;
            // Orca: properly adjust offset for the outer wall if precise_outer_wall is enabled.
            ExPolygons last = offset_ex(surface.expolygon.simplify_p(surface_simplify_resolution),
                           apply_precise_outer_wall? -float(ext_perimeter_width - ext_perimeter_spacing )
                                                     : -float(ext_perimeter_width / 2. - ext_perimeter_spacing / 2.));
        
            Arachne::WallToolPathsParams input_params = Arachne::make_paths_params(this->layer_id, *object_config, *print_config);
            // Set params is_top_or_bottom_layer for adjusting short-wall removal sensitivity.
            input_params.is_top_or_bottom_layer = (is_bottom_layer || is_topmost_layer) ? true : false;
 
            coord_t wall_0_inset = 0;
            if (apply_precise_outer_wall)
               wall_0_inset = -coord_t(ext_perimeter_width / 2 - ext_perimeter_spacing / 2);
 
            //PS: One wall top surface for Arachne
            ExPolygons top_expolygons;
            // Calculate how many inner loops remain when TopSurfaces is selected.
            const int inner_loop_number = (only_one_wall_top && upper_slices != nullptr) ? loop_number - 1 : -1;
 
            // Set one perimeter when TopSurfaces is selected.
            if (only_one_wall_top && loop_number > 0)
                loop_number = 0;
 
            Arachne::WallToolPathsParams input_params_tmp = input_params;
        
            Polygons   last_p = to_polygons(last);
            Arachne::WallToolPaths wallToolPaths(last_p, bead_width_0, perimeter_spacing, coord_t(loop_number + 1),
                                                   wall_0_inset, layer_height, input_params_tmp);
            std::vector<Arachne::VariableWidthLines>   perimeters = wallToolPaths.getToolPaths();
            ExPolygons  infill_contour = union_ex(wallToolPaths.getInnerContour());
 
            // Check if there are some remaining perimeters to generate (the number of perimeters
            // is greater than one together with enabled the single perimeter on top surface feature).
            if (inner_loop_number >= 0) {
                assert(upper_slices != nullptr);
 
                coord_t perimeter_width = this->perimeter_flow.scaled_width();
 
                // Filter out areas that are too thin and expand top surface polygons a bit to hide the wall line.
                // ORCA: skip if the top surface area is smaller than "min_width_top_surface"
                const float top_surface_min_width = std::max<float>(float(ext_perimeter_spacing) / 4.f + scaled<float>(0.00001), float(scale_(config->min_width_top_surface.get_abs_value(unscale_(perimeter_width)))) / 4.f);
 
                // Get top ExPolygons from the given contour. uncovered reports whether the upper layer leaves any of the
                // contour uncovered, before bridges and too thin areas are filtered out.
                auto get_top_expolygons = [&](const ExPolygons &contour, bool &uncovered) {
                    // Contour bounding box.
                    BoundingBox contour_bbox = get_extents(contour);
                    contour_bbox.offset(SCALED_EPSILON);
 
                    Polygons upper_slices_clipped;
                    if (object_config->interface_shells) {
                        auto upper_slicer_same_region = to_expolygons(this->upper_slices_same_region->surfaces);
                        upper_slices_clipped = ClipperUtils::clip_clipper_polygons_with_subject_bbox(upper_slicer_same_region, contour_bbox);
                    } else
                        upper_slices_clipped = ClipperUtils::clip_clipper_polygons_with_subject_bbox(*upper_slices, contour_bbox);
 
                    ExPolygons top = diff_ex(contour, upper_slices_clipped);
                    uncovered      = !top.empty();
                    if (top.empty())
                        return top;
 
                    if (lower_slices != nullptr) {
                        const float      bridge_offset          = float(std::max<coord_t>(ext_perimeter_spacing, perimeter_width));
                        const Polygons   lower_slices_clipped   = ClipperUtils::clip_clipper_polygons_with_subject_bbox(*lower_slices, contour_bbox);
                        const ExPolygons current_slices_bridges = offset_ex(diff_ex(top, lower_slices_clipped), bridge_offset);
 
                        // Remove bridges from top surface polygons.
                        top = diff_ex(top, current_slices_bridges);
                    }
 
                    // Shrink the polygon to remove the small areas, then expand it back out plus a maragin to hide the wall line a little.
                    // ORCA: Expand the polygon with half the perimeter width in addition to the contracted amount,
                    // not the full perimeter width as PS does, to enable thin lettering to print on the top surface without nozzle collisions
                    // due to thin lines being generated
                    top = offset2_ex(top, -top_surface_min_width, top_surface_min_width + float(perimeter_width * 0.85));
 
                    // Get final top ExPolygons (bridges were excluded above, so they stay walled).
                    return intersection_ex(top, contour);
                };
 
                // Walls with the full count, as generated when the single perimeter feature is disabled. Generated on first use.
                std::vector<Arachne::VariableWidthLines> full_perimeters;
                Polygons                                 full_inner_contour;
                bool                                     full_perimeters_generated = false;
                auto generate_full_perimeters = [&]() {
                    if (full_perimeters_generated)
                        return;
                    Arachne::WallToolPaths full_tool_paths(last_p, bead_width_0, perimeter_spacing, coord_t(inner_loop_number + 2), wall_0_inset, layer_height, input_params_tmp);
                    full_perimeters           = full_tool_paths.getToolPaths();
                    full_inner_contour        = full_tool_paths.getInnerContour();
                    full_perimeters_generated = true;
                };
 
                // ORCA: the single wall pass allows Arachne 2 beads across a wall, so it fills a wall narrower than 3 outer wall
                // widths by widening both, where the full pass adds a middle bead. Over the top surface that is the intent;
                // anywhere else it leaves no room for the inner walls. When the single wall pass's outer walls run away from
                // the full pass's outside the top surface, take the full pass's outer walls and the area inside them instead.
                // Walls closer than outer_wall_tolerance count as the same wall: a widened bead's centerline moves by half
                // the width added, and only beads widened by more than twice the tolerance are looked for.
                const coord_t outer_wall_tolerance = bead_width_0 / 10;
                if (widest_bead(perimeters) > bead_width_0 + 2 * outer_wall_tolerance) {
                    // The single wall pass's inner contour where it widens no bead: inside nominal width outer walls.
                    const ExPolygons nominal_infill_contour = offset_ex(last, -float(bead_width_0 + wall_0_inset));
                    bool             nominal_uncovered      = false;
                    // Grown by an outer wall width to take in the outer walls bordering the top surface.
                    const ExPolygons top_zone = offset_ex(get_top_expolygons(nominal_infill_contour, nominal_uncovered), float(bead_width_0));
                    if (nominal_uncovered) {
                        generate_full_perimeters();
                        if (! full_perimeters.empty() && ! full_perimeters.front().empty() &&
                            length_off_reference(perimeters, full_perimeters.front(), top_zone, outer_wall_tolerance) > double(perimeter_width)) {
                            perimeters     = { full_perimeters.front() };
                            infill_contour = diff_ex(nominal_infill_contour, walls_footprint(full_perimeters.front()), ApplySafetyOffset::Yes);
                        }
                    }
                }
 
                bool uncovered = false;
                top_expolygons = get_top_expolygons(infill_contour, uncovered);
 
                if (uncovered) {
                    // ORCA: onion the real region (inside the outer wall) so the remaining walls follow the actual
                    // geometry, then cut away the parts over the top surface. Re-onioning the non-top complement
                    // instead - the fallback when there is no top fill - walls the top/non-top interface and rings
                    // top-surface islands with inner walls that don't exist when the feature is disabled.
                    const bool     clip_walls_over_top = top_fill_replaces_inner_walls(*this->config);
                    const Polygons inner_region        = to_polygons(offset_ex(clip_walls_over_top ? infill_contour
                                                                                                   : diff_ex(infill_contour, top_expolygons),
                                                                              wall_0_inset));
                    Arachne::WallToolPaths inner_wall_tool_paths(inner_region, perimeter_spacing, perimeter_spacing, coord_t(inner_loop_number + 1), 0, layer_height, input_params_tmp);
                    std::vector<Arachne::VariableWidthLines> inner_perimeters = inner_wall_tool_paths.getToolPaths();
 
                    if (clip_walls_over_top) {
                        Polygons kept_over_top;
                        clip_inner_walls_over_top(inner_perimeters, top_expolygons, perimeter_width, kept_over_top);
                        // Route the top fill around the walls kept despite grazing the top.
                        if (! kept_over_top.empty())
                            top_expolygons = diff_ex(top_expolygons, kept_over_top);
                    }
 
                    // Recalculate indexes of inner perimeters before merging them: they come after the single outer wall.
                    if (!perimeters.empty())
                        for (Arachne::VariableWidthLines &inner_perimeter : inner_perimeters)
                            for (Arachne::ExtrusionLine &el : inner_perimeter)
                                ++el.inset_idx;
 
                    perimeters.insert(perimeters.end(), inner_perimeters.begin(), inner_perimeters.end());
                    infill_contour = union_ex(top_expolygons, inner_wall_tool_paths.getInnerContour());
                } else {
                    // There is no top surface ExPolygon, so use the walls generated like when the single perimeter
                    // feature is disabled.
                    generate_full_perimeters();
                    perimeters     = std::move(full_perimeters);
                    infill_contour = union_ex(full_inner_contour);
                }
            }
            //PS
 
            loop_number = int(perimeters.size()) - 1;
 
            #ifdef ARACHNE_DEBUG
            {
                static int iRun = 0;
                export_perimeters_to_svg(debug_out_path("arachne-perimeters-%d-%d.svg", layer_id, iRun++), to_polygons(last), perimeters, union_ex(wallToolPaths.getInnerContour()));
            }
    #endif
 
            // All closed ExtrusionLine should have the same the first and the last point.
            // But in rare cases, Arachne produce ExtrusionLine marked as closed but without
            // equal the first and the last point.
            assert([&perimeters = std::as_const(perimeters)]() -> bool {
                for (const Arachne::VariableWidthLines& perimeter : perimeters)
                    for (const Arachne::ExtrusionLine& el : perimeter)
                        if (el.is_closed && el.junctions.front().p != el.junctions.back().p)
                            return false;
                return true;
            }());
 
            int start_perimeter = int(perimeters.size()) - 1;
            int end_perimeter = -1;
            int direction = -1;
 
        bool is_outer_wall_first =
                  this->config->wall_sequence == WallSequence::OuterInner ||
                  this->config->wall_sequence == WallSequence::InnerOuterInner;
        
            if (layer_id == 0){ // disable inner outer inner algorithm after the first layer
              is_outer_wall_first =
                  this->config->wall_sequence == WallSequence::OuterInner || this->outer_walls_first_for_brim();
            }
            if (is_outer_wall_first) {
                start_perimeter = 0;
                end_perimeter = int(perimeters.size());
                direction = 1;
            }
 
            std::vector<Arachne::ExtrusionLine*> all_extrusions;
            for (int perimeter_idx = start_perimeter; perimeter_idx != end_perimeter; perimeter_idx += direction) {
                if (perimeters[perimeter_idx].empty())
                    continue;
                for (Arachne::ExtrusionLine& wall : perimeters[perimeter_idx])
                    all_extrusions.emplace_back(&wall);
            }
 
            // Find topological order with constraints from extrusions_constrains.
            std::vector<size_t>              blocked(all_extrusions.size(), 0); // Value indicating how many extrusions it is blocking (preceding extrusions) an extrusion.
            std::vector<std::vector<size_t>> blocking(all_extrusions.size());   // Each extrusion contains a vector of extrusions that are blocked by this extrusion.
            std::unordered_map<const Arachne::ExtrusionLine*, size_t> map_extrusion_to_idx;
            for (size_t idx = 0; idx < all_extrusions.size(); idx++)
                map_extrusion_to_idx.emplace(all_extrusions[idx], idx);
 
            auto extrusions_constrains = Arachne::WallToolPaths::getRegionOrder(all_extrusions, is_outer_wall_first);
            for (auto [before, after] : extrusions_constrains) {
                auto after_it = map_extrusion_to_idx.find(after);
                ++blocked[after_it->second];
                blocking[map_extrusion_to_idx.find(before)->second].emplace_back(after_it->second);
            }
 
            std::vector<bool> processed(all_extrusions.size(), false);          // Indicate that the extrusion was already processed.
            Point             current_position = all_extrusions.empty() ? Point::Zero() : all_extrusions.front()->junctions.front().p; // Some starting position.
            std::vector<PerimeterGeneratorArachneExtrusion> ordered_extrusions;         // To store our result in. At the end we'll std::swap.
            ordered_extrusions.reserve(all_extrusions.size());
 
            while (ordered_extrusions.size() < all_extrusions.size()) {
                size_t best_candidate = 0;
                double best_distance_sqr = std::numeric_limits<double>::max();
                bool   is_best_closed = false;
 
                std::vector<size_t> available_candidates;
                for (size_t candidate = 0; candidate < all_extrusions.size(); ++candidate) {
                    if (processed[candidate] || blocked[candidate])
                        continue; // Not a valid candidate.
                    available_candidates.push_back(candidate);
                }
 
                std::sort(available_candidates.begin(), available_candidates.end(), [&all_extrusions](const size_t a_idx, const size_t b_idx) -> bool {
                    return all_extrusions[a_idx]->is_closed < all_extrusions[b_idx]->is_closed;
                    });
 
                for (const size_t candidate_path_idx : available_candidates) {
                    auto& path = all_extrusions[candidate_path_idx];
 
                    if (path->junctions.empty()) { // No vertices in the path. Can't find the start position then or really plan it in. Put that at the end.
                        if (best_distance_sqr == std::numeric_limits<double>::max()) {
                            best_candidate = candidate_path_idx;
                            is_best_closed = path->is_closed;
                        }
                        continue;
                    }
 
                    const Point candidate_position = path->junctions.front().p;
                    double      distance_sqr = (current_position - candidate_position).cast<double>().norm();
                    if (distance_sqr < best_distance_sqr) { // Closer than the best candidate so far.
                        if (path->is_closed || (!path->is_closed && best_distance_sqr != std::numeric_limits<double>::max()) || (!path->is_closed && !is_best_closed)) {
                            best_candidate = candidate_path_idx;
                            best_distance_sqr = distance_sqr;
                            is_best_closed = path->is_closed;
                        }
                    }
                }
 
                auto& best_path = all_extrusions[best_candidate];
                ordered_extrusions.push_back({ best_path, best_path->is_contour() });
                processed[best_candidate] = true;
                for (size_t unlocked_idx : blocking[best_candidate])
                    blocked[unlocked_idx]--;
 
                if (!best_path->junctions.empty()) { //If all paths were empty, the best path is still empty. We don't upate the current position then.
                    if (best_path->is_closed)
                        current_position = best_path->junctions[0].p; //We end where we started.
                    else
                        current_position = best_path->junctions.back().p; //Pick the other end from where we started.
                }
            }
 
           // printf("New Layer: Layer ID %d\n",layer_id); //debug - new layer
            if (this->config->wall_sequence == WallSequence::InnerOuterInner && layer_id > 0) { // only enable inner outer inner algorithm after first layer
                if (ordered_extrusions.size() > 2) { // 3 walls minimum needed to do inner outer inner ordering
                    int position = 0; // index to run the re-ordering for multiple external perimeters in a single island.
                    int arr_i, arr_j = 0;    // indexes to run through the walls in the for loops
                    int outer, first_internal, second_internal, max_internal, current_perimeter; // allocate index values
                
                    // To address any remaining scenarios where the outer perimeter contour is not first on the list as arachne sometimes reorders the perimeters when clustering
                    // for OI mode that is used the basis for IOI
                    bringContoursToFront(ordered_extrusions);
                    std::vector<PerimeterGeneratorArachneExtrusion> reordered_extrusions;
                
                    // Debug statement to print spacing values:
                    //printf("External threshold - Ext perimeter: %d Ext spacing: %d Int perimeter: %d Int spacing: %d\n", this->ext_perimeter_flow.scaled_width(),this->ext_perimeter_flow.scaled_spacing(),this->perimeter_flow.scaled_width(), this->perimeter_flow.scaled_spacing());
 
                    // Get searching thresholds. For an external perimeter we take the external perimeter spacing/2 plus the internal perimeter spacing/2 and expand by the factor
                    // rounding errors. When precise wall is enabled, the external perimeter full spacing is used.
                    coord_t threshold_external = (apply_precise_outer_wall)
                        // Precise outer wall: use the full external spacing
                        ? ( this->ext_perimeter_flow.scaled_spacing()
                            + this->perimeter_flow.scaled_spacing()/2.0 )
                        // Normal: half ext spacing plus half int spacing
                        : ( this->ext_perimeter_flow.scaled_spacing()/2.0
                            + this->perimeter_flow.scaled_spacing()/2.0 );
                
                    // For the intenal perimeter threshold, the distance is the internal perimeter spacing expanded by the factor to cover rounding errors.
                    coord_t threshold_internal = this->perimeter_flow.scaled_spacing();
                
                    // Re-order extrusions based on distance
                    // Alorithm will aggresively optimise for the appearance of the outermost perimeter
                    ordered_extrusions = reorderPerimetersByProximity(ordered_extrusions,threshold_external,threshold_internal );
                    reordered_extrusions = ordered_extrusions; // copy them into the reordered extrusions vector to allow for IOI operations to be performed below without altering the base ordered extrusions list.
                
                    // Now start the sandwich mode wall re-ordering using the reordered_extrusions as the basis
                    // scan to find the external perimeter, first internal, second internal and last perimeter in the island.
                    // We then advance the position index to move to the second island and continue until there are no more
                    // perimeters left.
                    while (position < reordered_extrusions.size()) {
                        outer = first_internal = second_internal = current_perimeter = -1; // initialise all index values to -1
                        max_internal = reordered_extrusions.size()-1; // initialise the maximum internal perimeter to the last perimeter on the extrusion list
                        // run through the walls to get the index values that need re-ordering until the first one for each
                        // is found. Start at "position" index to enable the for loop to iterate for multiple external
                        // perimeters in a single island
                        // printf("Reorder Loop. Position %d, extrusion list size: %d, Outer index %d, inner index %d, second inner index %d\n", position, reordered_extrusions.size(),outer,first_internal,second_internal);
                        for (arr_i = position; arr_i < reordered_extrusions.size(); ++arr_i) {
                            // printf("Perimeter: extrusion inset index %d, ordered extrusions array position %d\n",reordered_extrusions[arr_i].extrusion->inset_idx, arr_i);
                            switch (reordered_extrusions[arr_i].extrusion->inset_idx) {
                                case 0: // external perimeter
                                    if (outer == -1)
                                        outer = arr_i;
                                    break;
                                case 1: // first internal wall
                                    if (first_internal==-1 && arr_i>outer && outer!=-1){
                                        first_internal = arr_i;
                                    }
                                    break;
                                case 2: // second internal wall
                                    if (second_internal == -1 && arr_i > first_internal && outer!=-1){
                                        second_internal = arr_i;
                                    }
                                    break;
                            }
                            if(outer >-1 && first_internal>-1 && reordered_extrusions[arr_i].extrusion->inset_idx == 0){  // found a new external perimeter after we've found at least a first internal perimeter to re-order.
                                                                                                                          // This means we entered a new island.
                                arr_i=arr_i-1; //step back one perimeter
                                max_internal = arr_i; // new maximum internal perimeter is now this as we have found a new external perimeter, hence a new island.
                                break; // exit the for loop
                            }
                        }
                    
                        // printf("Layer ID %d, Outer index %d, inner index %d, second inner index %d, maximum internal perimeter %d \n",layer_id,outer,first_internal,second_internal, max_internal);
                        if (outer > -1 && first_internal > -1 && second_internal > -1) { // found all three perimeters to re-order? If not the perimeters will be processed outside in.
                            std::vector<PerimeterGeneratorArachneExtrusion> inner_outer_extrusions; // temporary array to hold extrusions for reordering
                            inner_outer_extrusions.resize(max_internal - position + 1); // reserve array containing the number of perimeters before a new island. Variables are array indexes hence need to add +1 to convert to position allocations
                            // printf("Allocated array size %d, max_internal index %d, start position index %d \n",max_internal-position+1,max_internal,position);
                        
                            for (arr_j = max_internal; arr_j >=position; --arr_j){ // go inside out towards the external perimeter (perimeters in reverse order) and store all internal perimeters until the first one identified with inset index 2
                                if(arr_j >= second_internal){
                                    //printf("Inside out loop: Mapped perimeter index %d to array position %d\n", arr_j, max_internal-arr_j);
                                    inner_outer_extrusions[max_internal-arr_j] = reordered_extrusions[arr_j];
                                    current_perimeter++; 
                                }
                            }
                        
                            for (arr_j = position; arr_j < second_internal; ++arr_j){ // go outside in and map the remaining perimeters (external and first internal wall(s)) using the outside in wall order
                                // printf("Outside in loop: Mapped perimeter index %d to array position %d\n", arr_j, current_perimeter+1);
                                inner_outer_extrusions[++current_perimeter] = reordered_extrusions[arr_j];
                            }
                        
                            for(arr_j = position; arr_j <= max_internal; ++arr_j) // replace perimeter array with the new re-ordered array
                                ordered_extrusions[arr_j] = inner_outer_extrusions[arr_j-position];
                        }
                        // go to the next perimeter from the current position to continue scanning for external walls in the same island
                        position = arr_i + 1;
                    }
                }
            }
        
            bool steep_overhang_contour = false;
            bool steep_overhang_hole    = false;
            if (!config->overhang_reverse) {
                // Skip steep overhang detection no reverse is specified
                steep_overhang_contour = true;
                steep_overhang_hole    = true;
            }
            if (ExtrusionEntityCollection extrusion_coll = traverse_extrusions(*this, ordered_extrusions, steep_overhang_contour, steep_overhang_hole); !extrusion_coll.empty()) {
                if (config->overhang_reverse) {
                    reorient_perimeters(extrusion_coll, steep_overhang_contour, steep_overhang_hole,
                                        this->config->overhang_reverse_internal_only);
                }
                defer_unsupported_loops(*this, extrusion_coll);
                result.loops     = std::move(extrusion_coll);
                result.has_loops = true;
            }
 
            const coord_t spacing = (perimeters.size() == 1) ? ext_perimeter_spacing2 : perimeter_spacing;
 
            if (offset_ex(infill_contour, -float(spacing / 2.)).empty())
                infill_contour.clear(); // Infill region is too small, so let's filter it out.
 
            // create one more offset to be used as boundary for fill
            // we offset by half the perimeter spacing (to get to the actual infill boundary)
            // and then we offset back and forth by half the infill spacing to only consider the
            // non-collapsing regions
            coord_t inset =
                (loop_number < 0) ? 0 :
                (loop_number == 0) ?
                // one loop
                ext_perimeter_spacing :
                // two or more loops?
                perimeter_spacing;
            coord_t top_inset = inset;
        
            top_inset = coord_t(scale_(this->config->top_bottom_infill_wall_overlap.get_abs_value(unscale<double>(inset))));
            if(is_topmost_layer || is_bottom_layer)
                inset = coord_t(scale_(this->config->top_bottom_infill_wall_overlap.get_abs_value(unscale<double>(inset))));
            else
                inset = coord_t(scale_(this->config->infill_wall_overlap.get_abs_value(unscale<double>(inset))));
        
            // simplify infill contours according to resolution
            Polygons pp;
            for (ExPolygon& ex : infill_contour)
                ex.simplify_p(m_scaled_resolution, &pp);
            ExPolygons not_filled_exp = union_ex(pp);
            // collapse too narrow infill areas
            const auto    min_perimeter_infill_spacing = coord_t(solid_infill_spacing * (1. - INSET_OVERLAP_TOLERANCE));
 
            ExPolygons infill_exp = offset2_ex(
                not_filled_exp,
                float(-min_perimeter_infill_spacing / 2.),
                float(inset + min_perimeter_infill_spacing / 2.));
            // append infill areas to fill_surfaces
            if (!top_expolygons.empty()) {
                infill_exp = union_ex(infill_exp, offset_ex(top_expolygons, double(top_inset)));
            }
            result.infill = std::move(infill_exp);
 
            // BBS: get the no-overlap infill expolygons
            {
                ExPolygons polyWithoutOverlap;
                polyWithoutOverlap = offset2_ex(
                    not_filled_exp,
                    float(-min_perimeter_infill_spacing / 2.),
                    float(+min_perimeter_infill_spacing / 2.));
                if (!top_expolygons.empty())
                    polyWithoutOverlap = union_ex(polyWithoutOverlap, top_expolygons);
                result.no_overlap = std::move(polyWithoutOverlap);
            }
      }
    });
    for (ArachneSurfaceResult &result : results) {
        if (result.has_loops)
            // Moved, not copied: append(const ExtrusionEntity &) clones the whole wall tree of the island.
            this->loops->append(std::move(result.loops));
        this->fill_surfaces->append(result.infill, stInternal);
        apply_extra_perimeters(result.infill);
        append(*this->fill_no_overlap, std::move(result.no_overlap));
    }
}

References config, Slic3r::Enabled, ext_perimeter_flow, Slic3r::Feature::FuzzySkin::group_region_by_fuzzify(), Slic3r::has_bottom_shell_layers(), has_fuzzy_skin, Slic3r::has_top_shell_layers(), loops, lower_slices, m_ext_mm3_per_mm, m_lower_slices_polygons, m_mm3_per_mm, m_mm3_per_mm_overhang, m_scaled_resolution, Slic3r::nozzle_diameter(), Slic3r::offset(), overhang_flow, perimeter_flow, print_config, process_arachne(), process_no_bridge(), Slic3r::range(), scale_, Slic3r::scaled(), slices, and solid_infill_flow.

Referenced by Slic3r::LayerRegion::make_perimeters(), and process_arachne().

Here is the call graph for this function:

Here is the caller graph for this function:

process_classic()

void Slic3r::PerimeterGenerator::process_classic

(

)

{
    group_region_by_fuzzify(*this);
 
    // other perimeters
    m_mm3_per_mm                  = this->perimeter_flow.mm3_per_mm();
    coord_t perimeter_width         = this->perimeter_flow.scaled_width();
    coord_t perimeter_spacing       = this->perimeter_flow.scaled_spacing();
 
    // external perimeters
    m_ext_mm3_per_mm              = this->ext_perimeter_flow.mm3_per_mm();
    coord_t ext_perimeter_width     = this->ext_perimeter_flow.scaled_width();
 
    coord_t ext_perimeter_spacing   = this->ext_perimeter_flow.scaled_spacing();
    coord_t ext_perimeter_spacing2;
    // Orca: ignore precise_outer_wall if wall_sequence is not InnerOuter
    if(config->precise_outer_wall && config->wall_sequence == WallSequence::InnerOuter)
        ext_perimeter_spacing2 = scaled<coord_t>(0.5f * (this->ext_perimeter_flow.width() + this->perimeter_flow.width()));
    else
        ext_perimeter_spacing2 = scaled<coord_t>(0.5f * (this->ext_perimeter_flow.spacing() + this->perimeter_flow.spacing()));
 
    // overhang perimeters
    m_mm3_per_mm_overhang         = this->overhang_flow.mm3_per_mm();
 
    // solid infill
    coord_t solid_infill_spacing    = this->solid_infill_flow.scaled_spacing();
 
    // prepare grown lower layer slices for overhang detection
    if (this->lower_slices != nullptr && this->config->detect_overhang_wall) {
        // We consider overhang any part where the entire nozzle diameter is not supported by the
        // lower layer, so we take lower slices and offset them by half the nozzle diameter used
        // in the current layer
        double nozzle_diameter = this->print_config->nozzle_diameter.get_at(this->config->outer_wall_filament_id - 1);
        m_lower_slices_polygons = offset(*this->lower_slices, float(scale_(+nozzle_diameter / 2)));
    }
 
    // Calculate the minimum required spacing between two adjacent traces.
    // This should be equal to the nominal flow spacing but we experiment
    // with some tolerance in order to avoid triggering medial axis when
    // some squishing might work. Loops are still spaced by the entire
    // flow spacing; this only applies to collapsing parts.
    // For ext_min_spacing we use the ext_perimeter_spacing calculated for two adjacent
    // external loops (which is the correct way) instead of using ext_perimeter_spacing2
    // which is the spacing between external and internal, which is not correct
    // and would make the collapsing (thus the details resolution) dependent on
    // internal flow which is unrelated.
    coord_t min_spacing         = coord_t(perimeter_spacing      * (1 - INSET_OVERLAP_TOLERANCE));
    coord_t ext_min_spacing     = coord_t(ext_perimeter_spacing  * (1 - INSET_OVERLAP_TOLERANCE));
    bool    has_gap_fill    = this->config->gap_infill_speed.get_at(get_extruder_index(*print_config, this->config->outer_wall_filament_id - 1)) > 0;
    // ORCA: Use the smaller width as the lower bound to avoid overestimating safe overlap
    const double gap_fill_min_width = 0.2 * std::min(perimeter_width, ext_perimeter_width) * (1 - INSET_OVERLAP_TOLERANCE);
 
    // BBS: this flow is for smaller external perimeter for small area
    coord_t ext_min_spacing_smaller = coord_t(ext_perimeter_spacing * (1 - SMALLER_EXT_INSET_OVERLAP_TOLERANCE));
    this->smaller_ext_perimeter_flow = this->ext_perimeter_flow;
    // BBS: to be checked
    this->smaller_ext_perimeter_flow = this->smaller_ext_perimeter_flow.with_width(SCALING_FACTOR *
        (ext_perimeter_width - 0.5 * SMALLER_EXT_INSET_OVERLAP_TOLERANCE * ext_perimeter_spacing));
    m_ext_mm3_per_mm_smaller_width = this->smaller_ext_perimeter_flow.mm3_per_mm();
 
    // prepare grown lower layer slices for overhang detection
    m_lower_polygons_series = generate_lower_polygons_series(this->perimeter_flow.width());
    if (ext_perimeter_width == perimeter_width){
        m_external_lower_polygons_series = m_lower_polygons_series;
    } else {
        m_external_lower_polygons_series = generate_lower_polygons_series(this->ext_perimeter_flow.width());
    }
    m_smaller_external_lower_polygons_series = generate_lower_polygons_series(this->smaller_ext_perimeter_flow.width());
    // we need to process each island separately because we might have different
    // extra perimeters for each one
    Surfaces all_surfaces = this->slices->surfaces;
 
    process_no_bridge(all_surfaces, perimeter_spacing, ext_perimeter_width);
    // BBS: don't simplify too much which influence arc fitting when export gcode if arc_fitting is enabled
    double surface_simplify_resolution = (print_config->enable_arc_fitting.value == ArcFittingMode::Enabled && !this->has_fuzzy_skin) ? 0.2 * m_scaled_resolution : m_scaled_resolution;
    //BBS: reorder the surface to reduce the travel time
    ExPolygons surface_exp;
    for (const Surface &surface : all_surfaces)
        surface_exp.push_back(surface.expolygon);
    std::vector<size_t> surface_order = chain_expolygons(surface_exp);
    // ORCA: neither one-wall option has a surface to act on without the shell behind it, see
    // has_top_shell_layers() / has_bottom_shell_layers(). Gated here so every use below - including the
    // topmost and first layers - sees the same answer.
    const bool only_one_wall_top         = this->config->only_one_wall_top && has_top_shell_layers(*this->config);
    const bool only_one_wall_first_layer = this->config->only_one_wall_first_layer && has_bottom_shell_layers(*this->config);
    for (size_t order_idx = 0; order_idx < surface_order.size(); order_idx++) {
        const Surface &surface = all_surfaces[surface_order[order_idx]];
        // detect how many perimeters must be generated for this island
        int loop_number = this->config->wall_loops + surface.extra_perimeters - 1;  // 0-indexed loops
        int sparse_infill_density = this->config->sparse_infill_density.value;
        if (this->config->alternate_extra_wall && this->layer_id % 2 == 1 && !m_spiral_vase && sparse_infill_density > 0) // add alternating extra wall
            loop_number++;
        if (this->layer_id == object_config->raft_layers && only_one_wall_first_layer)
            loop_number = 0;
        // Set the topmost layer to be one wall
        if (loop_number > 0 && only_one_wall_top && this->upper_slices == nullptr)
            loop_number = 0;
 
        ExPolygons last        = union_ex(surface.expolygon.simplify_p(surface_simplify_resolution));
        ExPolygons gaps;
        ExPolygons top_fills;
        ExPolygons fill_clip;
        // ORCA: only_one_wall_top, all empty unless this island has a top surface on this layer. See the
        // post-onion reduction below: the region to keep clear of inner walls, the space freed by the dropped
        // walls (goes to infill, not left as a void) and the space held by the kept ones (withheld from the fill).
        ExPolygons one_wall_top_region;
        ExPolygons one_wall_top_reclaimed;
        Polygons   one_wall_top_kept_bands;
        bool       apply_one_wall_top = false;
        if (loop_number >= 0) {
            // In case no perimeters are to be generated, loop_number will equal to -1.
            std::vector<PerimeterGeneratorLoops> contours(loop_number+1);    // depth => loops
            std::vector<PerimeterGeneratorLoops> holes(loop_number+1);       // depth => loops
            ThickPolylines thin_walls;
            // we loop one time more than needed in order to find gaps after the last perimeter was applied
            for (int i = 0;; ++ i) {  // outer loop is 0
                // Calculate next onion shell of perimeters.
                ExPolygons offsets;
                ExPolygons offsets_with_smaller_width;
                if (i == 0) {
                    // look for thin walls
                    if (this->config->detect_thin_wall) {
                        // the minimum thickness of a single loop is:
                        // ext_width/2 + ext_spacing/2 + spacing/2 + width/2
                        offsets = offset2_ex(last,
                            -float(ext_perimeter_width / 2. + ext_min_spacing / 2. - 1),
                            +float(ext_min_spacing / 2. - 1));
                        // the following offset2 ensures almost nothing in @thin_walls is narrower than $min_width
                        // (actually, something larger than that still may exist due to mitering or other causes)
                        coord_t min_width = coord_t(scale_(this->ext_perimeter_flow.nozzle_diameter() / 3));
                        ExPolygons expp = opening_ex(
                            // medial axis requires non-overlapping geometry
                            diff_ex(last, offset(offsets, float(ext_perimeter_width / 2.) + ClipperSafetyOffset)),
                            float(min_width / 2.));
                        // the maximum thickness of our thin wall area is equal to the minimum thickness of a single loop
                        for (ExPolygon &ex : expp)
                            ex.medial_axis(min_width, ext_perimeter_width + ext_perimeter_spacing2, &thin_walls);
                    } else {
                        coord_t ext_perimeter_smaller_width = this->smaller_ext_perimeter_flow.scaled_width();
                        for (const ExPolygon& expolygon : last) {
                            // BBS: judge whether it's narrow but not too long island which is hard to place two line
                            ExPolygons expolys;
                            expolys.push_back(expolygon);
                            ExPolygons offset_result = offset2_ex(expolys,
                                -float(ext_perimeter_width / 2. + ext_min_spacing_smaller / 2.),
                                +float(ext_min_spacing_smaller / 2.));
                            if (offset_result.empty() &&
                                expolygon.area() < (double)(ext_perimeter_width + ext_min_spacing_smaller) * scale_(narrow_loop_length_threshold)) {
                                // BBS: for narrow external loop, use smaller line width
                                ExPolygons temp_result = offset_ex(expolygon, -float(ext_perimeter_smaller_width / 2.));
                                offsets_with_smaller_width.insert(offsets_with_smaller_width.end(), temp_result.begin(), temp_result.end());
                            }
                            else {
                                //BBS: for not narrow loop, use normal external perimeter line width
                                ExPolygons temp_result = offset_ex(expolygon, -float(ext_perimeter_width / 2.));
                                offsets.insert(offsets.end(), temp_result.begin(), temp_result.end());
                            }
                        }
                    }
                    if (m_spiral_vase && (offsets.size() > 1 || offsets_with_smaller_width.size() > 1)) {
                        // Remove all but the largest area polygon.
                        keep_largest_contour_only(offsets);
                        //BBS
                        if (offsets.empty())
                            //BBS: only have small width loop, then keep the largest in spiral vase mode
                            keep_largest_contour_only(offsets_with_smaller_width);
                        else
                            //BBS: have large area, clean the small width loop
                            offsets_with_smaller_width.clear();
                    }
                } else {
                    //FIXME Is this offset correct if the line width of the inner perimeters differs
                    // from the line width of the infill?
                    coord_t distance = (i == 1) ? ext_perimeter_spacing2 : perimeter_spacing;
                    //BBS
                    //offsets = this->config->thin_walls ?
                        // This path will ensure, that the perimeters do not overfill, as in
                        // prusa3d/Slic3r GH #32, but with the cost of rounding the perimeters
                        // excessively, creating gaps, which then need to be filled in by the not very
                        // reliable gap fill algorithm.
                        // Also the offset2(perimeter, -x, x) may sometimes lead to a perimeter, which is larger than
                        // the original.
                        //offset2_ex(last,
                        //        - float(distance + min_spacing / 2. - 1.),
                        //        float(min_spacing / 2. - 1.)) :
                        // If "detect thin walls" is not enabled, this paths will be entered, which
                        // leads to overflows, as in prusa3d/Slic3r GH #32
                        //offset_ex(last, - float(distance));
 
                    //BBS: For internal perimeter, we should "enable" thin wall strategy in which offset2 is used to
                    // remove too closed line, so that gap fill can be used for such internal narrow area in following
                    // handling.
                    offsets = offset2_ex(last,
                        -float(distance + min_spacing / 2. - 1.),
                        float(min_spacing / 2. - 1.));
                    // look for gaps
                    if (has_gap_fill)
                        // not using safety offset here would "detect" very narrow gaps
                        // (but still long enough to escape the area threshold) that gap fill
                        // won't be able to fill but we'd still remove from infill area
                        append(gaps, diff_ex(
                            offset(last,    - float(0.5 * distance)),
                            offset(offsets,   float(0.5 * distance + 10))));  // safety offset
                }
                if (offsets.empty() && offsets_with_smaller_width.empty()) {
                    // Store the number of loops actually generated.
                    loop_number = i - 1;
                    // No region left to be filled in.
                    last.clear();
                    break;
                } else if (i > loop_number) {
                    // If i > loop_number, we were looking just for gaps.
                    break;
                }
                {
                    for (const ExPolygon& expolygon : offsets) {
                        // Outer contour may overlap with an inner contour,
                        // inner contour may overlap with another inner contour,
                        // outer contour may overlap with itself.
                        //FIXME evaluate the overlaps, annotate each point with an overlap depth,
                        // compensate for the depth of intersection.
                        contours[i].emplace_back(expolygon.contour, i, true);
 
                        if (!expolygon.holes.empty()) {
                            holes[i].reserve(holes[i].size() + expolygon.holes.size());
                            for (const Polygon& hole : expolygon.holes)
                                holes[i].emplace_back(hole, i, false);
                        }
                    }
 
                    //BBS: save perimeter loop which use smaller width
                    if (i == 0) {
                        for (const ExPolygon& expolygon : offsets_with_smaller_width) {
                            contours[i].emplace_back(PerimeterGeneratorLoop(expolygon.contour, i, true, true));
                            if (!expolygon.holes.empty()) {
                                holes[i].reserve(holes[i].size() + expolygon.holes.size());
                                for (const Polygon& hole : expolygon.holes)
                                    holes[i].emplace_back(PerimeterGeneratorLoop(hole, i, false, true));
                            }
                        }
                    }
                }
 
                last = std::move(offsets);
 
                // ORCA: a thin wall hole has no room for gap fill or an inner wall anywhere beside its outer wall, a
                // narrow wall hole none for an inner wall, the room the next loop is offset by below.
                if (i == 0 && ! holes[0].empty()) {
                    auto reach = [&last](double room) {
                        return to_polygons(offset2_ex(last, -float(room), float(room) + float(SCALED_EPSILON)));
                    };
                    auto out_of_reach = [](const Polygon &hole, const Polygons &reach) {
                        return intersection_pl(Polylines{ hole.split_at_first_point() },
                            ClipperUtils::clip_clipper_polygons_with_subject_bbox(reach, get_extents(hole).inflated(SCALED_EPSILON))).empty();
                    };
                    // Only Inner/Outer/Inner orders narrow wall holes apart.
                    const bool     narrow_holes_ordered = this->config->wall_sequence == WallSequence::InnerOuterInner;
                    const Polygons gap_fill_reach       = reach(0.5 * (ext_perimeter_spacing2 + gap_fill_min_width));
                    const Polygons inner_wall_reach     = narrow_holes_ordered ? reach(ext_perimeter_spacing2 + min_spacing / 2.) : Polygons();
                    for (PerimeterGeneratorLoop &hole : holes[0]) {
                        hole.is_thin_wall_hole   = out_of_reach(hole.polygon, gap_fill_reach);
                        hole.is_narrow_wall_hole = narrow_holes_ordered && out_of_reach(hole.polygon, inner_wall_reach);
                    }
                }
 
                //BBS: refer to superslicer
                //store surface for top infill if only_one_wall_top
                if (i == 0 && i!=loop_number && only_one_wall_top && !surface.is_bridge() && this->upper_slices != NULL) {
                    if (top_fill_replaces_inner_walls(*this->config)) {
                        // ORCA: take the top fill and the keep-out region but leave `last` as the real geometry,
                        // so the onion follows it and the walls over the top are reduced in one step below.
                        ExPolygons non_top_polygons;
                        this->split_top_surfaces(last, top_fills, non_top_polygons, fill_clip);
                        apply_one_wall_top = !top_fills.empty();
                        if (apply_one_wall_top)
                            one_wall_top_region = diff_ex(last, non_top_polygons);
                    } else {
                        // Onion the not-top region only, so the remaining walls stop at the top boundary.
                        this->split_top_surfaces(last, top_fills, last, fill_clip);
                    }
                }
 
                if (i == loop_number && (! has_gap_fill || this->config->sparse_infill_density.value == 0)) {
                  // The last run of this loop is executed to collect gaps for gap fill.
                  // As the gap fill is either disabled or not
                  break;
                }
            }
 
            // ORCA: only_one_wall_top reduction - drop the inner walls (depth > 0) running over the top surface and
            // take that space back from the gaps, leaving the top with the outer wall and the top infill. Classic
            // perimeters are closed loops, so a wall can only be kept or dropped whole; one that merely grazes the
            // top (same tolerance as the Arachne clip) is kept and withheld from the top fill instead.
            if (apply_one_wall_top) {
                const BoundingBox top_region_bbox   = get_extents(one_wall_top_region).inflated(SCALED_EPSILON);
                const double      grazing_tolerance = 2. * double(perimeter_width);
                // The band a wall covers, taken around its centerline so the orientation of holes does not matter.
                auto wall_band = [perimeter_spacing](const Polygon &poly) {
                    Polygon centerline = poly;
                    centerline.make_counter_clockwise();
                    return diff(offset(centerline, float(perimeter_spacing) / 2.f),
                                offset(centerline, -float(perimeter_spacing) / 2.f));
                };
                Polygons dropped_wall_bands;
                auto reduce_over_top = [&](PerimeterGeneratorLoops &loops) {
                    loops.erase(std::remove_if(loops.begin(), loops.end(), [&](const PerimeterGeneratorLoop &loop) {
                        const TopOverlap overlap = classify_over_top(loop.polygon.points, one_wall_top_region, top_region_bbox);
                        if (overlap == TopOverlap::None)
                            return false;
                        // Only a wall straddling the boundary is worth measuring; a wall wholly over the top goes.
                        if (overlap == TopOverlap::Partial &&
                            total_length(intersection_pl(Polylines{ loop.polygon.split_at_first_point() }, one_wall_top_region)) < grazing_tolerance) {
                            append(one_wall_top_kept_bands, wall_band(loop.polygon));
                            return false;
                        }
                        append(dropped_wall_bands, wall_band(loop.polygon));
                        return true;
                    }), loops.end());
                };
                for (int d = 1; d <= loop_number; ++ d) {
                    reduce_over_top(contours[d]);
                    reduce_over_top(holes[d]);
                }
                if (! gaps.empty())
                    gaps = diff_ex(gaps, one_wall_top_region);
                if (! dropped_wall_bands.empty())
                    one_wall_top_reclaimed = diff_ex(dropped_wall_bands, one_wall_top_region);
            }
 
            // nest loops: holes first
            for (int d = 0; d <= loop_number; ++ d) {
                PerimeterGeneratorLoops &holes_d = holes[d];
                // loop through all holes having depth == d
                for (int i = 0; i < (int)holes_d.size(); ++ i) {
                    const PerimeterGeneratorLoop &loop = holes_d[i];
                    // find the hole loop that contains this one, if any
                    for (int t = d + 1; t <= loop_number; ++ t) {
                        for (int j = 0; j < (int)holes[t].size(); ++ j) {
                            PerimeterGeneratorLoop &candidate_parent = holes[t][j];
                            if (candidate_parent.polygon.contains(loop.polygon.first_point())) {
                                candidate_parent.children.push_back(loop);
                                holes_d.erase(holes_d.begin() + i);
                                -- i;
                                goto NEXT_LOOP;
                            }
                        }
                    }
                    // if no hole contains this hole, find the contour loop that contains it
                    for (int t = loop_number; t >= 0; -- t) {
                        for (int j = 0; j < (int)contours[t].size(); ++ j) {
                            PerimeterGeneratorLoop &candidate_parent = contours[t][j];
                            if (candidate_parent.polygon.contains(loop.polygon.first_point())) {
                                candidate_parent.children.push_back(loop);
                                holes_d.erase(holes_d.begin() + i);
                                -- i;
                                goto NEXT_LOOP;
                            }
                        }
                    }
                    NEXT_LOOP: ;
                }
            }
            // nest contour loops
            for (int d = loop_number; d >= 1; -- d) {
                PerimeterGeneratorLoops &contours_d = contours[d];
                // loop through all contours having depth == d
                for (int i = 0; i < (int)contours_d.size(); ++ i) {
                    const PerimeterGeneratorLoop &loop = contours_d[i];
                    // find the contour loop that contains it
                    for (int t = d - 1; t >= 0; -- t) {
                        for (size_t j = 0; j < contours[t].size(); ++ j) {
                            PerimeterGeneratorLoop &candidate_parent = contours[t][j];
                            if (candidate_parent.polygon.contains(loop.polygon.first_point())) {
                                candidate_parent.children.push_back(loop);
                                contours_d.erase(contours_d.begin() + i);
                                -- i;
                                goto NEXT_CONTOUR;
                            }
                        }
                    }
                    NEXT_CONTOUR: ;
                }
            }
            // at this point, all loops should be in contours[0]
            bool steep_overhang_contour = false;
            bool steep_overhang_hole    = false;
            if (!config->overhang_reverse) {
                // Skip steep overhang detection no reverse is specified
                steep_overhang_contour = true;
                steep_overhang_hole    = true;
            }
            ExtrusionEntityCollection entities = traverse_loops(*this, contours.front(), thin_walls, steep_overhang_contour, steep_overhang_hole);
            // All walls are counter-clockwise initially, so we don't need to reorient it if that's what we want
            if (config->overhang_reverse) {
                reorient_perimeters(entities, steep_overhang_contour, steep_overhang_hole,
                                    // Reverse internal only if the wall direction is auto
                                    this->config->overhang_reverse_internal_only);
            }
 
            // if brim will be printed, reverse the order of perimeters so that
            // we continue inwards after having finished the brim
            bool is_outer_wall_first = this->config->wall_sequence == WallSequence::OuterInner;
            // Orca: a contour with only a narrow wall hole beside it has nothing to sandwich, and prints the hole first,
            // then the contour, then the gap fill between them, as Arachne does.
            const PerimeterGeneratorLoops &island_loops = contours.front();
            const bool narrow_wall_hole_island = island_loops.size() == 1 && island_loops.front().children.size() == 1 &&
                                                 island_loops.front().children.front().is_narrow_wall_hole;
            if (is_outer_wall_first || this->outer_walls_first_for_brim())
                entities.reverse();
            // Orca: sandwich mode. Apply after 1st layer.
            else if ((this->config->wall_sequence == WallSequence::InnerOuterInner) && layer_id > 0 && !narrow_wall_hole_island){
                entities.reverse(); // reverse all entities - order them from external to internal
                if(entities.entities.size()>2){ // 3 walls minimum needed to do inner outer inner ordering
                    int position = 0; // index to run the re-ordering for multiple external perimeters in a single island.
                    int arr_i, arr_j = 0;    // indexes to run through the walls in the for loops
                    int outer, first_internal, second_internal, max_internal, current_perimeter; // allocate index values
                    
                    // Initiate reorder sequence to bring any index 1 (first internal) perimeters ahead of any second internal perimeters
                    // Leaving these out of order will result in print defects on the external wall as they will be extruded prior to any
                    // external wall. To do the re-ordering, we are creating two extrusion arrays - reordered_extrusions which will contain
                    // the reordered extrusions and skipped_extrusions will contain the ones that were skipped in the scan
                    ExtrusionEntityCollection reordered_extrusions, skipped_extrusions;
                    bool found_second_internal = false; // helper variable to indicate the start of a new island
                    
                    for(auto extrusion_to_reorder : entities.entities){ //scan the perimeters to reorder
                        switch (extrusion_to_reorder->inset_idx) {
                            case 0: // external perimeter
                                if(found_second_internal){ //new island - move skipped extrusions to reordered array
                                    for(auto extrusion_skipped : skipped_extrusions)
                                        reordered_extrusions.append(*extrusion_skipped);
                                    skipped_extrusions.clear();
                                }
                                reordered_extrusions.append(*extrusion_to_reorder);
                                break;
                            case 1: // first internal perimeter
                                reordered_extrusions.append(*extrusion_to_reorder);
                                break;
                            default: // second internal+ perimeter -> put them in the skipped extrusions array
                                skipped_extrusions.append(*extrusion_to_reorder);
                                found_second_internal = true;
                                break;
                        }
                    }
                    if(entities.entities.size()>reordered_extrusions.size()){
                        // we didnt find any more islands, so lets move the remaining skipped perimeters to the reordered extrusions list.
                        for(auto extrusion_skipped : skipped_extrusions)
                            reordered_extrusions.append(*extrusion_skipped);
                        skipped_extrusions.clear();
                    }
                    
                    // Now start the sandwich mode wall re-ordering using the reordered_extrusions as the basis
                    // scan to find the external perimeter, first internal, second internal and last perimeter in the island.
                    // We then advance the position index to move to the second "island" and continue until there are no more
                    // perimeters left.
                    while (position < reordered_extrusions.size()) {
                        outer = first_internal = second_internal = current_perimeter = -1; // initialise all index values to -1
                        max_internal = reordered_extrusions.size()-1; // initialise the maximum internal perimeter to the last perimeter on the extrusion list
                        // run through the walls to get the index values that need re-ordering until the first one for each
                        // is found. Start at "position" index to enable the for loop to iterate for multiple external
                        // perimeters in a single island
                        for (arr_i = position; arr_i < reordered_extrusions.size(); ++arr_i) {
                            switch (reordered_extrusions.entities[arr_i]->inset_idx) {
                                case 0: // external perimeter
                                    if (outer == -1)
                                        outer = arr_i;
                                    break;
                                case 1: // first internal wall
                                    if (first_internal==-1 && arr_i>outer && outer!=-1){
                                        first_internal = arr_i;
                                    }
                                    break;
                                case 2: // second internal wall
                                    if (second_internal == -1 && arr_i > first_internal && outer!=-1){
                                        second_internal = arr_i;
                                    }
                                    break;
                            }
                            if(outer >-1 && first_internal>-1 && second_internal>-1 && reordered_extrusions.entities[arr_i]->inset_idx == 0){ // found a new external perimeter after we've found all three perimeters to re-order -> this means we entered a new island.
                                arr_i=arr_i-1; //step back one perimeter
                                max_internal = arr_i; // new maximum internal perimeter is now this as we have found a new external perimeter, hence a new island.
                                break; // exit the for loop
                            }
                        }
                    
                        if (outer > -1 && first_internal > -1 && second_internal > -1) { // found perimeters to re-order?
                            ExtrusionEntityCollection inner_outer_extrusions; // temporary collection to hold extrusions for reordering
            
                            for (arr_j = max_internal; arr_j >=position; --arr_j){ // go inside out towards the external perimeter (perimeters in reverse order) and store all internal perimeters until the first one identified with inset index 2
                                if(arr_j >= second_internal){
                                    inner_outer_extrusions.append(*reordered_extrusions.entities[arr_j]);
                                    current_perimeter++;
                                }
                            }
                            
                            for (arr_j = position; arr_j < second_internal; ++arr_j){ // go outside in and map the remaining perimeters (external and first internal wall(s)) using the outside in wall order
                                inner_outer_extrusions.append(*reordered_extrusions.entities[arr_j]);
                            }
                            
                            for(arr_j = position; arr_j <= max_internal; ++arr_j) // replace perimeter array with the new re-ordered array
                                entities.replace(arr_j, *inner_outer_extrusions.entities[arr_j-position]);
                        } else
                            break;
                        // go to the next perimeter from the current position to continue scanning for external walls in the same island
                        position = arr_i + 1;
                    }
                }
            }
            
            defer_unsupported_loops(*this, entities);
 
            // append perimeters for this slice as a collection
            if (! entities.empty())
                this->loops->append(entities);
 
        } // for each loop of an island
 
        // fill gaps
        if (! gaps.empty()) { // collapse
            double min = gap_fill_min_width;
            double max = 2. * perimeter_spacing;
            ExPolygons gaps_ex = diff_ex(
                //FIXME offset2 would be enough and cheaper.
                opening_ex(gaps, float(min / 2.)),
                offset2_ex(gaps, - float(max / 2.), float(max / 2. + ClipperSafetyOffset)));
            ThickPolylines polylines;
            for (ExPolygon& ex : gaps_ex) {
                //BBS: Use DP simplify to avoid duplicated points and accelerate medial-axis calculation as well.
                ex.douglas_peucker(surface_simplify_resolution);
                ex.medial_axis(min, max, &polylines);
            }
 
#ifdef GAPS_OF_PERIMETER_DEBUG_TO_SVG
            {
                static int irun = 0;
                BoundingBox bbox_svg;
                bbox_svg.merge(get_extents(gaps_ex));
                {
                    std::stringstream stri;
                    stri << "debug_gaps_ex_" << irun << ".svg";
                    SVG svg(stri.str(), bbox_svg);
                    svg.draw(to_polylines(gaps_ex), "blue", 0.5);
                    svg.Close();
                }
                ++ irun;
            }
#endif
            // SoftFever: filter out tiny gap fills
            polylines.erase(std::remove_if(polylines.begin(), polylines.end(),
                [&](const ThickPolyline& p) {
                    return p.length() < scale_(config->filter_out_gap_fill.value);
                }), polylines.end());
 
 
            if (! polylines.empty()) {
        ExtrusionEntityCollection gap_fill;
        variable_width(polylines, erGapFill, this->solid_infill_flow, gap_fill.entities);
                /*  Make sure we don't infill narrow parts that are already gap-filled
                    (we only consider this surface's gaps to reduce the diff() complexity).
                    Growing actual extrusions ensures that gaps not filled by medial axis
                    are not subtracted from fill surfaces (they might be too short gaps
                    that medial axis skips but infill might join with other infill regions
                    and use zigzag).  */
                //FIXME Vojtech: This grows by a rounded extrusion width, not by line spacing,
                // therefore it may cover the area, but no the volume.
                Polygons gap_fill_covered = gap_fill.polygons_covered_by_width(10.f);
                last = diff_ex(last, gap_fill_covered);
                if (! one_wall_top_reclaimed.empty())
                    one_wall_top_reclaimed = diff_ex(one_wall_top_reclaimed, gap_fill_covered);
                this->gap_fill->append(std::move(gap_fill.entities));
 
      }
        }
 
        // create one more offset to be used as boundary for fill
        // we offset by half the perimeter spacing (to get to the actual infill boundary)
        // and then we offset back and forth by half the infill spacing to only consider the
        // non-collapsing regions
        coord_t inset =
            (loop_number < 0) ? 0 :
            (loop_number == 0) ?
                // one loop
                ext_perimeter_spacing / 2 :
                // two or more loops?
                perimeter_spacing / 2;
        
        // only apply infill overlap if we actually have one perimeter
        coord_t infill_peri_overlap = 0;
        coord_t top_infill_peri_overlap = 0;
        if (inset > 0) {
            if(this->layer_id == 0 || this->upper_slices == nullptr){
                infill_peri_overlap = coord_t(scale_(this->config->top_bottom_infill_wall_overlap.get_abs_value(unscale<double>(inset + solid_infill_spacing / 2))));
            }else{
                infill_peri_overlap = coord_t(scale_(this->config->infill_wall_overlap.get_abs_value(unscale<double>(inset + solid_infill_spacing / 2))));
                top_infill_peri_overlap = coord_t(scale_(this->config->top_bottom_infill_wall_overlap.get_abs_value(unscale<double>(inset + solid_infill_spacing / 2))));
            }
            inset -= infill_peri_overlap;
        }
        // simplify infill contours according to resolution
        Polygons pp;
        for (ExPolygon &ex : last)
            ex.simplify_p(m_scaled_resolution, &pp);
        ExPolygons not_filled_exp = union_ex(pp);
        // collapse too narrow infill areas
        coord_t min_perimeter_infill_spacing = coord_t(solid_infill_spacing * (1. - INSET_OVERLAP_TOLERANCE));
 
        ExPolygons infill_exp = offset2_ex(
            not_filled_exp,
            float(-inset - min_perimeter_infill_spacing / 2.),
            float(min_perimeter_infill_spacing / 2.));
        // append infill areas to fill_surfaces
        //if any top_fills, grow them by ext_perimeter_spacing/2 to have the real un-anchored fill
        ExPolygons top_infill_exp = intersection_ex(fill_clip, offset_ex(top_fills, double(ext_perimeter_spacing / 2)));
        // ORCA: only_one_wall_top - route the top fill around the walls kept despite grazing the top.
        if (!one_wall_top_kept_bands.empty())
            top_infill_exp = diff_ex(top_infill_exp, one_wall_top_kept_bands);
        if (!top_fills.empty()) {
            infill_exp = union_ex(infill_exp, offset_ex(top_infill_exp, double(top_infill_peri_overlap)));
        }
        // ORCA: only_one_wall_top - what the top fill does not cover of the dropped walls goes to infill.
        if (!one_wall_top_reclaimed.empty())
            infill_exp = union_ex(infill_exp, one_wall_top_reclaimed);
        this->fill_surfaces->append(infill_exp, stInternal);
 
        apply_extra_perimeters(infill_exp);
 
        // BBS: get the no-overlap infill expolygons
        {
            ExPolygons polyWithoutOverlap;
            if (min_perimeter_infill_spacing / 2 > infill_peri_overlap)
                polyWithoutOverlap = offset2_ex(
                    not_filled_exp,
                    float(-inset - min_perimeter_infill_spacing / 2.),
                    float(min_perimeter_infill_spacing / 2 - infill_peri_overlap));
            else
                polyWithoutOverlap = offset_ex(
                    not_filled_exp,
                    double(-inset - infill_peri_overlap));
            if (!top_fills.empty())
                polyWithoutOverlap = union_ex(polyWithoutOverlap, top_infill_exp);
            if (!one_wall_top_reclaimed.empty())
                polyWithoutOverlap = union_ex(polyWithoutOverlap, one_wall_top_reclaimed);
            this->fill_no_overlap->insert(this->fill_no_overlap->end(), polyWithoutOverlap.begin(), polyWithoutOverlap.end());
        }
 
    } // for each island
}

References Slic3r::append(), Slic3r::ExtrusionEntityCollection::append(), apply_extra_perimeters(), Slic3r::chain_expolygons(), Slic3r::PerimeterGeneratorLoop::children, Slic3r::ClipperUtils::clip_clipper_polygons_with_subject_bbox(), Slic3r::ClipperSafetyOffset, Slic3r::SVG::Close(), config, Slic3r::Polygon::contains(), Slic3r::defer_unsupported_loops(), Slic3r::diff(), Slic3r::diff_ex(), Slic3r::SVG::draw(), Slic3r::empty(), Slic3r::ExtrusionEntityCollection::empty(), Slic3r::Enabled, Slic3r::ExtrusionEntityCollection::entities, Slic3r::erGapFill, Slic3r::Surface::expolygon, ext_perimeter_flow, Slic3r::Surface::extra_perimeters, fill_no_overlap, fill_surfaces, Slic3r::MultiPoint::first_point(), gap_fill, generate_lower_polygons_series(), Slic3r::get_extents(), Slic3r::get_extruder_index(), Slic3r::Feature::FuzzySkin::group_region_by_fuzzify(), Slic3r::has_bottom_shell_layers(), has_fuzzy_skin, Slic3r::has_top_shell_layers(), Slic3r::holes(), Slic3r::BoundingBox::inflated(), Slic3r::InnerOuter, Slic3r::InnerOuterInner, INSET_OVERLAP_TOLERANCE, Slic3r::intersection_ex(), Slic3r::intersection_pl(), Slic3r::Surface::is_bridge(), Slic3r::keep_largest_contour_only(), layer_id, loops, lower_slices, m_ext_mm3_per_mm, m_ext_mm3_per_mm_smaller_width, m_external_lower_polygons_series, m_lower_polygons_series, m_lower_slices_polygons, m_mm3_per_mm, m_mm3_per_mm_overhang, m_scaled_resolution, m_smaller_external_lower_polygons_series, m_spiral_vase, Slic3r::Polygon::make_counter_clockwise(), Slic3r::BoundingBoxBase< PointType, APointsType >::merge(), narrow_loop_length_threshold, Slic3r::nozzle_diameter(), object_config, Slic3r::offset(), Slic3r::offset2_ex(), Slic3r::offset_ex(), Slic3r::opening_ex(), outer_walls_first_for_brim(), Slic3r::OuterInner, overhang_flow, perimeter_flow, Slic3r::PerimeterGeneratorLoop::polygon, print_config, process_no_bridge(), Slic3r::reorient_perimeters(), Slic3r::ExtrusionEntityCollection::replace(), Slic3r::ExtrusionEntityCollection::reverse(), scale_, Slic3r::scaled(), SCALED_EPSILON, SCALING_FACTOR, Slic3r::ExPolygon::simplify_p(), Slic3r::ExtrusionEntityCollection::size(), slices, SMALLER_EXT_INSET_OVERLAP_TOLERANCE, smaller_ext_perimeter_flow, solid_infill_flow, Slic3r::sparse_infill_density(), Slic3r::Polygon::split_at_first_point(), split_top_surfaces(), Slic3r::stInternal, Slic3r::to_polygons(), Slic3r::to_polylines(), Slic3r::top_fill_replaces_inner_walls(), Slic3r::traverse_loops(), Slic3r::union_ex(), Slic3r::unscale(), upper_slices, and Slic3r::variable_width().

Referenced by Slic3r::LayerRegion::make_perimeters().

Here is the caller graph for this function:

process_no_bridge()

void Slic3r::PerimeterGenerator::process_no_bridge ( Surfaces & all_surfaces, coord_t perimeter_spacing, coord_t ext_perimeter_width )

private

{
 
    if (this->config->counterbore_hole_bridging == chbNone)
        return; // return if counterbore hole is not enabled
 
    //store surface for bridge infill to avoid unsupported perimeters (but the first one, this one is always good)
    if (this->lower_slices != NULL && !this->lower_slices->empty()) {
        const coordf_t bridged_infill_margin = scale_(BRIDGE_INFILL_MARGIN);
 
        for (size_t surface_idx = 0; surface_idx < all_surfaces.size(); surface_idx++) {
            Surface* surface = &all_surfaces[surface_idx];
            ExPolygons last = { surface->expolygon };
            //compute our unsupported surface
            ExPolygons unsupported = diff_ex(last, *this->lower_slices, ApplySafetyOffset::Yes);
            if (!unsupported.empty()) {
                //remove small overhangs
                ExPolygons unsupported_filtered = opening_ex(unsupported, perimeter_spacing);
 
                if (!unsupported_filtered.empty()) {
                    //to_draw.insert(to_draw.end(), last.begin(), last.end());
                    //extract only the useful part of the lower layer. The safety offset is really needed here.
                    ExPolygons support = diff_ex(last, unsupported, ApplySafetyOffset::Yes);
                    if (!unsupported.empty()) {
                        //only consider the part that can be bridged (really, by the bridge algorithm)
                        //first, separate into islands (ie, each ExPlolygon)
                        int numploy = 0;
                        //only consider the bottom layer that intersect unsupported, to be sure it's only on our island.
                        ExPolygonCollection lower_island(support);
                        //a detector per island
                        ExPolygons bridgeable;
                        for (ExPolygon unsupported : unsupported_filtered) {
                            BridgeDetector detector{ unsupported,
                                                    lower_island.expolygons,
                                                    perimeter_spacing / 4}; // Use a finer BridgeDetector. This affects coverage resolution, not extrusion spacing.
                            // ORCA: Relative/Align Bridge Angle
                            const double custom_angle_deg = this->config->bridge_angle.value;
                            const bool   relative_angle   = this->config->relative_bridge_angle.value;
                            const double detect_angle_rad = (custom_angle_deg > 0.0 && !relative_angle)
                                ? Geometry::deg2rad(custom_angle_deg) +
                                      (this->config->align_infill_direction_to_model ? this->m_model_rotation_rad : 0.0)
                                : 0.0;
                            if (detector.detect_angle(detect_angle_rad))
                                expolygons_append(bridgeable, union_ex(detector.coverage(-1, true)));
                        }
                        if (!bridgeable.empty() && !surface->expolygon.holes.empty()) { // keep out if cannot be bridged or no holes to bridge
                            const coordf_t bridge_anchor_offset = std::min({bridged_infill_margin, coordf_t(perimeter_spacing), coordf_t(ext_perimeter_width)});
 
                            // Handle filled vs partial counterbore bridging modes.
                            if (this->config->counterbore_hole_bridging.value == chbFilled) {
                                unsupported_filtered = offset_ex(unsupported_filtered, -perimeter_spacing);  // shrink it to survive the strict bridge-candidate filter
 
                                //we bridge everything, even the not-bridgeable bits
                                for (size_t i = 0; i < unsupported_filtered.size();) {
                                    ExPolygon& poly_unsupp = *(unsupported_filtered.begin() + i);
                                    Polygons contour_simplified = poly_unsupp.contour.simplify(perimeter_spacing);
                                    ExPolygon poly_unsupp_bigger = poly_unsupp;
                                    Polygons contour_bigger = offset(poly_unsupp_bigger.contour, bridged_infill_margin);
                                    if (contour_bigger.size() == 1) poly_unsupp_bigger.contour = contour_bigger[0];
 
                                    //check convex, has some bridge, not overhang
                                    if (contour_simplified.size() == 1 && contour_bigger.size() == 1 && contour_simplified[0].concave_points().size() == 0
                                        && intersection_ex(bridgeable, ExPolygons{ poly_unsupp }).size() > 0
                                        && diff_ex(ExPolygons{ poly_unsupp_bigger }, union_ex(last, offset_ex(bridgeable, bridged_infill_margin + perimeter_spacing / 2)), ApplySafetyOffset::Yes).size() == 0
                                    ) {
                                        //ok, keep it
                                        i++;
                                    } else {
                                        unsupported_filtered.erase(unsupported_filtered.begin() + i);
                                    }
                                }
 
                                unsupported_filtered = offset_ex(unsupported_filtered, perimeter_spacing + bridge_anchor_offset); // restore it back to its original size and add anchor
                                unsupported_filtered = intersection_ex(last, unsupported_filtered); // clamp to the original surface, to avoid creating new unsupported areas
 
                                for (ExPolygon& expol : unsupported_filtered) {
                                    // Remove holes that need sacrificial fill, but keep holes
                                    // whose wall is already supported by the lower layer.
                                    const float hole_wall_width = float(ext_perimeter_width / 2);
                                    for (size_t hole_idx = 0; hole_idx < expol.holes.size();) {
                                        Polygon hole_area_contour = expol.holes[hole_idx];
                                        hole_area_contour.make_counter_clockwise();
 
                                        const ExPolygons hole_area = { ExPolygon(hole_area_contour) };
                                        ExPolygons hole_wall_area = diff_ex(
                                            offset_ex(hole_area_contour, hole_wall_width),
                                            hole_area,
                                            ApplySafetyOffset::Yes);
                                        hole_wall_area = intersection_ex(hole_wall_area, ExPolygons{ expol }, ApplySafetyOffset::Yes);
                                        if (!hole_wall_area.empty() &&
                                            intersection_ex(hole_wall_area, *this->lower_slices, ApplySafetyOffset::Yes).empty())
                                            expol.holes.erase(expol.holes.begin() + hole_idx);
                                            // After erase(), the next hole shifts into the same index. So hole_idx
                                            // must not be incremented, otherwise the next hole would be skipped.
                                        else
                                            ++hole_idx; // keep this hole, it won't be bridged, so we need to keep it as a hole
                                    }
 
                                    //detect inside volume
                                    for (size_t surface_idx_other = 0; surface_idx_other < all_surfaces.size(); surface_idx_other++) {
                                        if (surface_idx == surface_idx_other) continue;
                                        if (intersection_ex(ExPolygons() = { expol }, ExPolygons() = { all_surfaces[surface_idx_other].expolygon }).size() > 0) {
                                            //this means that other_surf was inside an expol holes
                                            //as we removed them, we need to add a new one
                                            ExPolygons new_poly = offset2_ex(ExPolygons{ all_surfaces[surface_idx_other].expolygon }, double(-bridged_infill_margin - perimeter_spacing), double(perimeter_spacing));
                                            if (new_poly.size() == 1) {
                                                all_surfaces[surface_idx_other].expolygon = new_poly[0];
                                                expol.holes.push_back(new_poly[0].contour);
                                                expol.holes.back().make_clockwise();
                                            } else {
                                                for (size_t idx = 0; idx < new_poly.size(); idx++) {
                                                    Surface new_surf = all_surfaces[surface_idx_other];
                                                    new_surf.expolygon = new_poly[idx];
                                                    all_surfaces.push_back(new_surf);
                                                    expol.holes.push_back(new_poly[idx].contour);
                                                    expol.holes.back().make_clockwise();
                                                }
                                                all_surfaces.erase(all_surfaces.begin() + surface_idx_other);
                                                if (surface_idx_other < surface_idx) {
                                                    surface_idx--;
                                                    surface = &all_surfaces[surface_idx];
                                                }
                                                surface_idx_other--;
                                            }
                                        }
                                    }
                                }
                                //TODO: add other polys as holes inside this one (-margin)
                            } else { // if(this->config->counterbore_hole_bridging.value == chbBridges)
                                // Orca: Partial counterbore bridging is mask-based. Preserve the supported
                                // remainder and use simplified BridgeDetector coverage to derive the
                                // bridgeable counterbore span. The span is grown from supported material,
                                // shrunk back, stripped from the remaining normal surface, and expanded back.
                                // It is then prevented from intruding deeper into it than the explicit anchor overlap.
                                // Finally, add the allowed anchor band from it then remove the
                                // narrow hole-side wall contact, which must remain unbridgeable.
 
                                const ExPolygons remaining = diff_ex(last, unsupported_filtered, ApplySafetyOffset::Yes);
 
                                ExPolygons bridgeable_filtered;
 
                                for (ExPolygon& poly : bridgeable) {
                                    poly.simplify(perimeter_spacing, &bridgeable_filtered);
                                }
                                bridgeable_filtered = opening_ex(bridgeable_filtered, ext_perimeter_width);
 
                                // Get rid of coarseness of the resulted bridgeable area by using the original supported area as reference.
                                // This is to avoid keeping tiny bridgeable areas that are far from the supported area, or protrude into it.
                                bridgeable_filtered = union_ex(offset_ex(remaining, perimeter_spacing), bridgeable_filtered);
                                bridgeable_filtered = offset_ex(bridgeable_filtered, -perimeter_spacing);
                                bridgeable_filtered = diff_ex(bridgeable_filtered, remaining, ApplySafetyOffset::Yes);
                                bridgeable_filtered = opening_ex(bridgeable_filtered, ext_perimeter_width / 2); // filter noise from the diff_ex
                                bridgeable_filtered = offset_ex(bridgeable_filtered, perimeter_spacing);  // restore the size to the original bridgeable area
                                // Safety measure: Keep the bridge mask from intruding deeper into the
                                // supported anchor region than the explicit anchor overlap.
                                bridgeable_filtered = diff_ex(bridgeable_filtered, offset_ex(remaining, -bridge_anchor_offset));
 
                                ExPolygons bridge_anchor_areas = intersection_ex(remaining, offset_ex(unsupported_filtered, bridge_anchor_offset));
                                unsupported_filtered = union_ex(bridgeable_filtered, bridge_anchor_areas); // add bridge anchor
                                unsupported_filtered = opening_ex(unsupported_filtered, bridge_anchor_offset); // remove anchor area from hole-side walls, it must remain unbridgeable
 
                                // update 'last' only if we have a valid bridgeable area, otherwise we will lose the original unsupported area
                                if (!unsupported_filtered.empty())
                                    last = remaining;
                                // TODO: Fix the case with thin outer walls around the bridge (1~2 walls) where classic wall
                                // might generate two walls in a tiny space or non at all if "Detect thin walls" is not activated
                            }
                        } else {
                            unsupported_filtered.clear();
                        }
                    }
 
                    if (!unsupported_filtered.empty()) {
 
                        //add this directly to the infill list.
                        // this will avoid to throw wrong offsets into a good polygons
                        this->fill_surfaces->append(
                            unsupported_filtered,
                            stInternal);
 
                        // store the results
                        last = diff_ex(last, unsupported_filtered, ApplySafetyOffset::Yes);
                        //remove "thin air" polygons (note: it assumes that all polygons below will be extruded)
                        for (int i = 0; i < last.size(); i++) {
                            if (intersection_ex(support, ExPolygons() = { last[i] }).empty()) {
                                this->fill_surfaces->append(
                                    ExPolygons() = { last[i] },
                                    stInternal);
                                last.erase(last.begin() + i);
                                i--;
                            }
                        }
                    }
                }
            }
            if (last.size() == 0) {
                all_surfaces.erase(all_surfaces.begin() + surface_idx);
                surface_idx--;
            } else {
                surface->expolygon = last[0];
                for (size_t idx = 1; idx < last.size(); idx++) {
                    all_surfaces.emplace_back(*surface, last[idx]);
                }
            }
        }
    }
}

References BRIDGE_INFILL_MARGIN, Slic3r::chbFilled, Slic3r::chbNone, config, Slic3r::contour(), Slic3r::ExPolygon::contour, Slic3r::BridgeDetector::coverage(), Slic3r::Geometry::deg2rad(), Slic3r::BridgeDetector::detect_angle(), Slic3r::diff_ex(), Slic3r::empty(), Slic3r::Surface::expolygon, Slic3r::ExPolygonCollection::expolygons, Slic3r::expolygons_append(), fill_surfaces, Slic3r::ExPolygon::holes, Slic3r::intersection_ex(), lower_slices, m_model_rotation_rad, Slic3r::Polygon::make_counter_clockwise(), Slic3r::offset(), Slic3r::offset2_ex(), Slic3r::offset_ex(), Slic3r::opening_ex(), process_no_bridge(), scale_, Slic3r::Polygon::simplify(), Slic3r::stInternal, Slic3r::union_ex(), and Slic3r::Yes.

Referenced by process_arachne(), process_classic(), and process_no_bridge().

Here is the call graph for this function:

Here is the caller graph for this function:

smaller_width_ext_mm3_per_mm()

double Slic3r::PerimeterGenerator::smaller_width_ext_mm3_per_mm ( ) const

inline

{ return m_ext_mm3_per_mm_smaller_width; }

References m_ext_mm3_per_mm_smaller_width.

Referenced by Slic3r::traverse_loops().

Here is the caller graph for this function:

split_top_surfaces()

void Slic3r::PerimeterGenerator::split_top_surfaces ( const ExPolygons & orig_polygons, ExPolygons & top_fills, ExPolygons & non_top_polygons, ExPolygons & fill_clip ) const

private

                                                                                                       {
    // other perimeters
    coord_t perimeter_width = this->perimeter_flow.scaled_width();
    coord_t perimeter_spacing = this->perimeter_flow.scaled_spacing();
 
    // external perimeters
    coord_t ext_perimeter_width = this->ext_perimeter_flow.scaled_width();
    coord_t ext_perimeter_spacing = this->ext_perimeter_flow.scaled_spacing();
 
    bool has_gap_fill = this->config->gap_infill_speed.get_at(get_extruder_index(*print_config, this->config->outer_wall_filament_id - 1)) > 0;
 
    // split the polygons with top/not_top
    // get the offset from solid surface anchor
    coord_t offset_top_surface =
        scale_(0.9 * (config->wall_loops.value == 0
                          ? 0.
                          : unscaled(double(ext_perimeter_width +
                                            perimeter_spacing * int(int(config->wall_loops.value) - int(1))))));
    // if possible, try to not push the extra perimeters inside the sparse infill
    if (offset_top_surface >
        0.9 * (config->wall_loops.value <= 1 ? 0. : (perimeter_spacing * (config->wall_loops.value - 1))))
        offset_top_surface -=
            coord_t(0.9 * (config->wall_loops.value <= 1 ? 0. : (perimeter_spacing * (config->wall_loops.value - 1))));
    else
        offset_top_surface = 0;
    // don't takes into account too thin areas
    // get boungding box of last
    BoundingBox last_box = get_extents(orig_polygons);
    last_box.offset(SCALED_EPSILON);
 
    // skip if the exposed area is smaller than "min_width_top_surface"
    double min_width_top_surface = std::max(double(ext_perimeter_spacing / 2. + 10), scale_(config->min_width_top_surface.get_abs_value(unscale_(perimeter_width))));
 
    // get the Polygons upper the polygon this layer
    Polygons upper_polygons_series_clipped;
    if (object_config->interface_shells) {
        auto upper_slicer_same_region = to_expolygons(this->upper_slices_same_region->surfaces);
        upper_polygons_series_clipped = ClipperUtils::clip_clipper_polygons_with_subject_bbox(upper_slicer_same_region, last_box);
    } else
        upper_polygons_series_clipped = ClipperUtils::clip_clipper_polygons_with_subject_bbox(*this->upper_slices, last_box);
 
    upper_polygons_series_clipped          = offset(upper_polygons_series_clipped, min_width_top_surface);
 
    // set the clip to a virtual "second perimeter"
    fill_clip = offset_ex(orig_polygons, -double(ext_perimeter_spacing));
    // get the real top surface
    ExPolygons grown_lower_slices;
    ExPolygons bridge_checker;
    auto nozzle_diameter = this->print_config->nozzle_diameter.get_at(this->config->outer_wall_filament_id - 1);
    // Check whether surface be bridge or not
    if (this->lower_slices != NULL) {
        // BBS: get the Polygons below the polygon this layer
        Polygons lower_polygons_series_clipped =
            ClipperUtils::clip_clipper_polygons_with_subject_bbox(*this->lower_slices, last_box);
        double bridge_offset = std::max(double(ext_perimeter_spacing), (double(perimeter_width)));
        // SoftFever: improve bridging
        const float bridge_margin =
            std::min(float(scale_(BRIDGE_INFILL_MARGIN)), float(scale_(nozzle_diameter * BRIDGE_INFILL_MARGIN / 0.4)));
        bridge_checker = offset_ex(diff_ex(orig_polygons, lower_polygons_series_clipped, ApplySafetyOffset::Yes),
                                   1.5 * bridge_offset + bridge_margin + perimeter_spacing / 2.);
    }
    ExPolygons delete_bridge = diff_ex(orig_polygons, bridge_checker, ApplySafetyOffset::Yes);
 
    ExPolygons top_polygons = diff_ex(delete_bridge, upper_polygons_series_clipped, ApplySafetyOffset::Yes);
 
    // get the not-top surface, from the "real top" but enlarged by external_infill_margin (and the
    // min_width_top_surface we removed a bit before)
    ExPolygons temp_gap = diff_ex(top_polygons, fill_clip);
    ExPolygons inner_polygons =
        diff_ex(orig_polygons,
                offset_ex(top_polygons, offset_top_surface + min_width_top_surface - double(ext_perimeter_spacing / 2.)),
                ApplySafetyOffset::Yes);
    // get the enlarged top surface, by using inner_polygons instead of upper_slices, and clip it for it to be exactly
    // the polygons to fill.
    top_polygons = diff_ex(fill_clip, inner_polygons, ApplySafetyOffset::Yes);
    // increase by half peri the inner space to fill the frontier between last and stored.
    top_fills = union_ex(top_fills, top_polygons);
    //set the clip to the external wall but go back inside by infill_extrusion_width/2 to be sure the extrusion won't go outside even with a 100% overlap.
    double infill_spacing_unscaled = this->config->sparse_infill_line_width.get_abs_value(nozzle_diameter);
    if (infill_spacing_unscaled == 0) infill_spacing_unscaled = Flow::auto_extrusion_width(frInfill, nozzle_diameter);
    fill_clip = offset_ex(orig_polygons, double(ext_perimeter_spacing / 2.) - scale_(infill_spacing_unscaled / 2.));
    // ExPolygons oldLast = last;
 
    non_top_polygons = intersection_ex(inner_polygons, orig_polygons);
    if (has_gap_fill)
        non_top_polygons = union_ex(non_top_polygons, temp_gap);
    //{
    //    std::stringstream stri;
    //    stri << this->layer_id << "_1_"<< i <<"_only_one_peri"<< ".svg";
    //    SVG svg(stri.str());
    //    svg.draw(to_polylines(top_fills), "green");
    //    svg.draw(to_polylines(inner_polygons), "yellow");
    //    svg.draw(to_polylines(top_polygons), "cyan");
    //    svg.draw(to_polylines(oldLast), "orange");
    //    svg.draw(to_polylines(last), "red");
    //    svg.Close();
    //}
}

References Slic3r::Flow::auto_extrusion_width(), BRIDGE_INFILL_MARGIN, Slic3r::ClipperUtils::clip_clipper_polygons_with_subject_bbox(), config, Slic3r::diff_ex(), ext_perimeter_flow, Slic3r::frInfill, Slic3r::get_extents(), Slic3r::get_extruder_index(), Slic3r::intersection_ex(), lower_slices, Slic3r::min_width_top_surface(), Slic3r::nozzle_diameter(), object_config, Slic3r::BoundingBoxBase< PointType, APointsType >::offset(), Slic3r::offset(), Slic3r::offset_ex(), perimeter_flow, print_config, scale_, SCALED_EPSILON, Slic3r::to_expolygons(), Slic3r::union_ex(), unscale_, Slic3r::unscaled(), upper_slices, upper_slices_same_region, and Slic3r::Yes.

Referenced by process_classic().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

compatible_regions

const LayerRegionPtrs* Slic3r::PerimeterGenerator::compatible_regions

Referenced by PerimeterGenerator(), and Slic3r::Feature::FuzzySkin::group_region_by_fuzzify().

config

const PrintRegionConfig* Slic3r::PerimeterGenerator::config

Referenced by PerimeterGenerator(), add_infill_contour_for_arachne(), apply_extra_perimeters(), Slic3r::defer_unsupported_loops(), generate_lower_polygons_series(), process_arachne(), process_classic(), process_no_bridge(), split_top_surfaces(), Slic3r::traverse_extrusions(), and Slic3r::traverse_loops().

ext_perimeter_flow

Flow Slic3r::PerimeterGenerator::ext_perimeter_flow

Referenced by PerimeterGenerator(), Slic3r::Feature::FuzzySkin::apply_fuzzy_skin(), Slic3r::defer_unsupported_loops(), Slic3r::Feature::FuzzySkin::group_region_by_fuzzify(), Slic3r::LayerRegion::make_perimeters(), process_arachne(), process_classic(), split_top_surfaces(), Slic3r::traverse_extrusions(), and Slic3r::traverse_loops().

fill_no_overlap

ExPolygons* Slic3r::PerimeterGenerator::fill_no_overlap

Referenced by PerimeterGenerator(), add_infill_contour_for_arachne(), and process_classic().

fill_surfaces

SurfaceCollection* Slic3r::PerimeterGenerator::fill_surfaces

Referenced by PerimeterGenerator(), add_infill_contour_for_arachne(), apply_extra_perimeters(), process_classic(), and process_no_bridge().

fuzzy_supported_area

std::optional<ExPolygons> Slic3r::PerimeterGenerator::fuzzy_supported_area

Referenced by Slic3r::Feature::FuzzySkin::apply_fuzzy_skin(), Slic3r::Feature::FuzzySkin::apply_fuzzy_skin(), and Slic3r::Feature::FuzzySkin::group_region_by_fuzzify().

gap_fill

ExtrusionEntityCollection* Slic3r::PerimeterGenerator::gap_fill

Referenced by PerimeterGenerator(), and process_classic().

has_fuzzy_hole

bool Slic3r::PerimeterGenerator::has_fuzzy_hole = false

Referenced by Slic3r::Feature::FuzzySkin::group_region_by_fuzzify(), Slic3r::traverse_extrusions(), and Slic3r::traverse_loops().

has_fuzzy_skin

bool Slic3r::PerimeterGenerator::has_fuzzy_skin = false

Referenced by Slic3r::Feature::FuzzySkin::group_region_by_fuzzify(), process_arachne(), process_classic(), Slic3r::traverse_extrusions(), and Slic3r::traverse_loops().

layer_height

double Slic3r::PerimeterGenerator::layer_height

Referenced by PerimeterGenerator(), Slic3r::Feature::FuzzySkin::apply_fuzzy_skin(), and Slic3r::traverse_loops().

layer_id

int Slic3r::PerimeterGenerator::layer_id

Referenced by PerimeterGenerator(), Slic3r::Feature::FuzzySkin::apply_fuzzy_skin(), Slic3r::Feature::FuzzySkin::apply_fuzzy_skin(), Slic3r::Feature::FuzzySkin::group_region_by_fuzzify(), Slic3r::LayerRegion::make_perimeters(), outer_walls_first_for_brim(), printable_slices(), process_classic(), Slic3r::traverse_extrusions(), and Slic3r::traverse_loops().

loops

ExtrusionEntityCollection* Slic3r::PerimeterGenerator::loops

Referenced by PerimeterGenerator(), add_infill_contour_for_arachne(), apply_extra_perimeters(), process_arachne(), and process_classic().

lower_slices

const ExPolygons* Slic3r::PerimeterGenerator::lower_slices

Referenced by PerimeterGenerator(), apply_extra_perimeters(), generate_lower_polygons_series(), Slic3r::Feature::FuzzySkin::group_region_by_fuzzify(), Slic3r::LayerRegion::make_perimeters(), process_arachne(), process_classic(), process_no_bridge(), split_top_surfaces(), Slic3r::traverse_extrusions(), and Slic3r::traverse_loops().

m_ext_mm3_per_mm

double Slic3r::PerimeterGenerator::m_ext_mm3_per_mm

private

Referenced by PerimeterGenerator(), ext_mm3_per_mm(), process_arachne(), and process_classic().

m_ext_mm3_per_mm_smaller_width

double Slic3r::PerimeterGenerator::m_ext_mm3_per_mm_smaller_width

private

Referenced by PerimeterGenerator(), process_classic(), and smaller_width_ext_mm3_per_mm().

m_external_lower_polygons_series

std::vector<Polygons> Slic3r::PerimeterGenerator::m_external_lower_polygons_series

Referenced by process_classic(), and Slic3r::traverse_loops().

m_lower_polygons_series

std::vector<Polygons> Slic3r::PerimeterGenerator::m_lower_polygons_series

Referenced by process_classic(), and Slic3r::traverse_loops().

m_lower_slices_polygons

Polygons Slic3r::PerimeterGenerator::m_lower_slices_polygons

private

Referenced by lower_slices_polygons(), process_arachne(), and process_classic().

m_mm3_per_mm

double Slic3r::PerimeterGenerator::m_mm3_per_mm

private

Referenced by PerimeterGenerator(), mm3_per_mm(), process_arachne(), and process_classic().

m_mm3_per_mm_overhang

double Slic3r::PerimeterGenerator::m_mm3_per_mm_overhang

private

Referenced by PerimeterGenerator(), mm3_per_mm_overhang(), process_arachne(), and process_classic().

m_model_rotation_rad

double Slic3r::PerimeterGenerator::m_model_rotation_rad

private

Referenced by PerimeterGenerator(), and process_no_bridge().

m_scaled_resolution

double Slic3r::PerimeterGenerator::m_scaled_resolution

private

Referenced by PerimeterGenerator(), add_infill_contour_for_arachne(), process_arachne(), and process_classic().

m_smaller_external_lower_polygons_series

std::vector<Polygons> Slic3r::PerimeterGenerator::m_smaller_external_lower_polygons_series

Referenced by process_classic(), and Slic3r::traverse_loops().

m_spiral_vase

bool Slic3r::PerimeterGenerator::m_spiral_vase

private

Referenced by PerimeterGenerator(), apply_extra_perimeters(), and process_classic().

object_config

const PrintObjectConfig* Slic3r::PerimeterGenerator::object_config

Referenced by PerimeterGenerator(), outer_walls_first_for_brim(), printable_slices(), process_classic(), split_top_surfaces(), Slic3r::traverse_extrusions(), and Slic3r::traverse_loops().

overhang_flow

Flow Slic3r::PerimeterGenerator::overhang_flow

Referenced by PerimeterGenerator(), Slic3r::LayerRegion::make_perimeters(), process_arachne(), process_classic(), Slic3r::traverse_extrusions(), and Slic3r::traverse_loops().

perimeter_flow

Flow Slic3r::PerimeterGenerator::perimeter_flow

Referenced by PerimeterGenerator(), Slic3r::defer_unsupported_loops(), process_arachne(), process_classic(), split_top_surfaces(), Slic3r::traverse_extrusions(), and Slic3r::traverse_loops().

print_config

const PrintConfig* Slic3r::PerimeterGenerator::print_config

Referenced by PerimeterGenerator(), generate_lower_polygons_series(), printable_slices(), process_arachne(), process_classic(), and split_top_surfaces().

regions_by_fuzzify

std::vector<std::pair<FuzzySkinConfig, ExPolygons> > Slic3r::PerimeterGenerator::regions_by_fuzzify

Referenced by Slic3r::Feature::FuzzySkin::apply_fuzzy_skin(), Slic3r::Feature::FuzzySkin::apply_fuzzy_skin(), and Slic3r::Feature::FuzzySkin::group_region_by_fuzzify().

slice_z

coordf_t Slic3r::PerimeterGenerator::slice_z

Referenced by PerimeterGenerator(), Slic3r::Feature::FuzzySkin::apply_fuzzy_skin(), and Slic3r::Feature::FuzzySkin::apply_fuzzy_skin().

slices

const SurfaceCollection* Slic3r::PerimeterGenerator::slices

Referenced by PerimeterGenerator(), Slic3r::Feature::FuzzySkin::apply_fuzzy_skin(), Slic3r::Feature::FuzzySkin::apply_fuzzy_skin(), printable_slices(), process_arachne(), and process_classic().

smaller_ext_perimeter_flow

Flow Slic3r::PerimeterGenerator::smaller_ext_perimeter_flow

Referenced by process_classic(), and Slic3r::traverse_loops().

solid_infill_flow

Flow Slic3r::PerimeterGenerator::solid_infill_flow

Referenced by PerimeterGenerator(), Slic3r::LayerRegion::make_perimeters(), process_arachne(), and process_classic().

upper_slices

const ExPolygons* Slic3r::PerimeterGenerator::upper_slices

Referenced by PerimeterGenerator(), Slic3r::LayerRegion::make_perimeters(), process_classic(), and split_top_surfaces().

upper_slices_same_region

const SurfaceCollection* Slic3r::PerimeterGenerator::upper_slices_same_region

Referenced by Slic3r::LayerRegion::make_perimeters(), and split_top_surfaces().

---

The documentation for this class was generated from the following files:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/PerimeterGenerator.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/PerimeterGenerator.cpp