Slic3r::ModelObject Class Reference

#include <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
ModelVolume *	add_volume (const TriangleMesh &mesh)
ModelVolume *	add_volume (TriangleMesh &&mesh, ModelVolumeType type=ModelVolumeType::MODEL_PART)
ModelVolume *	add_volume (const ModelVolume &volume, ModelVolumeType type=ModelVolumeType::INVALID)
ModelVolume *	add_volume (const ModelVolume &volume, TriangleMesh &&mesh)
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_text () const
bool	has_custom_layering () const
ModelInstance *	add_instance ()
ModelInstance *	add_instance (const ModelInstance &instance)
ModelInstance *	add_instance (const Geometry::Transformation &trafo)
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
const BoundingBoxf3 &	raw_mesh_bounding_box () const
BoundingBoxf3	full_raw_mesh_bounding_box () 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	apply_cut_connectors (const std::string &name)
void	invalidate_cut ()
void	delete_connectors ()
void	clone_for_cut (ModelObject **obj)
ModelObjectPtrs	cut (size_t instance, const Transform3d &cut_matrix, ModelObjectCutAttributes attributes)
void	split (ModelObjectPtrs *new_objects)
void	merge ()
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	has_negative_volume_mesh () const
bool	has_sla_drain_holes () const
bool	is_cut () const
bool	has_connectors () const
ObjectID	id () const
virtual Timestamp	timestamp () const

Static Public Member Functions
static indexed_triangle_set	get_connector_mesh (CutConnectorAttributes connector_attributes)
static void	reset_instance_transformation (ModelObject *object, size_t src_instance_idx, const Transform3d &cut_matrix, bool place_on_cut=false, bool flip=false)

Public Attributes
std::string	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 }
sla::SupportPoints	sla_support_points
sla::PointsStatus	sla_points_status = sla::PointsStatus::NoPoints
sla::DrainHoles	sla_drain_holes
CutConnectors	cut_connectors
CutObjectBase	cut_id
Vec3d	origin_translation

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

Private Member Functions
void	process_connector_cut (ModelVolume *volume, const Transform3d &instance_matrix, const Transform3d &cut_matrix, ModelObjectCutAttributes attributes, ModelObject *upper, ModelObject *lower, std::vector< ModelObject * > &dowels)
void	process_modifier_cut (ModelVolume *volume, const Transform3d &instance_matrix, const Transform3d &inverse_cut_matrix, ModelObjectCutAttributes attributes, ModelObject *upper, ModelObject *lower)
void	process_volume_cut (ModelVolume *volume, const Transform3d &instance_matrix, const Transform3d &cut_matrix, ModelObjectCutAttributes attributes, TriangleMesh &upper_mesh, TriangleMesh &lower_mesh)
void	process_solid_part_cut (ModelVolume *volume, const Transform3d &instance_matrix, const Transform3d &cut_matrix, ModelObjectCutAttributes attributes, ModelObject *upper, ModelObject *lower)
	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	serialize (Archive &ar)
unsigned int	update_instances_print_volume_state (const BuildVolume &build_volume)
void	update_min_max_z ()

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(), and Slic3r::ObjectID::valid().

Here is the call 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::id(), and Slic3r::ObjectID::invalid().

Here is the call graph for this function:

~ModelObject()

Slic3r::ModelObject::~ModelObject ( )

private

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

References clear_instances(), and clear_volumes().

Here is the call 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 config, Slic3r::ObjectBase::id(), Slic3r::ObjectID::invalid(), layer_height_profile, 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 Slic3r::ObjectID::id, Slic3r::ObjectBase::id(), Slic3r::ObjectID::invalid(), 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::id(), and Slic3r::ObjectID::invalid().

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();
    return i;
}

References instances, and invalidate_bounding_box().

Referenced by Slic3r::_3MF_Importer::_load_model_from_file(), add_instance(), Slic3r::GUI::Selection::copy_to_clipboard(), Slic3r::GUI::Plater::increase_instances(), Slic3r::GUI::ObjectList::load_mesh_object(), Slic3r::GUI::ObjectList::merge(), Slic3r::GUI::FillBedJob::prepare(), 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 Geometry::Transformation &

trafo

)

{
    ModelInstance* instance = add_instance();
    instance->set_transformation(trafo);
    return instance;
}

References add_instance(), and Slic3r::ModelInstance::set_transformation().

Here is the call graph for this function:

add_instance() [3/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 instances, and invalidate_bounding_box().

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();
    return v;
}

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

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();
    return v;
}

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

Here is the call graph for this function:

add_volume() [3/4]

ModelVolume * Slic3r::ModelObject::add_volume

(

const TriangleMesh &

mesh

)

{
    ModelVolume* v = new ModelVolume(this, mesh);
    this->volumes.push_back(v);
    v->center_geometry_after_creation();
    this->invalidate_bounding_box();
    return v;
}

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

Referenced by Slic3r::Model::add_object(), Slic3r::Model::add_object(), Slic3r::Model::convert_multipart_object(), convert_units(), Slic3r::GUI::Selection::copy_to_clipboard(), priv::create_volume(), Slic3r::GUI::ObjectList::load_generic_subobject(), Slic3r::GUI::ObjectList::load_mesh_object(), Slic3r::GUI::ObjectList::load_modifier(), Slic3r::load_step(), Slic3r::GUI::ObjectList::merge(), Slic3r::GUI::Selection::paste_volumes_from_clipboard(), Slic3r::GUI::GLGizmoCut3D::perform_cut(), process_connector_cut(), process_modifier_cut(), Slic3r::GUI::Plater::priv::reload_from_disk(), Slic3r::GUI::Plater::priv::replace_volume_with_stl(), Slic3r::CLI::run(), split(), and Slic3r::AMFParserContext::startElement().

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
	)

{
    ModelVolume* v = new ModelVolume(this, std::move(mesh), type);
    this->volumes.push_back(v);
    v->center_geometry_after_creation();
    this->invalidate_bounding_box();
    return v;
}

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

Here is the call graph for this function:

apply_cut_connectors()

void Slic3r::ModelObject::apply_cut_connectors

(

const std::string &

name

)

{
    if (cut_connectors.empty())
        return;
 
    using namespace Geometry;
 
    size_t connector_id = cut_id.connectors_cnt();
    for (const CutConnector& connector : cut_connectors) {
        TriangleMesh mesh = TriangleMesh(get_connector_mesh(connector.attribs));
        // Mesh will be centered when loading.
        ModelVolume* new_volume = add_volume(std::move(mesh), ModelVolumeType::NEGATIVE_VOLUME);
 
        // Transform the new modifier to be aligned inside the instance
        new_volume->set_transformation(translation_transform(connector.pos) * connector.rotation_m *
                                       scale_transform(Vec3f(connector.radius, connector.radius, connector.height).cast<double>()));
 
        new_volume->cut_info = { connector.attribs.type, connector.radius_tolerance, connector.height_tolerance };
        new_volume->name = new_name + "-" + std::to_string(++connector_id);
    }
    cut_id.increase_connectors_cnt(cut_connectors.size());
 
    // delete all connectors
    cut_connectors.clear();
}

References Slic3r::ModelVolume::cut_info, Slic3r::ModelVolume::name, Slic3r::ModelVolume::CutInfo::radius_tolerance, and Slic3r::ModelVolume::set_transformation().

Referenced by Slic3r::GUI::GLGizmoCut3D::apply_connectors_in_model().

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 instances, layer_height_profile, set_new_unique_id(), Slic3r::ObjectBase::set_new_unique_id(), and volumes.

Here is the call 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();
    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_matrix(), model_instance.get_matrix())));
        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 EPSILON, Slic3r::Geometry::Transformation::get_matrix(), Slic3r::ModelInstance::get_matrix(), Slic3r::Geometry::Transformation::get_mirror(), Slic3r::Geometry::Transformation::get_offset(), Slic3r::Geometry::Transformation::get_scaling_factor(), Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::inverse(), Slic3r::Geometry::Transformation::is_left_handed(), Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::matrix(), Slic3r::Geometry::Transformation::reset_mirror(), Slic3r::Geometry::Transformation::reset_offset(), Slic3r::Geometry::Transformation::reset_scaling_factor(), Slic3r::ModelInstance::set_mirror(), Slic3r::ModelInstance::set_rotation(), and Slic3r::ModelInstance::set_scaling_factor().

