Slic3r::PrintObjectSupportMaterial Class Reference

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

Collaboration diagram for Slic3r::PrintObjectSupportMaterial:

Public Member Functions
	PrintObjectSupportMaterial (const PrintObject *object, const SlicingParameters &slicing_params)
bool	has_raft () const
bool	has_support () const
bool	build_plate_only () const
bool	synchronize_layers () const
bool	has_contact_loops () const
void	generate (PrintObject &object)

Private Member Functions
std::vector< Polygons >	buildplate_covered (const PrintObject &object) const
SupportGeneratorLayersPtr	top_contact_layers (const PrintObject &object, const std::vector< Polygons > &buildplate_covered, SupportGeneratorLayerStorage &layer_storage) const
SupportGeneratorLayersPtr	bottom_contact_layers_and_layer_support_areas (const PrintObject &object, const SupportGeneratorLayersPtr &top_contacts, std::vector< Polygons > &buildplate_covered, SupportGeneratorLayerStorage &layer_storage, std::vector< Polygons > &layer_support_areas) const
void	trim_top_contacts_by_bottom_contacts (const PrintObject &object, const SupportGeneratorLayersPtr &bottom_contacts, SupportGeneratorLayersPtr &top_contacts) const
SupportGeneratorLayersPtr	raft_and_intermediate_support_layers (const PrintObject &object, const SupportGeneratorLayersPtr &bottom_contacts, const SupportGeneratorLayersPtr &top_contacts, SupportGeneratorLayerStorage &layer_storage) const
void	generate_base_layers (const PrintObject &object, const SupportGeneratorLayersPtr &bottom_contacts, const SupportGeneratorLayersPtr &top_contacts, SupportGeneratorLayersPtr &intermediate_layers, const std::vector< Polygons > &layer_support_areas) const
void	trim_support_layers_by_object (const PrintObject &object, SupportGeneratorLayersPtr &support_layers, const coordf_t gap_extra_above, const coordf_t gap_extra_below, const coordf_t gap_xy) const

Private Attributes
const PrintConfig *	m_print_config
const PrintObjectConfig *	m_object_config
SlicingParameters	m_slicing_params
SupportParameters	m_support_params

Detailed Description

Constructor & Destructor Documentation

PrintObjectSupportMaterial()

Slic3r::PrintObjectSupportMaterial::PrintObjectSupportMaterial	(	const PrintObject *	object,
		const SlicingParameters &	slicing_params )

                                                                                                                         :
    m_print_config          (&object->print()->config()),
    m_object_config         (&object->config()),
    m_slicing_params        (slicing_params),
    m_support_params        (*object)
{
}

References m_object_config, m_print_config, m_slicing_params, and m_support_params.

Member Function Documentation

bottom_contact_layers_and_layer_support_areas()

SupportGeneratorLayersPtr Slic3r::PrintObjectSupportMaterial::bottom_contact_layers_and_layer_support_areas ( const PrintObject & object, const SupportGeneratorLayersPtr & top_contacts, std::vector< Polygons > & buildplate_covered, SupportGeneratorLayerStorage & layer_storage, std::vector< Polygons > & layer_support_areas ) const

private

{
    if (top_contacts.empty())
        return SupportGeneratorLayersPtr();
 
#ifdef SLIC3R_DEBUG
    static size_t s_iRun = 0;
    size_t iRun = s_iRun ++;
#endif /* SLIC3R_DEBUG */
 
    //FIXME higher expansion_to_slice here? why?
    //const auto   expansion_to_slice = m_support_material_flow.scaled_spacing() / 2 + 25;
    const SupportGridParams grid_params(*m_object_config, m_support_params.support_material_flow);
    const bool buildplate_only = ! buildplate_covered.empty();
    const bool has_belt_floor  = std::abs(m_slicing_params.belt_floor_shear_factor) > EPSILON;
 
    // Allocate empty surface areas, one per object layer.
    layer_support_areas.assign(object.total_layer_count(), Polygons());
 
    // find object top surfaces
    // we'll use them to clip our support and detect where does it stick
    SupportGeneratorLayersPtr bottom_contacts;
 
    // There is some support to be built, if there are non-empty top surfaces detected.
    // Sum of unsupported contact areas above the current layer.print_z.
    Polygons  overhangs_projection;
    // Sum of unsupported enforcer contact areas above the current layer.print_z.
    // Only used if "supports on build plate only" is enabled and both automatic and support enforcers are enabled.
    Polygons  enforcers_projection;
    // Last top contact layer visited when collecting the projection of contact areas.
    int       contact_idx = int(top_contacts.size()) - 1;
    for (int layer_id = int(object.total_layer_count()) - 2; layer_id >= 0; -- layer_id) {
        BOOST_LOG_TRIVIAL(trace) << "Support generator - bottom_contact_layers - layer " << layer_id;
        const Layer &layer = *object.get_layer(layer_id);
        // Collect projections of all contact areas above or at the same level as this top surface.
#ifdef SLIC3R_DEBUG
        Polygons polygons_new;
        Polygons enforcers_new;
#endif // SLIC3R_DEBUG
        for (; contact_idx >= 0 && top_contacts[contact_idx]->print_z > layer.print_z - EPSILON; -- contact_idx) {
            SupportGeneratorLayer &top_contact = *top_contacts[contact_idx];
#ifndef SLIC3R_DEBUG
            Polygons polygons_new;
            Polygons enforcers_new;
#endif // SLIC3R_DEBUG
            // Contact surfaces are expanded away from the object, trimmed by the object.
            // Use a slight positive offset to overlap the touching regions.
#if 0
            // Merge and collect the contact polygons. The contact polygons are inflated, but not extended into a grid form.
            polygons_append(polygons_new,  offset(*top_contact.contact_polygons,  SCALED_EPSILON));
            if (top_contact.enforcer_polygons)
                polygons_append(enforcers_new, offset(*top_contact.enforcer_polygons, SCALED_EPSILON));
#else
            // Consume the contact_polygons. The contact polygons are already expanded into a grid form, and they are a tiny bit smaller
            // than the grid cells.
            polygons_append(polygons_new,  std::move(*top_contact.contact_polygons));
            if (top_contact.enforcer_polygons)
                polygons_append(enforcers_new, std::move(*top_contact.enforcer_polygons));
#endif
            // These are the overhang surfaces. They are touching the object and they are not expanded away from the object.
            // Use a slight positive offset to overlap the touching regions.
            polygons_append(polygons_new, expand(*top_contact.overhang_polygons, float(SCALED_EPSILON)));
            polygons_append(overhangs_projection, union_(polygons_new));
            polygons_append(enforcers_projection, enforcers_new);
        }
        if (overhangs_projection.empty() && enforcers_projection.empty())
            continue;
 
        // Overhangs_projection will be filled in asynchronously, move it away.
        Polygons overhangs_projection_raw = union_(std::move(overhangs_projection));
        Polygons enforcers_projection_raw = union_(std::move(enforcers_projection));
 
        tbb::task_group task_group;
        const Polygons &overhangs_for_bottom_contacts = buildplate_only ? enforcers_projection_raw : overhangs_projection_raw;
        if (! overhangs_for_bottom_contacts.empty())
            // Find the bottom contact layers above the top surfaces of this layer,
            // and also detect belt floor contacts if belt mode is active.
            task_group.run([this, &object, &layer, &top_contacts, contact_idx, &layer_storage, &layer_support_areas, &bottom_contacts, &overhangs_for_bottom_contacts, has_belt_floor
    #ifdef SLIC3R_DEBUG
                , iRun, &polygons_new
    #endif // SLIC3R_DEBUG
                ] {
                    // Find the bottom contact layers above the top surfaces of this layer.
                    SupportGeneratorLayer *layer_new = detect_bottom_contacts(
                        m_slicing_params, m_support_params, object, layer, top_contacts, contact_idx, layer_storage, layer_support_areas, overhangs_for_bottom_contacts
#ifdef SLIC3R_DEBUG
                        , iRun, polygons_new
#endif // SLIC3R_DEBUG
                    );
                    if (layer_new)
                        bottom_contacts.push_back(layer_new);
                    // Belt floor phantom surface: detect where support meets the belt plane.
                    if (has_belt_floor) {
                        SupportGeneratorLayer *belt_layer = detect_belt_floor_bottom_contacts(
                            m_slicing_params, m_support_params, *m_print_config, object,
                            layer, top_contacts, contact_idx, layer_storage,
                            layer_support_areas, overhangs_for_bottom_contacts);
                        if (belt_layer)
                            bottom_contacts.push_back(belt_layer);
                    }
                });
 
        Polygons &layer_support_area = layer_support_areas[layer_id];
        Polygons *layer_buildplate_covered = buildplate_covered.empty() ? nullptr : &buildplate_covered[layer_id];
        // Filtering the propagated support columns to two extrusions, overlapping by maximum 20%.
//        float column_propagation_filtering_radius = scaled<float>(0.8 * 0.5 * (m_support_params.support_material_flow.spacing() + m_support_params.support_material_flow.width()));
        task_group.run([&grid_params, &overhangs_projection, &overhangs_projection_raw, &layer, &layer_support_area, layer_buildplate_covered /* , column_propagation_filtering_radius */
#ifdef SLIC3R_DEBUG 
            , iRun, layer_id
#endif /* SLIC3R_DEBUG */
            ] {
                // buildplate_covered[layer_id] will be consumed here.
                std::tie(layer_support_area, overhangs_projection) = project_support_to_grid(layer, grid_params, overhangs_projection_raw, layer_buildplate_covered
#ifdef SLIC3R_DEBUG 
                    , iRun, layer_id, "general"
#endif /* SLIC3R_DEBUG */
                );
                // When propagating support areas downwards, stop propagating the support column if it becomes too thin to be printable.
                //overhangs_projection = opening(overhangs_projection, column_propagation_filtering_radius);
            });
 
        Polygons layer_support_area_enforcers;
        if (! enforcers_projection.empty())
            // Project the enforcers polygons downwards, don't trim them with the "buildplate only" polygons.
            task_group.run([&grid_params, &enforcers_projection, &enforcers_projection_raw, &layer, &layer_support_area_enforcers
#ifdef SLIC3R_DEBUG 
                , iRun, layer_id
#endif /* SLIC3R_DEBUG */
            ]{
                std::tie(layer_support_area_enforcers, enforcers_projection) = project_support_to_grid(layer, grid_params, enforcers_projection_raw, nullptr
#ifdef SLIC3R_DEBUG 
                    , iRun, layer_id, "enforcers"
#endif /* SLIC3R_DEBUG */
                );
            });
 
        task_group.wait();
 
        // Belt floor: clip projections and support areas so support doesn't
        // propagate below the belt plane.
        if (has_belt_floor) {
            Polygons valid_region = belt_floor_valid_region_polygon(
                m_slicing_params, *m_print_config, object, layer.print_z);
            if (! valid_region.empty()) {
                if (! overhangs_projection.empty())
                    overhangs_projection = intersection(overhangs_projection, valid_region);
                if (! enforcers_projection.empty())
                    enforcers_projection = intersection(enforcers_projection, valid_region);
                if (! layer_support_area.empty())
                    layer_support_area = intersection(layer_support_area, valid_region);
                if (! layer_support_area_enforcers.empty())
                    layer_support_area_enforcers = intersection(layer_support_area_enforcers, valid_region);
            }
        }
 
        if (! layer_support_area_enforcers.empty()) {
            if (layer_support_area.empty())
                layer_support_area = std::move(layer_support_area_enforcers);
            else
                layer_support_area = union_(layer_support_area, layer_support_area_enforcers);
        }
    } // over all layers downwards
 
    std::reverse(bottom_contacts.begin(), bottom_contacts.end());
    trim_support_layers_by_object(object, bottom_contacts, m_slicing_params.gap_support_object, m_slicing_params.gap_object_support, m_support_params.gap_xy);
    trim_support_layers_by_belt_floor(m_slicing_params, *m_print_config, object, bottom_contacts);
    return bottom_contacts;
}

