Slic3r::LayerRegion Class Reference

#include <src/libslic3r/Layer.hpp>

Collaboration diagram for Slic3r::LayerRegion:

Public Member Functions
Layer *	layer ()
const Layer *	layer () const
const PrintRegion &	region () const
const SurfaceCollection &	slices () const
const ExPolygons &	fill_expolygons () const
const BoundingBoxes &	fill_expolygons_bboxes () const
const ExPolygons &	fill_expolygons_composite () const
const BoundingBoxes &	fill_expolygons_composite_bboxes () const
const SurfaceCollection &	fill_surfaces () const
const ExtrusionEntityCollection &	thin_fills () const
const Polylines &	unsupported_bridge_edges () const
const ExtrusionEntityCollection &	perimeters () const
const ExtrusionEntityCollection &	fills () const
Flow	flow (FlowRole role) const
Flow	flow (FlowRole role, double layer_height) const
Flow	bridging_flow (FlowRole role, bool force_thick_bridges=false) const
void	slices_to_fill_surfaces_clipped ()
void	prepare_fill_surfaces ()
void	make_perimeters (const SurfaceCollection &slices, std::vector< std::pair< ExtrusionRange, ExtrusionRange > > &perimeter_and_gapfill_ranges, ExPolygons &fill_expolygons, std::vector< ExPolygonRange > &fill_expolygons_ranges)
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

Public Attributes
SurfaceCollection	m_slices

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

Private Attributes
Layer *	m_layer
const PrintRegion *	m_region
ExPolygons	m_raw_slices
ExPolygons	m_fill_expolygons
BoundingBoxes	m_fill_expolygons_bboxes
ExPolygons	m_fill_expolygons_composite
BoundingBoxes	m_fill_expolygons_composite_bboxes
SurfaceCollection	m_fill_surfaces
ExtrusionEntityCollection	m_thin_fills
Polylines	m_unsupported_bridge_edges
ExtrusionEntityCollection	m_perimeters
ExtrusionEntityCollection	m_fills

Friends
class	Layer
class	PrintObject
std::string	fix_slicing_errors (LayerPtrs &, const std::function< void()> &)
template<typename ThrowOnCancel >
void	apply_mm_segmentation (PrintObject &print_object, ThrowOnCancel throw_on_cancel)

Detailed Description

Constructor & Destructor Documentation

LayerRegion()

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

inlineprotected

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

~LayerRegion()

Slic3r::LayerRegion::~LayerRegion ( )

protecteddefault

Member Function Documentation

bridging_flow()

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

{
    const PrintRegion       &region         = this->region();
    const PrintRegionConfig &region_config  = region.config();
    const PrintObject       &print_object   = *this->layer()->object();
    if (print_object.config().thick_bridges || force_thick_bridges) {
        // 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.
        // Here this->extruder(role) - 1 may underflow to MAX_INT, but then the get_at() will follback to zero'th element, so everything is all right.
        auto nozzle_diameter = float(print_object.print()->config().nozzle_diameter.get_at(region.extruder(role) - 1));
        // Applies default bridge spacing.
        return Flow::bridging_flow(float(sqrt(region_config.bridge_flow_ratio)) * nozzle_diameter, nozzle_diameter);
    } else {
        // The same way as other slicers: Use normal extrusions. Apply bridge_flow_ratio while maintaining the original spacing.
        return this->flow(role).with_flow_ratio(region_config.bridge_flow_ratio);
    }
}

References Slic3r::Flow::bridging_flow(), Slic3r::PrintRegion::config(), Slic3r::PrintObject::config(), Slic3r::Print::config(), Slic3r::PrintRegion::extruder(), flow(), layer(), Slic3r::Layer::object(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::print(), Slic3r::PrintRegionConfig, region(), sqrt(), and Slic3r::Flow::with_flow_ratio().

Referenced by Slic3r::group_fills(), make_perimeters(), and Slic3r::FFFSupport::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())
        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)));
    m_slices.set(union_ex(tmp), stInternal);
}