Here is the call 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 instances, m_bounding_box_approx, m_bounding_box_approx_valid, Slic3r::BoundingBox3Base< PointType >::merge(), raw_mesh_bounding_box(), and Slic3r::BoundingBoxBase< PointType, APointsType >::reset().

Here is the call 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 instances, m_bounding_box_exact, m_bounding_box_exact_valid, m_min_max_z_valid, Slic3r::BoundingBox3Base< PointType >::merge(), and Slic3r::BoundingBoxBase< PointType, APointsType >::reset().

Here is the call 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().

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

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 instances, and invalidate_bounding_box().

Referenced by ~ModelObject(), Slic3r::_3MF_Importer::_load_model_from_file(), Slic3r::Print::apply(), and Slic3r::SLAPrint::apply().

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();
}

References invalidate_bounding_box(), and volumes.

Referenced by ~ModelObject(), and convert_units().

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();
}

Referenced by Slic3r::GUI::GLGizmoCut3D::perform_cut().

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->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);
 
            // 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 add_volume(), Slic3r::FacetsAnnotation::assign(), Slic3r::ModelConfig::assign_config(), clear_volumes(), Slic3r::ModelVolume::config, Slic3r::ObjectBase::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, Slic3r::ModelVolume::mmu_segmentation_facets, Slic3r::ModelVolume::name, 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::ObjectID::valid(), and Slic3r::ModelVolume::Source::volume_idx.

Here is the call graph for this function:

convex_hull_2d()

Polygon Slic3r::ModelObject::convex_hull_2d

(

const Transform3d &

trafo_instance

)

const

{
    tbb::concurrent_vector<Polygon> chs;
    chs.reserve(volumes.size());
    tbb::parallel_for(tbb::blocked_range<size_t>(0, volumes.size()), [&](const tbb::blocked_range<size_t>& range) {
        for (size_t i = range.begin(); i < range.end(); ++i) {
            const ModelVolume* v = volumes[i];
            chs.emplace_back(its_convex_hull_2d_above(v->mesh().its, (trafo_instance * v->get_matrix()).cast<float>(), 0.0f));
        }
    });
 
    Polygons polygons;
    polygons.assign(chs.begin(), chs.end());
    return Geometry::convex_hull(polygons);
}

References Slic3r::range(), and volumes.

Referenced by Slic3r::GUI::RotoptimizeJob::finalize(), 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 Slic3r::ObjectBase::id(), and Slic3r::ObjectBase::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 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.

Referenced by Slic3r::Print::apply().

Here is the caller graph for this function:

cut()

ModelObjectPtrs Slic3r::ModelObject::cut	(	size_t	instance,
		const Transform3d &	cut_matrix,
		ModelObjectCutAttributes	attributes
	)

{
    if (!attributes.has(ModelObjectCutAttribute::KeepUpper) && !attributes.has(ModelObjectCutAttribute::KeepLower))
        return {};
 
    BOOST_LOG_TRIVIAL(trace) << "ModelObject::cut - start";
 
    // Clone the object to duplicate instances, materials etc.
    ModelObject* upper{ nullptr };
    if (attributes.has(ModelObjectCutAttribute::KeepUpper))
        clone_for_cut(&upper);
 
    ModelObject* lower{ nullptr };
    if (attributes.has(ModelObjectCutAttribute::KeepLower) && !attributes.has(ModelObjectCutAttribute::KeepAsParts))
        clone_for_cut(&lower);
 
    std::vector<ModelObject*> dowels;
 
    using namespace Geometry;
 
    // Because transformations are going to be applied to meshes directly,
    // we reset transformation of all instances and volumes,
    // except for translation and Z-rotation on instances, which are preserved
    // in the transformation matrix and not applied to the mesh transform.
 
    // const auto instance_matrix = instances[instance]->get_matrix(true);
    const auto instance_matrix = instances[instance]->get_transformation().get_matrix_no_offset();
    const Transformation cut_transformation = Transformation(cut_matrix);
    const Transform3d inverse_cut_matrix    = cut_transformation.get_rotation_matrix().inverse() * translation_transform(-1. * cut_transformation.get_offset());
 
    for (ModelVolume* volume : volumes) {
        volume->reset_extra_facets();
 
        if (!volume->is_model_part()) {
            if (volume->cut_info.is_processed)
                process_modifier_cut(volume, instance_matrix, inverse_cut_matrix, attributes, upper, lower);
            else
                process_connector_cut(volume, instance_matrix, cut_matrix, attributes, upper, lower, dowels);
        }
        else if (!volume->mesh().empty())
            process_solid_part_cut(volume, instance_matrix, cut_matrix, attributes, upper, lower);
    }
 
    // Post-process cut parts
 
    ModelObjectPtrs res;
 
    if (attributes.has(ModelObjectCutAttribute::KeepAsParts) && !upper->volumes.empty()) {
        reset_instance_transformation(upper, instance, cut_matrix);
        res.push_back(upper);
    }
    else {
        if (attributes.has(ModelObjectCutAttribute::KeepUpper) && !upper->volumes.empty()) {
            reset_instance_transformation(upper, instance, cut_matrix,
                attributes.has(ModelObjectCutAttribute::PlaceOnCutUpper),
                attributes.has(ModelObjectCutAttribute::FlipUpper));
            res.push_back(upper);
        }
 
        if (attributes.has(ModelObjectCutAttribute::KeepLower) && !lower->volumes.empty()) {
            reset_instance_transformation(lower, instance, cut_matrix,
                attributes.has(ModelObjectCutAttribute::PlaceOnCutLower),
                attributes.has(ModelObjectCutAttribute::PlaceOnCutLower) || attributes.has(ModelObjectCutAttribute::FlipLower));
            res.push_back(lower);
        }
 
        if (attributes.has(ModelObjectCutAttribute::CreateDowels) && !dowels.empty()) {
            for (auto dowel : dowels) {
                reset_instance_transformation(dowel, instance, Transform3d::Identity());
                dowel->name += "-Dowel-" + dowel->volumes[0]->name;
                res.push_back(dowel);
            }
        }
    }
 
    BOOST_LOG_TRIVIAL(trace) << "ModelObject::cut - end";
 
    return res;
}

References Slic3r::enum_bitmask< option_type, typename >::has(), and Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::inverse().

Referenced by Slic3r::GUI::GLGizmoCut3D::perform_cut().

Here is the call graph for this function:

Here is the caller 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));
    }
}

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 instances, and invalidate_bounding_box().

Referenced by delete_last_instance(), 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:

delete_last_instance()

void Slic3r::ModelObject::delete_last_instance

(

)

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

References delete_instance(), and instances.

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

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();
}

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

Referenced by Slic3r::GUI::GLGizmoCut3D::perform_cut(), 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

)

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

Referenced by Slic3r::GUI::GLGizmoSimplify::apply_simplify(), Slic3r::GUI::RotoptimizeJob::finalize(), Slic3r::GUI::FillBedJob::finalize(), Slic3r::GUI::ObjectList::load_mesh_object(), Slic3r::GUI::Plater::priv::reload_from_disk(), and Slic3r::GUI::Plater::priv::replace_volume_with_stl().

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;
}

Referenced by Slic3r::GUI::Sidebar::show_info_sizer().

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 Slic3r::BoundingBox3Base< PointType >::merge(), and volumes.

Here is the call graph for this function:

generate_new_id()

static ObjectID Slic3r::ObjectBase::generate_new_id ( )

inlinestaticprivateinherited

{ return ObjectID(++ s_last_id); }

References Slic3r::ObjectBase::s_last_id.

Referenced by Slic3r::ObjectBase::set_new_unique_id().

Here is the caller graph for this function:

get_connector_mesh()

