Slic3r::SLAPrintObject Class Reference

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

Inheritance diagram for Slic3r::SLAPrintObject:

Collaboration diagram for Slic3r::SLAPrintObject:

Classes
struct	Instance
class	SliceRecord
class	SupportData
class	HollowingData

Public Types
typedef PrintState< SLAPrintObjectStep, COUNT >	PrintObjectState
using	Timestamp

Public Member Functions
	SLAPrintObject (const SLAPrintObject &)=delete
SLAPrintObject &	operator= (const SLAPrintObject &)=delete
const SLAPrintObjectConfig &	config () const
const Transform3d &	trafo () const
bool	is_left_handed () const
const std::vector< Instance > &	instances () const
bool	has_mesh (SLAPrintObjectStep step) const
TriangleMesh	get_mesh (SLAPrintObjectStep step) const
const TriangleMesh &	support_mesh () const
const TriangleMesh &	pad_mesh () const
const indexed_triangle_set &	hollowed_interior_mesh () const
const TriangleMesh &	get_mesh_to_print () const
const TriangleMesh &	get_mesh_to_slice () const
const TriangleMesh &	transformed_mesh () const
sla::SupportPoints	transformed_support_points () const
sla::DrainHoles	transformed_drainhole_points () const
double	get_elevation () const
double	get_current_elevation () const
const std::vector< sla::SupportPoint > &	get_support_points () const
const std::vector< SliceRecord > &	get_slice_index () const
const SliceRecord &	closest_slice_to_print_level (coord_t print_level, coord_t max_epsilon=std::numeric_limits< coord_t >::max()) const
const SliceRecord &	closest_slice_to_slice_level (float slice_level, float max_epsilon=std::numeric_limits< float >::max()) const
SLAPrint *	print ()
const SLAPrint *	print () const
bool	is_step_done (SLAPrintObjectStep step) const
PrintStateBase::StateWithTimeStamp	step_state_with_timestamp (SLAPrintObjectStep step) const
PrintStateBase::StateWithWarnings	step_state_with_warnings (SLAPrintObjectStep step) const
const ModelObject *	model_object () const
ModelObject *	model_object ()
ObjectID	id () const
virtual Timestamp	timestamp () const

Protected Member Functions
	SLAPrintObject (SLAPrint *print, ModelObject *model_object)
	~SLAPrintObject ()
void	config_apply (const ConfigBase &other, bool ignore_nonexistent=false)
void	config_apply_only (const ConfigBase &other, const t_config_option_keys &keys, bool ignore_nonexistent=false)
void	set_trafo (const Transform3d &trafo, bool left_handed)
template<class InstVec>
void	set_instances (InstVec &&instances)
bool	invalidate_step (SLAPrintObjectStep step)
bool	invalidate_all_steps ()
bool	invalidate_state_by_config_options (const std::vector< t_config_option_key > &opt_keys)
bool	set_started (SLAPrintObjectStep step)
PrintStateBase::TimeStamp	set_done (SLAPrintObjectStep step)
bool	invalidate_steps (StepTypeIterator step_begin, StepTypeIterator step_end)
bool	invalidate_steps (std::initializer_list< SLAPrintObjectStep > il)
bool	invalidate_all_steps_without_cancel ()
bool	is_step_started_unguarded (SLAPrintObjectStep step) const
bool	is_step_done_unguarded (SLAPrintObjectStep step) const
void	active_step_add_warning (PrintStateBase::WarningLevel warning_level, const std::string &message, PrintStateBase::SlicingNotificationType message_id=PrintStateBase::SlicingDefaultNotification)
void	throw_if_canceled ()
void	status_update_warnings (PrintBase *print, int step, PrintStateBase::WarningLevel warning_level, const std::string &message, PrintStateBase::SlicingNotificationType message_id=PrintStateBase::SlicingDefaultNotification)
void	emptylayer_update_msg (PrintBase *print, int type, const std::string &message, bool overwrite)
void	set_new_unique_id ()
void	set_invalid_id ()
void	copy_id (const ObjectBase &rhs)
virtual void	assign_new_unique_ids_recursive ()

Static Protected Member Functions
static std::mutex &	state_mutex (PrintBase *print)
static std::function< void()>	cancel_callback (PrintBase *print)

Protected Attributes
std::vector< bool >	m_stepmask
friend	PrintType
SLAPrint *	m_print
ModelObject *	m_model_object

Private Types
using	Inherited = _SLAPrintObjectBase

Private Member Functions
const std::vector< ExPolygons > &	get_model_slices () const
const std::vector< ExPolygons > &	get_support_slices () const
void	serialize (Archive &ar)

Static Private Member Functions
template<class T>
static T	level (const SliceRecord &sr)
template<class T>
static SliceRecord	create_slice_record (T val)
template<class Container, class T>
static auto	closest_slice_record (Container &cont, T lvl, T eps=std::numeric_limits< T >::max()) -> decltype(cont.begin())
static ObjectID	generate_new_id ()
static void	load_and_construct (Archive &ar, cereal::construct< ObjectBase > &construct)

Private Attributes
SLAPrintObjectConfig	m_config
Transform3d	m_trafo = Transform3d::Identity()
bool	m_left_handed = false
std::vector< Instance >	m_instances
std::vector< ExPolygons >	m_model_slices
std::vector< SliceRecord >	m_slice_index
std::vector< float >	m_model_height_levels
CachedObject< TriangleMesh >	m_transformed_rmesh
std::unique_ptr< SupportData >	m_supportdata
std::unique_ptr< HollowingData >	m_hollowing_data
PrintState< SLAPrintObjectStep, COUNT >	m_state
ObjectID	m_id

