Slic3r::ModelObject Class Reference

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

Inheritance diagram for Slic3r::ModelObject:

Collaboration diagram for Slic3r::ModelObject:

Public Types
using	Timestamp = uint64_t

Public Member Functions
Model *	get_model ()
const Model *	get_model () const
int	get_backup_id () const
template<typename T>
const T *	get_config_value (const DynamicPrintConfig &global_config, const std::string &config_option)
ModelVolume *	add_volume (const TriangleMesh &mesh, bool modify_to_center_geometry=true)
ModelVolume *	add_volume (TriangleMesh &&mesh, ModelVolumeType type=ModelVolumeType::MODEL_PART, bool modify_to_center_geometry=true)
ModelVolume *	add_volume (const ModelVolume &volume, ModelVolumeType type=ModelVolumeType::INVALID)
ModelVolume *	add_volume (const ModelVolume &volume, TriangleMesh &&mesh)
ModelVolume *	add_volume_with_shared_mesh (const ModelVolume &other, ModelVolumeType type=ModelVolumeType::MODEL_PART)
void	delete_volume (size_t idx)
void	clear_volumes ()
void	sort_volumes (bool full_sort)
bool	is_multiparts () const
bool	is_fdm_support_painted () const
bool	is_seam_painted () const
bool	is_mm_painted () const
bool	is_fuzzy_skin_painted () const
bool	has_custom_layering () const
ModelInstance *	add_instance ()
ModelInstance *	add_instance (const ModelInstance &instance)
ModelInstance *	add_instance (const Vec3d &offset, const Vec3d &scaling_factor, const Vec3d &rotation, const Vec3d &mirror)
void	delete_instance (size_t idx)
void	delete_last_instance ()
void	clear_instances ()
const BoundingBoxf3 &	bounding_box_approx () const
const BoundingBoxf3 &	bounding_box_exact () const
double	min_z () const
double	max_z () const
void	invalidate_bounding_box ()
TriangleMesh	mesh () const
TriangleMesh	raw_mesh () const
indexed_triangle_set	raw_indexed_triangle_set () const
const BoundingBoxf3 &	raw_bounding_box () const
BoundingBoxf3	instance_bounding_box (size_t instance_idx, bool dont_translate=false) const
BoundingBoxf3	instance_bounding_box (const ModelInstance &instance, bool dont_translate=false) const
const BoundingBoxf3 &	raw_mesh_bounding_box () const
BoundingBoxf3	full_raw_mesh_bounding_box () const
BoundingBoxf3	instance_convex_hull_bounding_box (size_t instance_idx, bool dont_translate=false) const
BoundingBoxf3	instance_convex_hull_bounding_box (const ModelInstance *instance, bool dont_translate=false) const
Polygon	convex_hull_2d (const Transform3d &trafo_instance) const
void	center_around_origin (bool include_modifiers=true)
void	ensure_on_bed (bool allow_negative_z=false)
void	translate_instances (const Vec3d &vector)
void	translate_instance (size_t instance_idx, const Vec3d &vector)
void	translate (const Vec3d &vector)
void	translate (double x, double y, double z)
void	scale (const Vec3d &versor)
void	scale (const double s)
void	scale (double x, double y, double z)
void	scale_to_fit (const Vec3d &size)
	Scale the current ModelObject to fit by altering the scaling factor of ModelInstances. It operates on the total size by duplicating the object according to all the instances.
void	rotate (double angle, Axis axis)
void	rotate (double angle, const Vec3d &axis)
void	mirror (Axis axis)
void	scale_mesh_after_creation (const float scale)
void	convert_units (ModelObjectPtrs &new_objects, ConversionType conv_type, std::vector< int > volume_idxs)
size_t	materials_count () const
size_t	facets_count () const
size_t	parts_count () const
void	invalidate_cut ()
void	delete_connectors ()
void	clone_for_cut (ModelObject **obj)
void	split (ModelObjectPtrs *new_objects, bool remap_paint)
void	merge ()
bool	make_boolean (ModelObject *cut_object, const std::string &boolean_opts)
ModelObjectPtrs	merge_volumes (std::vector< int > &vol_indeces)
void	bake_xy_rotation_into_meshes (size_t instance_idx)
double	get_instance_min_z (size_t instance_idx) const
double	get_instance_max_z (size_t instance_idx) const
void	print_info () const
std::string	get_export_filename () const
TriangleMeshStats	get_object_stl_stats () const
int	get_repaired_errors_count (const int vol_idx=-1) const
bool	has_solid_mesh () const
bool	is_cut () const
bool	has_connectors () const
ObjectID	id () const
virtual Timestamp	timestamp () const

Public Attributes
std::string	name
std::string	module_name
std::string	input_file
ModelInstancePtrs	instances
ModelVolumePtrs	volumes
ModelConfigObject	config
t_layer_config_ranges	layer_config_ranges
LayerHeightProfile	layer_height_profile
bool	printable { true }
bool	auto_drop { true }
sla::SupportPoints	sla_support_points
sla::PointsStatus	sla_points_status = sla::PointsStatus::NoPoints
sla::DrainHoles	sla_drain_holes
BrimPoints	brim_points
Vec3d	origin_translation
std::vector< ObjectID >	volume_ids
CutConnectors	cut_connectors
CutObjectBase	cut_id

Protected Member Functions
void	set_invalid_id ()
void	copy_id (const ObjectBase &rhs)

Private Member Functions
	ModelObject (Model *model)
	ModelObject (int)
	~ModelObject ()
void	assign_new_unique_ids_recursive () override
	ModelObject (const ModelObject &rhs)
	ModelObject (ModelObject &&rhs)
ModelObject &	operator= (const ModelObject &rhs)
ModelObject &	operator= (ModelObject &&rhs)
void	set_new_unique_id ()
void	copy_transformation_caches (const ModelObject &src)
void	set_model (Model *model)
	ModelObject ()
template<class Archive>
void	save (Archive &ar) const
template<class Archive>
void	load (Archive &ar)
unsigned int	update_instances_print_volume_state (const BuildVolume &build_volume)
void	update_min_max_z ()
template<class Archive>
void	serialize (Archive &ar)

Static Private Member Functions
static ObjectID	generate_new_id ()
template<class Archive>
static void	load_and_construct (Archive &ar, cereal::construct< ObjectBase > &construct)

Private Attributes
Model *	m_model { nullptr }
BoundingBoxf3	m_bounding_box_approx
bool	m_bounding_box_approx_valid { false }
BoundingBoxf3	m_bounding_box_exact
bool	m_bounding_box_exact_valid { false }
bool	m_min_max_z_valid { false }
BoundingBoxf3	m_raw_bounding_box
bool	m_raw_bounding_box_valid { false }
BoundingBoxf3	m_raw_mesh_bounding_box
bool	m_raw_mesh_bounding_box_valid { false }
ObjectID	m_id

Static Private Attributes
static size_t	s_last_id = 0

Friends
class	Model
class	Print
class	SLAPrint
class	cereal::access
class	UndoRedo::StackImpl

Detailed Description

Member Typedef Documentation

Timestamp

using Slic3r::ObjectBase::Timestamp = uint64_t

inherited

Constructor & Destructor Documentation

ModelObject() [1/5]

Slic3r::ModelObject::ModelObject ( Model * model )

inlineexplicitprivate

                                       : m_model(model), origin_translation(Vec3d::Zero())
    {
        assert(this->id().valid());
        assert(this->config.id().valid());
        assert(this->layer_height_profile.id().valid());
    }

References Slic3r::ObjectBase::id(), m_model, Model, origin_translation, and Slic3r::ObjectID::valid().

Referenced by ModelObject(), ModelObject(), clone_for_cut(), convert_units(), copy_transformation_caches(), make_boolean(), max_z(), merge_volumes(), min_z(), operator=(), operator=(), and split().

Here is the call graph for this function:

Here is the caller graph for this function:

ModelObject() [2/5]

Slic3r::ModelObject::ModelObject ( int )

inlineexplicitprivate

                              : ObjectBase(-1), config(-1), layer_height_profile(-1), origin_translation(Vec3d::Zero())
    {
        assert(this->id().invalid());
        assert(this->config.id().invalid());
        assert(this->layer_height_profile.id().invalid());
    }

References Slic3r::ObjectBase::ObjectBase(), config, Slic3r::ObjectBase::id(), Slic3r::ObjectID::invalid(), layer_height_profile, and origin_translation.

Here is the call graph for this function:

~ModelObject()

Slic3r::ModelObject::~ModelObject ( )

private

{
    this->clear_volumes();
    this->clear_instances();
}

References ~ModelObject(), clear_instances(), and clear_volumes().

Referenced by ~ModelObject().

Here is the call graph for this function:

Here is the caller graph for this function:

ModelObject() [3/5]

Slic3r::ModelObject::ModelObject ( const ModelObject & rhs )

inlineprivate

                                        : ObjectBase(-1), config(-1), layer_height_profile(-1), m_model(rhs.m_model) {
      assert(this->id().invalid());
        assert(this->config.id().invalid());
        assert(this->layer_height_profile.id().invalid());
        assert(rhs.id() != rhs.config.id());
        assert(rhs.id() != rhs.layer_height_profile.id());
      this->assign_copy(rhs);
      assert(this->id().valid());
        assert(this->config.id().valid());
        assert(this->layer_height_profile.id().valid());
        assert(this->id() != this->config.id());
        assert(this->id() != this->layer_height_profile.id());
      assert(this->id() == rhs.id());
        assert(this->config.id() == rhs.config.id());
        assert(this->layer_height_profile.id() == rhs.layer_height_profile.id());
    }

References ModelObject(), Slic3r::ObjectBase::ObjectBase(), config, Slic3r::ObjectBase::id(), Slic3r::ObjectID::invalid(), layer_height_profile, m_model, and Slic3r::ObjectID::valid().

Here is the call graph for this function:

ModelObject() [4/5]

Slic3r::ModelObject::ModelObject ( ModelObject && rhs )

inlineexplicitprivate

                                            : ObjectBase(-1), config(-1), layer_height_profile(-1) {
      assert(this->id().invalid());
        assert(this->config.id().invalid());
        assert(this->layer_height_profile.id().invalid());
        assert(rhs.id() != rhs.config.id());
        assert(rhs.id() != rhs.layer_height_profile.id());
      this->assign_copy(std::move(rhs));
      assert(this->id().valid());
        assert(this->config.id().valid());
        assert(this->layer_height_profile.id().valid());
        assert(this->id() != this->config.id());
        assert(this->id() != this->layer_height_profile.id());
      assert(this->id() == rhs.id());
        assert(this->config.id() == rhs.config.id());
        assert(this->layer_height_profile.id() == rhs.layer_height_profile.id());
    }

References ModelObject(), Slic3r::ObjectBase::ObjectBase(), config, Slic3r::ObjectBase::id(), Slic3r::ObjectID::id, Slic3r::ObjectID::invalid(), layer_height_profile, and Slic3r::ObjectID::valid().

Here is the call graph for this function:

ModelObject() [5/5]

Slic3r::ModelObject::ModelObject ( )

inlineprivate

                :
        ObjectBase(-1), config(-1), layer_height_profile(-1) {
    assert(this->id().invalid());
        assert(this->config.id().invalid());
        assert(this->layer_height_profile.id().invalid());
  }

References Slic3r::ObjectBase::ObjectBase(), config, Slic3r::ObjectBase::id(), Slic3r::ObjectID::invalid(), and layer_height_profile.

Here is the call graph for this function:

Member Function Documentation

add_instance() [1/3]

ModelInstance * Slic3r::ModelObject::add_instance

(

)

{
    ModelInstance* i = new ModelInstance(this);
    this->instances.push_back(i);
    this->invalidate_bounding_box();
    // BBS: backup: do not save
    if (this->instances.size() == 1)
        Slic3r::save_object_mesh(*this);
    return i;
}

References add_instance(), instances, invalidate_bounding_box(), and Slic3r::save_object_mesh().

Referenced by Slic3r::_3MF_Importer::_load_model_from_file(), add_instance(), add_instance(), add_instance(), Slic3r::GUI::ObjectList::boolean(), Slic3r::GUI::Selection::copy_to_clipboard(), Slic3r::duplicate(), Slic3r::duplicate_objects(), Slic3r::AMFParserContext::endDocument(), Slic3r::GUI::ensure_belt_purge_tower(), anonymous_namespace{EmbossJob.cpp}::CreateObjectJob::finalize(), Slic3r::GUI::Plater::increase_instances(), Slic3r::GUI::ObjectList::load_mesh_object(), Slic3r::GUI::ObjectList::merge(), Slic3r::GUI::FillBedJob::prepare(), Slic3r::GUI::DesignCanvas::rebuild_bodies(), Slic3r::CLI::run(), anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_two_color_cube_and_export(), and split().

Here is the call graph for this function:

Here is the caller graph for this function:

add_instance() [2/3]

ModelInstance * Slic3r::ModelObject::add_instance

(

const ModelInstance &

instance

)

{
    ModelInstance* i = new ModelInstance(this, other);
    this->instances.push_back(i);
    this->invalidate_bounding_box();
    return i;
}

References add_instance(), instances, and invalidate_bounding_box().

Here is the call graph for this function:

add_instance() [3/3]

ModelInstance * Slic3r::ModelObject::add_instance	(	const Vec3d &	offset,
		const Vec3d &	scaling_factor,
		const Vec3d &	rotation,
		const Vec3d &	mirror )

{
    auto *instance = add_instance();
    instance->set_offset(offset);
    instance->set_scaling_factor(scaling_factor);
    instance->set_rotation(rotation);
    instance->set_mirror(mirror);
    return instance;
}

References add_instance(), mirror(), and Slic3r::offset().

Here is the call graph for this function:

add_volume() [1/4]

ModelVolume * Slic3r::ModelObject::add_volume	(	const ModelVolume &	volume,
		ModelVolumeType	type = ModelVolumeType::INVALID )

{
    ModelVolume* v = new ModelVolume(this, other);
    if (type != ModelVolumeType::INVALID && v->type() != type)
        v->set_type(type);
 
    v->cut_info = other.cut_info;
 
    this->volumes.push_back(v);
  // The volume should already be centered at this point of time when copying shared pointers of the triangle mesh and convex hull.
//  v->center_geometry_after_creation();
//    this->invalidate_bounding_box();
    // BBS: backup
    Slic3r::save_object_mesh(*this);
    return v;
}

References add_volume(), Slic3r::ModelVolume::cut_info, Slic3r::INVALID, Slic3r::save_object_mesh(), Slic3r::ModelVolume::set_type(), and Slic3r::ModelVolume::type().

Here is the call graph for this function:

add_volume() [2/4]

ModelVolume * Slic3r::ModelObject::add_volume	(	const ModelVolume &	volume,
		TriangleMesh &&	mesh )

{
    ModelVolume* v = new ModelVolume(this, other, std::move(mesh));
    this->volumes.push_back(v);
    v->center_geometry_after_creation();
    this->invalidate_bounding_box();
    // BBS: backup
    Slic3r::save_object_mesh(*this);
    return v;
}

References add_volume(), Slic3r::ModelVolume::center_geometry_after_creation(), invalidate_bounding_box(), mesh(), and Slic3r::save_object_mesh().

Here is the call graph for this function:

add_volume() [3/4]

ModelVolume * Slic3r::ModelObject::add_volume	(	const TriangleMesh &	mesh,
		bool	modify_to_center_geometry = true )

{
    ModelVolume* v = new ModelVolume(this, mesh);
    this->volumes.push_back(v);
    if (modify_to_center_geometry) {
        v->center_geometry_after_creation();
        this->invalidate_bounding_box();
    }
    // BBS: backup
    Slic3r::save_object_mesh(*this);
    return v;
}

References add_volume(), Slic3r::ModelVolume::center_geometry_after_creation(), invalidate_bounding_box(), mesh(), and Slic3r::save_object_mesh().

Referenced by Slic3r::Model::add_object(), Slic3r::Model::add_object(), add_volume(), add_volume(), add_volume(), add_volume(), Slic3r::GUI::GLGizmoCut3D::apply_cut_connectors(), Slic3r::GUI::ObjectList::boolean(), Slic3r::Model::convert_multipart_object(), convert_units(), Slic3r::GUI::Selection::copy_to_clipboard(), anonymous_namespace{EmbossJob.cpp}::create_volume(), Slic3r::distribute_modifiers_from_object(), Slic3r::GUI::ensure_belt_purge_tower(), anonymous_namespace{EmbossJob.cpp}::CreateObjectJob::finalize(), Slic3r::GUI::GLGizmoMeshBoolean::generate_new_volume(), Slic3r::GUI::ObjectList::load_generic_subobject(), Slic3r::GUI::ObjectList::load_mesh_object(), Slic3r::GUI::ObjectList::load_modifier(), Slic3r::load_svg(), make_boolean(), Slic3r::GUI::ObjectList::merge(), merge(), merge_or_add_object(), merge_volumes(), Slic3r::Step::mesh(), Slic3r::GUI::Selection::paste_volumes_from_clipboard(), Slic3r::Cut::perform_by_contour(), Slic3r::Cut::perform_with_groove(), Slic3r::process_connector_cut(), Slic3r::process_modifier_cut(), Slic3r::GUI::DesignCanvas::rebuild_bodies(), Slic3r::GUI::Plater::priv::reload_from_disk(), Slic3r::GUI::Plater::priv::replace_volume_with_stl(), Slic3r::CLI::run(), anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_two_color_cube_and_export(), and split().

Here is the call graph for this function:

Here is the caller graph for this function:

add_volume() [4/4]

ModelVolume * Slic3r::ModelObject::add_volume	(	TriangleMesh &&	mesh,
		ModelVolumeType	type = ModelVolumeType::MODEL_PART,
		bool	modify_to_center_geometry = true )

{
    ModelVolume* v = new ModelVolume(this, std::move(mesh), type);
    this->volumes.push_back(v);
    if (modify_to_center_geometry) {
        v->center_geometry_after_creation();
        this->invalidate_bounding_box();
    }
    // BBS: backup
    Slic3r::save_object_mesh(*this);
    return v;
}

References add_volume(), Slic3r::ModelVolume::center_geometry_after_creation(), invalidate_bounding_box(), mesh(), and Slic3r::save_object_mesh().

Here is the call graph for this function:

add_volume_with_shared_mesh()