References Slic3r::belt_floor_valid_region_polygon(), bottom_contact_layers_and_layer_support_areas(), buildplate_covered(), Slic3r::SupportGeneratorLayer::contact_polygons, Slic3r::detect_belt_floor_bottom_contacts(), Slic3r::detect_bottom_contacts(), Slic3r::SupportGeneratorLayer::enforcer_polygons, EPSILON, Slic3r::expand(), Slic3r::intersection(), m_object_config, m_print_config, m_slicing_params, m_support_params, Slic3r::offset(), Slic3r::SupportGeneratorLayer::overhang_polygons, Slic3r::polygons_append(), Slic3r::Layer::print_z, Slic3r::project_support_to_grid(), SCALED_EPSILON, Slic3r::trace(), Slic3r::trim_support_layers_by_belt_floor(), trim_support_layers_by_object(), and Slic3r::union_().

Referenced by bottom_contact_layers_and_layer_support_areas(), and generate().

Here is the call graph for this function:

Here is the caller graph for this function:

build_plate_only()

bool Slic3r::PrintObjectSupportMaterial::build_plate_only ( ) const

inline

{ return this->has_support() && m_object_config->support_on_build_plate_only.value; }

References has_support(), and m_object_config.

Referenced by buildplate_covered().

Here is the call graph for this function:

Here is the caller graph for this function:

buildplate_covered()

std::vector< Polygons > Slic3r::PrintObjectSupportMaterial::buildplate_covered ( const PrintObject & object ) const

private

{
    // Build support on a build plate only? If so, then collect and union all the surfaces below the current layer.
    // Unfortunately this is an inherently serial process.
    const bool            buildplate_only = this->build_plate_only();
    std::vector<Polygons> buildplate_covered;
    if (buildplate_only) {
        BOOST_LOG_TRIVIAL(debug) << "PrintObjectSupportMaterial::buildplate_covered() - start";
        buildplate_covered.assign(object.layers().size(), Polygons());
        //FIXME prefix sum algorithm, parallelize it! Parallelization will also likely be more numerically stable.
        for (size_t layer_id = 1; layer_id < object.layers().size(); ++ layer_id) {
            const Layer &lower_layer = *object.layers()[layer_id-1];
            // Merge the new slices with the preceding slices.
            // Apply the safety offset to the newly added polygons, so they will connect
            // with the polygons collected before,
            // but don't apply the safety offset during the union operation as it would
            // inflate the polygons over and over.
            Polygons &covered = buildplate_covered[layer_id];
            covered = buildplate_covered[layer_id - 1];
            polygons_append(covered, offset(lower_layer.lslices, scale_(0.01)));
            covered = union_(covered);
        }
        BOOST_LOG_TRIVIAL(debug) << "PrintObjectSupportMaterial::buildplate_covered() - end";
    }
    return buildplate_covered;
}

References build_plate_only(), buildplate_covered(), Slic3r::Layer::lslices, Slic3r::offset(), Slic3r::polygons_append(), scale_, and Slic3r::union_().

Referenced by bottom_contact_layers_and_layer_support_areas(), buildplate_covered(), generate(), and top_contact_layers().

Here is the call graph for this function:

Here is the caller graph for this function:

generate()

void Slic3r::PrintObjectSupportMaterial::generate

(

PrintObject &

object

)

