Slic3r::SLAPrint::Steps Class Reference

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

Collaboration diagram for Slic3r::SLAPrint::Steps:

Public Member Functions
	Steps (SLAPrint *print)
void	hollow_model (SLAPrintObject &po)
void	drill_holes (SLAPrintObject &po)
void	slice_model (SLAPrintObject &po)
void	support_points (SLAPrintObject &po)
void	support_tree (SLAPrintObject &po)
void	generate_pad (SLAPrintObject &po)
void	slice_supports (SLAPrintObject &po)
void	merge_slices_and_eval_stats ()
void	rasterize ()
void	execute (SLAPrintObjectStep step, SLAPrintObject &obj)
void	execute (SLAPrintStep step)
double	progressrange (SLAPrintObjectStep step) const
double	progressrange (SLAPrintStep step) const

Static Public Member Functions
static std::string	label (SLAPrintObjectStep step)
static std::string	label (SLAPrintStep step)

Static Public Attributes
static const constexpr unsigned	min_objstatus = 0
static const constexpr unsigned	max_objstatus = 50

Private Member Functions
template<class... Args>
void	report_status (Args &&...args)
double	current_status () const
void	throw_if_canceled () const
bool	canceled () const
void	initialize_printer_input ()
void	apply_printer_corrections (SLAPrintObject &po, SliceOrigin o)

Private Attributes
SLAPrint *	m_print = nullptr
std::mt19937	m_rng
const size_t	objcount
const double	ilhd
const float	ilh
const coord_t	ilhs
const double	objectstep_scale

Detailed Description

Constructor & Destructor Documentation

Steps()

Slic3r::SLAPrint::Steps::Steps ( SLAPrint * print )

explicit

    : m_print{print}
    , m_rng{std::random_device{}()}
    , objcount{m_print->m_objects.size()}
    , ilhd{m_print->m_material_config.initial_layer_height.getFloat()}
    , ilh{float(ilhd)}
    , ilhs{scaled(ilhd)}
    , objectstep_scale{(max_objstatus - min_objstatus) / (objcount * 100.0)}
{}

References Slic3r::SLAPrint::SLAPrint(), ilh, ilhd, ilhs, Slic3r::SLAPrint::m_material_config, Slic3r::SLAPrint::m_objects, m_print, m_rng, max_objstatus, min_objstatus, objcount, objectstep_scale, and Slic3r::scaled().

Here is the call graph for this function:

Member Function Documentation

apply_printer_corrections()

void Slic3r::SLAPrint::Steps::apply_printer_corrections ( SLAPrintObject & po, SliceOrigin o )

private

{
    if (o == soSupport && !po.m_supportdata) return;
 
    auto faded_lyrs = size_t(po.m_config.faded_layers.getInt());
    double min_w = m_print->m_printer_config.elefant_foot_min_width.getFloat() / 2.;
    double start_efc = m_print->m_printer_config.elefant_foot_compensation.getFloat();
 
    double doffs = m_print->m_printer_config.absolute_correction.getFloat();
    coord_t clpr_offs = scaled(doffs);
 
    faded_lyrs = std::min(po.m_slice_index.size(), faded_lyrs);
    size_t faded_lyrs_efc = std::max(size_t(1), faded_lyrs - 1);
 
    auto efc = [start_efc, faded_lyrs_efc](size_t pos) {
        return (faded_lyrs_efc - pos) * start_efc / faded_lyrs_efc;
    };
 
    std::vector<ExPolygons> &slices = o == soModel ?
                                          po.m_model_slices :
                                          po.m_supportdata->support_slices;
 
    if (clpr_offs != 0) for (size_t i = 0; i < po.m_slice_index.size(); ++i) {
        size_t idx = po.m_slice_index[i].get_slice_idx(o);
        if (idx < slices.size())
            slices[idx] = offset_ex(slices[idx], float(clpr_offs));
    }
 
    if (start_efc > 0.) for (size_t i = 0; i < faded_lyrs; ++i) {
        size_t idx = po.m_slice_index[i].get_slice_idx(o);
        if (idx < slices.size())
            slices[idx] = elephant_foot_compensation(slices[idx], min_w, efc(i));
    }
}

References Slic3r::elephant_foot_compensation(), Slic3r::SLAPrintObject::m_config, Slic3r::SLAPrintObject::m_model_slices, m_print, Slic3r::SLAPrintObject::m_slice_index, Slic3r::SLAPrintObject::m_supportdata, Slic3r::offset_ex(), Slic3r::scaled(), Slic3r::SLAPrint::SLAPrintObject, Slic3r::soModel, and Slic3r::soSupport.

Referenced by slice_model(), and slice_supports().

Here is the call graph for this function:

Here is the caller graph for this function:

canceled()

bool Slic3r::SLAPrint::Steps::canceled ( ) const

inlineprivate

{ return m_print->canceled(); }

References m_print.

current_status()

double Slic3r::SLAPrint::Steps::current_status ( ) const

inlineprivate

{ return m_print->m_report_status.status(); }

References m_print.

Referenced by rasterize(), support_points(), and support_tree().

Here is the caller graph for this function:

drill_holes()

void Slic3r::SLAPrint::Steps::drill_holes

(

SLAPrintObject &

po

)

