Slic3r::Layer Class Reference

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

Inheritance diagram for Slic3r::Layer:

Collaboration diagram for Slic3r::Layer:

Public Member Functions
size_t	id () const
void	set_id (size_t id)
PrintObject *	object ()
const PrintObject *	object () const
coordf_t	bottom_z () const
size_t	region_count () const
const LayerRegion *	get_region (int idx) const
LayerRegion *	get_region (int idx)
LayerRegion *	add_region (const PrintRegion *print_region)
const LayerRegionPtrs &	regions () const
bool	empty () const
void	make_slices ()
void	backup_untyped_slices ()
void	restore_untyped_slices ()
void	restore_untyped_slices_no_extra_perimeters ()
ExPolygons	merged (float offset) const
template<class T>
bool	any_internal_region_slice_contains (const T &item) const
template<class T>
bool	any_bottom_region_slice_contains (const T &item) const
void	make_perimeters ()
void	make_fills ()
void	make_fills (const FillAdaptive::RegionOctrees *fill_octrees, FillLightning::Generator *lightning_generator=nullptr)
Polylines	generate_sparse_infill_polylines_for_anchoring (const FillAdaptive::RegionOctrees *fill_octrees, FillLightning::Generator *lightning_generator) const
void	make_ironing ()
void	make_contour_z (const sla::IndexedMesh &mesh)
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
virtual bool	has_extrusions () const
void	simplify_wall_extrusion_path ()
void	simplify_infill_extrusion_path ()
coordf_t	get_sparse_infill_max_void_area ()
size_t	get_extruder_id (unsigned int filament_id) const

Static Public Member Functions
static bool	is_perimeter_compatible (const Print &print, const PrintRegion &a, const PrintRegion &b)
static int	choose_ironing_extruder (const PrintRegionConfig &cfg, bool spiral_mode, bool is_topmost_layer)
template<typename IteratorType, typename IndexType, typename FN_HIGHER_EQUAL>
static IndexType	idx_higher_or_equal (IteratorType begin, IteratorType end, IndexType idx, FN_HIGHER_EQUAL fn_higher_equal)

Public Attributes
Layer *	upper_layer
Layer *	lower_layer
bool	slicing_errors
coordf_t	slice_z
coordf_t	print_z
coordf_t	height
CurledLines	curled_lines
ExPolygons	sharp_tails
ExPolygons	cantilevers
std::vector< float >	sharp_tails_height
ExPolygons	lslices
ExPolygons	lslices_extrudable
std::vector< BoundingBox >	lslices_bboxes
std::vector< size_t >	lslices_separated_component_ids
ExPolygons	loverhangs
BoundingBox	loverhangs_bbox

Protected Member Functions
	Layer (size_t id, PrintObject *object, coordf_t height, coordf_t print_z, coordf_t slice_z)
virtual	~Layer ()
void	simplify_support_entity_collection (ExtrusionEntityCollection *entity_collection)
void	simplify_support_path (ExtrusionPath *path)
void	simplify_support_multi_path (ExtrusionMultiPath *multipath)
void	simplify_support_loop (ExtrusionLoop *loop)

Private Attributes
size_t	m_id
PrintObject *	m_object
LayerRegionPtrs	m_regions

Friends
class	PrintObject
std::vector< Layer * >	new_layers (PrintObject *print_object, const std::vector< coordf_t > &object_layers)
std::string	fix_slicing_errors (PrintObject *object, LayerPtrs &, const std::function< void()> &, int &)

Detailed Description

Constructor & Destructor Documentation

Layer()

Slic3r::Layer::Layer ( size_t id, PrintObject * object, coordf_t height, coordf_t print_z, coordf_t slice_z )

inlineprotected

                                                                                               :
        upper_layer(nullptr), lower_layer(nullptr), slicing_errors(false),
        slice_z(slice_z), print_z(print_z), height(height),
        m_id(id), m_object(object) {}

References height, id(), lower_layer, m_id, m_object, object(), print_z, PrintObject, slice_z, slicing_errors, and upper_layer.

Referenced by Slic3r::SupportLayer::SupportLayer(), and new_layers.

Here is the call graph for this function:

Here is the caller graph for this function:

~Layer()

Slic3r::Layer::~Layer ( )

protectedvirtual

{
    this->lower_layer = this->upper_layer = nullptr;
    for (LayerRegion *region : m_regions)
        delete region;
    m_regions.clear();
}

References lower_layer, m_regions, and upper_layer.

Member Function Documentation

add_region()

LayerRegion * Slic3r::Layer::add_region

(

const PrintRegion *

print_region

)

{
    m_regions.emplace_back(new LayerRegion(this, print_region));
    return m_regions.back();
}

References m_regions.

any_bottom_region_slice_contains()

template<class T>

bool Slic3r::Layer::any_bottom_region_slice_contains ( const T & item ) const

inline

                                                                                  {
        for (const LayerRegion *layerm : m_regions) if (layerm->slices.any_bottom_contains(item)) return true;
        return false;
    }

References m_regions.

any_internal_region_slice_contains()

template<class T>

bool Slic3r::Layer::any_internal_region_slice_contains ( const T & item ) const

inline

                                                                                    {
        for (const LayerRegion *layerm : m_regions) if (layerm->slices.any_internal_contains(item)) return true;
        return false;
    }

References m_regions.

backup_untyped_slices()

void Slic3r::Layer::backup_untyped_slices

(

)

{
    if (layer_needs_raw_backup(this)) {
        for (LayerRegion *layerm : m_regions)
            layerm->raw_slices = to_expolygons(layerm->slices.surfaces);
    } else {
        assert(m_regions.size() == 1);
        m_regions.front()->raw_slices.clear();
    }
}

References Slic3r::layer_needs_raw_backup(), m_regions, and Slic3r::to_expolygons().

Here is the call graph for this function:

bottom_z()

coordf_t Slic3r::Layer::bottom_z ( ) const

inline

{ return this->print_z - this->height; }

Referenced by Slic3r::PrintObject::discover_horizontal_shells(), Slic3r::PrintObject::discover_vertical_shells(), Slic3r::TreeSupport::get_trim_support_regions(), Slic3r::getExtrusionPathsFromSupportLayer(), Slic3r::new_contact_layer(), and Slic3r::PrintObjectSupportMaterial::trim_support_layers_by_object().

Here is the caller graph for this function:

choose_ironing_extruder()

int Slic3r::Layer::choose_ironing_extruder ( const PrintRegionConfig & cfg, bool spiral_mode, bool is_topmost_layer )

static

{
    if (cfg.ironing_type == IroningType::NoIroning)
        return -1;
    const bool gate = (cfg.ironing_type == IroningType::AllSolid)
        || ((cfg.top_shell_layers > 0 || (spiral_mode && cfg.bottom_shell_layers > 1))
            && (cfg.ironing_type == IroningType::TopSurfaces
                || (cfg.ironing_type == IroningType::TopmostOnly && is_topmost_layer)));
    if (!gate)
        return -1;
    return cfg.top_surface_filament_id;
}

References Slic3r::AllSolid, choose_ironing_extruder(), Slic3r::NoIroning, Slic3r::PrintRegionConfig, Slic3r::TopmostOnly, and Slic3r::TopSurfaces.

Referenced by choose_ironing_extruder(), and make_ironing().

Here is the call graph for this function:

Here is the caller graph for this function:

empty()

bool Slic3r::Layer::empty

(

)

const

{
  for (const LayerRegion *layerm : m_regions)
        if (layerm != nullptr && ! layerm->slices.empty())
            // Non empty layer.
            return false;
    return true;
}

References m_regions.

Referenced by Slic3r::PrintObject::apply_conical_overhang(), and Slic3r::PrintObject::slice_volumes().

Here is the caller graph for this function:

export_region_fill_surfaces_to_svg()

void Slic3r::Layer::export_region_fill_surfaces_to_svg

(

const char *

path

)

const