Static Private Attributes
static size_t	s_last_id

Friends
class	SLAPrint

Detailed Description

---

Class Documentation

Slic3r::SLAPrintObject::HollowingData

class Slic3r::SLAPrintObject::HollowingData

Collaboration diagram for Slic3r::SLAPrintObject::HollowingData:

Class Members
TriangleMesh	hollow_mesh_with_holes
TriangleMesh	hollow_mesh_with_holes_trimmed
InteriorPtr	interior

Member Typedef Documentation

Inherited

using Slic3r::SLAPrintObject::Inherited = _SLAPrintObjectBase

private

PrintObjectState

typedef PrintState<SLAPrintObjectStep, COUNT> Slic3r::PrintObjectBaseWithState< SLAPrint, SLAPrintObjectStep, COUNT >::PrintObjectState

inherited

Timestamp

using Slic3r::ObjectBase::Timestamp

inherited

Constructor & Destructor Documentation

SLAPrintObject() [1/2]

Slic3r::SLAPrintObject::SLAPrintObject ( const SLAPrintObject & )

delete

References SLAPrintObject().

Referenced by SLAPrintObject(), operator=(), Slic3r::SLAPrintObject::SliceRecord::print_obj(), Slic3r::SLAPrintObject::SliceRecord::set_model_slice_idx(), and Slic3r::SLAPrintObject::SliceRecord::set_support_slice_idx().

Here is the call graph for this function:

Here is the caller graph for this function:

SLAPrintObject() [2/2]

Slic3r::SLAPrintObject::SLAPrintObject ( SLAPrint * print, ModelObject * model_object )

protected

    : Inherited(print, model_object)
    , m_stepmask(slaposCount, true)
    , m_transformed_rmesh([this](TriangleMesh &obj) {
        obj = m_model_object->raw_mesh();
        if (!obj.empty()) {
            obj.transform(m_trafo);
        }
    })
{}

References Slic3r::PrintObjectBaseWithState< SLAPrint, SLAPrintObjectStep, slaposCount >::m_model_object, m_stepmask, m_transformed_rmesh, Slic3r::PrintObjectBaseWithState< SLAPrint, SLAPrintObjectStep, slaposCount >::model_object(), Slic3r::PrintObjectBaseWithState< SLAPrint, SLAPrintObjectStep, slaposCount >::print(), Slic3r::slaposCount, and SLAPrint.

Here is the call graph for this function:

~SLAPrintObject()

Slic3r::SLAPrintObject::~SLAPrintObject ( )

protected

{}

Member Function Documentation

active_step_add_warning()

void Slic3r::PrintObjectBaseWithState< SLAPrint, SLAPrintObjectStep, COUNT >::active_step_add_warning ( PrintStateBase::WarningLevel warning_level, const std::string & message, PrintStateBase::SlicingNotificationType message_id = PrintStateBase::SlicingDefaultNotification )

inlineprotectedinherited

                                                                                                                     {
      std::pair<PrintObjectStepEnum, bool> active_step = m_state.active_step_add_warning(warning_level, message,(int) message_id, PrintObjectBase::state_mutex(m_print));
      if (active_step.second)
        this->status_update_warnings(m_print, static_cast<int>(active_step.first), warning_level, message, message_id);
    }

assign_new_unique_ids_recursive()

virtual void Slic3r::ObjectBase::assign_new_unique_ids_recursive ( )

inlineprotectedvirtualinherited

{ this->set_new_unique_id(); }

cancel_callback()

std::function< void()> Slic3r::PrintObjectBase::cancel_callback ( PrintBase * print )

staticprotectedinherited

{
  return print->cancel_callback();
}

closest_slice_record()

template<class Container, class T>

auto Slic3r::SLAPrintObject::closest_slice_record ( Container & cont, T lvl, T eps = std::numeric_limits<T>::max() )->decltype(cont.begin())

inlinestaticprivate

    {
        if(cont.empty()) return cont.end();
        if(cont.size() == 1 && std::abs(level<T>(cont.front()) - lvl) > eps)
            return cont.end();
 
        SliceRecord query = create_slice_record(lvl);
 
        auto it = std::lower_bound(cont.begin(), cont.end(), query,
                                   [](const SliceRecord& r1,
                                      const SliceRecord& r2)
        {
            return level<T>(r1) < level<T>(r2);
        });
 
        if(it == cont.end()) return it;
 
        T diff = std::abs(level<T>(*it) - lvl);
 
        if(it != cont.begin()) {
            auto it_prev = std::prev(it);
            T diff_prev = std::abs(level<T>(*it_prev) - lvl);
            if(diff_prev < diff) { diff = diff_prev; it = it_prev; }
        }
 
        if(diff > eps) it = cont.end();
 
        return it;
    }

References create_slice_record(), Slic3r::diff(), and level().

Referenced by closest_slice_to_print_level(), closest_slice_to_slice_level(), and Slic3r::SLAPrint::Steps::slice_model().

Here is the call graph for this function:

Here is the caller graph for this function:

closest_slice_to_print_level()

const SliceRecord & Slic3r::SLAPrintObject::closest_slice_to_print_level ( coord_t print_level, coord_t max_epsilon = std::numeric_limits<coord_t>::max() ) const

inline

    {
        auto it = closest_slice_record(m_slice_index, print_level, max_epsilon);
        return it == m_slice_index.end() ? SliceRecord::EMPTY : *it;
    }