indexed_triangle_set Slic3r::ModelObject::get_connector_mesh ( CutConnectorAttributes  connector_attributes )

static

{
    indexed_triangle_set connector_mesh;
 
    int   sectorCount {1};
    switch (CutConnectorShape(connector_attributes.shape)) {
    case CutConnectorShape::Triangle:
        sectorCount = 3;
        break;
    case CutConnectorShape::Square:
        sectorCount = 4;
        break;
    case CutConnectorShape::Circle:
        sectorCount = 360;
        break;
    case CutConnectorShape::Hexagon:
        sectorCount = 6;
        break;
    default:
        break;
    }
 
    if (connector_attributes.style == CutConnectorStyle::Prism)
        connector_mesh = its_make_cylinder(1.0, 1.0, (2 * PI / sectorCount));
    else if (connector_attributes.type == CutConnectorType::Plug)
        connector_mesh = its_make_frustum(1.0, 1.0, (2 * PI / sectorCount));
    else
        connector_mesh = its_make_frustum_dowel(1.0, 1.0, sectorCount);
 
    return connector_mesh;
}

References Slic3r::its_make_cylinder(), Slic3r::its_make_frustum(), Slic3r::its_make_frustum_dowel(), PI, Slic3r::CutConnectorAttributes::shape, Slic3r::CutConnectorAttributes::style, and Slic3r::CutConnectorAttributes::type.

Referenced by Slic3r::GUI::GLGizmoCut3D::init_connector_shapes(), and Slic3r::GUI::GLGizmoCut3D::update_connector_shape().

Here is the call graph for this function:

Here is the caller 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;
}

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 Slic3r::ModelInstance::get_matrix_no_offset(), Slic3r::ModelInstance::get_offset(), indexed_triangle_set::indices, Slic3r::TriangleMesh::its, indexed_triangle_set::vertices, and Slic3r::Z.

Here is the call 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();
        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());
    }
 
    return min_z + inst->get_offset(Z);
}

References Slic3r::ModelInstance::get_matrix_no_offset(), Slic3r::ModelInstance::get_offset(), indexed_triangle_set::indices, Slic3r::TriangleMesh::its, indexed_triangle_set::vertices, and Slic3r::Z.

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

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.

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

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.

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 Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::matrix(), 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(), and Slic3r::GUI::Sidebar::show_info_sizer().

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, and Slic3r::RepairedMeshErrors::facets_reversed.

Referenced by Slic3r::GUI::ObjectList::fix_through_netfabb().

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;
}

Referenced by Slic3r::GUI::ObjectList::update_info_items().

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

Here is the call graph for this function:

has_negative_volume_mesh()

bool Slic3r::ModelObject::has_negative_volume_mesh

(

)

const

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

has_sla_drain_holes()

bool Slic3r::ModelObject::has_sla_drain_holes ( ) const

inline

{ return !sla_drain_holes.empty(); }

References sla_drain_holes.

has_solid_mesh()

bool Slic3r::ModelObject::has_solid_mesh

(

)

const

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

id()

ObjectID Slic3r::ObjectBase::id ( ) const

inlineinherited

{ return m_id; }

References Slic3r::ObjectBase::m_id.

Referenced by Slic3r::Model::Model(), Slic3r::ModelInstance::ModelInstance(), Slic3r::ModelMaterial::ModelMaterial(), ModelObject(), ModelObject(), ModelObject(), ModelObject(), ModelObject(), Slic3r::ModelVolume::ModelVolume(), Slic3r::ModelVolume::ModelVolume(), Slic3r::ModelVolume::ModelVolume(), Slic3r::_3MF_Importer::_load_model_from_file(), Slic3r::GUI::Plater::priv::actualize_slicing_warnings(), Slic3r::ModelObjectStatusDB::add(), Slic3r::ModelObjectStatusDB::add_if_new(), Slic3r::Print::apply(), Slic3r::SLAPrint::apply(), Slic3r::GUI::GLGizmoFdmSupports::apply_data_from_backend(), Slic3r::ModelVolume::check(), Slic3r::check_model_ids_equal(), convert_units(), Slic3r::ObjectBase::copy_id(), Slic3r::PrintObjectStatusDB::count(), anonymous_namespace{RaycastManager.cpp}::create_key(), priv::create_volume(), Slic3r::GUI::Emboss::create_volume_sources(), Slic3r::GUI::GLGizmoHollow::data_changed(), Slic3r::GUI::GLGizmoPainterBase::data_changed(), Slic3r::GUI::GLGizmoSlaSupports::data_changed(), Slic3r::Model::delete_object(), Slic3r::GUI::Plater::export_stl_obj(), Slic3r::ModelObjectStatusDB::get(), Slic3r::GUI::get_arrange_poly(), Slic3r::GUI::GLGizmoSlaSupports::get_data_from_backend(), Slic3r::PrintObjectStatusDB::get_range(), Slic3r::GUI::GLGizmoFdmSupports::has_backend_supports(), Slic3r::GUI::GLGizmoSlaSupports::has_backend_supports(), Slic3r::CutObjectBase::has_same_id(), Slic3r::UndoRedo::StackImpl::immutable_object_id_impl(), Slic3r::GUI::GLGizmoSimplify::init_model(), Slic3r::inner_brim_area(), is_cut(), Slic3r::CutObjectBase::is_equal(), Slic3r::ObjectBase::load_and_construct(), Slic3r::UndoRedo::StackImpl::load_snapshot(), Slic3r::GUI::ObjectList::merge(), 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::CommonGizmosDataObjects::SelectionInfo::on_update(), Slic3r::CutObjectBase::operator<(), Slic3r::Model::operator=(), operator=(), operator=(), Slic3r::CutObjectBase::operator==(), Slic3r::GUI::GLGizmoCut3D::perform_cut(), Slic3r::GUI::GLGizmoEmboss::process(), Slic3r::GUI::processed_objects_idxs(), Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::GUI::GLCanvas3D::LayersEditing::select_object(), Slic3r::ModelMaterial::serialize(), Slic3r::SLAPrintObject::SliceRecord::set_model_slice_idx(), Slic3r::SLAPrintObject::SliceRecord::set_support_slice_idx(), Slic3r::slices_to_regions(), split(), Slic3r::UndoRedo::StackImpl::take_snapshot(), Slic3r::top_level_outer_brim_area(), Slic3r::GUI::update_object_cut_id(), and anonymous_namespace{EmbossJob.cpp}::update_volume_name().

instance_bounding_box()

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

{
    BoundingBoxf3 bb;
    const Transform3d inst_matrix = dont_translate ?
        this->instances[instance_idx]->get_transformation().get_matrix_no_offset() :
        this->instances[instance_idx]->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 instances, Slic3r::BoundingBox3Base< PointType >::merge(), and volumes.

Referenced by Slic3r::GUI::GLGizmoEmboss::create_volume(), Slic3r::GUI::GLCanvas3D::do_mirror(), Slic3r::GUI::GLCanvas3D::do_reset_skew(), Slic3r::GUI::GLCanvas3D::do_rotate(), Slic3r::GUI::GLCanvas3D::do_scale(), Slic3r::GUI::ObjectList::load_generic_subobject(), Slic3r::GUI::ObjectList::load_modifier(), Slic3r::GUI::CommonGizmosDataObjects::ObjectClipper::on_update(), Slic3r::GUI::Selection::paste_volumes_from_clipboard(), and Slic3r::GUI::Sidebar::show_info_sizer().

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 add_instance(), add_instance(), Slic3r::Model::add_object(), Slic3r::Model::add_object(), add_volume(), add_volume(), add_volume(), Slic3r::GUI::GLGizmoSimplify::apply_simplify(), clear_instances(), clear_volumes(), convert_units(), delete_instance(), delete_volume(), Slic3r::GUI::GLCanvas3D::do_mirror(), Slic3r::GUI::GLCanvas3D::do_move(), Slic3r::GUI::GLCanvas3D::do_reset_skew(), Slic3r::GUI::GLCanvas3D::do_rotate(), Slic3r::GUI::GLCanvas3D::do_scale(), and Slic3r::GUI::ObjectList::load_mesh_object().

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();
}