ModelVolume * Slic3r::ModelObject::add_volume_with_shared_mesh	(	const ModelVolume &	other,
		ModelVolumeType	type = ModelVolumeType::MODEL_PART )

{
    ModelVolume* v = new ModelVolume(this, other.m_mesh);
    if (type != ModelVolumeType::INVALID && v->type() != type)
        v->set_type(type);
    this->volumes.push_back(v);
  // The volume should already be centered at this point of time when copying shared pointers of the triangle mesh and convex hull.
//  v->center_geometry_after_creation();
//    this->invalidate_bounding_box();
    // BBS: backup
    Slic3r::save_object_mesh(*this);
    return v;
}

References add_volume_with_shared_mesh(), Slic3r::INVALID, Slic3r::ModelVolume::m_mesh, Slic3r::save_object_mesh(), Slic3r::ModelVolume::set_type(), and Slic3r::ModelVolume::type().

Referenced by add_volume_with_shared_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

assign_new_unique_ids_recursive()

void Slic3r::ModelObject::assign_new_unique_ids_recursive ( )

overrideprivatevirtual

Reimplemented from Slic3r::ObjectBase.

{
    this->set_new_unique_id();
    for (ModelVolume *model_volume : this->volumes)
        model_volume->assign_new_unique_ids_recursive();
    for (ModelInstance *model_instance : this->instances)
        model_instance->assign_new_unique_ids_recursive();
    this->layer_height_profile.set_new_unique_id();
}

References assign_new_unique_ids_recursive(), Slic3r::ModelVolume::assign_new_unique_ids_recursive(), layer_height_profile, and set_new_unique_id().

Referenced by assign_new_unique_ids_recursive().

Here is the call graph for this function:

Here is the caller graph for this function:

bake_xy_rotation_into_meshes()

void Slic3r::ModelObject::bake_xy_rotation_into_meshes

(

size_t

instance_idx

)

{
    assert(instance_idx < this->instances.size());
 
  const Geometry::Transformation reference_trafo = this->instances[instance_idx]->get_transformation();
    if (Geometry::is_rotation_ninety_degrees(reference_trafo.get_rotation()))
        // nothing to do, scaling in the world coordinate space is possible in the representation of Geometry::Transformation.
        return;
 
    bool   left_handed        = reference_trafo.is_left_handed();
    bool   has_mirrorring     = ! reference_trafo.get_mirror().isApprox(Vec3d(1., 1., 1.));
    bool   uniform_scaling    = std::abs(reference_trafo.get_scaling_factor().x() - reference_trafo.get_scaling_factor().y()) < EPSILON &&
                                std::abs(reference_trafo.get_scaling_factor().x() - reference_trafo.get_scaling_factor().z()) < EPSILON;
    double new_scaling_factor = uniform_scaling ? reference_trafo.get_scaling_factor().x() : 1.;
 
    // Adjust the instances.
    for (size_t i = 0; i < this->instances.size(); ++ i) {
        ModelInstance &model_instance = *this->instances[i];
        model_instance.set_rotation(Vec3d(0., 0., Geometry::rotation_diff_z(reference_trafo.get_rotation(), model_instance.get_rotation())));
        model_instance.set_scaling_factor(Vec3d(new_scaling_factor, new_scaling_factor, new_scaling_factor));
        model_instance.set_mirror(Vec3d(1., 1., 1.));
    }
 
    // Adjust the meshes.
    // Transformation to be applied to the meshes.
    Geometry::Transformation reference_trafo_mod = reference_trafo;
    reference_trafo_mod.reset_offset();
    if (uniform_scaling)
        reference_trafo_mod.reset_scaling_factor();
    if (!has_mirrorring)
        reference_trafo_mod.reset_mirror();
    Eigen::Matrix3d mesh_trafo_3x3 = reference_trafo_mod.get_matrix().matrix().block<3, 3>(0, 0);
    Transform3d     volume_offset_correction = this->instances[instance_idx]->get_transformation().get_matrix().inverse() * reference_trafo.get_matrix();
    for (ModelVolume *model_volume : this->volumes) {
        const Geometry::Transformation volume_trafo = model_volume->get_transformation();
        bool   volume_left_handed        = volume_trafo.is_left_handed();
        bool   volume_has_mirrorring     = ! volume_trafo.get_mirror().isApprox(Vec3d(1., 1., 1.));
        bool   volume_uniform_scaling    = std::abs(volume_trafo.get_scaling_factor().x() - volume_trafo.get_scaling_factor().y()) < EPSILON &&
                                           std::abs(volume_trafo.get_scaling_factor().x() - volume_trafo.get_scaling_factor().z()) < EPSILON;
        double volume_new_scaling_factor = volume_uniform_scaling ? volume_trafo.get_scaling_factor().x() : 1.;
        // Transform the mesh.
        Geometry::Transformation volume_trafo_mod = volume_trafo;
        volume_trafo_mod.reset_offset();
        if (volume_uniform_scaling)
            volume_trafo_mod.reset_scaling_factor();
        if (!volume_has_mirrorring)
            volume_trafo_mod.reset_mirror();
        Eigen::Matrix3d volume_trafo_3x3 = volume_trafo_mod.get_matrix().matrix().block<3, 3>(0, 0);
        // Following method creates a new shared_ptr<TriangleMesh>
        model_volume->transform_this_mesh(mesh_trafo_3x3 * volume_trafo_3x3, left_handed != volume_left_handed);
        // Reset the rotation, scaling and mirroring.
        model_volume->set_rotation(Vec3d(0., 0., 0.));
        model_volume->set_scaling_factor(Vec3d(volume_new_scaling_factor, volume_new_scaling_factor, volume_new_scaling_factor));
        model_volume->set_mirror(Vec3d(1., 1., 1.));
        // Move the reference point of the volume to compensate for the change of the instance trafo.
        model_volume->set_offset(volume_offset_correction * volume_trafo.get_offset());
        // reset the source to disable reload from disk
        model_volume->source = ModelVolume::Source();
    }
 
    this->invalidate_bounding_box();
}

References bake_xy_rotation_into_meshes(), EPSILON, Slic3r::Geometry::Transformation::get_matrix(), Slic3r::Geometry::Transformation::get_mirror(), Slic3r::Geometry::Transformation::get_offset(), Slic3r::Geometry::Transformation::get_rotation(), Slic3r::ModelInstance::get_rotation(), Slic3r::Geometry::Transformation::get_scaling_factor(), Slic3r::ModelVolume::get_transformation(), instances, invalidate_bounding_box(), Slic3r::Geometry::Transformation::is_left_handed(), Slic3r::Geometry::is_rotation_ninety_degrees(), Slic3r::Geometry::Transformation::reset_mirror(), Slic3r::Geometry::Transformation::reset_offset(), Slic3r::Geometry::Transformation::reset_scaling_factor(), Slic3r::Geometry::rotation_diff_z(), Slic3r::ModelInstance::set_mirror(), Slic3r::ModelVolume::set_mirror(), Slic3r::ModelVolume::set_offset(), Slic3r::ModelInstance::set_rotation(), Slic3r::ModelVolume::set_rotation(), Slic3r::ModelInstance::set_scaling_factor(), Slic3r::ModelVolume::set_scaling_factor(), Slic3r::ModelVolume::source, and Slic3r::ModelVolume::transform_this_mesh().

Referenced by bake_xy_rotation_into_meshes().

Here is the call graph for this function:

Here is the caller graph for this function:

bounding_box_approx()

const BoundingBoxf3 & Slic3r::ModelObject::bounding_box_approx

(

)

const

{
    if (! m_bounding_box_approx_valid) {
        m_bounding_box_approx_valid = true;
        BoundingBoxf3 raw_bbox = this->raw_mesh_bounding_box();
        m_bounding_box_approx.reset();
        for (const ModelInstance *i : this->instances)
            m_bounding_box_approx.merge(i->transform_bounding_box(raw_bbox));
    }
    return m_bounding_box_approx;
}

References bounding_box_approx(), instances, m_bounding_box_approx, m_bounding_box_approx_valid, and raw_mesh_bounding_box().

Referenced by bounding_box_approx().

Here is the call graph for this function:

Here is the caller graph for this function:

bounding_box_exact()

const BoundingBoxf3 & Slic3r::ModelObject::bounding_box_exact

(

)

const

{
    if (! m_bounding_box_exact_valid) {
        m_bounding_box_exact_valid = true;
        m_min_max_z_valid = true;
        m_bounding_box_exact.reset();
        for (size_t i = 0; i < this->instances.size(); ++ i)
            m_bounding_box_exact.merge(this->instance_bounding_box(i));
    }
    return m_bounding_box_exact;
}

References bounding_box_exact(), instances, m_bounding_box_exact, m_bounding_box_exact_valid, and m_min_max_z_valid.

Referenced by bounding_box_exact(), Slic3r::GUI::Plater::calib_max_vol_speed(), Slic3r::GUI::Plater::calib_retraction(), Slic3r::GUI::Plater::calib_temp(), Slic3r::GUI::ensure_belt_purge_tower(), and scale_to_fit().

Here is the call graph for this function:

Here is the caller graph for this function:

center_around_origin()

void Slic3r::ModelObject::center_around_origin

(

bool

include_modifiers = true

)

{
    // calculate the displacements needed to
    // center this object around the origin
    const BoundingBoxf3 bb = include_modifiers ? full_raw_mesh_bounding_box() : raw_mesh_bounding_box();
 
    // Shift is the vector from the center of the bounding box to the origin
    const Vec3d shift = -bb.center();
 
    this->translate(shift);
    this->origin_translation += shift;
}

References Slic3r::BoundingBox3Base< PointType >::center(), center_around_origin(), full_raw_mesh_bounding_box(), origin_translation, raw_mesh_bounding_box(), and translate().

Referenced by Slic3r::GUI::ObjectList::boolean(), center_around_origin(), Slic3r::GUI::Plater::priv::load_files(), Slic3r::GUI::ObjectList::merge(), Slic3r::GUI::Plater::priv::reload_from_disk(), Slic3r::GUI::Plater::priv::replace_volume_with_stl(), rotate(), and rotate().

Here is the call graph for this function:

Here is the caller graph for this function:

clear_instances()

void Slic3r::ModelObject::clear_instances

(

)

{
    for (ModelInstance *i : this->instances)
        delete i;
    this->instances.clear();
    this->invalidate_bounding_box();
}

References clear_instances(), instances, and invalidate_bounding_box().

Referenced by ~ModelObject(), Slic3r::_3MF_Importer::_load_model_from_file(), Slic3r::SLAPrint::apply(), clear_instances(), Slic3r::Model::duplicate_objects_grid(), and Slic3r::AMFParserContext::endDocument().

Here is the call graph for this function:

Here is the caller graph for this function:

clear_volumes()

void Slic3r::ModelObject::clear_volumes

(

)

{
    for (ModelVolume *v : this->volumes)
        delete v;
    this->volumes.clear();
    this->invalidate_bounding_box();
    // BBS: backup: do not save
    // Slic3r::save_object_mesh(*this);
}

References clear_volumes(), and invalidate_bounding_box().

Referenced by ~ModelObject(), clear_volumes(), convert_units(), make_boolean(), merge(), merge_volumes(), Slic3r::Cut::perform_with_groove(), and Slic3r::GUI::DesignCanvas::rebuild_bodies().

Here is the call graph for this function:

Here is the caller graph for this function:

clone_for_cut()

void Slic3r::ModelObject::clone_for_cut

(

ModelObject **

obj

)

{
    (*obj) = ModelObject::new_clone(*this);
    (*obj)->set_model(this->get_model());
    (*obj)->sla_support_points.clear();
    (*obj)->sla_drain_holes.clear();
    (*obj)->sla_points_status = sla::PointsStatus::NoPoints;
    (*obj)->clear_volumes();
    (*obj)->input_file.clear();
}

References ModelObject(), clone_for_cut(), get_model(), and Slic3r::sla::NoPoints.

Referenced by clone_for_cut(), Slic3r::Cut::perform_by_contour(), Slic3r::Cut::perform_with_groove(), Slic3r::Cut::perform_with_plane(), and Slic3r::process_connector_cut().

Here is the call graph for this function:

Here is the caller graph for this function:

convert_units()

void Slic3r::ModelObject::convert_units	(	ModelObjectPtrs &	new_objects,
		ConversionType	conv_type,
		std::vector< int >	volume_idxs )

{
    BOOST_LOG_TRIVIAL(trace) << "ModelObject::convert_units - start";
 
    ModelObject* new_object = new_clone(*this);
 
    float koef = conv_type == ConversionType::CONV_FROM_INCH   ? 25.4f  : conv_type == ConversionType::CONV_TO_INCH  ? 0.0393700787f  :
                 conv_type == ConversionType::CONV_FROM_METER  ? 1000.f : conv_type == ConversionType::CONV_TO_METER ? 0.001f         : 1.f;
 
    new_object->set_model(nullptr);
    new_object->sla_support_points.clear();
    new_object->sla_drain_holes.clear();
    new_object->sla_points_status = sla::PointsStatus::NoPoints;
    new_object->brim_points.clear();
    new_object->clear_volumes();
    new_object->input_file.clear();
 
    int vol_idx = 0;
    for (ModelVolume* volume : volumes) {
        if (!volume->mesh().empty()) {
            TriangleMesh mesh(volume->mesh());
 
            ModelVolume* vol = new_object->add_volume(mesh);
            vol->name = volume->name;
            vol->set_type(volume->type());
            // Don't copy the config's ID.
            vol->config.assign_config(volume->config);
            assert(vol->config.id().valid());
            assert(vol->config.id() != volume->config.id());
            vol->set_material(volume->material_id(), *volume->material());
            vol->source.input_file = volume->source.input_file;
            vol->source.object_idx = (int)new_objects.size();
            vol->source.volume_idx = vol_idx;
            vol->source.is_converted_from_inches = volume->source.is_converted_from_inches;
            vol->source.is_converted_from_meters = volume->source.is_converted_from_meters;
            vol->source.is_from_builtin_objects = volume->source.is_from_builtin_objects;
 
            vol->supported_facets.assign(volume->supported_facets);
            vol->seam_facets.assign(volume->seam_facets);
            vol->mmu_segmentation_facets.assign(volume->mmu_segmentation_facets);
            vol->fuzzy_skin_facets.assign(volume->fuzzy_skin_facets);
 
            // Perform conversion only if the target "imperial" state is different from the current one.
            // This check supports conversion of "mixed" set of volumes, each with different "imperial" state.
            if (//vol->source.is_converted_from_inches != from_imperial &&
                (volume_idxs.empty() ||
                 std::find(volume_idxs.begin(), volume_idxs.end(), vol_idx) != volume_idxs.end())) {
                vol->scale_geometry_after_creation(koef);
                vol->set_offset(Vec3d(koef, koef, koef).cwiseProduct(volume->get_offset()));
                if (conv_type == ConversionType::CONV_FROM_INCH || conv_type == ConversionType::CONV_TO_INCH)
                    vol->source.is_converted_from_inches = conv_type == ConversionType::CONV_FROM_INCH;
                if (conv_type == ConversionType::CONV_FROM_METER || conv_type == ConversionType::CONV_TO_METER)
                    vol->source.is_converted_from_meters = conv_type == ConversionType::CONV_FROM_METER;
                assert(! vol->source.is_converted_from_inches || ! vol->source.is_converted_from_meters);
            }
            else
                vol->set_offset(volume->get_offset());
        }
        vol_idx ++;
    }
    new_object->invalidate_bounding_box();
 
    new_objects.push_back(new_object);
 
    BOOST_LOG_TRIVIAL(trace) << "ModelObject::convert_units - end";
}

References ModelObject(), add_volume(), Slic3r::FacetsAnnotation::assign(), Slic3r::ModelConfig::assign_config(), brim_points, clear_volumes(), Slic3r::ModelVolume::config, Slic3r::CONV_FROM_INCH, Slic3r::CONV_FROM_METER, Slic3r::CONV_TO_INCH, Slic3r::CONV_TO_METER, convert_units(), Slic3r::ModelVolume::fuzzy_skin_facets, Slic3r::ObjectBase::id(), Slic3r::ObjectID::id, input_file, Slic3r::ModelVolume::Source::input_file, invalidate_bounding_box(), Slic3r::ModelVolume::Source::is_converted_from_inches, Slic3r::ModelVolume::Source::is_converted_from_meters, Slic3r::ModelVolume::Source::is_from_builtin_objects, mesh(), Slic3r::ModelVolume::mmu_segmentation_facets, Slic3r::ModelVolume::name, Slic3r::sla::NoPoints, Slic3r::ModelVolume::Source::object_idx, Slic3r::ModelVolume::scale_geometry_after_creation(), Slic3r::ModelVolume::seam_facets, Slic3r::ModelVolume::set_material(), set_model(), Slic3r::ModelVolume::set_offset(), Slic3r::ModelVolume::set_type(), sla_drain_holes, sla_points_status, sla_support_points, Slic3r::ModelVolume::source, Slic3r::ModelVolume::supported_facets, Slic3r::trace(), Slic3r::ObjectID::valid(), Slic3r::ModelVolume::Source::volume_idx, and volumes.

Referenced by convert_units().

Here is the call graph for this function:

Here is the caller graph for this function:

convex_hull_2d()

Polygon Slic3r::ModelObject::convex_hull_2d

(

const Transform3d &

trafo_instance

)

const

