Slic3r::LayerRegion Class Reference

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

Collaboration diagram for Slic3r::LayerRegion:

Public Member Functions
Layer *	layer ()
const Layer *	layer () const
const PrintRegion &	region () const
const SurfaceCollection &	get_slices () const
Flow	flow (FlowRole role) const
Flow	flow (FlowRole role, double layer_height) const
Flow	bridging_flow (FlowRole role, bool thick_bridge=false) const
void	slices_to_fill_surfaces_clipped ()
void	prepare_fill_surfaces ()
void	make_perimeters (const SurfaceCollection &slices, const LayerRegionPtrs &compatible_regions, SurfaceCollection *fill_surfaces, ExPolygons *fill_no_overlap)
void	process_external_surfaces (const Layer *lower_layer, const Polygons *lower_layer_covered)
double	infill_area_threshold () const
void	trim_surfaces (const Polygons &trimming_polygons)
void	elephant_foot_compensation_step (const float elephant_foot_compensation_perimeter_step, const Polygons &trimming_polygons)
void	export_region_slices_to_svg (const char *path) const
void	export_region_fill_surfaces_to_svg (const char *path) const
void	export_region_slices_to_svg_debug (const char *name) const
void	export_region_fill_surfaces_to_svg_debug (const char *name) const
bool	has_extrusions () const
void	simplify_infill_extrusion_entity ()
void	simplify_wall_extrusion_entity ()

Public Attributes
SurfaceCollection	slices
ExPolygons	raw_slices
ExtrusionEntityCollection	thin_fills
ExPolygons	fill_expolygons
SurfaceCollection	fill_surfaces
ExPolygons	fill_no_overlap_expolygons
Polylines	unsupported_bridge_edges
ExtrusionEntityCollection	perimeters
ExtrusionEntityCollection	fills

Protected Member Functions
	LayerRegion (Layer *layer, const PrintRegion *region)
	~LayerRegion ()

Private Member Functions
void	simplify_entity_collection (ExtrusionEntityCollection *entity_collection)
void	simplify_path (ExtrusionPath *path)
void	simplify_multi_path (ExtrusionMultiPath *multipath)
void	simplify_loop (ExtrusionLoop *loop)

Private Attributes
Layer *	m_layer
const PrintRegion *	m_region

Friends
class	Layer
class	PrintObject

Detailed Description

Constructor & Destructor Documentation

LayerRegion()

Slic3r::LayerRegion::LayerRegion ( Layer * layer, const PrintRegion * region )

inlineprotected

: m_layer(layer), m_region(region) {}

References Layer, layer(), m_layer, m_region, and region().

Here is the call graph for this function:

~LayerRegion()

Slic3r::LayerRegion::~LayerRegion ( )

inlineprotected

{}

Member Function Documentation

bridging_flow()

Flow Slic3r::LayerRegion::bridging_flow	(	FlowRole	role,
		bool	thick_bridge = false ) const

{
    const PrintRegion       &region         = this->region();
    const PrintRegionConfig &region_config  = region.config();
    const PrintObject       &print_object   = *this->layer()->object();
    Flow bridge_flow;
    // Here this->extruder(role) - 1 may underflow to MAX_INT, but then the get_at() will fall back to zero'th element, so everything is all right.
    auto nozzle_diameter = float(nozzle_diameter_for_filament(print_object.print()->config(), region.extruder(role), print_object.print()->is_BBL_printer()));
    const ConfigOptionFloatOrPercent& bridge_width_opt = region_config.bridge_line_width;
    const double                      bridge_width      = bridge_width_opt.get_abs_value(nozzle_diameter);
    const bool                        has_bridge_width  = bridge_width > 0.;
    const double                      bridge_flow_ratio = region_config.bridge_flow;
 
    if (thick_bridge) {
        // The old Slic3r way (different from all other slicers): Use rounded extrusions.
        // Get the configured nozzle_diameter for the extruder associated to the flow role requested.
        float thread_diameter = has_bridge_width ? float(bridge_width) : nozzle_diameter;
        if (bridge_flow_ratio > 0.)
            thread_diameter *= float(sqrt(bridge_flow_ratio));
        bridge_flow = Flow::bridging_flow(thread_diameter, nozzle_diameter);
    } else {
        // The same way as other slicers: Use normal extrusions. Apply bridge_flow while maintaining the original spacing.
        Flow base_flow = this->flow(role);
        if (has_bridge_width)
            base_flow = Flow(float(bridge_width), base_flow.height(), nozzle_diameter);
        bridge_flow = base_flow.with_flow_ratio(bridge_flow_ratio);
    }
    return bridge_flow;
 
}