{
    BoundingBox bbox;
    for (const auto *region : m_regions)
        for (const auto &surface : region->slices.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 auto *region : m_regions)
        for (const auto &surface : region->slices.surfaces)
            svg.draw(surface.expolygon, surface_type_to_color_name(surface.surface_type), transparency);
    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(), m_regions, Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::merge(), Slic3r::BoundingBoxBase< PointType, APointsType >::min, and Slic3r::surface_type_to_color_name().

Referenced by 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::Layer::export_region_fill_surfaces_to_svg_debug

(

const char *

name

)

const

{
    static size_t idx = 0;
    this->export_region_fill_surfaces_to_svg(debug_out_path("Layer-fill_surfaces-%s-%d.svg", name, idx ++).c_str());
}

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

Here is the call graph for this function:

export_region_slices_to_svg()

void Slic3r::Layer::export_region_slices_to_svg

(

const char *

path

)

const

{
    BoundingBox bbox;
    for (const auto *region : m_regions)
        for (const auto &surface : region->slices.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 auto *region : m_regions)
        for (const auto &surface : region->slices.surfaces)
            svg.draw(surface.expolygon, surface_type_to_color_name(surface.surface_type), transparency);
    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(), m_regions, Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::merge(), Slic3r::BoundingBoxBase< PointType, APointsType >::min, and Slic3r::surface_type_to_color_name().

Referenced by 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::Layer::export_region_slices_to_svg_debug

(

const char *

name

)

const

{
    static size_t idx = 0;
    this->export_region_slices_to_svg(debug_out_path("Layer-slices-%s-%d.svg", name, idx ++).c_str());
}

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

Here is the call graph for this function:

generate_sparse_infill_polylines_for_anchoring()

Polylines Slic3r::Layer::generate_sparse_infill_polylines_for_anchoring	(	const FillAdaptive::RegionOctrees *	fill_octrees,
		FillLightning::Generator *	lightning_generator ) const

Generate sparse-infill polylines for anchoring/analysis purposes.

This produces the geometric polylines of internal sparse infill for the current layer (using the same infill pattern, angle, rotation template, and spacing that normal slicing would use), but it does not create extrusion entities.

The returned polylines are consumed by internal-bridge detection on the next layer to derive anchor lines and compute the bridge direction over sparse infill.

Notes:

• Only stInternal surfaces are considered.
• Rotation templates (e.g. sparse_infill_rotate_template) are applied so the anchors reflect the actual infill orientation.
• For lightning/adaptive patterns, the respective generators are wired so their polylines match the final infill layout.

{
    LockRegionParam skin_inner_param;
    std::vector<SurfaceFill> surface_fills = group_fills(*this, skin_inner_param);
  const Slic3r::BoundingBox bbox = this->object()->bounding_box();
  const auto                resolution = this->object()->print()->config().resolution.value;
 
    Polylines sparse_infill_polylines{};
 
    for (SurfaceFill &surface_fill : surface_fills) {
    if (surface_fill.surface.surface_type != stInternal) {
      continue;
    }
 
        switch (surface_fill.params.pattern) {
        case ipCount: continue; break;
        case ipSupportBase: continue; break;
        case ipConcentricInternal: continue; break;
        case ipLightning:
    case ipAdaptiveCubic:
        case ipSupportCubic:
        case ipRectilinear:
        case ipMonotonic:
        case ipMonotonicLine:
        case ipAlignedRectilinear:
        case ipGrid:
        case ipLateralLattice:
        case ipTriangles:
        case ipStars:
        case ipCubic:
        case ipLine:
        case ipConcentric:
        case ipSpiralInset:
        case ipHoneycomb:
        case ipLateralHoneycomb:
        case ip3DHoneycomb:
        case ipGyroid:
        case ipTpmsD:
        case ipTpmsFK:
        case ipHilbertCurve:
        case ipArchimedeanChords:
        case ipOctagramSpiral:
        case ipZigZag:
        case ipCrossZag:
    case ipLockedZag: break;
        }
 
        // Create the filler object.
        std::unique_ptr<Fill> f = std::unique_ptr<Fill>(Fill::new_from_type(surface_fill.params.pattern));
        f->set_bounding_box(bbox);
        f->layer_id = this->id() - this->object()->get_layer(0)->id(); // We need to subtract raft layers.
        {
            const auto &rcfg = m_regions[surface_fill.region_id]->region().config();
            f->dont_alternate_fill_direction = rcfg.zaa_enabled && rcfg.zaa_dont_alternate_fill_direction;
        }
        f->z        = this->print_z;
        f->angle    = surface_fill.params.angle;
        f->fixed_angle = surface_fill.params.fixed_angle;
        const FillAdaptive::Octrees *octrees = fill_octrees ? fill_octrees->region(surface_fill.region_id) : nullptr;
        f->adaptive_infill_field   = this->object()->adaptive_infill_field(surface_fill.params.adaptive_infill_mode);
        f->print_config        = &this->object()->print()->config();
        f->print_object_config = &this->object()->config();
 
        if (surface_fill.params.pattern == ipLightning)
            dynamic_cast<FillLightning::Filler *>(f.get())->generator = lightning_generator;
 
        // calculate flow spacing for infill pattern generation
        double link_max_length = 0.;
        if (!surface_fill.params.bridge) {
#if 0
            link_max_length = layerm.region()->config().get_abs_value(surface.is_external() ? "external_fill_link_max_length" : "fill_link_max_length", flow.spacing());
//            printf("flow spacing: %f,  is_external: %d, link_max_length: %lf\n", flow.spacing(), int(surface.is_external()), link_max_length);
#else
            if (surface_fill.params.density > 80.) // 80%
                link_max_length = 3. * f->spacing;
#endif
        }
 
        LayerRegion &layerm = *m_regions[surface_fill.region_id];
 
        // Maximum length of the perimeter segment linking two infill lines.
        f->link_max_length = (coord_t) scale_(link_max_length);
        // Used by the concentric infill pattern to clip the loops to create extrusion paths.
        f->loop_clipping = coord_t(scale_(layerm.region().config().seam_gap.get_abs_value(surface_fill.params.flow.nozzle_diameter())));
 
        // apply half spacing using this flow's own spacing and generate infill
        FillParams params;
        params.density           = float(0.01 * surface_fill.params.density);
        params.dont_adjust       = false; //  surface_fill.params.dont_adjust;
        params.anchor_length     = surface_fill.params.anchor_length;
        params.anchor_length_max = surface_fill.params.anchor_length_max;
        params.resolution        = resolution;
        params.use_arachne       = false;
        params.layer_height      = layerm.layer()->height;
        params.lateral_lattice_angle_1   = surface_fill.params.lateral_lattice_angle_1;
        params.lateral_lattice_angle_2   = surface_fill.params.lateral_lattice_angle_2;
        params.infill_overhang_angle   = surface_fill.params.infill_overhang_angle;
        params.multiline         = surface_fill.params.multiline;
        params.gyroid_optimized          = surface_fill.params.gyroid_optimized;
        params.adaptive_infill_mode             = surface_fill.params.adaptive_infill_mode;
        params.adaptive_infill_interior_density     = float(0.01 * surface_fill.params.adaptive_infill_interior_density);
        params.adaptive_infill_gradient    = surface_fill.params.adaptive_infill_gradient;
        params.smooth_factor             = surface_fill.params.smooth_factor;
        // Orca: Match make_fills() when choosing the origin of plane-path patterns.
        // Without the sparse extrusion role, the filler uses each surface's bounds
        // instead of the object's bounds, so bridge anchors shift away from printed infill.
        params.extrusion_role            = surface_fill.params.extrusion_role;
 
        for (ExPolygon &expoly : surface_fill.expolygons) {
            // Orca: Match the per-body box and octree of make_fills() before generating physical anchors.
            const int body = infill_body(*this, surface_fill, expoly);
            f->set_bounding_box(body >= 0 ? this->object()->separated_body_bboxes()[body] : bbox);
            f->adapt_fill_octree = octrees ? octrees->get(body) : nullptr;
            // Spacing is modified by the filler to indicate adjustments. Reset it for each expolygon.
            f->spacing                     = surface_fill.params.spacing;
            surface_fill.surface.expolygon = std::move(expoly);
            try {
                Polylines polylines = f->fill_surface(&surface_fill.surface, params);
                sparse_infill_polylines.insert(sparse_infill_polylines.end(), polylines.begin(), polylines.end());
            } catch (InfillFailedException &) {}
        }
    }
 
    return sparse_infill_polylines;
}

References Slic3r::FillParams::adaptive_infill_gradient, Slic3r::FillParams::adaptive_infill_interior_density, Slic3r::FillParams::adaptive_infill_mode, Slic3r::FillParams::anchor_length, Slic3r::FillParams::anchor_length_max, Slic3r::PrintRegion::config(), Slic3r::FillParams::density, Slic3r::FillParams::dont_adjust, Slic3r::FillParams::extrusion_role, Slic3r::f(), generate_sparse_infill_polylines_for_anchoring(), Slic3r::FillLightning::Filler::generator, Slic3r::FillAdaptive::Octrees::get(), Slic3r::group_fills(), Slic3r::FillParams::gyroid_optimized, height, id(), Slic3r::infill_body(), Slic3r::FillParams::infill_overhang_angle, Slic3r::ip3DHoneycomb, Slic3r::ipAdaptiveCubic, Slic3r::ipAlignedRectilinear, Slic3r::ipArchimedeanChords, Slic3r::ipConcentric, Slic3r::ipConcentricInternal, Slic3r::ipCount, Slic3r::ipCrossZag, Slic3r::ipCubic, Slic3r::ipGrid, Slic3r::ipGyroid, Slic3r::ipHilbertCurve, Slic3r::ipHoneycomb, Slic3r::ipLateralHoneycomb, Slic3r::ipLateralLattice, Slic3r::ipLightning, Slic3r::ipLine, Slic3r::ipLockedZag, Slic3r::ipMonotonic, Slic3r::ipMonotonicLine, Slic3r::ipOctagramSpiral, Slic3r::ipRectilinear, Slic3r::ipSpiralInset, Slic3r::ipStars, Slic3r::ipSupportBase, Slic3r::ipSupportCubic, Slic3r::ipTpmsD, Slic3r::ipTpmsFK, Slic3r::ipTriangles, Slic3r::ipZigZag, Slic3r::FillParams::lateral_lattice_angle_1, Slic3r::FillParams::lateral_lattice_angle_2, Slic3r::LayerRegion::layer(), Slic3r::FillParams::layer_height, m_regions, Slic3r::FillParams::multiline, Slic3r::Fill::new_from_type(), object(), print_z, Slic3r::FillAdaptive::RegionOctrees::region(), Slic3r::LayerRegion::region(), Slic3r::FillParams::resolution, Slic3r::resolution(), scale_, Slic3r::FillParams::smooth_factor, Slic3r::stInternal, and Slic3r::FillParams::use_arachne.

Referenced by generate_sparse_infill_polylines_for_anchoring().

Here is the call graph for this function:

Here is the caller graph for this function:

get_extruder_id()

size_t Slic3r::Layer::get_extruder_id

(

unsigned int

filament_id

)

const

{
    return m_object->print()->get_extruder_id(filament_id);
}

References m_object.

Referenced by Slic3r::group_fills().

Here is the caller graph for this function:

get_region() [1/2]

LayerRegion * Slic3r::Layer::get_region ( int idx )

inline

{ return m_regions[idx]; }

References m_regions.

get_region() [2/2]

const LayerRegion * Slic3r::Layer::get_region ( int idx ) const

inline

{ return m_regions[idx]; }

References m_regions.

Referenced by Slic3r::PrintObject::belt_drop_unclaimed_fills(), Slic3r::extract_layer(), and Slic3r::LayerRegion::make_perimeters().

Here is the caller graph for this function:

get_sparse_infill_max_void_area()

coordf_t Slic3r::Layer::get_sparse_infill_max_void_area

(

)

{
    double max_void_area = 0.;
    for (auto layerm : m_regions) {
        Flow flow = layerm->flow(frInfill);
        const PrintRegionConfig &config = layerm->region().config();
        float density = config.sparse_infill_density;
        InfillPattern pattern = config.sparse_infill_pattern;
        if (density == 0.)
            return -1;
        // Orca: the adaptive TPMS infill is as sparse as its interior density.
        if (density < 100.f && config.adaptive_infill_mode != AdaptiveInfillMode::Disabled && is_adaptive_infill_pattern(pattern))
            density = std::min(density, std::max(1.f, float(config.adaptive_infill_interior_density)));
 
        //BBS: rough estimation and need to be optimized
        double spacing = flow.scaled_spacing() * (100 - density) / density;
        switch (pattern) {
            case ipConcentric:
            case ipSpiralInset:
            case ipRectilinear:
            case ipLine:
            case ipGyroid:
            case ipTpmsD:
            case ipTpmsFK:
            case ipAlignedRectilinear:
            case ipOctagramSpiral:
            case ipHilbertCurve:
            case ipLateralHoneycomb:
            case ip3DHoneycomb:
            case ipArchimedeanChords:
                max_void_area = std::max(max_void_area, spacing * spacing);
                break;
            case ipGrid:
            case ipLateralLattice:
            case ipHoneycomb:
            case ipLightning:
                max_void_area = std::max(max_void_area, 4.0 * spacing * spacing);
                break;
            case ipCubic:
            case ipAdaptiveCubic:
            case ipTriangles:
            case ipStars:
            case ipSupportCubic:
                max_void_area = std::max(max_void_area, 4.5 * spacing * spacing);
                break;
            default:
                max_void_area = std::max(max_void_area, spacing * spacing);
                break;
        }
    };
    return max_void_area;
}

References Slic3r::Disabled, Slic3r::frInfill, Slic3r::ip3DHoneycomb, Slic3r::ipAdaptiveCubic, Slic3r::ipAlignedRectilinear, Slic3r::ipArchimedeanChords, Slic3r::ipConcentric, Slic3r::ipCubic, Slic3r::ipGrid, Slic3r::ipGyroid, Slic3r::ipHilbertCurve, Slic3r::ipHoneycomb, Slic3r::ipLateralHoneycomb, Slic3r::ipLateralLattice, Slic3r::ipLightning, Slic3r::ipLine, Slic3r::ipOctagramSpiral, Slic3r::ipRectilinear, Slic3r::ipSpiralInset, Slic3r::ipStars, Slic3r::ipSupportCubic, Slic3r::ipTpmsD, Slic3r::ipTpmsFK, Slic3r::ipTriangles, Slic3r::is_adaptive_infill_pattern(), m_regions, Slic3r::PrintRegionConfig, and Slic3r::Flow::scaled_spacing().

Here is the call graph for this function:

has_extrusions()

virtual bool Slic3r::Layer::has_extrusions ( ) const

inlinevirtual

Reimplemented in Slic3r::SupportLayer.

{ for (auto layerm : m_regions) if (layerm->has_extrusions()) return true; return false; }

References m_regions.

Referenced by Slic3r::belt_object_layer_prints_something(), and Slic3r::GCode::collect_layers_to_print().

Here is the caller graph for this function:

id()

size_t Slic3r::Layer::id ( ) const

inline

{ return m_id; }

References m_id.

Referenced by Layer(), Slic3r::SupportLayer::SupportLayer(), Slic3r::OozePrevention::_get_temp(), Slic3r::avoid_perimeters(), Slic3r::avoid_perimeters_inner(), Slic3r::belt_object_layer_prints_something(), Slic3r::PrintObject::bridge_over_infill(), Slic3r::PreciseSeam::collect_weak_modifier_segments(), Slic3r::PrintObject::combine_infill(), Slic3r::convert_layer_region_from_json(), Slic3r::detect_belt_floor_bottom_contacts(), Slic3r::extract_support_layer(), Slic3r::PreciseSeam::detail::fragment_location(), Slic3r::GCode::generate_object_brim(), generate_sparse_infill_polylines_for_anchoring(), Slic3r::group_fills(), Slic3r::PreciseSeam::insert_strong_seam_point(), make_fills(), make_ironing(), make_perimeters(), Slic3r::LayerRegion::make_perimeters(), Slic3r::new_contact_layer(), Slic3r::SeamPlacer::place_seam(), Slic3r::TreeSupport::plan_layer_heights(), Slic3r::GCode::process_layer(), and set_id().

Here is the caller graph for this function:

idx_higher_or_equal()

template<typename IteratorType, typename IndexType, typename FN_HIGHER_EQUAL>

IndexType Slic3r::Layer::idx_higher_or_equal ( IteratorType begin, IteratorType end, IndexType idx, FN_HIGHER_EQUAL fn_higher_equal )

inlinestatic

    {
        auto size = int(end - begin);
        if (size == 0) {
            idx = 0;
            }
        else if (idx == IndexType(-1)) {
            // First of the batch of layers per thread pool invocation. Use binary search.
            int idx_low = 0;
            int idx_high = std::max(0, size - 1);
            while (idx_low + 1 < idx_high) {
                int idx_mid = (idx_low + idx_high) / 2;
                if (fn_higher_equal(begin[idx_mid]))
                    idx_high = idx_mid;
                else
                    idx_low = idx_mid;
                }
            idx = fn_higher_equal(begin[idx_low]) ? idx_low :
                (fn_higher_equal(begin[idx_high]) ? idx_high : size);
            }
        else {
            // For the other layers of this batch of layers, search incrementally, which is cheaper than the binary search.
            while (int(idx) < size && !fn_higher_equal(begin[idx]))
                ++idx;
            }
        return idx;
    }

Referenced by Slic3r::TreeSupport::get_trim_support_regions().

Here is the caller graph for this function:

is_perimeter_compatible()

bool Slic3r::Layer::is_perimeter_compatible ( const Print & print, const PrintRegion & a, const PrintRegion & b )

static

{
    const PrintRegionConfig& config       = a.config();
    const PrintRegionConfig& other_config = b.config();
 
        return config.outer_wall_filament_id       == other_config.outer_wall_filament_id
    && config.inner_wall_filament_id       == other_config.inner_wall_filament_id
    && config.wall_loops                  == other_config.wall_loops
    && config.wall_sequence               == other_config.wall_sequence
    && config.is_infill_first             == other_config.is_infill_first
    && config.inner_wall_speed.get_at(print.get_extruder_id(config.outer_wall_filament_id)) == other_config.inner_wall_speed.get_at(print.get_extruder_id(config.outer_wall_filament_id))
    && config.outer_wall_speed.get_at(print.get_extruder_id(config.outer_wall_filament_id)) == other_config.outer_wall_speed.get_at(print.get_extruder_id(config.outer_wall_filament_id))
    && config.small_perimeter_speed.get_at(print.get_extruder_id(config.outer_wall_filament_id)) == other_config.small_perimeter_speed.get_at(print.get_extruder_id(config.outer_wall_filament_id))
    && config.small_support_perimeter_speed.get_at(print.get_extruder_id(config.outer_wall_filament_id)) == other_config.small_support_perimeter_speed.get_at(print.get_extruder_id(config.outer_wall_filament_id))
        && config.gap_infill_speed.get_at(print.get_extruder_id(config.outer_wall_filament_id)) == other_config.gap_infill_speed.get_at(print.get_extruder_id(config.outer_wall_filament_id))
        && config.filter_out_gap_fill.value == other_config.filter_out_gap_fill.value
    && config.detect_overhang_wall                   == other_config.detect_overhang_wall
    && config.unsupported_wall_last                  == other_config.unsupported_wall_last
    && config.overhang_reverse                       == other_config.overhang_reverse
    && config.overhang_reverse_threshold             == other_config.overhang_reverse_threshold
    && config.wall_direction                         == other_config.wall_direction
    && config.opt_serialize("inner_wall_line_width") == other_config.opt_serialize("inner_wall_line_width")
    && config.opt_serialize("outer_wall_line_width") == other_config.opt_serialize("outer_wall_line_width")
    && config.detect_thin_wall                  == other_config.detect_thin_wall
    && config.infill_wall_overlap              == other_config.infill_wall_overlap
        && config.top_bottom_infill_wall_overlap              == other_config.top_bottom_infill_wall_overlap
        // Orca: these flags directly change the effective wall count produced by the perimeter
        // generator. If two regions disagree on any of them, merging their slices into one shared make_perimeters
        // call would silently use the first region's flag for both.
        && config.only_one_wall_first_layer == other_config.only_one_wall_first_layer
        && config.only_one_wall_top         == other_config.only_one_wall_top
        && config.min_width_top_surface     == other_config.min_width_top_surface
        && config.seam_slope_type         == other_config.seam_slope_type
        && config.seam_slope_conditional == other_config.seam_slope_conditional
        && config.scarf_angle_threshold  == other_config.scarf_angle_threshold
        && config.scarf_overhang_threshold  == other_config.scarf_overhang_threshold
        && config.scarf_joint_speed       == other_config.scarf_joint_speed
        && config.scarf_joint_flow_ratio       == other_config.scarf_joint_flow_ratio
        && config.seam_slope_start_height == other_config.seam_slope_start_height
        && config.seam_slope_entire_loop  == other_config.seam_slope_entire_loop
        && config.seam_slope_min_length   == other_config.seam_slope_min_length
        && config.seam_slope_steps        == other_config.seam_slope_steps
        && config.seam_slope_inner_walls  == other_config.seam_slope_inner_walls;
}

References Slic3r::PrintRegion::config(), Slic3r::Print::get_extruder_id(), and Slic3r::PrintRegionConfig.

Referenced by make_perimeters().

Here is the call graph for this function:

Here is the caller graph for this function:

make_contour_z()

void Slic3r::Layer::make_contour_z

(

const sla::IndexedMesh &

mesh

)

{
  for (LayerRegion *region : this->regions()) {
        if (!region->region().config().zaa_enabled)
            continue;
 
        handle_extrusion_collection(region, mesh, region->fills, {erTopSolidInfill, erIroning, erPerimeter, erExternalPerimeter, erMixed});
        handle_extrusion_collection(region, mesh, region->perimeters, {erPerimeter, erExternalPerimeter, erMixed});
    }
}

References Slic3r::handle_extrusion_collection(), and regions().

Here is the call graph for this function:

make_fills() [1/2]

void Slic3r::Layer::make_fills ( )

inline

{ this->make_fills(nullptr); }

References make_fills().

Referenced by make_fills(), and make_fills().

Here is the call graph for this function:

Here is the caller graph for this function:

make_fills() [2/2]

void Slic3r::Layer::make_fills	(	const FillAdaptive::RegionOctrees *	fill_octrees,
		FillLightning::Generator *	lightning_generator = nullptr )

{
  for (LayerRegion *layerm : m_regions)
    layerm->fills.clear();
 
 
#ifdef SLIC3R_DEBUG_SLICE_PROCESSING
//  this->export_region_fill_surfaces_to_svg_debug("10_fill-initial");
#endif /* SLIC3R_DEBUG_SLICE_PROCESSING */
    LockRegionParam lock_param;
    std::vector<SurfaceFill>     surface_fills = group_fills(*this, lock_param);
  const Slic3r::BoundingBox bbox      = this->object()->bounding_box();
  const auto                resolution  = this->object()->print()->config().resolution.value;
 
#ifdef SLIC3R_DEBUG_SLICE_PROCESSING
  {
    static int iRun = 0;
    export_group_fills_to_svg(debug_out_path("Layer-fill_surfaces-10_fill-final-%d.svg", iRun ++).c_str(), surface_fills);
  }
#endif /* SLIC3R_DEBUG_SLICE_PROCESSING */
 
    for (SurfaceFill &surface_fill : surface_fills) {
        // Create the filler object.
        std::unique_ptr<Fill> f = std::unique_ptr<Fill>(Fill::new_from_type(surface_fill.params.pattern));
        f->set_bounding_box(bbox);
        f->layer_id = this->id();
        {
            const auto &rcfg = m_regions[surface_fill.region_id]->region().config();
            f->dont_alternate_fill_direction = rcfg.zaa_enabled && rcfg.zaa_dont_alternate_fill_direction;
        }
        f->z    = this->print_z;
        f->angle  = surface_fill.params.angle;
        f->fixed_angle = surface_fill.params.fixed_angle;
        const FillAdaptive::Octrees *octrees = fill_octrees ? fill_octrees->region(surface_fill.region_id) : nullptr;
        f->adaptive_infill_field   = this->object()->adaptive_infill_field(surface_fill.params.adaptive_infill_mode);
        f->print_config        = &this->object()->print()->config();
        f->print_object_config = &this->object()->config();
    if (surface_fill.params.pattern == ipConcentricInternal) {
            FillConcentricInternal *fill_concentric = dynamic_cast<FillConcentricInternal *>(f.get());
            assert(fill_concentric != nullptr);
            fill_concentric->print_config        = &this->object()->print()->config();
            fill_concentric->print_object_config = &this->object()->config();
        } else if (surface_fill.params.pattern == ipConcentric) {
            FillConcentric *fill_concentric = dynamic_cast<FillConcentric *>(f.get());
            assert(fill_concentric != nullptr);
            fill_concentric->print_config = &this->object()->print()->config();
            fill_concentric->print_object_config = &this->object()->config();
        } else if (surface_fill.params.pattern == ipLightning)
            dynamic_cast<FillLightning::Filler*>(f.get())->generator = lightning_generator;
        // calculate flow spacing for infill pattern generation
        bool using_internal_flow = ! surface_fill.surface.is_solid() && ! surface_fill.params.bridge;
        double link_max_length = 0.;
        if (! surface_fill.params.bridge) {
#if 0
            link_max_length = layerm.region()->config().get_abs_value(surface.is_external() ? "external_fill_link_max_length" : "fill_link_max_length", flow.spacing());
//            printf("flow spacing: %f,  is_external: %d, link_max_length: %lf\n", flow.spacing(), int(surface.is_external()), link_max_length);
#else
            if (surface_fill.params.density > 80.) // 80%
                link_max_length = 3. * f->spacing;
#endif
        }
 
        LayerRegion* layerm = this->m_regions[surface_fill.region_id];
 
        // Maximum length of the perimeter segment linking two infill lines.
        f->link_max_length = (coord_t)scale_(link_max_length);
        // Used by the concentric infill pattern to clip the loops to create extrusion paths.
        f->loop_clipping = coord_t(scale_(layerm->region().config().seam_gap.get_abs_value(surface_fill.params.flow.nozzle_diameter())));
 
        // apply half spacing using this flow's own spacing and generate infill
        FillParams params;
        params.density         = float(0.01 * surface_fill.params.density);
        params.multiline         = surface_fill.params.multiline;
    params.dont_adjust     = false; //  surface_fill.params.dont_adjust;
        params.anchor_length     = surface_fill.params.anchor_length;
    params.anchor_length_max = surface_fill.params.anchor_length_max;
    params.resolution        = resolution;
        params.use_arachne       = surface_fill.params.pattern == ipConcentric || surface_fill.params.pattern == ipSpiralInset ||
                                   surface_fill.params.pattern == ipConcentricInternal;
        params.layer_height      = layerm->layer()->height;
        params.lateral_lattice_angle_1   = surface_fill.params.lateral_lattice_angle_1;
        params.lateral_lattice_angle_2   = surface_fill.params.lateral_lattice_angle_2;
        params.infill_overhang_angle   = surface_fill.params.infill_overhang_angle;
        params.gyroid_optimized          = surface_fill.params.gyroid_optimized;
        params.adaptive_infill_mode             = surface_fill.params.adaptive_infill_mode;
        params.adaptive_infill_interior_density     = float(0.01 * surface_fill.params.adaptive_infill_interior_density);
        params.adaptive_infill_gradient    = surface_fill.params.adaptive_infill_gradient;
        params.smooth_factor             = surface_fill.params.smooth_factor;
 
    // BBS
    params.flow = surface_fill.params.flow;
    params.extrusion_role = surface_fill.params.extrusion_role;
    params.using_internal_flow = using_internal_flow;
    params.no_extrusion_overlap = surface_fill.params.overlap;
        auto &region_config = layerm->region().config();
        params.config               = &region_config;
        params.pattern              = surface_fill.params.pattern;
        params.fill_order           = surface_fill.params.fill_order;
 
        // Orca: Checking the filling of a centered surface by drawing for each model parts
        bool is_top_or_bottom = params.extrusion_role == erTopSolidInfill || params.extrusion_role == erBottomSurface;
        if (is_top_or_bottom) {
            params.center_of_surface_pattern = surface_fill.params.center_of_surface_pattern; // Orca: center of surface pattern
        }
        if( surface_fill.params.pattern == ipLockedZag ) {
      params.locked_zag = true;
            params.infill_lock_depth = surface_fill.params.infill_lock_depth;
            params.skin_infill_depth = surface_fill.params.skin_infill_depth;
            f->set_lock_region_param(lock_param);
    }
        if (surface_fill.params.pattern == ipCrossZag || surface_fill.params.pattern == ipLockedZag) {
            if (f->layer_id % 2 == 0) {
                params.horiz_move -= scale_(region_config.infill_shift_step) * (f->layer_id / 2);
            } else {
                params.horiz_move += scale_(region_config.infill_shift_step) * (f->layer_id / 2);
            }
 
            params.symmetric_infill_y_axis = surface_fill.params.symmetric_infill_y_axis;
 
        } else if (surface_fill.params.pattern == ipZigZag) {
            params.symmetric_infill_y_axis = surface_fill.params.symmetric_infill_y_axis;
 
        } else if (surface_fill.params.pattern == ip3DHoneycomb) {
            params.infill_complete_top = surface_fill.params.infill_complete_top;
        }
    if (surface_fill.params.pattern == ipGrid)
      params.can_reverse = false;
    for (ExPolygon& expoly : surface_fill.expolygons) {
 
            // Orca: Reuse the body box and octree used for bridge anchoring, resetting them for each surface.
            const int body = infill_body(*this, surface_fill, expoly);
            f->set_bounding_box(body >= 0 ? this->object()->separated_body_bboxes()[body] : bbox);
            f->adapt_fill_octree = octrees ? octrees->get(body) : nullptr;
 
            // Only the part of the layer-wide no-overlap area under this expolygon matters, so clip it to the
            // expolygon's box first (padded past the safety offset, which grows the clip side). The result is
            // identical; the cost is not: a layer split into many small fills, e.g. by colour painting,
            // otherwise intersects every one of them with the whole layer.
            BoundingBox no_overlap_bbox = get_extents(expoly);
            no_overlap_bbox.offset(SCALED_EPSILON);
            f->no_overlap_expolygons = intersection_ex(
                ClipperUtils::clip_clipper_polygons_with_subject_bbox(surface_fill.no_overlap_expolygons, no_overlap_bbox),
                ExPolygons() = {expoly}, ApplySafetyOffset::Yes);
            if (params.symmetric_infill_y_axis) {
                params.symmetric_y_axis = f->extended_object_bounding_box().center().x();
                expoly.symmetric_y(params.symmetric_y_axis);
            }
 
      // Spacing is modified by the filler to indicate adjustments. Reset it for each expolygon.
      f->spacing = surface_fill.params.spacing;
      surface_fill.surface.expolygon = std::move(expoly);
 
      if(surface_fill.params.bridge && surface_fill.surface.is_external() && surface_fill.params.density > 99.0){
        params.density = layerm->region().config().bridge_density.get_abs_value(1.0);
        params.dont_adjust = true;
      }
            if(surface_fill.surface.is_internal_bridge()){
                params.density = f->print_object_config->internal_bridge_density.get_abs_value(1.0);
                params.dont_adjust = true;
            }
            // Orca: Elephant foot compensation for solid layers above bottommost by infill density manipulation.
            float elefant_density = f->print_object_config->elefant_foot_layers_density.get_abs_value(1.0);
            if (!is_approx(elefant_density, 1.0f) && surface_fill.surface.is_solid_infill()) {
                size_t elefant_layers = f->print_object_config->elefant_foot_compensation_layers.value;
                if (f->layer_id > 0 && f->layer_id <= elefant_layers)
                    params.density = 1.0f - (1.0f - elefant_density) * (elefant_layers - (f->layer_id - 1)) / elefant_layers; // Reverse calculation - The higher layer number means the higher density. Counting starts from the second layer.
            }
            // make fill
      f->fill_surface_extrusion(&surface_fill.surface,
        params,
        m_regions[surface_fill.region_id]->fills.entities);
    }
    }
 
    // add thin fill regions
    // Unpacks the collection, creates multiple collections per path.
    // The path type could be ExtrusionPath, ExtrusionLoop or ExtrusionEntityCollection.
    // Why the paths are unpacked?
  for (LayerRegion *layerm : m_regions)
      for (const ExtrusionEntity *thin_fill : layerm->thin_fills.entities) {
          ExtrusionEntityCollection &collection = *(new ExtrusionEntityCollection());
          layerm->fills.entities.push_back(&collection);
          collection.entities.push_back(thin_fill->clone());
      }
 
#ifndef NDEBUG
  for (LayerRegion *layerm : m_regions)
      for (size_t i = 0; i < layerm->fills.entities.size(); ++ i)
          assert(dynamic_cast<ExtrusionEntityCollection*>(layerm->fills.entities[i]) != nullptr);
#endif
}

References Slic3r::FillParams::adaptive_infill_gradient, Slic3r::FillParams::adaptive_infill_interior_density, Slic3r::FillParams::adaptive_infill_mode, Slic3r::FillParams::anchor_length, Slic3r::FillParams::anchor_length_max, Slic3r::FillParams::can_reverse, Slic3r::FillParams::center_of_surface_pattern, Slic3r::ClipperUtils::clip_clipper_polygons_with_subject_bbox(), Slic3r::ExtrusionEntity::clone(), Slic3r::FillParams::config, Slic3r::PrintRegion::config(), Slic3r::debug_out_path(), Slic3r::FillParams::density, Slic3r::FillParams::dont_adjust, Slic3r::ExtrusionEntityCollection::entities, Slic3r::erBottomSurface, Slic3r::erTopSolidInfill, Slic3r::FillParams::extrusion_role, Slic3r::f(), Slic3r::FillParams::fill_order, Slic3r::FillParams::flow, Slic3r::FillLightning::Filler::generator, Slic3r::FillAdaptive::Octrees::get(), Slic3r::get_extents(), Slic3r::group_fills(), Slic3r::FillParams::gyroid_optimized, height, Slic3r::FillParams::horiz_move, id(), Slic3r::infill_body(), Slic3r::FillParams::infill_complete_top, Slic3r::FillParams::infill_lock_depth, Slic3r::FillParams::infill_overhang_angle, Slic3r::intersection_ex(), Slic3r::ip3DHoneycomb, Slic3r::ipConcentric, Slic3r::ipConcentricInternal, Slic3r::ipCrossZag, Slic3r::ipGrid, Slic3r::ipLightning, Slic3r::ipLockedZag, Slic3r::ipSpiralInset, Slic3r::ipZigZag, Slic3r::is_approx(), Slic3r::FillParams::lateral_lattice_angle_1, Slic3r::FillParams::lateral_lattice_angle_2, Slic3r::LayerRegion::layer(), Slic3r::FillParams::layer_height, Slic3r::FillParams::locked_zag, m_regions, make_fills(), Slic3r::FillParams::multiline, Slic3r::Fill::new_from_type(), Slic3r::FillParams::no_extrusion_overlap, object(), Slic3r::BoundingBoxBase< PointType, APointsType >::offset(), Slic3r::FillParams::pattern, Slic3r::Fill::print_config, Slic3r::Fill::print_object_config, print_z, Slic3r::FillAdaptive::RegionOctrees::region(), Slic3r::LayerRegion::region(), Slic3r::FillParams::resolution, Slic3r::resolution(), scale_, SCALED_EPSILON, Slic3r::FillParams::skin_infill_depth, Slic3r::FillParams::smooth_factor, Slic3r::FillParams::symmetric_infill_y_axis, Slic3r::ExPolygon::symmetric_y(), Slic3r::FillParams::symmetric_y_axis, Slic3r::FillParams::use_arachne, Slic3r::FillParams::using_internal_flow, and Slic3r::Yes.

Here is the call graph for this function:

make_ironing()

void Slic3r::Layer::make_ironing

(

)

{
  // LayerRegion::slices contains surfaces marked with SurfaceType.
  // Here we want to collect top surfaces extruded with the same extruder.
  // A surface will be ironed with the same extruder to not contaminate the print with another material leaking from the nozzle.
 
  // First classify regions based on the extruder used.
  struct IroningParams {
    InfillPattern pattern;
    int     extruder  = -1;
    bool    just_infill = false;
    // Spacing of the ironing lines, also to calculate the extrusion flow from.
    double    line_spacing;
    // Height of the extrusion, to calculate the extrusion flow from.
    double    height;
    double    speed;
    double    angle;
        bool        fixed_angle;
        double    inset;
 
    bool operator<(const IroningParams &rhs) const {
            RETURN_COMPARE_NON_EQUAL(extruder);
            RETURN_COMPARE_NON_EQUAL(just_infill);
            RETURN_COMPARE_NON_EQUAL(line_spacing);
            RETURN_COMPARE_NON_EQUAL(height);
            RETURN_COMPARE_NON_EQUAL(speed);
            RETURN_COMPARE_NON_EQUAL(angle);
            RETURN_COMPARE_NON_EQUAL(fixed_angle);
            RETURN_COMPARE_NON_EQUAL(inset);
      return false;
    }
 
    bool operator==(const IroningParams &rhs) const {
      return  this->extruder == rhs.extruder  && 
                    this->just_infill == rhs.just_infill &&
            this->line_spacing == rhs.line_spacing && 
                    this->height == rhs.height && 
                    this->speed == rhs.speed && 
                    this->angle == rhs.angle && 
                    this->fixed_angle == rhs.fixed_angle && 
                    this->pattern == rhs.pattern && 
                    this->inset == rhs.inset;
    }
 
    LayerRegion *layerm   = nullptr;
 
    // IdeaMaker: ironing
    // ironing flowrate (5% percent)
    // ironing speed (10 mm/sec)
 
    // Kisslicer:
    // iron off, Sweep, Group
    // ironing speed: 15 mm/sec
 
    // Cura:
    // Pattern (zig-zag / concentric)
    // line spacing (0.1mm)
    // flow: from normal layer height. 10%
    // speed: 20 mm/sec
  };
 
  std::vector<IroningParams> by_extruder;
    double default_layer_height = this->object()->config().layer_height;
 
  for (LayerRegion *layerm : m_regions)
    if (! layerm->slices.empty()) {
      IroningParams ironing_params;
      const PrintRegionConfig &config = layerm->region().config();
      ironing_params.extruder = Layer::choose_ironing_extruder(
        config,
        /*spiral_mode=*/this->object()->print()->config().spiral_mode,
        /*is_topmost_layer=*/layerm->layer()->upper_layer == nullptr);
      if (ironing_params.extruder != -1) {
        //TODO just_infill is currently not used.
        ironing_params.just_infill  = false;
        // ORCA: Get filament-specific overrides if configured, otherwise use process values
        size_t extruder_idx = ironing_params.extruder - 1;
        ironing_params.line_spacing = std::max(IRONING_SPACING_MIN, !config.filament_ironing_spacing.is_nil(extruder_idx)
          ? config.filament_ironing_spacing.get_at(extruder_idx)
          : config.ironing_spacing.value);
                ironing_params.inset = (!config.filament_ironing_inset.is_nil(extruder_idx)
          ? config.filament_ironing_inset.get_at(extruder_idx)
          : config.ironing_inset);
        ironing_params.height = default_layer_height * 0.01 * (!config.filament_ironing_flow.is_nil(extruder_idx)
          ? config.filament_ironing_flow.get_at(extruder_idx)
          : config.ironing_flow);
                ironing_params.speed = (!config.filament_ironing_speed.is_nil(extruder_idx)
                    ? config.filament_ironing_speed.get_at(extruder_idx)
                    : config.ironing_speed);
                const bool top_layer_direction_set = config.top_layer_direction.value >= 0.;
                const double top_layer_base_angle  = top_layer_direction_set ?
                    Geometry::deg2rad(config.top_layer_direction.value) :
                    calculate_infill_rotation_angle(this->object(), this->id(), config.solid_infill_direction.value, config.solid_infill_rotate_template.value);
                double ironing_angle = (config.ironing_angle_fixed ? 0. : top_layer_base_angle) + config.ironing_angle * M_PI / 180.;
                if (config.align_infill_direction_to_model) {
                    auto m = this->object()->trafo().matrix();
                    ironing_angle += atan2((double)m(1, 0), (double)m(0, 0));
                }
                ironing_params.angle      = ironing_angle;
                ironing_params.fixed_angle = config.ironing_angle_fixed || top_layer_direction_set || !config.solid_infill_rotate_template.value.empty();
        ironing_params.pattern      = config.ironing_pattern;
        ironing_params.layerm     = layerm;
        by_extruder.emplace_back(ironing_params);
      }
    }
  std::sort(by_extruder.begin(), by_extruder.end());
 
    FillParams      fill_params;
    fill_params.density    = 1.;
    fill_params.monotonic    = true;
    InfillPattern         f_pattern = ipRectilinear;
    std::unique_ptr<Fill> f         = std::unique_ptr<Fill>(Fill::new_from_type(f_pattern));
    f->set_bounding_box(this->object()->bounding_box());
    f->layer_id = this->id();
    f->z        = this->print_z;
    f->overlap  = 0;
  for (size_t i = 0; i < by_extruder.size();) {
    // Find span of regions equivalent to the ironing operation.
    IroningParams &ironing_params = by_extruder[i];
        f->dont_alternate_fill_direction = ironing_params.layerm->region().config().zaa_enabled && ironing_params.layerm->region().config().zaa_dont_alternate_fill_direction;
    // Create the filler object.
    if( f_pattern != ironing_params.pattern )
    {
            f_pattern               = ironing_params.pattern;
            f = std::unique_ptr<Fill>(Fill::new_from_type(f_pattern));
            f->set_bounding_box(this->object()->bounding_box());
            f->layer_id = this->id();
            f->z        = this->print_z;
            f->overlap  = 0;
    }
 
    size_t j = i;
    for (++ j; j < by_extruder.size() && ironing_params == by_extruder[j]; ++ j) ;
 
    // Create the ironing extrusions for regions <i, j)
    ExPolygons ironing_areas;
    double nozzle_dmr = nozzle_diameter_for_filament(this->object()->print()->config(), ironing_params.extruder, this->object()->print()->is_BBL_printer());
    if (ironing_params.just_infill) {
      //TODO just_infill is currently not used.
      // Just infill.
    } else {
      // Infill and perimeter.
      // Merge top surfaces with the same ironing parameters.
      Polygons polys;
      Polygons infills;
      for (size_t k = i; k < j; ++ k) {
        const IroningParams    &ironing_params  = by_extruder[k];
        const PrintRegionConfig  &region_config   = ironing_params.layerm->region().config();
        bool            iron_everything = region_config.ironing_type == IroningType::AllSolid;
        bool            iron_completely = iron_everything;
        if (iron_everything) {
          // Check whether there is any non-solid hole in the regions.
          bool internal_infill_solid = region_config.sparse_infill_density.value > 95.;
          for (const Surface &surface : ironing_params.layerm->fill_surfaces.surfaces)
            if ((!internal_infill_solid && surface.surface_type == stInternal) || surface.surface_type == stInternalBridge || surface.surface_type == stInternalVoid) {
              // Some fill region is not quite solid. Don't iron over the whole surface.
              iron_completely = false;
              break;
            }
        }
        if (iron_completely) {
          // Iron everything. This is likely only good for solid transparent objects.
          for (const Surface &surface : ironing_params.layerm->slices.surfaces)
            polygons_append(polys, surface.expolygon);
        } else {
          for (const Surface &surface : ironing_params.layerm->slices.surfaces)
            if ((surface.surface_type == stTop && (region_config.top_shell_layers > 0 || this->object()->print()->config().spiral_mode)) || (iron_everything && surface.surface_type == stBottom && region_config.bottom_shell_layers > 0))
              // stBottomBridge is not being ironed on purpose, as it would likely destroy the bridges.
              polygons_append(polys, surface.expolygon);
        }
        if (iron_everything && ! iron_completely) {
          // Add solid fill surfaces. This may not be ideal, as one will not iron perimeters touching these
          // solid fill surfaces, but it is likely better than nothing.
          for (const Surface &surface : ironing_params.layerm->fill_surfaces.surfaces)
            if (surface.surface_type == stInternalSolid)
              polygons_append(infills, surface.expolygon);
        }
      }
 
      if (! infills.empty() || j > i + 1) {
        // Ironing over more than a single region or over solid internal infill.
        if (! infills.empty())
          // For IroningType::AllSolid only:
          // Add solid infill areas for layers, that contain some non-ironable infil (sparse infill, bridge infill).
          append(polys, std::move(infills));
        polys = union_safety_offset(polys);
      }
      // Trim the top surfaces with half the nozzle diameter.
            // BBS: ironing inset
            double ironing_areas_offset = ironing_params.inset == 0 ? float(scale_(0.5 * nozzle_dmr)) : scale_(ironing_params.inset);
      ironing_areas = intersection_ex(polys, offset(this->lslices, - ironing_areas_offset));
    }
 
        // Create the filler object.
        f->spacing = ironing_params.line_spacing;
        f->angle = float(ironing_params.angle);
        f->fixed_angle = ironing_params.fixed_angle;
        f->link_max_length = (coord_t) scale_(3. * f->spacing);
    double  extrusion_height = ironing_params.height * f->spacing / nozzle_dmr;
    float  extrusion_width  = Flow::rounded_rectangle_extrusion_width_from_spacing(float(nozzle_dmr), float(extrusion_height));
    double flow_mm3_per_mm = nozzle_dmr * extrusion_height;
        Surface surface_fill(stTop, ExPolygon());
        for (ExPolygon &expoly : ironing_areas) {
      surface_fill.expolygon = std::move(expoly);
      Polylines polylines;
      try {
        polylines = f->fill_surface(&surface_fill, fill_params);
      } catch (InfillFailedException &) {
      }
          if (! polylines.empty()) {
            // Save into layer.
        ExtrusionEntityCollection *eec = nullptr;
            ironing_params.layerm->fills.entities.push_back(eec = new ExtrusionEntityCollection());
            // Don't sort the ironing infill lines as they are monotonicly ordered.
        eec->no_sort = true;
            extrusion_entities_append_paths(
                eec->entities, std::move(polylines),
                erIroning,
                flow_mm3_per_mm, extrusion_width, float(extrusion_height));
        }
    }
 
    // Regions up to j were processed.
    i = j;
  }
}

References Slic3r::AllSolid, Slic3r::angle(), Slic3r::append(), Slic3r::bounding_box(), Slic3r::calculate_infill_rotation_angle(), choose_ironing_extruder(), Slic3r::Geometry::deg2rad(), Slic3r::FillParams::density, Slic3r::ExtrusionEntityCollection::entities, Slic3r::erIroning, Slic3r::Surface::expolygon, Slic3r::extrusion_entities_append_paths(), Slic3r::f(), height, id(), Slic3r::intersection_ex(), Slic3r::ipRectilinear, Slic3r::IRONING_SPACING_MIN, lslices, M_PI, m_regions, make_ironing(), Slic3r::FillParams::monotonic, Slic3r::Fill::new_from_type(), Slic3r::ExtrusionEntityCollection::no_sort, Slic3r::nozzle_diameter_for_filament(), object(), Slic3r::offset(), operator<(), Slic3r::operator==(), Slic3r::polygons_append(), print_z, Slic3r::PrintRegionConfig, RETURN_COMPARE_NON_EQUAL, Slic3r::Flow::rounded_rectangle_extrusion_width_from_spacing(), scale_, Slic3r::stBottom, Slic3r::stInternal, Slic3r::stInternalBridge, Slic3r::stInternalSolid, Slic3r::stInternalVoid, Slic3r::stTop, Slic3r::Surface::surface_type, and Slic3r::union_safety_offset().

Referenced by make_ironing().

Here is the call graph for this function:

Here is the caller graph for this function:

make_perimeters()

void Slic3r::Layer::make_perimeters

(

)

{
    BOOST_LOG_TRIVIAL(trace) << "Generating perimeters for layer " << this->id();
 
    const auto clear_generated_extrusions = [](LayerRegion *layer_region) {
        layer_region->perimeters.clear();
        layer_region->fills.clear();
        layer_region->thin_fills.clear();
    };
 
    // keep track of regions whose perimeters we have already generated
    std::vector<unsigned char> done(m_regions.size(), false);
 
    for (LayerRegionPtrs::iterator layerm = m_regions.begin(); layerm != m_regions.end(); ++ layerm)
      if ((*layerm)->slices.empty()) {
      (*layerm)->perimeters.clear();
      (*layerm)->fills.clear();
      (*layerm)->thin_fills.clear();
      } else {
          size_t region_id = layerm - m_regions.begin();
          if (done[region_id])
              continue;
          BOOST_LOG_TRIVIAL(trace) << "Generating perimeters for layer " << this->id() << ", region " << region_id;
          done[region_id] = true;
          const PrintRegion &this_region = (*layerm)->region();
 
          // find compatible regions
          LayerRegionPtrs layerms;
          layerms.push_back(*layerm);
          for (LayerRegionPtrs::const_iterator it = layerm + 1; it != m_regions.end(); ++it)
              if (! (*it)->slices.empty()) {
                LayerRegion* other_layerm = *it;
                const PrintRegion &other_region = other_layerm->region();
                    // Per-part gradient tags a region with its owning ModelVolume; merging two
                    // differently-tagged regions would collapse volumes that need independent
                    // gradient runs. Both tags are invalid unless per-part gradient is on, so
                    // this is a no-op for every other configuration.
                    if (this_region.gradient_volume_id() != other_region.gradient_volume_id())
                        continue;
                    if (is_perimeter_compatible(*m_object->print(), this_region, other_region))
                    {
                        clear_generated_extrusions(other_layerm);
                        layerms.push_back(other_layerm);
                        done[it - m_regions.begin()] = true;
                    }
            }
 
          if (layerms.size() == 1) {  // optimization
              (*layerm)->fill_surfaces.surfaces.clear();
                (*layerm)->make_perimeters((*layerm)->slices, {*layerm}, &(*layerm)->fill_surfaces, &(*layerm)->fill_no_overlap_expolygons);
              (*layerm)->fill_expolygons = to_expolygons((*layerm)->fill_surfaces.surfaces);
          } else {
              // Orca: Unlike the compatible regions above, the initiating region has not
              // been cleared yet and may contain paths from a previous incompatible run.
              clear_generated_extrusions(*layerm);
 
              SurfaceCollection new_slices;
              // Use the region with highest infill rate, as the make_perimeters() function below decides on the gap fill based on the infill existence.
              LayerRegion *layerm_config = layerms.front();
              {
                  // group slices (surfaces) according to number of extra perimeters
                  std::map<unsigned short, Surfaces> slices;  // extra_perimeters => [ surface, surface... ]
                  for (LayerRegion *layerm : layerms) {
                      for (const Surface &surface : layerm->slices.surfaces)
                          slices[surface.extra_perimeters].emplace_back(surface);
                      if (layerm->region().config().sparse_infill_density > layerm_config->region().config().sparse_infill_density)
                        layerm_config = layerm;
                  }
                  // merge the surfaces assigned to each group
                  for (std::pair<const unsigned short,Surfaces> &surfaces_with_extra_perimeters : slices)
                      new_slices.append(offset_ex(surfaces_with_extra_perimeters.second, ClipperSafetyOffset), surfaces_with_extra_perimeters.second.front());
              }
 
              // make perimeters
              SurfaceCollection fill_surfaces;
                //BBS
                ExPolygons fill_no_overlap;
              layerm_config->make_perimeters(new_slices, layerms, &fill_surfaces, &fill_no_overlap);
 
              // assign fill_surfaces to each layer
              if (!fill_surfaces.surfaces.empty()) {
                  for (LayerRegionPtrs::iterator l = layerms.begin(); l != layerms.end(); ++l) {
                      // Separate the fill surfaces.
                      ExPolygons expp = intersection_ex(fill_surfaces.surfaces, (*l)->slices.surfaces);
                      (*l)->fill_expolygons = expp;
                      (*l)->fill_surfaces.set(std::move(expp), fill_surfaces.surfaces.front());
                        //BBS: Separate fill_no_overlap
                        (*l)->fill_no_overlap_expolygons = intersection_ex((*l)->slices.surfaces, fill_no_overlap);
                  }
 
                  // When counterbore hole bridging (chbFilled) is active, process_no_bridge may
                  // create fill surfaces that extend beyond all region slices (e.g. by clearing
                  // holes in the bridge expolygon). These "extra" fills are lost during the
                  // intersection-based splitting above. Recover them and assign to the first
                  // merged region so the sacrificial bridge layer is not broken.
                  if (layerm_config->region().config().counterbore_hole_bridging.value != chbNone) {
                      Polygons all_region_slices_p;
                      for (LayerRegion *l : layerms)
                          polygons_append(all_region_slices_p, to_polygons(l->slices.surfaces));
                      ExPolygons extra_fill = diff_ex(fill_surfaces.surfaces, all_region_slices_p, ApplySafetyOffset::Yes);
                      if (!extra_fill.empty()) {
                          append(layerms.front()->fill_expolygons, extra_fill);
                          layerms.front()->fill_expolygons = union_ex(layerms.front()->fill_expolygons);
                          layerms.front()->fill_surfaces.append(std::move(extra_fill), fill_surfaces.surfaces.front());
                      }
                  }
              }
          }
      }
    BOOST_LOG_TRIVIAL(trace) << "Generating perimeters for layer " << this->id() << " - Done";
}

References Slic3r::append(), Slic3r::SurfaceCollection::append(), Slic3r::chbNone, Slic3r::ClipperSafetyOffset, Slic3r::PrintRegion::config(), Slic3r::diff_ex(), Slic3r::Surface::extra_perimeters, Slic3r::PrintRegion::gradient_volume_id(), id(), Slic3r::intersection_ex(), is_perimeter_compatible(), m_object, m_regions, Slic3r::LayerRegion::make_perimeters(), Slic3r::offset_ex(), Slic3r::polygons_append(), Slic3r::LayerRegion::region(), Slic3r::SurfaceCollection::surfaces, Slic3r::to_expolygons(), Slic3r::to_polygons(), Slic3r::trace(), Slic3r::union_ex(), and Slic3r::Yes.

Here is the call graph for this function:

make_slices()

void Slic3r::Layer::make_slices

(

)

{
    ExPolygons slices;
    if (m_regions.size() == 1) {
        // optimization: if we only have one region, take its slices
        slices = to_expolygons(m_regions.front()->slices.surfaces);
    } else {
        Polygons slices_p;
        for (LayerRegion *layerm : m_regions)
            polygons_append(slices_p, to_polygons(layerm->slices.surfaces));
        slices = union_safety_offset_ex(slices_p);
    }
 
    this->lslices.clear();
    this->lslices.reserve(slices.size());
 
    // prepare ordering points
    Points ordering_points;
    ordering_points.reserve(slices.size());
    for (const ExPolygon &ex : slices)
        ordering_points.push_back(ex.contour.first_point());
 
    // sort slices
    std::vector<Points::size_type> order = chain_points(ordering_points);
 
    // populate slices vector
    for (size_t i : order)
        this->lslices.emplace_back(std::move(slices[i]));
}

References Slic3r::chain_points(), lslices, m_regions, Slic3r::polygons_append(), Slic3r::to_expolygons(), Slic3r::to_polygons(), and Slic3r::union_safety_offset_ex().

Here is the call graph for this function:

merged()

ExPolygons Slic3r::Layer::merged

(

float

offset

)

const

{
  assert(offset_scaled >= 0.f);
    // If no offset is set, apply EPSILON offset before union, and revert it afterwards.
  float offset_scaled2 = 0;
  if (offset_scaled == 0.f) {
    offset_scaled  = float(  EPSILON);
    offset_scaled2 = float(- EPSILON);
    }
    Polygons polygons;
  for (LayerRegion *layerm : m_regions) {
    const PrintRegionConfig &config = layerm->region().config();
    // Our users learned to bend Slic3r to produce empty volumes to act as subtracters. Only add the region if it is non-empty.
    if (config.bottom_shell_layers > 0 || config.top_shell_layers > 0 || config.sparse_infill_density > 0. || config.wall_loops > 0)
      append(polygons, offset(layerm->slices.surfaces, offset_scaled));
  }
    ExPolygons out = union_ex(polygons);
  if (offset_scaled2 != 0.f)
    out = offset_ex(out, offset_scaled2);
    return out;
}

References Slic3r::append(), EPSILON, m_regions, Slic3r::offset(), Slic3r::offset_ex(), Slic3r::PrintRegionConfig, and Slic3r::union_ex().

Referenced by Slic3r::PrintObject::apply_conical_overhang().

Here is the call graph for this function:

Here is the caller graph for this function:

object() [1/2]

PrintObject * Slic3r::Layer::object ( )

inline

{ return m_object; }

References m_object, and PrintObject.

Referenced by Layer(), Slic3r::SupportLayer::SupportLayer(), Slic3r::LayerRegion::bridging_flow(), Slic3r::TimelapsePosPicker::collect_object_slices_data(), Slic3r::PreciseSeam::collect_weak_modifier_segments(), libvgcode::convert_object_to_vertices(), Slic3r::PreciseSeam::detail::fragment_location(), generate_sparse_infill_polylines_for_anchoring(), Slic3r::get_boundary(), Slic3r::get_boundary_external(), Slic3r::get_external_perimeter_width(), Slic3r::get_perimeter_spacing(), Slic3r::get_perimeter_spacing_external(), Slic3r::group_fills(), Slic3r::PreciseSeam::insert_strong_seam_point(), make_fills(), make_ironing(), Slic3r::LayerRegion::make_perimeters(), Slic3r::GCode::LayerToPrint::object(), Slic3r::SeamPlacer::place_seam(), Slic3r::LayerRegion::process_external_surfaces(), Slic3r::GCode::process_layer(), Slic3r::PrintObject::remove_bridges_from_contacts(), Slic3r::SupportMaterialInternal::remove_bridges_from_contacts(), simplify_support_loop(), simplify_support_multi_path(), and simplify_support_path().

Here is the call graph for this function:

Here is the caller graph for this function:

object() [2/2]

const PrintObject * Slic3r::Layer::object ( ) const

inline

{ return m_object; }

References m_object, and PrintObject.

Here is the call graph for this function:

region_count()

size_t Slic3r::Layer::region_count ( ) const

inline

{ return m_regions.size(); }

References m_regions.

Referenced by Slic3r::extract_layer().

Here is the caller graph for this function:

regions()

const LayerRegionPtrs & Slic3r::Layer::regions ( ) const

inline

{ return m_regions; }

References m_regions.

Referenced by Slic3r::PrintObject::belt_drop_unclaimed_fills(), Slic3r::PrintObject::bridge_over_infill(), Slic3r::collect_region_slices_by_type(), Slic3r::detect_contacts(), Slic3r::detect_overhangs(), Slic3r::PrintObject::discover_horizontal_shells(), Slic3r::PrintObject::discover_vertical_shells(), Slic3r::WipingExtrusions::ensure_perimeters_infills_order(), Slic3r::SeamPlacerImpl::extract_perimeter_polygons(), Slic3r::ToolOrdering::generate_first_layer_tool_order(), Slic3r::ToolOrdering::generate_first_layer_tool_order(), Slic3r::FillLightning::Generator::generateInitialInternalOverhangs(), Slic3r::FillLightning::Generator::generateTrees(), Slic3r::get_boundary(), Slic3r::get_external_perimeter_width(), Slic3r::get_perimeter_spacing(), Slic3r::get_print_object_bottom_layer_expolygons(), Slic3r::TreeSupport::get_trim_support_regions(), Slic3r::getadhesionCoeff(), Slic3r::group_fills(), Slic3r::SupportMaterialInternal::has_bridging_extrusions(), make_contour_z(), Slic3r::new_contact_layer(), Slic3r::precompute_overhang_layer(), Slic3r::precompute_overhang_layers(), Slic3r::prepares_overhang_estimator(), Slic3r::PrintObject::process_external_surfaces(), Slic3r::PrintObject::remove_bridges_from_contacts(), Slic3r::segmentation_top_and_bottom_layers(), Slic3r::RetractWhenCrossingPerimeters::travel_inside_internal_regions(), and Slic3r::PrintObjectSupportMaterial::trim_support_layers_by_object().

Here is the caller graph for this function:

restore_untyped_slices()

void Slic3r::Layer::restore_untyped_slices

(

)

{
    if (layer_needs_raw_backup(this)) {
        for (LayerRegion *layerm : m_regions)
            layerm->slices.set(layerm->raw_slices, stInternal);
    } else {
        assert(m_regions.size() == 1);
        m_regions.front()->slices.set(this->lslices, stInternal);
    }
}

References Slic3r::layer_needs_raw_backup(), lslices, m_regions, and Slic3r::stInternal.

Here is the call graph for this function:

restore_untyped_slices_no_extra_perimeters()

void Slic3r::Layer::restore_untyped_slices_no_extra_perimeters

(

)

{
    if (layer_needs_raw_backup(this)) {
        for (LayerRegion *layerm : m_regions)
            //BBS: remove extra_perimeters. Always false
          //if (! layerm->region().config().extra_perimeters.value)
              layerm->slices.set(layerm->raw_slices, stInternal);
    } else {
      assert(m_regions.size() == 1);
      LayerRegion *layerm = m_regions.front();
      // This optimization is correct, as extra_perimeters are only reused by prepare_infill() with multi-regions.
        //if (! layerm->region().config().extra_perimeters.value)
          layerm->slices.set(this->lslices, stInternal);
    }
}

References Slic3r::layer_needs_raw_backup(), lslices, m_regions, Slic3r::SurfaceCollection::set(), Slic3r::LayerRegion::slices, and Slic3r::stInternal.

Here is the call graph for this function:

set_id()

void Slic3r::Layer::set_id ( size_t id )

inline

{ m_id = id; }

References id(), and m_id.

Here is the call graph for this function:

simplify_infill_extrusion_path()

void Slic3r::Layer::simplify_infill_extrusion_path ( )

inline

{ for (auto layerm : m_regions) layerm->simplify_infill_extrusion_entity(); }

References m_regions.

simplify_support_entity_collection()

void Slic3r::Layer::simplify_support_entity_collection ( ExtrusionEntityCollection * entity_collection )

protected

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

References Slic3r::ExtrusionEntityCollection::entities, simplify_support_entity_collection(), simplify_support_loop(), simplify_support_multi_path(), and simplify_support_path().

Referenced by simplify_support_entity_collection(), and Slic3r::SupportLayer::simplify_support_extrusion_path().

Here is the call graph for this function:

Here is the caller graph for this function:

simplify_support_loop()

void Slic3r::Layer::simplify_support_loop ( ExtrusionLoop * loop )

protected

{
    const auto &print_config = this->object()->print()->config();
    const bool spiral_mode = print_config.spiral_mode;
    const bool enable_arc_fitting = print_config.enable_arc_fitting.value == ArcFittingMode::Enabled;
    const auto scaled_resolution = scaled<double>(print_config.resolution.value);
 
    for (size_t i = 0; i < loop->paths.size(); ++i) {
        if (enable_arc_fitting &&
            !spiral_mode) {
            loop->paths[i].simplify_by_fitting_arc(SCALED_SUPPORT_RESOLUTION);
        } else {
            loop->paths[i].simplify(scaled_resolution);
        }
    }
}

References Slic3r::Print::config(), Slic3r::Enabled, object(), Slic3r::ExtrusionLoop::paths, Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnum, COUNT >::print(), Slic3r::scaled(), and SCALED_SUPPORT_RESOLUTION.

Referenced by simplify_support_entity_collection().

Here is the call graph for this function:

Here is the caller graph for this function:

simplify_support_multi_path()

void Slic3r::Layer::simplify_support_multi_path ( ExtrusionMultiPath * multipath )

protected

{
    const auto &print_config = this->object()->print()->config();
    const bool spiral_mode = print_config.spiral_mode;
    const bool enable_arc_fitting = print_config.enable_arc_fitting.value == ArcFittingMode::Enabled;
    const auto scaled_resolution = scaled<double>(print_config.resolution.value);
 
    for (size_t i = 0; i < multipath->paths.size(); ++i) {
        if (enable_arc_fitting &&
            !spiral_mode) {
            multipath->paths[i].simplify_by_fitting_arc(SCALED_SUPPORT_RESOLUTION);
        } else {
            multipath->paths[i].simplify(scaled_resolution);
        }
    }
}

References Slic3r::Print::config(), Slic3r::Enabled, object(), Slic3r::ExtrusionMultiPath::paths, Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnum, COUNT >::print(), Slic3r::scaled(), and SCALED_SUPPORT_RESOLUTION.

Referenced by simplify_support_entity_collection().

Here is the call graph for this function:

Here is the caller graph for this function:

simplify_support_path()

void Slic3r::Layer::simplify_support_path ( ExtrusionPath * path )

protected

{
    const auto &print_config = this->object()->print()->config();
    const bool spiral_mode = print_config.spiral_mode;
    const bool enable_arc_fitting = print_config.enable_arc_fitting.value == ArcFittingMode::Enabled;
    const auto scaled_resolution = scaled<double>(print_config.resolution.value);
 
    if (enable_arc_fitting &&
        !spiral_mode) {
        path->simplify_by_fitting_arc(SCALED_SUPPORT_RESOLUTION);
    } else {
        path->simplify(scaled_resolution);
    }
}

References Slic3r::Print::config(), Slic3r::Enabled, object(), Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnum, COUNT >::print(), Slic3r::scaled(), SCALED_SUPPORT_RESOLUTION, Slic3r::ExtrusionPath::simplify(), and Slic3r::ExtrusionPath::simplify_by_fitting_arc().

Referenced by simplify_support_entity_collection().

Here is the call graph for this function:

Here is the caller graph for this function:

simplify_wall_extrusion_path()

void Slic3r::Layer::simplify_wall_extrusion_path ( )

inline

{ for (auto layerm : m_regions) layerm->simplify_wall_extrusion_entity();}

References m_regions.

Friends And Related Symbol Documentation

fix_slicing_errors

std::string fix_slicing_errors ( PrintObject * object, LayerPtrs & , const std::function< void()> & , int &  )

friend

References PrintObject.

new_layers

std::vector< Layer * > new_layers ( PrintObject * print_object, const std::vector< coordf_t > & object_layers )

friend

{
    LayerPtrs out;
    out.reserve(object_layers.size());
    auto     id   = int(print_object->slicing_parameters().raft_layers());
    coordf_t zmin = print_object->slicing_parameters().object_print_z_min;
    Layer   *prev = nullptr;
    for (size_t i_layer = 0; i_layer < object_layers.size(); i_layer += 2) {
        coordf_t lo = object_layers[i_layer];
        coordf_t hi = object_layers[i_layer + 1];
        coordf_t slice_z = compute_slice_z(print_object, i_layer, lo, hi);
 
        Layer *layer = new Layer(id ++, print_object, hi - lo, hi + zmin, slice_z);
        out.emplace_back(layer);
        if (prev != nullptr) {
            prev->upper_layer = layer;
            layer->lower_layer = prev;
        }
        prev = layer;
    }
    return out;
}

References Layer(), Slic3r::compute_slice_z(), lower_layer, Slic3r::SlicingParameters::object_print_z_min, PrintObject, Slic3r::SlicingParameters::raft_layers(), slice_z, Slic3r::PrintObject::slicing_parameters(), and upper_layer.

PrintObject

friend class PrintObject

friend

References PrintObject.

Referenced by Layer(), fix_slicing_errors, new_layers, object(), object(), and PrintObject.

Member Data Documentation

cantilevers

ExPolygons Slic3r::Layer::cantilevers

mutable

Referenced by Slic3r::detect_overhangs(), and Slic3r::PrintObjectSupportMaterial::top_contact_layers().

curled_lines

CurledLines Slic3r::Layer::curled_lines

Referenced by Slic3r::ExtrusionQualityEstimator::prepare_for_new_layer().

height

coordf_t Slic3r::Layer::height

Referenced by Layer(), Slic3r::SupportLayer::SupportLayer(), Slic3r::TreeSupportData::TreeSupportData(), Slic3r::GCode::collect_layers_to_print(), Slic3r::PrintObject::combine_infill(), Slic3r::contour_extrusion_path(), Slic3r::detect_overhangs(), generate_sparse_infill_polylines_for_anchoring(), Slic3r::TreeSupport::generate_toolpaths(), Slic3r::getExtrusionPathsFromSupportLayer(), Slic3r::group_fills(), Slic3r::make_belt_brim(), make_fills(), make_ironing(), Slic3r::new_contact_layer(), Slic3r::segmentation_top_and_bottom_layers(), Slic3r::sync_gap_with_object_layer(), and Slic3r::PrintObjectSupportMaterial::top_contact_layers().

loverhangs

ExPolygons Slic3r::Layer::loverhangs

Referenced by Slic3r::PrintObject::copy_layers_overhang_from_shared_object(), Slic3r::PrintObject::detect_overhangs_for_lift(), and Slic3r::extract_layer().

loverhangs_bbox

BoundingBox Slic3r::Layer::loverhangs_bbox

Referenced by Slic3r::PrintObject::copy_layers_overhang_from_shared_object(), Slic3r::PrintObject::detect_overhangs_for_lift(), and Slic3r::extract_layer().

lower_layer

Layer* Slic3r::Layer::lower_layer

Referenced by Layer(), ~Layer(), Slic3r::PrintObject::bridge_over_infill(), Slic3r::detect_contacts(), Slic3r::detect_overhangs(), Slic3r::PrintObject::detect_overhangs_for_lift(), Slic3r::new_contact_layer(), new_layers, Slic3r::TreeSupport::plan_layer_heights(), Slic3r::precompute_overhang_layers(), Slic3r::ExtrusionQualityEstimator::prepare_for_new_layer(), Slic3r::sync_gap_with_object_layer(), and Slic3r::PrintObjectSupportMaterial::top_contact_layers().

lslices

ExPolygons Slic3r::Layer::lslices

Referenced by Slic3r::TreeSupport3D::TreeModelVolumes::TreeModelVolumes(), Slic3r::TreeSupportData::TreeSupportData(), Slic3r::GCode::_do_export(), Slic3r::Print::_make_skirt(), Slic3r::PrintObjectSupportMaterial::buildplate_covered(), Slic3r::calculate_layer_edge_grid(), Slic3r::GUI::check_color_change(), Slic3r::PrintObject::clip_fill_surfaces(), Slic3r::collect_slices_outer(), Slic3r::detect_contacts(), Slic3r::detect_overhangs(), Slic3r::PrintObject::detect_overhangs_for_lift(), Slic3r::PrintObject::discover_vertical_shells(), Slic3r::extract_layer(), Slic3r::TreeSupport3D::generate_raft_contact(), Slic3r::TreeSupport::generate_toolpaths(), Slic3r::get_boundary(), Slic3r::TreeSupport::get_trim_support_regions(), Slic3r::infill_body(), Slic3r::AvoidCrossingPerimeters::init_layer(), Slic3r::make_belt_brim(), make_ironing(), Slic3r::LayerRegion::make_perimeters(), make_slices(), Slic3r::outer_inner_brim_area(), Slic3r::ExtrusionQualityEstimator::prepare_for_new_layer(), Slic3r::PrintObject::prepare_infill(), Slic3r::GCode::process_layer(), Slic3r::project_support_to_grid(), Slic3r::anonymous_namespace{PluginHostSlicing.cpp}::refresh_lslices_bboxes(), Slic3r::PrintObject::remove_bridges_from_contacts(), Slic3r::SupportMaterialInternal::remove_bridges_from_contacts(), restore_untyped_slices(), restore_untyped_slices_no_extra_perimeters(), Slic3r::separated_body_at(), Slic3r::set_mass_locator(), Slic3r::PrintObjectSupportMaterial::top_contact_layers(), Slic3r::AvoidCrossingPerimeters::travel_to(), and Slic3r::PrintObjectSupportMaterial::trim_support_layers_by_object().

lslices_bboxes

std::vector<BoundingBox> Slic3r::Layer::lslices_bboxes

Referenced by Slic3r::GCode::belt_layer_past_first_layer_band(), Slic3r::extract_layer(), Slic3r::infill_body(), Slic3r::PrintObject::prepare_infill(), Slic3r::anonymous_namespace{PluginHostSlicing.cpp}::refresh_lslices_bboxes(), Slic3r::PrintObject::remove_bridges_from_contacts(), Slic3r::SupportMaterialInternal::remove_bridges_from_contacts(), Slic3r::separated_body_at(), and Slic3r::AvoidCrossingPerimeters::travel_to().

lslices_extrudable

ExPolygons Slic3r::Layer::lslices_extrudable

lslices_separated_component_ids

std::vector<size_t> Slic3r::Layer::lslices_separated_component_ids

Referenced by Slic3r::infill_body(), Slic3r::PrintObject::prepare_infill(), Slic3r::separated_body_at(), and Slic3r::set_mass_locator().

m_id

size_t Slic3r::Layer::m_id

private

Referenced by Layer(), id(), and set_id().

m_object

PrintObject* Slic3r::Layer::m_object

private

Referenced by Layer(), get_extruder_id(), make_perimeters(), object(), and object().

m_regions

LayerRegionPtrs Slic3r::Layer::m_regions

private

Referenced by ~Layer(), add_region(), any_bottom_region_slice_contains(), any_internal_region_slice_contains(), Slic3r::PrintObject::apply_conical_overhang(), backup_untyped_slices(), Slic3r::PrintObject::clip_fill_surfaces(), Slic3r::PrintObject::discover_vertical_shells(), empty(), export_region_fill_surfaces_to_svg(), export_region_slices_to_svg(), generate_sparse_infill_polylines_for_anchoring(), get_region(), get_region(), get_sparse_infill_max_void_area(), has_extrusions(), make_fills(), make_ironing(), make_perimeters(), make_slices(), merged(), region_count(), regions(), restore_untyped_slices(), restore_untyped_slices_no_extra_perimeters(), simplify_infill_extrusion_path(), and simplify_wall_extrusion_path().

print_z

coordf_t Slic3r::Layer::print_z

Referenced by Layer(), Slic3r::SupportLayer::SupportLayer(), Slic3r::TreeSupport3D::TreeModelVolumes::TreeModelVolumes(), Slic3r::GCode::_do_export(), Slic3r::Print::_make_skirt(), Slic3r::GCode::belt_layer_past_first_layer_band(), Slic3r::PrintObjectSupportMaterial::bottom_contact_layers_and_layer_support_areas(), Slic3r::GCode::collect_layers_to_print(), Slic3r::TimelapsePosPicker::collect_limit_areas_for_rod(), Slic3r::TimelapsePosPicker::collect_object_slices_data(), Slic3r::contour_extrusion_path(), Slic3r::convert_layer_region_from_json(), Slic3r::detect_belt_floor_bottom_contacts(), Slic3r::detect_bottom_contacts(), Slic3r::detect_contacts(), Slic3r::PrintObject::discover_horizontal_shells(), Slic3r::PrintObject::discover_vertical_shells(), Slic3r::extract_support_layer(), generate_sparse_infill_polylines_for_anchoring(), Slic3r::generate_support_toolpaths(), Slic3r::get_boundary(), Slic3r::get_boundary_external(), Slic3r::TimelapsePosPicker::get_is_clear_to_x0(), Slic3r::get_perimeter_spacing_external(), Slic3r::TreeSupport::get_trim_support_regions(), Slic3r::TreeSupport3D::group_meshes(), Slic3r::make_belt_brim(), make_fills(), make_ironing(), Slic3r::LayerRegion::make_perimeters(), Slic3r::new_contact_layer(), Slic3r::TimelapsePosPicker::pick_pos_for_all_layer(), Slic3r::OozePrevention::pre_toolchange(), Slic3r::LayerRegion::process_external_surfaces(), Slic3r::project_support_to_grid(), Slic3r::set_mass_locator(), Slic3r::to_json(), Slic3r::PrintObjectSupportMaterial::top_contact_layers(), and Slic3r::PrintObjectSupportMaterial::trim_support_layers_by_object().

sharp_tails

ExPolygons Slic3r::Layer::sharp_tails

mutable

Referenced by Slic3r::detect_contacts(), Slic3r::detect_overhangs(), Slic3r::TreeSupport::get_trim_support_regions(), Slic3r::PrintObjectSupportMaterial::top_contact_layers(), and Slic3r::PrintObjectSupportMaterial::trim_support_layers_by_object().

sharp_tails_height

std::vector<float> Slic3r::Layer::sharp_tails_height

mutable

Referenced by Slic3r::detect_overhangs(), and Slic3r::PrintObjectSupportMaterial::top_contact_layers().

slice_z

coordf_t Slic3r::Layer::slice_z

Referenced by Layer(), Slic3r::SupportLayer::SupportLayer(), Slic3r::contour_extrusion_path(), Slic3r::SeamPlacer::find_seam_string(), Slic3r::PreciseSeam::detail::fragment_location(), new_layers, and Slic3r::SeamPlacer::place_seam().

slicing_errors

bool Slic3r::Layer::slicing_errors

Referenced by Layer().

upper_layer

Layer* Slic3r::Layer::upper_layer

Referenced by Layer(), ~Layer(), Slic3r::PrintObject::apply_conical_overhang(), Slic3r::LayerRegion::make_perimeters(), new_layers, Slic3r::TreeSupport::plan_layer_heights(), and Slic3r::sync_gap_with_object_layer().

---

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/ContourZ.cpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Fill/Fill.cpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Layer.cpp