{
#if 0
    Points pts;
 
    for (const ModelVolume* v : volumes) {
        if (v->is_model_part()) {
            //BBS: use convex hull vertex instead of all
            append(pts, its_convex_hull_2d_above(v->get_convex_hull().its, (trafo_instance * v->get_matrix()).cast<float>(), 0.0f).points);
      // The next commented line instead of the previous + the rest of this #if0 section is the same as PrusaSlicer until https://github.com/prusa3d/PrusaSlicer/commit/2f7f3578d531f2d34f7732a64449606d86bb4aaa where it was parallelised.
            //append(pts, its_convex_hull_2d_above(v->mesh().its, (trafo_instance * v->get_matrix()).cast<float>(), 0.0f).points);
      // its_convex_hull_2d_above calls its_collect_mesh_projection_points_above
      // The latter multiplies each vertex by the full matrix
      // For every vector which crosses the Z plane, the intersection is used instead of any point below. Consecutive points below the Z plane are ignored.
  }
    }
    return Geometry::convex_hull(std::move(pts));
#else
    // This seems to differ from PrusaSlicer (and the old code above) in that
    // points below the Z plane aren't treated specially.
    Points pts;
    for (const ModelVolume *v : this->volumes)
        if (v->is_model_part()) {
            const Polygon& volume_hull = v->get_convex_hull_2d(trafo_instance);
      // In comparison to the old code above, get_convex_hull_2d starts with:
      // new_matrix = trafo_instance * m_transformation.get_matrix();
      // which is the same matrix multiplication as above.
      // Then checks caches, maybe calling ModelVolume::calculate_convex_hull_2d(const Geometry::Transformation &) if no hit
      // That method accesses v->get_convex_hull().its (also used above).
      // It multiplies each point by the matrix w/o translate, then calls convex_hull(pts)
      // Then translates polygon in X & Y
 
            pts.insert(pts.end(), volume_hull.points.begin(), volume_hull.points.end());
        }
 
    //std::sort(pts.begin(), pts.end(), [](const Point& a, const Point& b) { return a(0) < b(0) || (a(0) == b(0) && a(1) < b(1)); });
    //pts.erase(std::unique(pts.begin(), pts.end(), [](const Point& a, const Point& b) { return a(0) == b(0) && a(1) == b(1); }), pts.end());
    /*std::vector<Points> points;
    //points.push_back(pts);
    Polygon hull = Geometry::convex_hull(std::move(pts));
    static int irun = 0;
    BoundingBox bbox_svg;
 
    bbox_svg.merge(get_extents(pts));
    bbox_svg.merge(get_extents(hull));
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": bbox_svg.min{%1%,%2%} max{%3%,%4%}, points count %5%")% bbox_svg.min.x()% bbox_svg.min.y()% bbox_svg.max.x()% bbox_svg.max.y()%points[0].size();
    {
        std::stringstream stri;
        stri << "convex_2d_hull_" << irun << ".svg";
        SVG svg(stri.str(), bbox_svg);
 
        std::vector<Polygon> hulls;
        hulls.push_back(hull);
        svg.draw(to_polylines(points), "blue");
        svg.draw(to_polylines(hulls), "red");
        svg.Close();
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": stri %1%, Polygon.size %2%, point[0] {%3%, %4%}, point[1] {%5%, %6%}")% stri.str()% hull.size()% hull[0].x()% hull[0].y()% hull[1].x()% hull[1].y();
    }
    ++ irun;
    return hull;*/
    return Geometry::convex_hull(std::move(pts));
#endif
}

References Slic3r::append(), Slic3r::Geometry::convex_hull(), convex_hull_2d(), Slic3r::its_convex_hull_2d_above(), Slic3r::MultiPoint::points, and volumes.

Referenced by convex_hull_2d(), Slic3r::GUI::RotoptimizeJob::finalize(), Slic3r::GUI::GLCanvas3D::get_empty_cells(), Slic3r::GUI::GLCanvas3D::update_compacted_wipe_tower_clearance(), and Slic3r::GUI::GLCanvas3D::update_sequential_clearance().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_id()

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

inlineprotectedinherited

{ m_id = rhs.id(); }

References ObjectBase(), id(), and m_id.

Referenced by Slic3r::CutObjectBase::copy().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_transformation_caches()

void Slic3r::ModelObject::copy_transformation_caches ( const ModelObject & src )

inlineprivate

                                                            {
        m_bounding_box_approx             = src.m_bounding_box_approx;
        m_bounding_box_approx_valid       = src.m_bounding_box_approx_valid;
        m_bounding_box_exact              = src.m_bounding_box_exact;
        m_bounding_box_exact_valid        = src.m_bounding_box_exact_valid;
        m_min_max_z_valid                 = src.m_min_max_z_valid;
        m_raw_bounding_box                = src.m_raw_bounding_box;
        m_raw_bounding_box_valid          = src.m_raw_bounding_box_valid;
        m_raw_mesh_bounding_box           = src.m_raw_mesh_bounding_box;
        m_raw_mesh_bounding_box_valid     = src.m_raw_mesh_bounding_box_valid;
    }

References ModelObject(), m_bounding_box_approx, m_bounding_box_approx_valid, m_bounding_box_exact, m_bounding_box_exact_valid, m_min_max_z_valid, m_raw_bounding_box, m_raw_bounding_box_valid, m_raw_mesh_bounding_box, and m_raw_mesh_bounding_box_valid.

Here is the call graph for this function:

delete_connectors()

void Slic3r::ModelObject::delete_connectors

(

)

{
    for (int id = int(this->volumes.size()) - 1; id >= 0; id--) {
        if (volumes[id]->is_cut_connector())
            this->delete_volume(size_t(id));
    }
}

References delete_connectors(), delete_volume(), and volumes.

Referenced by delete_connectors().

Here is the call graph for this function:

Here is the caller graph for this function:

delete_instance()

void Slic3r::ModelObject::delete_instance

(

size_t

idx

)

{
    ModelInstancePtrs::iterator i = this->instances.begin() + idx;
    delete *i;
    this->instances.erase(i);
    this->invalidate_bounding_box();
}

References delete_instance(), instances, and invalidate_bounding_box().

Referenced by delete_instance(), delete_last_instance(), and Slic3r::GUI::ObjectList::instances_to_separated_object().

Here is the call graph for this function:

Here is the caller graph for this function:

delete_last_instance()

void Slic3r::ModelObject::delete_last_instance

(

)

{
    this->delete_instance(this->instances.size() - 1);
}

References delete_instance(), delete_last_instance(), and instances.

Referenced by Slic3r::_3MF_Importer::_load_model_from_file(), Slic3r::GUI::Plater::decrease_instances(), and delete_last_instance().

Here is the call graph for this function:

Here is the caller graph for this function:

delete_volume()

void Slic3r::ModelObject::delete_volume

(

size_t

idx

)

{
    ModelVolumePtrs::iterator i = this->volumes.begin() + idx;
    delete *i;
    this->volumes.erase(i);
 
    if (this->volumes.size() == 1)
    {
        // only one volume left
        // we need to collapse the volume transform into the instances transforms because now when selecting this volume
        // it will be seen as a single full instance ans so its volume transform may be ignored
        ModelVolume* v = this->volumes.front();
        Transform3d v_t = v->get_transformation().get_matrix();
        for (ModelInstance* inst : this->instances)
        {
            inst->set_transformation(Geometry::Transformation(inst->get_transformation().get_matrix() * v_t));
        }
        Geometry::Transformation t;
        v->set_transformation(t);
        v->set_new_unique_id();
    }
 
    this->invalidate_bounding_box();
    // BBS: backup
    Slic3r::save_object_mesh(*this);
}