{
    BOOST_LOG_TRIVIAL(info) << "Support generator - Start";
 
    coordf_t max_object_layer_height = 0.;
    for (size_t i = 0; i < object.layer_count(); ++ i)
        max_object_layer_height = std::max(max_object_layer_height, object.layers()[i]->height);
 
    // Layer instances will be allocated by std::deque and they will be kept until the end of this function call.
    // The layers will be referenced by various LayersPtr (of type std::vector<Layer*>)
    SupportGeneratorLayerStorage layer_storage;
 
    BOOST_LOG_TRIVIAL(info) << "Support generator - Creating top contacts";
 
    // Per object layer projection of the object below the layer into print bed.
    std::vector<Polygons> buildplate_covered = this->buildplate_covered(object);
 
    // Determine the top contact surfaces of the support, defined as:
    // contact = overhangs - clearance + margin
    // This method is responsible for identifying what contact surfaces
    // should the support material expose to the object in order to guarantee
    // that it will be effective, regardless of how it's built below.
    // If raft is to be generated, the 1st top_contact layer will contain the 1st object layer silhouette without holes.
    SupportGeneratorLayersPtr top_contacts = this->top_contact_layers(object, buildplate_covered, layer_storage);
    if (top_contacts.empty())
        // Nothing is supported, no supports are generated.
        return;
 
    if (object.print()->canceled())
        return;
 
#ifdef SLIC3R_DEBUG
    static int iRun = 0;
    iRun ++;
    for (const SupportGeneratorLayer *layer : top_contacts)
        Slic3r::SVG::export_expolygons(
            debug_out_path("support-top-contacts-%d-%lf.svg", iRun, layer->print_z), 
            union_ex(layer->polygons));
#endif /* SLIC3R_DEBUG */
 
    BOOST_LOG_TRIVIAL(info) << "Support generator - Creating bottom contacts";
 
    // Determine the bottom contact surfaces of the supports over the top surfaces of the object.
    // Depending on whether the support is soluble or not, the contact layer thickness is decided.
    // layer_support_areas contains the per object layer support areas. These per object layer support areas
    // may get merged and trimmed by this->generate_base_layers() if the support layers are not synchronized with object layers.
    std::vector<Polygons> layer_support_areas;
    SupportGeneratorLayersPtr bottom_contacts = this->bottom_contact_layers_and_layer_support_areas(
        object, top_contacts, buildplate_covered,
        layer_storage, layer_support_areas);
 
    if (object.print()->canceled())
        return;
 
#ifdef SLIC3R_DEBUG
    for (size_t layer_id = 0; layer_id < object.layers().size(); ++ layer_id)
        Slic3r::SVG::export_expolygons(
            debug_out_path("support-areas-%d-%lf.svg", iRun, object.layers()[layer_id]->print_z), 
            union_ex(layer_support_areas[layer_id]));
#endif /* SLIC3R_DEBUG */
 
    BOOST_LOG_TRIVIAL(info) << "Support generator - Creating intermediate layers - indices";
 
    // Allocate empty layers between the top / bottom support contact layers
    // as placeholders for the base and intermediate support layers.
    // The layers may or may not be synchronized with the object layers, depending on the configuration.
    // For example, a single nozzle multi material printing will need to generate a waste tower, which in turn
    // wastes less material, if there are as little tool changes as possible.
    SupportGeneratorLayersPtr intermediate_layers = this->raft_and_intermediate_support_layers(
        object, bottom_contacts, top_contacts, layer_storage);
 
    this->trim_support_layers_by_object(object, top_contacts, m_slicing_params.gap_support_object, m_slicing_params.gap_object_support, m_support_params.gap_xy);
    trim_support_layers_by_belt_floor(m_slicing_params, *m_print_config, object, top_contacts);
 
#ifdef SLIC3R_DEBUG
    for (const SupportGeneratorLayer *layer : top_contacts)
        Slic3r::SVG::export_expolygons(
            debug_out_path("support-top-contacts-trimmed-by-object-%d-%lf.svg", iRun, layer->print_z),
            union_ex(layer->polygons));
#endif
 
    BOOST_LOG_TRIVIAL(info) << "Support generator - Creating base layers";
 
    // Fill in intermediate layers between the top / bottom support contact layers, trim them by the object.
    this->generate_base_layers(object, bottom_contacts, top_contacts, intermediate_layers, layer_support_areas);
 
#ifdef SLIC3R_DEBUG
    for (SupportGeneratorLayersPtr::const_iterator it = intermediate_layers.begin(); it != intermediate_layers.end(); ++ it)
        Slic3r::SVG::export_expolygons(
            debug_out_path("support-base-layers-%d-%lf.svg", iRun, (*it)->print_z), 
            union_ex((*it)->polygons));
#endif /* SLIC3R_DEBUG */
 
    BOOST_LOG_TRIVIAL(info) << "Support generator - Trimming top contacts by bottom contacts";
 
    // Because the top and bottom contacts are thick slabs, they may overlap causing over extrusion 
    // and unwanted strong bonds to the object.
    // Rather trim the top contacts by their overlapping bottom contacts to leave a gap instead of over extruding
    // top contacts over the bottom contacts.
    this->trim_top_contacts_by_bottom_contacts(object, bottom_contacts, top_contacts);
 
 
    BOOST_LOG_TRIVIAL(info) << "Support generator - Creating interfaces";
 
    // Propagate top / bottom contact layers to generate interface layers 
    // and base interface layers (for soluble interface / non souble base only)
  SupportGeneratorLayersPtr empty_layers;
    auto [interface_layers, base_interface_layers] = generate_interface_layers(*m_object_config, m_support_params, bottom_contacts, top_contacts, empty_layers, empty_layers, intermediate_layers, layer_storage);
 
    BOOST_LOG_TRIVIAL(info) << "Support generator - Creating raft";
 
    // If raft is to be generated, the 1st top_contact layer will contain the 1st object layer silhouette with holes filled.
    // There is also a 1st intermediate layer containing bases of support columns.
    // Inflate the bases of the support columns and create the raft base under the object.
    SupportGeneratorLayersPtr raft_layers = generate_raft_base(object, m_support_params, m_slicing_params, top_contacts, interface_layers, base_interface_layers, intermediate_layers, layer_storage);
 
    if (object.print()->canceled())
        return;
 
#ifdef SLIC3R_DEBUG
    for (const SupportGeneratorLayer *l : interface_layers)
        Slic3r::SVG::export_expolygons(
            debug_out_path("support-interface-layers-%d-%lf.svg", iRun, l->print_z), 
            union_ex(l->polygons));
    for (const SupportGeneratorLayer *l : base_interface_layers)
        Slic3r::SVG::export_expolygons(
            debug_out_path("support-base-interface-layers-%d-%lf.svg", iRun, l->print_z), 
            union_ex(l->polygons));
#endif // SLIC3R_DEBUG
 
/*
    // Clip with the pillars.
    if (! shape.empty()) {
        this->clip_with_shape(interface, shape);
        this->clip_with_shape(base, shape);
    }
*/
 
    BOOST_LOG_TRIVIAL(info) << "Support generator - Creating layers";
 
    trim_support_layers_by_exclusion_volumes(
        object, raft_layers, bottom_contacts, top_contacts, intermediate_layers,
        interface_layers, base_interface_layers);
 
// For debugging purposes, one may want to show only some of the support extrusions.
//    raft_layers.clear();
//    bottom_contacts.clear();
//    top_contacts.clear();
//    intermediate_layers.clear();
//    interface_layers.clear();
 
#ifdef SLIC3R_DEBUG
    SupportGeneratorLayersPtr layers_sorted =
#endif // SLIC3R_DEBUG
    generate_support_layers(object, raft_layers, bottom_contacts, top_contacts, intermediate_layers, interface_layers, base_interface_layers);
 
    BOOST_LOG_TRIVIAL(info) << "Support generator - Generating tool paths";
 
#if 0 // #ifdef SLIC3R_DEBUG
    {
        size_t layer_id = 0;
        for (int i = 0; i < int(layers_sorted.size());) {
            // Find the last layer with roughly the same print_z, find the minimum layer height of all.
            // Due to the floating point inaccuracies, the print_z may not be the same even if in theory they should.
            int j = i + 1;
            coordf_t zmax = layers_sorted[i]->print_z + EPSILON;
            bool empty = true;
            for (; j < layers_sorted.size() && layers_sorted[j]->print_z <= zmax; ++j)
                if (!layers_sorted[j]->polygons.empty())
                    empty = false;
            if (!empty) {
                export_print_z_polygons_to_svg(
                    debug_out_path("support-%d-%lf-before.svg", iRun, layers_sorted[i]->print_z).c_str(),
                    layers_sorted.data() + i, j - i);
                export_print_z_polygons_and_extrusions_to_svg(
                    debug_out_path("support-w-fills-%d-%lf-before.svg", iRun, layers_sorted[i]->print_z).c_str(),
                    layers_sorted.data() + i, j - i,
                    *object.support_layers()[layer_id]);
                ++layer_id;
            }
            i = j;
        }
    }
#endif /* SLIC3R_DEBUG */
 
    // Generate the actual toolpaths and save them into each layer.
    generate_support_toolpaths(object.support_layers(), *m_object_config, m_support_params, m_slicing_params, raft_layers, bottom_contacts, top_contacts, intermediate_layers, interface_layers, base_interface_layers);
 
#ifdef SLIC3R_DEBUG
    {
        size_t layer_id = 0;
        for (int i = 0; i < int(layers_sorted.size());) {
            // Find the last layer with roughly the same print_z, find the minimum layer height of all.
            // Due to the floating point inaccuracies, the print_z may not be the same even if in theory they should.
            int j = i + 1;
            coordf_t zmax = layers_sorted[i]->print_z + EPSILON;
            bool empty = true;
            for (; j < layers_sorted.size() && layers_sorted[j]->print_z <= zmax; ++j)
                if (! layers_sorted[j]->polygons.empty())
                    empty = false;
            if (! empty) {
                export_print_z_polygons_to_svg(
                    debug_out_path("support-%d-%lf.svg", iRun, layers_sorted[i]->print_z).c_str(),
                    layers_sorted.data() + i, j - i);
                export_print_z_polygons_and_extrusions_to_svg(
                    debug_out_path("support-w-fills-%d-%lf.svg", iRun, layers_sorted[i]->print_z).c_str(),
                    layers_sorted.data() + i, j - i,
                    *object.support_layers()[layer_id]);
                ++layer_id;
            }
            i = j;
        }
    }
#endif /* SLIC3R_DEBUG */
 
    BOOST_LOG_TRIVIAL(info) << "Support generator - End";
}

References bottom_contact_layers_and_layer_support_areas(), buildplate_covered(), Slic3r::debug_out_path(), Slic3r::empty(), EPSILON, Slic3r::SVG::export_expolygons(), generate_base_layers(), Slic3r::generate_interface_layers(), Slic3r::generate_raft_base(), Slic3r::generate_support_layers(), Slic3r::generate_support_toolpaths(), m_object_config, m_print_config, m_slicing_params, m_support_params, raft_and_intermediate_support_layers(), top_contact_layers(), Slic3r::trim_support_layers_by_belt_floor(), Slic3r::trim_support_layers_by_exclusion_volumes(), trim_support_layers_by_object(), trim_top_contacts_by_bottom_contacts(), and Slic3r::union_ex().

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

Here is the call graph for this function:

Here is the caller graph for this function:

generate_base_layers()

void Slic3r::PrintObjectSupportMaterial::generate_base_layers ( const PrintObject & object, const SupportGeneratorLayersPtr & bottom_contacts, const SupportGeneratorLayersPtr & top_contacts, SupportGeneratorLayersPtr & intermediate_layers, const std::vector< Polygons > & layer_support_areas ) const

private