References Slic3r::diff(), Slic3r::intersection(), Slic3r::opening(), Slic3r::stInternal, and Slic3r::union_ex().

Here is the call 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 (const Surface &surface : this->fill_surfaces())
        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()) {
        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::export_surface_type_legend_to_svg(), Slic3r::export_surface_type_legend_to_svg_box_size(), Slic3r::get_extents(), Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::merge(), Slic3r::BoundingBoxBase< PointType, APointsType >::min, scale_, and Slic3r::surface_type_to_color_name().

Here is the call 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().

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

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 (const Surface &surface : this->slices())
        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->slices())
        svg.draw(surface.expolygon, surface_type_to_color_name(surface.surface_type), transparency);
    for (const Surface &surface : this->fill_surfaces())
        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::export_surface_type_legend_to_svg(), Slic3r::export_surface_type_legend_to_svg_box_size(), Slic3r::get_extents(), Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::merge(), Slic3r::BoundingBoxBase< PointType, APointsType >::min, and Slic3r::surface_type_to_color_name().

Here is the call 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().

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

Here is the call graph for this function:

Here is the caller graph for this function:

fill_expolygons()

const ExPolygons & Slic3r::LayerRegion::fill_expolygons ( ) const

inline

{ return m_fill_expolygons; }

References m_fill_expolygons.

Referenced by Slic3r::PrintObject::discover_vertical_shells(), Slic3r::insert_fills_into_islands(), make_perimeters(), slices_to_fill_surfaces_clipped(), and Slic3r::Layer::sort_perimeters_into_islands().

Here is the caller graph for this function:

fill_expolygons_bboxes()

const BoundingBoxes & Slic3r::LayerRegion::fill_expolygons_bboxes ( ) const

inline

{ return m_fill_expolygons_bboxes; }

References m_fill_expolygons_bboxes.

Referenced by Slic3r::insert_fills_into_islands().

Here is the caller graph for this function:

fill_expolygons_composite()

const ExPolygons & Slic3r::LayerRegion::fill_expolygons_composite ( ) const

inline

{ return m_fill_expolygons_composite; }

References m_fill_expolygons_composite.

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

Here is the caller graph for this function:

fill_expolygons_composite_bboxes()

const BoundingBoxes & Slic3r::LayerRegion::fill_expolygons_composite_bboxes ( ) const

inline

{ return m_fill_expolygons_composite_bboxes; }

References m_fill_expolygons_composite_bboxes.

fill_surfaces()

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

inline

{ return m_fill_surfaces; }

References m_fill_surfaces.

Referenced by Slic3r::PrintObject::discover_vertical_shells(), Slic3r::group_fills(), and Slic3r::FFFSupport::remove_bridges_from_contacts().

Here is the caller graph for this function:

fills()

const ExtrusionEntityCollection & Slic3r::LayerRegion::fills ( ) const

inline

{ return m_fills; }

References m_fills.

Referenced by Slic3r::DoExport::autospeed_volumetric_limit(), Slic3r::SupportSpotsGenerator::build_object_part_from_slice(), Slic3r::SupportSpotsGenerator::check_stability(), has_extrusions(), Slic3r::insert_fills_into_islands(), Slic3r::Layer::make_fills(), and Slic3r::GCode::process_layer_single_object().

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(), Slic3r::Layer::height, and m_layer.

Referenced by bridging_flow(), Slic3r::detect_overhangs(), Slic3r::PrintObject::detect_surfaces_type(), Slic3r::PrintObject::discover_vertical_shells(), flow(), Slic3r::SupportSpotsGenerator::get_flow_width(), Slic3r::group_fills(), make_perimeters(), 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::PrintRegion::flow(), Slic3r::Layer::id(), Slic3r::layer_height(), m_layer, m_region, and Slic3r::Layer::object().