{
    /*
    bool needs_drilling = ! po.m_model_object->sla_drain_holes.empty();
    bool is_hollowed =
        (po.m_hollowing_data && po.m_hollowing_data->interior &&
         !sla::get_mesh(*po.m_hollowing_data->interior).empty());
 
    if (! is_hollowed && ! needs_drilling) {
        // In this case we can dump any data that might have been
        // generated on previous runs.
        po.m_hollowing_data.reset();
        return;
    }
 
    if (! po.m_hollowing_data)
        po.m_hollowing_data.reset(new SLAPrintObject::HollowingData());
 
    // Hollowing and/or drilling is active, m_hollowing_data is valid.
 
    // Regenerate hollowed mesh, even if it was there already. It may contain
    // holes that are no longer on the frontend.
    TriangleMesh &hollowed_mesh = po.m_hollowing_data->hollow_mesh_with_holes;
    hollowed_mesh = po.transformed_mesh();
    if (is_hollowed)
        sla::hollow_mesh(hollowed_mesh, *po.m_hollowing_data->interior);
 
    TriangleMesh &mesh_view = po.m_hollowing_data->hollow_mesh_with_holes_trimmed;
 
    if (! needs_drilling) {
        mesh_view = po.transformed_mesh();
 
        if (is_hollowed)
            sla::hollow_mesh(mesh_view, *po.m_hollowing_data->interior,
                             sla::hfRemoveInsideTriangles);
 
        BOOST_LOG_TRIVIAL(info) << "Drilling skipped (no holes).";
        return;
    }
 
    BOOST_LOG_TRIVIAL(info) << "Drilling drainage holes.";
    sla::DrainHoles drainholes = po.transformed_drainhole_points();
 
    auto tree = AABBTreeIndirect::build_aabb_tree_over_indexed_triangle_set(
        hollowed_mesh.its.vertices,
        hollowed_mesh.its.indices
    );
 
    std::uniform_real_distribution<float> dist(0., float(EPSILON));
    auto holes_mesh_cgal = MeshBoolean::cgal::triangle_mesh_to_cgal({}, {});
    indexed_triangle_set part_to_drill = hollowed_mesh.its;
 
    bool hole_fail = false;
    for (size_t i = 0; i < drainholes.size(); ++i) {
        sla::DrainHole holept = drainholes[i];
 
        holept.normal += Vec3f{dist(m_rng), dist(m_rng), dist(m_rng)};
        holept.normal.normalize();
        holept.pos += Vec3f{dist(m_rng), dist(m_rng), dist(m_rng)};
        indexed_triangle_set m = holept.to_mesh();
 
        part_to_drill.indices.clear();
        auto bb = bounding_box(m);
        Eigen::AlignedBox<float, 3> ebb{bb.min.cast<float>(),
                                        bb.max.cast<float>()};
        //BBS
        //AABBTreeIndirect::traverse(
        //            tree,
        //            AABBTreeIndirect::intersecting(ebb),
        //            [&part_to_drill, &hollowed_mesh](size_t faceid)
        //{
        //    part_to_drill.indices.emplace_back(hollowed_mesh.its.indices[faceid]);
        //});
 
        auto cgal_meshpart = MeshBoolean::cgal::triangle_mesh_to_cgal(
            remove_unconnected_vertices(part_to_drill));
 
        if (MeshBoolean::cgal::does_self_intersect(*cgal_meshpart)) {
            BOOST_LOG_TRIVIAL(error) << "Failed to drill hole";
 
            hole_fail = drainholes[i].failed =
                    po.model_object()->sla_drain_holes[i].failed = true;
 
            continue;
        }
 
        auto cgal_hole = MeshBoolean::cgal::triangle_mesh_to_cgal(m);
        MeshBoolean::cgal::plus(*holes_mesh_cgal, *cgal_hole);
    }
 
    if (MeshBoolean::cgal::does_self_intersect(*holes_mesh_cgal))
        throw Slic3r::SlicingError(L("Too many overlapping holes."));
 
    auto hollowed_mesh_cgal = MeshBoolean::cgal::triangle_mesh_to_cgal(hollowed_mesh);
 
    if (!MeshBoolean::cgal::does_bound_a_volume(*hollowed_mesh_cgal)) {
        po.active_step_add_warning(
            PrintStateBase::WarningLevel::NON_CRITICAL,
            L("Mesh to be hollowed is not suitable for hollowing (does not "
              "bound a volume)."));
    }
 
    if (!MeshBoolean::cgal::empty(*holes_mesh_cgal)
        && !MeshBoolean::cgal::does_bound_a_volume(*holes_mesh_cgal)) {
        po.active_step_add_warning(
            PrintStateBase::WarningLevel::NON_CRITICAL,
            L("Unable to drill the current configuration of holes into the "
              "model."));
    }
 
    try {
        if (!MeshBoolean::cgal::empty(*holes_mesh_cgal))
            MeshBoolean::cgal::minus(*hollowed_mesh_cgal, *holes_mesh_cgal);
 
        hollowed_mesh = MeshBoolean::cgal::cgal_to_triangle_mesh(*hollowed_mesh_cgal);
        mesh_view = hollowed_mesh;
 
        if (is_hollowed) {
            auto &interior = *po.m_hollowing_data->interior;
            std::vector<bool> exclude_mask =
                    create_exclude_mask(mesh_view.its, interior, drainholes);
 
            sla::remove_inside_triangles(mesh_view, interior, exclude_mask);
        }
    } catch (const Slic3r::RuntimeError &) {
        throw Slic3r::SlicingError(L(
            "Drilling holes into the mesh failed. "
            "This is usually caused by broken model. Try to fix it first."));
    }
 
    if (hole_fail)
        po.active_step_add_warning(PrintStateBase::WarningLevel::NON_CRITICAL,
                                   L("Failed to drill some holes into the model"));
     */
}

References Slic3r::SLAPrint::SLAPrintObject.

Referenced by execute().

Here is the caller graph for this function:

execute() [1/2]

void Slic3r::SLAPrint::Steps::execute	(	SLAPrintObjectStep	step,
		SLAPrintObject &	obj )