{
#ifdef SLIC3R_DEBUG
    static int iRun = 0;
#endif /* SLIC3R_DEBUG */
 
    if (top_contacts.empty())
        // No top contacts -> no intermediate layers will be produced.
        return;
 
    BOOST_LOG_TRIVIAL(debug) << "PrintObjectSupportMaterial::generate_base_layers() in parallel - start";
    tbb::parallel_for(
        tbb::blocked_range<size_t>(0, intermediate_layers.size()),
        [&object, &bottom_contacts, &top_contacts, &intermediate_layers, &layer_support_areas](const tbb::blocked_range<size_t>& range) {
            // index -2 means not initialized yet, -1 means intialized and decremented to 0 and then -1.
            int idx_top_contact_above           = -2;
            int idx_bottom_contact_overlapping  = -2;
            int idx_object_layer_above          = -2;
            // Counting down due to the way idx_lower_or_equal caches indices to avoid repeated binary search over the complete sequence.
            for (int idx_intermediate = int(range.end()) - 1; idx_intermediate >= int(range.begin()); -- idx_intermediate)
            {
                BOOST_LOG_TRIVIAL(trace) << "Support generator - generate_base_layers - creating layer " << 
                    idx_intermediate << " of " << intermediate_layers.size();
                SupportGeneratorLayer &layer_intermediate = *intermediate_layers[idx_intermediate];
                // Layers must be sorted by print_z. 
                assert(idx_intermediate == 0 || layer_intermediate.print_z >= intermediate_layers[idx_intermediate - 1]->print_z);
 
                // Find a top_contact layer touching the layer_intermediate from above, if any, and collect its polygons into polygons_new.
                // New polygons for layer_intermediate.
                Polygons polygons_new;
 
                // Use the precomputed layer_support_areas. "idx_object_layer_above": above means above since the last iteration, not above after this call.
                idx_object_layer_above = idx_lower_or_equal(object.layers().begin(), object.layers().end(), idx_object_layer_above,
                    [&layer_intermediate](const Layer* layer) { return layer->print_z <= layer_intermediate.print_z + EPSILON; });
 
                // Polygons to trim polygons_new.
                Polygons polygons_trimming; 
 
                // Trimming the base layer with any overlapping top layer.
                // Following cases are recognized:
                // 1) top.bottom_z >= base.top_z -> No overlap, no trimming needed.
                // 2) base.bottom_z >= top.print_z -> No overlap, no trimming needed.
                // 3) base.print_z > top.print_z  && base.bottom_z >= top.bottom_z -> Overlap, which will be solved inside generate_toolpaths() by reducing the base layer height where it overlaps the top layer. No trimming needed here.
                // 4) base.print_z > top.bottom_z && base.bottom_z < top.bottom_z -> Base overlaps with top.bottom_z. This must not happen.
                // 5) base.print_z <= top.print_z  && base.bottom_z >= top.bottom_z -> Base is fully inside top. Trim base by top.
                idx_top_contact_above = idx_lower_or_equal(top_contacts, idx_top_contact_above, 
                    [&layer_intermediate](const SupportGeneratorLayer *layer){ return layer->bottom_z <= layer_intermediate.print_z - EPSILON; });
                // Collect all the top_contact layer intersecting with this layer.
                for (int idx_top_contact_overlapping = idx_top_contact_above; idx_top_contact_overlapping >= 0; -- idx_top_contact_overlapping) {
                    SupportGeneratorLayer &layer_top_overlapping = *top_contacts[idx_top_contact_overlapping];
                    if (layer_top_overlapping.print_z < layer_intermediate.bottom_z + EPSILON)
                        break;
                    // Base must not overlap with top.bottom_z.
                    assert(! (layer_intermediate.print_z > layer_top_overlapping.bottom_z + EPSILON && layer_intermediate.bottom_z < layer_top_overlapping.bottom_z - EPSILON));
                    if (layer_intermediate.print_z <= layer_top_overlapping.print_z + EPSILON && layer_intermediate.bottom_z >= layer_top_overlapping.bottom_z - EPSILON)
                        // Base is fully inside top. Trim base by top.
                        polygons_append(polygons_trimming, layer_top_overlapping.polygons);
                }
 
                if (idx_object_layer_above < 0) {
                    // layer_support_areas are synchronized with object layers and they contain projections of the contact layers above them.
                    // This intermediate layer is not above any object layer, thus there is no information in layer_support_areas about
                    // towers supporting contact layers intersecting the first object layer. Project these contact layers now.
                    polygons_new = layer_support_areas.front();
                    double first_layer_z = object.layers().front()->print_z;
                    for (int i = idx_top_contact_above + 1; i < int(top_contacts.size()); ++ i) {
                        SupportGeneratorLayer &contacts = *top_contacts[i];
                        if (contacts.print_z > first_layer_z + EPSILON)
                            break;
                        assert(contacts.bottom_z > layer_intermediate.print_z - EPSILON);
                        polygons_append(polygons_new, contacts.polygons);
                    }
                } else
                    polygons_new = layer_support_areas[idx_object_layer_above];
 
                // Trimming the base layer with any overlapping bottom layer.
                // Following cases are recognized:
                // 1) bottom.bottom_z >= base.top_z -> No overlap, no trimming needed.
                // 2) base.bottom_z >= bottom.print_z -> No overlap, no trimming needed.
                // 3) base.print_z > bottom.bottom_z && base.bottom_z < bottom.bottom_z -> Overlap, which will be solved inside generate_toolpaths() by reducing the bottom layer height where it overlaps the base layer. No trimming needed here.
                // 4) base.print_z > bottom.print_z  && base.bottom_z >= bottom.print_z -> Base overlaps with bottom.print_z. This must not happen.
                // 5) base.print_z <= bottom.print_z && base.bottom_z >= bottom.bottom_z -> Base is fully inside top. Trim base by top.
                idx_bottom_contact_overlapping = idx_lower_or_equal(bottom_contacts, idx_bottom_contact_overlapping, 
                    [&layer_intermediate](const SupportGeneratorLayer *layer){ return layer->bottom_print_z() <= layer_intermediate.print_z - EPSILON; });
                // Collect all the bottom_contacts layer intersecting with this layer.
                for (int i = idx_bottom_contact_overlapping; i >= 0; -- i) {
                    SupportGeneratorLayer &layer_bottom_overlapping = *bottom_contacts[i];
                    if (layer_bottom_overlapping.print_z < layer_intermediate.bottom_print_z() + EPSILON)
                        break; 
                    // Base must not overlap with bottom.top_z.
                    assert(! (layer_intermediate.print_z > layer_bottom_overlapping.print_z + EPSILON && layer_intermediate.bottom_z < layer_bottom_overlapping.print_z - EPSILON));
                    if (layer_intermediate.print_z <= layer_bottom_overlapping.print_z + EPSILON && layer_intermediate.bottom_z >= layer_bottom_overlapping.bottom_print_z() - EPSILON)
                        // Base is fully inside bottom. Trim base by bottom.
                        polygons_append(polygons_trimming, layer_bottom_overlapping.polygons);
                }
 
        #ifdef SLIC3R_DEBUG
                {
                    BoundingBox bbox = get_extents(polygons_new);
                    bbox.merge(get_extents(polygons_trimming));
                    ::Slic3r::SVG svg(debug_out_path("support-intermediate-layers-raw-%d-%lf.svg", iRun, layer_intermediate.print_z), bbox);
                    svg.draw(union_ex(polygons_new),                    "blue", 0.5f);
                    svg.draw(to_polylines(polygons_new),                "blue");
                    svg.draw(union_safety_offset_ex(polygons_trimming), "red", 0.5f);
                    svg.draw(to_polylines(polygons_trimming),           "red");
                }
        #endif /* SLIC3R_DEBUG */
 
                // Trim the polygons, store them.
                if (polygons_trimming.empty())
                    layer_intermediate.polygons = std::move(polygons_new);
                else
                    layer_intermediate.polygons = diff(
                        polygons_new,
                        polygons_trimming,
                        ApplySafetyOffset::Yes); // safety offset to merge the touching source polygons
                layer_intermediate.layer_type = SupporLayerType::Base;
 
        #if 0
                    // coordf_t fillet_radius_scaled = scale_(m_object_config->support_base_pattern_spacing);
                    // Fillet the base polygons and trim them again with the top, interface and contact layers.
                    $base->{$i} = diff(
                        offset2(
                            $base->{$i}, 
                            $fillet_radius_scaled, 
                            -$fillet_radius_scaled,
                            # Use a geometric offsetting for filleting.
                            JT_ROUND,
                            0.2*$fillet_radius_scaled),
                        $trim_polygons,
                        false); // don't apply the safety offset.
                }
        #endif
            }
        });
    BOOST_LOG_TRIVIAL(debug) << "PrintObjectSupportMaterial::generate_base_layers() in parallel - end";
 
#ifdef SLIC3R_DEBUG
    for (SupportGeneratorLayersPtr::const_iterator it = intermediate_layers.begin(); it != intermediate_layers.end(); ++it)
        ::Slic3r::SVG::export_expolygons(
            debug_out_path("support-intermediate-layers-untrimmed-%d-%lf.svg", iRun, (*it)->print_z),
            union_ex((*it)->polygons));
    ++ iRun;
#endif /* SLIC3R_DEBUG */
 
    this->trim_support_layers_by_object(object, intermediate_layers, m_slicing_params.gap_support_object, m_slicing_params.gap_object_support, m_support_params.gap_xy);
    trim_support_layers_by_belt_floor(m_slicing_params, *m_print_config, object, intermediate_layers);
}

References generate_base_layers(), and Slic3r::range().

Referenced by generate(), and generate_base_layers().

Here is the call graph for this function:

Here is the caller graph for this function:

has_contact_loops()

bool Slic3r::PrintObjectSupportMaterial::has_contact_loops ( ) const

inline

{ return m_object_config->support_interface_loop_pattern.value; }

References m_object_config.

has_raft()

bool Slic3r::PrintObjectSupportMaterial::has_raft ( ) const

inline

{ return m_slicing_params.has_raft(); }

References m_slicing_params.

Referenced by top_contact_layers().

Here is the caller graph for this function:

has_support()

bool Slic3r::PrintObjectSupportMaterial::has_support ( ) const

inline

{ return m_object_config->enable_support.value || m_object_config->enforce_support_layers; }

References m_object_config.

Referenced by build_plate_only(), and top_contact_layers().

Here is the caller graph for this function:

raft_and_intermediate_support_layers()