is_cut()

bool Slic3r::ModelObject::is_cut ( ) const

inline

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

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

Referenced by Slic3r::GUI::ObjectList::add_volumes_to_object_in_list(), Slic3r::GUI::MenuFactory::append_menu_items_convert_unit(), Slic3r::GUI::can_add_volumes_to_object(), Slic3r::GUI::ObjectList::change_part_type(), Slic3r::GUI::ObjectList::del_subobject_from_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::ObjectList::fix_cut_selection(), Slic3r::GUI::ObjectList::invalidate_cut_info_for_object(), Slic3r::GUI::ObjectList::is_selected_object_cut(), Slic3r::GUI::ObjectList::is_splittable(), Slic3r::GUI::ObjectList::load_generic_subobject(), Slic3r::GUI::ObjectList::part_selection_changed(), and Slic3r::GUI::ObjectList::update_info_items().

Here is the call graph for this function:

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 volumes.

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 volumes.

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

Here is the caller graph for this function:

is_multiparts()

bool Slic3r::ModelObject::is_multiparts ( ) const

inline

{ return volumes.size() > 1; }

References volumes.

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 volumes.

is_text()

bool Slic3r::ModelObject::is_text

(

)

const

{
    return this->volumes.size() == 1 && this->volumes[0]->is_text();
}

References volumes.

Referenced by Slic3r::GUI::ObjectList::update_name_in_list().

Here is the caller graph for this function:

load_and_construct()

template<class Archive >

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

inlinestaticprivateinherited

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

References Slic3r::ObjectBase::id().

Here is the call 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();
}

max_z()

double Slic3r::ModelObject::max_z

(

)

const

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

References m_bounding_box_exact, Slic3r::BoundingBoxBase< PointType, APointsType >::max, and update_min_max_z().

Referenced by Slic3r::PrintObject::PrintObject(), and Slic3r::GUI::GLCanvas3D::LayersEditing::select_object().

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 Slic3r::TriangleMesh::merge().

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

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, Slic3r::TriangleMesh::merge(), mesh(), and raw_mesh().

Referenced by add_volume(), add_volume(), add_volume(), mesh(), raw_mesh(), 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 m_bounding_box_exact, Slic3r::BoundingBoxBase< PointType, APointsType >::min, and update_min_max_z().

Referenced by 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();
}

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 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 Slic3r::ObjectID::id, Slic3r::ObjectBase::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;
}

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::TriangleMesh::bounding_box(), Slic3r::RepairedMeshErrors::degenerate_facets, Slic3r::RepairedMeshErrors::edges_fixed, Slic3r::TriangleMesh::facets_count(), Slic3r::RepairedMeshErrors::facets_removed, Slic3r::RepairedMeshErrors::facets_reversed, Slic3r::TriangleMeshStats::manifold(), Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::TriangleMeshStats::number_of_parts, Slic3r::TriangleMeshStats::open_edges, Slic3r::TriangleMeshStats::repaired(), Slic3r::TriangleMeshStats::repaired_errors, Slic3r::BoundingBox3Base< PointType >::size(), Slic3r::TriangleMesh::stats(), and Slic3r::TriangleMesh::volume().

Here is the call graph for this function:

process_connector_cut()

void Slic3r::ModelObject::process_connector_cut ( ModelVolume *  volume, const Transform3d &  instance_matrix, const Transform3d &  cut_matrix, ModelObjectCutAttributes  attributes, ModelObject *  upper, ModelObject *  lower, std::vector< ModelObject * > &  dowels  )

private

{
    assert(volume->cut_info.is_connector);
    volume->cut_info.set_processed();
 
    const auto volume_matrix = volume->get_matrix();
 
    // ! Don't apply instance transformation for the conntectors.
    // This transformation is already there
    if (volume->cut_info.connector_type != CutConnectorType::Dowel) {
        if (attributes.has(ModelObjectCutAttribute::KeepUpper)) {
            ModelVolume* vol = upper->add_volume(*volume);
            vol->set_transformation(volume_matrix);
            vol->apply_tolerance();
        }
        if (attributes.has(ModelObjectCutAttribute::KeepLower)) {
            ModelVolume* vol = lower->add_volume(*volume);
            vol->set_transformation(volume_matrix);
            // for lower part change type of connector from NEGATIVE_VOLUME to MODEL_PART if this connector is a plug
            vol->set_type(ModelVolumeType::MODEL_PART);
        }
    }
    else {
        if (attributes.has(ModelObjectCutAttribute::CreateDowels)) {
            ModelObject* dowel{ nullptr };
            // Clone the object to duplicate instances, materials etc.
            clone_for_cut(&dowel);
 
            // add one more solid part same as connector if this connector is a dowel
            ModelVolume* vol = dowel->add_volume(*volume);
            vol->set_type(ModelVolumeType::MODEL_PART);
 
            // But discard rotation and Z-offset for this volume
            vol->set_rotation(Vec3d::Zero());
            vol->set_offset(Z, 0.0);
 
            dowels.push_back(dowel);
        }
 
        // Cut the dowel
        volume->apply_tolerance();
 
        // Perform cut
        TriangleMesh upper_mesh, lower_mesh;
        process_volume_cut(volume, Transform3d::Identity(), cut_matrix, attributes, upper_mesh, lower_mesh);
 
        // add small Z offset to better preview
        upper_mesh.translate((-0.05 * Vec3d::UnitZ()).cast<float>());
        lower_mesh.translate((0.05 * Vec3d::UnitZ()).cast<float>());
 
        // Add cut parts to the related objects
        add_cut_volume(upper_mesh, upper, volume, cut_matrix, "_A", volume->type());
        add_cut_volume(lower_mesh, lower, volume, cut_matrix, "_B", volume->type());
    }
}

References Slic3r::add_cut_volume(), add_volume(), Slic3r::ModelVolume::apply_tolerance(), Slic3r::enum_bitmask< option_type, typename >::has(), Slic3r::ModelVolume::set_offset(), Slic3r::ModelVolume::set_rotation(), Slic3r::ModelVolume::set_transformation(), Slic3r::ModelVolume::set_type(), Slic3r::TriangleMesh::translate(), and Slic3r::Z.

Here is the call graph for this function:

process_modifier_cut()

void Slic3r::ModelObject::process_modifier_cut ( ModelVolume *  volume, const Transform3d &  instance_matrix, const Transform3d &  inverse_cut_matrix, ModelObjectCutAttributes  attributes, ModelObject *  upper, ModelObject *  lower  )

private

{
    const auto volume_matrix = instance_matrix * volume->get_matrix();
 
    // Modifiers are not cut, but we still need to add the instance transformation
    // to the modifier volume transformation to preserve their shape properly.
    volume->set_transformation(Geometry::Transformation(volume_matrix));
 
    if (attributes.has(ModelObjectCutAttribute::KeepAsParts)) {
        upper->add_volume(*volume);
        return;
    }
 
    // Some logic for the negative volumes/connectors. Add only needed modifiers
    auto bb = volume->mesh().transformed_bounding_box(inverse_cut_matrix * volume_matrix);
    bool is_crossed_by_cut = bb.min[Z] <= 0 && bb.max[Z] >= 0;
    if (attributes.has(ModelObjectCutAttribute::KeepUpper) && (bb.min[Z] >= 0 || is_crossed_by_cut))
        upper->add_volume(*volume);
    if (attributes.has(ModelObjectCutAttribute::KeepLower) && (bb.max[Z] <= 0 || is_crossed_by_cut))
        lower->add_volume(*volume);
}

References add_volume(), Slic3r::enum_bitmask< option_type, typename >::has(), and Slic3r::Z.

Here is the call graph for this function:

process_solid_part_cut()

void Slic3r::ModelObject::process_solid_part_cut ( ModelVolume *  volume, const Transform3d &  instance_matrix, const Transform3d &  cut_matrix, ModelObjectCutAttributes  attributes, ModelObject *  upper, ModelObject *  lower  )