References delete_volume(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::ModelVolume::get_transformation(), invalidate_bounding_box(), Slic3r::save_object_mesh(), Slic3r::ModelVolume::set_new_unique_id(), and Slic3r::ModelVolume::set_transformation().

Referenced by delete_connectors(), delete_volume(), Slic3r::GUI::GLGizmoMeshBoolean::generate_new_volume(), Slic3r::Cut::perform_with_plane(), Slic3r::GUI::Plater::priv::reload_from_disk(), and Slic3r::GUI::Plater::priv::replace_volume_with_stl().

Here is the call graph for this function:

Here is the caller graph for this function:

ensure_on_bed()

void Slic3r::ModelObject::ensure_on_bed

(

bool

allow_negative_z = false

)

{
    if (!auto_drop)
        return;
 
    double z_offset = 0.0;
 
    if (allow_negative_z) {
        if (parts_count() == 1) {
            const double min_z = this->min_z();
            const double max_z = this->max_z();
            if (min_z >= SINKING_Z_THRESHOLD || max_z < 0.0)
                z_offset = -min_z;
        }
        else {
            const double max_z = this->max_z();
            if (max_z < SINKING_MIN_Z_THRESHOLD)
                z_offset = SINKING_MIN_Z_THRESHOLD - max_z;
        }
    }
    else
        z_offset = -this->min_z();
 
    if (z_offset != 0.0)
        translate_instances(z_offset * Vec3d::UnitZ());
}

References auto_drop, ensure_on_bed(), max_z(), min_z(), parts_count(), Slic3r::SINKING_MIN_Z_THRESHOLD, Slic3r::SINKING_Z_THRESHOLD, and translate_instances().

Referenced by Slic3r::GUI::Plater::_calib_apply_belt_mode(), Slic3r::GUI::Plater::_calib_pa_pattern(), Slic3r::GUI::Plater::_calib_temp_belt_sectioned(), Slic3r::GUI::ObjectList::apply_object_instance_transfrom_to_all_volumes(), Slic3r::GUI::GLGizmoSimplify::apply_simplify(), Slic3r::GUI::Plater::priv::apply_textured_mesh_import_result(), Slic3r::GUI::ObjectList::boolean(), Slic3r::GUI::Plater::calib_temp(), anonymous_namespace{EmbossJob.cpp}::create_volume(), Slic3r::GUI::ensure_belt_purge_tower(), ensure_on_bed(), anonymous_namespace{EmbossJob.cpp}::CreateObjectJob::finalize(), Slic3r::GUI::RotoptimizeJob::finalize(), Slic3r::GUI::ObjectList::fix_through_cgal(), Slic3r::GUI::OrientJob::get_orient_mesh(), Slic3r::GUI::Plater::priv::load_files(), Slic3r::GUI::ObjectList::load_mesh_object(), Slic3r::GUI::ObjectList::merge(), Slic3r::orientation::orient(), Slic3r::GUI::Plater::priv::reload_from_disk(), Slic3r::GUI::Plater::priv::replace_volume_with_stl(), Slic3r::CLI::run(), Slic3r::GUI::Plater::set_printer_technology(), anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_two_color_cube_and_export(), Slic3r::GUI::ObjectList::smooth_mesh(), and Slic3r::GUI::ObjectList::toggle_auto_drop().

Here is the call graph for this function:

Here is the caller graph for this function:

facets_count()

size_t Slic3r::ModelObject::facets_count

(

)

const

{
    size_t num = 0;
    for (const ModelVolume *v : this->volumes)
        if (v->is_model_part())
            num += v->mesh().facets_count();
    return num;
}

References facets_count().

Referenced by facets_count(), Slic3r::MeshInspect::inspect_to_json(), Slic3r::GUI::Plater::show_object_info(), and Slic3r::GUI::ObjectList::smooth_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

full_raw_mesh_bounding_box()

BoundingBoxf3 Slic3r::ModelObject::full_raw_mesh_bounding_box

(

)

const

{
  BoundingBoxf3 bb;
  for (const ModelVolume *v : this->volumes)
    bb.merge(v->mesh().transformed_bounding_box(v->get_matrix()));
  return bb;
}

References full_raw_mesh_bounding_box(), and Slic3r::BoundingBox3Base< PointType >::merge().

Referenced by center_around_origin(), and full_raw_mesh_bounding_box().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_new_id()

ObjectID Slic3r::ObjectBase::generate_new_id ( )

inlinestaticprivateinherited

{ return ObjectID(++ s_last_id); }

References s_last_id.

Referenced by ObjectBase(), and set_new_unique_id().

Here is the caller graph for this function:

get_backup_id()

int Slic3r::ModelObject::get_backup_id

(

)

const

{ return m_model ? get_model()->get_object_backup_id(*this) : -1; }

References get_backup_id(), get_model(), and m_model.

Referenced by get_backup_id().

Here is the call graph for this function:

Here is the caller graph for this function:

get_config_value()

template<typename T>

const T * Slic3r::ModelObject::get_config_value ( const DynamicPrintConfig & global_config, const std::string & config_option )

inline

                                                                                                                            {
        if (config.has(config_option))
            return static_cast<const T*>(config.option(config_option));
        else
            return global_config.option<T>(config_option);
    }

References config, and Slic3r::ConfigBase::option().

Here is the call graph for this function:

get_export_filename()

std::string Slic3r::ModelObject::get_export_filename

(

)

const

{
    std::string ret = input_file;
 
    if (!name.empty())
    {
        if (ret.empty())
            // input_file was empty, just use name
            ret = name;
        else
        {
            // Replace file name in input_file with name, but keep the path and file extension.
            ret = (boost::filesystem::path(name).parent_path().empty()) ?
                (boost::filesystem::path(ret).parent_path() / name).make_preferred().string() : name;
        }
    }
 
    return ret;
}

References get_export_filename(), input_file, and name.

Referenced by get_export_filename().

Here is the call graph for this function:

Here is the caller graph for this function:

get_instance_max_z()

double Slic3r::ModelObject::get_instance_max_z

(

size_t

instance_idx

)

const

{
    double max_z = -DBL_MAX;
 
    const ModelInstance* inst = instances[instance_idx];
    const Transform3d mi = inst->get_matrix_no_offset();
 
    for (const ModelVolume* v : volumes) {
        if (!v->is_model_part())
            continue;
 
        const Transform3d mv = mi * v->get_matrix();
        const TriangleMesh& hull = v->get_convex_hull();
        for (const stl_triangle_vertex_indices& facet : hull.its.indices)
            for (int i = 0; i < 3; ++i)
                max_z = std::max(max_z, (mv * hull.its.vertices[facet[i]].cast<double>()).z());
    }
 
    return max_z + inst->get_offset(Z);
}

References get_instance_max_z(), Slic3r::ModelInstance::get_matrix_no_offset(), Slic3r::ModelInstance::get_offset(), instances, Slic3r::TriangleMesh::its, max_z(), volumes, and Slic3r::Z.

Referenced by get_instance_max_z(), and Slic3r::GUI::GLCanvas3D::update_compacted_wipe_tower_clearance().

Here is the call graph for this function:

Here is the caller graph for this function:

get_instance_min_z()

double Slic3r::ModelObject::get_instance_min_z

(

size_t

instance_idx

)

const

{
    double min_z = DBL_MAX;
 
    const ModelInstance* inst = instances[instance_idx];
    const Transform3d mi = inst->get_matrix_no_offset();
 
    for (const ModelVolume* v : volumes) {
        if (!v->is_model_part())
            continue;
 
        const Transform3d mv = mi * v->get_matrix();
        const TriangleMesh& hull = v->get_convex_hull();
        //BBS: in some case the convex hull is empty due to the qhull algo
        //use the original mesh instead
        //TODO: when the vertex's x/y/z are all the same, the run_qhull can not get correct result
        //we need to find another algo then
        if (hull.its.indices.size() == 0) {
            const TriangleMesh& mesh = v->mesh();
            for (const stl_triangle_vertex_indices& facet : mesh.its.indices)
                for (int i = 0; i < 3; ++i)
                    min_z = std::min(min_z, (mv * mesh.its.vertices[facet[i]].cast<double>()).z());
        }
        else {
            for (const stl_triangle_vertex_indices& facet : hull.its.indices)
                for (int i = 0; i < 3; ++i)
                    min_z = std::min(min_z, (mv * hull.its.vertices[facet[i]].cast<double>()).z());
        }
    }
 
    //BBS: add some logic to avoid wrong compute for min_z
    if (min_z == DBL_MAX)
        min_z = 0;
    return min_z + inst->get_offset(Z);
}

References get_instance_min_z(), Slic3r::ModelInstance::get_matrix_no_offset(), Slic3r::ModelInstance::get_offset(), instances, Slic3r::TriangleMesh::its, mesh(), min_z(), volumes, and Slic3r::Z.

Referenced by Slic3r::GUI::GLCanvas3D::do_mirror(), Slic3r::GUI::GLCanvas3D::do_move(), Slic3r::GUI::GLCanvas3D::do_rotate(), Slic3r::GUI::GLCanvas3D::do_scale(), and get_instance_min_z().

Here is the call graph for this function:

Here is the caller graph for this function:

get_model() [1/2]

Model * Slic3r::ModelObject::get_model ( )

inline

{ return m_model; }

References m_model, and Model.

Referenced by Slic3r::Model::add_object(), clone_for_cut(), get_backup_id(), Slic3r::GUI::ObjectList::instances_to_separated_object(), and Slic3r::GUI::ObjectList::instances_to_separated_objects().

Here is the call graph for this function:

Here is the caller graph for this function:

get_model() [2/2]

const Model * Slic3r::ModelObject::get_model ( ) const

inline

{ return m_model; }

References m_model, and Model.

Here is the call graph for this function:

get_object_stl_stats()

TriangleMeshStats Slic3r::ModelObject::get_object_stl_stats

(

)

const

{
    TriangleMeshStats full_stats;
    full_stats.volume = 0.f;
 
    // fill full_stats from all objet's meshes
    for (ModelVolume* volume : this->volumes)
    {
        const TriangleMeshStats& stats = volume->mesh().stats();
 
        // initialize full_stats (for repaired errors)
        full_stats.open_edges           += stats.open_edges;
        full_stats.repaired_errors.merge(stats.repaired_errors);
 
        // another used satistics value
        if (volume->is_model_part()) {
            Transform3d trans = instances.empty() ? volume->get_matrix() : (volume->get_matrix() * instances[0]->get_matrix());
            full_stats.volume           += stats.volume * std::fabs(trans.matrix().block(0, 0, 3, 3).determinant());
            full_stats.number_of_parts  += stats.number_of_parts;
        }
    }
 
    return full_stats;
}

References get_object_stl_stats(), instances, Slic3r::RepairedMeshErrors::merge(), Slic3r::TriangleMeshStats::number_of_parts, Slic3r::TriangleMeshStats::open_edges, Slic3r::TriangleMeshStats::repaired_errors, and Slic3r::TriangleMeshStats::volume.

Referenced by Slic3r::GUI::ObjectList::delete_from_model_and_list(), get_object_stl_stats(), get_repaired_errors_count(), and Slic3r::GUI::Plater::show_object_info().

Here is the call graph for this function:

Here is the caller graph for this function:

get_repaired_errors_count()

int Slic3r::ModelObject::get_repaired_errors_count

(

const int

vol_idx = -1

)

const

{
    if (vol_idx >= 0)
        return this->volumes[vol_idx]->get_repaired_errors_count();
 
    const RepairedMeshErrors& stats = get_object_stl_stats().repaired_errors;
 
    return  stats.degenerate_facets + stats.edges_fixed     + stats.facets_removed +
            stats.facets_reversed + stats.backwards_edges;
}

References Slic3r::RepairedMeshErrors::backwards_edges, Slic3r::RepairedMeshErrors::degenerate_facets, Slic3r::RepairedMeshErrors::edges_fixed, Slic3r::RepairedMeshErrors::facets_removed, Slic3r::RepairedMeshErrors::facets_reversed, get_object_stl_stats(), and get_repaired_errors_count().

Referenced by get_repaired_errors_count().

Here is the call graph for this function:

Here is the caller graph for this function:

has_connectors()

bool Slic3r::ModelObject::has_connectors

(

)

const

{
    assert(is_cut());
    for (const ModelVolume *v : this->volumes)
        if (v->cut_info.is_connector) return true;
 
    return false;
}

References has_connectors(), and is_cut().

Referenced by has_connectors(), and Slic3r::GUI::ObjectList::update_info_items().

Here is the call graph for this function:

Here is the caller graph for this function:

has_custom_layering()

bool Slic3r::ModelObject::has_custom_layering ( ) const

inline

        { return ! this->layer_config_ranges.empty() || ! this->layer_height_profile.empty(); }

References Slic3r::LayerHeightProfile::empty().

Referenced by Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

has_solid_mesh()

bool Slic3r::ModelObject::has_solid_mesh

(

)

const

{
    for (const ModelVolume* volume : volumes)
        if (volume->is_model_part())
            return true;
    return false;
}

References has_solid_mesh(), and volumes.

Referenced by has_solid_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

id()

ObjectID Slic3r::ObjectBase::id ( ) const

inlineinherited

{ return m_id; }

References m_id.

Referenced by Slic3r::CutObjectBase::CutObjectBase(), Slic3r::Model::Model(), Slic3r::ModelInstance::ModelInstance(), Slic3r::ModelMaterial::ModelMaterial(), Slic3r::ModelObject::ModelObject(), Slic3r::ModelObject::ModelObject(), Slic3r::ModelObject::ModelObject(), Slic3r::ModelObject::ModelObject(), Slic3r::ModelObject::ModelObject(), Slic3r::ModelVolume::ModelVolume(), Slic3r::ModelVolume::ModelVolume(), Slic3r::ModelVolume::ModelVolume(), Slic3r::ModelVolume::ModelVolume(), Slic3r::ModelVolume::ModelVolume(), Slic3r::ModelVolume::ModelVolume(), ObjectBase(), Slic3r::PrintBase::SlicingStatus::SlicingStatus(), Slic3r::PrintBase::SlicingStatus::SlicingStatus(), Slic3r::_BBS_3MF_Exporter::_add_cut_information_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_model_config_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_slice_info_config_file_to_archive(), Slic3r::GUI::Plater::priv::actualize_slicing_warnings(), Slic3r::ModelObjectStatusDB::add(), Slic3r::ModelObjectStatusDB::add_if_new(), Slic3r::Model::add_object(), Slic3r::append_and_translate(), Slic3r::SLAPrint::apply(), Slic3r::GUI::calc_distance(), Slic3r::GUI::calc_surface_offset(), Slic3r::check_model_ids_equal(), Slic3r::check_model_ids_validity(), Slic3r::GUI::GLGizmoTextureDisplacement::close_image_adjust(), Slic3r::Model::collect_reusable_objects(), Slic3r::ModelObject::convert_units(), copy_id(), Slic3r::PrintObjectStatusDB::count(), anonymous_namespace{RaycastManager.cpp}::create_key(), Slic3r::GUI::create_meshes(), anonymous_namespace{EmbossJob.cpp}::create_volume(), Slic3r::GUI::Emboss::create_volume_sources(), Slic3r::GUI::GLGizmoPainterBase::data_changed(), Slic3r::GCode::do_export(), Slic3r::GUI::PartPlate::duplicate_all_instance(), Slic3r::GUI::PartPlateList::duplicate_plate(), Slic3r::GUI::PartPlate::estimate_wipe_tower_footprint(), Slic3r::Print::export_cached_data(), Slic3r::GUI::Plater::export_stl(), Slic3r::find_volume_extents(), Slic3r::PreciseSeam::detail::fragment_location(), Slic3r::GUI::Plater::priv::generate_first_layer_bbox(), Slic3r::ModelObjectStatusDB::get(), Slic3r::Model::get_backup_path(), Slic3r::GUI::GLCanvas3D::get_empty_cells(), Slic3r::ModelInstance::get_labeled_id(), Slic3r::GUI::get_model_volume(), Slic3r::PrintObjectStatusDB::get_range(), Slic3r::GUI::get_selected_volume(), Slic3r::GUI::get_volume(), Slic3r::CutObjectBase::has_same_id(), Slic3r::UndoRedo::StackImpl::immutable_object_id_impl(), Slic3r::GUI::GLGizmoFdmSupports::init_print_instance(), Slic3r::CutObjectBase::is_equal(), Slic3r::GUI::GLGizmoSVG::is_svg_object(), Slic3r::ModelVolume::is_the_only_one_part(), Slic3r::GUI::IMSlider::IsNewPrint(), Slic3r::ModelObject::load(), load_and_construct(), Slic3r::Print::load_cached_data(), Slic3r::GLVolumeCollection::load_object_auxiliary(), Slic3r::GLVolumeCollection::load_object_volume(), Slic3r::GUI::GCodeViewer::load_shells(), Slic3r::UndoRedo::StackImpl::load_snapshot(), Slic3r::GUI::GLCanvas3D::CenterOfMass::model_markers(), Slic3r::model_property_changed(), Slic3r::model_volume_list_changed(), Slic3r::model_volume_list_copy_configs(), Slic3r::ModelConfigObject::object_id_and_timestamp_match(), Slic3r::ObjectWithTimestamp::object_id_and_timestamp_match(), Slic3r::GUI::GLGizmoEmboss::on_mouse_change_selection(), Slic3r::GUI::GLGizmoSimplify::on_render_input_window(), Slic3r::GUI::GLGizmoTextureDisplacement::open_image_adjust(), Slic3r::CutObjectBase::operator<(), Slic3r::Model::operator=(), Slic3r::ModelObject::operator=(), Slic3r::ModelObject::operator=(), Slic3r::CutObjectBase::operator==(), Slic3r::outer_inner_brim_area(), Slic3r::GUI::GLGizmoTextureDisplacement::painted_area_mm2(), Slic3r::GUI::GLGizmoCut3D::perform_cut(), anonymous_namespace{GLGizmoEmboss.cpp}::prepare_volumes_to_slice(), Slic3r::GUI::GLGizmoTextureDisplacement::preview_part(), Slic3r::GCode::process_layer(), Slic3r::GUI::NotificationManager::push_slicing_warning_notification(), Slic3r::GUI::GLGizmoTextureDisplacement::queue_preview_job(), Slic3r::GUI::queue_texture_displacement_debug(), Slic3r::GUI::GLGizmoEmboss::re_emboss(), Slic3r::GUI::GLGizmoTextureDisplacement::rebuild_other_paint_overlay(), Slic3r::GUI::GLGizmoTextureDisplacement::rebuild_painted_colors(), Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::_BBS_Backup_Manager::remove_backup(), Slic3r::Model::remove_backup_path_if_exist(), Slic3r::GUI::GLGizmoTextureDisplacement::render_image_adjust_window(), Slic3r::CLI::run(), Slic3r::GUI::GLCanvas3D::LayersEditing::select_object(), Slic3r::ModelMaterial::serialize(), Slic3r::Model::set_backup_path(), Slic3r::GUI::GLGizmoBrimEars::set_brim_data(), Slic3r::GUI::PartPlate::set_hover_id(), Slic3r::GUI::GLGizmoEmboss::set_volume_by_selection(), Slic3r::GUI::GLGizmoSVG::set_volume_by_selection(), Slic3r::sla_instances(), Slic3r::slices_to_regions(), Slic3r::ModelObject::split(), anonymous_namespace{EmbossJob.cpp}::start_create_volume_on_surface_job(), anonymous_namespace{SurfaceDrag.cpp}::start_dragging(), Slic3r::GUI::Emboss::start_update_volume(), Slic3r::UndoRedo::StackImpl::take_snapshot(), Slic3r::GUI::texture_displacement_bake_volume(), Slic3r::GUI::GLGizmoPainterBase::update_contours(), anonymous_namespace{EmbossJob.cpp}::update_name_in_list(), Slic3r::GUI::ObjectList::update_name_in_model(), Slic3r::GUI::update_object_cut_id(), Slic3r::GUI::GLGizmoTextureDisplacement::v2_recommendation(), Slic3r::verify_update_print_object_regions(), wipe_tower_instance_id, and wipe_tower_object_id.

instance_bounding_box() [1/2]

BoundingBoxf3 Slic3r::ModelObject::instance_bounding_box	(	const ModelInstance &	instance,
		bool	dont_translate = false ) const

{
    BoundingBoxf3 bb;
    const Transform3d inst_matrix = dont_translate ?
        instance.get_transformation().get_matrix_no_offset() :
        instance.get_transformation().get_matrix();
 
    for (ModelVolume *v : this->volumes) {
        if (v->is_model_part())
            bb.merge(v->mesh().transformed_bounding_box(inst_matrix * v->get_matrix()));
    }
    return bb;
}

References Slic3r::Geometry::Transformation::get_matrix(), Slic3r::Geometry::Transformation::get_matrix_no_offset(), Slic3r::ModelInstance::get_transformation(), instance_bounding_box(), and Slic3r::BoundingBox3Base< PointType >::merge().

Here is the call graph for this function:

instance_bounding_box() [2/2]

BoundingBoxf3 Slic3r::ModelObject::instance_bounding_box	(	size_t	instance_idx,
		bool	dont_translate = false ) const

                                                                                               {
    return instance_bounding_box(*this->instances[instance_idx], dont_translate);
}

References instance_bounding_box(), and instances.

Referenced by Slic3r::GUI::Plater::_calib_temp_belt_sectioned(), anonymous_namespace{EmbossJob.cpp}::create_volume(), Slic3r::distribute_modifiers_from_object(), Slic3r::GUI::GLCanvas3D::do_mirror(), Slic3r::GUI::GLCanvas3D::do_rotate(), Slic3r::GUI::GLCanvas3D::do_scale(), Slic3r::GUI::ensure_belt_purge_tower(), Slic3r::MeshInspect::inspect_to_json(), instance_bounding_box(), instance_bounding_box(), Slic3r::GUI::ObjectList::load_generic_subobject(), Slic3r::GUI::ObjectList::load_modifier(), Slic3r::GUI::CommonGizmosDataObjects::ObjectClipper::on_update(), Slic3r::GUI::Selection::paste_volumes_from_clipboard(), Slic3r::Cut::perform_with_plane(), and Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

instance_convex_hull_bounding_box() [1/2]

BoundingBoxf3 Slic3r::ModelObject::instance_convex_hull_bounding_box	(	const ModelInstance *	instance,
		bool	dont_translate = false ) const

{
    BoundingBoxf3 bb;
    const Transform3d inst_matrix = dont_translate ? instance->get_transformation().get_matrix_no_offset() :
                                                     instance->get_transformation().get_matrix();
    for (ModelVolume* v : this->volumes) {
        if (v->is_model_part())
            bb.merge(v->get_convex_hull().transformed_bounding_box(inst_matrix * v->get_matrix()));
    }
    return bb;
}

References Slic3r::Geometry::Transformation::get_matrix(), Slic3r::Geometry::Transformation::get_matrix_no_offset(), Slic3r::ModelInstance::get_transformation(), instance_convex_hull_bounding_box(), and Slic3r::BoundingBox3Base< PointType >::merge().

Here is the call graph for this function:

instance_convex_hull_bounding_box() [2/2]

BoundingBoxf3 Slic3r::ModelObject::instance_convex_hull_bounding_box	(	size_t	instance_idx,
		bool	dont_translate = false ) const

{
    return instance_convex_hull_bounding_box(this->instances[instance_idx], dont_translate);
}

References instance_convex_hull_bounding_box(), and instances.

Referenced by Slic3r::GUI::PartPlate::estimate_wipe_tower_footprint(), instance_convex_hull_bounding_box(), instance_convex_hull_bounding_box(), Slic3r::GUI::Selection::paste_objects_from_clipboard(), and Slic3r::GUI::Plater::show_object_info().

Here is the call graph for this function:

Here is the caller graph for this function:

invalidate_bounding_box()

void Slic3r::ModelObject::invalidate_bounding_box ( )

inline

                                   {
        m_bounding_box_approx_valid     = false;
        m_bounding_box_exact_valid      = false;
        m_min_max_z_valid               = false;
        m_raw_bounding_box_valid        = false;
        m_raw_mesh_bounding_box_valid   = false;
    }

References m_bounding_box_approx_valid, m_bounding_box_exact_valid, m_min_max_z_valid, m_raw_bounding_box_valid, and m_raw_mesh_bounding_box_valid.

Referenced by Slic3r::GUI::Plater::_calib_apply_belt_mode(), Slic3r::GUI::Plater::_calib_temp_belt_sectioned(), add_instance(), add_instance(), Slic3r::Model::add_object(), Slic3r::Model::add_object(), add_volume(), add_volume(), add_volume(), Slic3r::GUI::GLGizmoSimplify::apply_simplify(), bake_xy_rotation_into_meshes(), clear_instances(), clear_volumes(), convert_units(), delete_instance(), delete_volume(), Slic3r::GUI::GLCanvas3D::do_mirror(), Slic3r::GUI::GLCanvas3D::do_move(), Slic3r::GUI::GLCanvas3D::do_rotate(), Slic3r::GUI::GLCanvas3D::do_scale(), Slic3r::duplicate(), Slic3r::GUI::ensure_belt_purge_tower(), Slic3r::fix_model_with_cgal_gui(), Slic3r::GUI::OrientJob::get_orient_mesh(), Slic3r::GUI::ObjectList::load_mesh_object(), merge_volumes(), mirror(), rotate(), rotate(), scale(), scale_mesh_after_creation(), Slic3r::GUI::ObjectList::smooth_mesh(), and translate_instance().

Here is the caller graph for this function:

invalidate_cut()

void Slic3r::ModelObject::invalidate_cut

(

)

{
    this->cut_id.invalidate();
    for (ModelVolume *volume : this->volumes)
        volume->invalidate_cut_info();
}

References cut_id, and invalidate_cut().

Referenced by invalidate_cut().

Here is the call graph for this function:

Here is the caller graph for this function:

is_cut()

bool Slic3r::ModelObject::is_cut ( ) const

inline

{ return cut_id.id().valid(); }

References cut_id.

Referenced by Slic3r::_BBS_3MF_Exporter::_add_cut_information_file_to_archive(), Slic3r::GUI::can_add_volumes_to_object(), Slic3r::GUI::ObjectList::delete_all_connectors_for_object(), Slic3r::GUI::ObjectList::delete_from_model_and_list(), Slic3r::GUI::ObjectList::delete_from_model_and_list(), Slic3r::GUI::Plater::priv::delete_object_from_model(), Slic3r::GUI::GLGizmoAlignment::get_selected_part_volumes(), has_connectors(), Slic3r::GUI::ObjectList::invalidate_cut_info_for_object(), Slic3r::GUI::ObjectList::part_selection_changed(), Slic3r::GUI::synchronize_model_after_cut(), and Slic3r::GUI::ObjectList::update_info_items().

Here is the caller graph for this function:

is_fdm_support_painted()

bool Slic3r::ModelObject::is_fdm_support_painted

(

)

const

{
    return std::any_of(this->volumes.cbegin(), this->volumes.cend(), [](const ModelVolume *mv) { return mv->is_fdm_support_painted(); });
}

References is_fdm_support_painted().

Referenced by is_fdm_support_painted().

Here is the call graph for this function:

Here is the caller graph for this function:

is_fuzzy_skin_painted()

bool Slic3r::ModelObject::is_fuzzy_skin_painted

(

)

const

{
    return std::any_of(this->volumes.cbegin(), this->volumes.cend(), [](const ModelVolume *mv) { return mv->is_fuzzy_skin_painted(); });
}

References is_fuzzy_skin_painted().

Referenced by is_fuzzy_skin_painted(), Slic3r::PrintObject::is_fuzzy_skin_painted(), and Slic3r::GUI::GLGizmoFuzzySkin::on_render_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

is_mm_painted()

bool Slic3r::ModelObject::is_mm_painted

(

)

const

{
    return std::any_of(this->volumes.cbegin(), this->volumes.cend(), [](const ModelVolume *mv) { return mv->is_mm_painted(); });
}

References is_mm_painted().

Referenced by is_mm_painted(), and Slic3r::PrintObject::is_mm_painted().

Here is the call graph for this function:

Here is the caller graph for this function:

is_multiparts()

bool Slic3r::ModelObject::is_multiparts ( ) const

inline

{ return volumes.size() > 1; }

References volumes.

Referenced by Slic3r::GUI::Selection::Clipboard::is_sla_compliant().

Here is the caller graph for this function:

is_seam_painted()

bool Slic3r::ModelObject::is_seam_painted

(

)

const

{
    return std::any_of(this->volumes.cbegin(), this->volumes.cend(), [](const ModelVolume *mv) { return mv->is_seam_painted(); });
}

References is_seam_painted().

Referenced by is_seam_painted().

Here is the call graph for this function:

Here is the caller graph for this function:

load()

template<class Archive>

void Slic3r::ModelObject::load ( Archive & ar )

inlineprivate

                                                   {
        ar(cereal::base_class<ObjectBase>(this));
        Internal::StaticSerializationWrapper<ModelConfigObject> config_wrapper(config);
        Internal::StaticSerializationWrapper<LayerHeightProfile> layer_heigth_profile_wrapper(layer_height_profile);
        // BBS: add backup, check modify
        SaveObjectGaurd gaurd(*this);
        ar(name, module_name, input_file, instances, volumes, config_wrapper, layer_config_ranges, layer_heigth_profile_wrapper,
            sla_support_points, sla_points_status, sla_drain_holes, printable, auto_drop, origin_translation, brim_points,
            m_bounding_box_approx, m_bounding_box_approx_valid, 
            m_bounding_box_exact, m_bounding_box_exact_valid, m_min_max_z_valid,
            m_raw_bounding_box, m_raw_bounding_box_valid, m_raw_mesh_bounding_box, m_raw_mesh_bounding_box_valid,
            cut_connectors, cut_id);
        std::vector<ObjectID> volume_ids2;
        std::transform(volumes.begin(), volumes.end(), std::back_inserter(volume_ids2), std::mem_fn(&ObjectBase::id));
        if (volume_ids != volume_ids2)
            Slic3r::save_object_mesh(*this);
        volume_ids.clear();
    }

References auto_drop, brim_points, config, cut_connectors, cut_id, Slic3r::ObjectBase::id(), input_file, instances, layer_config_ranges, layer_height_profile, m_bounding_box_approx, m_bounding_box_approx_valid, m_bounding_box_exact, m_bounding_box_exact_valid, m_min_max_z_valid, m_raw_bounding_box, m_raw_bounding_box_valid, m_raw_mesh_bounding_box, m_raw_mesh_bounding_box_valid, module_name, name, origin_translation, printable, Slic3r::save_object_mesh(), sla_drain_holes, sla_points_status, sla_support_points, volume_ids, and volumes.

Here is the call graph for this function:

load_and_construct()

template<class Archive>

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

inlinestaticprivateinherited

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

References id().

Here is the call graph for this function:

make_boolean()

bool Slic3r::ModelObject::make_boolean	(	ModelObject *	cut_object,
		const std::string &	boolean_opts )

{
    // merge meshes into single volume instead of multi-parts object
    if (this->volumes.size() != 1) {
        // we can't merge meshes if there's not just one volume
        return false;
    }
    std::vector<TriangleMesh> new_meshes;
 
    const TriangleMesh &cut_mesh = cut_object->mesh();
    MeshBoolean::mcut::make_boolean(this->mesh(), cut_mesh, new_meshes, boolean_opts);
 
    this->clear_volumes();
    int i = 1;
    for (TriangleMesh &mesh : new_meshes) {
        ModelVolume *vol = this->add_volume(mesh);
        vol->name        = this->name + "_" + std::to_string(i++);
    }
    return true;
}

References ModelObject(), add_volume(), clear_volumes(), Slic3r::cut_mesh(), Slic3r::MeshBoolean::mcut::make_boolean(), make_boolean(), mesh(), name, and Slic3r::ModelVolume::name.

Referenced by make_boolean().

Here is the call graph for this function:

Here is the caller graph for this function:

materials_count()

size_t Slic3r::ModelObject::materials_count

(

)

const

{
    std::set<t_model_material_id> material_ids;
    for (const ModelVolume *v : this->volumes)
        material_ids.insert(v->material_id());
    return material_ids.size();
}

References materials_count().

Referenced by materials_count().

Here is the call graph for this function:

Here is the caller graph for this function:

max_z()

double Slic3r::ModelObject::max_z

(

)

const

{
    const_cast<ModelObject*>(this)->update_min_max_z();
    return m_bounding_box_exact.max.z();
}

References ModelObject(), m_bounding_box_exact, max_z(), and update_min_max_z().

Referenced by ensure_on_bed(), get_instance_max_z(), max_z(), Slic3r::GUI::GLCanvas3D::LayersEditing::select_object(), and Slic3r::Print::validate().

Here is the call graph for this function:

Here is the caller graph for this function:

merge()

void Slic3r::ModelObject::merge

(

)

{
    if (this->volumes.size() == 1) {
        // We can't merge meshes if there's just one volume
        return;
    }
 
    TriangleMesh mesh;
 
    for (ModelVolume* volume : volumes)
        if (!volume->mesh().empty())
            mesh.merge(volume->mesh());
 
    this->clear_volumes();
    ModelVolume* vol = this->add_volume(mesh);
 
    if (!vol)
        return;
}

References add_volume(), clear_volumes(), merge(), mesh(), and volumes.

Referenced by Slic3r::GUI::ObjectList::merge(), and merge().

Here is the call graph for this function:

Here is the caller graph for this function:

merge_volumes()

ModelObjectPtrs Slic3r::ModelObject::merge_volumes

(

std::vector< int > &

vol_indeces

)

{
    ModelObjectPtrs res;
    if (this->volumes.size() == 1) {
        // We can't merge meshes if there's just one volume
        return res;
    }
 
    ModelObject* upper = ModelObject::new_clone(*this);
    upper->set_model(nullptr);
    upper->sla_support_points.clear();
    upper->sla_drain_holes.clear();
    upper->sla_points_status = sla::PointsStatus::NoPoints;
    upper->brim_points.clear();
    upper->clear_volumes();
    upper->input_file.clear();
 
#if 1
    TriangleMesh mesh;
    for (int i : vol_indeces) {
        auto volume = volumes[i];
        if (!volume->mesh().empty()) {
            const auto volume_matrix = volume->get_matrix();
            TriangleMesh mesh_(volume->mesh());
            mesh_.transform(volume_matrix, true);
            volume->reset_mesh();
 
            mesh.merge(mesh_);
        }
    }
#else
    std::vector<TriangleMesh> meshes;
    for (int i : vol_indeces) {
        auto volume = volumes[i];
        if (!volume->mesh().empty())
            meshes.emplace_back(volume->mesh());
    }
    TriangleMesh mesh = MeshBoolean::cgal::merge(meshes);
#endif
 
    ModelVolume* vol = upper->add_volume(mesh);
    for (int i = 0; i < volumes.size();i++) {
        if (std::find(vol_indeces.begin(), vol_indeces.end(), i) != vol_indeces.end()) {
            vol->name = volumes[i]->name + "_merged";
            vol->config.assign_config(volumes[i]->config);
        }
        else
            upper->add_volume(*volumes[i]);
    }
    upper->invalidate_bounding_box();
    res.push_back(upper);
    return res;
}

References ModelObject(), add_volume(), Slic3r::ModelConfig::assign_config(), brim_points, clear_volumes(), config, Slic3r::ModelVolume::config, input_file, invalidate_bounding_box(), Slic3r::MeshBoolean::cgal::merge(), merge_volumes(), mesh(), Slic3r::ModelVolume::name, Slic3r::sla::NoPoints, set_model(), sla_drain_holes, sla_points_status, sla_support_points, Slic3r::TriangleMesh::transform(), and volumes.

Referenced by merge_volumes().

Here is the call graph for this function:

Here is the caller graph for this function:

mesh()

TriangleMesh Slic3r::ModelObject::mesh

(

)

const

{
    TriangleMesh mesh;
    TriangleMesh raw_mesh = this->raw_mesh();
    for (const ModelInstance *i : this->instances) {
        TriangleMesh m = raw_mesh;
        i->transform_mesh(&m);
        mesh.merge(m);
    }
    return mesh;
}

References instances, mesh(), and raw_mesh().

Referenced by add_volume(), add_volume(), add_volume(), convert_units(), get_instance_min_z(), make_boolean(), merge(), merge_volumes(), mesh(), Slic3r::orientation::orient(), Slic3r::orientation::orient(), print_info(), raw_mesh(), Slic3r::GUI::Plater::priv::reload_from_disk(), split(), Slic3r::store_drc(), Slic3r::store_obj(), and Slic3r::store_stl().

Here is the call graph for this function:

Here is the caller graph for this function:

min_z()

double Slic3r::ModelObject::min_z

(

)

const

{
    const_cast<ModelObject*>(this)->update_min_max_z();
    return m_bounding_box_exact.min.z();
}

References ModelObject(), m_bounding_box_exact, min_z(), and update_min_max_z().

Referenced by ensure_on_bed(), get_instance_min_z(), Slic3r::GUI::ObjectList::list_manipulation(), min_z(), Slic3r::GUI::ObjectList::OnEditingStarted(), Slic3r::GUI::Plater::priv::reload_from_disk(), and Slic3r::GUI::Plater::priv::replace_volume_with_stl().

Here is the call graph for this function:

Here is the caller graph for this function:

mirror()

void Slic3r::ModelObject::mirror

(

Axis

axis

)

{
    for (ModelVolume *v : this->volumes) {
        v->mirror(axis);
    }
    this->invalidate_bounding_box();
}

References invalidate_bounding_box(), and mirror().

Referenced by add_instance(), and mirror().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=() [1/2]

ModelObject & Slic3r::ModelObject::operator= ( const ModelObject & rhs )

inlineprivate

                                                   {
      this->assign_copy(rhs);
      m_model = rhs.m_model;
      assert(this->id().valid());
        assert(this->config.id().valid());
        assert(this->layer_height_profile.id().valid());
        assert(this->id() != this->config.id());
        assert(this->id() != this->layer_height_profile.id());
      assert(this->id() == rhs.id());
        assert(this->config.id() == rhs.config.id());
        assert(this->layer_height_profile.id() == rhs.layer_height_profile.id());
      return *this;
    }

References ModelObject(), config, Slic3r::ObjectBase::id(), layer_height_profile, m_model, and Slic3r::ObjectID::valid().

Here is the call graph for this function:

operator=() [2/2]

ModelObject & Slic3r::ModelObject::operator= ( ModelObject && rhs )

inlineprivate

                                              {
      this->assign_copy(std::move(rhs));
      m_model = rhs.m_model;
      assert(this->id().valid());
        assert(this->config.id().valid());
        assert(this->layer_height_profile.id().valid());
        assert(this->id() != this->config.id());
        assert(this->id() != this->layer_height_profile.id());
      assert(this->id() == rhs.id());
        assert(this->config.id() == rhs.config.id());
        assert(this->layer_height_profile.id() == rhs.layer_height_profile.id());
      return *this;
    }

References ModelObject(), Slic3r::ObjectBase::id(), Slic3r::ObjectID::id, m_model, and Slic3r::ObjectID::valid().

Here is the call graph for this function:

parts_count()

size_t Slic3r::ModelObject::parts_count

(

)

const

{
    size_t num = 0;
    for (const ModelVolume* v : this->volumes)
        if (v->is_model_part())
            ++num;
    return num;
}

References parts_count().

Referenced by ensure_on_bed(), and parts_count().

Here is the call graph for this function:

Here is the caller graph for this function:

print_info()

void Slic3r::ModelObject::print_info

(

)

const

{
    using namespace std;
    cout << fixed;
    boost::nowide::cout << "[" << boost::filesystem::path(this->input_file).filename().string() << "]" << endl;
 
    TriangleMesh mesh = this->raw_mesh();
    BoundingBoxf3 bb = mesh.bounding_box();
    Vec3d size = bb.size();
    cout << "size_x = " << size(0) << endl;
    cout << "size_y = " << size(1) << endl;
    cout << "size_z = " << size(2) << endl;
    cout << "min_x = " << bb.min(0) << endl;
    cout << "min_y = " << bb.min(1) << endl;
    cout << "min_z = " << bb.min(2) << endl;
    cout << "max_x = " << bb.max(0) << endl;
    cout << "max_y = " << bb.max(1) << endl;
    cout << "max_z = " << bb.max(2) << endl;
    cout << "number_of_facets = " << mesh.facets_count() << endl;
 
    cout << "manifold = "   << (mesh.stats().manifold() ? "yes" : "no") << endl;
    if (! mesh.stats().manifold())
        cout << "open_edges = " << mesh.stats().open_edges << endl;
 
    if (mesh.stats().repaired()) {
        const RepairedMeshErrors& stats = mesh.stats().repaired_errors;
        if (stats.degenerate_facets > 0)
            cout << "degenerate_facets = "  << stats.degenerate_facets << endl;
        if (stats.edges_fixed > 0)
            cout << "edges_fixed = "        << stats.edges_fixed       << endl;
        if (stats.facets_removed > 0)
            cout << "facets_removed = "     << stats.facets_removed    << endl;
        if (stats.facets_reversed > 0)
            cout << "facets_reversed = "    << stats.facets_reversed   << endl;
        if (stats.backwards_edges > 0)
            cout << "backwards_edges = "    << stats.backwards_edges   << endl;
    }
    cout << "number_of_parts =  " << mesh.stats().number_of_parts << endl;
    cout << "volume = "           << mesh.volume()                << endl;
}

References Slic3r::RepairedMeshErrors::backwards_edges, Slic3r::RepairedMeshErrors::degenerate_facets, Slic3r::RepairedMeshErrors::edges_fixed, Slic3r::RepairedMeshErrors::facets_removed, Slic3r::RepairedMeshErrors::facets_reversed, input_file, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, mesh(), Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, print_info(), raw_mesh(), and Slic3r::BoundingBox3Base< PointType >::size().

Referenced by print_info().

Here is the call graph for this function:

Here is the caller graph for this function:

raw_bounding_box()

const BoundingBoxf3 & Slic3r::ModelObject::raw_bounding_box

(

)

const

{
    if (! m_raw_bounding_box_valid) {
        m_raw_bounding_box_valid = true;
        m_raw_bounding_box.reset();
        if (this->instances.empty())
            throw Slic3r::InvalidArgument("Can't call raw_bounding_box() with no instances");
 
        const Transform3d inst_matrix = this->instances.front()->get_transformation().get_matrix_no_offset();
        for (const ModelVolume *v : this->volumes)
            if (v->is_model_part())
                m_raw_bounding_box.merge(v->mesh().transformed_bounding_box(inst_matrix * v->get_matrix()));
    }
  return m_raw_bounding_box;
}

References instances, m_raw_bounding_box, m_raw_bounding_box_valid, and raw_bounding_box().

Referenced by raw_bounding_box().

Here is the call graph for this function:

Here is the caller graph for this function:

raw_indexed_triangle_set()

indexed_triangle_set Slic3r::ModelObject::raw_indexed_triangle_set

(

)

const

{
    size_t num_vertices = 0;
    size_t num_faces    = 0;
    for (const ModelVolume *v : this->volumes)
        if (v->is_model_part()) {
            num_vertices += v->mesh().its.vertices.size();
            num_faces    += v->mesh().its.indices.size();
        }
    indexed_triangle_set out;
    out.vertices.reserve(num_vertices);
    out.indices.reserve(num_faces);
    for (const ModelVolume *v : this->volumes)
        if (v->is_model_part()) {
            size_t i = out.vertices.size();
            size_t j = out.indices.size();
            append(out.vertices, v->mesh().its.vertices);
            append(out.indices,  v->mesh().its.indices);
            // Orca: Point the volume's triangles at its own vertices, which follow those of the volumes before it.
            for (size_t k = j; k < out.indices.size(); ++ k)
                out.indices[k] += stl_triangle_vertex_indices::Constant(int(i));
            const Transform3d& m = v->get_matrix();
            for (; i < out.vertices.size(); ++ i)
                out.vertices[i] = (m * out.vertices[i].cast<double>()).cast<float>().eval();
            if (v->is_left_handed()) {
                for (; j < out.indices.size(); ++ j)
                    std::swap(out.indices[j][0], out.indices[j][1]);
            }
        }
    return out;
}

References Slic3r::append(), and raw_indexed_triangle_set().

Referenced by raw_indexed_triangle_set().

Here is the call graph for this function:

Here is the caller graph for this function:

raw_mesh()

TriangleMesh Slic3r::ModelObject::raw_mesh

(

)

const

{
    TriangleMesh mesh;
    for (const ModelVolume *v : this->volumes)
        if (v->is_model_part())
        {
            TriangleMesh vol_mesh(v->mesh());
            vol_mesh.transform(v->get_matrix());
            mesh.merge(vol_mesh);
        }
    return mesh;
}

References mesh(), raw_mesh(), and Slic3r::TriangleMesh::transform().

Referenced by Slic3r::sla::RotfinderBoilerplate< MAX_ITER >::get_mesh_to_rotate(), mesh(), print_info(), and raw_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

raw_mesh_bounding_box()

const BoundingBoxf3 & Slic3r::ModelObject::raw_mesh_bounding_box

(

)

const

{
    if (! m_raw_mesh_bounding_box_valid) {
        m_raw_mesh_bounding_box_valid = true;
        m_raw_mesh_bounding_box.reset();
        for (const ModelVolume *v : this->volumes)
            if (v->is_model_part())
                m_raw_mesh_bounding_box.merge(v->mesh().transformed_bounding_box(v->get_matrix()));
    }
    return m_raw_mesh_bounding_box;
}

References m_raw_mesh_bounding_box, m_raw_mesh_bounding_box_valid, and raw_mesh_bounding_box().

Referenced by bounding_box_approx(), center_around_origin(), Slic3r::MeshInspect::inspect_to_json(), and raw_mesh_bounding_box().

Here is the call graph for this function:

Here is the caller graph for this function:

rotate() [1/2]

void Slic3r::ModelObject::rotate	(	double	angle,
		Axis	axis )

{
    for (ModelVolume *v : this->volumes) {
        v->rotate(angle, axis);
    }
    center_around_origin();
    this->invalidate_bounding_box();
}

References Slic3r::angle(), center_around_origin(), invalidate_bounding_box(), and rotate().

Referenced by Slic3r::orientation::orient(), rotate(), and rotate().

Here is the call graph for this function:

Here is the caller graph for this function:

rotate() [2/2]

void Slic3r::ModelObject::rotate	(	double	angle,
		const Vec3d &	axis )

{
    for (ModelVolume *v : this->volumes) {
        v->rotate(angle, axis);
    }
 
    //BBS update assemble transformation when modify volume rotation
    for (int i = 0; i < instances.size(); i++) {
        instances[i]->rotate_assemble(-angle, axis);
    }
 
    center_around_origin();
    this->invalidate_bounding_box();
}

References Slic3r::angle(), center_around_origin(), instances, invalidate_bounding_box(), and rotate().

Here is the call graph for this function:

save()

template<class Archive>

void Slic3r::ModelObject::save ( Archive & ar ) const

inlineprivate

                                                         {
        ar(cereal::base_class<ObjectBase>(this));
        Internal::StaticSerializationWrapper<ModelConfigObject const> config_wrapper(config);
        Internal::StaticSerializationWrapper<LayerHeightProfile const> layer_heigth_profile_wrapper(layer_height_profile);
        ar(name, module_name, input_file, instances, volumes, config_wrapper, layer_config_ranges, layer_heigth_profile_wrapper,
            sla_support_points, sla_points_status, sla_drain_holes, printable, auto_drop, origin_translation, brim_points,
            m_bounding_box_approx, m_bounding_box_approx_valid, 
            m_bounding_box_exact, m_bounding_box_exact_valid, m_min_max_z_valid,
            m_raw_bounding_box, m_raw_bounding_box_valid, m_raw_mesh_bounding_box, m_raw_mesh_bounding_box_valid,
            cut_connectors, cut_id);
    }

References auto_drop, brim_points, config, cut_connectors, cut_id, input_file, instances, layer_config_ranges, layer_height_profile, m_bounding_box_approx, m_bounding_box_approx_valid, m_bounding_box_exact, m_bounding_box_exact_valid, m_min_max_z_valid, m_raw_bounding_box, m_raw_bounding_box_valid, m_raw_mesh_bounding_box, m_raw_mesh_bounding_box_valid, module_name, name, origin_translation, printable, sla_drain_holes, sla_points_status, sla_support_points, and volumes.

scale() [1/3]

void Slic3r::ModelObject::scale ( const double s )

inline

{ this->scale(Vec3d(s, s, s)); }

References scale().

Referenced by scale().

Here is the call graph for this function:

Here is the caller graph for this function:

scale() [2/3]

void Slic3r::ModelObject::scale

(

const Vec3d &

versor

)

{
    for (ModelVolume *v : this->volumes) {
        v->scale(versor);
    }
    this->invalidate_bounding_box();
}

References invalidate_bounding_box(), and scale().

Referenced by Slic3r::GUI::Plater::_calib_temp_belt_sectioned(), Slic3r::GUI::Plater::calib_max_vol_speed(), scale(), and scale_mesh_after_creation().

Here is the call graph for this function:

Here is the caller graph for this function:

scale() [3/3]

void Slic3r::ModelObject::scale ( double x, double y, double z )

inline

{ this->scale(Vec3d(x, y, z)); }

References scale().

Referenced by scale().

Here is the call graph for this function:

Here is the caller graph for this function:

scale_mesh_after_creation()

void Slic3r::ModelObject::scale_mesh_after_creation

(

const float

scale

)

{
    for (ModelVolume *v : this->volumes) {
        v->scale_geometry_after_creation(scale);
        v->set_offset(Vec3d(scale, scale, scale).cwiseProduct(v->get_offset()));
    }
    this->invalidate_bounding_box();
}

References invalidate_bounding_box(), scale(), and scale_mesh_after_creation().

Referenced by scale_mesh_after_creation().

Here is the call graph for this function:

Here is the caller graph for this function:

scale_to_fit()

void Slic3r::ModelObject::scale_to_fit

(

const Vec3d &

size

)

Scale the current ModelObject to fit by altering the scaling factor of ModelInstances. It operates on the total size by duplicating the object according to all the instances.

Parameters

size	Sizef3 the size vector

{
    Vec3d orig_size = this->bounding_box_exact().size();
    double factor = std::min(
        size.x() / orig_size.x(),
        std::min(
            size.y() / orig_size.y(),
            size.z() / orig_size.z()
        )
    );
    this->scale(factor);
}

References bounding_box_exact(), scale(), and scale_to_fit().

Referenced by scale_to_fit().

Here is the call graph for this function:

Here is the caller graph for this function:

serialize()

template<class Archive>

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

inlineprivateinherited

{ ar(m_id); }

References m_id.

set_invalid_id()

void Slic3r::ObjectBase::set_invalid_id ( )

inlineprotectedinherited

{ m_id = 0; }

References m_id.

Referenced by Slic3r::CutObjectBase::invalidate().

Here is the caller graph for this function:

set_model()

void Slic3r::ModelObject::set_model ( Model * model )

inlineprivate

{ m_model = model; }

References m_model, and Model.

Referenced by Slic3r::Model::add_object(), convert_units(), and merge_volumes().

Here is the call graph for this function:

Here is the caller graph for this function:

set_new_unique_id()

void Slic3r::ModelObject::set_new_unique_id ( )

inlineprivate

                           {
        ObjectBase::set_new_unique_id();
        this->config.set_new_unique_id();
        this->layer_height_profile.set_new_unique_id();
    }

References Slic3r::ObjectBase::set_new_unique_id().

Referenced by assign_new_unique_ids_recursive().

Here is the call graph for this function:

Here is the caller graph for this function:

sort_volumes()

void Slic3r::ModelObject::sort_volumes

(

bool

full_sort

)

{
    // sort volumes inside the object to order "Model Part, Negative Volume, Modifier, Support Blocker and Support Enforcer. "
    if (full_sort)
        std::stable_sort(volumes.begin(), volumes.end(), [](ModelVolume* vl, ModelVolume* vr) {
            // Special handling for Precise Seam modifiers: group-based sorting with user order preservation
            if (vl->is_precise_seam() && vr->is_precise_seam()) {
                // Strong (center/left/right) always before weak (enforced/blocked/neutral)
                bool vl_strong = vl->is_precise_seam_strong();
                bool vr_strong = vr->is_precise_seam_strong();
                if (vl_strong != vr_strong)
                    return vl_strong; // strong < weak → strong group appears first
 
                // Within same group (both strong or both weak): preserve current order
                // stable_sort will maintain relative positions when comparator returns false
                return false;
            }
 
            // For non-Precise-Seam or mixed types: use standard enum-based ordering
            return vl->type() < vr->type();
        });
    // sort have to controll "place" of the support blockers/enforcers. But one of the model parts have to be on the first place.
    else
        std::stable_sort(volumes.begin(), volumes.end(), [](ModelVolume* vl, ModelVolume* vr) {
            ModelVolumeType vl_type = vl->type() > ModelVolumeType::PARAMETER_MODIFIER ? vl->type() : ModelVolumeType::PARAMETER_MODIFIER;
            ModelVolumeType vr_type = vr->type() > ModelVolumeType::PARAMETER_MODIFIER ? vr->type() : ModelVolumeType::PARAMETER_MODIFIER;
 
            // Apply same Precise Seam grouping logic for partial sort
            if (vl->is_precise_seam() && vr->is_precise_seam()) {
                bool vl_strong = vl->is_precise_seam_strong();
                bool vr_strong = vr->is_precise_seam_strong();
                if (vl_strong != vr_strong)
                    return vl_strong;
                return false; // preserve order within same group
            }
 
            return vl_type < vr_type;
        });
}

References sort_volumes(), Slic3r::ModelVolume::type(), and volumes.

Referenced by Slic3r::GUI::cut_model(), Slic3r::GUI::ObjectList::load_mesh_object(), Slic3r::GUI::ObjectList::merge(), Slic3r::GUI::Plater::priv::reload_from_disk(), Slic3r::GUI::ObjectList::reorder_volumes_and_get_selection(), Slic3r::GUI::Plater::priv::replace_volume_with_stl(), and sort_volumes().

Here is the call graph for this function:

Here is the caller graph for this function:

split()

void Slic3r::ModelObject::split	(	ModelObjectPtrs *	new_objects,
		bool	remap_paint )

{
    std::vector<TriangleMesh> all_meshes;
    std::vector<Transform3d> all_transfos;
    std::vector<std::pair<int, int>> volume_mesh_counts;
    all_meshes.reserve(this->volumes.size() * 5);
    bool is_multi_volume_object = (this->volumes.size() > 1);
    std::optional<TriangleSelector::SavedPainting> saved_painting;
 
    for (int volume_idx = 0; volume_idx < this->volumes.size(); volume_idx++) {
        ModelVolume* volume = this->volumes[volume_idx];
        if (volume->type() != ModelVolumeType::MODEL_PART)
            continue;
 
        // splited volume should not be text object 
        if (volume->text_configuration.has_value())
            volume->text_configuration.reset();
 
        if (!is_multi_volume_object) {
            if (remap_paint) {
                // Save painting so we could restore them after the mesh split
                saved_painting = volume->save_painting();
            }
            //BBS: not multi volume object, then split mesh.
            std::vector<TriangleMesh> volume_meshes = volume->mesh().split();
            int mesh_count = 0;
            for (TriangleMesh& mesh : volume_meshes) {
                if (mesh.facets_count() < 3)
                    continue;
 
                all_meshes.emplace_back(std::move(mesh));
                all_transfos.emplace_back(volume->get_matrix());
                mesh_count++;
            }
            volume_mesh_counts.push_back({ volume_idx, mesh_count });
        } else {
            //BBS: multi volume object, then only split to volume
            if (volume->mesh().facets_count() >= 3) {
                all_meshes.emplace_back(std::move(volume->mesh()));
                all_transfos.emplace_back(volume->get_matrix());
                volume_mesh_counts.push_back({ volume_idx, 1 });
            }
        }
    }
 
    FaceDetector face_detector(all_meshes, all_transfos, 1.0);
    face_detector.detect_exterior_face();
 
    int volume_mesh_begin = 0;
    for (int i = 0; i < volume_mesh_counts.size(); i++) {
        std::pair<int, int> mesh_info = volume_mesh_counts[i];
        ModelVolume* volume = this->volumes[mesh_info.first];
 
        std::vector<TriangleMesh> meshes;
        for (int mesh_idx = volume_mesh_begin; mesh_idx < volume_mesh_begin + mesh_info.second; mesh_idx++) {
            meshes.emplace_back(std::move(all_meshes[mesh_idx]));
        }
        volume_mesh_begin += mesh_info.second;
 
        size_t counter = 1;
        for (TriangleMesh& mesh : meshes) {
            // FIXME: crashes if not satisfied
            if (mesh.facets_count() < 3)
                continue;
 
            // XXX: this seems to be the only real usage of m_model, maybe refactor this so that it's not needed?
            ModelObject* new_object = m_model->add_object();
            //BBS: refine the config logic
            //use object as basic, and add volume's config
            if (meshes.size() == 1) {
                new_object->name = volume->name;
                // Don't copy the config's ID.
                //new_object->config.assign_config(this->config.size() > 0 ? this->config : volume->config);
            }
            else {
                new_object->name = this->name + (meshes.size() > 1 ? "_" + std::to_string(counter++) : "");
                // Don't copy the config's ID.
                //new_object->config.assign_config(this->config);
            }
            new_object->config.assign_config(this->config);
            new_object->config.apply(volume->config, true);
 
            assert(new_object->config.id().valid());
            assert(new_object->config.id() != this->config.id());
            new_object->instances.reserve(this->instances.size());
            for (const ModelInstance* model_instance : this->instances)
                new_object->add_instance(*model_instance);
            ModelVolume* new_vol = new_object->add_volume(*volume, std::move(mesh));
 
            if (is_multi_volume_object) {
                // BBS: volume geometry not changed, so we can keep the paint facets
#define COPY_FACETS(f)                 if (new_vol->f.timestamp() == volume->f.timestamp())                     new_vol->f.reset(); /* BBS: let next assign take effect */                 new_vol->f.assign(volume->f)
 
                COPY_FACETS(supported_facets);
                COPY_FACETS(seam_facets);
                COPY_FACETS(mmu_segmentation_facets);
                COPY_FACETS(fuzzy_skin_facets);
            } else if (saved_painting) {
                // Geometry changed, attempt to remap them to the new mesh
                new_vol->restore_painting(saved_painting);
            }
 
            // BBS: clear volume's config, as we already set them into object
            new_vol->config.reset();
 
            for (ModelInstance* model_instance : new_object->instances)
            {
                const Vec3d shift = model_instance->get_transformation().get_matrix_no_offset() * new_vol->get_offset();
                model_instance->set_offset(model_instance->get_offset() + shift);
 
                //BBS: add assemble_view related logic
                Geometry::Transformation instance_transformation_copy = model_instance->get_transformation();
                instance_transformation_copy.set_offset(-new_vol->get_offset());
                const Transform3d &assemble_matrix = model_instance->get_assemble_transformation().get_matrix();
                const Transform3d &instance_inverse_matrix = instance_transformation_copy.get_matrix().inverse();
                Transform3d new_instance_inverse_matrix = instance_inverse_matrix * model_instance->get_transformation().get_matrix_no_offset().inverse();
                Transform3d new_assemble_transform      = assemble_matrix * new_instance_inverse_matrix;
                model_instance->set_assemble_from_transform(new_assemble_transform);
                model_instance->set_offset_to_assembly(new_vol->get_offset());
            }
 
            new_vol->set_offset(Vec3d::Zero());
            // reset the source to disable reload from disk
            new_vol->source = ModelVolume::Source();
            new_objects->emplace_back(new_object);
        }
    }
}

References ModelObject(), add_instance(), add_volume(), Slic3r::ModelConfig::apply(), Slic3r::ModelConfig::assign_config(), config, Slic3r::ModelVolume::config, COPY_FACETS, Slic3r::FaceDetector::detect_exterior_face(), Slic3r::TriangleMesh::facets_count(), Slic3r::ModelInstance::get_assemble_transformation(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::ModelVolume::get_matrix(), Slic3r::Geometry::Transformation::get_matrix_no_offset(), Slic3r::ModelInstance::get_offset(), Slic3r::ModelVolume::get_offset(), Slic3r::ModelInstance::get_transformation(), Slic3r::ObjectBase::id(), Slic3r::ObjectID::id, instances, m_model, mesh(), Slic3r::ModelVolume::mesh(), Slic3r::MODEL_PART, name, Slic3r::ModelVolume::name, Slic3r::ModelConfig::reset(), Slic3r::ModelVolume::restore_painting(), Slic3r::ModelVolume::save_painting(), Slic3r::ModelInstance::set_assemble_from_transform(), Slic3r::Geometry::Transformation::set_offset(), Slic3r::ModelInstance::set_offset(), Slic3r::ModelVolume::set_offset(), Slic3r::ModelInstance::set_offset_to_assembly(), Slic3r::ModelVolume::source, split(), Slic3r::TriangleMesh::split(), Slic3r::ModelVolume::text_configuration, Slic3r::ModelVolume::type(), and Slic3r::ObjectID::valid().

Referenced by split(), and Slic3r::GUI::Plater::priv::split_object().

Here is the call graph for this function:

Here is the caller graph for this function:

timestamp()

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

inlinevirtualinherited

Reimplemented in Slic3r::ModelConfigObject, and Slic3r::ObjectWithTimestamp.

{ return 0; }

translate() [1/2]

void Slic3r::ModelObject::translate ( const Vec3d & vector )

inline

{ this->translate(vector(0), vector(1), vector(2)); }

References translate().

Referenced by Slic3r::GUI::ObjectList::apply_object_instance_transfrom_to_all_volumes(), center_around_origin(), construct_assemble_list(), Slic3r::GUI::ObjectList::load_mesh_object(), translate(), and translate().

Here is the call graph for this function:

Here is the caller graph for this function:

translate() [2/2]

void Slic3r::ModelObject::translate	(	double	x,
		double	y,
		double	z )

{
    for (ModelVolume *v : this->volumes) {
        v->translate(x, y, z);
    }
 
    if (m_bounding_box_approx_valid)
        m_bounding_box_approx.translate(x, y, z);
    if (m_bounding_box_exact_valid)
        m_bounding_box_exact.translate(x, y, z);
}

References m_bounding_box_approx, m_bounding_box_approx_valid, m_bounding_box_exact, m_bounding_box_exact_valid, and translate().

Here is the call graph for this function:

translate_instance()

void Slic3r::ModelObject::translate_instance	(	size_t	instance_idx,
		const Vec3d &	vector )

{
    assert(instance_idx < instances.size());
    ModelInstance* i = instances[instance_idx];
    i->set_offset(i->get_offset() + vector);
    invalidate_bounding_box();
}

References Slic3r::ModelInstance::get_offset(), instances, invalidate_bounding_box(), Slic3r::ModelInstance::set_offset(), and translate_instance().

Referenced by Slic3r::GUI::GLCanvas3D::do_mirror(), Slic3r::GUI::GLCanvas3D::do_move(), Slic3r::GUI::GLCanvas3D::do_rotate(), Slic3r::GUI::GLCanvas3D::do_scale(), translate_instance(), and translate_instances().

Here is the call graph for this function:

Here is the caller graph for this function:

translate_instances()

void Slic3r::ModelObject::translate_instances

(

const Vec3d &

vector

)

{
    for (size_t i = 0; i < instances.size(); ++i) {
        translate_instance(i, vector);
    }
}

References instances, translate_instance(), and translate_instances().

Referenced by Slic3r::GUI::ObjectList::apply_object_instance_transfrom_to_all_volumes(), Slic3r::GUI::ObjectList::boolean(), Slic3r::GUI::Plater::calib_temp(), Slic3r::GUI::ensure_belt_purge_tower(), ensure_on_bed(), Slic3r::GUI::ObjectList::list_manipulation(), Slic3r::GUI::ObjectList::merge(), Slic3r::GUI::ObjectList::OnEditingStarted(), Slic3r::CLI::run(), and translate_instances().

Here is the call graph for this function:

Here is the caller graph for this function:

update_instances_print_volume_state()

unsigned int Slic3r::ModelObject::update_instances_print_volume_state ( const BuildVolume & build_volume )

private

{
    unsigned int num_printable = 0;
    //BBS: add logs for build_volume
    //const BoundingBoxf3& print_volume = build_volume.bounding_volume();
    //BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", print_volume {%1%, %2%, %3%} to {%4%, %5%, %6%}")    //    %print_volume.min.x() %print_volume.min.y() %print_volume.min.z()%print_volume.max.x() %print_volume.max.y() %print_volume.max.z();
    for (ModelInstance* model_instance : this->instances) {
        if (model_instance->update_print_volume_state(build_volume) == ModelInstancePVS_Inside) {
            //BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", object %1%'s instance inside print volum")%this->name;
            ++num_printable;
        }
    }
    //BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", found %1% printable instances")%num_printable;
    return num_printable;
}

References instances, Slic3r::ModelInstancePVS_Inside, and update_instances_print_volume_state().

Referenced by update_instances_print_volume_state().

Here is the call graph for this function:

Here is the caller graph for this function:

update_min_max_z()

void Slic3r::ModelObject::update_min_max_z ( )

private

{
    assert(! this->instances.empty());
    if (! m_min_max_z_valid && ! this->instances.empty()) {
        m_min_max_z_valid = true;
        const Transform3d mat_instance = this->instances.front()->get_transformation().get_matrix();
        double global_min_z = std::numeric_limits<double>::max();
        double global_max_z = - std::numeric_limits<double>::max();
        for (const ModelVolume *v : this->volumes)
            if (v->is_model_part()) {
                const Transform3d m = mat_instance * v->get_matrix();
                const Vec3d  row_z   = m.linear().row(2).cast<double>();
                const double shift_z = m.translation().z();
                double this_min_z = std::numeric_limits<double>::max();
                double this_max_z = - std::numeric_limits<double>::max();
                for (const Vec3f &p : v->mesh().its.vertices) {
                    double z = row_z.dot(p.cast<double>());
                    this_min_z = std::min(this_min_z, z);
                    this_max_z = std::max(this_max_z, z);
                }
                this_min_z += shift_z;
                this_max_z += shift_z;
                global_min_z = std::min(global_min_z, this_min_z);
                global_max_z = std::max(global_max_z, this_max_z);
            }
        m_bounding_box_exact.min.z() = global_min_z;
        m_bounding_box_exact.max.z() = global_max_z;
    }
}

References instances, m_bounding_box_exact, m_min_max_z_valid, and update_min_max_z().

Referenced by max_z(), min_z(), and update_min_max_z().

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Symbol Documentation

cereal::access

friend class cereal::access

friend

References cereal::access.

Referenced by cereal::access.

Model

friend class Model

friend

References Model.

Referenced by ModelObject(), get_model(), get_model(), Model, and set_model().

Print

friend class Print

friend

References Print.

Referenced by Print.

SLAPrint

friend class SLAPrint

friend

References SLAPrint.

Referenced by SLAPrint.

UndoRedo::StackImpl

friend class UndoRedo::StackImpl

friend

Member Data Documentation

auto_drop

bool Slic3r::ModelObject::auto_drop { true }

{ true };

Referenced by Slic3r::_BBS_3MF_Exporter::_add_model_config_file_to_archive(), Slic3r::GUI::GLCanvas3D::do_mirror(), Slic3r::GUI::GLCanvas3D::do_move(), Slic3r::GUI::GLCanvas3D::do_rotate(), Slic3r::GUI::GLCanvas3D::do_scale(), Slic3r::GUI::GLCanvas3D::ensure_on_bed(), Slic3r::GUI::Selection::ensure_on_bed(), ensure_on_bed(), Slic3r::GUI::Selection::get_auto_drop(), load(), Slic3r::GUI::ObjectList::merge(), save(), Slic3r::GUI::Plater::priv::split_object(), and Slic3r::GUI::ObjectList::toggle_auto_drop().

brim_points

BrimPoints Slic3r::ModelObject::brim_points

Referenced by convert_units(), Slic3r::GUI::Selection::copy_to_clipboard(), load(), Slic3r::GUI::ObjectList::merge(), merge_volumes(), Slic3r::model_brim_points_data_changed(), Slic3r::GUI::GLGizmoBrimEars::reload_cache(), save(), and Slic3r::GUI::GLGizmoBrimEars::update_model_object().

config

ModelConfigObject Slic3r::ModelObject::config

Referenced by ModelObject(), ModelObject(), ModelObject(), ModelObject(), Slic3r::_3MF_Exporter::_add_model_config_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_model_config_file_to_archive(), Slic3r::GUI::Plater::_calib_apply_belt_mode(), Slic3r::GUI::Plater::_calib_pa_pattern(), Slic3r::GUI::Plater::_calib_temp_belt_sectioned(), Slic3r::_3MF_Importer::_load_model_from_file(), Slic3r::Model::add_object(), Slic3r::Model::add_object(), Slic3r::Model::add_object(), Slic3r::GUI::ObjectDataViewModel::AddObject(), Slic3r::GUI::MenuFactory::append_menu_items_flush_options(), Slic3r::SLAPrint::apply(), Slic3r::GUI::Plater::priv::apply_textured_mesh_import_result(), Slic3r::GUI::ObjectList::boolean(), Slic3r::GUI::Plater::calib_max_vol_speed(), Slic3r::GUI::Plater::calib_retraction(), Slic3r::GUI::Plater::calib_temp(), Slic3r::check_model_ids_equal(), Slic3r::check_model_ids_validity(), Slic3r::GUI::PartPlate::check_single_extruder_mixed_filament_risk(), construct_assemble_list(), Slic3r::GUI::Selection::copy_to_clipboard(), Slic3r::GUI::ObjectList::delete_from_model_and_list(), Slic3r::GUI::ensure_belt_purge_tower(), anonymous_namespace{EmbossJob.cpp}::CreateObjectJob::finalize(), Slic3r::sla::find_least_supports_rotation(), Slic3r::GUI::GLGizmoBrimEars::get_config_options(), get_config_value(), Slic3r::GUI::ObjectList::get_default_layer_config(), Slic3r::GUI::PartPlate::get_extruders(), Slic3r::GUI::PartPlate::get_extruders_under_cli(), Slic3r::GUI::is_belt_purge_prism(), load(), Slic3r::GUI::Plater::priv::load_files(), Slic3r::GUI::ObjectList::load_generic_subobject(), Slic3r::GUI::ObjectList::load_mesh_object(), Slic3r::GUI::ObjectList::load_modifier(), Slic3r::GUI::ObjectList::merge(), merge_or_add_object(), merge_volumes(), Slic3r::model_has_advanced_features(), Slic3r::GUI::ObjectList::object_config_options_changed(), Slic3r::GUI::GLGizmoBrimEars::on_render_input_window(), Slic3r::GUI::GLGizmoFuzzySkin::on_render_input_window(), operator=(), Slic3r::Print::process(), Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp}::project_used_filament_slots(), Slic3r::region_config_from_model_volume(), Slic3r::GUI::GLGizmoMmuSegmentation::remap_filament_assignments(), Slic3r::remap_model_filament_slots(), Slic3r::CLI::run(), save(), anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_two_color_cube_and_export(), split(), Slic3r::GUI::ObjectTableSettings::update_settings_list(), and Slic3r::SLAPrint::validate().

cut_connectors

CutConnectors Slic3r::ModelObject::cut_connectors

Referenced by Slic3r::GUI::GLGizmoCut3D::apply_connectors_in_model(), Slic3r::GUI::GLGizmoCut3D::apply_cut_connectors(), Slic3r::GUI::GLGizmoCut3D::check_and_update_connectors_state(), load(), Slic3r::GUI::GLGizmoCut3D::perform_cut(), Slic3r::GUI::GLGizmoCut3D::put_connectors_on_cut_plane(), Slic3r::GUI::GLGizmoCut3D::render_connectors(), save(), and Slic3r::GUI::GLGizmoCut3D::update_raycasters_for_picking_transform().

cut_id

CutObjectBase Slic3r::ModelObject::cut_id

Referenced by Slic3r::_BBS_3MF_Exporter::_add_cut_information_file_to_archive(), Slic3r::GUI::GLGizmoCut3D::apply_cut_connectors(), Slic3r::GUI::ObjectList::delete_all_connectors_for_object(), invalidate_cut(), Slic3r::GUI::ObjectList::invalidate_cut_info_for_object(), is_cut(), load(), Slic3r::GUI::ObjectList::part_selection_changed(), Slic3r::GUI::GLGizmoCut3D::perform_cut(), save(), and Slic3r::GUI::synchronize_model_after_cut().

input_file

std::string Slic3r::ModelObject::input_file

Referenced by Slic3r::Model::add_object(), Slic3r::Model::add_object(), Slic3r::SLAPrint::apply(), Slic3r::GUI::Plater::priv::can_reload_from_disk(), convert_units(), Slic3r::GUI::Selection::copy_to_clipboard(), get_export_filename(), load(), Slic3r::load_svg(), merge_volumes(), Slic3r::Step::mesh(), Slic3r::GUI::Selection::paste_volumes_from_clipboard(), print_info(), Slic3r::Model::read_from_archive(), Slic3r::Model::read_from_step(), Slic3r::GUI::Plater::priv::reload_from_disk(), save(), and Slic3r::PrintBase::update_object_placeholders().

instances

ModelInstancePtrs Slic3r::ModelObject::instances

Referenced by Slic3r::GUI::GLGizmoCut3D::PartSelection::PartSelection(), Slic3r::_3MF_Exporter::_add_model_config_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_model_config_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_slice_info_config_file_to_archive(), Slic3r::GUI::Plater::_calib_apply_belt_mode(), Slic3r::GUI::Plater::_calib_pa_pattern(), Slic3r::GUI::Plater::_calib_temp_belt_sectioned(), Slic3r::_3MF_Importer::_handle_end_model(), Slic3r::_BBS_3MF_Importer::_handle_end_model(), Slic3r::_3MF_Importer::_load_model_from_file(), Slic3r::GUI::GLCanvas3D::_set_warning_notification(), add_instance(), add_instance(), Slic3r::GUI::GLGizmoCut3D::PartSelection::add_object(), Slic3r::GUI::MenuFactory::append_menu_item_printable(), Slic3r::GUI::MenuFactory::append_menu_item_set_printable(), Slic3r::SLAPrint::apply(), Slic3r::GUI::ObjectList::apply_object_instance_transfrom_to_all_volumes(), Slic3r::GUI::GLGizmoTextureDisplacement::apply_projection_frame(), bake_xy_rotation_into_meshes(), Slic3r::GUI::ObjectList::boolean(), bounding_box_approx(), bounding_box_exact(), Slic3r::GUI::PartPlate::calc_imex_ghosts(), Slic3r::GUI::GLGizmoTextureDisplacement::capture_view_projection(), Slic3r::GUI::GLGizmoCut3D::check_and_update_connectors_state(), Slic3r::check_model_ids_equal(), Slic3r::check_model_ids_validity(), clear_instances(), Slic3r::GUI::Plater::combine_mesh_fff(), Slic3r::GUI::PartPlate::contain_any_instance_totally(), Slic3r::GUI::Selection::copy_to_clipboard(), anonymous_namespace{EmbossJob.cpp}::create_volume(), Slic3r::GUI::Plater::decrease_instances(), delete_instance(), delete_last_instance(), Slic3r::distribute_modifiers_from_object(), Slic3r::GUI::GLCanvas3D::do_mirror(), Slic3r::GUI::GLCanvas3D::do_move(), Slic3r::GUI::GLCanvas3D::do_rotate(), Slic3r::GUI::GLCanvas3D::do_scale(), Slic3r::duplicate(), Slic3r::GUI::PartPlate::duplicate_all_instance(), Slic3r::duplicate_objects(), Slic3r::GUI::PartPlateList::duplicate_plate(), Slic3r::GUI::ensure_belt_purge_tower(), Slic3r::GUI::PartPlate::estimate_wipe_tower_footprint(), Slic3r::GUI::PartPlate::exclusion_volume_preview_cache_key(), Slic3r::GUI::Plater::export_stl(), anonymous_namespace{EmbossJob.cpp}::CreateObjectJob::finalize(), Slic3r::GUI::FillBedJob::finalize(), Slic3r::GUI::RotoptimizeJob::finalize(), Slic3r::GUI::Plater::find_new_position(), Slic3r::get_arrange_poly(), Slic3r::get_arrange_polys(), Slic3r::GUI::GLGizmoCut3D::get_cut_matrix(), Slic3r::GUI::GLCanvas3D::get_empty_cells(), get_instance_max_z(), get_instance_min_z(), Slic3r::sla::RotfinderBoilerplate< MAX_ITER >::get_mesh_to_rotate(), get_object_stl_stats(), Slic3r::GUI::GLGizmoAlignment::get_parent_box(), Slic3r::GUI::GLGizmoPainterBase::get_projected_height_range(), Slic3r::GUI::GLGizmoAlignment::get_selected_objects_info(), Slic3r::GUI::Selection::get_volume_idxs_from_plate(), Slic3r::GUI::GLGizmoBrimEars::gizmo_event(), Slic3r::GUI::GLGizmoMeshBoolean::gizmo_event(), Slic3r::GUI::GLGizmoPainterBase::gizmo_event(), Slic3r::GUI::Plater::increase_instances(), Slic3r::GUI::GLGizmoFdmSupports::init_print_instance(), Slic3r::MeshInspect::inspect_to_json(), instance_bounding_box(), instance_convex_hull_bounding_box(), Slic3r::GUI::ObjectList::instances_to_separated_object(), Slic3r::GUI::GLGizmoFlatten::is_plane_update_necessary(), load(), Slic3r::GUI::Plater::priv::load_files(), Slic3r::GUI::ObjectList::load_mesh_object(), Slic3r::GUI::Plater::priv::load_model_objects(), Slic3r::GUI::GLCanvas3D::load_object(), Slic3r::GLVolumeCollection::load_object_auxiliary(), Slic3r::GLVolumeCollection::load_object_volume(), Slic3r::GUI::GCodeViewer::load_shells(), Slic3r::GUI::PartPlate::max_broad_phase_intersecting_object_height(), Slic3r::GUI::ObjectList::merge(), mesh(), Slic3r::GUI::GLGizmoPainterBase::mesh_trafo_matrices(), Slic3r::model_has_advanced_features(), Slic3r::GUI::GLGizmoTextureDisplacement::on_mouse_adjust_texture(), Slic3r::GUI::GLGizmoMeshBoolean::on_render(), Slic3r::GUI::Selection::paste_objects_from_clipboard(), Slic3r::GUI::Selection::paste_volumes_from_clipboard(), Slic3r::Cut::perform_by_contour(), Slic3r::Cut::perform_with_groove(), Slic3r::Cut::perform_with_plane(), Slic3r::GUI::FillBedJob::prepare(), Slic3r::GUI::ArrangeJob::prepare_all(), Slic3r::GUI::ArrangeJob::prepare_partplate(), Slic3r::GUI::OrientJob::prepare_partplate(), Slic3r::GUI::ArrangeJob::prepare_selected(), Slic3r::GUI::OrientJob::prepare_selection(), Slic3r::print_objects_from_model_object(), Slic3r::Print::process(), Slic3r::GUI::CalibUtils::process_and_store_3mf(), Slic3r::GUI::GLGizmoCut3D::process_selection_rectangle(), Slic3r::GUI::Plater::priv::process_validation_warning(), Slic3r::GUI::NotificationManager::push_slicing_serious_warning_notification(), Slic3r::GUI::NotificationManager::push_validate_error_notification(), Slic3r::GUI::GLGizmoCut3D::put_connectors_on_cut_plane(), raw_bounding_box(), Slic3r::GUI::DesignCanvas::rebuild_bodies(), Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::GUI::GLCanvas3D::Labels::render(), Slic3r::GUI::GLGizmoTextureDisplacement::render_adjust_texture_gizmo(), Slic3r::GUI::GLGizmoCut3D::render_connectors(), Slic3r::GUI::GLGizmoPainterBase::render_cursor_height_range(), Slic3r::GUI::CommonGizmosDataObjects::InstancesHider::render_cut(), Slic3r::GUI::CommonGizmosDataObjects::ObjectClipper::render_cut(), Slic3r::GUI::GLGizmoTextureDisplacement::render_island_overlay(), Slic3r::GUI::GLGizmoTextureDisplacement::render_paint_overlay(), Slic3r::GUI::GLGizmoTextureDisplacement::render_painted_colors(), Slic3r::GUI::GLGizmoTextureDisplacement::render_painter_gizmo(), Slic3r::GUI::GLGizmoTextureDisplacement::render_preview_mesh(), Slic3r::GUI::GLGizmoTextureDisplacement::render_seam_overlay(), Slic3r::GUI::GLGizmoTextureDisplacement::render_shaded_preview_mesh(), Slic3r::GUI::GLGizmoTextureDisplacement::render_subdivide_preview(), Slic3r::GUI::GLGizmoPainterBase::render_triangles(), Slic3r::GUI::GLGizmoTextureDisplacement::render_uvcheck_mesh(), Slic3r::GUI::GLGizmoTextureDisplacement::render_wireframe_overlay(), rotate(), Slic3r::CLI::run(), save(), Slic3r::GUI::GLGizmoTextureDisplacement::seam_edge_at(), Slic3r::GUI::GLGizmoTextureDisplacement::seam_vertex_at(), Slic3r::GUI::GLGizmoFdmSupports::select_facets_by_angle(), Slic3r::GUI::GLGizmoTextureDisplacement::select_visible_faces(), Slic3r::GUI::Plater::set_number_of_copies(), Slic3r::GUI::CommonGizmosDataObjects::ObjectClipper::set_position_by_ratio(), Slic3r::GUI::Selection::set_printable(), Slic3r::GUI::Plater::show_object_info(), Slic3r::sla_instances(), Slic3r::SLAPrint::sla_trafo(), split(), Slic3r::texture_displacement_volume_to_world(), Slic3r::GUI::ObjectList::toggle_printable_state(), translate_instance(), translate_instances(), Slic3r::GUI::GLGizmoCut3D::unproject_on_cut_plane(), Slic3r::GUI::GLCanvas3D::update_compacted_wipe_tower_clearance(), Slic3r::GUI::PartPlate::update_exclusion_volume_preview_models(), Slic3r::GUI::PartPlate::update_imex_ghost_transforms(), Slic3r::GUI::GLCanvas3D::update_instance_printable_state_for_object(), update_instances_print_volume_state(), update_min_max_z(), Slic3r::PrintBase::update_object_placeholders(), Slic3r::GUI::GLGizmoFlatten::update_planes(), Slic3r::GUI::GLGizmoCut3D::update_raycasters_for_picking_transform(), Slic3r::GUI::GLCanvas3D::update_sequential_clearance(), Slic3r::Print::update_shrinkage_compensation(), and Slic3r::GUI::Selection::update_type().

layer_config_ranges

t_layer_config_ranges Slic3r::ModelObject::layer_config_ranges

Referenced by Slic3r::_3MF_Importer::_load_model_from_file(), Slic3r::GUI::ObjectList::add_layer_item(), Slic3r::GUI::ObjectList::add_layer_range_after_current(), Slic3r::adjust_layer_height_profile(), Slic3r::Print::append_model_object_extruders(), Slic3r::Print::apply(), Slic3r::GUI::ObjectList::can_add_new_range_after_current(), construct_assemble_list(), Slic3r::GUI::ObjectList::copy_layers_to_clipboard(), Slic3r::GUI::Selection::copy_to_clipboard(), Slic3r::GUI::ObjectList::del_layer_from_object(), Slic3r::GUI::ObjectList::del_layer_range(), Slic3r::GUI::ObjectList::del_layers_from_object(), Slic3r::GUI::ObjectList::edit_layer_range(), Slic3r::GUI::ObjectList::edit_layer_range(), Slic3r::GUI::PartPlate::get_extruders(), Slic3r::GUI::PartPlate::get_extruders_under_cli(), Slic3r::GUI::ObjectList::layers_editing(), load(), Slic3r::GUI::Tab::load_current_preset(), Slic3r::GUI::ObjectList::merge(), Slic3r::GUI::ObjectList::paste_layers_into_list(), Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp}::project_used_filament_slots(), Slic3r::CLI::run(), save(), anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_two_color_cube_and_export(), and Slic3r::Print::update_shrinkage_compensation().