SupportGeneratorLayersPtr Slic3r::PrintObjectSupportMaterial::raft_and_intermediate_support_layers ( const PrintObject & object, const SupportGeneratorLayersPtr & bottom_contacts, const SupportGeneratorLayersPtr & top_contacts, SupportGeneratorLayerStorage & layer_storage ) const

private

{
    SupportGeneratorLayersPtr intermediate_layers;
 
    // Collect and sort the extremes (bottoms of the top contacts and tops of the bottom contacts).
    SupportGeneratorLayersPtr extremes;
    extremes.reserve(top_contacts.size() + bottom_contacts.size());
    for (size_t i = 0; i < top_contacts.size(); ++ i)
        // Bottoms of the top contact layers. In case of non-soluble supports,
        // the top contact layer thickness is not known yet.
        extremes.push_back(top_contacts[i]);
    for (size_t i = 0; i < bottom_contacts.size(); ++ i)
        // Tops of the bottom contact layers.
        extremes.push_back(bottom_contacts[i]);
    if (extremes.empty())
        return intermediate_layers;
 
    auto layer_extreme_lower = [](const SupportGeneratorLayer *l1, const SupportGeneratorLayer *l2) {
        coordf_t z1 = l1->extreme_z();
        coordf_t z2 = l2->extreme_z();
        // If the layers are aligned, return the top contact surface first.
        return z1 < z2 || (z1 == z2 && l1->layer_type == SupporLayerType::TopContact && l2->layer_type == SupporLayerType::BottomContact);
    };
    std::sort(extremes.begin(), extremes.end(), layer_extreme_lower);
 
    assert(extremes.empty() || 
        (extremes.front()->extreme_z() > m_slicing_params.raft_interface_top_z - EPSILON && 
          (m_slicing_params.raft_layers() == 1 || // only raft contact layer
           extremes.front()->layer_type == SupporLayerType::TopContact || // first extreme is a top contact layer
           extremes.front()->extreme_z() > m_slicing_params.first_print_layer_height - EPSILON)));
 
    bool synchronize = this->synchronize_layers();
 
#ifdef _DEBUG
    // Verify that the extremes are separated by m_support_layer_height_min.
    for (size_t i = 1; i < extremes.size(); ++ i) {
        assert(extremes[i]->extreme_z() - extremes[i-1]->extreme_z() == 0. ||
               extremes[i]->extreme_z() - extremes[i-1]->extreme_z() > m_support_params.support_layer_height_min - EPSILON);
        assert(extremes[i]->extreme_z() - extremes[i-1]->extreme_z() > 0. ||
               extremes[i]->layer_type == extremes[i-1]->layer_type ||
               (extremes[i]->layer_type == SupporLayerType::BottomContact && extremes[i - 1]->layer_type == SupporLayerType::TopContact));
    }
#endif
 
    // Generate intermediate layers.
    // The first intermediate layer is the same as the 1st layer if there is no raft,
    // or the bottom of the first intermediate layer is aligned with the bottom of the raft contact layer.
    // Intermediate layers are always printed with a normal extrusion flow (non-bridging).
    size_t idx_layer_object = 0;
    size_t idx_extreme_first = 0;
    if (! extremes.empty() && std::abs(extremes.front()->extreme_z() - m_slicing_params.raft_interface_top_z) < EPSILON) {
        // This is a raft contact layer, its height has been decided in this->top_contact_layers().
        // Ignore this layer when calculating the intermediate support layers.
        assert(extremes.front()->layer_type == SupporLayerType::TopContact);
        ++ idx_extreme_first;
    }
    for (size_t idx_extreme = idx_extreme_first; idx_extreme < extremes.size(); ++ idx_extreme) {
        SupportGeneratorLayer      *extr2  = extremes[idx_extreme];
        coordf_t      extr2z = extr2->extreme_z();
        if (std::abs(extr2z - m_slicing_params.first_print_layer_height) < EPSILON) {
            // This is a bottom of a synchronized (or soluble) top contact layer, its height has been decided in this->top_contact_layers().
            assert(extr2->layer_type == SupporLayerType::TopContact);
            assert(std::abs(extr2->bottom_z - m_slicing_params.first_print_layer_height) < EPSILON);
            assert(extr2->print_z >= m_slicing_params.first_print_layer_height + m_support_params.support_layer_height_min - EPSILON);
            if (intermediate_layers.empty() || intermediate_layers.back()->print_z < m_slicing_params.first_print_layer_height) {
                SupportGeneratorLayer &layer_new = layer_storage.allocate(SupporLayerType::Intermediate);
                layer_new.bottom_z = 0.;
                layer_new.print_z  = m_slicing_params.first_print_layer_height;
                layer_new.height   = m_slicing_params.first_print_layer_height;
                intermediate_layers.push_back(&layer_new);
            }
            continue;
        }
        assert(extr2z >= m_slicing_params.raft_interface_top_z + EPSILON);
        assert(extr2z >= m_slicing_params.first_print_layer_height + EPSILON);
        SupportGeneratorLayer      *extr1  = (idx_extreme == idx_extreme_first) ? nullptr : extremes[idx_extreme - 1];
        // Fuse a support layer firmly to the raft top interface (not to the raft contacts).
        coordf_t      extr1z = (extr1 == nullptr) ? m_slicing_params.raft_interface_top_z : extr1->extreme_z();
        assert(extr2z >= extr1z);
        assert(extr2z > extr1z || (extr1 != nullptr && extr2->layer_type == SupporLayerType::BottomContact));
        if (std::abs(extr1z) < EPSILON) {
            // This layer interval starts with the 1st layer. Print the 1st layer using the prescribed 1st layer thickness.
            // assert(! m_slicing_params.has_raft()); RaftingEdition: unclear where the issue is: assert fails with 1-layer raft & base supports
            assert(intermediate_layers.empty() || intermediate_layers.back()->print_z <= m_slicing_params.first_print_layer_height);
            // At this point only layers above first_print_layer_heigth + EPSILON are expected as the other cases were captured earlier.
            assert(extr2z >= m_slicing_params.first_print_layer_height + EPSILON);
            // Generate a new intermediate layer.
            SupportGeneratorLayer &layer_new = layer_storage.allocate(SupporLayerType::Intermediate);
            layer_new.bottom_z = 0.;
            layer_new.print_z  = extr1z = m_slicing_params.first_print_layer_height;
            layer_new.height   = extr1z;
            intermediate_layers.push_back(&layer_new);
            // Continue printing the other layers up to extr2z.
        }
        coordf_t      dist   = extr2z - extr1z;
        assert(dist >= 0.);
        if (dist == 0.)
            continue;
        // The new layers shall be at least m_support_layer_height_min thick.
        assert(dist >= m_support_params.support_layer_height_min - EPSILON);
        if (synchronize) {
            // Emit support layers synchronized with the object layers.
            // Find the first object layer, which has its print_z in this support Z range.
            while (idx_layer_object < object.layers().size() && object.layers()[idx_layer_object]->print_z < extr1z + EPSILON)
                ++ idx_layer_object;
            if (idx_layer_object == 0 && extr1z == m_slicing_params.raft_interface_top_z) {
                // Insert one base support layer below the object.
                SupportGeneratorLayer &layer_new = layer_storage.allocate(SupporLayerType::Intermediate);
                layer_new.print_z  = m_slicing_params.object_print_z_min;
                layer_new.bottom_z = m_slicing_params.raft_interface_top_z;
                layer_new.height   = layer_new.print_z - layer_new.bottom_z;
                intermediate_layers.push_back(&layer_new);
            }
            // Emit all intermediate support layers synchronized with object layers up to extr2z.
            for (; idx_layer_object < object.layers().size() && object.layers()[idx_layer_object]->print_z < extr2z + EPSILON; ++ idx_layer_object) {
                SupportGeneratorLayer &layer_new = layer_storage.allocate(SupporLayerType::Intermediate);
                layer_new.print_z  = object.layers()[idx_layer_object]->print_z;
                layer_new.height   = object.layers()[idx_layer_object]->height;
                layer_new.bottom_z = (idx_layer_object > 0) ? object.layers()[idx_layer_object - 1]->print_z : (layer_new.print_z - layer_new.height);
                assert(intermediate_layers.empty() || intermediate_layers.back()->print_z < layer_new.print_z + EPSILON);
                intermediate_layers.push_back(&layer_new);
            }
        } else {
            // ORCA: Bias by EPSILON so a gap effectively equal to
            // max_suport_layer_height is not split by floating-point noise.
            size_t n_layers_extra = size_t(ceil((dist - EPSILON) / m_slicing_params.max_suport_layer_height));
            assert(n_layers_extra > 0);
            coordf_t      step   = dist / coordf_t(n_layers_extra);
            if (extr1 != nullptr && extr1->layer_type == SupporLayerType::TopContact &&
                extr1->print_z + m_support_params.support_layer_height_min > extr1->bottom_z + step) {
                // The bottom extreme is a bottom of a top surface. Ensure that the gap 
                // between the 1st intermediate layer print_z and extr1->print_z is not too small.
                assert(extr1->bottom_z + m_support_params.support_layer_height_min < extr1->print_z + EPSILON);
                // Generate the first intermediate layer.
                SupportGeneratorLayer &layer_new = layer_storage.allocate(SupporLayerType::Intermediate);
                layer_new.bottom_z = extr1->bottom_z;
                layer_new.print_z  = extr1z = extr1->print_z;
                layer_new.height   = extr1->height;
                intermediate_layers.push_back(&layer_new);
                dist = extr2z - extr1z;
                // ORCA: Recalculate with the same EPSILON bias after re-anchoring at the top
                // contact layer so near-equal gaps do not gain an extra split here either.
                n_layers_extra = size_t(ceil((dist - EPSILON) / m_slicing_params.max_suport_layer_height));
                if (n_layers_extra == 0)
                    continue;
                // Continue printing the other layers up to extr2z.
                step = dist / coordf_t(n_layers_extra);
            }
            if (!m_slicing_params.zero_gap_interface_top && extr2->layer_type == SupporLayerType::TopContact) {
                // This is a top interface layer, which does not have a height assigned yet. Do it now.
                assert(extr2->height == 0.);
                assert(extr1z > m_slicing_params.first_print_layer_height - EPSILON);
                extr2->height = step;
                extr2->bottom_z = extr2z = extr2->print_z - step;
                if (-- n_layers_extra == 0)
                    continue;
            }
            coordf_t extr2z_large_steps = extr2z;
            // Take the largest allowed step in the Z axis until extr2z_large_steps is reached.
            for (size_t i = 0; i < n_layers_extra; ++ i) {
                SupportGeneratorLayer &layer_new = layer_storage.allocate(SupporLayerType::Intermediate);
                if (i + 1 == n_layers_extra) {
                    // Last intermediate layer added. Align the last entered layer with extr2z_large_steps exactly.
                    layer_new.bottom_z = (i == 0) ? extr1z : intermediate_layers.back()->print_z;
                    layer_new.print_z = extr2z_large_steps;
                    layer_new.height = layer_new.print_z - layer_new.bottom_z;
                }
                else {
                    // Intermediate layer, not the last added.
                    layer_new.height = step;
                    layer_new.bottom_z = extr1z + i * step;
                    layer_new.print_z = layer_new.bottom_z + step;
                }
                assert(intermediate_layers.empty() || intermediate_layers.back()->print_z <= layer_new.print_z);
                intermediate_layers.push_back(&layer_new);
            }
        }
    }
 
#ifdef _DEBUG
    for (size_t i = 0; i < top_contacts.size(); ++i)
        assert(top_contacts[i]->height > 0.);
#endif /* _DEBUG */
    
    return intermediate_layers;
}

