Slic3r::Layer Class Reference

#include <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 (FillAdaptive::Octree *adaptive_fill_octree, FillAdaptive::Octree *support_fill_octree, FillLightning::Generator *lightning_generator)
Polylines	generate_sparse_infill_polylines_for_anchoring (FillAdaptive::Octree *adaptive_fill_octree, FillAdaptive::Octree *support_fill_octree, FillLightning::Generator *lightning_generator) const
void	make_ironing ()
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

Static Public Member Functions
static void	build_up_down_graph (Layer &below, Layer &above)

Public Attributes
Layer *	upper_layer
Layer *	lower_layer
coordf_t	slice_z
coordf_t	print_z
coordf_t	height
CurledLines	curled_lines
ExPolygons	lslices
std::vector< size_t >	lslice_indices_sorted_by_print_order
LayerSlices	lslices_ex

Protected Member Functions
	Layer (size_t id, PrintObject *object, coordf_t height, coordf_t print_z, coordf_t slice_z)
virtual	~Layer ()
void	clear_fills ()

Private Member Functions
void	sort_perimeters_into_islands (const SurfaceCollection &slices, const uint32_t region_id, const std::vector< std::pair< ExtrusionRange, ExtrusionRange > > &perimeter_and_gapfill_ranges, ExPolygons &&fill_expolygons, const std::vector< ExPolygonRange > &fill_expolygons_ranges, const std::vector< uint32_t > &layer_region_ids)

Private Attributes
size_t	m_id
PrintObject *	m_object
LayerRegionPtrs	m_regions

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

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) {}

~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->m_raw_slices = to_expolygons(layerm->slices().surfaces);
    } else {
        assert(m_regions.size() == 1);
        m_regions.front()->m_raw_slices.clear();
    }
}

References Slic3r::layer_needs_raw_backup(), 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; }

References height.

Referenced by Slic3r::SupportSpotsGenerator::check_stability(), Slic3r::PrintObject::discover_vertical_shells(), and Slic3r::new_contact_layer().

Here is the caller graph for this function:

build_up_down_graph()

void Slic3r::Layer::build_up_down_graph ( Layer &  below, Layer &  above  )

static

{
    coord_t             paths_below_offset = 0;
    ClipperLib_Z::Paths paths_below = expolygons_to_zpaths_shrunk(below.lslices, paths_below_offset);
    coord_t             paths_above_offset = paths_below_offset + coord_t(below.lslices.size());
    ClipperLib_Z::Paths paths_above = expolygons_to_zpaths_shrunk(above.lslices, paths_above_offset);
#ifndef NDEBUG
    coord_t             paths_end = paths_above_offset + coord_t(above.lslices.size());
#endif // NDEBUG
 
    ClipperLib_Z::Clipper  clipper;
    ClipperLib_Z::PolyTree result;
    ClipperZUtils::ClipperZIntersectionVisitor::Intersections intersections;
    ClipperZUtils::ClipperZIntersectionVisitor visitor(intersections);
    clipper.ZFillFunction(visitor.clipper_callback());
    clipper.AddPaths(paths_below, ClipperLib_Z::ptSubject, true);
    clipper.AddPaths(paths_above, ClipperLib_Z::ptClip, true);
    clipper.Execute(ClipperLib_Z::ctIntersection, result, ClipperLib_Z::pftNonZero, ClipperLib_Z::pftNonZero);
 
    connect_layer_slices(below, above, result, intersections, paths_below_offset, paths_above_offset
#ifndef NDEBUG
        , paths_end
#endif // NDEBUG
        );
}

References Slic3r::ClipperZUtils::ClipperZIntersectionVisitor::clipper_callback(), Slic3r::connect_layer_slices(), Slic3r::expolygons_to_zpaths_shrunk(), and lslices.

Here is the call graph for this function:

clear_fills()

void Slic3r::Layer::clear_fills ( )

protected

{
    for (LayerRegion *layerm : m_regions)
        layerm->m_fills.clear();
    for (LayerSlice &lslice : lslices_ex)
    for (LayerIsland &island : lslice.islands)
      island.fills.clear();
}

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::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())
            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())
            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(), 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_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().

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())
            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())
            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(), 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::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().

Here is the call graph for this function:

generate_sparse_infill_polylines_for_anchoring()

Polylines Slic3r::Layer::generate_sparse_infill_polylines_for_anchoring	(	FillAdaptive::Octree *	adaptive_fill_octree,
		FillAdaptive::Octree *	support_fill_octree,
		FillLightning::Generator *	lightning_generator
	)		const

{
    std::vector<SurfaceFill>  surface_fills = group_fills(*this);
    const Slic3r::BoundingBox bbox          = this->object()->bounding_box();
    const auto                resolution    = this->object()->print()->config().gcode_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 ipEnsuring: continue; break;
        case ipLightning:
    case ipAdaptiveCubic:
        case ipSupportCubic:
        case ipRectilinear:
        case ipMonotonic:
        case ipMonotonicLines:
        case ipAlignedRectilinear:
        case ipGrid:
        case ipTriangles:
        case ipStars:
        case ipCubic:
        case ipLine:
        case ipConcentric:
        case ipHoneycomb:
        case ip3DHoneycomb:
        case ipGyroid:
        case ipHilbertCurve:
        case ipArchimedeanChords:
        case ipOctagramSpiral: break;
        }
 
        // Create the filler object.
        std::unique_ptr<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.
        f->z        = this->print_z;
        f->angle    = surface_fill.params.angle;
        f->adapt_fill_octree   = (surface_fill.params.pattern == ipSupportCubic) ? support_fill_octree : adaptive_fill_octree;
        f->print_config        = &this->object()->print()->config();
        f->print_object_config = &this->object()->config();
 
        if (surface_fill.params.pattern == ipLightning)
            dynamic_cast<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
        }
 
        // 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_(surface_fill.params.flow.nozzle_diameter()) * LOOP_CLIPPING_LENGTH_OVER_NOZZLE_DIAMETER);
 
        LayerRegion &layerm = *m_regions[surface_fill.region_id];
 
        // apply half spacing using this flow's own spacing and generate infill
        FillParams params;
        params.density           = float(0.01 * surface_fill.params.density);
        params.dont_adjust       = false; //  surface_fill.params.dont_adjust;
        params.anchor_length     = surface_fill.params.anchor_length;
        params.anchor_length_max = surface_fill.params.anchor_length_max;
        params.resolution        = resolution;
        params.use_arachne       = false;
        params.layer_height      = layerm.layer()->height;
 
        for (ExPolygon &expoly : surface_fill.expolygons) {
            // Spacing is modified by the filler to indicate adjustments. Reset it for each expolygon.
            f->spacing                     = surface_fill.params.spacing;
            surface_fill.surface.expolygon = std::move(expoly);
            try {
                Polylines polylines = f->fill_surface(&surface_fill.surface, params);
                sparse_infill_polylines.insert(sparse_infill_polylines.end(), polylines.begin(), polylines.end());
            } catch (InfillFailedException &) {}
        }
    }
 
    return sparse_infill_polylines;
}