layer_height_profile

LayerHeightProfile Slic3r::ModelObject::layer_height_profile

Referenced by ModelObject(), ModelObject(), ModelObject(), ModelObject(), Slic3r::_3MF_Importer::_load_model_from_file(), assign_new_unique_ids_recursive(), Slic3r::GUI::Selection::copy_to_clipboard(), Slic3r::GUI::ObjectList::delete_from_model_and_list(), Slic3r::GUI::ObjectList::delete_from_model_and_list(), load(), operator=(), Slic3r::Print::process(), save(), and Slic3r::GUI::ObjectList::update_info_items().

m_bounding_box_approx

BoundingBoxf3 Slic3r::ModelObject::m_bounding_box_approx

mutableprivate

Referenced by bounding_box_approx(), copy_transformation_caches(), load(), save(), and translate().

m_bounding_box_approx_valid

bool Slic3r::ModelObject::m_bounding_box_approx_valid { false }

mutableprivate

{ false };

Referenced by bounding_box_approx(), copy_transformation_caches(), invalidate_bounding_box(), load(), save(), and translate().

m_bounding_box_exact

BoundingBoxf3 Slic3r::ModelObject::m_bounding_box_exact

mutableprivate

Referenced by bounding_box_exact(), copy_transformation_caches(), load(), max_z(), min_z(), save(), translate(), and update_min_max_z().