private

{
    // Perform cut
    TriangleMesh upper_mesh, lower_mesh;
    process_volume_cut(volume, instance_matrix, cut_matrix, attributes, upper_mesh, lower_mesh);
 
    // Add required cut parts to the objects
 
    if (attributes.has(ModelObjectCutAttribute::KeepAsParts)) {
        add_cut_volume(upper_mesh, upper, volume, cut_matrix, "_A");
        add_cut_volume(lower_mesh, upper, volume, cut_matrix, "_B");
        return;
    }
 
    if (attributes.has(ModelObjectCutAttribute::KeepUpper))
        add_cut_volume(upper_mesh, upper, volume, cut_matrix);
 
    if (attributes.has(ModelObjectCutAttribute::KeepLower) && !lower_mesh.empty())
        add_cut_volume(lower_mesh, lower, volume, cut_matrix);
}

References Slic3r::add_cut_volume(), Slic3r::TriangleMesh::empty(), and Slic3r::enum_bitmask< option_type, typename >::has().

Here is the call graph for this function:

process_volume_cut()

void Slic3r::ModelObject::process_volume_cut ( ModelVolume *  volume, const Transform3d &  instance_matrix, const Transform3d &  cut_matrix, ModelObjectCutAttributes  attributes, TriangleMesh &  upper_mesh, TriangleMesh &  lower_mesh  )

private

{
    const auto volume_matrix = volume->get_matrix();
 
    using namespace Geometry;
 
    const Transformation cut_transformation = Transformation(cut_matrix);
    const Transform3d invert_cut_matrix = cut_transformation.get_rotation_matrix().inverse() * translation_transform(-1 * cut_transformation.get_offset());
 
    // Transform the mesh by the combined transformation matrix.
    // Flip the triangles in case the composite transformation is left handed.
    TriangleMesh mesh(volume->mesh());
    mesh.transform(invert_cut_matrix * instance_matrix * volume_matrix, true);
 
    indexed_triangle_set upper_its, lower_its;
    cut_mesh(mesh.its, 0.0f, &upper_its, &lower_its);
    if (attributes.has(ModelObjectCutAttribute::KeepUpper))
        upper_mesh = TriangleMesh(upper_its);
    if (attributes.has(ModelObjectCutAttribute::KeepLower))
        lower_mesh = TriangleMesh(lower_its);
}

References Slic3r::enum_bitmask< option_type, typename >::has(), Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::inverse(), Slic3r::TriangleMesh::its, and Slic3r::TriangleMesh::transform().

Here is the call 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, Slic3r::BoundingBox3Base< PointType >::merge(), Slic3r::BoundingBoxBase< PointType, APointsType >::reset(), and volumes.

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

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);
            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(), indexed_triangle_set::indices, indexed_triangle_set::vertices, and volumes.

Here is the call 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 Slic3r::TriangleMesh::merge(), mesh(), Slic3r::TriangleMesh::transform(), and volumes.

Referenced by Slic3r::sla::RotfinderBoilerplate< MAX_ITER >::get_mesh_to_rotate(), and 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, Slic3r::BoundingBox3Base< PointType >::merge(), Slic3r::BoundingBoxBase< PointType, APointsType >::reset(), and volumes.

Referenced by bounding_box_approx().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_instance_transformation()

void Slic3r::ModelObject::reset_instance_transformation ( ModelObject *  object, size_t  src_instance_idx, const Transform3d &  cut_matrix, bool  place_on_cut = false, bool  flip = false  )

static

{
    using namespace Geometry;
 
    // Reset instance transformation except offset and Z-rotation
 
    for (size_t i = 0; i < object->instances.size(); ++i) {
        auto& obj_instance = object->instances[i];
        const double rot_z = obj_instance->get_rotation().z();
        
        obj_instance->set_transformation(Transformation(obj_instance->get_transformation().get_matrix_no_scaling_factor()));
 
        Vec3d rotation = Vec3d::Zero();
        if (!flip && !place_on_cut) {
            if ( i != src_instance_idx)
            rotation[Z] = rot_z;
        }
        else {
            Transform3d rotation_matrix = Transform3d::Identity();
            if (flip)
                rotation_matrix = rotation_transform(PI * Vec3d::UnitX());
 
            if (place_on_cut)
                rotation_matrix = rotation_matrix * Transformation(cut_matrix).get_rotation_matrix().inverse();
 
            if (i != src_instance_idx)
                rotation_matrix = rotation_transform(rot_z * Vec3d::UnitZ()) * rotation_matrix;
 
            rotation = Transformation(rotation_matrix).get_rotation();
        }
 
        obj_instance->set_rotation(rotation);
    }
}

References Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::inverse(), PI, and Slic3r::Z.

Referenced by Slic3r::GUI::GLGizmoCut3D::perform_cut().

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

Here is the call 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);
    }
    center_around_origin();
    this->invalidate_bounding_box();
}

References Slic3r::angle().

Here is the call graph for this function:

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();
}

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 scale().

Here is the call 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 scale().

Here is the call graph for this function:

serialize()

template<class Archive >

void Slic3r::ModelObject::serialize ( 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);
        ar(name, input_file, instances, volumes, config_wrapper, layer_config_ranges, layer_heigth_profile_wrapper, 
            sla_support_points, sla_points_status, sla_drain_holes, printable, origin_translation,
            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 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, name, origin_translation, printable, sla_drain_holes, sla_points_status, sla_support_points, and volumes.

set_invalid_id()

void Slic3r::ObjectBase::set_invalid_id ( )

inlineprotectedinherited

{ m_id = 0; }

References Slic3r::ObjectBase::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.

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

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) {
            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;
            return vl_type < vr_type;
        });
}

References volumes.

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

Here is the caller graph for this function:

split()

void Slic3r::ModelObject::split

(

ModelObjectPtrs *

new_objects

)

{
    for (ModelVolume* volume : this->volumes) {
        if (volume->type() != ModelVolumeType::MODEL_PART)
            continue;
 
        // splited volume should not be text object 
        if (volume->text_configuration.has_value())
            volume->text_configuration.reset();
 
        std::vector<TriangleMesh> meshes = volume->mesh().split();
        std::sort(meshes.begin(), meshes.end(), is_front_up_left);
 
        size_t counter = 1;
        for (TriangleMesh &mesh : meshes) {
            // FIXME: crashes if not satisfied
            if (mesh.facets_count() < 3 || mesh.has_zero_volume())
                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();
            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);
            }
            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));
 
            // Invalidate extruder value in volume's config,
            // otherwise there will no way to change extruder for object after splitting,
            // because volume's extruder value overrides object's extruder value.
            if (new_vol->config.has("extruder"))
                new_vol->config.set_key_value("extruder", new ConfigOptionInt(0));
 
            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);
            }
 
            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 add_instance(), add_volume(), Slic3r::ModelConfig::assign_config(), config, Slic3r::ModelVolume::config, Slic3r::TriangleMesh::facets_count(), Slic3r::ModelVolume::get_offset(), Slic3r::ModelConfig::has(), Slic3r::TriangleMesh::has_zero_volume(), Slic3r::ObjectID::id, Slic3r::ObjectBase::id(), instances, Slic3r::is_front_up_left(), name, Slic3r::ModelConfig::set_key_value(), Slic3r::ModelVolume::set_offset(), Slic3r::ModelVolume::source, and Slic3r::ObjectID::valid().

Referenced by 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; }

Referenced by Slic3r::GUI::Plater::priv::undo_redo_to().