{
    switch(step) {
    case slaposHollowing: hollow_model(obj); break;
    case slaposDrillHoles: drill_holes(obj); break;
    case slaposObjectSlice: slice_model(obj); break;
    case slaposSupportPoints:  support_points(obj); break;
    case slaposSupportTree: support_tree(obj); break;
    case slaposPad: generate_pad(obj); break;
    case slaposSliceSupports: slice_supports(obj); break;
    case slaposCount: assert(false);
    }
}

References drill_holes(), generate_pad(), hollow_model(), Slic3r::slaposCount, Slic3r::slaposDrillHoles, Slic3r::slaposHollowing, Slic3r::slaposObjectSlice, Slic3r::slaposPad, Slic3r::slaposSliceSupports, Slic3r::slaposSupportPoints, Slic3r::slaposSupportTree, Slic3r::SLAPrint::SLAPrintObject, slice_model(), slice_supports(), support_points(), and support_tree().

Referenced by Slic3r::SLAPrint::process().

Here is the call graph for this function:

Here is the caller graph for this function:

execute() [2/2]

void Slic3r::SLAPrint::Steps::execute

(

SLAPrintStep

step

)

{
    switch (step) {
    case slapsMergeSlicesAndEval: merge_slices_and_eval_stats(); break;
    case slapsRasterize: rasterize(); break;
    case slapsCount: assert(false);
    }
}

References merge_slices_and_eval_stats(), rasterize(), Slic3r::slapsCount, Slic3r::slapsMergeSlicesAndEval, and Slic3r::slapsRasterize.

Here is the call graph for this function:

generate_pad()

void Slic3r::SLAPrint::Steps::generate_pad

(

SLAPrintObject &

po

)

                                                   {
    // this step can only go after the support tree has been created
    // and before the supports had been sliced. (or the slicing has to be
    // repeated)
 
    if(po.m_config.pad_enable.getBool()) {
        // Get the distilled pad configuration from the config
        sla::PadConfig pcfg = make_pad_cfg(po.m_config);
 
        ExPolygons bp; // This will store the base plate of the pad.
        double   pad_h             = pcfg.full_height();
        const TriangleMesh &trmesh = po.transformed_mesh();
 
        if (!po.m_config.supports_enable.getBool() || pcfg.embed_object) {
            // No support (thus no elevation) or zero elevation mode
            // we sometimes call it "builtin pad" is enabled so we will
            // get a sample from the bottom of the mesh and use it for pad
            // creation.
            sla::pad_blueprint(trmesh.its, bp, float(pad_h),
                               float(po.m_config.layer_height.getFloat()),
                               [this](){ throw_if_canceled(); });
        }
 
        po.m_supportdata->create_pad(bp, pcfg);
 
        if (!validate_pad(po.m_supportdata->support_tree_ptr->retrieve_mesh(sla::MeshType::Pad), pcfg))
            throw Slic3r::SlicingError(
                    L("No pad can be generated for this model with the "
                      "current configuration"));
 
    } else if(po.m_supportdata && po.m_supportdata->support_tree_ptr) {
        po.m_supportdata->support_tree_ptr->remove_pad();
    }
 
    throw_if_canceled();
    report_status(-1, L("Visualizing supports"), SlicingStatus::RELOAD_SCENE);
}

References Slic3r::sla::PadConfig::embed_object, Slic3r::sla::PadConfig::full_height(), Slic3r::TriangleMesh::its, L, Slic3r::SLAPrintObject::m_config, Slic3r::SLAPrintObject::m_supportdata, Slic3r::make_pad_cfg(), Slic3r::sla::Pad, Slic3r::sla::pad_blueprint(), report_status(), Slic3r::SLAPrint::SLAPrintObject, Slic3r::PrintBaseWithState< SLAPrintStep, slapsCount >::throw_if_canceled(), Slic3r::SLAPrintObject::transformed_mesh(), and Slic3r::validate_pad().

Referenced by execute().

Here is the call graph for this function:

Here is the caller graph for this function:

hollow_model()

void Slic3r::SLAPrint::Steps::hollow_model

(

SLAPrintObject &

po

)

{
    po.m_hollowing_data.reset();
 
    if (! po.m_config.hollowing_enable.getBool()) {
        BOOST_LOG_TRIVIAL(info) << "Skipping hollowing step!";
        return;
    }
 
    BOOST_LOG_TRIVIAL(info) << "Performing hollowing step!";
 
    double thickness = po.m_config.hollowing_min_thickness.getFloat();
    double quality  = po.m_config.hollowing_quality.getFloat();
    double closing_d = po.m_config.hollowing_closing_distance.getFloat();
    sla::HollowingConfig hlwcfg{thickness, quality, closing_d};
 
    sla::InteriorPtr interior = generate_interior(po.transformed_mesh(), hlwcfg);
 
    if (!interior || sla::get_mesh(*interior).empty())
        BOOST_LOG_TRIVIAL(warning) << "Hollowed interior is empty!";
    else {
        po.m_hollowing_data.reset(new SLAPrintObject::HollowingData());
        po.m_hollowing_data->interior = std::move(interior);
    }
}

References Slic3r::sla::get_mesh(), Slic3r::SLAPrintObject::m_config, Slic3r::SLAPrintObject::m_hollowing_data, Slic3r::SLAPrint::SLAPrintObject, and Slic3r::SLAPrintObject::transformed_mesh().

Referenced by execute().

Here is the call graph for this function:

Here is the caller graph for this function:

initialize_printer_input()

void Slic3r::SLAPrint::Steps::initialize_printer_input ( )

private