References closest_slice_record(), Slic3r::SLAPrintObject::SliceRecord::EMPTY, and m_slice_index.

Referenced by Slic3r::GUI::GLCanvas3D::_render_sla_slices().

Here is the call graph for this function:

Here is the caller graph for this function:

closest_slice_to_slice_level()

const SliceRecord & Slic3r::SLAPrintObject::closest_slice_to_slice_level ( float slice_level, float max_epsilon = std::numeric_limits<float>::max() ) const

inline

    {
        auto it = closest_slice_record(m_slice_index, slice_level, max_epsilon);
        return it == m_slice_index.end() ? SliceRecord::EMPTY : *it;
    }

References closest_slice_record(), Slic3r::SLAPrintObject::SliceRecord::EMPTY, and m_slice_index.

Here is the call graph for this function:

config()

const SLAPrintObjectConfig & Slic3r::SLAPrintObject::config ( ) const

inline

{ return m_config; }

References m_config.

Referenced by Slic3r::SLAPrintStatistics::finalize_output_path(), Slic3r::SLAPrint::Steps::slice_model(), Slic3r::SLAPrint::Steps::slice_supports(), Slic3r::SLAPrint::Steps::support_points(), and Slic3r::SLAPrint::Steps::support_tree().

Here is the caller graph for this function:

config_apply()

void Slic3r::SLAPrintObject::config_apply ( const ConfigBase & other, bool ignore_nonexistent = false )

inlineprotected

{ m_config.apply(other, ignore_nonexistent); }

References m_config.

config_apply_only()

void Slic3r::SLAPrintObject::config_apply_only ( const ConfigBase & other, const t_config_option_keys & keys, bool ignore_nonexistent = false )

inlineprotected

        { m_config.apply_only(other, keys, ignore_nonexistent); }

References m_config.

copy_id()

void Slic3r::ObjectBase::copy_id ( const ObjectBase & rhs )

inlineprotectedinherited

{ m_id = rhs.id(); }

create_slice_record()

template<class T>

SliceRecord Slic3r::SLAPrintObject::create_slice_record ( T val )

inlinestaticprivate

    {
        static_assert(std::is_arithmetic<T>::value, "Arithmetic only!");
        return std::is_integral<T>::value
                   ? SliceRecord{coord_t(val), 0.f, 0.f}
                   : SliceRecord{0, float(val), 0.f};
    }

Referenced by closest_slice_record().

Here is the caller graph for this function:

emptylayer_update_msg()

void Slic3r::PrintObjectBase::emptylayer_update_msg ( PrintBase * print, int type, const std::string & message, bool overwrite )

protectedinherited

generate_new_id()

ObjectID Slic3r::ObjectBase::generate_new_id ( )

inlinestaticprivateinherited

{ return ObjectID(++ s_last_id); }

get_current_elevation()

double Slic3r::SLAPrintObject::get_current_elevation

(

)

const

{
    if (is_zero_elevation(m_config)) return 0.;
 
    bool has_supports = is_step_done(slaposSupportTree);
    bool has_pad      = is_step_done(slaposPad);
 
    if(!has_supports && !has_pad)
        return 0;
    else if(has_supports && !has_pad) {
        return m_config.support_object_elevation.getFloat();
    }
 
    return get_elevation();
}

References get_elevation(), Slic3r::PrintObjectBaseWithState< SLAPrint, SLAPrintObjectStep, slaposCount >::is_step_done(), Slic3r::is_zero_elevation(), m_config, Slic3r::slaposPad, and Slic3r::slaposSupportTree.

Here is the call graph for this function:

get_elevation()

double Slic3r::SLAPrintObject::get_elevation

(

)

const

                                           {
    if (is_zero_elevation(m_config)) return 0.;
 
    bool en = m_config.supports_enable.getBool();
 
    double ret = en ? m_config.support_object_elevation.getFloat() : 0.;
 
    if(m_config.pad_enable.getBool()) {
        // Normally the elevation for the pad itself would be the thickness of
        // its walls but currently it is half of its thickness. Whatever it
        // will be in the future, we provide the config to the get_pad_elevation
        // method and we will have the correct value
        sla::PadConfig pcfg = make_pad_cfg(m_config);
        if(!pcfg.embed_object) ret += pcfg.required_elevation();
    }
 
    return ret;
}

References Slic3r::sla::PadConfig::embed_object, Slic3r::is_zero_elevation(), m_config, Slic3r::make_pad_cfg(), and Slic3r::sla::PadConfig::required_elevation().

Referenced by get_current_elevation(), and Slic3r::SLAPrint::Steps::slice_model().

Here is the call graph for this function:

Here is the caller graph for this function:

get_mesh()

TriangleMesh Slic3r::SLAPrintObject::get_mesh

(

SLAPrintObjectStep

step

)

const

{
    switch (step) {
    case slaposSupportTree:
        return this->support_mesh();
    case slaposPad:
        return this->pad_mesh();
    case slaposDrillHoles:
        if (m_hollowing_data)
            return get_mesh_to_print();
        [[fallthrough]];
    default:
        return TriangleMesh();
    }
}

References get_mesh_to_print(), m_hollowing_data, pad_mesh(), Slic3r::slaposDrillHoles, Slic3r::slaposPad, Slic3r::slaposSupportTree, and support_mesh().

Referenced by Slic3r::GLVolumeCollection::load_object_auxiliary().

Here is the call graph for this function:

Here is the caller graph for this function:

get_mesh_to_print()

const TriangleMesh & Slic3r::SLAPrintObject::get_mesh_to_print ( ) const