Here is the caller graph for this function:

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::load_mesh_object(), 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);
}

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(), and Slic3r::ModelInstance::set_offset().

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

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

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

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;
    enum {
        INSIDE = 1,
        OUTSIDE = 2
    };
    for (ModelInstance* model_instance : this->instances) {
        unsigned int inside_outside = 0;
        for (const ModelVolume* vol : this->volumes)
            if (vol->is_model_part()) {
                const Transform3d matrix = model_instance->get_matrix() * vol->get_matrix();
                BuildVolume::ObjectState state = build_volume.object_state(vol->mesh().its, matrix.cast<float>(), true /* may be below print bed */);
                if (state == BuildVolume::ObjectState::Inside)
                    // Volume is completely inside.
                    inside_outside |= INSIDE;
                else if (state == BuildVolume::ObjectState::Outside)
                    // Volume is completely outside.
                    inside_outside |= OUTSIDE;
                else if (state == BuildVolume::ObjectState::Below) {
                    // Volume below the print bed, thus it is completely outside, however this does not prevent the object to be printable
                    // if some of its volumes are still inside the build volume.
                } else
                    // Volume colliding with the build volume.
                    inside_outside |= INSIDE | OUTSIDE;
            }
        model_instance->print_volume_state =
            inside_outside == (INSIDE | OUTSIDE) ? ModelInstancePVS_Partly_Outside :
            inside_outside == INSIDE ? ModelInstancePVS_Inside : ModelInstancePVS_Fully_Outside;
        if (inside_outside == INSIDE)
            ++num_printable;
    }
    return num_printable;
}

References Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::cast(), Slic3r::ModelInstancePVS_Fully_Outside, Slic3r::ModelInstancePVS_Inside, Slic3r::ModelInstancePVS_Partly_Outside, and Slic3r::BuildVolume::object_state().

Here is the call 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, Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::linear(), m_bounding_box_exact, m_min_max_z_valid, Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::translation(), and volumes.

Referenced by max_z(), and min_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

Model

friend class Model

friend

Print

friend class Print

friend

SLAPrint

friend class SLAPrint

friend

UndoRedo::StackImpl

friend class UndoRedo::StackImpl

friend

Member Data Documentation

config

ModelConfigObject Slic3r::ModelObject::config

Referenced by ModelObject(), Slic3r::_3MF_Exporter::_add_model_config_file_to_archive(), Slic3r::_3MF_Importer::_load_model_from_file(), Slic3r::Print::apply(), Slic3r::SLAPrint::apply(), Slic3r::check_model_ids_equal(), Slic3r::GUI::Selection::copy_to_clipboard(), Slic3r::GUI::ObjectList::del_subobject_from_object(), Slic3r::GUI::ObjectList::delete_from_model_and_list(), Slic3r::AMFParserContext::endElement(), Slic3r::sla::find_least_supports_rotation(), Slic3r::GUI::GLGizmoHollow::get_config_options(), Slic3r::GUI::GLGizmoSlaSupports::get_config_options(), Slic3r::GUI::ObjectList::get_default_layer_config(), Slic3r::GUI::ObjectList::merge(), Slic3r::GUI::GLGizmoHollow::on_render_input_window(), Slic3r::GUI::GLGizmoSlaSupports::on_render_input_window(), operator=(), serialize(), split(), Slic3r::store_amf(), Slic3r::GUI::ObjectList::update_extruder_values_for_items(), and Slic3r::SLAPrint::validate().

cut_connectors

CutConnectors Slic3r::ModelObject::cut_connectors

Referenced by Slic3r::GUI::GLGizmoCut3D::apply_connectors_in_model(), Slic3r::GUI::GLGizmoCut3D::check_and_update_connectors_state(), Slic3r::GUI::GLGizmoCut3D::dragging_connector(), Slic3r::GUI::GLGizmoCut3D::gizmo_event(), Slic3r::GUI::GLGizmoCut3D::on_render_input_window(), Slic3r::GUI::GLGizmoCut3D::perform_cut(), Slic3r::GUI::GLGizmoCut3D::put_connectors_on_cut_plane(), Slic3r::GUI::GLGizmoCut3D::render_connectors(), Slic3r::GUI::GLGizmoCut3D::reset_connectors(), serialize(), and Slic3r::GUI::GLGizmoCut3D::update_raycasters_for_picking_transform().

cut_id

CutObjectBase Slic3r::ModelObject::cut_id

Referenced by Slic3r::_3MF_Importer::_load_model_from_file(), Slic3r::GUI::ObjectList::delete_all_connectors_for_object(), Slic3r::GUI::ObjectList::fix_cut_selection(), Slic3r::GUI::ObjectList::invalidate_cut_info_for_object(), is_cut(), Slic3r::GUI::ObjectList::part_selection_changed(), Slic3r::GUI::GLGizmoCut3D::perform_cut(), and serialize().

input_file

std::string Slic3r::ModelObject::input_file

Referenced by Slic3r::Model::add_object(), Slic3r::Model::add_object(), Slic3r::Print::apply(), Slic3r::SLAPrint::apply(), convert_units(), Slic3r::GUI::Selection::copy_to_clipboard(), Slic3r::load_step(), Slic3r::GUI::Selection::paste_volumes_from_clipboard(), Slic3r::GUI::Plater::priv::reload_from_disk(), and serialize().

instances

ModelInstancePtrs Slic3r::ModelObject::instances

Referenced by Slic3r::GUI::GLGizmoCut3D::PartSelection::PartSelection(), Slic3r::PrintObject::PrintObject(), Slic3r::_3MF_Exporter::_add_model_config_file_to_archive(), Slic3r::_3MF_Importer::_handle_end_model(), Slic3r::_3MF_Importer::_load_model_from_file(), add_instance(), add_instance(), Slic3r::GUI::MenuFactory::append_menu_item_printable(), Slic3r::Print::apply(), Slic3r::SLAPrint::apply(), assign_new_unique_ids_recursive(), Slic3r::GUI::GLGizmoFdmSupports::auto_generate(), bounding_box_approx(), bounding_box_exact(), Slic3r::GUI::GLGizmoCut3D::check_and_update_connectors_state(), Slic3r::check_model_ids_equal(), clear_instances(), Slic3r::GUI::Selection::copy_to_clipboard(), Slic3r::GUI::Plater::decrease_instances(), Slic3r::GUI::ObjectList::del_subobject_from_object(), delete_instance(), delete_last_instance(), delete_volume(), Slic3r::GUI::GLCanvas3D::do_mirror(), Slic3r::GUI::GLCanvas3D::do_move(), Slic3r::GUI::GLCanvas3D::do_reset_skew(), Slic3r::GUI::GLCanvas3D::do_rotate(), Slic3r::GUI::GLCanvas3D::do_scale(), Slic3r::GUI::Plater::export_stl_obj(), Slic3r::GUI::RotoptimizeJob::finalize(), Slic3r::GUI::FillBedJob::finalize(), Slic3r::GUI::GLGizmoCut3D::get_cut_matrix(), Slic3r::sla::RotfinderBoilerplate< MAX_ITER >::get_mesh_to_rotate(), Slic3r::GUI::GLGizmoHollow::gizmo_event(), Slic3r::GUI::GLGizmoPainterBase::gizmo_event(), Slic3r::GUI::GLGizmoSlaSupports::gizmo_event(), Slic3r::GUI::Plater::increase_instances(), instance_bounding_box(), Slic3r::GUI::ObjectList::instances_to_separated_object(), Slic3r::GUI::ObjectList::instances_to_separated_objects(), Slic3r::GUI::GLGizmoFlatten::is_plane_update_necessary(), Slic3r::GUI::ObjectList::load_mesh_object(), Slic3r::GUI::GLCanvas3D::load_object(), Slic3r::GLVolumeCollection::load_object_auxiliary(), Slic3r::GLVolumeCollection::load_object_volume(), Slic3r::GUI::GCodeViewer::load_shells(), Slic3r::GUI::ObjectList::merge(), mesh(), Slic3r::GUI::CommonGizmosDataObjects::SelectionInfo::model_instance(), Slic3r::GUI::Selection::paste_objects_from_clipboard(), Slic3r::GUI::Selection::paste_volumes_from_clipboard(), Slic3r::GUI::GLGizmoCut3D::perform_cut(), Slic3r::GUI::FillBedJob::prepare(), Slic3r::GUI::ArrangeJob::prepare_selected(), Slic3r::print_objects_from_model_object(), Slic3r::GUI::GLGizmoCut3D::process_selection_rectangle(), Slic3r::GUI::processed_objects_idxs(), Slic3r::GUI::GLGizmoCut3D::put_connectors_on_cut_plane(), raw_bounding_box(), Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::GUI::GLCanvas3D::Labels::render(), Slic3r::GUI::GLGizmoCut3D::render_connectors(), Slic3r::GUI::GLGizmoPainterBase::render_cursor(), Slic3r::GUI::CommonGizmosDataObjects::InstancesHider::render_cut(), Slic3r::GUI::CommonGizmosDataObjects::SupportsClipper::render_cut(), Slic3r::GUI::CommonGizmosDataObjects::ObjectClipper::render_cut(), Slic3r::GUI::GLGizmoFdmSupports::select_facets_by_angle(), serialize(), Slic3r::GUI::Plater::set_number_of_copies(), Slic3r::GUI::CommonGizmosDataObjects::ObjectClipper::set_position_by_ratio(), Slic3r::GUI::Sidebar::show_info_sizer(), Slic3r::sla_instances(), Slic3r::SLAPrint::sla_trafo(), split(), Slic3r::store_amf(), Slic3r::GUI::ObjectList::toggle_printable_state(), Slic3r::GUI::GLGizmoCut3D::unproject_on_cut_plane(), Slic3r::GUI::GLGizmoMeasure::update_if_needed(), Slic3r::GUI::GLCanvas3D::update_instance_printable_state_for_object(), update_min_max_z(), Slic3r::GUI::GLGizmoFlatten::update_planes(), Slic3r::GUI::ObjectList::update_printable_state(), Slic3r::GUI::GLGizmoCut3D::update_raycasters_for_picking_transform(), Slic3r::GUI::GLCanvas3D::update_sequential_clearance(), Slic3r::GUI::Selection::update_type(), and Slic3r::GUI::GLGizmoSlaBase::update_volumes().

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::GUI::ObjectList::add_layer_root_item(), Slic3r::Print::apply(), Slic3r::GUI::ObjectList::can_add_new_range_after_current(), 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::AMFParserContext::endElement(), Slic3r::GUI::ObjectList::layers_editing(), Slic3r::GUI::ObjectList::merge(), Slic3r::GUI::ObjectList::paste_layers_into_list(), serialize(), Slic3r::PrintObject::slicing_parameters(), and Slic3r::PrintObject::update_layer_height_profile().