{
    auto &printer_input = m_print->m_printer_input;
 
    // clear the rasterizer input
    printer_input.clear();
 
    size_t mx = 0;
    for(SLAPrintObject * o : m_print->m_objects) {
        if(auto m = o->get_slice_index().size() > mx) mx = m;
    }
 
    printer_input.reserve(mx);
 
    auto eps = coord_t(SCALED_EPSILON);
 
    for(SLAPrintObject * o : m_print->m_objects) {
        coord_t gndlvl = o->get_slice_index().front().print_level() - ilhs;
 
        for(const SliceRecord& slicerecord : o->get_slice_index()) {
            if (!slicerecord.is_valid())
                throw Slic3r::SlicingError(
                    L("There are unprintable objects. Try to "
                      "adjust support settings to make the "
                      "objects printable."));
 
            coord_t lvlid = slicerecord.print_level() - gndlvl;
 
            // Neat trick to round the layer levels to the grid.
            lvlid = eps * (lvlid / eps);
 
            auto it = std::lower_bound(printer_input.begin(),
                                       printer_input.end(),
                                       PrintLayer(lvlid));
 
            if(it == printer_input.end() || it->level() != lvlid)
                it = printer_input.insert(it, PrintLayer(lvlid));
 
 
            it->add(slicerecord);
        }
    }
}

References Slic3r::SLAPrintObject::get_slice_index(), ilhs, L, m_print, SCALED_EPSILON, and Slic3r::SLAPrint::SLAPrintObject.

Referenced by merge_slices_and_eval_stats().

Here is the call graph for this function:

Here is the caller graph for this function:

label() [1/2]

std::string Slic3r::SLAPrint::Steps::label ( SLAPrintObjectStep step )

static

{
    return OBJ_STEP_LABELS(step);
}

Referenced by Slic3r::SLAPrint::process().

Here is the caller graph for this function:

label() [2/2]

std::string Slic3r::SLAPrint::Steps::label ( SLAPrintStep step )

static

{
    return PRINT_STEP_LABELS(step);
}

merge_slices_and_eval_stats()

void Slic3r::SLAPrint::Steps::merge_slices_and_eval_stats

(

)

                                                {
 
    initialize_printer_input();
 
    auto &print_statistics = m_print->m_print_statistics;
    auto &printer_config   = m_print->m_printer_config;
    auto &material_config  = m_print->m_material_config;
    auto &printer_input    = m_print->m_printer_input;
 
    print_statistics.clear();
 
    const double area_fill = printer_config.area_fill.getFloat()*0.01;// 0.5 (50%);
    const double fast_tilt = printer_config.fast_tilt_time.getFloat();// 5.0;
    const double slow_tilt = printer_config.slow_tilt_time.getFloat();// 8.0;
 
    const double init_exp_time = material_config.initial_exposure_time.getFloat();
    const double exp_time      = material_config.exposure_time.getFloat();
 
    const int fade_layers_cnt = m_print->m_default_object_config.faded_layers.getInt();// 10 // [3;20]
 
    const auto width          = scaled<double>(printer_config.display_width.getFloat());
    const auto height         = scaled<double>(printer_config.display_height.getFloat());
    const double display_area = width*height;
 
    double supports_volume(0.0);
    double models_volume(0.0);
 
    double estim_time(0.0);
    std::vector<double> layers_times;
    layers_times.reserve(printer_input.size());
 
    size_t slow_layers = 0;
    size_t fast_layers = 0;
 
    const double delta_fade_time = (init_exp_time - exp_time) / (fade_layers_cnt + 1);
    double fade_layer_time = init_exp_time;
 
    sla::ccr::SpinningMutex mutex;
    using Lock = std::lock_guard<sla::ccr::SpinningMutex>;
 
    // Going to parallel:
    auto printlayerfn = [this,
            // functions and read only vars
            area_fill, display_area, exp_time, init_exp_time, fast_tilt, slow_tilt, delta_fade_time,
 
            // write vars
            &mutex, &models_volume, &supports_volume, &estim_time, &slow_layers,
            &fast_layers, &fade_layer_time, &layers_times](size_t sliced_layer_cnt)
    {
        PrintLayer &layer = m_print->m_printer_input[sliced_layer_cnt];
 
        // vector of slice record references
        auto& slicerecord_references = layer.slices();
 
        if(slicerecord_references.empty()) return;
 
        // Layer height should match for all object slices for a given level.
        const auto l_height = double(slicerecord_references.front().get().layer_height());
 
        // Calculation of the consumed material
 
        ExPolygons model_polygons;
        ExPolygons supports_polygons;
 
        size_t c = std::accumulate(layer.slices().begin(),
                                   layer.slices().end(),
                                   size_t(0),
                                   [](size_t a, const SliceRecord &sr) {
            return a + sr.get_slice(soModel).size();
        });
 
        model_polygons.reserve(c);
 
        c = std::accumulate(layer.slices().begin(),
                            layer.slices().end(),
                            size_t(0),
                            [](size_t a, const SliceRecord &sr) {
            return a + sr.get_slice(soModel).size();
        });
 
        supports_polygons.reserve(c);
 
        for(const SliceRecord& record : layer.slices()) {
 
            ExPolygons modelslices = get_all_polygons(record, soModel);
            for(ExPolygon& p_tmp : modelslices) model_polygons.emplace_back(std::move(p_tmp));
 
            ExPolygons supportslices = get_all_polygons(record, soSupport);
            for(ExPolygon& p_tmp : supportslices) supports_polygons.emplace_back(std::move(p_tmp));
 
        }
 
        model_polygons = union_ex(model_polygons);
        double layer_model_area = 0;
        for (const ExPolygon& polygon : model_polygons)
            layer_model_area += area(polygon);
 
        if (layer_model_area < 0 || layer_model_area > 0) {
            Lock lck(mutex); models_volume += layer_model_area * l_height;
        }
 
        if(!supports_polygons.empty()) {
            if(model_polygons.empty()) supports_polygons = union_ex(supports_polygons);
            else supports_polygons = diff_ex(supports_polygons, model_polygons);
            // allegedly, union of subject is done withing the diff according to the pftPositive polyFillType
        }
 
        double layer_support_area = 0;
        for (const ExPolygon& polygon : supports_polygons)
            layer_support_area += area(polygon);
 
        if (layer_support_area < 0 || layer_support_area > 0) {
            Lock lck(mutex); supports_volume += layer_support_area * l_height;
        }
 
        // Here we can save the expensively calculated polygons for printing
        ExPolygons trslices;
        trslices.reserve(model_polygons.size() + supports_polygons.size());
        for(ExPolygon& poly : model_polygons) trslices.emplace_back(std::move(poly));
        for(ExPolygon& poly : supports_polygons) trslices.emplace_back(std::move(poly));
 
        layer.transformed_slices(union_ex(trslices));
 
        // Calculation of the slow and fast layers to the future controlling those values on FW
 
        const bool is_fast_layer = (layer_model_area + layer_support_area) <= display_area*area_fill;
        const double tilt_time = is_fast_layer ? fast_tilt : slow_tilt;
 
        { Lock lck(mutex);
            if (is_fast_layer)
                fast_layers++;
            else
                slow_layers++;
 
            // Calculation of the printing time
 
            double layer_times = 0.0;
            if (sliced_layer_cnt < 3)
                layer_times += init_exp_time;
            else if (fade_layer_time > exp_time) {
                fade_layer_time -= delta_fade_time;
                layer_times += fade_layer_time;
            }
            else
                layer_times += exp_time;
            layer_times += tilt_time;
 
            layers_times.push_back(layer_times);
            estim_time += layer_times;
        }
    };
 
    // sequential version for debugging:
    // for(size_t i = 0; i < m_printer_input.size(); ++i) printlayerfn(i);
    sla::ccr::for_each(size_t(0), printer_input.size(), printlayerfn);
 
    auto SCALING2 = SCALING_FACTOR * SCALING_FACTOR;
    print_statistics.support_used_material = supports_volume * SCALING2;
    print_statistics.objects_used_material = models_volume  * SCALING2;
 
    // Estimated printing time
    // A layers count o the highest object
    if (printer_input.size() == 0)
        print_statistics.estimated_print_time = std::nan("");
    else {
        print_statistics.estimated_print_time = estim_time;
        print_statistics.layers_times = layers_times;
    }
 
    print_statistics.fast_layers_count = fast_layers;
    print_statistics.slow_layers_count = slow_layers;
 
    report_status(-2, "", SlicingStatus::RELOAD_SLA_PREVIEW);
}