References Slic3r::SupportGeneratorLayerStorage::allocate(), Slic3r::SupportGeneratorLayer::bottom_z, Slic3r::BottomContact, Slic3r::Geometry::dist(), EPSILON, Slic3r::SupportGeneratorLayer::extreme_z(), Slic3r::SupportGeneratorLayer::height, Slic3r::Intermediate, Slic3r::l2(), Slic3r::SupportGeneratorLayer::layer_type, m_slicing_params, m_support_params, Slic3r::SupportGeneratorLayer::print_z, raft_and_intermediate_support_layers(), synchronize_layers(), and Slic3r::TopContact.

Referenced by generate(), and raft_and_intermediate_support_layers().

Here is the call graph for this function:

Here is the caller graph for this function:

synchronize_layers()

bool Slic3r::PrintObjectSupportMaterial::synchronize_layers ( ) const

inline

{ return /*m_slicing_params.zero_gap_interface_top && */!m_print_config->independent_support_layer_height.value; }

References m_print_config.

Referenced by raft_and_intermediate_support_layers().

Here is the caller graph for this function:

top_contact_layers()

SupportGeneratorLayersPtr Slic3r::PrintObjectSupportMaterial::top_contact_layers ( const PrintObject & object, const std::vector< Polygons > & buildplate_covered, SupportGeneratorLayerStorage & layer_storage ) const

private