m_bounding_box_exact_valid

bool Slic3r::ModelObject::m_bounding_box_exact_valid { false }

mutableprivate

{ false };

Referenced by bounding_box_exact(), copy_transformation_caches(), invalidate_bounding_box(), load(), save(), and translate().

m_id

ObjectID Slic3r::ObjectBase::m_id

privateinherited

Referenced by ObjectBase(), ObjectBase(), ObjectBase(), copy_id(), id(), serialize(), set_invalid_id(), and set_new_unique_id().

m_min_max_z_valid

bool Slic3r::ModelObject::m_min_max_z_valid { false }

mutableprivate

{ false };

Referenced by bounding_box_exact(), copy_transformation_caches(), invalidate_bounding_box(), load(), save(), and update_min_max_z().

m_model

Model* Slic3r::ModelObject::m_model { nullptr }

private

{ nullptr };

Referenced by ModelObject(), ModelObject(), get_backup_id(), get_model(), get_model(), operator=(), operator=(), set_model(), and split().

m_raw_bounding_box

BoundingBoxf3 Slic3r::ModelObject::m_raw_bounding_box

mutableprivate

Referenced by copy_transformation_caches(), load(), raw_bounding_box(), and save().

m_raw_bounding_box_valid

bool Slic3r::ModelObject::m_raw_bounding_box_valid { false }