inline

                                                   {
        return (m_hollowing_data && is_step_done(slaposDrillHoles)) ? m_hollowing_data->hollow_mesh_with_holes_trimmed : transformed_mesh();
    }

References Slic3r::PrintObjectBaseWithState< SLAPrint, SLAPrintObjectStep, slaposCount >::is_step_done(), m_hollowing_data, Slic3r::slaposDrillHoles, and transformed_mesh().

Referenced by Slic3r::GUI::Plater::export_stl(), get_mesh(), Slic3r::SLAPrint::Steps::slice_model(), and Slic3r::SLAPrint::Steps::support_points().

Here is the call graph for this function:

Here is the caller graph for this function:

get_mesh_to_slice()

const TriangleMesh & Slic3r::SLAPrintObject::get_mesh_to_slice ( ) const

inline

                                                   {
        return (m_hollowing_data && is_step_done(slaposDrillHoles)) ? m_hollowing_data->hollow_mesh_with_holes : transformed_mesh();
    }

References Slic3r::PrintObjectBaseWithState< SLAPrint, SLAPrintObjectStep, slaposCount >::is_step_done(), m_hollowing_data, Slic3r::slaposDrillHoles, and transformed_mesh().

Referenced by Slic3r::SLAPrint::Steps::slice_model().

Here is the call graph for this function:

Here is the caller graph for this function:

get_model_slices()

const std::vector< ExPolygons > & Slic3r::SLAPrintObject::get_model_slices ( ) const

inlineprivate

{ return m_model_slices; }

References m_model_slices.

Referenced by Slic3r::SLAPrint::Steps::support_points().

Here is the caller graph for this function:

get_slice_index()

const std::vector< SliceRecord > & Slic3r::SLAPrintObject::get_slice_index ( ) const

inline

                                                          {
        return m_slice_index;
    }

References m_slice_index.

Referenced by Slic3r::GUI::GLCanvas3D::_render_sla_slices(), and Slic3r::SLAPrint::Steps::initialize_printer_input().

Here is the caller graph for this function:

get_support_points()

const std::vector< sla::SupportPoint > & Slic3r::SLAPrintObject::get_support_points

(

)

const

{
    return m_supportdata? m_supportdata->pts : EMPTY_SUPPORT_POINTS;
}

References m_supportdata.

get_support_slices()

const std::vector< ExPolygons > & Slic3r::SLAPrintObject::get_support_slices ( ) const

private

{
    // assert(is_step_done(slaposSliceSupports));
    if (!m_supportdata) return EMPTY_SLICES;
    return m_supportdata->support_slices;
}

References m_supportdata.

has_mesh()

bool Slic3r::SLAPrintObject::has_mesh

(

SLAPrintObjectStep

step

)

const

{
    switch (step) {
    case slaposDrillHoles:
        return m_hollowing_data && !m_hollowing_data->hollow_mesh_with_holes.empty();
    case slaposSupportTree:
        return ! this->support_mesh().empty();
    case slaposPad:
        return ! this->pad_mesh().empty();
    default:
        return false;
    }
}

References Slic3r::TriangleMesh::empty(), m_hollowing_data, pad_mesh(), Slic3r::slaposDrillHoles, Slic3r::slaposPad, Slic3r::slaposSupportTree, and support_mesh().

Here is the call graph for this function:

hollowed_interior_mesh()

const indexed_triangle_set & Slic3r::SLAPrintObject::hollowed_interior_mesh

(

)

const

{
    if (m_hollowing_data && m_hollowing_data->interior &&
        m_config.hollowing_enable.getBool())
        return sla::get_mesh(*m_hollowing_data->interior);
 
    return EMPTY_TRIANGLE_SET;
}

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

Here is the call graph for this function:

id()

ObjectID Slic3r::ObjectBase::id ( ) const

inlineinherited

{ return m_id; }

Referenced by Slic3r::SLAPrintObject::SliceRecord::set_model_slice_idx(), and Slic3r::SLAPrintObject::SliceRecord::set_support_slice_idx().

Here is the caller graph for this function:

instances()

const std::vector< Instance > & Slic3r::SLAPrintObject::instances ( ) const

inline

{ return m_instances; }

References m_instances.

Referenced by Slic3r::GUI::GLCanvas3D::_render_sla_slices(), Slic3r::get_all_polygons(), and set_instances().

Here is the caller graph for this function:

invalidate_all_steps()

bool Slic3r::SLAPrintObject::invalidate_all_steps ( )

protected

{
    const bool inherited_invalidated = Inherited::invalidate_all_steps();
    const bool print_invalidated     = m_print->invalidate_all_steps();
    return inherited_invalidated || print_invalidated;
}

References Slic3r::PrintObjectBaseWithState< SLAPrint, SLAPrintObjectStep, slaposCount >::invalidate_all_steps(), and Slic3r::PrintObjectBaseWithState< SLAPrint, SLAPrintObjectStep, slaposCount >::m_print.

Referenced by invalidate_step().

Here is the call graph for this function:

Here is the caller graph for this function:

invalidate_all_steps_without_cancel()

bool Slic3r::PrintObjectBaseWithState< SLAPrint, SLAPrintObjectStep, COUNT >::invalidate_all_steps_without_cancel ( )

inlineprotectedinherited

        { return m_state.invalidate_all([](){}); }

invalidate_state_by_config_options()

bool Slic3r::SLAPrintObject::invalidate_state_by_config_options ( const std::vector< t_config_option_key > & opt_keys )

protected