References Slic3r::FillParams::anchor_length, Slic3r::FillParams::anchor_length_max, Slic3r::FillParams::density, Slic3r::FillParams::dont_adjust, Slic3r::group_fills(), height, Slic3r::ip3DHoneycomb, Slic3r::ipAdaptiveCubic, Slic3r::ipAlignedRectilinear, Slic3r::ipArchimedeanChords, Slic3r::ipConcentric, Slic3r::ipCount, Slic3r::ipCubic, Slic3r::ipEnsuring, Slic3r::ipGrid, Slic3r::ipGyroid, Slic3r::ipHilbertCurve, Slic3r::ipHoneycomb, Slic3r::ipLightning, Slic3r::ipLine, Slic3r::ipMonotonic, Slic3r::ipMonotonicLines, Slic3r::ipOctagramSpiral, Slic3r::ipRectilinear, Slic3r::ipStars, Slic3r::ipSupportBase, Slic3r::ipSupportCubic, Slic3r::ipTriangles, Slic3r::LayerRegion::layer(), Slic3r::FillParams::layer_height, LOOP_CLIPPING_LENGTH_OVER_NOZZLE_DIAMETER, Slic3r::FillParams::resolution, scale_, Slic3r::stInternal, and Slic3r::FillParams::use_arachne.

Here is the call 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::SupportSpotsGenerator::build_object_part_from_slice(), Slic3r::SupportSpotsGenerator::check_stability(), Slic3r::PrintObject::detect_surfaces_type(), Slic3r::insert_fills_into_islands(), and Slic3r::GCode::process_layer_single_object().

Here is the caller 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::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 Slic3r::OozePrevention::_get_temp(), Slic3r::avoid_perimeters(), Slic3r::SupportSpotsGenerator::build_object_part_from_slice(), Slic3r::PrintObject::combine_infill(), Slic3r::LayerRegion::flow(), Slic3r::group_fills(), Slic3r::layer_needs_raw_backup(), Slic3r::LayerRegion::make_perimeters(), Slic3r::new_contact_layer(), Slic3r::GCode::on_first_layer(), Slic3r::SeamPlacer::place_seam(), Slic3r::GCode::process_layer(), Slic3r::GCode::process_layer_single_object(), set_id(), and Slic3r::PrintObject::slice_volumes().

Here is the caller graph for this function:

make_fills() [1/2]

void Slic3r::Layer::make_fills ( )

inline

{ this->make_fills(nullptr, nullptr, nullptr); }

References make_fills().

Referenced by 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	(	FillAdaptive::Octree *	adaptive_fill_octree,
		FillAdaptive::Octree *	support_fill_octree,
		FillLightning::Generator *	lightning_generator
	)

{
  this->clear_fills();
 
#ifdef SLIC3R_DEBUG_SLICE_PROCESSING
//  this->export_region_fill_surfaces_to_svg_debug("10_fill-initial");
#endif /* SLIC3R_DEBUG_SLICE_PROCESSING */
 
    std::vector<SurfaceFill>  surface_fills       = group_fills(*this);
    const Slic3r::BoundingBox bbox                = this->object()->bounding_box();
    const auto                resolution          = this->object()->print()->config().gcode_resolution.value;
    const auto                perimeter_generator = this->object()->config().perimeter_generator;
 
#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 */
 
  size_t first_object_layer_id = this->object()->get_layer(0)->id();
    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);
    // Layer ID is used for orienting the infill in alternating directions.
    // Layer::id() returns layer ID including raft layers, subtract them to make the infill direction independent
    // from raft.
        f->layer_id = this->id() - first_object_layer_id;
        f->z    = this->print_z;
        f->angle  = surface_fill.params.angle;
        f->adapt_fill_octree   = (surface_fill.params.pattern == ipSupportCubic) ? support_fill_octree : adaptive_fill_octree;
        f->print_config        = &this->object()->print()->config();
        f->print_object_config = &this->object()->config();
 
        if (surface_fill.params.pattern == ipLightning)
            dynamic_cast<FillLightning::Filler*>(f.get())->generator = lightning_generator;
 
        if (surface_fill.params.pattern == ipEnsuring) {
            auto *fill_ensuring = dynamic_cast<FillEnsuring *>(f.get());
            assert(fill_ensuring != nullptr);
            fill_ensuring->print_region_config = &m_regions[surface_fill.region_id]->region().config();
        }
 
        // 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
        }
 
        // 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_(surface_fill.params.flow.nozzle_diameter()) * LOOP_CLIPPING_LENGTH_OVER_NOZZLE_DIAMETER);
 
        LayerRegion &layerm = *m_regions[surface_fill.region_id];
 
        // 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       = (perimeter_generator == PerimeterGeneratorType::Arachne && surface_fill.params.pattern == ipConcentric) || surface_fill.params.pattern == ipEnsuring;
        params.layer_height      = layerm.layer()->height;
 
        for (ExPolygon &expoly : surface_fill.expolygons) {
      // Spacing is modified by the filler to indicate adjustments. Reset it for each expolygon.
      f->spacing = surface_fill.params.spacing;
      surface_fill.surface.expolygon = std::move(expoly);
            Polylines      polylines;
            ThickPolylines thick_polylines;
      try {
                if (params.use_arachne)
                    thick_polylines = f->fill_surface_arachne(&surface_fill.surface, params);
                else
            polylines = f->fill_surface(&surface_fill.surface, params);
      } catch (InfillFailedException &) {
      }
            if (!polylines.empty() || !thick_polylines.empty()) {
                // calculate actual flow from spacing (which might have been adjusted by the infill
            // pattern generator)
            double flow_mm3_per_mm = surface_fill.params.flow.mm3_per_mm();
            double flow_width      = surface_fill.params.flow.width();
            if (using_internal_flow) {
                // if we used the internal flow we're not doing a solid infill
                // so we can safely ignore the slight variation that might have
                // been applied to f->spacing
            } else {
                Flow new_flow   = surface_fill.params.flow.with_spacing(float(f->spacing));
              flow_mm3_per_mm = new_flow.mm3_per_mm();
              flow_width      = new_flow.width();
            }
            // Save into layer.
        ExtrusionEntityCollection* eec = nullptr;
        auto fill_begin = uint32_t(layerm.fills().size());
            layerm.m_fills.entities.push_back(eec = new ExtrusionEntityCollection());
            // Only concentric fills are not sorted.
            eec->no_sort = f->no_sort();
                if (params.use_arachne) {
                    for (const ThickPolyline &thick_polyline : thick_polylines) {
                        Flow new_flow = surface_fill.params.flow.with_spacing(float(f->spacing));
 
                        ExtrusionMultiPath multi_path = PerimeterGenerator::thick_polyline_to_multi_path(thick_polyline, surface_fill.params.extrusion_role, new_flow, scaled<float>(0.05), float(SCALED_EPSILON));
                        // Append paths to collection.
                        if (!multi_path.empty()) {
                            if (multi_path.paths.front().first_point() == multi_path.paths.back().last_point())
                                eec->entities.emplace_back(new ExtrusionLoop(std::move(multi_path.paths)));
                            else
                                eec->entities.emplace_back(new ExtrusionMultiPath(std::move(multi_path)));
                        }
                    }
 
                    thick_polylines.clear();
                } else {
                    extrusion_entities_append_paths(
                        eec->entities, std::move(polylines),
                        surface_fill.params.extrusion_role,
                        flow_mm3_per_mm, float(flow_width), surface_fill.params.flow.height());
                }
                insert_fills_into_islands(*this, uint32_t(surface_fill.region_id), fill_begin, uint32_t(layerm.fills().size()));
        }
    }
    }
 
  for (LayerSlice &lslice : this->lslices_ex)
    for (LayerIsland &island : lslice.islands) {
      if (! island.thin_fills.empty()) {
        // Copy thin fills into fills packed as a collection.
        // Fills are always stored as collections, the rest of the pipeline (wipe into infill, G-code generator) relies on it.
        LayerRegion         &layerm   = *this->get_region(island.perimeters.region());
        ExtrusionEntityCollection &collection = *(new ExtrusionEntityCollection());
        layerm.m_fills.entities.push_back(&collection);
        collection.entities.reserve(island.thin_fills.size());
        for (uint32_t fill_id : island.thin_fills)
          collection.entities.push_back(layerm.thin_fills().entities[fill_id]->clone());
          island.add_fill_range({ island.perimeters.region(), { uint32_t(layerm.m_fills.entities.size() - 1), uint32_t(layerm.m_fills.entities.size()) } });
      }
      // Sort the fills by region ID.
      std::sort(island.fills.begin(), island.fills.end(), [](auto &l, auto &r){ return l.region() < r.region() || (l.region() == r.region() && *l.begin() < *r.begin()); });
      // Compress continuous fill ranges of the same region.
      {
        size_t k = 0;
        for (size_t i = 0; i < island.fills.size();) {
          uint32_t region_id = island.fills[i].region();
          uint32_t begin     = *island.fills[i].begin();
          uint32_t end       = *island.fills[i].end();
          size_t   j         = i + 1;
          for (; j < island.fills.size() && island.fills[j].region() == region_id && *island.fills[j].begin() == end; ++ j)
            end = *island.fills[j].end();
          island.fills[k ++] = { region_id, { begin, end } };
          i = j;
        }
        island.fills.erase(island.fills.begin() + k, island.fills.end());
      }
    }
 