References Slic3r::area(), Slic3r::area_fill(), Slic3r::diff_ex(), Slic3r::get_all_polygons(), initialize_printer_input(), m_print, Slic3r::SLAPrint::material_config(), Slic3r::SLAPrint::print_statistics(), Slic3r::SLAPrint::printer_config(), report_status(), Slic3r::scaled(), SCALING_FACTOR, Slic3r::SLAPrint::PrintLayer::slices(), Slic3r::soModel, Slic3r::soSupport, Slic3r::SLAPrint::PrintLayer::transformed_slices(), and Slic3r::union_ex().

Referenced by execute().

Here is the call graph for this function:

Here is the caller graph for this function:

progressrange() [1/2]

double Slic3r::SLAPrint::Steps::progressrange

(

SLAPrintObjectStep

step

)

const

{
    return OBJ_STEP_LEVELS[step] * objectstep_scale;
}

References objectstep_scale.

Referenced by Slic3r::SLAPrint::process().

Here is the caller graph for this function:

progressrange() [2/2]

double Slic3r::SLAPrint::Steps::progressrange

(

SLAPrintStep

step

)

const

{
    return PRINT_STEP_LEVELS[step] * (100 - max_objstatus) / 100.0;
}

References max_objstatus.

rasterize()

void Slic3r::SLAPrint::Steps::rasterize

(

)

{
    if(canceled() || !m_print->m_printer) return;
 
    // coefficient to map the rasterization state (0-99) to the allocated
    // portion (slot) of the process state
    double sd = (100 - max_objstatus) / 100.0;
 
    // slot is the portion of 100% that is realted to rasterization
    unsigned slot = PRINT_STEP_LEVELS[slapsRasterize];
 
    // pst: previous state
    double pst = current_status();
 
    double increment = (slot * sd) / m_print->m_printer_input.size();
    double dstatus = current_status();
 
    sla::ccr::SpinningMutex slck;
    using Lock = std::lock_guard<sla::ccr::SpinningMutex>;
 
    // procedure to process one height level. This will run in parallel
    auto lvlfn =
        [this, &slck, increment, &dstatus, &pst]
        (sla::RasterBase& raster, size_t idx)
    {
        PrintLayer& printlayer = m_print->m_printer_input[idx];
        if(canceled()) return;
 
        for (const ExPolygon& poly : printlayer.transformed_slices())
            raster.draw(poly);
 
        // Status indication guarded with the spinlock
        {
            Lock lck(slck);
            dstatus += increment;
            double st = std::round(dstatus);
            if(st > pst) {
                report_status(st, PRINT_STEP_LABELS(slapsRasterize));
                pst = st;
            }
        }
    };
 
    // last minute escape
    if(canceled()) return;
 
    // Print all the layers in parallel
    m_print->m_printer->draw_layers(m_print->m_printer_input.size(), lvlfn,
                                    [this]() { return canceled(); }, ex_tbb);
}