{
    if (opt_keys.empty())
        return false;
 
    std::vector<SLAPrintObjectStep> steps;
    bool invalidated = false;
    for (const t_config_option_key &opt_key : opt_keys) {
        if (   opt_key == "hollowing_enable"
            || opt_key == "hollowing_min_thickness"
            || opt_key == "hollowing_quality"
            || opt_key == "hollowing_closing_distance"
            ) {
            steps.emplace_back(slaposHollowing);
        } else if (
               opt_key == "layer_height"
            || opt_key == "faded_layers"
            || opt_key == "pad_enable"
            || opt_key == "pad_wall_thickness"
            || opt_key == "supports_enable"
            || opt_key == "support_object_elevation"
            || opt_key == "pad_around_object"
            || opt_key == "pad_around_object_everywhere"
            || opt_key == "slice_closing_radius") {
            steps.emplace_back(slaposObjectSlice);
        } else if (
               opt_key == "support_points_density_relative"
            || opt_key == "support_points_minimal_distance") {
            steps.emplace_back(slaposSupportPoints);
        } else if (
               opt_key == "support_head_front_diameter"
            || opt_key == "support_head_penetration"
            || opt_key == "support_head_width"
            || opt_key == "support_pillar_diameter"
            || opt_key == "support_small_pillar_diameter_percent"
            || opt_key == "support_max_bridges_on_pillar"
            || opt_key == "support_pillar_connection_mode"
            || opt_key == "support_buildplate_only"
            || opt_key == "support_base_diameter"
            || opt_key == "support_base_height"
            || opt_key == "support_critical_angle"
            || opt_key == "support_max_bridge_length"
            || opt_key == "support_max_pillar_link_distance"
            || opt_key == "support_base_safety_distance"
            ) {
            steps.emplace_back(slaposSupportTree);
        } else if (
               opt_key == "pad_wall_height"
            || opt_key == "pad_brim_size"
            || opt_key == "pad_max_merge_distance"
            || opt_key == "pad_wall_slope"
            || opt_key == "pad_edge_radius"
            || opt_key == "pad_object_gap"
            || opt_key == "pad_object_connector_stride"
            || opt_key == "pad_object_connector_width"
            || opt_key == "pad_object_connector_penetration"
            ) {
            steps.emplace_back(slaposPad);
        } else {
            // All keys should be covered.
            assert(false);
        }
    }
 
    sort_remove_duplicates(steps);
    for (SLAPrintObjectStep step : steps)
        invalidated |= this->invalidate_step(step);
    return invalidated;
}

References invalidate_step(), Slic3r::slaposHollowing, Slic3r::slaposObjectSlice, Slic3r::slaposPad, Slic3r::slaposSupportPoints, Slic3r::slaposSupportTree, and Slic3r::sort_remove_duplicates().

Here is the call graph for this function:

invalidate_step()

bool Slic3r::SLAPrintObject::invalidate_step ( SLAPrintObjectStep step )

protected

{
    bool invalidated = Inherited::invalidate_step(step);
    // propagate to dependent steps
    if (step == slaposHollowing) {
        invalidated |= this->invalidate_all_steps();
    } else if (step == slaposDrillHoles) {
        invalidated |= this->invalidate_steps({ slaposObjectSlice, slaposSupportPoints, slaposSupportTree, slaposPad, slaposSliceSupports });
        invalidated |= m_print->invalidate_step(slapsMergeSlicesAndEval);
    } else if (step == slaposObjectSlice) {
        invalidated |= this->invalidate_steps({ slaposSupportPoints, slaposSupportTree, slaposPad, slaposSliceSupports });
        invalidated |= m_print->invalidate_step(slapsMergeSlicesAndEval);
    } else if (step == slaposSupportPoints) {
        invalidated |= this->invalidate_steps({ slaposSupportTree, slaposPad, slaposSliceSupports });
        invalidated |= m_print->invalidate_step(slapsMergeSlicesAndEval);
    } else if (step == slaposSupportTree) {
        invalidated |= this->invalidate_steps({ slaposPad, slaposSliceSupports });
        invalidated |= m_print->invalidate_step(slapsMergeSlicesAndEval);
    } else if (step == slaposPad) {
        invalidated |= this->invalidate_steps({slaposSliceSupports});
        invalidated |= m_print->invalidate_step(slapsMergeSlicesAndEval);
    } else if (step == slaposSliceSupports) {
        invalidated |= m_print->invalidate_step(slapsMergeSlicesAndEval);
    }
    return invalidated;
}

References invalidate_all_steps(), Slic3r::PrintObjectBaseWithState< SLAPrint, SLAPrintObjectStep, slaposCount >::invalidate_step(), Slic3r::PrintObjectBaseWithState< SLAPrint, SLAPrintObjectStep, slaposCount >::invalidate_steps(), Slic3r::PrintObjectBaseWithState< SLAPrint, SLAPrintObjectStep, slaposCount >::m_print, Slic3r::slaposDrillHoles, Slic3r::slaposHollowing, Slic3r::slaposObjectSlice, Slic3r::slaposPad, Slic3r::slaposSliceSupports, Slic3r::slaposSupportPoints, Slic3r::slaposSupportTree, and Slic3r::slapsMergeSlicesAndEval.

Referenced by invalidate_state_by_config_options().

Here is the call graph for this function:

Here is the caller graph for this function:

invalidate_steps() [1/2]

bool Slic3r::PrintObjectBaseWithState< SLAPrint, SLAPrintObjectStep, COUNT >::invalidate_steps ( std::initializer_list< SLAPrintObjectStep > il )

inlineprotectedinherited

        { return m_state.invalidate_multiple(il.begin(), il.end(), PrintObjectBase::cancel_callback(m_print)); }