#ifndef NDEBUG
  for (LayerRegion *layerm : m_regions)
      for (const ExtrusionEntity *e : layerm->fills())
          assert(dynamic_cast<const ExtrusionEntityCollection*>(e) != nullptr);
#endif
}

References Slic3r::FillParams::anchor_length, Slic3r::FillParams::anchor_length_max, Slic3r::debug_out_path(), Slic3r::FillParams::density, Slic3r::FillParams::dont_adjust, Slic3r::ExtrusionMultiPath::empty(), Slic3r::ExtrusionEntityCollection::entities, Slic3r::extrusion_entities_append_paths(), Slic3r::LayerRegion::fills(), Slic3r::group_fills(), height, Slic3r::insert_fills_into_islands(), Slic3r::ipConcentric, Slic3r::ipEnsuring, Slic3r::ipLightning, Slic3r::ipSupportCubic, Slic3r::LayerRegion::layer(), Slic3r::FillParams::layer_height, LOOP_CLIPPING_LENGTH_OVER_NOZZLE_DIAMETER, Slic3r::LayerRegion::m_fills, Slic3r::Flow::mm3_per_mm(), Slic3r::ExtrusionEntityCollection::no_sort, Slic3r::ExtrusionMultiPath::paths, Slic3r::FillParams::resolution, scale_, SCALED_EPSILON, Slic3r::ExtrusionEntityCollection::size(), Slic3r::LayerRegion::thin_fills(), Slic3r::FillParams::use_arachne, Slic3r::Flow::width(), and Slic3r::Flow::with_spacing().

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 {
    int     extruder  = -1;
    bool    just_infill = false;
    // Spacing of the ironing lines, also to calculate the extrusion flow from.
    double    line_spacing;
    // Height of the extrusion, to calculate the extrusion flow from.
    double    height;
    double    speed;
    double    angle;
 
    bool operator<(const IroningParams &rhs) const {
      if (this->extruder < rhs.extruder)
        return true;
      if (this->extruder > rhs.extruder)
        return false;
      if (int(this->just_infill) < int(rhs.just_infill))
        return true;
      if (int(this->just_infill) > int(rhs.just_infill))
        return false;
      if (this->line_spacing < rhs.line_spacing)
        return true;
      if (this->line_spacing > rhs.line_spacing)
        return false;
      if (this->height < rhs.height)
        return true;
      if (this->height > rhs.height)
        return false;
      if (this->speed < rhs.speed)
        return true;
      if (this->speed > rhs.speed)
        return false;
      if (this->angle < rhs.angle)
        return true;
      if (this->angle > rhs.angle)
        return false;
      return false;
    }
 
    bool operator==(const IroningParams &rhs) const {
      return this->extruder == rhs.extruder && this->just_infill == rhs.just_infill &&
           this->line_spacing == rhs.line_spacing && this->height == rhs.height && this->speed == rhs.speed &&
           this->angle == rhs.angle;
    }
 
    LayerRegion *layerm;
    uint32_t     region_id;
 
    // 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 (uint32_t region_id = 0; region_id < uint32_t(this->regions().size()); ++region_id)
    if (LayerRegion *layerm = this->get_region(region_id); ! layerm->slices().empty()) {
      IroningParams ironing_params;
      const PrintRegionConfig &config = layerm->region().config();
      if (config.ironing && 
        (config.ironing_type == IroningType::AllSolid ||
          (config.top_solid_layers > 0 && 
            (config.ironing_type == IroningType::TopSurfaces ||
            (config.ironing_type == IroningType::TopmostOnly && layerm->layer()->upper_layer == nullptr))))) {
        if (config.perimeter_extruder == config.solid_infill_extruder || config.perimeters == 0) {
          // Iron the whole face.
          ironing_params.extruder = config.solid_infill_extruder;
        } else {
          // Iron just the infill.
          ironing_params.extruder = config.solid_infill_extruder;
        }
      }
      if (ironing_params.extruder != -1) {
        //TODO just_infill is currently not used.
        ironing_params.just_infill  = false;
        ironing_params.line_spacing = config.ironing_spacing;
        ironing_params.height     = default_layer_height * 0.01 * config.ironing_flowrate;
        ironing_params.speed    = config.ironing_speed;
        ironing_params.angle    = config.fill_angle * M_PI / 180.;
        ironing_params.layerm     = layerm;
        ironing_params.region_id    = region_id;
        by_extruder.emplace_back(ironing_params);
      }
    }
  std::sort(by_extruder.begin(), by_extruder.end());
 
    FillRectilinear   fill;
    FillParams      fill_params;
  fill.set_bounding_box(this->object()->bounding_box());
  // Layer ID is used for orienting the infill in alternating directions.
  // Layer::id() returns layer ID including raft layers, subtract them to make the infill direction independent
  // from raft.
  //FIXME ironing does not take fill angle into account. Shall it? Does it matter?
  fill.layer_id        = this->id() - this->object()->get_layer(0)->id();
    fill.z           = this->print_z;
    fill.overlap       = 0;
    fill_params.density    = 1.;
    fill_params.monotonic    = true;
 
  for (size_t i = 0; i < by_extruder.size();) {
    // Find span of regions equivalent to the ironing operation.
    IroningParams &ironing_params = by_extruder[i];
    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 = this->object()->print()->config().nozzle_diameter.values[ironing_params.extruder - 1];
    if (ironing_params.just_infill) {
      //TODO just_infill is currently not used.
      // Just infill.
    } else {
      // Infill and perimeter.
      // Merge top surfaces with the same ironing parameters.
      Polygons polys;
      Polygons infills;
      for (size_t k = i; k < j; ++ k) {
        const IroningParams    &ironing_params  = by_extruder[k];
        const PrintRegionConfig  &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.fill_density.value > 95.;
          for (const Surface &surface : ironing_params.layerm->fill_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())
            polygons_append(polys, surface.expolygon);
        } else {
          for (const Surface &surface : ironing_params.layerm->slices())
            if (surface.surface_type == stTop || (iron_everything && surface.surface_type == stBottom))
              // 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())
            if (surface.surface_type == stInternalSolid)
              polygons_append(infills, surface.expolygon);
        }
      }
 
      if (! infills.empty() || j > i + 1) {
        // Ironing over more than a single region or over solid internal infill.
        if (! infills.empty())
          // For IroningType::AllSolid only:
          // Add solid infill areas for layers, that contain some non-ironable infil (sparse infill, bridge infill).
          append(polys, std::move(infills));
        polys = union_safety_offset(polys);
      }
      // Trim the top surfaces with half the nozzle diameter.
      ironing_areas = intersection_ex(polys, offset(this->lslices, - float(scale_(0.5 * nozzle_dmr))));
    }
 
        // Create the filler object.
        fill.spacing = ironing_params.line_spacing;
        fill.angle = float(ironing_params.angle + 0.25 * M_PI);
        fill.link_max_length = (coord_t)scale_(3. * fill.spacing);
    double extrusion_height = ironing_params.height * fill.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 {
                assert(!fill_params.use_arachne);
        polylines = fill.fill_surface(&surface_fill, fill_params);
      } catch (InfillFailedException &) {
      }
          if (! polylines.empty()) {
            // Save into layer.
        auto fill_begin = uint32_t(ironing_params.layerm->fills().size());
        ExtrusionEntityCollection *eec = nullptr;
            ironing_params.layerm->m_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),
          ExtrusionRole::Ironing,
                flow_mm3_per_mm, extrusion_width, float(extrusion_height));
        insert_fills_into_islands(*this, ironing_params.region_id, fill_begin, uint32_t(ironing_params.layerm->fills().size()));
        }
    }
 
    // Regions up to j were processed.
    i = j;
  }
}