Here is the call graph for this function:

has_extrusions()

bool Slic3r::LayerRegion::has_extrusions ( ) const

inline

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

References Slic3r::ExtrusionEntityCollection::empty(), fills(), and perimeters().

Here is the call graph for this function:

infill_area_threshold()

double Slic3r::LayerRegion::infill_area_threshold

(

)

const

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

References Slic3r::frSolidInfill.

layer() [1/2]

Layer * Slic3r::LayerRegion::layer ( )

inline

{ return m_layer; }

References m_layer.

Referenced by bridging_flow(), Slic3r::SupportSpotsGenerator::check_extrusion_entity_stability(), Slic3r::Layer::generate_sparse_infill_polylines_for_anchoring(), Slic3r::Layer::make_fills(), and make_perimeters().

Here is the caller graph for this function:

layer() [2/2]

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

inline

{ return m_layer; }

References m_layer.

make_perimeters()

void Slic3r::LayerRegion::make_perimeters	(	const SurfaceCollection &	slices,
		std::vector< std::pair< ExtrusionRange, ExtrusionRange > > &	perimeter_and_gapfill_ranges,
		ExPolygons &	fill_expolygons,
		std::vector< ExPolygonRange > &	fill_expolygons_ranges
	)

{
    m_perimeters.clear();
    m_thin_fills.clear();
 
    perimeter_and_gapfill_ranges.reserve(perimeter_and_gapfill_ranges.size() + slices.size());
    // There may be more expolygons produced per slice, thus this reserve is conservative.
    fill_expolygons.reserve(fill_expolygons.size() + slices.size());
    fill_expolygons_ranges.reserve(fill_expolygons_ranges.size() + slices.size());
 
    const PrintConfig       &print_config  = this->layer()->object()->print()->config();
    const PrintRegionConfig &region_config = this->region().config();
    // This needs to be in sync with PrintObject::_slice() slicing_mode_normal_below_layer!
    bool spiral_vase = print_config.spiral_vase &&
        //FIXME account for raft layers.
        (this->layer()->id() >= size_t(region_config.bottom_solid_layers.value) &&
         this->layer()->print_z >= region_config.bottom_solid_min_thickness - EPSILON);
 
    PerimeterGenerator::Parameters params(
        this->layer()->height,
        int(this->layer()->id()),
        this->flow(frPerimeter),
        this->flow(frExternalPerimeter),
        this->bridging_flow(frPerimeter),
        this->flow(frSolidInfill),
        region_config,
        this->layer()->object()->config(),
        print_config,
        spiral_vase
    );
 
    // Cummulative sum of polygons over all the regions.
    const ExPolygons *lower_slices = this->layer()->lower_layer ? &this->layer()->lower_layer->lslices : nullptr;
    // Cache for offsetted lower_slices
    Polygons          lower_layer_polygons_cache;
 
    for (const Surface &surface : slices) {
        auto perimeters_begin      = uint32_t(m_perimeters.size());
        auto gap_fills_begin       = uint32_t(m_thin_fills.size());
        auto fill_expolygons_begin = uint32_t(fill_expolygons.size());
        if (this->layer()->object()->config().perimeter_generator.value == PerimeterGeneratorType::Arachne && !spiral_vase)
            PerimeterGenerator::process_arachne(
                // input:
                params,
                surface,
                lower_slices,
                lower_layer_polygons_cache,
                // output:
                m_perimeters,
                m_thin_fills,
                fill_expolygons);
        else
            PerimeterGenerator::process_classic(
                // input:
                params,
                surface,
                lower_slices,
                lower_layer_polygons_cache,
                // output:
                m_perimeters,
                m_thin_fills,
                fill_expolygons);
        perimeter_and_gapfill_ranges.emplace_back(
            ExtrusionRange{ perimeters_begin, uint32_t(m_perimeters.size()) }, 
            ExtrusionRange{ gap_fills_begin,  uint32_t(m_thin_fills.size()) });
        fill_expolygons_ranges.emplace_back(ExtrusionRange{ fill_expolygons_begin, uint32_t(fill_expolygons.size()) });
    }
}