layer_height_profile

LayerHeightProfile Slic3r::ModelObject::layer_height_profile

Referenced by ModelObject(), Slic3r::_3MF_Importer::_load_model_from_file(), Slic3r::Print::apply(), assign_new_unique_ids_recursive(), Slic3r::GUI::Selection::copy_to_clipboard(), Slic3r::AMFParserContext::endElement(), operator=(), serialize(), Slic3r::GUI::ObjectList::update_info_items(), and Slic3r::PrintObject::update_layer_height_profile().

m_bounding_box_approx

BoundingBoxf3 Slic3r::ModelObject::m_bounding_box_approx

mutableprivate

Referenced by bounding_box_approx(), copy_transformation_caches(), and serialize().

m_bounding_box_approx_valid

bool Slic3r::ModelObject::m_bounding_box_approx_valid { false }

mutableprivate

Referenced by bounding_box_approx(), copy_transformation_caches(), invalidate_bounding_box(), and serialize().

m_bounding_box_exact

BoundingBoxf3 Slic3r::ModelObject::m_bounding_box_exact

mutableprivate

Referenced by bounding_box_exact(), copy_transformation_caches(), max_z(), min_z(), serialize(), and update_min_max_z().

m_bounding_box_exact_valid

bool Slic3r::ModelObject::m_bounding_box_exact_valid { false }

mutableprivate

Referenced by bounding_box_exact(), copy_transformation_caches(), invalidate_bounding_box(), and serialize().

m_id

ObjectID Slic3r::ObjectBase::m_id

privateinherited

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

m_min_max_z_valid

bool Slic3r::ModelObject::m_min_max_z_valid { false }

mutableprivate

Referenced by bounding_box_exact(), copy_transformation_caches(), invalidate_bounding_box(), serialize(), and update_min_max_z().

m_model

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

private

Referenced by get_model(), get_model(), operator=(), operator=(), and set_model().

m_raw_bounding_box

BoundingBoxf3 Slic3r::ModelObject::m_raw_bounding_box

mutableprivate

Referenced by copy_transformation_caches(), raw_bounding_box(), and serialize().

m_raw_bounding_box_valid

bool Slic3r::ModelObject::m_raw_bounding_box_valid { false }

mutableprivate

Referenced by copy_transformation_caches(), invalidate_bounding_box(), raw_bounding_box(), and serialize().

m_raw_mesh_bounding_box

BoundingBoxf3 Slic3r::ModelObject::m_raw_mesh_bounding_box

mutableprivate

Referenced by copy_transformation_caches(), raw_mesh_bounding_box(), and serialize().

m_raw_mesh_bounding_box_valid

bool Slic3r::ModelObject::m_raw_mesh_bounding_box_valid { false }

mutableprivate

Referenced by copy_transformation_caches(), invalidate_bounding_box(), raw_mesh_bounding_box(), and serialize().

name

std::string Slic3r::ModelObject::name

Referenced by Slic3r::_3MF_Exporter::_add_model_config_file_to_archive(), Slic3r::_3MF_Importer::_handle_start_object(), Slic3r::_3MF_Importer::_load_model_from_file(), Slic3r::Model::add_object(), Slic3r::Model::add_object(), Slic3r::GUI::ObjectList::add_volumes_to_object_in_list(), Slic3r::Print::apply(), Slic3r::SLAPrint::apply(), Slic3r::GUI::Selection::copy_to_clipboard(), Slic3r::GUI::ObjectList::del_subobject_from_object(), Slic3r::GUI::Plater::priv::delete_object_from_model(), Slic3r::AMFParserContext::endElement(), Slic3r::GUI::ObjectList::load_mesh_object(), Slic3r::load_step(), Slic3r::GUI::ObjectList::merge(), Slic3r::GUI::GLGizmoCut3D::perform_cut(), Slic3r::GCode::process_layer_single_object(), Slic3r::GUI::GLCanvas3D::Labels::render(), Slic3r::GUI::Plater::priv::replace_volume_with_stl(), serialize(), Slic3r::SLAPrint::Steps::slice_model(), split(), Slic3r::AMFParserContext::startElement(), Slic3r::store_amf(), Slic3r::GUI::ObjectList::update_name_in_list(), and Slic3r::Print::validate().

origin_translation

Vec3d Slic3r::ModelObject::origin_translation

Referenced by Slic3r::Print::apply(), Slic3r::GUI::Selection::copy_to_clipboard(), Slic3r::GUI::Plater::export_stl_obj(), Slic3r::GUI::ObjectList::load_mesh_object(), Slic3r::GUI::ObjectList::load_modifier(), Slic3r::GUI::ObjectList::merge(), and serialize().

printable

bool Slic3r::ModelObject::printable { true }

Referenced by serialize().

s_last_id

size_t Slic3r::ObjectBase::s_last_id = 0

staticprivateinherited