References Slic3r::Fill::angle, Slic3r::angle(), Slic3r::FillParams::density, Slic3r::SurfaceCollection::empty(), Slic3r::ExtrusionEntityCollection::entities, Slic3r::Surface::expolygon, Slic3r::extrusion_entities_append_paths(), Slic3r::FillRectilinear::fill_surface(), Slic3r::insert_fills_into_islands(), Slic3r::intersection_ex(), Slic3r::Fill::layer_id, Slic3r::Fill::link_max_length, M_PI, Slic3r::FillParams::monotonic, Slic3r::ExtrusionEntityCollection::no_sort, Slic3r::Fill::overlap, Slic3r::polygons_append(), Slic3r::PrintRegionConfig, scale_, Slic3r::Fill::set_bounding_box(), Slic3r::LayerRegion::slices(), Slic3r::Fill::spacing, Slic3r::stBottom, Slic3r::stInternal, Slic3r::stInternalBridge, Slic3r::stInternalSolid, Slic3r::stInternalVoid, Slic3r::stTop, Slic3r::union_safety_offset(), Slic3r::FillParams::use_arachne, and Slic3r::Fill::z.

Here is the call graph for this function:

make_perimeters()

void Slic3r::Layer::make_perimeters

(

)

{
    BOOST_LOG_TRIVIAL(trace) << "Generating perimeters for layer " << this->id();
    
    // keep track of regions whose perimeters we have already generated
    std::vector<unsigned char>                              done(m_regions.size(), false);
    std::vector<uint32_t>                                   layer_region_ids;
    std::vector<std::pair<ExtrusionRange, ExtrusionRange>>  perimeter_and_gapfill_ranges;
    ExPolygons                                              fill_expolygons;
    std::vector<ExPolygonRange>                             fill_expolygons_ranges;
    SurfacesPtr                                             surfaces_to_merge;
    SurfacesPtr                                             surfaces_to_merge_temp;
 
    auto layer_region_reset_perimeters = [](LayerRegion &layerm) {
        layerm.m_perimeters.clear();
        layerm.m_fills.clear();
        layerm.m_thin_fills.clear();
        layerm.m_fill_expolygons.clear();
        layerm.m_fill_expolygons_bboxes.clear();
        layerm.m_fill_expolygons_composite.clear();
        layerm.m_fill_expolygons_composite_bboxes.clear();
    };
 
    // Remove layer islands, remove references to perimeters and fills from these layer islands to LayerRegion ExtrusionEntities.
    for (LayerSlice &lslice : this->lslices_ex)
        lslice.islands.clear();
 
    for (LayerRegionPtrs::iterator layerm = m_regions.begin(); layerm != m_regions.end(); ++ layerm)
        if (size_t region_id = layerm - m_regions.begin(); ! done[region_id]) {
            layer_region_reset_perimeters(**layerm);
            if (! (*layerm)->slices().empty()) {
              BOOST_LOG_TRIVIAL(trace) << "Generating perimeters for layer " << this->id() << ", region " << region_id;
              done[region_id] = true;
              const PrintRegionConfig &config = (*layerm)->region().config();
              
                perimeter_and_gapfill_ranges.clear();
                fill_expolygons.clear();
                fill_expolygons_ranges.clear();
                surfaces_to_merge.clear();
 
              // find compatible regions
                layer_region_ids.clear();
              layer_region_ids.push_back(region_id);
              for (LayerRegionPtrs::const_iterator it = layerm + 1; it != m_regions.end(); ++it)
                  if (! (*it)->slices().empty()) {
                        LayerRegion             *other_layerm                         = *it;
                        const PrintRegionConfig &other_config                         = other_layerm->region().config();
                        bool                     dynamic_overhang_speed_compatibility = config.enable_dynamic_overhang_speeds ==
                                                                    other_config.enable_dynamic_overhang_speeds;
                        if (dynamic_overhang_speed_compatibility && config.enable_dynamic_overhang_speeds) {
                            dynamic_overhang_speed_compatibility = config.overhang_speed_0 == other_config.overhang_speed_0 &&
                                                                   config.overhang_speed_1 == other_config.overhang_speed_1 &&
                                                                   config.overhang_speed_2 == other_config.overhang_speed_2 &&
                                                                   config.overhang_speed_3 == other_config.overhang_speed_3;
                        }
 
                        if (config.perimeter_extruder             == other_config.perimeter_extruder
                        && config.perimeters                  == other_config.perimeters
                        && config.perimeter_speed             == other_config.perimeter_speed
                        && config.external_perimeter_speed    == other_config.external_perimeter_speed
                            && dynamic_overhang_speed_compatibility
                        && (config.gap_fill_enabled ? config.gap_fill_speed.value : 0.) == 
                               (other_config.gap_fill_enabled ? other_config.gap_fill_speed.value : 0.)
                        && config.overhangs                   == other_config.overhangs
                        && config.opt_serialize("perimeter_extrusion_width") == other_config.opt_serialize("perimeter_extrusion_width")
                        && config.thin_walls                  == other_config.thin_walls
                        && config.external_perimeters_first   == other_config.external_perimeters_first
                        && config.infill_overlap              == other_config.infill_overlap
                            && config.fuzzy_skin                  == other_config.fuzzy_skin
                            && config.fuzzy_skin_thickness        == other_config.fuzzy_skin_thickness
                            && config.fuzzy_skin_point_dist       == other_config.fuzzy_skin_point_dist)
                    {
                            layer_region_reset_perimeters(*other_layerm);
                        layer_region_ids.push_back(it - m_regions.begin());
                        done[it - m_regions.begin()] = true;
                    }
                }
 
              if (layer_region_ids.size() == 1) {  // optimization
                  (*layerm)->make_perimeters((*layerm)->slices(), perimeter_and_gapfill_ranges, fill_expolygons, fill_expolygons_ranges);
                    this->sort_perimeters_into_islands((*layerm)->slices(), region_id, perimeter_and_gapfill_ranges, std::move(fill_expolygons), fill_expolygons_ranges, layer_region_ids);
              } else {
                  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.
                    uint32_t     region_id_config = layer_region_ids.front();
                    LayerRegion* layerm_config = m_regions[region_id_config];
                    {
                      // Merge slices (surfaces) according to number of extra perimeters.
                      for (uint32_t region_id : layer_region_ids) {
                            LayerRegion &layerm = *m_regions[region_id];
                          for (const Surface &surface : layerm.slices())
                                surfaces_to_merge.emplace_back(&surface);
                            if (layerm.region().config().fill_density > layerm_config->region().config().fill_density) {
                                region_id_config = region_id;
                                layerm_config    = &layerm;
                            }
                      }
                        std::sort(surfaces_to_merge.begin(), surfaces_to_merge.end(), [](const Surface *l, const Surface *r){ return l->extra_perimeters < r->extra_perimeters; });
                        for (size_t i = 0; i < surfaces_to_merge.size();) {
                            size_t j = i;
                            const Surface &first = *surfaces_to_merge[i];
                            size_t extra_perimeters = first.extra_perimeters;
                            for (; j < surfaces_to_merge.size() && surfaces_to_merge[j]->extra_perimeters == extra_perimeters; ++ j) ;
                            if (i + 1 == j)
                                // Nothing to merge, just copy.
                                new_slices.surfaces.emplace_back(*surfaces_to_merge[i]);
                            else {
                                surfaces_to_merge_temp.assign(surfaces_to_merge.begin() + i, surfaces_to_merge.begin() + j);
                                new_slices.append(offset_ex(surfaces_to_merge_temp, ClipperSafetyOffset), first);
                            }
                            i = j;
                        }
                  }
                  // make perimeters
                  layerm_config->make_perimeters(new_slices, perimeter_and_gapfill_ranges, fill_expolygons, fill_expolygons_ranges);
                    this->sort_perimeters_into_islands(new_slices, region_id_config, perimeter_and_gapfill_ranges, std::move(fill_expolygons), fill_expolygons_ranges, layer_region_ids);
              }
          }
        }
    BOOST_LOG_TRIVIAL(trace) << "Generating perimeters for layer " << this->id() << " - Done";
}