References Slic3r::PrintBaseWithState< SLAPrintStep, slapsCount >::canceled(), current_status(), Slic3r::ex_tbb, m_print, max_objstatus, report_status(), Slic3r::slapsRasterize, and Slic3r::SLAPrint::PrintLayer::transformed_slices().

Referenced by execute().

Here is the call graph for this function:

Here is the caller graph for this function:

report_status()

template<class... Args>

void Slic3r::SLAPrint::Steps::report_status ( Args &&... args )

inlineprivate

    {
        m_print->m_report_status(*m_print, std::forward<Args>(args)...);
    }

References m_print.

Referenced by generate_pad(), merge_slices_and_eval_stats(), rasterize(), slice_supports(), support_points(), and support_tree().

Here is the caller graph for this function:

slice_model()

void Slic3r::SLAPrint::Steps::slice_model

(

SLAPrintObject &

po

)

{
    const TriangleMesh &mesh = po.get_mesh_to_slice();
 
    // We need to prepare the slice index...
 
    double  lhd  = m_print->m_objects.front()->m_config.layer_height.getFloat();
    float   lh   = float(lhd);
    coord_t lhs  = scaled(lhd);
    auto && bb3d = mesh.bounding_box();
    double  minZ = bb3d.min(Z) - po.get_elevation();
    double  maxZ = bb3d.max(Z);
    auto    minZf = float(minZ);
    coord_t minZs = scaled(minZ);
    coord_t maxZs = scaled(maxZ);
 
    po.m_slice_index.clear();
 
    size_t cap = size_t(1 + (maxZs - minZs - ilhs) / lhs);
    po.m_slice_index.reserve(cap);
 
    po.m_slice_index.emplace_back(minZs + ilhs, minZf + ilh / 2.f, ilh);
 
    for(coord_t h = minZs + ilhs + lhs; h <= maxZs; h += lhs)
        po.m_slice_index.emplace_back(h, unscaled<float>(h) - lh / 2.f, lh);
 
    // Just get the first record that is from the model:
    auto slindex_it =
        po.closest_slice_record(po.m_slice_index, float(bb3d.min(Z)));
 
    if(slindex_it == po.m_slice_index.end())
        //TRN To be shown at the status bar on SLA slicing error.
        throw Slic3r::RuntimeError(
            L("Slicing had to be stopped due to an internal error: "
              "Inconsistent slice index."));
 
    po.m_model_height_levels.clear();
    po.m_model_height_levels.reserve(po.m_slice_index.size());
    for(auto it = slindex_it; it != po.m_slice_index.end(); ++it)
        po.m_model_height_levels.emplace_back(it->slice_level());
 
    po.m_model_slices.clear();
    MeshSlicingParamsEx params;
    params.closing_radius = float(po.config().slice_closing_radius.value);
    //BBS: always regular mode
    //switch (po.config().slicing_mode.value) {
    //case SlicingMode::Regular:    params.mode = MeshSlicingParams::SlicingMode::Regular; break;
    //case SlicingMode::EvenOdd:    params.mode = MeshSlicingParams::SlicingMode::EvenOdd; break;
    //case SlicingMode::CloseHoles: params.mode = MeshSlicingParams::SlicingMode::Positive; break;
    //}
    params.mode = MeshSlicingParams::SlicingMode::Regular;
    auto  thr        = [this]() { m_print->throw_if_canceled(); };
    auto &slice_grid = po.m_model_height_levels;
    po.m_model_slices = slice_mesh_ex(mesh.its, slice_grid, params, thr);
 
    sla::Interior *interior = po.m_hollowing_data ?
                                  po.m_hollowing_data->interior.get() :
                                  nullptr;
 
    if (interior && ! sla::get_mesh(*interior).empty()) {
        indexed_triangle_set interiormesh = sla::get_mesh(*interior);
        sla::swap_normals(interiormesh);
        params.mode = MeshSlicingParams::SlicingMode::Regular;
 
        std::vector<ExPolygons> interior_slices = slice_mesh_ex(interiormesh, slice_grid, params, thr);
 
        sla::ccr::for_each(size_t(0), interior_slices.size(),
                           [&po, &interior_slices] (size_t i) {
                              const ExPolygons &slice = interior_slices[i];
                              po.m_model_slices[i] =
                                  diff_ex(po.m_model_slices[i], slice);
                           });
    }
 
    auto mit = slindex_it;
    for (size_t id = 0;
         id < po.m_model_slices.size() && mit != po.m_slice_index.end();
         id++) {
        mit->set_model_slice_idx(po, id); ++mit;
    }
 
    // We apply the printer correction offset here.
    apply_printer_corrections(po, soModel);
 
    if(po.m_config.supports_enable.getBool() || po.m_config.pad_enable.getBool())
    {
        po.m_supportdata.reset(new SLAPrintObject::SupportData(po.get_mesh_to_print()));
    }
}

References apply_printer_corrections(), Slic3r::TriangleMesh::bounding_box(), Slic3r::SLAPrintObject::closest_slice_record(), Slic3r::MeshSlicingParamsEx::closing_radius, Slic3r::SLAPrintObject::config(), Slic3r::SLAPrintObject::get_elevation(), Slic3r::sla::get_mesh(), Slic3r::SLAPrintObject::get_mesh_to_print(), Slic3r::SLAPrintObject::get_mesh_to_slice(), ilh, ilhs, Slic3r::TriangleMesh::its, L, Slic3r::SLAPrintObject::m_config, Slic3r::SLAPrintObject::m_hollowing_data, Slic3r::SLAPrintObject::m_model_height_levels, Slic3r::SLAPrintObject::m_model_slices, m_print, Slic3r::SLAPrintObject::m_slice_index, Slic3r::SLAPrintObject::m_supportdata, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, Slic3r::MeshSlicingParams::mode, Slic3r::MeshSlicingParams::Regular, Slic3r::scaled(), Slic3r::SLAPrint::SLAPrintObject, Slic3r::slice_mesh_ex(), Slic3r::soModel, Slic3r::sla::swap_normals(), Slic3r::unscaled(), and Slic3r::Z.