Referenced by Slic3r::ObjectBase::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(), Slic3r::GUI::GLGizmoHollow::delete_selected_points(), Slic3r::SLAPrint::Steps::generate_preview(), Slic3r::GUI::GLGizmoHollow::gizmo_event(), has_sla_drain_holes(), Slic3r::GUI::GLGizmoHollow::on_dragging(), Slic3r::GUI::GLGizmoHollow::on_render_input_window(), Slic3r::GUI::GLGizmoHollow::on_set_hover_id(), Slic3r::GUI::GLGizmoHollow::on_start_dragging(), Slic3r::GUI::GLGizmoHollow::on_stop_dragging(), Slic3r::GUI::GLGizmoHollow::register_hole_raycasters_for_picking(), Slic3r::GUI::GLGizmoHollow::reload_cache(), Slic3r::GUI::GLGizmoHollow::render_points(), Slic3r::sla::reproject_points_and_holes(), Slic3r::GUI::GLGizmoHollow::select_point(), serialize(), Slic3r::sla::transformed_drainhole_points(), and Slic3r::GUI::GLGizmoHollow::update_hole_raycasters_for_picking_transform().

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(), Slic3r::GUI::GLGizmoSlaSupports::auto_generate(), convert_units(), Slic3r::GUI::Selection::copy_to_clipboard(), Slic3r::GUI::GLGizmoSlaSupports::data_changed(), Slic3r::GUI::GLGizmoSlaSupports::editing_mode_apply_changes(), Slic3r::AMFParserContext::endElement(), Slic3r::GUI::GLGizmoSlaSupports::get_data_from_backend(), Slic3r::GUI::GLGizmoSlaSupports::reload_cache(), Slic3r::GUI::GLCanvas3D::reload_scene(), serialize(), Slic3r::SLAPrint::Steps::support_points(), Slic3r::GUI::GLGizmoSlaBase::update_volumes(), 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(), Slic3r::GUI::GLGizmoSlaSupports::editing_mode_apply_changes(), Slic3r::AMFParserContext::endElement(), Slic3r::GUI::GLGizmoSlaSupports::reload_cache(), Slic3r::sla::reproject_points_and_holes(), serialize(), Slic3r::SLAPrint::Steps::support_points(), Slic3r::sla::transformed_support_points(), and Slic3r::SLAPrint::validate().

volumes

ModelVolumePtrs Slic3r::ModelObject::volumes

Referenced by Slic3r::GUI::GLGizmoCut3D::PartSelection::PartSelection(), Slic3r::_3MF_Importer::_load_model_from_file(), Slic3r::GUI::RaycastManager::actualize(), Slic3r::Model::add_object(), Slic3r::Model::add_object(), add_volume(), add_volume(), add_volume(), add_volume(), Slic3r::GUI::ObjectList::add_volumes_to_object_in_list(), Slic3r::GUI::MenuFactory::append_menu_items_convert_unit(), Slic3r::Print::apply(), Slic3r::GUI::GLGizmoFdmSupports::apply_data_from_backend(), assign_new_unique_ids_recursive(), Slic3r::Print::auto_assign_extruders(), Slic3r::GUI::GLGizmoFdmSupports::auto_generate(), Slic3r::GUI::ObjectList::change_part_type(), Slic3r::check_model_ids_equal(), Slic3r::GUI::Plater::clear_before_change_mesh(), clear_volumes(), Slic3r::SeamPlacerImpl::compute_global_occlusion(), convex_hull_2d(), Slic3r::GUI::Selection::copy_to_clipboard(), Slic3r::GUI::Emboss::create_volume_sources(), Slic3r::GUI::GLGizmoPainterBase::data_changed(), Slic3r::GUI::ObjectList::del_subobject_from_object(), Slic3r::GUI::ObjectList::delete_from_model_and_list(), delete_volume(), Slic3r::GUI::GLCanvas3D::do_mirror(), Slic3r::GUI::GLCanvas3D::do_move(), Slic3r::GUI::GLCanvas3D::do_reset_skew(), Slic3r::GUI::GLCanvas3D::do_rotate(), Slic3r::GUI::GLCanvas3D::do_scale(), Slic3r::GUI::GLGizmoEmboss::draw_advanced(), Slic3r::GUI::GLGizmoEmboss::draw_window(), Slic3r::GUI::Plater::export_stl_obj(), Slic3r::GUI::ObjectList::fix_through_netfabb(), full_raw_mesh_bounding_box(), Slic3r::SeamPlacerImpl::gather_enforcers_blockers(), Slic3r::GUI::get_extruder_id_for_volumes(), Slic3r::GUI::ObjectList::get_mesh_errors_info(), Slic3r::GUI::GLGizmoEmboss::get_minimal_window_size(), Slic3r::GUI::get_model_volume(), Slic3r::GUI::get_volume(), Slic3r::GUI::get_volume_ids(), Slic3r::GUI::GLGizmoPainterBase::gizmo_event(), Slic3r::GUI::GLGizmoSimplify::init_model(), Slic3r::GUI::GLGizmoMmuSegmentation::init_model_triangle_selectors(), instance_bounding_box(), is_fdm_support_painted(), is_mm_painted(), is_multiparts(), Slic3r::GUI::GLGizmoFlatten::is_plane_update_necessary(), is_seam_painted(), Slic3r::GUI::ObjectList::is_splittable(), is_text(), Slic3r::GUI::ObjectList::load_modifier(), Slic3r::GLVolumeCollection::load_object(), Slic3r::GLVolumeCollection::load_object_volume(), Slic3r::load_step(), Slic3r::GUI::ObjectList::merge(), Slic3r::mmu_segmentation_top_and_bottom_layers(), Slic3r::model_property_changed(), Slic3r::csg::model_to_csgmesh(), Slic3r::model_volume_list_changed(), Slic3r::model_volume_list_copy_configs(), Slic3r::multi_material_segmentation_by_painting(), Slic3r::GUI::GLCanvas3D::on_mouse(), Slic3r::GUI::GLGizmoSimplify::on_render(), Slic3r::GUI::GLGizmoFdmSupports::on_render_input_window(), Slic3r::GUI::GLGizmoMmuSegmentation::on_render_input_window(), Slic3r::GUI::GLGizmoSeam::on_render_input_window(), Slic3r::GUI::CommonGizmosDataObjects::InstancesHider::on_update(), Slic3r::GUI::CommonGizmosDataObjects::Raycaster::on_update(), Slic3r::GUI::CommonGizmosDataObjects::ObjectClipper::on_update(), Slic3r::GUI::Selection::paste_volumes_from_clipboard(), Slic3r::GUI::GLGizmoCut3D::perform_cut(), Slic3r::GUI::GLGizmoEmboss::process(), raw_bounding_box(), raw_indexed_triangle_set(), raw_mesh(), raw_mesh_bounding_box(), Slic3r::GUI::Plater::priv::reload_from_disk(), Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::GUI::reloadable_volumes(), Slic3r::GUI::GLGizmoPainterBase::render_cursor(), Slic3r::GUI::CommonGizmosDataObjects::InstancesHider::render_cut(), Slic3r::GUI::Plater::priv::replace_volume_with_stl(), Slic3r::GUI::GLGizmoFdmSupports::select_facets_by_angle(), serialize(), Slic3r::GUI::GLGizmoEmboss::set_volume_by_selection(), Slic3r::GUI::ObjectList::show_context_menu(), Slic3r::GUI::Sidebar::show_info_sizer(), Slic3r::PrintObject::slicing_parameters(), sort_volumes(), Slic3r::ModelVolume::split(), Slic3r::GUI::Plater::priv::split_object(), priv::start_create_volume_job(), priv::start_create_volume_on_surface_job(), Slic3r::SLAPrint::Steps::support_points(), Slic3r::GLVolume::NonManifoldEdges::update(), Slic3r::GUI::ObjectList::update_extruder_values_for_items(), Slic3r::GUI::GLGizmoFdmSupports::update_from_model_object(), Slic3r::GUI::GLGizmoSeam::update_from_model_object(), Slic3r::GUI::GLGizmoMeasure::update_if_needed(), Slic3r::GUI::ObjectList::update_info_items(), update_min_max_z(), Slic3r::GUI::GLGizmoFdmSupports::update_model_object(), Slic3r::GUI::GLGizmoMmuSegmentation::update_model_object(), Slic3r::GUI::GLGizmoSeam::update_model_object(), Slic3r::GUI::ObjectList::update_name_in_list(), Slic3r::GUI::GLGizmoFlatten::update_planes(), Slic3r::GUI::ObjectList::update_selections_on_canvas(), Slic3r::GUI::Selection::update_type(), anonymous_namespace{EmbossJob.cpp}::update_volume_name(), and Slic3r::GUI::GLGizmoSlaBase::update_volumes().

---

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

• src/libslic3r/Model.hpp
• src/libslic3r/Model.cpp