{
#ifdef SLIC3R_DEBUG
    static int iRun = 0;
    ++ iRun; 
    #define SLIC3R_IRUN , iRun
#endif /* SLIC3R_DEBUG */
 
    // BBS: tree support is selected so normal supports need not be generated.
    // Note we still need to go through the following steps if support is disabled but raft is enabled.
    if (m_object_config->enable_support.value && (m_object_config->support_type.value != stNormalAuto && m_object_config->support_type.value != stNormal)) {
        return SupportGeneratorLayersPtr();
    }
 
    // Slice support enforcers / support blockers.
    SupportAnnotations annotations(object, buildplate_covered);
 
    // Output layers, sorted by top Z.
    SupportGeneratorLayersPtr contact_out;
 
    BOOST_LOG_TRIVIAL(debug) << "PrintObjectSupportMaterial::top_contact_layers() in parallel - start";
    // Determine top contact areas.
    // If generating raft only (no support), only calculate top contact areas for the 0th layer.
    // If having a raft, start with 0th layer, otherwise with 1st layer.
    // Note that layer_id < layer->id when raft_layers > 0 as the layer->id incorporates the raft layers.
    // So layer_id == 0 means first object layer and layer->id == 0 means first print layer if there are no explicit raft layers.
    size_t num_layers = this->has_support() ? object.layer_count() : 1;
    // For each overhang layer, two supporting layers may be generated: One for the overhangs extruded with a bridging flow, 
    // and the other for the overhangs extruded with a normal flow.
    contact_out.assign(num_layers * 2, nullptr);
 
    std::vector<ExPolygons> overhangs_per_layers(num_layers);
    size_t layer_id_start = this->has_raft() ? 0 : 1;
     // main part of overhang detection can be parallel
    tbb::parallel_for(tbb::blocked_range<size_t>(layer_id_start, num_layers),
        [&](const tbb::blocked_range<size_t>& range) {
            for (size_t layer_id = range.begin(); layer_id < range.end(); layer_id++) {
                const Layer& layer = *object.layers()[layer_id];
                Polygons            lower_layer_polygons = (layer_id == 0) ? Polygons() : to_polygons(object.layers()[layer_id - 1]->lslices);
 
                overhangs_per_layers[layer_id] = detect_overhangs(layer, layer_id, lower_layer_polygons, *m_print_config, *m_object_config, annotations, m_support_params.gap_xy
#ifdef SLIC3R_DEBUG
                    , iRun
#endif // SLIC3R_DEBUG
                );
 
                if (object.print()->canceled())
                    break;
            }
        }
    ); // end tbb::parallel_for
 
    if (object.print()->canceled())
        return SupportGeneratorLayersPtr();
 
    // check if the sharp tails should be extended higher
    bool detect_first_sharp_tail_only = false;
    const coordf_t extrusion_width = m_object_config->line_width.get_abs_value(nozzle_diameter_for_filament(object.print()->config(), object.config().support_interface_filament, object.print()->is_BBL_printer()));
    const coordf_t extrusion_width_scaled = scale_(extrusion_width);
    if (is_auto(m_object_config->support_type.value) && g_config_support_sharp_tails && !detect_first_sharp_tail_only) {
        for (size_t layer_nr = layer_id_start; layer_nr < num_layers; layer_nr++) {
            if (object.print()->canceled())
                break;
 
            const Layer* layer = object.get_layer(layer_nr);
            const Layer* lower_layer = layer->lower_layer;
            if (!lower_layer)
                continue;
 
            // BBS detect sharp tail
            const ExPolygons& lower_layer_sharptails = lower_layer->sharp_tails;
            const auto& lower_layer_sharptails_height = lower_layer->sharp_tails_height;
            for (const ExPolygon& expoly : layer->lslices) {
                bool  is_sharp_tail = false;
                float accum_height = layer->height;
                do {
                    // 2. something below
                    // check whether this is above a sharp tail region.
 
                    // 2.1 If no sharp tail below, this is considered as common region.
                    ExPolygons supported_by_lower = intersection_ex({ expoly }, lower_layer_sharptails);
                    if (supported_by_lower.empty()) {
                        is_sharp_tail = false;
                        break;
                    }
 
                    // 2.2 If sharp tail below, check whether it support this region enough.
#if 0
                    // judge by area isn't reliable, failure cases include 45 degree rotated cube
                    float       supported_area = area(supported_by_lower);
                    if (supported_area > area_thresh_well_supported) {
                        is_sharp_tail = false;
                        break;
                    }
#endif
                    BoundingBox bbox = get_extents(supported_by_lower);
                    if (bbox.size().x() > length_thresh_well_supported && bbox.size().y() > length_thresh_well_supported) {
                        is_sharp_tail = false;
                        break;
                    }
 
                    // 2.3 check whether sharp tail exceed the max height
                    for (size_t i = 0; i < lower_layer_sharptails_height.size();i++) {
                        if (lower_layer_sharptails[i].overlaps(expoly)) {
                            accum_height += lower_layer_sharptails_height[i];
                            break;
                        }
                    }
                    if (accum_height > sharp_tail_max_support_height) {
                        is_sharp_tail = false;
                        break;
                    }
 
                    // 2.4 if the area grows fast than threshold, it get connected to other part or
                    // it has a sharp slop and will be auto supported.
                    ExPolygons new_overhang_expolys = diff_ex({ expoly }, lower_layer_sharptails);
                    Point size_diff = get_extents(new_overhang_expolys).size() - get_extents(lower_layer_sharptails).size();
                    if (size_diff.both_comp(Point(scale_(5), scale_(5)), ">") || !offset_ex(new_overhang_expolys, -5.0 * extrusion_width_scaled).empty()) {
                        is_sharp_tail = false;
                        break;
                    }
 
                    // 2.5 mark the expoly as sharptail
                    is_sharp_tail = true;
                } while (0);
 
                if (is_sharp_tail) {
                    ExPolygons overhang = diff_ex({ expoly }, lower_layer->lslices);
                    layer->sharp_tails.push_back(expoly);
                    layer->sharp_tails_height.push_back( accum_height );
 
                    // Apply the "support blockers".
                    if (!annotations.blockers_layers.empty() && !annotations.blockers_layers[layer_nr].empty()) {
                        const auto& blocker = annotations.blockers_layers[layer_nr];
                        overhang            = diff_ex(overhang, blocker);
                    }
 
                    append(overhangs_per_layers[layer_nr], overhang);
                }
 
            }
        }
    }
 
    if (object.print()->canceled())
        return SupportGeneratorLayersPtr();
 
    // BBS group overhang clusters
    const bool config_remove_small_overhangs = m_object_config->support_remove_small_overhang.value;
    if (config_remove_small_overhangs) {
        std::vector<OverhangCluster> clusters;
      double fw_scaled = scale_(extrusion_width);
        std::set<ExPolygon*> removed_overhang;
 
        for (size_t layer_id = layer_id_start; layer_id < num_layers; layer_id++) {
            const Layer* layer = object.get_layer(layer_id);
            for (auto& overhang : overhangs_per_layers[layer_id]) {
                OverhangCluster* cluster = add_overhang(clusters, &overhang, layer_id, fw_scaled);
                if (overlaps({ overhang }, layer->cantilevers))
                    cluster->is_cantilever = true;
            }
        }
 
        for (OverhangCluster& cluster : clusters) {
            // 3. check whether the small overhang is sharp tail
            cluster.is_sharp_tail = false;
            for (size_t layer_id = cluster.min_layer; layer_id <= cluster.max_layer; layer_id++) {
                const Layer* layer = object.get_layer(layer_id);
                if (overlaps(layer->sharp_tails, cluster.merged_overhangs_dilated)) {
                    cluster.is_sharp_tail = true;
                    break;
                }
            }
 
            if (!cluster.is_sharp_tail && !cluster.is_cantilever) {
                // 2. check overhang cluster size is small
                cluster.is_small_overhang = false;
                auto erode1 = offset_ex(cluster.merged_overhangs_dilated, -1.0 * fw_scaled);
                Point bbox_sz = get_extents(erode1).size();
                if (bbox_sz.x() < 2 * fw_scaled || bbox_sz.y() < 2 * fw_scaled) {
                    cluster.is_small_overhang = true;
                }
            }
 
#ifdef SUPPORT_TREE_DEBUG_TO_SVG
            const Layer* layer1 = object.get_layer(cluster.min_layer);
            BoundingBox bbox = get_extents(cluster.merged_overhangs_dilated);
            bbox.merge(get_extents(layer1->lslices));
            SVG svg(format("SVG/overhangCluster_%s_%s_tail=%s_cantilever=%s_small=%s.svg", cluster.min_layer, layer1->print_z, cluster.is_sharp_tail, cluster.is_cantilever, cluster.is_small_overhang), bbox);
            if (svg.is_opened()) {
                svg.draw(layer1->lslices, "red");
                svg.draw(cluster.merged_overhangs_dilated, "blue");
            }
#endif
 
            // 5. remove small overhangs
            if (cluster.is_small_overhang) {
                for (auto overhangs : cluster.layer_overhangs) {
                    for (auto* poly : overhangs.second)
                        removed_overhang.insert(poly);
                }
            }
        }
 
        for (size_t layer_id = layer_id_start; layer_id < num_layers; layer_id++) {
            auto& layer_overhangs = overhangs_per_layers[layer_id];
            if (layer_overhangs.empty())
                continue;
 
            for (int poly_idx = 0; poly_idx < layer_overhangs.size(); poly_idx++) {
                auto* overhang = &layer_overhangs[poly_idx];
                if (removed_overhang.find(overhang) != removed_overhang.end()) {
                    overhang->clear();
                }
            }
        }
    }
 
    if (object.print()->canceled())
        return SupportGeneratorLayersPtr();
 
    for (size_t layer_id = layer_id_start; layer_id < num_layers; layer_id++) {
        const Layer& layer = *object.layers()[layer_id];
        Polygons            overhang_polygons = to_polygons(overhangs_per_layers[layer_id]);
        Polygons            lower_layer_polygons = (layer_id == 0) ? Polygons() : to_polygons(object.layers()[layer_id - 1]->lslices);
        SlicesMarginCache   slices_margin;
 
        auto [contact_polygons, enforcer_polygons, no_interface_offset] =
            detect_contacts(layer, layer_id, overhang_polygons, lower_layer_polygons, *m_print_config, *m_object_config, annotations, slices_margin, m_support_params.gap_xy
#ifdef SLIC3R_DEBUG
                , iRun
#endif // SLIC3R_DEBUG
            );
 
        // Now apply the contact areas to the layer where they need to be made.
        if (!contact_polygons.empty() || !overhang_polygons.empty()) {
            // Allocate the two empty layers.
            auto [new_layer, bridging_layer] = new_contact_layer(*m_print_config, *m_object_config, m_slicing_params, m_support_params.support_layer_height_min, layer, layer_storage);
            if (new_layer) {
                // Fill the non-bridging layer with polygons.
                fill_contact_layer(*new_layer, layer_id, m_slicing_params,
                    *m_object_config, slices_margin, overhang_polygons, contact_polygons, enforcer_polygons, lower_layer_polygons,
                    m_support_params.support_material_flow, no_interface_offset
#ifdef SLIC3R_DEBUG
                    , iRun, layer
#endif // SLIC3R_DEBUG
                );
                // Insert new layer even if there is no interface generated: Likely the support angle is not steep enough to require dense interface,
                // however generating a sparse support will be useful for the object stability.
                // if (! new_layer->polygons.empty())
                contact_out[layer_id * 2] = new_layer;
                if (bridging_layer != nullptr) {
                    bridging_layer->polygons = new_layer->polygons;
                    bridging_layer->contact_polygons = std::make_unique<Polygons>(*new_layer->contact_polygons);
                    bridging_layer->overhang_polygons = std::make_unique<Polygons>(*new_layer->overhang_polygons);
                    if (new_layer->enforcer_polygons)
                        bridging_layer->enforcer_polygons = std::make_unique<Polygons>(*new_layer->enforcer_polygons);
                    contact_out[layer_id * 2 + 1] = bridging_layer;
                }
            }
        }
    }
 
    // Compress contact_out, remove the nullptr items.
    remove_nulls(contact_out);
 
    // Merge close contact layers conservatively: If two layers are closer than the minimum allowed print layer height (the min_layer_height parameter),
    // the top contact layer is merged into the bottom contact layer.
    merge_contact_layers(m_slicing_params, m_support_params.support_layer_height_min, contact_out);
 
    BOOST_LOG_TRIVIAL(debug) << "PrintObjectSupportMaterial::top_contact_layers() in parallel - end";
 
    return contact_out;
}

References Slic3r::add_overhang(), Slic3r::append(), Slic3r::area(), Slic3r::area_thresh_well_supported, Slic3r::SupportAnnotations::blockers_layers, buildplate_covered(), Slic3r::Layer::cantilevers, Slic3r::detect_contacts(), Slic3r::detect_overhangs(), Slic3r::diff_ex(), Slic3r::SVG::draw(), Slic3r::empty(), Slic3r::fill_contact_layer(), Slic3r::format(), g_config_support_sharp_tails, Slic3r::get_extents(), has_raft(), has_support(), Slic3r::Layer::height, Slic3r::intersection_ex(), Slic3r::is_auto(), Slic3r::SVG::is_opened(), Slic3r::length_thresh_well_supported, Slic3r::Layer::lower_layer, Slic3r::Layer::lslices, m_object_config, m_print_config, m_slicing_params, m_support_params, Slic3r::BoundingBoxBase< PointType, APointsType >::merge(), Slic3r::merge_contact_layers(), Slic3r::new_contact_layer(), Slic3r::nozzle_diameter_for_filament(), Slic3r::offset_ex(), Slic3r::overlaps(), Slic3r::Layer::print_z, Slic3r::range(), Slic3r::remove_nulls(), scale_, Slic3r::sharp_tail_max_support_height, Slic3r::Layer::sharp_tails, Slic3r::Layer::sharp_tails_height, Slic3r::BoundingBoxBase< PointType, APointsType >::size(), Slic3r::stNormal, Slic3r::stNormalAuto, Slic3r::to_polygons(), and top_contact_layers().

Referenced by generate(), and top_contact_layers().

Here is the call graph for this function:

Here is the caller graph for this function:

trim_support_layers_by_object()

void Slic3r::PrintObjectSupportMaterial::trim_support_layers_by_object ( const PrintObject & object, SupportGeneratorLayersPtr & support_layers, const coordf_t gap_extra_above, const coordf_t gap_extra_below, const coordf_t gap_xy ) const

private