References Slic3r::SurfaceCollection::append(), Slic3r::PrintRegion::config(), done, Slic3r::Surface::extra_perimeters, Slic3r::LayerRegion::make_perimeters(), Slic3r::offset_ex(), Slic3r::PrintRegionConfig, Slic3r::LayerRegion::region(), Slic3r::LayerRegion::slices(), and Slic3r::SurfaceCollection::surfaces.

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);
        }
        // lslices are sorted by topological order from outside to inside from the clipper union used above
        this->lslices = slices;
    }
 
    this->lslice_indices_sorted_by_print_order = chain_expolygons(this->lslices);
}

References Slic3r::chain_expolygons(), lslice_indices_sorted_by_print_order, 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_solid_layers > 0 || config.top_solid_layers > 0 || config.fill_density > 0. || config.perimeters > 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 EPSILON, Slic3r::offset_ex(), Slic3r::PrintRegionConfig, and Slic3r::union_ex().

Here is the call graph for this function:

object() [1/2]

PrintObject * Slic3r::Layer::object ( )

inline

{ return m_object; }

References m_object.

Referenced by Slic3r::GUI::GLCanvas3D::_load_print_object_toolpaths(), Slic3r::LayerRegion::bridging_flow(), Slic3r::LayerRegion::flow(), 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::layer_needs_raw_backup(), Slic3r::LayerRegion::make_perimeters(), Slic3r::GCode::ObjectLayerToPrint::object(), Slic3r::SeamPlacer::place_seam(), Slic3r::ExtrusionQualityEstimator::prepare_for_new_layer(), and Slic3r::GCode::process_layer().

Here is the caller graph for this function:

object() [2/2]

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

inline

{ return m_object; }

References m_object.

region_count()

size_t Slic3r::Layer::region_count ( ) const

inline

{ return m_regions.size(); }

References m_regions.

Referenced by Slic3r::FFFTreeSupport::generate_overhangs().

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::GUI::GLCanvas3D::_load_print_object_toolpaths(), Slic3r::PrintObject::bridge_over_infill(), Slic3r::collect_region_slices_by_type(), 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::FFFTreeSupport::generate_overhangs(), Slic3r::FillLightning::Generator::generateInitialInternalOverhangs(), Slic3r::FillLightning::Generator::generateTrees(), Slic3r::get_boundary(), Slic3r::get_external_perimeter_width(), Slic3r::get_perimeter_spacing(), Slic3r::group_fills(), Slic3r::SupportMaterialInternal::has_bridging_extrusions(), Slic3r::layer_needs_raw_backup(), Slic3r::WipingExtrusions::mark_wiping_extrusions(), Slic3r::mmu_segmentation_top_and_bottom_layers(), Slic3r::new_contact_layer(), Slic3r::PrintObject::process_external_surfaces(), Slic3r::GCode::process_layer(), and Slic3r::RetractWhenCrossingPerimeters::travel_inside_internal_regions().

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->m_slices.set(layerm->m_raw_slices, stInternal);
    } else {
        assert(m_regions.size() == 1);
        m_regions.front()->m_slices.set(this->lslices, stInternal);
    }
}

References Slic3r::layer_needs_raw_backup(), 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)
          if (! layerm->region().config().extra_perimeters.value)
              layerm->m_slices.set(layerm->m_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->m_slices.set(this->lslices, stInternal);
    }
}

References Slic3r::layer_needs_raw_backup(), Slic3r::LayerRegion::m_slices, Slic3r::SurfaceCollection::set(), 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:

sort_perimeters_into_islands()

void Slic3r::Layer::sort_perimeters_into_islands ( const SurfaceCollection &  slices, const uint32_t  region_id, const std::vector< std::pair< ExtrusionRange, ExtrusionRange > > &  perimeter_and_gapfill_ranges, ExPolygons &&  fill_expolygons, const std::vector< ExPolygonRange > &  fill_expolygons_ranges, const std::vector< uint32_t > &  layer_region_ids  )

private