Referenced by execute().

Here is the call graph for this function:

Here is the caller graph for this function:

slice_supports()

void Slic3r::SLAPrint::Steps::slice_supports

(

SLAPrintObject &

po

)

                                                     {
    auto& sd = po.m_supportdata;
 
    if(sd) sd->support_slices.clear();
 
    // Don't bother if no supports and no pad is present.
    if (!po.m_config.supports_enable.getBool() && !po.m_config.pad_enable.getBool())
        return;
 
    if(sd && sd->support_tree_ptr) {
        auto heights = reserve_vector<float>(po.m_slice_index.size());
 
        for(auto& rec : po.m_slice_index) heights.emplace_back(rec.slice_level());
 
        sd->support_slices = sd->support_tree_ptr->slice(
            heights, float(po.config().slice_closing_radius.value));
    }
 
    for (size_t i = 0; i < sd->support_slices.size() && i < po.m_slice_index.size(); ++i)
        po.m_slice_index[i].set_support_slice_idx(po, i);
 
    apply_printer_corrections(po, soSupport);
 
    // Using RELOAD_SLA_PREVIEW to tell the Plater to pass the update
    // status to the 3D preview to load the SLA slices.
    report_status(-2, "", SlicingStatus::RELOAD_SLA_PREVIEW);
}

References apply_printer_corrections(), Slic3r::SLAPrintObject::config(), Slic3r::SLAPrintObject::m_config, Slic3r::SLAPrintObject::m_slice_index, Slic3r::SLAPrintObject::m_supportdata, report_status(), Slic3r::reserve_vector(), Slic3r::SLAPrint::SLAPrintObject, and Slic3r::soSupport.

Referenced by execute().

Here is the call graph for this function:

Here is the caller graph for this function:

support_points()

void Slic3r::SLAPrint::Steps::support_points

(

SLAPrintObject &

po

)

{
    // If supports are disabled, we can skip the model scan.
    if(!po.m_config.supports_enable.getBool()) return;
 
    if (!po.m_supportdata)
        po.m_supportdata.reset(new SLAPrintObject::SupportData(po.get_mesh_to_print()));
 
    const ModelObject& mo = *po.m_model_object;
 
    BOOST_LOG_TRIVIAL(debug) << "Support point count "
                             << mo.sla_support_points.size();
 
    // Unless the user modified the points or we already did the calculation,
    // we will do the autoplacement. Otherwise we will just blindly copy the
    // frontend data into the backend cache.
    if (mo.sla_points_status != sla::PointsStatus::UserModified) {
 
        // calculate heights of slices (slices are calculated already)
        const std::vector<float>& heights = po.m_model_height_levels;
 
        // Tell the mesh where drain holes are. Although the points are
        // calculated on slices, the algorithm then raycasts the points
        // so they actually lie on the mesh.
//        po.m_supportdata->emesh.load_holes(po.transformed_drainhole_points());
 
        throw_if_canceled();
        sla::SupportPointGenerator::Config config;
        const SLAPrintObjectConfig& cfg = po.config();
 
        // the density config value is in percents:
        config.density_relative = float(cfg.support_points_density_relative / 100.f);
        config.minimal_distance = float(cfg.support_points_minimal_distance);
        config.head_diameter    = float(cfg.support_head_front_diameter);
 
        // scaling for the sub operations
        double d = objectstep_scale * OBJ_STEP_LEVELS[slaposSupportPoints] / 100.0;
        double init = current_status();
 
        auto statuscb = [this, d, init](unsigned st)
        {
            double current = init + st * d;
            if(std::round(current_status()) < std::round(current))
                report_status(current, OBJ_STEP_LABELS(slaposSupportPoints));
        };
 
        // Construction of this object does the calculation.
        throw_if_canceled();
        sla::SupportPointGenerator auto_supports(
            po.m_supportdata->emesh, po.get_model_slices(), heights, config,
            [this]() { throw_if_canceled(); }, statuscb);
 
        // Now let's extract the result.
        const std::vector<sla::SupportPoint>& points = auto_supports.output();
        throw_if_canceled();
        po.m_supportdata->pts = points;
 
        BOOST_LOG_TRIVIAL(debug) << "Automatic support points: "
                                 << po.m_supportdata->pts.size();
 
        // Using RELOAD_SLA_SUPPORT_POINTS to tell the Plater to pass
        // the update status to GLGizmoSlaSupports
        report_status(-1, L("Generating support points"),
                      SlicingStatus::RELOAD_SLA_SUPPORT_POINTS);
    } else {
        // There are either some points on the front-end, or the user
        // removed them on purpose. No calculation will be done.
        po.m_supportdata->pts = po.transformed_support_points();
    }
}