{
    const float gap_xy_scaled = float(scale_(gap_xy));
 
    // Collect non-empty layers to be processed in parallel.
    // This is a good idea as pulling a thread from a thread pool for an empty task is expensive.
    SupportGeneratorLayersPtr nonempty_layers;
    nonempty_layers.reserve(support_layers.size());
    for (size_t idx_layer = 0; idx_layer < support_layers.size(); ++ idx_layer) {
        SupportGeneratorLayer *support_layer = support_layers[idx_layer];
        if (! support_layer->polygons.empty() && support_layer->print_z >= m_slicing_params.raft_contact_top_z + EPSILON)
            // Non-empty support layer and not a raft layer.
            nonempty_layers.push_back(support_layer);
    }
 
    // For all intermediate support layers:
    BOOST_LOG_TRIVIAL(debug) << "PrintObjectSupportMaterial::trim_support_layers_by_object() in parallel - start";
    tbb::parallel_for(
        tbb::blocked_range<size_t>(0, nonempty_layers.size()),
        [this, &object, &nonempty_layers, gap_extra_above, gap_extra_below, gap_xy_scaled](const tbb::blocked_range<size_t>& range) {
            size_t idx_object_layer_overlapping = size_t(-1);
 
            auto is_layers_overlap = [](const SupportGeneratorLayer& support_layer, const Layer& object_layer, coordf_t bridging_height = 0.f) -> bool {
                if (std::abs(support_layer.print_z - object_layer.print_z) < EPSILON)
                    return true;
 
                coordf_t object_lh = bridging_height > EPSILON ? bridging_height : object_layer.height;
                if (support_layer.print_z < object_layer.print_z && support_layer.print_z > object_layer.print_z - object_lh)
                    return true;
 
                if (support_layer.print_z > object_layer.print_z && support_layer.bottom_z < object_layer.print_z - EPSILON)
                    return true;
 
                return false;
            };
            for (size_t idx_layer = range.begin(); idx_layer < range.end(); ++ idx_layer) {
                SupportGeneratorLayer &support_layer = *nonempty_layers[idx_layer];
                // BOOST_LOG_TRIVIAL(trace) << "Support generator - trim_support_layers_by_object - trimmming non-empty layer " << idx_layer << " of " << nonempty_layers.size();
                assert(! support_layer.polygons.empty() && support_layer.print_z >= m_slicing_params.raft_contact_top_z + EPSILON);
                // Find the overlapping object layers including the extra above / below gap.
                coordf_t z_threshold = support_layer.bottom_print_z() - gap_extra_below + EPSILON;
                idx_object_layer_overlapping = Layer::idx_higher_or_equal(
                    object.layers().begin(), object.layers().end(), idx_object_layer_overlapping,
                    [z_threshold](const Layer *layer){ return layer->print_z >= z_threshold; });
                // Collect all the object layers intersecting with this layer.
                Polygons polygons_trimming;
                size_t i = idx_object_layer_overlapping;
                for (; i < object.layers().size(); ++ i) {
                    const Layer &object_layer = *object.layers()[i];
                    if (object_layer.bottom_z() > support_layer.print_z + gap_extra_above - EPSILON)
                        break;
 
                    bool is_overlap = is_layers_overlap(support_layer, object_layer);
                    for (const ExPolygon& expoly : object_layer.lslices) {
                        // BBS
                        bool is_sharptail = !intersection_ex({ expoly }, object_layer.sharp_tails).empty();
                        coordf_t trimming_offset = is_sharptail ? scale_(sharp_tail_xy_gap) :
                                                   is_overlap ? gap_xy_scaled :
                                                   scale_(no_overlap_xy_gap);
                        polygons_append(polygons_trimming, offset({ expoly }, trimming_offset, SUPPORT_SURFACES_OFFSET_PARAMETERS));
                    }
                }
                if (!m_slicing_params.zero_gap_interface_top && m_object_config->thick_bridges) {
                    // Collect all bottom surfaces, which will be extruded with a bridging flow.
                    for (; i < object.layers().size(); ++ i) {
                        const Layer &object_layer = *object.layers()[i];
                        bool some_region_overlaps = false;
                        for (LayerRegion *region : object_layer.regions()) {
                            coordf_t bridging_height = region->region().bridging_height_avg(*m_print_config);
                            if (object_layer.print_z - bridging_height > support_layer.print_z + gap_extra_above - EPSILON)
                                break;
                            some_region_overlaps = true;
 
                            bool is_overlap = is_layers_overlap(support_layer, object_layer, bridging_height);
                            coordf_t trimming_offset = is_overlap ? gap_xy_scaled : scale_(no_overlap_xy_gap);
                            polygons_append(polygons_trimming, 
                                offset(region->fill_surfaces.filter_by_type(stBottomBridge), trimming_offset, SUPPORT_SURFACES_OFFSET_PARAMETERS));
                            if (region->region().config().detect_overhang_wall.value)
                                // Add bridging perimeters.
                                SupportMaterialInternal::collect_bridging_perimeter_areas(region->perimeters, gap_xy_scaled, polygons_trimming);
                        }
                        if (! some_region_overlaps)
                            break;
                    }
                }
 
                // $layer->slices contains the full shape of layer, thus including
                // perimeter's width. $support contains the full shape of support
                // material, thus including the width of its foremost extrusion.
                // We leave a gap equal to a full extrusion width.
                support_layer.polygons = diff(support_layer.polygons, polygons_trimming);
            }
        });
    BOOST_LOG_TRIVIAL(debug) << "PrintObjectSupportMaterial::trim_support_layers_by_object() in parallel - end";
}

References Slic3r::Layer::bottom_z(), Slic3r::SupportMaterialInternal::collect_bridging_perimeter_areas(), Slic3r::diff(), Slic3r::empty(), EPSILON, Slic3r::intersection_ex(), Slic3r::Layer::lslices, m_object_config, m_print_config, m_slicing_params, Slic3r::no_overlap_xy_gap, Slic3r::offset(), Slic3r::SupportGeneratorLayer::polygons, Slic3r::polygons_append(), Slic3r::Layer::print_z, Slic3r::SupportGeneratorLayer::print_z, Slic3r::range(), Slic3r::Layer::regions(), scale_, Slic3r::sharp_tail_xy_gap, Slic3r::Layer::sharp_tails, Slic3r::stBottomBridge, SUPPORT_SURFACES_OFFSET_PARAMETERS, and trim_support_layers_by_object().

Referenced by bottom_contact_layers_and_layer_support_areas(), generate(), and trim_support_layers_by_object().

Here is the call graph for this function:

Here is the caller graph for this function:

trim_top_contacts_by_bottom_contacts()

void Slic3r::PrintObjectSupportMaterial::trim_top_contacts_by_bottom_contacts ( const PrintObject & object, const SupportGeneratorLayersPtr & bottom_contacts, SupportGeneratorLayersPtr & top_contacts ) const

private

{
    tbb::parallel_for(tbb::blocked_range<int>(0, int(top_contacts.size())),
        [&bottom_contacts, &top_contacts](const tbb::blocked_range<int>& range) {
            int idx_bottom_overlapping_first = -2;
            // For all top contact layers, counting downwards due to the way idx_higher_or_equal caches the last index to avoid repeated binary search.
            for (int idx_top = range.end() - 1; idx_top >= range.begin(); -- idx_top) {
                SupportGeneratorLayer &layer_top = *top_contacts[idx_top];
                // Find the first bottom layer overlapping with layer_top.
                idx_bottom_overlapping_first = idx_lower_or_equal(bottom_contacts, idx_bottom_overlapping_first, [&layer_top](const SupportGeneratorLayer *layer_bottom){ return layer_bottom->bottom_print_z() - EPSILON <= layer_top.bottom_z; });
                // For all top contact layers overlapping with the thick bottom contact layer:
                for (int idx_bottom_overlapping = idx_bottom_overlapping_first; idx_bottom_overlapping >= 0; -- idx_bottom_overlapping) {
                    const SupportGeneratorLayer &layer_bottom = *bottom_contacts[idx_bottom_overlapping];
                    assert(layer_bottom.bottom_print_z() - EPSILON <= layer_top.bottom_z);
                    if (layer_top.print_z < layer_bottom.print_z + EPSILON) {
                        // Layers overlap. Trim layer_top with layer_bottom.
                        layer_top.polygons = diff(layer_top.polygons, layer_bottom.polygons);
                    } else
                        break;
                }
            }
        });
}

References Slic3r::range(), and trim_top_contacts_by_bottom_contacts().

Referenced by generate(), and trim_top_contacts_by_bottom_contacts().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_object_config

const PrintObjectConfig* Slic3r::PrintObjectSupportMaterial::m_object_config

private

Referenced by PrintObjectSupportMaterial(), bottom_contact_layers_and_layer_support_areas(), build_plate_only(), generate(), has_contact_loops(), has_support(), top_contact_layers(), and trim_support_layers_by_object().

m_print_config

const PrintConfig* Slic3r::PrintObjectSupportMaterial::m_print_config

private

Referenced by PrintObjectSupportMaterial(), bottom_contact_layers_and_layer_support_areas(), generate(), synchronize_layers(), top_contact_layers(), and trim_support_layers_by_object().

m_slicing_params

SlicingParameters Slic3r::PrintObjectSupportMaterial::m_slicing_params

private

Referenced by PrintObjectSupportMaterial(), bottom_contact_layers_and_layer_support_areas(), generate(), has_raft(), raft_and_intermediate_support_layers(), top_contact_layers(), and trim_support_layers_by_object().

m_support_params

SupportParameters Slic3r::PrintObjectSupportMaterial::m_support_params

private

Referenced by PrintObjectSupportMaterial(), bottom_contact_layers_and_layer_support_areas(), generate(), raft_and_intermediate_support_layers(), and top_contact_layers().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Support/SupportMaterial.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Support/SupportMaterial.cpp