{
    assert(perimeter_and_gapfill_ranges.size() == fill_expolygons_ranges.size());
    assert(! layer_region_ids.empty());
 
    LayerRegion &this_layer_region = *m_regions[region_id];
 
    // Bounding boxes of fill_expolygons.
    BoundingBoxes fill_expolygons_bboxes;
    fill_expolygons_bboxes.reserve(fill_expolygons.size());
    for (const ExPolygon &expolygon : fill_expolygons)
        fill_expolygons_bboxes.emplace_back(get_extents(expolygon));
 
    // Take one sample point for each source slice, to be used to sort source slices into layer slices.
    // source slice index + its sample.
    std::vector<std::pair<uint32_t, Point>> perimeter_slices_queue;
    perimeter_slices_queue.reserve(slices.size());
    for (uint32_t islice = 0; islice < uint32_t(slices.size()); ++ islice) {
        const std::pair<ExtrusionRange, ExtrusionRange> &extrusions = perimeter_and_gapfill_ranges[islice];
        Point sample;
        bool  sample_set = false;
        // Take a sample deep inside its island if available. Infills are usually quite far from the island boundary.
        for (uint32_t iexpoly : fill_expolygons_ranges[islice])
            if (const ExPolygon &expoly = fill_expolygons[iexpoly]; ! expoly.empty()) {
                sample     = expoly.contour.points[expoly.contour.points.size() / 2];
                sample_set = true;
                break;
            }
        if (! sample_set) {
            // If there is no infill, take a sample of some inner perimeter.
            for (uint32_t iperimeter : extrusions.first) {
                const ExtrusionEntity &ee = *this_layer_region.perimeters().entities[iperimeter];
                if (ee.is_collection()) {
                    for (const ExtrusionEntity *ee2 : dynamic_cast<const ExtrusionEntityCollection&>(ee).entities)
                        if (! ee2->role().is_external()) {
                            sample     = ee2->middle_point();
                            sample_set = true;
                            goto loop_end;
                        }
                } else if (! ee.role().is_external()) {
                    sample = ee.middle_point();
                    sample_set = true;
                    break;
                }
            }
        loop_end:
            if (! sample_set) {
                if (! extrusions.second.empty()) {
                    // If there is no inner perimeter, take a sample of some gap fill extrusion.
                    sample     = this_layer_region.thin_fills().entities[*extrusions.second.begin()]->middle_point();
                    sample_set = true;
                }
                if (! sample_set && ! extrusions.first.empty()) {
                    // As a last resort, take a sample of some external perimeter.
                    sample     = this_layer_region.perimeters().entities[*extrusions.first.begin()]->middle_point();
                    sample_set = true;
                }
            }
        }
        // There may be a valid empty island.
        // assert(sample_set);
        if (sample_set)
            perimeter_slices_queue.emplace_back(islice, sample);
    }
 
    // Map of source fill_expolygon into region and fill_expolygon of that region.
    // -1: not set
    struct RegionWithFillIndex {
        int region_id{ -1 };
        int fill_in_region_id{ -1 };
    };
    std::vector<RegionWithFillIndex> map_expolygon_to_region_and_fill;
    const bool                       has_multiple_regions = layer_region_ids.size() > 1;
    assert(has_multiple_regions || layer_region_ids.size() == 1);
    // assign fill_surfaces to each layer
    if (! fill_expolygons.empty()) {
        if (has_multiple_regions) {
            // Sort the bounding boxes lexicographically.
            std::vector<uint32_t> fill_expolygons_bboxes_sorted(fill_expolygons_bboxes.size());
            std::iota(fill_expolygons_bboxes_sorted.begin(), fill_expolygons_bboxes_sorted.end(), 0);
            std::sort(fill_expolygons_bboxes_sorted.begin(), fill_expolygons_bboxes_sorted.end(), [&fill_expolygons_bboxes](uint32_t lhs, uint32_t rhs){
                const BoundingBox &bbl = fill_expolygons_bboxes[lhs];
                const BoundingBox &bbr = fill_expolygons_bboxes[rhs];
                return bbl.min < bbr.min || (bbl.min == bbr.min && bbl.max < bbr.max);
            });
            map_expolygon_to_region_and_fill.assign(fill_expolygons.size(), {});
            for (uint32_t region_idx : layer_region_ids) {
                LayerRegion &l = *m_regions[region_idx];
                l.m_fill_expolygons = intersection_ex(l.slices().surfaces, fill_expolygons);
                l.m_fill_expolygons_bboxes.reserve(l.fill_expolygons().size());
                for (const ExPolygon &expolygon : l.fill_expolygons()) {
                    BoundingBox bbox = get_extents(expolygon);
                    l.m_fill_expolygons_bboxes.emplace_back(bbox);
                    auto it_bbox = std::lower_bound(fill_expolygons_bboxes_sorted.begin(), fill_expolygons_bboxes_sorted.end(), bbox, [&fill_expolygons_bboxes](uint32_t lhs, const BoundingBox &bbr){
                        const BoundingBox &bbl = fill_expolygons_bboxes[lhs];
                        return bbl.min < bbr.min || (bbl.min == bbr.min && bbl.max < bbr.max);
                    });
                    if (it_bbox != fill_expolygons_bboxes_sorted.end())
                        if (uint32_t fill_id = *it_bbox; fill_expolygons_bboxes[fill_id] == bbox) {
                            // With a very high probability the two expolygons match exactly. Confirm that.
                            if (expolygons_match(expolygon, fill_expolygons[fill_id])) {
                                RegionWithFillIndex &ref = map_expolygon_to_region_and_fill[fill_id];
                                // Only one expolygon produced by intersection with LayerRegion surface may match an expolygon of fill_expolygons.
                                assert(ref.region_id == -1 && ref.fill_in_region_id == -1);
                                ref.region_id         = region_idx;
                                ref.fill_in_region_id = int(&expolygon - l.fill_expolygons().data());
                            }
                        }
                }
            }
            // Check whether any island contains multiple fills that fall into the same region, but not they are not contiguous.
            // If so, sort fills in that particular region so that fills of an island become contiguous.
            // Index of a region to sort.
            int              sort_region_id = -1;
            // Temporary vector of fills for reordering.
            ExPolygons       fills_temp;
            // Vector of new positions of the above.
            std::vector<int> new_positions;
            do {
                sort_region_id = -1;
                for (size_t source_slice_idx = 0; source_slice_idx < fill_expolygons_ranges.size(); ++ source_slice_idx)
                    if (ExPolygonRange fill_range = fill_expolygons_ranges[source_slice_idx]; fill_range.size() > 1) {
                        // More than one expolygon exists for a single island. Check whether they are contiguous inside a single LayerRegion::fill_expolygons() vector.
                        uint32_t fill_idx = *fill_range.begin();
                        if (const int fill_regon_id = map_expolygon_to_region_and_fill[fill_idx].region_id; fill_regon_id != -1) {
                            int fill_in_region_id = map_expolygon_to_region_and_fill[fill_idx].fill_in_region_id;
                            bool needs_sorting = false;
                            for (++ fill_idx; fill_idx != *fill_range.end(); ++ fill_idx) {
                                if (const RegionWithFillIndex &ref = map_expolygon_to_region_and_fill[fill_idx]; ref.region_id != fill_regon_id) {
                                    // This island has expolygons split among multiple regions.
                                    needs_sorting = false;
                                    break;
                                } else if (ref.fill_in_region_id != ++ fill_in_region_id) {
                                    // This island has all expolygons stored inside the same region, but not sorted.
                                    needs_sorting = true;
                                }
                            }
                            if (needs_sorting) {
                                sort_region_id = fill_regon_id;
                                break;
                            }
                        }
                    }
                if (sort_region_id != -1) {
                    // Reorder fills in region with sort_region index.
                    LayerRegion &layerm = *m_regions[sort_region_id];
                    new_positions.assign(layerm.fill_expolygons().size(), -1);
                    int last = 0;
                    for (RegionWithFillIndex &ref : map_expolygon_to_region_and_fill)
                        if (ref.region_id == sort_region_id) {
                            new_positions[ref.fill_in_region_id] = last;
                            ref.fill_in_region_id = last ++;
                        }
                    for (auto &new_pos : new_positions)
                        if (new_pos == -1)
                            // Not referenced by any map_expolygon_to_region_and_fill.
                            new_pos = last ++;
                    // Move just the content of m_fill_expolygons to fills_temp, but don't move the container vector.
                    auto &fills = layerm.m_fill_expolygons;
                    assert(last == int(fills.size()));
                    fills_temp.reserve(fills.size());
                    fills_temp.insert(fills_temp.end(), std::make_move_iterator(fills.begin()), std::make_move_iterator(fills.end()));
                    for (ExPolygon &ex : fills)
                        ex.clear();
                    // Move / reoder the expolygons back into m_fill_expolygons.
                    for (size_t old_pos = 0; old_pos < new_positions.size(); ++ old_pos)
                        fills[new_positions[old_pos]] = std::move(fills_temp[old_pos]);
                }
            } while (sort_region_id != -1);
        } else {
            this_layer_region.m_fill_expolygons        = std::move(fill_expolygons);
            this_layer_region.m_fill_expolygons_bboxes = std::move(fill_expolygons_bboxes);
        }
    }
 
    auto insert_into_island = [
        // Region where the perimeters, gap fills and fill expolygons are stored.
        region_id, 
        // Whether there are infills with different regions generated for this LayerSlice.
        has_multiple_regions,
        // Perimeters and gap fills to be sorted into islands.
        &perimeter_and_gapfill_ranges,
        // Infill regions to be sorted into islands.
        &fill_expolygons, &fill_expolygons_bboxes, &fill_expolygons_ranges,
        // Mapping of fill_expolygon to region and its infill.
        &map_expolygon_to_region_and_fill,
        // Output
        &regions = m_regions, &lslices_ex = this->lslices_ex]
        (int lslice_idx, int source_slice_idx) {
        lslices_ex[lslice_idx].islands.push_back({});
        LayerIsland &island = lslices_ex[lslice_idx].islands.back();
        island.perimeters = LayerExtrusionRange(region_id, perimeter_and_gapfill_ranges[source_slice_idx].first);
        island.thin_fills = perimeter_and_gapfill_ranges[source_slice_idx].second;
        if (ExPolygonRange fill_range = fill_expolygons_ranges[source_slice_idx]; ! fill_range.empty()) {
            if (has_multiple_regions) {
                // Check whether the fill expolygons of this island were split into multiple regions.
                island.fill_region_id = LayerIsland::fill_region_composite_id;
                for (uint32_t fill_idx : fill_range) {
                    if (const int fill_regon_id = map_expolygon_to_region_and_fill[fill_idx].region_id; 
                        fill_regon_id == -1 || (island.fill_region_id != LayerIsland::fill_region_composite_id && int(island.fill_region_id) != fill_regon_id)) {
                        island.fill_region_id = LayerIsland::fill_region_composite_id;
                        break;
                    } else
                        island.fill_region_id = fill_regon_id;
                }
                if (island.fill_expolygons_composite()) {
                    // They were split, thus store the unsplit "composite" expolygons into the region of perimeters.
                    LayerRegion &this_layer_region = *regions[region_id];
                    auto begin = uint32_t(this_layer_region.fill_expolygons_composite().size());
                    this_layer_region.m_fill_expolygons_composite.reserve(this_layer_region.fill_expolygons_composite().size() + fill_range.size());
                    std::move(fill_expolygons.begin() + *fill_range.begin(), fill_expolygons.begin() + *fill_range.end(), std::back_inserter(this_layer_region.m_fill_expolygons_composite));
                    this_layer_region.m_fill_expolygons_composite_bboxes.insert(this_layer_region.m_fill_expolygons_composite_bboxes.end(), 
                        fill_expolygons_bboxes.begin() + *fill_range.begin(), fill_expolygons_bboxes.begin() + *fill_range.end());
                    island.fill_expolygons = ExPolygonRange(begin, uint32_t(this_layer_region.fill_expolygons_composite().size()));
                } else {
                    // All expolygons are stored inside a single LayerRegion in a contiguous range.
                    island.fill_expolygons = ExPolygonRange(
                        map_expolygon_to_region_and_fill[*fill_range.begin()].fill_in_region_id,
                        map_expolygon_to_region_and_fill[*fill_range.end() - 1].fill_in_region_id + 1);
                }
            } else {
                // Layer island is made of one fill region only.
                island.fill_expolygons = fill_range;
                island.fill_region_id  = region_id;
            }
        }
    };
 
    // First sort into islands using exact fit.
    // Traverse the slices in an increasing order of bounding box size, so that the islands inside another islands are tested first,
    // so we can just test a point inside ExPolygon::contour and we may skip testing the holes.
    auto point_inside_surface = [&lslices = this->lslices, &lslices_ex = this->lslices_ex](size_t lslice_idx, const Point &point) {
        const BoundingBox &bbox = lslices_ex[lslice_idx].bbox;
        return point.x() >= bbox.min.x() && point.x() < bbox.max.x() &&
               point.y() >= bbox.min.y() && point.y() < bbox.max.y() &&
               // Exact match: Don't just test whether a point is inside the outer contour of an island,
               // test also whether the point is not inside some hole of the same expolygon.
               // This is unfortunatelly necessary because the point may be inside an expolygon of one of this expolygon's hole
               // and missed due to numerical issues.
               lslices[lslice_idx].contains(point);
    };
    for (int lslice_idx = int(lslices_ex.size()) - 1; lslice_idx >= 0 && ! perimeter_slices_queue.empty(); -- lslice_idx)
        for (auto it_source_slice = perimeter_slices_queue.begin(); it_source_slice != perimeter_slices_queue.end(); ++ it_source_slice)
            if (point_inside_surface(lslice_idx, it_source_slice->second)) {
                insert_into_island(lslice_idx, it_source_slice->first);
                if (std::next(it_source_slice) != perimeter_slices_queue.end())
                    // Remove the current slice & point pair from the queue.
                    *it_source_slice = perimeter_slices_queue.back();
                perimeter_slices_queue.pop_back();
                break;
            }
    if (! perimeter_slices_queue.empty()) {
        // If the slice sample was not fitted into any slice using exact fit, try to find a closest island as a last resort.
        // This should be a rare event especially if the sample point was taken from infill or inner perimeter,
        // however we may land here for external perimeter only islands with fuzzy skin applied.
        // Check whether fuzzy skin was enabled and adjust the bounding box accordingly.
        const PrintConfig       &print_config  = this->object()->print()->config();
        const PrintRegionConfig &region_config = this_layer_region.region().config();
        const auto               bbox_eps      = scaled<coord_t>(
            EPSILON + print_config.gcode_resolution.value +
            (region_config.fuzzy_skin.value == FuzzySkinType::None ? 0. : region_config.fuzzy_skin_thickness.value 
                //FIXME it looks as if Arachne could extend open lines by fuzzy_skin_point_dist, which does not seem right.
                + region_config.fuzzy_skin_point_dist.value));
        auto point_inside_surface_dist2 =
            [&lslices = this->lslices, &lslices_ex = this->lslices_ex, bbox_eps]
            (const size_t lslice_idx, const Point &point) {
            const BoundingBox &bbox = lslices_ex[lslice_idx].bbox;
            return 
                point.x() < bbox.min.x() - bbox_eps || point.x() > bbox.max.x() + bbox_eps ||
                point.y() < bbox.min.y() - bbox_eps || point.y() > bbox.max.y() + bbox_eps ?
                std::numeric_limits<double>::max() :
                (lslices[lslice_idx].point_projection(point) - point).cast<double>().squaredNorm();
        };
        for (auto it_source_slice  = perimeter_slices_queue.begin(); it_source_slice != perimeter_slices_queue.end(); ++ it_source_slice) {
            double d2min = std::numeric_limits<double>::max();
            int    lslice_idx_min = -1;
            for (int lslice_idx = int(lslices_ex.size()) - 1; lslice_idx >= 0; -- lslice_idx)
                if (double d2 = point_inside_surface_dist2(lslice_idx, it_source_slice->second); d2 < d2min) {
                    d2min = d2;
                    lslice_idx_min = lslice_idx;
                }
            if (lslice_idx_min == -1) {
                // This should not happen, but Arachne seems to produce a perimeter point far outside its source contour.
                // As a last resort, find the closest source contours to the sample point.
                for (int lslice_idx = int(lslices_ex.size()) - 1; lslice_idx >= 0; -- lslice_idx)
                    if (double d2 = (lslices[lslice_idx].point_projection(it_source_slice->second) - it_source_slice->second).cast<double>().squaredNorm(); d2 < d2min) {
                        d2min = d2;
                        lslice_idx_min = lslice_idx;
                    }
            }
            assert(lslice_idx_min != -1);
            insert_into_island(lslice_idx_min, it_source_slice->first);
        }
    }
}