mutableprivate

{ false };

Referenced by copy_transformation_caches(), invalidate_bounding_box(), load(), raw_bounding_box(), and save().

m_raw_mesh_bounding_box

BoundingBoxf3 Slic3r::ModelObject::m_raw_mesh_bounding_box

mutableprivate

Referenced by copy_transformation_caches(), load(), raw_mesh_bounding_box(), and save().

m_raw_mesh_bounding_box_valid

bool Slic3r::ModelObject::m_raw_mesh_bounding_box_valid { false }

mutableprivate

{ false };

Referenced by copy_transformation_caches(), invalidate_bounding_box(), load(), raw_mesh_bounding_box(), and save().

module_name

std::string Slic3r::ModelObject::module_name

Referenced by Slic3r::_BBS_3MF_Exporter::_add_model_config_file_to_archive(), load(), and save().

name

std::string Slic3r::ModelObject::name

Referenced by Slic3r::_3MF_Exporter::_add_model_config_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_model_config_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_slice_info_config_file_to_archive(), Slic3r::GUI::Plater::_calib_pa_pattern(), Slic3r::GUI::Plater::_calib_temp_belt_sectioned(), Slic3r::_3MF_Importer::_load_model_from_file(), Slic3r::Model::add_object(), Slic3r::Model::add_object(), Slic3r::GUI::ObjectDataViewModel::AddObject(), Slic3r::SLAPrint::apply(), Slic3r::GUI::ObjectList::boolean(), construct_assemble_list(), Slic3r::GUI::Selection::copy_to_clipboard(), Slic3r::GUI::Plater::priv::delete_object_from_model(), Slic3r::GUI::PartPlate::duplicate_all_instance(), Slic3r::GUI::ensure_belt_purge_tower(), Slic3r::Print::export_cached_data(), Slic3r::GUI::Plater::export_stl(), anonymous_namespace{EmbossJob.cpp}::CreateObjectJob::finalize(), get_export_filename(), Slic3r::PrintObject::get_first_layer_bbox(), Slic3r::get_instance_name(), Slic3r::MeshInspect::inspect_to_json(), Slic3r::PaintCLI::inspect_to_json(), load(), Slic3r::Print::load_cached_data(), Slic3r::GUI::Plater::priv::load_files(), Slic3r::GUI::ObjectList::load_mesh_object(), make_boolean(), Slic3r::GUI::ObjectList::merge(), merge_or_add_object(), Slic3r::Step::mesh(), Slic3r::Cut::perform_by_contour(), Slic3r::Cut::perform_with_groove(), Slic3r::GUI::FillBedJob::prepare(), Slic3r::GUI::ArrangeJob::prepare_selected(), Slic3r::GUI::NotificationManager::push_slicing_warning_notification(), Slic3r::GUI::Plater::priv::reload_from_disk(), Slic3r::GUI::GLCanvas3D::Labels::render(), Slic3r::GUI::Plater::priv::replace_volume_with_stl(), Slic3r::CLI::run(), save(), Slic3r::GUI::Plater::show_object_info(), anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_two_color_cube_and_export(), Slic3r::GUI::ObjectList::smooth_mesh(), split(), Slic3r::GUI::ObjectList::update_name_in_model(), Slic3r::PrintBase::update_object_placeholders(), Slic3r::GUI::ObjectDataViewModel::UpdateItemNames(), and Slic3r::Print::validate().