References Slic3r::SLAPrintObject::config(), current_status(), Slic3r::sla::SupportPointGenerator::Config::density_relative, Slic3r::SLAPrintObject::get_mesh_to_print(), Slic3r::SLAPrintObject::get_model_slices(), Slic3r::sla::SupportPointGenerator::Config::head_diameter, L, Slic3r::SLAPrintObject::m_config, Slic3r::SLAPrintObject::m_model_height_levels, Slic3r::PrintObjectBase::m_model_object, Slic3r::SLAPrintObject::m_supportdata, Slic3r::sla::SupportPointGenerator::Config::minimal_distance, objectstep_scale, Slic3r::sla::SupportPointGenerator::output(), report_status(), Slic3r::ModelObject::sla_points_status, Slic3r::ModelObject::sla_support_points, Slic3r::slaposSupportPoints, Slic3r::SLAPrint::SLAPrintObject, Slic3r::PrintBaseWithState< SLAPrintStep, slapsCount >::throw_if_canceled(), Slic3r::SLAPrintObject::transformed_support_points(), and Slic3r::sla::UserModified.

Referenced by execute().

Here is the call graph for this function:

Here is the caller graph for this function:

support_tree()

void Slic3r::SLAPrint::Steps::support_tree

(

SLAPrintObject &

po

)

{
    if(!po.m_supportdata) return;
 
    sla::PadConfig pcfg = make_pad_cfg(po.m_config);
 
    if (pcfg.embed_object)
        po.m_supportdata->emesh.ground_level_offset(pcfg.wall_thickness_mm);
 
    // If the zero elevation mode is engaged, we have to filter out all the
    // points that are on the bottom of the object
    if (is_zero_elevation(po.config())) {
        remove_bottom_points(po.m_supportdata->pts,
                             float(po.m_supportdata->emesh.ground_level() + EPSILON));
    }
 
    po.m_supportdata->cfg = make_support_cfg(po.m_config);
//    po.m_supportdata->emesh.load_holes(po.transformed_drainhole_points());
 
    // scaling for the sub operations
    double d = objectstep_scale * OBJ_STEP_LEVELS[slaposSupportTree] / 100.0;
    double init = current_status();
    sla::JobController ctl;
 
    ctl.statuscb = [this, d, init](unsigned st, const std::string &logmsg) {
        double current = init + st * d;
        if (std::round(current_status()) < std::round(current))
            report_status(current, OBJ_STEP_LABELS(slaposSupportTree),
                          SlicingStatus::DEFAULT, logmsg);
    };
    ctl.stopcondition = [this]() { return canceled(); };
    ctl.cancelfn = [this]() { throw_if_canceled(); };
 
    po.m_supportdata->create_support_tree(ctl);
 
    if (!po.m_config.supports_enable.getBool()) return;
 
    throw_if_canceled();
 
    // Create the unified mesh
    auto rc = SlicingStatus::RELOAD_SCENE;
 
    // This is to prevent "Done." being displayed during merged_mesh()
    report_status(-1, L("Visualizing supports"));
 
    BOOST_LOG_TRIVIAL(debug) << "Processed support point count "
                             << po.m_supportdata->pts.size();
 
    // Check the mesh for later troubleshooting.
    if(po.support_mesh().empty())
        BOOST_LOG_TRIVIAL(warning) << "Support mesh is empty";
 
    report_status(-1, L("Visualizing supports"), rc);
}

References Slic3r::PrintBaseWithState< SLAPrintStep, slapsCount >::canceled(), Slic3r::sla::JobController::cancelfn, Slic3r::SLAPrintObject::config(), current_status(), Slic3r::sla::PadConfig::embed_object, Slic3r::TriangleMesh::empty(), EPSILON, Slic3r::is_zero_elevation(), L, Slic3r::SLAPrintObject::m_config, Slic3r::SLAPrintObject::m_supportdata, Slic3r::make_pad_cfg(), Slic3r::make_support_cfg(), objectstep_scale, report_status(), Slic3r::slaposSupportTree, Slic3r::SLAPrint::SLAPrintObject, Slic3r::sla::JobController::statuscb, Slic3r::sla::JobController::stopcondition, Slic3r::SLAPrintObject::support_mesh(), Slic3r::PrintBaseWithState< SLAPrintStep, slapsCount >::throw_if_canceled(), and Slic3r::sla::PadConfig::wall_thickness_mm.

Referenced by execute().

Here is the call graph for this function:

Here is the caller graph for this function:

throw_if_canceled()

void Slic3r::SLAPrint::Steps::throw_if_canceled ( ) const

inlineprivate

{ m_print->throw_if_canceled(); }

References m_print.

Member Data Documentation

ilh

const float Slic3r::SLAPrint::Steps::ilh

private

Referenced by Steps(), and slice_model().

ilhd

const double Slic3r::SLAPrint::Steps::ilhd

private

Referenced by Steps().

ilhs

const coord_t Slic3r::SLAPrint::Steps::ilhs

private

Referenced by Steps(), initialize_printer_input(), and slice_model().

m_print

SLAPrint* Slic3r::SLAPrint::Steps::m_print = nullptr

private

Referenced by Steps(), apply_printer_corrections(), canceled(), current_status(), initialize_printer_input(), merge_slices_and_eval_stats(), rasterize(), report_status(), slice_model(), and throw_if_canceled().

m_rng

std::mt19937 Slic3r::SLAPrint::Steps::m_rng

private

Referenced by Steps().

max_objstatus

const constexpr unsigned Slic3r::SLAPrint::Steps::max_objstatus = 50

staticconstexpr

Referenced by Steps(), Slic3r::SLAPrint::process(), progressrange(), and rasterize().

min_objstatus

const constexpr unsigned Slic3r::SLAPrint::Steps::min_objstatus = 0

staticconstexpr

Referenced by Steps(), and Slic3r::SLAPrint::process().

objcount

const size_t Slic3r::SLAPrint::Steps::objcount

private

Referenced by Steps().

objectstep_scale

const double Slic3r::SLAPrint::Steps::objectstep_scale

private

Referenced by Steps(), progressrange(), support_points(), and support_tree().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/SLAPrintSteps.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/SLAPrintSteps.cpp