References Slic3r::Arachne, bridging_flow(), Slic3r::ExtrusionEntityCollection::clear(), Slic3r::PrintRegion::config(), Slic3r::Print::config(), EPSILON, fill_expolygons(), flow(), Slic3r::frExternalPerimeter, Slic3r::frPerimeter, Slic3r::frSolidInfill, Slic3r::Layer::id(), layer(), Slic3r::Layer::lower_layer, Slic3r::Layer::lslices, m_perimeters, m_thin_fills, Slic3r::Layer::object(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnumType, COUNT >::print(), Slic3r::Layer::print_z, Slic3r::PrintRegionConfig, Slic3r::PerimeterGenerator::process_arachne(), Slic3r::PerimeterGenerator::process_classic(), region(), Slic3r::ExtrusionEntityCollection::size(), Slic3r::SurfaceCollection::size(), and slices().

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

Here is the call graph for this function:

Here is the caller graph for this function:

perimeters()

const ExtrusionEntityCollection & Slic3r::LayerRegion::perimeters ( ) const

inline

{ return m_perimeters; }

References m_perimeters.

Referenced by Slic3r::DoExport::autospeed_volumetric_limit(), Slic3r::SupportSpotsGenerator::build_object_part_from_slice(), Slic3r::SupportSpotsGenerator::check_stability(), has_extrusions(), Slic3r::GCode::process_layer_single_object(), Slic3r::FFFSupport::remove_bridges_from_contacts(), and Slic3r::Layer::sort_perimeters_into_islands().

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_vase = this->layer()->object()->print()->config().spiral_vase;
 
    // if no solid layers are requested, turn top/bottom surfaces to internal
    // For Lightning infill, infill_only_where_needed is ignored because both
    // do a similar thing, and their combination doesn't make much sense.
    if (! spiral_vase && this->region().config().top_solid_layers == 0) {
        for (Surface &surface : m_fill_surfaces)
            if (surface.is_top())
                surface.surface_type = /*this->layer()->object()->config().infill_only_where_needed && this->region().config().fill_pattern != ipLightning ? stInternalVoid :*/ stInternal;
    }
    if (this->region().config().bottom_solid_layers == 0) {
        for (Surface &surface : m_fill_surfaces)
            if (surface.is_bottom()) // (surface.surface_type == stBottom)
                surface.surface_type = stInternal;
    }
 
    // turn too small internal regions into solid regions according to the user setting
    if (! spiral_vase && this->region().config().fill_density.value > 0) {
        // scaling an area requires two calls!
        double min_area = scale_(scale_(this->region().config().solid_infill_below_area.value));
        for (Surface &surface : m_fill_surfaces)
            if (surface.surface_type == stInternal && surface.area() <= min_area)
                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::fill_density(), scale_, Slic3r::stInternal, Slic3r::stInternalSolid, and Slic3r::top_solid_layers().

Here is the call 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().perimeters; 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.
    static constexpr 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(m_fill_surfaces.surfaces, { stInternalSolid }, layer_thickness));
    ExPolygons sparse = union_ex(fill_surfaces_extract_expolygons(m_fill_surfaces.surfaces, { stInternal }, layer_thickness));
 
    SurfaceCollection bridges;
    const auto expansion_params_into_sparse_infill = RegionExpansionParameters::build(expansion_min, expansion_step, max_nr_expansion_steps);
    {
        BOOST_LOG_TRIVIAL(trace) << "Processing external surface, detecting bridges. layer" << this->layer()->print_z;
        const double custom_angle = this->region().config().bridge_angle.value;
        const auto   expansion_params_into_solid_infill  = RegionExpansionParameters::build(expansion_bottom_bridge, expansion_step, max_nr_expansion_steps);
        bridges.surfaces = custom_angle > 0 ?
            expand_merge_surfaces(m_fill_surfaces.surfaces, stBottomBridge, shells, expansion_params_into_solid_infill, sparse, expansion_params_into_sparse_infill, closing_radius, Geometry::deg2rad(custom_angle)) :
            expand_bridges_detect_orientations(m_fill_surfaces.surfaces, shells, expansion_params_into_solid_infill, sparse, expansion_params_into_sparse_infill, closing_radius);
        BOOST_LOG_TRIVIAL(trace) << "Processing external surface, detecting bridges - done";
#if 0
        {
            static int iRun = 0;
            bridges.export_to_svg(debug_out_path("bridges-after-grouping-%d.svg", iRun++), true);
        }
#endif
    }
 
    Surfaces    bottoms = expand_merge_surfaces(m_fill_surfaces.surfaces, stBottom, shells,
        RegionExpansionParameters::build(expansion_bottom, expansion_step, max_nr_expansion_steps), 
        sparse, expansion_params_into_sparse_infill, closing_radius);
    Surfaces    tops    = expand_merge_surfaces(m_fill_surfaces.surfaces, stTop, shells,
        RegionExpansionParameters::build(expansion_top, expansion_step, max_nr_expansion_steps), 
        sparse, expansion_params_into_sparse_infill, closing_radius);
 
//    m_fill_surfaces.remove_types({ stBottomBridge, stBottom, stTop, stInternal, stInternalSolid });
    m_fill_surfaces.clear();
    reserve_more(m_fill_surfaces.surfaces, shells.size() + sparse.size() + bridges.size() + bottoms.size() + tops.size());
    {
        Surface solid_templ(stInternalSolid, {});
        solid_templ.thickness = layer_thickness;
        m_fill_surfaces.append(std::move(shells), solid_templ);
    }
    {
        Surface sparse_templ(stInternal, {});
        sparse_templ.thickness = layer_thickness;
        m_fill_surfaces.append(std::move(sparse), sparse_templ);
    }
    m_fill_surfaces.append(std::move(bridges.surfaces));
    m_fill_surfaces.append(std::move(bottoms));
    m_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::debug_out_path(), Slic3r::expand_bridges_detect_orientations(), Slic3r::expand_merge_surfaces(), Slic3r::SurfaceCollection::export_to_svg(), Slic3r::fill_surfaces_extract_expolygons(), Slic3r::frExternalPerimeter, Slic3r::frPerimeter, Slic3r::frSolidInfill, Slic3r::reserve_more(), SCALED_EPSILON, Slic3r::Flow::scaled_spacing(), Slic3r::Flow::scaled_width(), Slic3r::SurfaceCollection::size(), sqrt(), Slic3r::stBottom, Slic3r::stBottomBridge, Slic3r::stInternal, Slic3r::stInternalSolid, Slic3r::stTop, Slic3r::SurfaceCollection::surfaces, Slic3r::Surface::thickness, 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 bridging_flow(), Slic3r::PrintObject::discover_horizontal_shells(), Slic3r::PrintObject::discover_vertical_shells(), Slic3r::group_fills(), Slic3r::Layer::make_perimeters(), make_perimeters(), Slic3r::GCode::process_layer_single_object(), Slic3r::FFFSupport::remove_bridges_from_contacts(), and Slic3r::Layer::sort_perimeters_into_islands().

Here is the caller graph for this function:

slices()

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

inline

{ return m_slices; }

References m_slices.

Referenced by Slic3r::detect_overhangs(), Slic3r::PrintObject::detect_surfaces_type(), Slic3r::PrintObject::discover_vertical_shells(), Slic3r::get_extents(), Slic3r::Layer::make_ironing(), Slic3r::Layer::make_perimeters(), make_perimeters(), slices_to_fill_surfaces_clipped(), and Slic3r::Layer::sort_perimeters_into_islands().

Here is the caller graph for this function:

slices_to_fill_surfaces_clipped()

void Slic3r::LayerRegion::slices_to_fill_surfaces_clipped

(

)

{
    // Collect polygons per surface type.
    std::array<std::vector<const Surface*>, size_t(stCount)> by_surface;
    for (const Surface &surface : this->slices())
        by_surface[size_t(surface.surface_type)].emplace_back(&surface);
    // Trim surfaces by the fill_boundaries.
    m_fill_surfaces.surfaces.clear();
    for (size_t surface_type = 0; surface_type < size_t(stCount); ++ surface_type) {
        const std::vector<const Surface*> &this_surfaces = by_surface[surface_type];
        if (! this_surfaces.empty())
            m_fill_surfaces.append(intersection_ex(this_surfaces, this->fill_expolygons()), SurfaceType(surface_type));
    }
}

References Slic3r::SurfaceCollection::append(), fill_expolygons(), Slic3r::intersection_ex(), m_fill_surfaces, slices(), Slic3r::stCount, and Slic3r::SurfaceCollection::surfaces.

Here is the call graph for this function:

thin_fills()

const ExtrusionEntityCollection & Slic3r::LayerRegion::thin_fills ( ) const

inline

{ return m_thin_fills; }

References m_thin_fills.

Referenced by Slic3r::SupportSpotsGenerator::build_object_part_from_slice(), Slic3r::Layer::make_fills(), and Slic3r::Layer::sort_perimeters_into_islands().

Here is the caller graph for this function:

trim_surfaces()

void Slic3r::LayerRegion::trim_surfaces

(

const Polygons &

trimming_polygons

)

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

References Slic3r::intersection_ex(), and Slic3r::stInternal.

Here is the call graph for this function:

unsupported_bridge_edges()

const Polylines & Slic3r::LayerRegion::unsupported_bridge_edges ( ) const

inline

{ return m_unsupported_bridge_edges; }

References m_unsupported_bridge_edges.

Referenced by Slic3r::FFFSupport::remove_bridges_from_contacts().

Here is the caller graph for this function:

Friends And Related Symbol Documentation

apply_mm_segmentation

template<typename ThrowOnCancel >

void apply_mm_segmentation ( PrintObject &  print_object, ThrowOnCancel  throw_on_cancel  )

friend

{
    // Returns MMU segmentation based on painting in MMU segmentation gizmo
    std::vector<std::vector<ExPolygons>> segmentation = multi_material_segmentation_by_painting(print_object, throw_on_cancel);
    assert(segmentation.size() == print_object.layer_count());
    tbb::parallel_for(
        tbb::blocked_range<size_t>(0, segmentation.size(), std::max(segmentation.size() / 128, size_t(1))),
        [&print_object, &segmentation, throw_on_cancel](const tbb::blocked_range<size_t> &range) {
            const auto  &layer_ranges   = print_object.shared_regions()->layer_ranges;
            double       z              = print_object.get_layer(range.begin())->slice_z;
            auto         it_layer_range = layer_range_first(layer_ranges, z);
            const size_t num_extruders = print_object.print()->config().nozzle_diameter.size();
            struct ByExtruder {
                ExPolygons  expolygons;
                BoundingBox bbox;
            };
            std::vector<ByExtruder> by_extruder;
            struct ByRegion {
                ExPolygons  expolygons;
                bool        needs_merge { false };
            };
            std::vector<ByRegion> by_region;
            for (size_t layer_id = range.begin(); layer_id < range.end(); ++ layer_id) {
                throw_on_cancel();
                Layer *layer = print_object.get_layer(layer_id);
                it_layer_range = layer_range_next(layer_ranges, it_layer_range, layer->slice_z);
                const PrintObjectRegions::LayerRangeRegions &layer_range = *it_layer_range;
                // Gather per extruder expolygons.
                by_extruder.assign(num_extruders, ByExtruder());
                by_region.assign(layer->region_count(), ByRegion());
                bool layer_split = false;
                for (size_t extruder_id = 0; extruder_id < num_extruders; ++ extruder_id) {
                    ByExtruder &region = by_extruder[extruder_id];
                    append(region.expolygons, std::move(segmentation[layer_id][extruder_id]));
                    if (! region.expolygons.empty()) {
                        region.bbox = get_extents(region.expolygons);
                        layer_split = true;
                    }
                }
                if (! layer_split)
                    continue;
                // Split LayerRegions by by_extruder regions.
                // layer_range.painted_regions are sorted by extruder ID and parent PrintObject region ID.
                auto it_painted_region = layer_range.painted_regions.begin();
                for (int region_id = 0; region_id < int(layer->region_count()); ++ region_id)
                    if (LayerRegion &layerm = *layer->get_region(region_id); ! layerm.slices().empty()) {
                        assert(layerm.region().print_object_region_id() == region_id);
                        const BoundingBox bbox = get_extents(layerm.slices().surfaces);
                        assert(it_painted_region < layer_range.painted_regions.end());
                        // Find the first it_painted_region which overrides this region.
                        for (; layer_range.volume_regions[it_painted_region->parent].region->print_object_region_id() < region_id; ++ it_painted_region)
                            assert(it_painted_region != layer_range.painted_regions.end());
                        assert(it_painted_region != layer_range.painted_regions.end());
                        assert(layer_range.volume_regions[it_painted_region->parent].region == &layerm.region());
                        // 1-based extruder ID
                        bool   self_trimmed = false;
                        int    self_extruder_id = -1;
                        for (int extruder_id = 1; extruder_id <= int(by_extruder.size()); ++ extruder_id)
                            if (ByExtruder &segmented = by_extruder[extruder_id - 1]; segmented.bbox.defined && bbox.overlap(segmented.bbox)) {
                                // Find the target region.
                                for (; int(it_painted_region->extruder_id) < extruder_id; ++ it_painted_region)
                                    assert(it_painted_region != layer_range.painted_regions.end());
                                assert(layer_range.volume_regions[it_painted_region->parent].region == &layerm.region() && int(it_painted_region->extruder_id) == extruder_id);
                                //FIXME Don't trim by self, it is not reliable.
                                if (&layerm.region() == it_painted_region->region) {
                                    self_extruder_id = extruder_id;
                                    continue;
                                }
                                // Steal from this region.
                                int         target_region_id = it_painted_region->region->print_object_region_id();
                                ExPolygons  stolen           = intersection_ex(layerm.slices().surfaces, segmented.expolygons);
                                if (! stolen.empty()) {
                                    ByRegion &dst = by_region[target_region_id];
                                    if (dst.expolygons.empty()) {
                                        dst.expolygons = std::move(stolen);
                                    } else {
                                        append(dst.expolygons, std::move(stolen));
                                        dst.needs_merge = true;
                                    }
                                }
#if 0
                                if (&layerm.region() == it_painted_region->region)
                                    // Slices of this LayerRegion were trimmed by a MMU region of the same PrintRegion.
                                    self_trimmed = true;
#endif
                            }
                        if (! self_trimmed) {
                            // Trim slices of this LayerRegion with all the MMU regions.
                            Polygons mine = to_polygons(std::move(layerm.slices().surfaces));
                            for (auto &segmented : by_extruder)
                                if (&segmented - by_extruder.data() + 1 != self_extruder_id && segmented.bbox.defined && bbox.overlap(segmented.bbox)) {
                                    mine = diff(mine, segmented.expolygons);
                                    if (mine.empty())
                                        break;
                                }
                            // Filter out unprintable polygons produced by subtraction multi-material painted regions from layerm.region().
                            // ExPolygon returned from multi-material segmentation does not precisely match ExPolygons in layerm.region()
                            // (because of preprocessing of the input regions in multi-material segmentation). Therefore, subtraction from
                            // layerm.region() could produce a huge number of small unprintable regions for the model's base extruder.
                            // This could, on some models, produce bulges with the model's base color (#7109).
                            if (! mine.empty())
                                mine = opening(union_ex(mine), float(scale_(5 * EPSILON)), float(scale_(5 * EPSILON)));
                            if (! mine.empty()) {
                                ByRegion &dst = by_region[layerm.region().print_object_region_id()];
                                if (dst.expolygons.empty()) {
                                    dst.expolygons = union_ex(mine);
                                } else {
                                    append(dst.expolygons, union_ex(mine));
                                    dst.needs_merge = true;
                                }
                            }
                        }
                    }
                // Re-create Surfaces of LayerRegions.
                for (size_t region_id = 0; region_id < layer->region_count(); ++ region_id) {
                    ByRegion &src = by_region[region_id];
                    if (src.needs_merge)
                        // Multiple regions were merged into one.
                        src.expolygons = closing_ex(src.expolygons, float(scale_(10 * EPSILON)));
                    layer->get_region(region_id)->m_slices.set(std::move(src.expolygons), stInternal);
                }
            }
        });
}

fix_slicing_errors

std::string fix_slicing_errors ( LayerPtrs &  , const std::function< void()> &    )

friend

Layer

friend class Layer

friend

PrintObject

friend class PrintObject

friend

Member Data Documentation

m_fill_expolygons

ExPolygons Slic3r::LayerRegion::m_fill_expolygons

private

Referenced by fill_expolygons(), and Slic3r::Layer::sort_perimeters_into_islands().

m_fill_expolygons_bboxes

BoundingBoxes Slic3r::LayerRegion::m_fill_expolygons_bboxes

private

Referenced by fill_expolygons_bboxes(), and Slic3r::Layer::sort_perimeters_into_islands().

m_fill_expolygons_composite

ExPolygons Slic3r::LayerRegion::m_fill_expolygons_composite

private

Referenced by fill_expolygons_composite(), and Slic3r::Layer::sort_perimeters_into_islands().

m_fill_expolygons_composite_bboxes

BoundingBoxes Slic3r::LayerRegion::m_fill_expolygons_composite_bboxes

private

Referenced by fill_expolygons_composite_bboxes(), and Slic3r::Layer::sort_perimeters_into_islands().

m_fill_surfaces

SurfaceCollection Slic3r::LayerRegion::m_fill_surfaces

private

Referenced by Slic3r::PrintObject::discover_horizontal_shells(), Slic3r::PrintObject::discover_vertical_shells(), fill_surfaces(), and slices_to_fill_surfaces_clipped().

m_fills

ExtrusionEntityCollection Slic3r::LayerRegion::m_fills

private

Referenced by fills(), and Slic3r::Layer::make_fills().

m_layer

Layer* Slic3r::LayerRegion::m_layer

private

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

m_perimeters

ExtrusionEntityCollection Slic3r::LayerRegion::m_perimeters

private

Referenced by make_perimeters(), and perimeters().

m_raw_slices

ExPolygons Slic3r::LayerRegion::m_raw_slices

private

m_region

const PrintRegion* Slic3r::LayerRegion::m_region

private

Referenced by flow(), and region().

m_slices

SurfaceCollection Slic3r::LayerRegion::m_slices

Referenced by Slic3r::PrintObject::detect_surfaces_type(), Slic3r::Layer::restore_untyped_slices_no_extra_perimeters(), and slices().

m_thin_fills

ExtrusionEntityCollection Slic3r::LayerRegion::m_thin_fills

private

Referenced by make_perimeters(), and thin_fills().

m_unsupported_bridge_edges

Polylines Slic3r::LayerRegion::m_unsupported_bridge_edges

private

Referenced by unsupported_bridge_edges().

---

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

• src/libslic3r/Layer.hpp
• src/libslic3r/LayerRegion.cpp