References Slic3r::PrintRegion::config(), Slic3r::ExPolygon::empty(), Slic3r::IndexRange< T >::empty(), Slic3r::ExtrusionEntityCollection::entities, EPSILON, Slic3r::expolygons_match(), Slic3r::LayerRegion::fill_expolygons(), Slic3r::LayerIsland::fill_expolygons, Slic3r::LayerRegion::fill_expolygons_composite(), Slic3r::LayerIsland::fill_expolygons_composite(), Slic3r::LayerIsland::fill_region_id, Slic3r::get_extents(), Slic3r::intersection_ex(), Slic3r::ExtrusionEntity::is_collection(), Slic3r::ExtrusionRole::is_external(), Slic3r::LayerRegion::m_fill_expolygons, Slic3r::LayerRegion::m_fill_expolygons_bboxes, Slic3r::LayerRegion::m_fill_expolygons_composite, Slic3r::LayerRegion::m_fill_expolygons_composite_bboxes, Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::ExtrusionEntity::middle_point(), Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::LayerRegion::perimeters(), Slic3r::LayerIsland::perimeters, Slic3r::PrintRegionConfig, Slic3r::LayerRegion::region(), Slic3r::ExtrusionEntity::role(), Slic3r::IndexRange< T >::size(), Slic3r::SurfaceCollection::size(), Slic3r::LayerRegion::slices(), Slic3r::SurfaceCollection::surfaces, Slic3r::LayerRegion::thin_fills(), and Slic3r::LayerIsland::thin_fills.