invalidate_steps() [2/2]

bool Slic3r::PrintObjectBaseWithState< SLAPrint, SLAPrintObjectStep, COUNT >::invalidate_steps ( StepTypeIterator step_begin, StepTypeIterator step_end )

inlineprotectedinherited

        { return m_state.invalidate_multiple(step_begin, step_end, PrintObjectBase::cancel_callback(m_print)); }

Referenced by Slic3r::SLAPrintObject::invalidate_step().

Here is the caller graph for this function:

is_left_handed()

bool Slic3r::SLAPrintObject::is_left_handed ( ) const

inline

{ return m_left_handed; }

References m_left_handed.

Referenced by Slic3r::GUI::GLCanvas3D::_render_sla_slices(), and Slic3r::get_all_polygons().

Here is the caller graph for this function:

is_step_done()

bool Slic3r::PrintObjectBaseWithState< SLAPrint, SLAPrintObjectStep, COUNT >::is_step_done ( SLAPrintObjectStep step ) const

inlineinherited

{ return m_state.is_done(step, PrintObjectBase::state_mutex(m_print)); }

Referenced by Slic3r::SLAPrintObject::get_current_elevation(), Slic3r::SLAPrintObject::get_mesh_to_print(), and Slic3r::SLAPrintObject::get_mesh_to_slice().

Here is the caller graph for this function:

is_step_done_unguarded()

bool Slic3r::PrintObjectBaseWithState< SLAPrint, SLAPrintObjectStep, COUNT >::is_step_done_unguarded ( SLAPrintObjectStep step ) const

inlineprotectedinherited

{ return m_state.is_done_unguarded(step); }

is_step_started_unguarded()

bool Slic3r::PrintObjectBaseWithState< SLAPrint, SLAPrintObjectStep, COUNT >::is_step_started_unguarded ( SLAPrintObjectStep step ) const

inlineprotectedinherited

{ return m_state.is_started_unguarded(step); }

level()

template<class T>

T Slic3r::SLAPrintObject::level ( const SliceRecord & sr )

inlinestaticprivate

    {
        static_assert(std::is_arithmetic<T>::value, "Arithmetic only!");
        return std::is_integral<T>::value ? T(sr.print_level())
                                          : T(sr.slice_level());
    }

References Slic3r::SLAPrintObject::SliceRecord::print_level(), and Slic3r::SLAPrintObject::SliceRecord::slice_level().

Referenced by closest_slice_record().

Here is the call graph for this function:

Here is the caller graph for this function:

load_and_construct()

void Slic3r::ObjectBase::load_and_construct ( Archive & ar, cereal::construct< ObjectBase > & construct )

inlinestaticprivateinherited

{ ObjectID id; ar(id); construct(id); }

model_object() [1/2]

ModelObject * Slic3r::PrintObjectBase::model_object ( )

inlineinherited

{ return m_model_object; }

model_object() [2/2]

const ModelObject * Slic3r::PrintObjectBase::model_object ( ) const

inlineinherited

{ return m_model_object; }

Referenced by Slic3r::SLAPrintObject::SLAPrintObject(), and Slic3r::SLAPrintObject::SLAPrint.

Here is the caller graph for this function:

operator=()

SLAPrintObject & Slic3r::SLAPrintObject::operator= ( const SLAPrintObject & )

delete

References SLAPrintObject().

Here is the call graph for this function:

pad_mesh()

const TriangleMesh & Slic3r::SLAPrintObject::pad_mesh

(

)

const

{
    if(m_config.pad_enable.getBool() && m_supportdata)
        return m_supportdata->pad_mesh;
 
    return EMPTY_MESH;
}

References m_config, and m_supportdata.

Referenced by get_mesh(), and has_mesh().

Here is the caller graph for this function:

print() [1/2]

SLAPrint * Slic3r::PrintObjectBaseWithState< SLAPrint, SLAPrintObjectStep, COUNT >::print ( )

inlineinherited

{ return m_print; }

Referenced by Slic3r::SLAPrintObject::SLAPrintObject(), and Slic3r::SLAPrintObject::SLAPrint.

Here is the caller graph for this function:

print() [2/2]

const SLAPrint * Slic3r::PrintObjectBaseWithState< SLAPrint, SLAPrintObjectStep, COUNT >::print ( ) const

inlineinherited

{ return m_print; }

serialize()

void Slic3r::ObjectBase::serialize ( Archive & ar )

inlineprivateinherited

{ ar(m_id); }

set_done()

PrintStateBase::TimeStamp Slic3r::PrintObjectBaseWithState< SLAPrint, SLAPrintObjectStep, COUNT >::set_done ( SLAPrintObjectStep step )

inlineprotectedinherited

                                                             {
    std::pair<PrintStateBase::TimeStamp, bool> status = m_state.set_done(step, PrintObjectBase::state_mutex(m_print), [this](){ this->throw_if_canceled(); });
        if (status.second)
            this->status_update_warnings(m_print, static_cast<int>(step), PrintStateBase::WarningLevel::NON_CRITICAL, std::string());
        return status.first;
  }

set_instances()

template<class InstVec>

void Slic3r::SLAPrintObject::set_instances ( InstVec && instances )

inlineprotected

{ m_instances = std::forward<InstVec>(instances); }

References instances(), and m_instances.

Here is the call graph for this function:

set_invalid_id()

void Slic3r::ObjectBase::set_invalid_id ( )

inlineprotectedinherited

{ m_id = 0; }

set_new_unique_id()