References Slic3r::bridge_flow(), Slic3r::Flow::bridging_flow(), Slic3r::Print::config(), flow(), Slic3r::ConfigOptionFloatOrPercent::get_abs_value(), Slic3r::Flow::height(), Slic3r::Print::is_BBL_printer(), layer(), Slic3r::nozzle_diameter(), Slic3r::nozzle_diameter_for_filament(), Slic3r::Layer::object(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnum, COUNT >::print(), PrintObject, Slic3r::PrintRegionConfig, region(), and Slic3r::Flow::with_flow_ratio().

Referenced by Slic3r::group_fills(), make_perimeters(), and Slic3r::SupportMaterialInternal::remove_bridges_from_contacts().

Here is the call graph for this function:

Here is the caller graph for this function:

elephant_foot_compensation_step()

void Slic3r::LayerRegion::elephant_foot_compensation_step	(	const float	elephant_foot_compensation_perimeter_step,
		const Polygons &	trimming_polygons )

{
#ifndef NDEBUG
    for (const Surface &surface : this->slices.surfaces)
        assert(surface.surface_type == stInternal);
#endif /* NDEBUG */
    Polygons tmp = intersection(this->slices.surfaces, trimming_polygons);
    append(tmp, diff(this->slices.surfaces, opening(this->slices.surfaces, elephant_foot_compensation_perimeter_step)));
    this->slices.set(union_ex(tmp), stInternal);
}

References Slic3r::append(), Slic3r::diff(), elephant_foot_compensation_step(), Slic3r::intersection(), Slic3r::opening(), slices, Slic3r::stInternal, Slic3r::Surface::surface_type, and Slic3r::union_ex().

Referenced by elephant_foot_compensation_step().

Here is the call graph for this function:

Here is the caller graph for this function:

export_region_fill_surfaces_to_svg()

void Slic3r::LayerRegion::export_region_fill_surfaces_to_svg

(

const char *

path

)

const

{
    BoundingBox bbox;
    for (Surfaces::const_iterator surface = this->fill_surfaces.surfaces.begin(); surface != this->fill_surfaces.surfaces.end(); ++surface)
        bbox.merge(get_extents(surface->expolygon));
    Point legend_size = export_surface_type_legend_to_svg_box_size();
    Point legend_pos(bbox.min(0), bbox.max(1));
    bbox.merge(Point(std::max(bbox.min(0) + legend_size(0), bbox.max(0)), bbox.max(1) + legend_size(1)));
 
    SVG svg(path, bbox);
    const float transparency = 0.5f;
    for (const Surface &surface : this->fill_surfaces.surfaces) {
        svg.draw(surface.expolygon, surface_type_to_color_name(surface.surface_type), transparency);
        svg.draw_outline(surface.expolygon, "black", "blue", scale_(0.05)); 
    }
    export_surface_type_legend_to_svg(svg, legend_pos);
    svg.Close();
}

References Slic3r::SVG::Close(), Slic3r::SVG::draw(), Slic3r::SVG::draw_outline(), Slic3r::Surface::expolygon, export_region_fill_surfaces_to_svg(), Slic3r::export_surface_type_legend_to_svg(), Slic3r::export_surface_type_legend_to_svg_box_size(), fill_surfaces, Slic3r::get_extents(), Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::merge(), Slic3r::BoundingBoxBase< PointType, APointsType >::min, scale_, Slic3r::Surface::surface_type, and Slic3r::surface_type_to_color_name().

Referenced by export_region_fill_surfaces_to_svg(), and export_region_fill_surfaces_to_svg_debug().

Here is the call graph for this function:

Here is the caller graph for this function:

export_region_fill_surfaces_to_svg_debug()

void Slic3r::LayerRegion::export_region_fill_surfaces_to_svg_debug

(

const char *

name

)

const

{
    static std::map<std::string, size_t> idx_map;
    size_t &idx = idx_map[name];
    this->export_region_fill_surfaces_to_svg(debug_out_path("LayerRegion-fill_surfaces-%s-%d.svg", name, idx ++).c_str());
}

References Slic3r::debug_out_path(), export_region_fill_surfaces_to_svg(), and export_region_fill_surfaces_to_svg_debug().

Referenced by Slic3r::PrintObject::clip_fill_surfaces(), Slic3r::PrintObject::discover_horizontal_shells(), Slic3r::PrintObject::discover_vertical_shells(), export_region_fill_surfaces_to_svg_debug(), prepare_fill_surfaces(), Slic3r::PrintObject::prepare_infill(), and process_external_surfaces().

Here is the call graph for this function:

Here is the caller graph for this function:

export_region_slices_to_svg()

void Slic3r::LayerRegion::export_region_slices_to_svg

(

const char *

path

)

const

{
    BoundingBox bbox;
    for (Surfaces::const_iterator surface = this->slices.surfaces.begin(); surface != this->slices.surfaces.end(); ++surface)
        bbox.merge(get_extents(surface->expolygon));
    Point legend_size = export_surface_type_legend_to_svg_box_size();
    Point legend_pos(bbox.min(0), bbox.max(1));
    bbox.merge(Point(std::max(bbox.min(0) + legend_size(0), bbox.max(0)), bbox.max(1) + legend_size(1)));
 
    SVG svg(path, bbox);
    const float transparency = 0.5f;
    for (Surfaces::const_iterator surface = this->slices.surfaces.begin(); surface != this->slices.surfaces.end(); ++surface)
        svg.draw(surface->expolygon, surface_type_to_color_name(surface->surface_type), transparency);
    for (Surfaces::const_iterator surface = this->fill_surfaces.surfaces.begin(); surface != this->fill_surfaces.surfaces.end(); ++surface)
        svg.draw(surface->expolygon.lines(), surface_type_to_color_name(surface->surface_type));
    export_surface_type_legend_to_svg(svg, legend_pos);
    svg.Close();
}

References Slic3r::SVG::Close(), Slic3r::SVG::draw(), Slic3r::Surface::expolygon, export_region_slices_to_svg(), Slic3r::export_surface_type_legend_to_svg(), Slic3r::export_surface_type_legend_to_svg_box_size(), fill_surfaces, Slic3r::get_extents(), Slic3r::ExPolygon::lines(), Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::merge(), Slic3r::BoundingBoxBase< PointType, APointsType >::min, slices, Slic3r::Surface::surface_type, and Slic3r::surface_type_to_color_name().

Referenced by export_region_slices_to_svg(), and export_region_slices_to_svg_debug().

Here is the call graph for this function:

Here is the caller graph for this function:

export_region_slices_to_svg_debug()

void Slic3r::LayerRegion::export_region_slices_to_svg_debug

(

const char *

name

)

const

{
    static std::map<std::string, size_t> idx_map;
    size_t &idx = idx_map[name];
    this->export_region_slices_to_svg(debug_out_path("LayerRegion-slices-%s-%d.svg", name, idx ++).c_str());
}

References Slic3r::debug_out_path(), export_region_slices_to_svg(), and export_region_slices_to_svg_debug().

Referenced by Slic3r::PrintObject::discover_horizontal_shells(), Slic3r::PrintObject::discover_vertical_shells(), export_region_slices_to_svg_debug(), prepare_fill_surfaces(), and Slic3r::PrintObject::prepare_infill().

Here is the call graph for this function:

Here is the caller graph for this function:

flow() [1/2]

Flow Slic3r::LayerRegion::flow

(

FlowRole

role

)

const

{
    return this->flow(role, m_layer->height);
}

References flow(), and m_layer.

Referenced by bridging_flow(), Slic3r::PrintObject::clip_fill_surfaces(), Slic3r::PrintObject::discover_horizontal_shells(), Slic3r::PrintObject::discover_vertical_shells(), flow(), Slic3r::SupportSpotsGenerator::get_flow_width(), Slic3r::group_fills(), infill_area_threshold(), make_perimeters(), process_external_surfaces(), and Slic3r::SeamPlacerImpl::process_perimeter_polygon().

Here is the call graph for this function:

Here is the caller graph for this function:

flow() [2/2]

Flow Slic3r::LayerRegion::flow	(	FlowRole	role,
		double	layer_height ) const

{
    return m_region->flow(*m_layer->object(), role, layer_height, m_layer->id() == 0);
}

References Slic3r::layer_height(), m_layer, and m_region.

Here is the call graph for this function:

get_slices()

const SurfaceCollection & Slic3r::LayerRegion::get_slices ( ) const

inline

{ return slices; }

References slices.

has_extrusions()

bool Slic3r::LayerRegion::has_extrusions ( ) const

inline

{ return ! this->perimeters.entities.empty() || ! this->fills.entities.empty(); }

References Slic3r::ExtrusionEntityCollection::entities.

infill_area_threshold()

double Slic3r::LayerRegion::infill_area_threshold

(

)

const

{
    double ss = this->flow(frSolidInfill).scaled_spacing();
    return ss*ss;
}

References flow(), Slic3r::frSolidInfill, and infill_area_threshold().

Referenced by infill_area_threshold().

Here is the call graph for this function:

Here is the caller graph for this function:

layer() [1/2]

Layer * Slic3r::LayerRegion::layer ( )

inline

{ return m_layer; }

References Layer, and m_layer.

Referenced by LayerRegion(), bridging_flow(), Slic3r::contour_extrusion_path(), Slic3r::convert_layer_region_from_json(), Slic3r::Layer::generate_sparse_infill_polylines_for_anchoring(), Slic3r::group_fills(), Slic3r::Layer::make_fills(), make_perimeters(), prepare_fill_surfaces(), process_external_surfaces(), Slic3r::SeamPlacerImpl::process_perimeter_polygon(), Slic3r::SupportMaterialInternal::remove_bridges_from_contacts(), simplify_path(), and Slic3r::to_json().

Here is the call graph for this function:

Here is the caller graph for this function:

layer() [2/2]

const Layer * Slic3r::LayerRegion::layer ( ) const

inline

{ return m_layer; }

References Layer, and m_layer.

Here is the call graph for this function:

make_perimeters()

void Slic3r::LayerRegion::make_perimeters	(	const SurfaceCollection &	slices,
		const LayerRegionPtrs &	compatible_regions,
		SurfaceCollection *	fill_surfaces,
		ExPolygons *	fill_no_overlap )

{
    this->perimeters.clear();
    this->thin_fills.clear();
 
    const PrintConfig       &print_config  = this->layer()->object()->print()->config();
    const PrintRegionConfig &region_config = this->region().config();
    const PrintObjectConfig& object_config = this->layer()->object()->config();
    // This needs to be in sync with PrintObject::_slice() slicing_mode_normal_below_layer!
    bool spiral_mode = print_config.spiral_mode &&
        //FIXME account for raft layers.
        (this->layer()->id() >= size_t(region_config.bottom_shell_layers.value) &&
         this->layer()->print_z >= region_config.bottom_shell_thickness - EPSILON);
 
    double model_rotation_rad = 0.0;
    if (region_config.align_infill_direction_to_model) {
        auto m = this->layer()->object()->trafo().matrix();
        model_rotation_rad = std::atan2((double)m(1, 0), (double)m(0, 0));
    }
 
    PerimeterGenerator g(
        // input:
        &slices,
        &compatible_regions,
        this->layer()->height,
        this->layer()->slice_z,
        this->flow(frPerimeter),
        &region_config,
        &this->layer()->object()->config(),
        &print_config,
        spiral_mode,
        model_rotation_rad,
        
        // output:
        &this->perimeters,
        &this->thin_fills,
        fill_surfaces,
        //BBS
        fill_no_overlap
    );
    
    if (this->layer()->upper_layer != NULL)
        g.upper_slices = &this->layer()->upper_layer->lslices;
 
    int region_id = this->region().print_object_region_id();
    if (this->layer()->upper_layer != NULL)
        g.upper_slices_same_region = &this->layer()->upper_layer->get_region(region_id)->slices;
 
    g.layer_id              = (int)this->layer()->id();
    g.ext_perimeter_flow    = this->flow(frExternalPerimeter);
    g.overhang_flow         = this->bridging_flow(frPerimeter, object_config.thick_bridges);
    g.solid_infill_flow     = this->flow(frSolidInfill);
 
    // Cumulative sum of polygons over all the regions, less what the lower layer could not print.
    ExPolygons lower_slices;
    if (this->layer()->lower_layer != nullptr) {
        lower_slices   = g.printable_slices(this->layer()->lower_layer->lslices);
        g.lower_slices = &lower_slices;
    }
 
    if (this->layer()->object()->config().wall_generator.value == PerimeterGeneratorType::Arachne && !spiral_mode)
        g.process_arachne();
    else
        g.process_classic();
}

References Slic3r::Arachne, bridging_flow(), Slic3r::Print::config(), Slic3r::PrintObject::config(), Slic3r::PrintRegion::config(), EPSILON, Slic3r::PerimeterGenerator::ext_perimeter_flow, fill_surfaces, flow(), Slic3r::frExternalPerimeter, Slic3r::frPerimeter, Slic3r::frSolidInfill, Slic3r::Layer::get_region(), Slic3r::Layer::id(), layer(), Slic3r::PerimeterGenerator::layer_id, Slic3r::PerimeterGenerator::lower_slices, Slic3r::Layer::lslices, Slic3r::Layer::object(), Slic3r::PerimeterGenerator::overhang_flow, perimeters, Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnum, COUNT >::print(), Slic3r::PrintRegion::print_object_region_id(), Slic3r::Layer::print_z, Slic3r::PerimeterGenerator::printable_slices(), Slic3r::PrintObjectConfig, Slic3r::PrintRegionConfig, Slic3r::PerimeterGenerator::process_arachne(), Slic3r::PerimeterGenerator::process_classic(), region(), slices, Slic3r::PerimeterGenerator::solid_infill_flow, thin_fills, Slic3r::PrintObject::trafo(), Slic3r::Layer::upper_layer, Slic3r::PerimeterGenerator::upper_slices, and Slic3r::PerimeterGenerator::upper_slices_same_region.

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

Here is the call graph for this function:

Here is the caller graph for this function:

prepare_fill_surfaces()

void Slic3r::LayerRegion::prepare_fill_surfaces

(

)

{
#ifdef SLIC3R_DEBUG_SLICE_PROCESSING
    export_region_slices_to_svg_debug("2_prepare_fill_surfaces-initial");
    export_region_fill_surfaces_to_svg_debug("2_prepare_fill_surfaces-initial");
#endif /* SLIC3R_DEBUG_SLICE_PROCESSING */ 
 
    /*  Note: in order to make the psPrepareInfill step idempotent, we should never
        alter fill_surfaces boundaries on which our idempotency relies since that's
        the only meaningful information returned by psPerimeters. */
    
    bool spiral_mode = this->layer()->object()->print()->config().spiral_mode;
 
    // if no solid layers are requested, turn top/bottom surfaces to internal
    if (! spiral_mode && this->region().config().top_shell_layers == 0) {
        for (Surface &surface : this->fill_surfaces.surfaces)
            if (surface.is_top())
                //BBS
                //surface.surface_type = this->layer()->object()->config().infill_only_where_needed ? stInternalVoid : stInternal;
                surface.surface_type = PrintObject::infill_only_where_needed ? stInternalVoid : stInternal;
    }
    if (this->region().config().bottom_shell_layers == 0) {
        for (Surface &surface : this->fill_surfaces.surfaces)
            if (surface.is_bottom()) // (surface.surface_type == stBottom)
                surface.surface_type = stInternal;
    }
 
    if (!spiral_mode && fabs(this->region().config().sparse_infill_density.value - 100.) < EPSILON) {
        // Turn all internal sparse infill into solid infill, if sparse_infill_density is 100%
        for (Surface &surface : this->fill_surfaces.surfaces)
            if (surface.surface_type == stInternal)
                surface.surface_type = stInternalSolid;
    }
 
#ifdef SLIC3R_DEBUG_SLICE_PROCESSING
    export_region_slices_to_svg_debug("2_prepare_fill_surfaces-final");
    export_region_fill_surfaces_to_svg_debug("2_prepare_fill_surfaces-final");
#endif /* SLIC3R_DEBUG_SLICE_PROCESSING */
}

References Slic3r::bottom_shell_layers(), EPSILON, export_region_fill_surfaces_to_svg_debug(), export_region_slices_to_svg_debug(), fill_surfaces, Slic3r::PrintObject::infill_only_where_needed, Slic3r::Surface::is_bottom(), Slic3r::Surface::is_top(), layer(), prepare_fill_surfaces(), region(), Slic3r::sparse_infill_density(), Slic3r::stInternal, Slic3r::stInternalSolid, Slic3r::stInternalVoid, and Slic3r::Surface::surface_type.

Referenced by prepare_fill_surfaces().

Here is the call graph for this function:

Here is the caller graph for this function:

process_external_surfaces()

void Slic3r::LayerRegion::process_external_surfaces	(	const Layer *	lower_layer,
		const Polygons *	lower_layer_covered )

{
    using namespace Slic3r::Algorithm;
 
#ifdef SLIC3R_DEBUG_SLICE_PROCESSING
    export_region_fill_surfaces_to_svg_debug("4_process_external_surfaces-initial");
#endif /* SLIC3R_DEBUG_SLICE_PROCESSING */
 
    // Width of the perimeters.
    float shell_width = 0;
    float expansion_min = 0;
    if (int num_perimeters = this->region().config().wall_loops; num_perimeters > 0) {
        Flow external_perimeter_flow = this->flow(frExternalPerimeter);
        Flow perimeter_flow          = this->flow(frPerimeter);
        shell_width  = 0.5f * external_perimeter_flow.scaled_width() + external_perimeter_flow.scaled_spacing();
        shell_width += perimeter_flow.scaled_spacing() * (num_perimeters - 1);
        expansion_min = perimeter_flow.scaled_spacing();
    } else {
        // TODO: Maybe there is better solution when printing with zero perimeters, but this works reasonably well, given the situation
        shell_width   = float(SCALED_EPSILON);
        expansion_min = float(SCALED_EPSILON);;
    }
 
    // Scaled expansions of the respective external surfaces.
    float                           expansion_top           = shell_width * sqrt(2.);
    float                           expansion_bottom        = expansion_top;
    float                           expansion_bottom_bridge = expansion_top;
    // Expand by waves of expansion_step size (expansion_step is scaled), but with no more steps than max_nr_expansion_steps.
    const float                     expansion_step          = scaled<float>(0.1);
    // Don't take more than max_nr_steps for small expansion_step.
    static constexpr const size_t   max_nr_expansion_steps  = 5;
    // Radius (with added epsilon) to absorb empty regions emering from regularization of ensuring, viz  const float narrow_ensure_vertical_wall_thickness_region_radius = 0.5f * 0.65f * min_perimeter_infill_spacing;
    const float closing_radius = 0.55f * 0.65f * 1.05f * this->flow(frSolidInfill).scaled_spacing();
 
    // Expand the top / bottom / bridge surfaces into the shell thickness solid infills.
    double     layer_thickness;
    ExPolygons shells = union_ex(fill_surfaces_extract_expolygons(this->fill_surfaces.surfaces, { stInternalSolid }, layer_thickness));
    ExPolygons sparse = union_ex(fill_surfaces_extract_expolygons(this->fill_surfaces.surfaces, {stInternal}, layer_thickness));
    ExPolygons top_expolygons = union_ex(fill_surfaces_extract_expolygons(this->fill_surfaces.surfaces, {stTop}, layer_thickness));
    const auto expansion_params_into_sparse_infill = RegionExpansionParameters::build(expansion_min, expansion_step, max_nr_expansion_steps);
    const auto expansion_params_into_solid_infill  = RegionExpansionParameters::build(expansion_bottom_bridge, expansion_step, max_nr_expansion_steps);
 
    std::vector<ExpansionZone> expansion_zones{
        ExpansionZone{std::move(shells), expansion_params_into_solid_infill},
        ExpansionZone{std::move(sparse), expansion_params_into_sparse_infill},
        ExpansionZone{std::move(top_expolygons), expansion_params_into_solid_infill},
    };
 
    SurfaceCollection bridges;
    {
        BOOST_LOG_TRIVIAL(trace) << "Processing external surface, detecting bridges. layer" << this->layer()->print_z;
        // ORCA: Relative/Align Bridge Angle
        const auto  &region_config    = this->region().config();
        const double custom_angle_deg = region_config.bridge_angle.value;
        const bool   relative_angle   = region_config.relative_bridge_angle.value;
        const double custom_angle_rad = Geometry::deg2rad(custom_angle_deg);
 
        double align_offset_rad = 0.0;
        if (region_config.align_infill_direction_to_model) {
            auto m = this->layer()->object()->trafo().matrix();
            align_offset_rad = std::atan2((double)m(1, 0), (double)m(0, 0));
        }
 
        bridges.surfaces = (custom_angle_deg > 0.0 && !relative_angle) ?
            expand_merge_surfaces(this->fill_surfaces.surfaces, stBottomBridge, expansion_zones, closing_radius, custom_angle_rad + align_offset_rad) :
            expand_bridges_detect_orientations(this->fill_surfaces.surfaces, expansion_zones, closing_radius);
        if (custom_angle_deg > 0.0 && relative_angle) {
            for (Surface &bridge_surface : bridges.surfaces) {
                if (bridge_surface.bridge_angle >= 0)
                    bridge_surface.bridge_angle += custom_angle_rad;
            }
        }
        BOOST_LOG_TRIVIAL(trace) << "Processing external surface, detecting bridges - done";
#ifdef SLIC3R_DEBUG_SLICE_PROCESSING
        {
            static int iRun = 0;
            bridges.export_to_svg(debug_out_path("bridges-after-grouping-%d.svg", iRun++).c_str(), true);
        }
#endif
    }
 
    this->fill_surfaces.remove_types({stTop});
    {
        Surface top_templ(stTop, {});
        top_templ.thickness = layer_thickness;
        this->fill_surfaces.append(std::move(expansion_zones.back().expolygons), top_templ);
    }
 
    expansion_zones.pop_back();
 
    expansion_zones.at(0).parameters = RegionExpansionParameters::build(expansion_bottom, expansion_step, max_nr_expansion_steps);
    Surfaces bottoms = expand_merge_surfaces(this->fill_surfaces.surfaces, stBottom, expansion_zones, closing_radius);
 
    expansion_zones.at(0).parameters = RegionExpansionParameters::build(expansion_top, expansion_step, max_nr_expansion_steps);
    Surfaces tops = expand_merge_surfaces(this->fill_surfaces.surfaces, stTop, expansion_zones, closing_radius);
 
    // turn too small internal regions into solid regions according to the user setting
    if (!this->layer()->object()->print()->config().spiral_mode && this->region().config().sparse_infill_density.value > 0) {
        // scaling an area requires two calls!
        double min_area = scale_(scale_(this->region().config().minimum_sparse_infill_area.value));
        ExPolygons small_regions{};
        expansion_zones[1].expolygons.erase(std::remove_if(expansion_zones[1].expolygons.begin(), expansion_zones[1].expolygons.end(), [min_area, &small_regions](ExPolygon& ex_polygon) {
            if (ex_polygon.area() <= min_area) {
                small_regions.push_back(ex_polygon);
                return true;
            }
            return false;
        }), expansion_zones[1].expolygons.end());
 
        if (!small_regions.empty()) {
            expansion_zones[0].expolygons = union_ex(expansion_zones[0].expolygons, small_regions);
        }
    }
 
//    this->fill_surfaces.remove_types({ stBottomBridge, stBottom, stTop, stInternal, stInternalSolid });
    this->fill_surfaces.clear();
    unsigned zones_expolygons_count = 0;
    for (const ExpansionZone& zone : expansion_zones)
        zones_expolygons_count += zone.expolygons.size();
    reserve_more(this->fill_surfaces.surfaces, zones_expolygons_count + bridges.size() + bottoms.size() + tops.size());
    {
        Surface solid_templ(stInternalSolid, {});
        solid_templ.thickness = layer_thickness;
        this->fill_surfaces.append(std::move(expansion_zones[0].expolygons), solid_templ);
    }
    {
        Surface sparse_templ(stInternal, {});
        sparse_templ.thickness = layer_thickness;
        this->fill_surfaces.append(std::move(expansion_zones[1].expolygons), sparse_templ);
    }
    this->fill_surfaces.append(std::move(bridges.surfaces));
    this->fill_surfaces.append(std::move(bottoms));
    this->fill_surfaces.append(std::move(tops));
 
#ifdef SLIC3R_DEBUG_SLICE_PROCESSING
    export_region_fill_surfaces_to_svg_debug("4_process_external_surfaces-final");
#endif /* SLIC3R_DEBUG_SLICE_PROCESSING */
}

References Slic3r::Surface::bridge_angle, Slic3r::Algorithm::RegionExpansionParameters::build(), Slic3r::PrintRegion::config(), Slic3r::debug_out_path(), Slic3r::Geometry::deg2rad(), Slic3r::expand_bridges_detect_orientations(), Slic3r::expand_merge_surfaces(), export_region_fill_surfaces_to_svg_debug(), Slic3r::SurfaceCollection::export_to_svg(), fill_surfaces, Slic3r::fill_surfaces_extract_expolygons(), flow(), Slic3r::frExternalPerimeter, Slic3r::frPerimeter, Slic3r::frSolidInfill, Layer, layer(), Slic3r::Layer::object(), Slic3r::Layer::print_z, region(), scale_, Slic3r::scaled(), SCALED_EPSILON, Slic3r::Flow::scaled_spacing(), Slic3r::Flow::scaled_width(), Slic3r::sparse_infill_density(), Slic3r::stBottom, Slic3r::stBottomBridge, Slic3r::stTop, Slic3r::SurfaceCollection::surfaces, Slic3r::Surface::thickness, Slic3r::trace(), Slic3r::PrintObject::trafo(), and Slic3r::union_ex().

Here is the call graph for this function:

region()

const PrintRegion & Slic3r::LayerRegion::region ( ) const

inline

{ return *m_region; }

References m_region.

Referenced by LayerRegion(), bridging_flow(), Slic3r::PrintObject::clip_fill_surfaces(), Slic3r::contour_extrusion_path(), Slic3r::PrintObject::discover_horizontal_shells(), Slic3r::PrintObject::discover_vertical_shells(), Slic3r::Layer::generate_sparse_infill_polylines_for_anchoring(), Slic3r::group_fills(), Slic3r::Layer::make_fills(), Slic3r::Layer::make_perimeters(), make_perimeters(), prepare_fill_surfaces(), process_external_surfaces(), Slic3r::GCode::process_layer(), Slic3r::SupportMaterialInternal::remove_bridges_from_contacts(), and Slic3r::to_json().

Here is the caller graph for this function:

simplify_entity_collection()

void Slic3r::LayerRegion::simplify_entity_collection ( ExtrusionEntityCollection * entity_collection )

private

{
    for (size_t i = 0; i < entity_collection->entities.size(); i++) {
        if (ExtrusionEntityCollection* collection = dynamic_cast<ExtrusionEntityCollection*>(entity_collection->entities[i]))
            this->simplify_entity_collection(collection);
        else if (ExtrusionPath* path = dynamic_cast<ExtrusionPath*>(entity_collection->entities[i]))
            this->simplify_path(path);
        else if (ExtrusionMultiPath* multipath = dynamic_cast<ExtrusionMultiPath*>(entity_collection->entities[i]))
            this->simplify_multi_path(multipath);
        else if (ExtrusionLoop* loop = dynamic_cast<ExtrusionLoop*>(entity_collection->entities[i]))
            this->simplify_loop(loop);
        else
            throw Slic3r::InvalidArgument("Invalid extrusion entity supplied to simplify_entity_collection()");
    }
}

References Slic3r::ExtrusionEntityCollection::entities, simplify_entity_collection(), simplify_loop(), simplify_multi_path(), and simplify_path().

Referenced by simplify_entity_collection(), simplify_infill_extrusion_entity(), and simplify_wall_extrusion_entity().

Here is the call graph for this function:

Here is the caller graph for this function:

simplify_infill_extrusion_entity()

void Slic3r::LayerRegion::simplify_infill_extrusion_entity ( )

inline

{ simplify_entity_collection(&fills); }

References fills, and simplify_entity_collection().

Here is the call graph for this function:

simplify_loop()

void Slic3r::LayerRegion::simplify_loop ( ExtrusionLoop * loop )

private

{
    for (ExtrusionPath &path : loop->paths)
        this->simplify_path(&path);
}

References Slic3r::ExtrusionLoop::paths, simplify_loop(), and simplify_path().

Referenced by simplify_entity_collection(), and simplify_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

simplify_multi_path()

void Slic3r::LayerRegion::simplify_multi_path ( ExtrusionMultiPath * multipath )

private

{
    for (ExtrusionPath &path : multipath->paths)
        this->simplify_path(&path);
}

References Slic3r::ExtrusionMultiPath::paths, simplify_multi_path(), and simplify_path().

Referenced by simplify_entity_collection(), and simplify_multi_path().

Here is the call graph for this function:

Here is the caller graph for this function:

simplify_path()

void Slic3r::LayerRegion::simplify_path ( ExtrusionPath * path )

private

{
    const auto &print_config = this->layer()->object()->print()->config();
    const ArcFittingMode arc_fitting = print_config.enable_arc_fitting.value;
    const bool is_sparse_infill = path->role() == erInternalInfill;
    const auto scaled_resolution = scaled<double>(print_config.resolution.value);
 
    if (!print_config.spiral_mode &&
        (arc_fitting == ArcFittingMode::Enabled || (arc_fitting == ArcFittingMode::SparseInfill && is_sparse_infill))) {
        path->simplify_by_fitting_arc(is_sparse_infill ? SCALED_SPARSE_INFILL_RESOLUTION : scaled_resolution);
    } else {
        path->simplify(scaled_resolution);
    }
}

References Slic3r::Enabled, Slic3r::erInternalInfill, layer(), Slic3r::ExtrusionPath::role(), Slic3r::scaled(), SCALED_SPARSE_INFILL_RESOLUTION, Slic3r::ExtrusionPath::simplify(), Slic3r::ExtrusionPath::simplify_by_fitting_arc(), simplify_path(), and Slic3r::SparseInfill.

Referenced by simplify_entity_collection(), simplify_loop(), simplify_multi_path(), and simplify_path().

Here is the call graph for this function:

Here is the caller graph for this function:

simplify_wall_extrusion_entity()

void Slic3r::LayerRegion::simplify_wall_extrusion_entity ( )

inline

{ simplify_entity_collection(&perimeters); }

References perimeters, and simplify_entity_collection().

Here is the call graph for this function:

slices_to_fill_surfaces_clipped()

void Slic3r::LayerRegion::slices_to_fill_surfaces_clipped

(

)

{
    // Note: this method should be idempotent, but fill_surfaces gets modified 
    // in place. However we're now only using its boundaries (which are invariant)
    // so we're safe. This guarantees idempotence of prepare_infill() also in case
    // that combine_infill() turns some fill_surface into VOID surfaces.
    // Collect polygons per surface type.
    std::array<SurfacesPtr, size_t(stCount)> by_surface;
    for (Surface &surface : this->slices.surfaces)
        by_surface[size_t(surface.surface_type)].emplace_back(&surface);
    // Trim surfaces by the fill_boundaries.
    this->fill_surfaces.surfaces.clear();
    const Polygons fill_boundaries = to_polygons(this->fill_expolygons);
    for (size_t surface_type = 0; surface_type < size_t(stCount); ++ surface_type) {
        const SurfacesPtr &this_surfaces = by_surface[surface_type];
        if (! this_surfaces.empty())
            this->fill_surfaces.append(intersection_ex_by_piece(to_expolygons(this_surfaces), fill_boundaries), SurfaceType(surface_type));
    }
}

References fill_expolygons, fill_surfaces, Slic3r::intersection_ex_by_piece(), slices, Slic3r::stCount, Slic3r::Surface::surface_type, Slic3r::to_expolygons(), and Slic3r::to_polygons().

Here is the call graph for this function:

trim_surfaces()

void Slic3r::LayerRegion::trim_surfaces

(

const Polygons &

trimming_polygons

)

{
#ifndef NDEBUG
    for (const Surface &surface : this->slices.surfaces)
        assert(surface.surface_type == stInternal);
#endif /* NDEBUG */
  this->slices.set(intersection_ex(this->slices.surfaces, trimming_polygons), stInternal);
}

References Slic3r::intersection_ex(), slices, Slic3r::stInternal, Slic3r::Surface::surface_type, and trim_surfaces().

Referenced by trim_surfaces().

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Symbol Documentation

Layer

friend class Layer

friend

References Layer.

Referenced by LayerRegion(), Layer, layer(), layer(), and process_external_surfaces().

PrintObject

friend class PrintObject

friend

References PrintObject.

Referenced by bridging_flow(), and PrintObject.

Member Data Documentation

fill_expolygons

ExPolygons Slic3r::LayerRegion::fill_expolygons

Referenced by Slic3r::convert_layer_region_from_json(), Slic3r::PrintObject::discover_vertical_shells(), slices_to_fill_surfaces_clipped(), and Slic3r::to_json().

fill_no_overlap_expolygons

ExPolygons Slic3r::LayerRegion::fill_no_overlap_expolygons

Referenced by Slic3r::convert_layer_region_from_json(), Slic3r::group_fills(), and Slic3r::to_json().

fill_surfaces

SurfaceCollection Slic3r::LayerRegion::fill_surfaces

Referenced by Slic3r::PrintObject::clip_fill_surfaces(), Slic3r::convert_layer_region_from_json(), Slic3r::PrintObject::discover_horizontal_shells(), Slic3r::PrintObject::discover_vertical_shells(), export_region_fill_surfaces_to_svg(), export_region_slices_to_svg(), Slic3r::group_fills(), make_perimeters(), prepare_fill_surfaces(), process_external_surfaces(), Slic3r::SupportMaterialInternal::remove_bridges_from_contacts(), slices_to_fill_surfaces_clipped(), and Slic3r::to_json().

fills

ExtrusionEntityCollection Slic3r::LayerRegion::fills

Referenced by Slic3r::PrintObject::belt_drop_unclaimed_fills(), Slic3r::convert_layer_region_from_json(), Slic3r::GCode::process_layer(), simplify_infill_extrusion_entity(), and Slic3r::to_json().

m_layer

Layer* Slic3r::LayerRegion::m_layer

private

Referenced by LayerRegion(), flow(), flow(), layer(), and layer().

m_region

const PrintRegion* Slic3r::LayerRegion::m_region

private

Referenced by LayerRegion(), flow(), and region().

perimeters

ExtrusionEntityCollection Slic3r::LayerRegion::perimeters

Referenced by Slic3r::convert_layer_region_from_json(), make_perimeters(), Slic3r::GCode::process_layer(), Slic3r::SupportMaterialInternal::remove_bridges_from_contacts(), simplify_wall_extrusion_entity(), and Slic3r::to_json().

raw_slices

ExPolygons Slic3r::LayerRegion::raw_slices

Referenced by Slic3r::convert_layer_region_from_json(), and Slic3r::to_json().

slices

SurfaceCollection Slic3r::LayerRegion::slices

Referenced by Slic3r::convert_layer_region_from_json(), Slic3r::detect_contacts(), Slic3r::PrintObject::discover_horizontal_shells(), Slic3r::PrintObject::discover_vertical_shells(), elephant_foot_compensation_step(), export_region_slices_to_svg(), Slic3r::get_extents(), get_slices(), make_perimeters(), Slic3r::Layer::restore_untyped_slices_no_extra_perimeters(), slices_to_fill_surfaces_clipped(), Slic3r::to_json(), and trim_surfaces().

thin_fills

ExtrusionEntityCollection Slic3r::LayerRegion::thin_fills

Referenced by Slic3r::convert_layer_region_from_json(), make_perimeters(), and Slic3r::to_json().

unsupported_bridge_edges

Polylines Slic3r::LayerRegion::unsupported_bridge_edges

Referenced by Slic3r::convert_layer_region_from_json(), Slic3r::SupportMaterialInternal::remove_bridges_from_contacts(), and Slic3r::to_json().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Layer.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/LayerRegion.cpp