Here is the call graph for this function:

Friends And Related Symbol Documentation

fix_slicing_errors

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

friend

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 = 0.5 * (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;
}

PrintObject

friend class PrintObject

friend

Member Data Documentation

curled_lines

CurledLines Slic3r::Layer::curled_lines

Referenced by Slic3r::JPSPathFinder::add_obstacles(), and Slic3r::ExtrusionQualityEstimator::prepare_for_new_layer().

height

coordf_t Slic3r::Layer::height

Referenced by bottom_z(), Slic3r::SupportSpotsGenerator::build_object_part_from_slice(), Slic3r::SupportSpotsGenerator::check_extrusion_entity_stability(), Slic3r::GCode::collect_layers_to_print(), Slic3r::PrintObject::combine_infill(), Slic3r::detect_overhangs(), Slic3r::LayerRegion::flow(), Slic3r::FFFTreeSupport::generate_overhangs(), generate_sparse_infill_polylines_for_anchoring(), Slic3r::group_fills(), make_fills(), Slic3r::mmu_segmentation_top_and_bottom_layers(), and Slic3r::new_contact_layer().

lower_layer

Layer* Slic3r::Layer::lower_layer

Referenced by ~Layer(), Slic3r::PrintObject::bridge_over_infill(), Slic3r::SupportSpotsGenerator::check_stability(), Slic3r::detect_overhangs(), Slic3r::SupportSpotsGenerator::estimate_slice_connection(), Slic3r::LayerRegion::make_perimeters(), and Slic3r::new_contact_layer().

lslice_indices_sorted_by_print_order

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

Referenced by make_slices(), Slic3r::GCode::process_layer_single_object(), and Slic3r::PrintObject::slice_volumes().

lslices

ExPolygons Slic3r::Layer::lslices

Referenced by Slic3r::FFFTreeSupport::TreeModelVolumes::TreeModelVolumes(), Slic3r::SupportSpotsGenerator::build_object_part_from_slice(), build_up_down_graph(), Slic3r::PrintObjectSupportMaterial::buildplate_covered(), Slic3r::DoubleSlider::check_color_change(), Slic3r::SupportSpotsGenerator::check_stability(), Slic3r::collect_slices_outer(), Slic3r::connect_layer_slices(), Slic3r::detect_overhangs(), Slic3r::PrintObject::detect_surfaces_type(), Slic3r::PrintObject::discover_vertical_shells(), Slic3r::SupportSpotsGenerator::estimate_slice_connection(), Slic3r::FFFTreeSupport::generate_overhangs(), Slic3r::FFFTreeSupport::generate_raft_contact(), Slic3r::get_boundary(), Slic3r::AvoidCrossingPerimeters::init_layer(), Slic3r::insert_fills_into_islands(), Slic3r::LayerRegion::make_perimeters(), make_slices(), Slic3r::ExtrusionQualityEstimator::prepare_for_new_layer(), Slic3r::project_support_to_grid(), Slic3r::FFFSupport::remove_bridges_from_contacts(), and Slic3r::PrintObject::slice_volumes().

lslices_ex

LayerSlices Slic3r::Layer::lslices_ex

Referenced by Slic3r::SupportSpotsGenerator::build_object_part_from_slice(), Slic3r::SupportSpotsGenerator::check_stability(), Slic3r::connect_layer_slices(), Slic3r::SupportSpotsGenerator::estimate_slice_connection(), Slic3r::insert_fills_into_islands(), Slic3r::GCode::process_layer_single_object(), and Slic3r::FFFSupport::remove_bridges_from_contacts().

m_id

size_t Slic3r::Layer::m_id

private

Referenced by id(), and set_id().

m_object

PrintObject* Slic3r::Layer::m_object

private

Referenced by 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::detect_surfaces_type(), Slic3r::PrintObject::discover_vertical_shells(), empty(), get_region(), get_region(), has_extrusions(), make_slices(), region_count(), and regions().

print_z

coordf_t Slic3r::Layer::print_z

Referenced by Slic3r::GCode::_do_export(), Slic3r::GUI::GLCanvas3D::_load_print_object_toolpaths(), Slic3r::JPSPathFinder::add_obstacles(), Slic3r::PrintObjectSupportMaterial::bottom_contact_layers_and_layer_support_areas(), Slic3r::SupportSpotsGenerator::build_object_part_from_slice(), Slic3r::GCode::collect_layers_to_print(), Slic3r::detect_bottom_contacts(), Slic3r::detect_overhangs(), Slic3r::PrintObject::detect_surfaces_type(), Slic3r::PrintObject::discover_vertical_shells(), Slic3r::SupportSpotsGenerator::estimate_slice_connection(), Slic3r::FFFSupport::generate_support_toolpaths(), Slic3r::get_boundary(), Slic3r::get_boundary_external(), Slic3r::get_perimeter_spacing_external(), Slic3r::LayerRegion::make_perimeters(), Slic3r::new_contact_layer(), Slic3r::GCode::ObjectLayerToPrint::print_z(), Slic3r::GCode::process_layer(), Slic3r::GCode::process_layers(), and Slic3r::project_support_to_grid().

slice_z

coordf_t Slic3r::Layer::slice_z

Referenced by Slic3r::SupportSpotsGenerator::build_object_part_from_slice(), Slic3r::SeamPlacer::find_seam_string(), and Slic3r::SeamPlacer::place_seam().

upper_layer

Layer* Slic3r::Layer::upper_layer

Referenced by ~Layer(), and Slic3r::PrintObject::slice_volumes().

---

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

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