void Slic3r::ObjectBase::set_new_unique_id ( )

inlineprotectedinherited

{ m_id = generate_new_id(); }

set_started()

bool Slic3r::PrintObjectBaseWithState< SLAPrint, SLAPrintObjectStep, COUNT >::set_started ( SLAPrintObjectStep step )

inlineprotectedinherited

        { return m_state.set_started(step, PrintObjectBase::state_mutex(m_print), [this](){ this->throw_if_canceled(); }); }

set_trafo()

void Slic3r::SLAPrintObject::set_trafo ( const Transform3d & trafo, bool left_handed )

inlineprotected

                                                                                  {
        m_transformed_rmesh.invalidate([this, &trafo, left_handed](){ m_trafo = trafo; m_left_handed = left_handed; });
    }

References m_left_handed, m_trafo, m_transformed_rmesh, and trafo().

Here is the call graph for this function:

state_mutex()

std::mutex & Slic3r::PrintObjectBase::state_mutex ( PrintBase * print )

staticprotectedinherited

{
  return print->state_mutex();
}

status_update_warnings()

void Slic3r::PrintObjectBase::status_update_warnings ( PrintBase * print, int step, PrintStateBase::WarningLevel warning_level, const std::string & message, PrintStateBase::SlicingNotificationType message_id = PrintStateBase::SlicingDefaultNotification )

protectedinherited

{
    print->status_update_warnings(step, warning_level, message, this, message_id);
}

step_state_with_timestamp()

PrintStateBase::StateWithTimeStamp Slic3r::PrintObjectBaseWithState< SLAPrint, SLAPrintObjectStep, COUNT >::step_state_with_timestamp ( SLAPrintObjectStep step ) const

inlineinherited

{ return m_state.state_with_timestamp(step, PrintObjectBase::state_mutex(m_print)); }

step_state_with_warnings()

PrintStateBase::StateWithWarnings Slic3r::PrintObjectBaseWithState< SLAPrint, SLAPrintObjectStep, COUNT >::step_state_with_warnings ( SLAPrintObjectStep step ) const

inlineinherited

{ return m_state.state_with_warnings(step, PrintObjectBase::state_mutex(m_print)); }

support_mesh()

const TriangleMesh & Slic3r::SLAPrintObject::support_mesh

(

)

const

{
    if(m_config.supports_enable.getBool() && m_supportdata)
        return m_supportdata->tree_mesh;
 
    return EMPTY_MESH;
}

References m_config, and m_supportdata.

Referenced by get_mesh(), has_mesh(), and Slic3r::SLAPrint::Steps::support_tree().

Here is the caller graph for this function:

throw_if_canceled()

void Slic3r::PrintObjectBaseWithState< SLAPrint, SLAPrintObjectStep, COUNT >::throw_if_canceled ( )

inlineprotectedinherited

{ if (m_print->canceled()) throw CanceledException(); }

timestamp()

virtual Timestamp Slic3r::ObjectBase::timestamp ( ) const

inlinevirtualinherited

{ return 0; }

trafo()

const Transform3d & Slic3r::SLAPrintObject::trafo ( ) const

inline

{ return m_trafo; }

References m_trafo.

Referenced by Slic3r::SLAPrint::apply(), Slic3r::GLVolumeCollection::load_object_auxiliary(), set_trafo(), transformed_drainhole_points(), and transformed_support_points().

Here is the caller graph for this function:

transformed_drainhole_points()

sla::DrainHoles Slic3r::SLAPrintObject::transformed_drainhole_points

(

)

const

{
    assert(m_model_object != nullptr);
    auto pts = m_model_object->sla_drain_holes;
    auto tr = trafo().cast<float>();
    auto sc = m_model_object->instances.front()->get_scaling_factor().cast<float>();
    for (sla::DrainHole &hl : pts) {
        hl.pos = tr * hl.pos;
        hl.normal = tr * hl.normal - tr.translation();
 
        // The normal scales as a covector (and we must also
        // undo the damage already done).
        hl.normal = Vec3f(hl.normal(0)/(sc(0)*sc(0)),
                          hl.normal(1)/(sc(1)*sc(1)),
                          hl.normal(2)/(sc(2)*sc(2)));
 
        // Now shift the hole a bit above the object and make it deeper to
        // compensate for it. This is to avoid problems when the hole is placed
        // on (nearly) flat surface.
        hl.pos -= hl.normal.normalized() * sla::HoleStickOutLength;
        hl.height += sla::HoleStickOutLength;
    }
 
    return pts;
}

References Slic3r::sla::HoleStickOutLength, Slic3r::PrintObjectBaseWithState< SLAPrint, SLAPrintObjectStep, slaposCount >::m_model_object, and trafo().

Here is the call graph for this function:

transformed_mesh()

const TriangleMesh & Slic3r::SLAPrintObject::transformed_mesh

(

)

const

                                                           {
    // we need to transform the raw mesh...
    // currently all the instances share the same x and y rotation and scaling
    // so we have to extract those from e.g. the first instance and apply to the
    // raw mesh. This is also true for the support points.
    // BUT: when the support structure is spawned for each instance than it has
    // to omit the X, Y rotation and scaling as those have been already applied
    // or apply an inverse transformation on the support structure after it
    // has been created.
 
    return m_transformed_rmesh.get();
}

References m_transformed_rmesh.

Referenced by Slic3r::SLAPrint::Steps::generate_pad(), get_mesh_to_print(), get_mesh_to_slice(), and Slic3r::SLAPrint::Steps::hollow_model().

Here is the caller graph for this function:

transformed_support_points()

sla::SupportPoints Slic3r::SLAPrintObject::transformed_support_points

(

)

const

{
    assert(m_model_object != nullptr);
    auto spts = m_model_object->sla_support_points;
    auto tr = trafo().cast<float>();
    for (sla::SupportPoint& suppt : spts) {
        suppt.pos = tr * suppt.pos;
    }
 
    return spts;
}

References Slic3r::PrintObjectBaseWithState< SLAPrint, SLAPrintObjectStep, slaposCount >::m_model_object, and trafo().

Referenced by Slic3r::SLAPrint::Steps::support_points().

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Symbol Documentation

SLAPrint

friend class SLAPrint

friend

References Slic3r::PrintObjectBaseWithState< SLAPrint, SLAPrintObjectStep, slaposCount >::model_object(), Slic3r::PrintObjectBaseWithState< SLAPrint, SLAPrintObjectStep, slaposCount >::print(), and SLAPrint.

Referenced by SLAPrintObject(), and SLAPrint.

Member Data Documentation

m_config

SLAPrintObjectConfig Slic3r::SLAPrintObject::m_config

private

Referenced by Slic3r::SLAPrint::Steps::apply_printer_corrections(), config(), config_apply(), config_apply_only(), Slic3r::SLAPrint::Steps::generate_pad(), get_current_elevation(), get_elevation(), Slic3r::SLAPrint::Steps::hollow_model(), hollowed_interior_mesh(), pad_mesh(), Slic3r::SLAPrint::Steps::slice_model(), Slic3r::SLAPrint::Steps::slice_supports(), support_mesh(), Slic3r::SLAPrint::Steps::support_points(), and Slic3r::SLAPrint::Steps::support_tree().

m_hollowing_data

std::unique_ptr<HollowingData> Slic3r::SLAPrintObject::m_hollowing_data

private

Referenced by get_mesh(), get_mesh_to_print(), get_mesh_to_slice(), has_mesh(), Slic3r::SLAPrint::Steps::hollow_model(), hollowed_interior_mesh(), and Slic3r::SLAPrint::Steps::slice_model().

m_id

ObjectID Slic3r::ObjectBase::m_id

privateinherited

m_instances

std::vector<Instance> Slic3r::SLAPrintObject::m_instances

private

Referenced by instances(), and set_instances().

m_left_handed

bool Slic3r::SLAPrintObject::m_left_handed = false

private

Referenced by is_left_handed(), and set_trafo().

m_model_height_levels

std::vector<float> Slic3r::SLAPrintObject::m_model_height_levels

private

Referenced by Slic3r::SLAPrint::Steps::slice_model(), and Slic3r::SLAPrint::Steps::support_points().

m_model_object

ModelObject* Slic3r::PrintObjectBase::m_model_object

protectedinherited

Referenced by Slic3r::SLAPrintObject::SLAPrintObject(), Slic3r::SLAPrintObject::transformed_drainhole_points(), and Slic3r::SLAPrintObject::transformed_support_points().

m_model_slices

std::vector<ExPolygons> Slic3r::SLAPrintObject::m_model_slices

private

Referenced by Slic3r::SLAPrint::Steps::apply_printer_corrections(), get_model_slices(), and Slic3r::SLAPrint::Steps::slice_model().

m_print

SLAPrint* Slic3r::PrintObjectBaseWithState< SLAPrint, SLAPrintObjectStep, COUNT >::m_print

protectedinherited

Referenced by Slic3r::SLAPrintObject::invalidate_all_steps(), and Slic3r::SLAPrintObject::invalidate_step().

m_slice_index

std::vector<SliceRecord> Slic3r::SLAPrintObject::m_slice_index

private

Referenced by Slic3r::SLAPrint::Steps::apply_printer_corrections(), closest_slice_to_print_level(), closest_slice_to_slice_level(), get_slice_index(), Slic3r::SLAPrint::Steps::slice_model(), and Slic3r::SLAPrint::Steps::slice_supports().

m_state

PrintState<SLAPrintObjectStep, COUNT> Slic3r::PrintObjectBaseWithState< SLAPrint, SLAPrintObjectStep, COUNT >::m_state

privateinherited

m_stepmask

std::vector<bool> Slic3r::SLAPrintObject::m_stepmask

protected

Referenced by SLAPrintObject(), and Slic3r::SLAPrint::set_task().

m_supportdata

std::unique_ptr<SupportData> Slic3r::SLAPrintObject::m_supportdata

private

Referenced by Slic3r::SLAPrint::Steps::apply_printer_corrections(), Slic3r::SLAPrint::Steps::generate_pad(), get_support_points(), get_support_slices(), pad_mesh(), Slic3r::SLAPrint::Steps::slice_model(), Slic3r::SLAPrint::Steps::slice_supports(), support_mesh(), Slic3r::SLAPrint::Steps::support_points(), and Slic3r::SLAPrint::Steps::support_tree().

m_trafo

Transform3d Slic3r::SLAPrintObject::m_trafo = Transform3d::Identity()

private

Referenced by set_trafo(), and trafo().

m_transformed_rmesh

CachedObject<TriangleMesh> Slic3r::SLAPrintObject::m_transformed_rmesh

mutableprivate

Referenced by SLAPrintObject(), set_trafo(), and transformed_mesh().

PrintType

friend Slic3r::PrintObjectBaseWithState< SLAPrint, SLAPrintObjectStep, COUNT >::SLAPrint

protectedinherited

s_last_id

size_t Slic3r::ObjectBase::s_last_id

staticprivateinherited

---

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

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