origin_translation

Vec3d Slic3r::ModelObject::origin_translation

Referenced by ModelObject(), ModelObject(), Slic3r::GUI::ObjectList::boolean(), center_around_origin(), Slic3r::GUI::Selection::copy_to_clipboard(), Slic3r::GUI::Plater::export_stl(), Slic3r::invalidate_translations(), load(), Slic3r::GUI::ObjectList::load_mesh_object(), Slic3r::GUI::ObjectList::load_modifier(), Slic3r::GUI::ObjectList::merge(), and save().

printable

bool Slic3r::ModelObject::printable { true }

{ true };

Referenced by load(), Slic3r::GUI::ObjectList::merge(), Slic3r::GUI::OrientJob::prepare_selection(), and save().

s_last_id

size_t Slic3r::ObjectBase::s_last_id = 0

staticprivateinherited

Referenced by generate_new_id().

sla_drain_holes

sla::DrainHoles Slic3r::ModelObject::sla_drain_holes

Referenced by Slic3r::_3MF_Importer::_load_model_from_file(), Slic3r::SLAPrint::apply(), convert_units(), Slic3r::GUI::Selection::copy_to_clipboard(), load(), merge_volumes(), Slic3r::sla::reproject_points_and_holes(), and save().

sla_points_status

sla::PointsStatus Slic3r::ModelObject::sla_points_status = sla::PointsStatus::NoPoints

Referenced by Slic3r::_3MF_Importer::_load_model_from_file(), Slic3r::SLAPrint::apply(), convert_units(), Slic3r::GUI::Selection::copy_to_clipboard(), load(), merge_volumes(), Slic3r::GUI::GLCanvas3D::reload_scene(), save(), Slic3r::SLAPrint::Steps::support_points(), and Slic3r::SLAPrint::validate().

sla_support_points

sla::SupportPoints Slic3r::ModelObject::sla_support_points

Referenced by Slic3r::_3MF_Importer::_load_model_from_file(), Slic3r::SLAPrint::apply(), convert_units(), Slic3r::GUI::Selection::copy_to_clipboard(), load(), merge_volumes(), Slic3r::sla::reproject_points_and_holes(), save(), Slic3r::SLAPrint::Steps::support_points(), and Slic3r::SLAPrint::validate().

volume_ids

std::vector<ObjectID> Slic3r::ModelObject::volume_ids

Referenced by load().

volumes

ModelVolumePtrs Slic3r::ModelObject::volumes

Referenced by Slic3r::GUI::GLGizmoCut3D::PartSelection::PartSelection(), Slic3r::GUI::GLGizmoCut3D::PartSelection::PartSelection(), Slic3r::GUI::anonymous_namespace{Plater.cpp}::SvgArchivePathsRestorer::SvgArchivePathsRestorer(), Slic3r::_BBS_3MF_Exporter::_add_cut_information_file_to_archive(), Slic3r::_3MF_Exporter::_add_model_config_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_model_config_file_to_archive(), Slic3r::_BBS_3MF_Importer::_extract_embossed_svg_shape_file(), Slic3r::_3MF_Importer::_load_model_from_file(), Slic3r::GUI::GLCanvas3D::_render_section_view_caps(), Slic3r::GUI::RaycastManager::actualize(), Slic3r::Model::add_object(), Slic3r::Model::add_object(), Slic3r::GUI::MenuFactory::append_menu_items_convert_unit(), Slic3r::Print::append_model_object_extruders(), Slic3r::GUI::ObjectList::apply_object_instance_transfrom_to_all_volumes(), Slic3r::GUI::Plater::priv::apply_textured_mesh_import_result(), Slic3r::Print::auto_assign_extruders(), Slic3r::GUI::calc_distance(), Slic3r::ModelInstance::calc_print_volume_state(), Slic3r::GUI::can_add_volumes_to_object(), Slic3r::check_model_ids_equal(), Slic3r::check_model_ids_validity(), Slic3r::GLVolumeCollection::check_outside_state(), Slic3r::GUI::PartPlate::check_single_extruder_mixed_filament_risk(), Slic3r::GUI::Plater::clear_before_change_mesh(), Slic3r::GUI::Plater::combine_mesh_fff(), Slic3r::SeamPlacerImpl::compute_global_occlusion(), construct_assemble_list(), convert_units(), convex_hull_2d(), Slic3r::GUI::Selection::copy_to_clipboard(), Slic3r::GUI::Emboss::create_volume_sources(), Slic3r::GUI::GLGizmoPainterBase::data_changed(), delete_connectors(), Slic3r::GUI::ObjectList::delete_from_model_and_list(), Slic3r::distribute_modifiers_from_object(), Slic3r::GUI::GLCanvas3D::do_mirror(), Slic3r::GUI::GLCanvas3D::do_move(), Slic3r::GUI::GLCanvas3D::do_rotate(), Slic3r::GUI::GLCanvas3D::do_scale(), Slic3r::GUI::ensure_belt_purge_tower(), Slic3r::GUI::PartPlate::exclusion_volume_preview_cache_key(), Slic3r::Print::export_cached_data(), Slic3r::GUI::Plater::export_stl(), Slic3r::Cut::finalize(), Slic3r::fix_model_with_cgal_gui(), Slic3r::GUI::ObjectList::fix_through_cgal(), Slic3r::SeamPlacerImpl::gather_enforcers_blockers(), Slic3r::GUI::GLGizmoMeshBoolean::generate_new_volume(), Slic3r::GUI::get_extruder_id_for_volumes(), Slic3r::GUI::PartPlate::get_extruders(), Slic3r::GUI::PartPlate::get_extruders_under_cli(), Slic3r::GUI::PartPlate::get_extruders_without_support(), get_instance_max_z(), get_instance_min_z(), Slic3r::GUI::get_model_volume(), Slic3r::GUI::get_model_volume(), Slic3r::GUI::GLGizmoAlignment::get_selected_part_volumes(), Slic3r::GUI::Selection::get_selected_single_volume(), Slic3r::GUI::get_selected_volume(), Slic3r::GUI::GLGizmoMeshBoolean::gizmo_event(), Slic3r::GUI::GLGizmoPainterBase::gizmo_event(), Slic3r::groupingVolumesForBrim(), has_solid_mesh(), Slic3r::GUI::GLGizmoMmuSegmentation::init_model_triangle_selectors(), Slic3r::GUI::GLGizmoMeasure::init_plane_glmodel(), Slic3r::PreciseSeam::init_precise_seam_data(), Slic3r::PaintCLI::inspect_to_json(), Slic3r::ModelInstance::intersects_bed_exclude_region(), is_multiparts(), Slic3r::GUI::GLGizmoFlatten::is_plane_update_necessary(), Slic3r::GUI::Selection::Clipboard::is_sla_compliant(), Slic3r::GUI::GLGizmoSVG::is_svg_object(), load(), Slic3r::load_amf_archive(), Slic3r::load_amf_file(), Slic3r::GUI::Tab::load_current_preset(), Slic3r::GUI::Plater::priv::load_files(), Slic3r::GUI::ObjectList::load_modifier(), Slic3r::GLVolumeCollection::load_object(), Slic3r::GLVolumeCollection::load_object_volume(), Slic3r::load_svg(), main(), Slic3r::GUI::ObjectList::merge(), merge(), merge_or_add_object(), merge_volumes(), Slic3r::Step::mesh(), Slic3r::GUI::GLGizmoPainterBase::mesh_trafo_matrices(), Slic3r::model_has_advanced_features(), Slic3r::model_has_multi_part_objects(), Slic3r::model_property_changed(), Slic3r::csg::model_to_csgmesh(), Slic3r::model_volume_list_changed(), Slic3r::model_volume_list_copy_configs(), Slic3r::ModelVolume::model_volume_list_update_supports_and_seams, Slic3r::GUI::move_volume_to_end(), Slic3r::GUI::GLGizmoFdmSupports::need_regenerate_support_volumes(), Slic3r::GUI::ObjectList::object_config_options_changed(), Slic3r::PrintObject::object_extruders(), Slic3r::GUI::Plater::on_filament_count_change(), Slic3r::GUI::Plater::on_filaments_delete(), Slic3r::GUI::GLGizmoMeshBoolean::on_load(), Slic3r::GUI::GLCanvas3D::on_mouse(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), Slic3r::GUI::GLGizmoFuzzySkin::on_render_input_window(), Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window(), Slic3r::GUI::GLGizmoSeam::on_render_input_window(), Slic3r::GUI::GLGizmoTextureDisplacement::on_render_input_window(), Slic3r::GUI::CommonGizmosDataObjects::InstancesHider::on_update(), Slic3r::GUI::CommonGizmosDataObjects::ObjectClipper::on_update(), Slic3r::GUI::CommonGizmosDataObjects::Raycaster::on_update(), Slic3r::GUI::ObjectGridTable::OnCellLeftClick(), Slic3r::GUI::ObjectList::OnDrop(), Slic3r::outer_inner_brim_area(), Slic3r::GUI::Selection::paste_volumes_from_clipboard(), Slic3r::Cut::perform_by_contour(), Slic3r::Cut::perform_with_groove(), Slic3r::Cut::perform_with_plane(), Slic3r::Cut::post_process(), anonymous_namespace{GLGizmoEmboss.cpp}::prepare_volumes_to_slice(), Slic3r::GUI::GLGizmoTextureDisplacement::preview_part(), Slic3r::Print::process(), Slic3r::GUI::CalibUtils::process_and_store_3mf(), Slic3r::process_solid_part_cut(), Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp}::project_used_filament_slots(), Slic3r::GUI::anonymous_namespace{Plater.cpp}::publish(), Slic3r::GUI::GLGizmoMeasure::register_single_mesh_pick(), Slic3r::GUI::ObjectGridTable::reload_cell_data(), Slic3r::GUI::Plater::priv::reload_from_disk(), Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::GUI::GLGizmoMmuSegmentation::remap_filament_assignments(), Slic3r::remap_model_filament_slots(), Slic3r::GUI::GLGizmoPainterBase::render_cursor_height_range(), Slic3r::GUI::CommonGizmosDataObjects::InstancesHider::render_cut(), Slic3r::GUI::GLGizmoPainterBase::render_triangles(), Slic3r::GUI::Plater::priv::replace_volume_with_stl(), Slic3r::CLI::run(), Slic3r::GUI::GLGizmoFdmSupports::run_thread(), save(), Slic3r::segmentation_by_painting(), Slic3r::segmentation_top_and_bottom_layers(), Slic3r::GUI::GLGizmoFdmSupports::select_facets_by_angle(), Slic3r::GUI::ObjectList::select_items(), Slic3r::GUI::GLGizmoTextureDisplacement::select_whole_model(), Slic3r::GUI::ObjectList::set_extruder_for_selected_items(), Slic3r::GUI::CalibUtils::set_for_auto_pa_model_and_config(), Slic3r::GUI::ObjectList::show_context_menu(), Slic3r::GUI::Plater::show_object_info(), Slic3r::GLVolume::simple_render(), Slic3r::GUI::ObjectList::smooth_mesh(), sort_volumes(), Slic3r::ModelVolume::split(), anonymous_namespace{SurfaceDrag.cpp}::start_dragging(), Slic3r::GUI::GLGizmoTextureDisplacement::swap_layer_slots(), Slic3r::GUI::GLGizmoTextureDisplacement::texture_parts(), Slic3r::GUI::GLGizmoTextureDisplacement::texture_volume(), Slic3r::GUI::GLGizmoTextureDisplacement::texture_volume_raycaster_index(), Slic3r::GUI::GLGizmoFdmSupports::update_from_model_object(), Slic3r::GUI::GLGizmoFuzzySkin::update_from_model_object(), Slic3r::GUI::GLGizmoSeam::update_from_model_object(), Slic3r::GUI::GLGizmoTextureDisplacement::update_from_model_object(), Slic3r::GUI::ObjectList::update_info_items(), Slic3r::GUI::GLGizmoFdmSupports::update_model_object(), Slic3r::GUI::GLGizmoFuzzySkin::update_model_object(), Slic3r::GUI::GLGizmoMmuSegmentation::update_model_object(), Slic3r::GUI::GLGizmoSeam::update_model_object(), Slic3r::GUI::GLGizmoTextureDisplacement::update_model_object(), Slic3r::GUI::ObjectList::update_name_in_model(), Slic3r::GUI::GLGizmoFlatten::update_planes(), Slic3r::GUI::ObjectList::update_selections_on_canvas(), Slic3r::Print::update_shrinkage_compensation(), Slic3r::GUI::Selection::update_type(), and Slic3r::GUI::ObjectDataViewModel::UpdateItemNames().

---

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

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