Slic3r::Model Class Reference

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

Inheritance diagram for Slic3r::Model:

Collaboration diagram for Slic3r::Model:

Public Types
using	Timestamp = uint64_t

Public Member Functions
void	SetDesigner (std::string designer, std::string designer_user_id)
const CustomGCode::Info	get_curr_plate_custom_gcodes () const
	Model ()
	~Model ()
	Model (const Model &rhs)
	Model (Model &&rhs)
Model &	operator= (const Model &rhs)
Model &	operator= (Model &&rhs)
ModelObject *	add_object ()
ModelObject *	add_object (const char *name, const char *path, const TriangleMesh &mesh)
ModelObject *	add_object (const char *name, const char *path, TriangleMesh &&mesh)
ModelObject *	add_object (const ModelObject &other)
void	delete_object (size_t idx)
bool	delete_object (ObjectID id)
bool	delete_object (ModelObject *object)
void	clear_objects ()
void	collect_reusable_objects (std::vector< ObjectBase * > &objects)
void	set_object_backup_id (ModelObject const &object, int uuid)
int	get_object_backup_id (ModelObject const &object)
int	get_object_backup_id (ModelObject const &object) const
ModelMaterial *	add_material (t_model_material_id material_id)
ModelMaterial *	add_material (t_model_material_id material_id, const ModelMaterial &other)
ModelMaterial *	get_material (t_model_material_id material_id)
void	delete_material (t_model_material_id material_id)
void	clear_materials ()
bool	add_default_instances ()
BoundingBoxf3	bounding_box_approx () const
BoundingBoxf3	bounding_box_exact () const
double	max_z () const
unsigned int	update_print_volume_state (const BuildVolume &build_volume)
bool	center_instances_around_point (const Vec2d &point)
void	translate (coordf_t x, coordf_t y, coordf_t z)
TriangleMesh	mesh () const
void	duplicate_objects_grid (size_t x, size_t y, coordf_t dist)
bool	looks_like_multipart_object () const
void	convert_multipart_object (unsigned int max_extruders)
bool	looks_like_imperial_units () const
void	convert_from_imperial_units (bool only_small_volumes)
bool	looks_like_saved_in_meters () const
void	convert_from_meters (bool only_small_volumes)
int	removed_objects_with_zero_volume ()
void	adjust_min_z ()
void	print_info () const
std::string	propose_export_file_name_and_path () const
std::string	propose_export_file_name_and_path (const std::string &new_extension) const
std::string	get_auxiliary_file_temp_path ()
std::string	get_backup_path ()
std::string	get_backup_path (const std::string &sub_path)
void	set_backup_path (const std::string &path)
void	load_from (Model &model)
bool	is_need_backup ()
void	set_need_backup ()
void	remove_backup_path_if_exist ()
bool	is_fdm_support_painted () const
bool	is_seam_painted () const
bool	is_mm_painted () const
bool	is_fuzzy_skin_painted () const
ObjectID	id () const
virtual Timestamp	timestamp () const

Static Public Member Functions
static Model	read_from_step (const std::string &input_file, LoadStrategy options, ImportStepProgressFn stepFn, StepIsUtf8Fn stepIsUtf8Fn, std::function< int(Slic3r::Step &, double &, double &, bool &)> step_mesh_fn, double linear_deflection, double angle_deflection, bool is_split_compound)
static Model	read_from_file (const std::string &input_file, DynamicPrintConfig *config=nullptr, ConfigSubstitutionContext *config_substitutions=nullptr, LoadStrategy options=LoadStrategy::AddDefaultInstances, PlateDataPtrs *plate_data=nullptr, std::vector< Preset * > *project_presets=nullptr, bool *is_xxx=nullptr, Semver *file_version=nullptr, Import3mfProgressFn proFn=nullptr, ImportstlProgressFn stlFn=nullptr, BBLProject *project=nullptr, int plate_id=0)
static bool	obj_import_vertex_color_deal (const std::vector< unsigned char > &vertex_filament_ids, const unsigned char &first_extruder_id, Model *model)
static bool	obj_import_face_color_deal (const std::vector< unsigned char > &face_filament_ids, const unsigned char &first_extruder_id, Model *model)
static double	findMaxSpeed (const ModelObject *object)
static double	getThermalLength (const ModelVolume *modelVolumePtr)
static double	getThermalLength (const std::vector< ModelVolume * > modelVolumePtrs)
static Polygon	getBedPolygon ()
static void	setPrintSpeedTable (const DynamicPrintConfig &config, const PrintConfig &print_config)
static void	setExtruderParams (const DynamicPrintConfig &config, int extruders_count)
static Model	read_from_archive (const std::string &input_file, DynamicPrintConfig *config, ConfigSubstitutionContext *config_substitutions, En3mfType &out_file_type, LoadStrategy options=LoadStrategy::AddDefaultInstances, PlateDataPtrs *plate_data=nullptr, std::vector< Preset * > *project_presets=nullptr, Semver *file_version=nullptr, Import3mfProgressFn proFn=nullptr, BBLProject *project=nullptr)

Public Attributes
ModelMaterialMap	materials
ModelObjectPtrs	objects
ModelWipeTower	wipe_tower
std::string	stl_design_id
std::string	stl_design_country
std::shared_ptr< ModelDesignInfo >	design_info = nullptr
std::shared_ptr< ModelInfo >	model_info = nullptr
std::shared_ptr< ModelProfileInfo >	profile_info = nullptr
std::shared_ptr< TexturedMesh >	texture_mesh
std::string	mk_name
std::string	mk_version
std::vector< std::string >	md_name
std::vector< std::string >	md_value
std::string	cad_recipe
int	curr_plate_index { 0 }
std::map< int, CustomGCode::Info >	plates_custom_gcodes
std::unique_ptr< CalibPressureAdvancePattern >	calib_pa_pattern

Static Public Attributes
static std::map< size_t, ExtruderParams >	extruderParamsMap = { {0,{"",0,0}}}
static GlobalSpeedMap	printSpeedMap {}

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

Private Member Functions
	Model (int)
void	assign_new_unique_ids_recursive ()
void	update_links_bottom_up_recursive ()
template<class Archive>
void	load (Archive &ar)
template<class Archive>
void	save (Archive &ar) const
template<class Archive>
void	serialize (Archive &ar)

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

Private Attributes
std::string	backup_path
bool	need_backup = false
std::map< int, int >	object_backup_id_map
int	next_object_backup_id = 1
ObjectID	m_id

Static Private Attributes
static size_t	s_last_id = 0

Friends
class	cereal::access
class	UndoRedo::StackImpl

Detailed Description

Member Typedef Documentation

Timestamp

using Slic3r::ObjectBase::Timestamp = uint64_t

inherited

Constructor & Destructor Documentation

Model() [1/4]

Slic3r::Model::Model ( )

inline

{ assert(this->id().valid()); }

Referenced by Model(), Model(), load_from(), obj_import_face_color_deal(), obj_import_vertex_color_deal(), operator=(), operator=(), read_from_archive(), read_from_file(), and read_from_step().

Here is the caller graph for this function:

~Model()

Slic3r::Model::~Model

(

)

{
    this->clear_objects();
    this->clear_materials();
    // BBS: clear backup dir of temparary model
    if (!backup_path.empty())
        Slic3r::remove_backup(*this, true);
}

References backup_path, clear_materials(), clear_objects(), and Slic3r::remove_backup().

Here is the call graph for this function:

Model() [2/4]

Slic3r::Model::Model ( const Model & rhs )

inline

: ObjectBase(-1) { assert(this->id().invalid()); this->assign_copy(rhs); assert(this->id().valid()); assert(this->id() == rhs.id()); }

References Model(), Slic3r::ObjectBase::ObjectBase(), and Slic3r::ObjectBase::id().

Here is the call graph for this function:

Model() [3/4]

Slic3r::Model::Model ( Model && rhs )

inline

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

References Model(), and Slic3r::ObjectBase::ObjectBase().

Here is the call graph for this function:

Model() [4/4]

Slic3r::Model::Model ( int )

inlineexplicitprivate

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

References Slic3r::ObjectBase::ObjectBase().

Here is the call graph for this function:

Member Function Documentation

add_default_instances()

bool Slic3r::Model::add_default_instances

(

)

{
    // apply a default position to all objects not having one
    for (ModelObject *o : this->objects)
        if (o->instances.empty())
            o->add_instance();
    return true;
}

References add_default_instances().

Referenced by add_default_instances(), Slic3r::GUI::ObjectList::load_modifier(), read_from_archive(), read_from_step(), Slic3r::GUI::read_model_from_file(), and Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

add_material() [1/2]

ModelMaterial * Slic3r::Model::add_material

(

t_model_material_id

material_id

)

{
    assert(! material_id.empty());
    ModelMaterial* material = this->get_material(material_id);
    if (material == nullptr)
        material = this->materials[material_id] = new ModelMaterial(this);
    return material;
}

References add_material(), and get_material().

Referenced by add_material(), and add_material().

Here is the call graph for this function:

Here is the caller graph for this function:

add_material() [2/2]

ModelMaterial * Slic3r::Model::add_material	(	t_model_material_id	material_id,
		const ModelMaterial &	other )

{
    assert(! material_id.empty());
    // delete existing material if any
    ModelMaterial* material = this->get_material(material_id);
    delete material;
    // set new material
  material = new ModelMaterial(other);
  material->set_model(this);
    this->materials[material_id] = material;
    return material;
}

References add_material(), get_material(), and Slic3r::ModelMaterial::set_model().

Here is the call graph for this function:

add_object() [1/4]

ModelObject * Slic3r::Model::add_object

(

)

{
    this->objects.emplace_back(new ModelObject(this));
    return this->objects.back();
}

References add_object().

Referenced by Slic3r::GUI::Plater::_calib_pa_pattern(), Slic3r::_3MF_Importer::_load_model_from_file(), add_object(), add_object(), add_object(), add_object(), Slic3r::add_textured_mesh_to_model(), construct_assemble_list(), Slic3r::GUI::cut_model(), Slic3r::GUI::ensure_belt_purge_tower(), anonymous_namespace{EmbossJob.cpp}::CreateObjectJob::finalize(), Slic3r::GUI::ObjectList::instances_to_separated_object(), Slic3r::GUI::ObjectList::instances_to_separated_objects(), Slic3r::load_drc(), Slic3r::GUI::ObjectList::load_mesh_object(), Slic3r::load_obj(), Slic3r::load_stl(), Slic3r::load_svg(), Slic3r::GUI::ObjectList::merge(), merge_or_add_object(), Slic3r::Step::mesh(), Slic3r::Cut::perform_with_groove(), Slic3r::CLI::run(), and anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_two_color_cube_and_export().

Here is the call graph for this function:

Here is the caller graph for this function:

add_object() [2/4]

ModelObject * Slic3r::Model::add_object	(	const char *	name,
		const char *	path,
		const TriangleMesh &	mesh )

{
    ModelObject* new_object = new ModelObject(this);
    this->objects.push_back(new_object);
    new_object->name = name;
    new_object->input_file = path;
    ModelVolume *new_volume = new_object->add_volume(mesh);
    new_volume->name = name;
    new_volume->source.input_file = path;
    new_volume->source.object_idx = (int)this->objects.size() - 1;
    new_volume->source.volume_idx = (int)new_object->volumes.size() - 1;
    // BBS: set extruder id to 1
    if (!new_object->config.has("extruder") || new_object->config.extruder() == 0)
        new_object->config.set_key_value("extruder", new ConfigOptionInt(1));
    new_object->invalidate_bounding_box();
    return new_object;
}

References add_object(), Slic3r::ModelObject::add_volume(), Slic3r::ModelObject::config, Slic3r::ModelConfig::extruder(), Slic3r::ModelConfig::has(), Slic3r::ModelObject::input_file, Slic3r::ModelVolume::Source::input_file, Slic3r::ModelObject::invalidate_bounding_box(), mesh(), Slic3r::ModelObject::name, Slic3r::ModelVolume::name, Slic3r::ModelVolume::Source::object_idx, Slic3r::ModelConfig::set_key_value(), Slic3r::ModelVolume::source, Slic3r::ModelVolume::Source::volume_idx, and Slic3r::ModelObject::volumes.

Here is the call graph for this function:

add_object() [3/4]

ModelObject * Slic3r::Model::add_object	(	const char *	name,
		const char *	path,
		TriangleMesh &&	mesh )

{
    ModelObject* new_object = new ModelObject(this);
    this->objects.push_back(new_object);
    new_object->name = name;
    new_object->input_file = path;
    ModelVolume *new_volume = new_object->add_volume(std::move(mesh));
    new_volume->name = name;
    new_volume->source.input_file = path;
    new_volume->source.object_idx = (int)this->objects.size() - 1;
    new_volume->source.volume_idx = (int)new_object->volumes.size() - 1;
    // BBS: set default extruder id to 1
    if (!new_object->config.has("extruder") || new_object->config.extruder() == 0)
        new_object->config.set_key_value("extruder", new ConfigOptionInt(1));
    new_object->invalidate_bounding_box();
    return new_object;
}

References add_object(), Slic3r::ModelObject::add_volume(), Slic3r::ModelObject::config, Slic3r::ModelConfig::extruder(), Slic3r::ModelConfig::has(), Slic3r::ModelObject::input_file, Slic3r::ModelVolume::Source::input_file, Slic3r::ModelObject::invalidate_bounding_box(), mesh(), Slic3r::ModelObject::name, Slic3r::ModelVolume::name, Slic3r::ModelVolume::Source::object_idx, Slic3r::ModelConfig::set_key_value(), Slic3r::ModelVolume::source, Slic3r::ModelVolume::Source::volume_idx, and Slic3r::ModelObject::volumes.

Here is the call graph for this function:

add_object() [4/4]

ModelObject * Slic3r::Model::add_object

(

const ModelObject &

other

)

{
  ModelObject* new_object = ModelObject::new_clone(other);
    new_object->set_model(this);
    // BBS: set default extruder id to 1
    if (!new_object->config.has("extruder") || new_object->config.extruder() == 0)
        new_object->config.set_key_value("extruder", new ConfigOptionInt(1));
    this->objects.push_back(new_object);
    // BBS: backup
    if (need_backup) {
        if (auto model = other.get_model()) {
            auto iter = object_backup_id_map.find(other.id().id);
            if (iter != object_backup_id_map.end()) {
                object_backup_id_map.emplace(new_object->id().id, iter->second);
                object_backup_id_map.erase(iter);
                return new_object;
            }
        }
        Slic3r::save_object_mesh(*new_object);
    }
    return new_object;
}

References add_object(), Slic3r::ModelObject::config, Slic3r::ModelConfig::extruder(), Slic3r::ModelObject::get_model(), Slic3r::ModelConfig::has(), Slic3r::ObjectBase::id(), Slic3r::ObjectID::id, need_backup, object_backup_id_map, Slic3r::save_object_mesh(), Slic3r::ModelConfig::set_key_value(), and Slic3r::ModelObject::set_model().

Here is the call graph for this function:

adjust_min_z()

void Slic3r::Model::adjust_min_z

(

)

{
    if (objects.empty())
        return;
 
    if (this->bounding_box_exact().min.z() < 0.0)
    {
        for (ModelObject* obj : objects)
        {
            if (obj != nullptr)
            {
                coordf_t obj_min_z = obj->min_z();
                if (obj_min_z < 0.0)
                    obj->translate_instances(Vec3d(0.0, 0.0, -obj_min_z));
            }
        }
    }
}

References adjust_min_z(), bounding_box_exact(), and objects.

Referenced by adjust_min_z().

Here is the call graph for this function:

Here is the caller graph for this function:

assign_new_unique_ids_recursive()

void Slic3r::Model::assign_new_unique_ids_recursive ( )

privatevirtual

Reimplemented from Slic3r::ObjectBase.

{
    this->set_new_unique_id();
    for (std::pair<const t_model_material_id, ModelMaterial*> &m : this->materials)
        m.second->assign_new_unique_ids_recursive();
    for (ModelObject *model_object : this->objects)
        model_object->assign_new_unique_ids_recursive();
}

References Slic3r::ObjectBase::set_new_unique_id().

Here is the call graph for this function:

bounding_box_approx()

BoundingBoxf3 Slic3r::Model::bounding_box_approx

(

)

const

{
    BoundingBoxf3 bb;
    for (ModelObject *o : this->objects)
        bb.merge(o->bounding_box_approx());
    return bb;
}

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

Referenced by bounding_box_approx().

Here is the call graph for this function:

Here is the caller graph for this function:

bounding_box_exact()

BoundingBoxf3 Slic3r::Model::bounding_box_exact

(

)

const

{
    BoundingBoxf3 bb;
    for (ModelObject *o : this->objects)
        bb.merge(o->bounding_box_exact());
    return bb;
}

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

Referenced by adjust_min_z(), bounding_box_exact(), and Slic3r::GUI::CalibUtils::process_and_store_3mf().

Here is the call graph for this function:

Here is the caller graph for this function:

center_instances_around_point()

bool Slic3r::Model::center_instances_around_point

(

const Vec2d &

point

)

{
    BoundingBoxf3 bb;
    for (ModelObject *o : this->objects)
        for (size_t i = 0; i < o->instances.size(); ++ i)
            bb.merge(o->instance_bounding_box(i, false));
 
    Vec2d shift2 = point - to_2d(bb.center());
  if (std::abs(shift2(0)) < EPSILON && std::abs(shift2(1)) < EPSILON)
    // No significant shift, don't do anything.
    return false;
 
  Vec3d shift3 = Vec3d(shift2(0), shift2(1), 0.0);
  for (ModelObject *o : this->objects) {
    for (ModelInstance *i : o->instances)
      i->set_offset(i->get_offset() + shift3);
    o->invalidate_bounding_box();
  }
  return true;
}

References Slic3r::BoundingBox3Base< PointType >::center(), center_instances_around_point(), EPSILON, Slic3r::ModelInstance::get_offset(), Slic3r::BoundingBox3Base< PointType >::merge(), Slic3r::ModelInstance::set_offset(), and Slic3r::to_2d().

Referenced by center_instances_around_point(), and Slic3r::GUI::ObjectList::load_modifier().

Here is the call graph for this function:

Here is the caller graph for this function:

clear_materials()

void Slic3r::Model::clear_materials

(

)

{
    for (auto &m : this->materials)
        delete m.second;
    this->materials.clear();
}

References clear_materials().

Referenced by ~Model(), clear_materials(), construct_assemble_list(), Slic3r::UndoRedo::StackImpl::load_snapshot(), and Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

clear_objects()

void Slic3r::Model::clear_objects

(

)

{
    for (ModelObject* o : this->objects) {
        // BBS: backup
        Slic3r::delete_object_mesh(*o);
        delete o;
    }
    this->objects.clear();
    object_backup_id_map.clear();
    next_object_backup_id = 1;
    texture_mesh.reset();
}

References clear_objects(), Slic3r::delete_object_mesh(), next_object_backup_id, object_backup_id_map, and texture_mesh.

Referenced by ~Model(), clear_objects(), construct_assemble_list(), convert_multipart_object(), and Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

collect_reusable_objects()

void Slic3r::Model::collect_reusable_objects

(

std::vector< ObjectBase * > &

objects

)

{
    for (ModelObject* model_object : this->objects) {
        objects.push_back(model_object);
        for (ModelVolume* model_volume : model_object->volumes)
            objects.push_back(model_volume);
        std::transform(model_object->volumes.begin(),
                       model_object->volumes.end(),
                       std::back_inserter(model_object->volume_ids),
                       std::mem_fn(&ObjectBase::id));
        model_object->volumes.clear();
    }
    // we never own these objects
    this->objects.clear();
}

References collect_reusable_objects(), Slic3r::ObjectBase::id(), and objects.

Referenced by collect_reusable_objects(), and Slic3r::UndoRedo::StackImpl::load_snapshot().

Here is the call graph for this function:

Here is the caller graph for this function:

convert_from_imperial_units()

void Slic3r::Model::convert_from_imperial_units

(

bool

only_small_volumes

)

{
    static constexpr const float in_to_mm = 25.4f;
    for (ModelObject* obj : this->objects)
        if (! only_small_volumes || obj->get_object_stl_stats().volume < volume_threshold_inches) {
            obj->scale_mesh_after_creation(in_to_mm);
            for (ModelVolume* v : obj->volumes) {
                assert(! v->source.is_converted_from_meters);
                v->source.is_converted_from_inches = true;
            }
        }
}

References convert_from_imperial_units(), Slic3r::ModelVolume::Source::is_converted_from_inches, Slic3r::ModelVolume::Source::is_converted_from_meters, Slic3r::ModelVolume::source, and Slic3r::volume_threshold_inches.

Referenced by convert_from_imperial_units().

Here is the call graph for this function:

Here is the caller graph for this function:

convert_from_meters()

void Slic3r::Model::convert_from_meters

(

bool

only_small_volumes

)

{
    static constexpr const double m_to_mm = 1000;
    for (ModelObject* obj : this->objects)
        if (! only_small_volumes || obj->get_object_stl_stats().volume < volume_threshold_meters) {
            obj->scale_mesh_after_creation(m_to_mm);
            for (ModelVolume* v : obj->volumes) {
                assert(! v->source.is_converted_from_inches);
                v->source.is_converted_from_meters = true;
            }
        }
}

References convert_from_meters(), Slic3r::ModelVolume::Source::is_converted_from_inches, Slic3r::ModelVolume::Source::is_converted_from_meters, Slic3r::ModelVolume::source, and Slic3r::volume_threshold_meters.

Referenced by convert_from_meters().

Here is the call graph for this function:

Here is the caller graph for this function:

convert_multipart_object()

void Slic3r::Model::convert_multipart_object

(

unsigned int

max_extruders

)

{
    assert(this->objects.size() >= 2);
    if (this->objects.size() < 2)
        return;
 
    ModelObject* object = new ModelObject(this);
    object->input_file = this->objects.front()->input_file;
    object->name = boost::filesystem::path(this->objects.front()->input_file).stem().string();
    //FIXME copy the config etc?
 
    unsigned int extruder_counter = 0;
 
  for (const ModelObject* o : this->objects)
      for (const ModelVolume* v : o->volumes) {
            // If there are more than one object, put all volumes together
            // Each object may contain any number of volumes and instances
            // The volumes transformations are relative to the object containing them...
            Geometry::Transformation trafo_volume = v->get_transformation();
            // Revert the centering operation.
            trafo_volume.set_offset(trafo_volume.get_offset() - o->origin_translation);
            int counter = 1;
            auto copy_volume = [o, v, &counter](ModelVolume *new_v) {
                assert(new_v != nullptr);
                new_v->name = (counter > 1) ? o->name + "_" + std::to_string(counter++) : o->name;
                //BBS: Use extruder priority: volumn > object > default
                if (v->config.option("extruder"))
                    new_v->config.set("extruder", v->config.extruder());
                else if (o->config.option("extruder"))
                    new_v->config.set("extruder", o->config.extruder());
 
                return new_v;
            };
            if (o->instances.empty()) {
                copy_volume(object->add_volume(*v))->set_transformation(trafo_volume);
            } else {
                for (const ModelInstance* i : o->instances)
                    // ...so, transform everything to a common reference system (world)
                    copy_volume(object->add_volume(*v))->set_transformation(i->get_transformation() * trafo_volume);
            }
        }
 
    // commented-out to fix #2868
//    object->add_instance();
//    object->instances[0]->set_offset(object->raw_mesh_bounding_box().center());
 
    this->clear_objects();
    this->objects.push_back(object);
}

References Slic3r::ModelObject::add_volume(), clear_objects(), convert_multipart_object(), Slic3r::Geometry::Transformation::get_offset(), Slic3r::ModelInstance::get_transformation(), Slic3r::ModelVolume::get_transformation(), and Slic3r::Geometry::Transformation::set_offset().

Referenced by convert_multipart_object().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_id()

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

inlineprotectedinherited

{ m_id = rhs.id(); }

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

delete_material()

void Slic3r::Model::delete_material

(

t_model_material_id

material_id

)

{
    ModelMaterialMap::iterator i = this->materials.find(material_id);
    if (i != this->materials.end()) {
        delete i->second;
        this->materials.erase(i);
    }
}

References delete_material().

Referenced by delete_material().

Here is the call graph for this function:

Here is the caller graph for this function:

delete_object() [1/3]

bool Slic3r::Model::delete_object

(

ModelObject *

object

)

{
    if (object != nullptr) {
        size_t idx = 0;
        for (ModelObject *model_object : objects) {
            if (model_object == object) {
                // BBS: backup
                Slic3r::delete_object_mesh(*model_object);
                delete model_object;
                objects.erase(objects.begin() + idx);
                return true;
            }
            ++ idx;
        }
    }
    return false;
}

References delete_object(), Slic3r::delete_object_mesh(), and objects.

Here is the call graph for this function:

delete_object() [2/3]

bool Slic3r::Model::delete_object

(

ObjectID

id

)

{
    if (id.id != 0) {
        size_t idx = 0;
        for (ModelObject *model_object : objects) {
            if (model_object->id() == id) {
                // BBS: backup
                Slic3r::delete_object_mesh(*model_object);
                delete model_object;
                objects.erase(objects.begin() + idx);
                return true;
            }
            ++ idx;
        }
    }
    return false;
}

References delete_object(), Slic3r::delete_object_mesh(), and objects.

Here is the call graph for this function:

delete_object() [3/3]

void Slic3r::Model::delete_object

(

size_t

idx

)

{
    ModelObjectPtrs::iterator i = this->objects.begin() + idx;
    // BBS: backup
    Slic3r::delete_object_mesh(**i);
    delete *i;
    this->objects.erase(i);
}

References delete_object(), and Slic3r::delete_object_mesh().

Referenced by Slic3r::GUI::Plater::apply_cut_object_to_model(), Slic3r::GUI::cut_model(), Slic3r::GUI::ObjectList::delete_all_connectors_for_object(), delete_object(), delete_object(), delete_object(), Slic3r::GUI::ensure_belt_purge_tower(), and removed_objects_with_zero_volume().

Here is the call graph for this function:

Here is the caller graph for this function:

duplicate_objects_grid()

void Slic3r::Model::duplicate_objects_grid	(	size_t	x,
		size_t	y,
		coordf_t	dist )

{
    if (this->objects.size() > 1) throw "Grid duplication is not supported with multiple objects";
    if (this->objects.empty()) throw "No objects!";
 
    ModelObject* object = this->objects.front();
    object->clear_instances();
 
    Vec3d ext_size = object->bounding_box_exact().size() + dist * Vec3d::Ones();
 
    for (size_t x_copy = 1; x_copy <= x; ++x_copy) {
        for (size_t y_copy = 1; y_copy <= y; ++y_copy) {
            ModelInstance* instance = object->add_instance();
            instance->set_offset(Vec3d(ext_size(0) * (double)(x_copy - 1), ext_size(1) * (double)(y_copy - 1), 0.0));
        }
    }
}

References Slic3r::ModelObject::clear_instances(), Slic3r::Geometry::dist(), duplicate_objects_grid(), and Slic3r::ModelInstance::set_offset().

Referenced by duplicate_objects_grid().

Here is the call graph for this function:

Here is the caller graph for this function:

findMaxSpeed()

double Slic3r::Model::findMaxSpeed ( const ModelObject * object )

static

                                                    {
    auto objectKeys = object->config.keys();
    double objMaxSpeed = -1.;
    if (objectKeys.empty())
        return Model::printSpeedMap.maxSpeed;
    double perimeterSpeedObj = Model::printSpeedMap.perimeterSpeed;
    double externalPerimeterSpeedObj = Model::printSpeedMap.externalPerimeterSpeed;
    double infillSpeedObj = Model::printSpeedMap.infillSpeed;
    double solidInfillSpeedObj = Model::printSpeedMap.solidInfillSpeed;
    double topSolidInfillSpeedObj = Model::printSpeedMap.topSolidInfillSpeed;
    double supportSpeedObj = Model::printSpeedMap.supportSpeed;
    double smallPerimeterSpeedObj = Model::printSpeedMap.smallPerimeterSpeed;
    double smallSupportPerimeterSpeedObj = Model::printSpeedMap.smallSupportPerimeterSpeed;
    for (std::string objectKey : objectKeys) {
        if (objectKey == "inner_wall_speed"){
            perimeterSpeedObj = object->config.get().opt_float_nullable(objectKey, 0);
            externalPerimeterSpeedObj = Model::printSpeedMap.externalPerimeterSpeed / Model::printSpeedMap.perimeterSpeed * perimeterSpeedObj;
        }
        if (objectKey == "sparse_infill_speed")
            infillSpeedObj = object->config.get().opt_float_nullable(objectKey, 0);
        if (objectKey == "internal_solid_infill_speed")
            solidInfillSpeedObj = object->config.get().opt_float_nullable(objectKey, 0);
        if (objectKey == "top_surface_speed")
            topSolidInfillSpeedObj = object->config.get().opt_float_nullable(objectKey, 0);
        if (objectKey == "support_speed")
            supportSpeedObj = object->config.get().opt_float_nullable(objectKey, 0);
        if (objectKey == "outer_wall_speed")
            externalPerimeterSpeedObj = object->config.get().opt_float_nullable(objectKey, 0);
        if (objectKey == "small_perimeter_speed")
            smallPerimeterSpeedObj = object->config.get().opt_float_or_percent_nullable(objectKey, 0).get_abs_value(externalPerimeterSpeedObj);
        if (objectKey == "small_support_perimeter_speed")
            smallSupportPerimeterSpeedObj = object->config.get().opt_float_or_percent_nullable(objectKey, 0).get_abs_value(supportSpeedObj);
    }
    objMaxSpeed = std::max(perimeterSpeedObj, std::max(externalPerimeterSpeedObj, std::max(infillSpeedObj, std::max(solidInfillSpeedObj, std::max(topSolidInfillSpeedObj, std::max(supportSpeedObj, std::max(smallPerimeterSpeedObj, std::max(smallSupportPerimeterSpeedObj, objMaxSpeed))))))));
    if (objMaxSpeed <= 0) objMaxSpeed = 250.;
    return objMaxSpeed;
}

References findMaxSpeed(), and printSpeedMap.

Referenced by findMaxSpeed(), Slic3r::ModelInstance::get_auto_brim_width(), and Slic3r::outer_inner_brim_area().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_new_id()

ObjectID Slic3r::ObjectBase::generate_new_id ( )

inlinestaticprivateinherited

{ return ObjectID(++ s_last_id); }

References s_last_id.

Referenced by ObjectBase(), and set_new_unique_id().

Here is the caller graph for this function:

get_auxiliary_file_temp_path()

std::string Slic3r::Model::get_auxiliary_file_temp_path

(

)

{
    return get_backup_path("Auxiliaries");
}

References get_auxiliary_file_temp_path(), and get_backup_path().

Referenced by Slic3r::_BBS_3MF_Importer::_extract_auxiliary_file_from_archive(), Slic3r::_BBS_3MF_Exporter::_save_model_to_file(), get_auxiliary_file_temp_path(), AuxiliaryList::init_auxiliary(), and Slic3r::GUI::AuxiliaryPanel::init_auxiliary().

Here is the call graph for this function:

Here is the caller graph for this function:

get_backup_path() [1/2]

std::string Slic3r::Model::get_backup_path

(

)

{
    if (backup_path.empty())
    {
        auto pid = get_current_pid();
        boost::filesystem::path parent_path(temporary_dir());
        std::time_t t = std::time(0);
        std::tm* now_time = std::localtime(&t);
        std::stringstream buf;
        buf << "/orcaslicer_model/";
        buf << std::put_time(now_time, "%a_%b_%d/%H_%M_%S#");
        buf << pid << "#";
        buf << this->id().id;
 
        backup_path = parent_path.string() + buf.str();
        BOOST_LOG_TRIVIAL(info) << boost::format("model %1%, id %2%, backup_path empty, set to %3%")%this%this->id().id%backup_path;
        boost::filesystem::path temp_path(backup_path);
        if (boost::filesystem::exists(temp_path))
        {
            BOOST_LOG_TRIVIAL(info) << boost::format("model %1%, id %2%, remove previous %3%")%this%this->id().id%backup_path;
            boost::filesystem::remove_all(temp_path);
        }
    }
    boost::filesystem::path temp_path(backup_path);
    try {
        if (!boost::filesystem::exists(temp_path))
        {
            BOOST_LOG_TRIVIAL(info) << "create /3D/Objects in " << temp_path;
            boost::filesystem::create_directories(backup_path + "/3D/Objects");
            BOOST_LOG_TRIVIAL(info) << "create /Metadata in " << temp_path;
            boost::filesystem::create_directories(backup_path + "/Metadata");
            BOOST_LOG_TRIVIAL(info) << "create /lock.txt in " << temp_path;
            save_string_file(backup_path + "/lock.txt",
                boost::lexical_cast<std::string>(get_current_pid()));
        }
    } catch (std::exception &ex) {
        BOOST_LOG_TRIVIAL(error) << "Failed to create backup path" << temp_path << ": " << ex.what();
    }
 
    return backup_path;
}

References backup_path, get_backup_path(), Slic3r::get_current_pid(), Slic3r::ObjectBase::id(), Slic3r::save_string_file(), and Slic3r::temporary_dir().

Referenced by Slic3r::_BBS_3MF_Exporter::_add_project_config_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_project_embedded_presets_to_archive(), Slic3r::_BBS_3MF_Importer::_extract_project_config_from_archive(), get_auxiliary_file_temp_path(), get_backup_path(), get_backup_path(), load_from(), Slic3r::_BBS_3MF_Importer::load_model_from_file(), Slic3r::_BBS_Backup_Manager::remove_backup(), and Slic3r::_BBS_3MF_Exporter::save_model_to_file().

Here is the call graph for this function:

Here is the caller graph for this function:

get_backup_path() [2/2]

std::string Slic3r::Model::get_backup_path

(

const std::string &

sub_path

)

{
    auto path = get_backup_path() + "/" + sub_path;
    try {
        if (!boost::filesystem::exists(path)) {
            BOOST_LOG_TRIVIAL(info) << "create missing sub_path" << path;
            boost::filesystem::create_directories(path);
        }
    } catch (std::exception &ex) {
        BOOST_LOG_TRIVIAL(error) << "Failed to create missing sub_path" << path << ": " << ex.what();
    }
    return path;
}

References get_backup_path().

Here is the call graph for this function:

get_curr_plate_custom_gcodes()

const CustomGCode::Info Slic3r::Model::get_curr_plate_custom_gcodes ( ) const

inline

                                                               {
        if (plates_custom_gcodes.find(curr_plate_index) != plates_custom_gcodes.end()) {
            return plates_custom_gcodes.at(curr_plate_index);
        }
        return CustomGCode::Info();
    }

References curr_plate_index, and plates_custom_gcodes.

Referenced by Slic3r::ToolOrdering::ToolOrdering(), and Slic3r::ToolOrdering::assign_custom_gcodes().

Here is the caller graph for this function:

get_material()

ModelMaterial * Slic3r::Model::get_material ( t_model_material_id material_id )

inline

                                                                 {
        ModelMaterialMap::iterator i = this->materials.find(material_id);
        return (i == this->materials.end()) ? nullptr : i->second;
    }

Referenced by add_material(), and add_material().

Here is the caller graph for this function:

get_object_backup_id() [1/2]

int Slic3r::Model::get_object_backup_id

(

ModelObject const &

object

)

{
    auto i = object_backup_id_map.find(object.id().id);
    if (i == object_backup_id_map.end()) {
        i = object_backup_id_map.insert(std::make_pair(object.id().id, next_object_backup_id++)).first;
    }
    return i->second;
}

References get_object_backup_id(), next_object_backup_id, and object_backup_id_map.

Referenced by get_object_backup_id(), and get_object_backup_id().

Here is the call graph for this function:

Here is the caller graph for this function:

get_object_backup_id() [2/2]

int Slic3r::Model::get_object_backup_id

(

ModelObject const &

object

)

const

{
    return object_backup_id_map.find(object.id().id)->second;
}

References get_object_backup_id(), and object_backup_id_map.

Here is the call graph for this function:

getBedPolygon()

Polygon Slic3r::Model::getBedPolygon ( )

inlinestatic

{ return Model::printSpeedMap.bed_poly; }

References printSpeedMap.

Referenced by Slic3r::outer_inner_brim_area().

Here is the caller graph for this function:

getThermalLength() [1/2]

double Slic3r::Model::getThermalLength ( const ModelVolume * modelVolumePtr )

static

                                                                {
    double thermalLength = 200.;
    auto aa = modelVolumePtr->extruder_id();
    if (Model::extruderParamsMap.find(aa) != Model::extruderParamsMap.end()) {
        double thermal_length = 200.0;
    if (MaterialType::get_thermal_length(Model::extruderParamsMap.at(aa).materialName, thermal_length)) {
            return thermal_length;
        }
    }
    return thermalLength;
}

References Slic3r::ModelVolume::extruder_id(), extruderParamsMap, Slic3r::MaterialType::get_thermal_length(), and getThermalLength().

Referenced by Slic3r::configBrimWidthByVolumeGroups(), Slic3r::ModelInstance::get_auto_brim_width(), getThermalLength(), and getThermalLength().

Here is the call graph for this function:

Here is the caller graph for this function:

getThermalLength() [2/2]

double Slic3r::Model::getThermalLength ( const std::vector< ModelVolume * > modelVolumePtrs )

static

{
    double thermalLength = 1250.;
 
    for (const auto& modelVolumePtr : modelVolumePtrs) {
        if (modelVolumePtr != nullptr) {
            // the thermal length of a group is decided by the volume with shortest thermal length
            thermalLength = std::min(thermalLength, getThermalLength(modelVolumePtr));
        }
    }
    return thermalLength;
}

References getThermalLength().

Here is the call graph for this function:

id()

ObjectID Slic3r::ObjectBase::id ( ) const

inlineinherited

{ return m_id; }

References m_id.

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

is_fdm_support_painted()

bool Slic3r::Model::is_fdm_support_painted

(

)

const

{
    return std::any_of(this->objects.cbegin(), this->objects.cend(), [](const ModelObject *mo) { return mo->is_fdm_support_painted(); });
}

References is_fdm_support_painted().

Referenced by Slic3r::_3MF_Exporter::_add_model_file_to_archive(), and is_fdm_support_painted().

Here is the call graph for this function:

Here is the caller graph for this function:

is_fuzzy_skin_painted()

bool Slic3r::Model::is_fuzzy_skin_painted

(

)

const

{
    return std::any_of(this->objects.cbegin(), this->objects.cend(), [](const ModelObject *mo) { return mo->is_fuzzy_skin_painted(); });
}

References is_fuzzy_skin_painted().

Referenced by is_fuzzy_skin_painted().

Here is the call graph for this function:

Here is the caller graph for this function:

is_mm_painted()

bool Slic3r::Model::is_mm_painted

(

)

const

{
    return std::any_of(this->objects.cbegin(), this->objects.cend(), [](const ModelObject *mo) { return mo->is_mm_painted(); });
}

References is_mm_painted().

Referenced by Slic3r::_3MF_Exporter::_add_model_file_to_archive(), and is_mm_painted().

Here is the call graph for this function:

Here is the caller graph for this function:

is_need_backup()

bool Slic3r::Model::is_need_backup ( )

inline

{ return need_backup;  }

References need_backup.

Referenced by Slic3r::_BBS_Backup_Manager::remove_backup().

Here is the caller graph for this function:

is_seam_painted()

bool Slic3r::Model::is_seam_painted

(

)

const

{
    return std::any_of(this->objects.cbegin(), this->objects.cend(), [](const ModelObject *mo) { return mo->is_seam_painted(); });
}

References is_seam_painted().

Referenced by Slic3r::_3MF_Exporter::_add_model_file_to_archive(), and is_seam_painted().

Here is the call graph for this function:

Here is the caller graph for this function:

load()

template<class Archive>

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

inlineprivate

                                                   {
        Internal::StaticSerializationWrapper<ModelWipeTower> wipe_tower_wrapper(wipe_tower);
        ar(materials, objects, wipe_tower_wrapper);
    }

References materials, objects, and wipe_tower.

load_and_construct()

template<class Archive>

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

inlinestaticprivateinherited

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

References id().

Here is the call graph for this function:

load_from()

void Slic3r::Model::load_from

(

Model &

model

)

{
    set_backup_path(model.get_backup_path());
    model.backup_path.clear();
    object_backup_id_map = model.object_backup_id_map;
    next_object_backup_id = model.next_object_backup_id;
    design_info = model.design_info;
    stl_design_id = model.stl_design_id;
    stl_design_country = model.stl_design_country;
    model_info  = model.model_info;
    profile_info  = model.profile_info;
    mk_name = model.mk_name;
    mk_version = model.mk_version;
    md_name = model.md_name;
    md_value = model.md_value;
    model.design_info.reset();
    model.model_info.reset();
    model.profile_info.reset();
    model.calib_pa_pattern.reset();
}

References Model(), backup_path, calib_pa_pattern, design_info, get_backup_path(), load_from(), md_name, md_value, mk_name, mk_version, model_info, next_object_backup_id, object_backup_id_map, profile_info, set_backup_path(), stl_design_country, and stl_design_id.

Referenced by load_from(), and Slic3r::GUI::Plater::new_project().

Here is the call graph for this function:

Here is the caller graph for this function:

looks_like_imperial_units()

bool Slic3r::Model::looks_like_imperial_units

(

)

const

{
    if (this->objects.size() == 0)
        return false;
 
    for (ModelObject* obj : this->objects)
        if (obj->get_object_stl_stats().volume < volume_threshold_inches) {
            if (!obj->is_cut())
                return true;
            bool all_cut_parts_look_like_imperial_units = true;
            for (ModelObject* obj_other : this->objects) {
                if (obj_other == obj)
                    continue;
                if (obj_other->cut_id.is_equal(obj->cut_id) && obj_other->get_object_stl_stats().volume >= volume_threshold_inches) {
                    all_cut_parts_look_like_imperial_units = false;
                    break;
                }
            }
            if (all_cut_parts_look_like_imperial_units)
                return true;
        }
 
    return false;
}

References looks_like_imperial_units(), and Slic3r::volume_threshold_inches.

Referenced by looks_like_imperial_units().

Here is the call graph for this function:

Here is the caller graph for this function:

looks_like_multipart_object()

bool Slic3r::Model::looks_like_multipart_object

(

)

const

{
    if (this->objects.size() <= 1)
        return false;
    double zmin = std::numeric_limits<double>::max();
    for (const ModelObject *obj : this->objects) {
        if (obj->volumes.size() > 1 || obj->config.keys().size() > 1)
            return false;
 
        double zmin_this = obj->min_z();
        if (zmin == std::numeric_limits<double>::max())
            zmin = zmin_this;
        else if (std::abs(zmin - zmin_this) > EPSILON)
            // The Object don't share zmin.
            return true;
    }
    return false;
}

References EPSILON, and looks_like_multipart_object().

Referenced by looks_like_multipart_object().

Here is the call graph for this function:

Here is the caller graph for this function:

looks_like_saved_in_meters()

bool Slic3r::Model::looks_like_saved_in_meters

(

)

const

{
    if (this->objects.size() == 0)
        return false;
 
    for (ModelObject* obj : this->objects)
        if (obj->get_object_stl_stats().volume < volume_threshold_meters)
            return true;
 
    return false;
}

References looks_like_saved_in_meters(), and Slic3r::volume_threshold_meters.

Referenced by looks_like_saved_in_meters().

Here is the call graph for this function:

Here is the caller graph for this function:

max_z()

double Slic3r::Model::max_z

(

)

const

{
    double z = 0;
    for (ModelObject *o : this->objects)
        z = std::max(z, o->max_z());
    return z;
}

References max_z().

Referenced by max_z().

Here is the call graph for this function:

Here is the caller graph for this function:

mesh()

TriangleMesh Slic3r::Model::mesh

(

)

const

{
    TriangleMesh mesh;
    for (const ModelObject *o : this->objects)
        mesh.merge(o->mesh());
    return mesh;
}

References mesh().

Referenced by add_object(), add_object(), Slic3r::GUI::GLModel::init_from_file(), Slic3r::GUI::ObjectList::load_modifier(), Slic3r::GUI::BedShapePanel::load_stl(), mesh(), Slic3r::store_drc(), Slic3r::store_obj(), and Slic3r::store_stl().

Here is the call graph for this function:

Here is the caller graph for this function:

obj_import_face_color_deal()

bool Slic3r::Model::obj_import_face_color_deal ( const std::vector< unsigned char > & face_filament_ids, const unsigned char & first_extruder_id, Model * model )

static

{
    if (face_filament_ids.size() == 0) { return false; }
    // 2.generate mmu_segmentation_facets
    if (model->objects.size() == 1) {
        auto obj = model->objects[0];
        obj->config.set("extruder", first_extruder_id);
        if (obj->volumes.size() == 1) {
            auto volume        = obj->volumes[0];
            volume->config.set("extruder", first_extruder_id);
            auto face_count    = volume->mesh().its.indices.size();
            volume->mmu_segmentation_facets.reset();
            volume->mmu_segmentation_facets.reserve(face_count);
            if (volume->mesh().its.indices.size() != face_filament_ids.size()) {
                return false;
            }
            for (size_t i = 0; i < volume->mesh().its.indices.size(); i++) {
                auto face         = volume->mesh().its.indices[i];
                auto filament_id = face_filament_ids[i];
                if (filament_id < 1) {
                    continue;
                }
                std::string result;
                get_real_filament_id(filament_id, result);
                volume->mmu_segmentation_facets.set_triangle_from_string(i, result);
            }
            return true;
        }
    }
    return false;
}

References Model(), Slic3r::get_real_filament_id(), obj_import_face_color_deal(), and objects.

Referenced by construct_assemble_list(), and obj_import_face_color_deal().

Here is the call graph for this function:

Here is the caller graph for this function:

obj_import_vertex_color_deal()

bool Slic3r::Model::obj_import_vertex_color_deal ( const std::vector< unsigned char > & vertex_filament_ids, const unsigned char & first_extruder_id, Model * model )

static

{
    if (vertex_filament_ids.size() == 0) {
        return false;
    }
    // 2.generate mmu_segmentation_facets
    if (model->objects.size() == 1 ) {
        auto obj = model->objects[0];
        obj->config.set("extruder", first_extruder_id);
        if (obj->volumes.size() == 1) {
            enum VertexColorCase {
                _3_SAME_COLOR,
                _3_DIFF_COLOR,
                _2_SAME_1_DIFF_COLOR,
            };
            auto calc_vertex_color_case = [](const unsigned char &c0, const unsigned char &c1, const unsigned char &c2, VertexColorCase &vertex_color_case,
                                             unsigned char &iso_index) {
                if (c0 == c1 && c1 == c2) {
                    vertex_color_case = VertexColorCase::_3_SAME_COLOR;
                } else if (c0 != c1 && c1 != c2 && c0 != c2) {
                    vertex_color_case = VertexColorCase::_3_DIFF_COLOR;
                } else if (c0 == c1) {
                    vertex_color_case = _2_SAME_1_DIFF_COLOR;
                    iso_index         = 2;
                } else if (c1 == c2) {
                    vertex_color_case = _2_SAME_1_DIFF_COLOR;
                    iso_index         = 0;
                } else if (c0 == c2) {
                    vertex_color_case = _2_SAME_1_DIFF_COLOR;
                    iso_index         = 1;
                } else {
                    std::cout << "error";
                }
            };
            auto calc_tri_area = [](const Vec3f &v0, const Vec3f &v1, const Vec3f &v2) {
                return std::abs((v0 - v1).cross(v0 - v2).norm()) / 2;
            };
            auto volume = obj->volumes[0];
            volume->config.set("extruder", first_extruder_id);
            auto face_count = volume->mesh().its.indices.size();
            volume->mmu_segmentation_facets.reset();
            volume->mmu_segmentation_facets.reserve(face_count);
            if (volume->mesh().its.vertices.size() != vertex_filament_ids.size()) {
                return false;
            }
            for (size_t i = 0; i < volume->mesh().its.indices.size(); i++) {
                auto face   = volume->mesh().its.indices[i];
                auto filament_id0 = vertex_filament_ids[face[0]];
                auto filament_id1 = vertex_filament_ids[face[1]];
                auto filament_id2 = vertex_filament_ids[face[2]];
                if (filament_id0 <= 1 && filament_id1 <= 1 && filament_id2 <= 2) {
                    continue;
                }
                VertexColorCase vertex_color_case;
                unsigned char iso_index;
                calc_vertex_color_case(filament_id0, filament_id1, filament_id2, vertex_color_case, iso_index);
                switch (vertex_color_case) {
                case _3_SAME_COLOR: {
                    std::string result;
                    get_real_filament_id(filament_id0, result);
                    volume->mmu_segmentation_facets.set_triangle_from_string(i, result);
                    break;
                }
                case _3_DIFF_COLOR: {
                    std::string result0, result1, result2;
                    get_real_filament_id(filament_id0, result0);
                    get_real_filament_id(filament_id1, result1);
                    get_real_filament_id(filament_id2, result2);
 
                    auto v0 = volume->mesh().its.vertices[face[0]];
                    auto v1 = volume->mesh().its.vertices[face[1]];
                    auto v2 = volume->mesh().its.vertices[face[2]];
                    auto                 dir_0_1  = (v1 - v0).normalized().eval();
                    auto                 dir_0_2  = (v2 - v0).normalized().eval();
                    float                sita0    = acos(dir_0_1.dot(dir_0_2));
                    auto                 dir_1_0  = (-dir_0_1).eval();
                    auto                 dir_1_2  = (v2 - v1).normalized().eval();
                    float                sita1    = acos(dir_1_0.dot(dir_1_2));
                    float                sita2    = PI - sita0 - sita1;
                    std::array<float, 3> sitas    = {sita0, sita1, sita2};
                    float                max_sita = sitas[0];
                    int                  max_sita_vertex_index = 0;
                    for (size_t j = 1; j < sitas.size(); j++) {
                        if (sitas[j] > max_sita) {
                            max_sita_vertex_index = j;
                            max_sita = sitas[j];
                        }
                    }
                    if (max_sita_vertex_index == 0) {
                        volume->mmu_segmentation_facets.set_triangle_from_string(i, result0 + result1 + result2 + (result1 + result2 + "5" )+ "3"); //"1C0C2C0C1C13"
                    } else if (max_sita_vertex_index == 1) {
                        volume->mmu_segmentation_facets.set_triangle_from_string(i, result0 + result1 + result2 + (result0 + result2 + "9") + "3");
                    } else{// if (max_sita_vertex_index == 2)
                        volume->mmu_segmentation_facets.set_triangle_from_string(i, result0 + result1 + result2 + (result1 + result0 + "1") + "3");
                    }
                    break;
                }
                case _2_SAME_1_DIFF_COLOR: {
                    std::string result0, result1, result2;
                    get_real_filament_id(filament_id0, result0);
                    get_real_filament_id(filament_id1, result1);
                    get_real_filament_id(filament_id2, result2);
                    if (iso_index == 0) {
                        volume->mmu_segmentation_facets.set_triangle_from_string(i, result0 + result1 + result1 + "2");
                    } else if (iso_index == 1) {
                        volume->mmu_segmentation_facets.set_triangle_from_string(i, result1 + result0 + result0 + "6");
                    } else if (iso_index == 2) {
                        volume->mmu_segmentation_facets.set_triangle_from_string(i, result2 + result0 + result0 + "A");
                    }
                    break;
                }
                default: break;
                }
            }
            return true;
        }
    }
    return false;
}

References Model(), Slic3r::cross(), Slic3r::get_real_filament_id(), obj_import_vertex_color_deal(), objects, and PI.

Referenced by construct_assemble_list(), and obj_import_vertex_color_deal().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=() [1/2]

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

inline

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

References Model(), and Slic3r::ObjectBase::id().

Here is the call graph for this function:

operator=() [2/2]

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

inline

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

References Model().

Here is the call graph for this function:

print_info()

void Slic3r::Model::print_info ( ) const

inline

{ for (const ModelObject *o : this->objects) o->print_info(); }

propose_export_file_name_and_path() [1/2]

std::string Slic3r::Model::propose_export_file_name_and_path

(

)

const

{
    std::string input_file;
    for (const ModelObject *model_object : this->objects)
        for (ModelInstance *model_instance : model_object->instances)
            if (model_instance->is_printable()) {
                input_file = model_object->get_export_filename();
 
                if (!input_file.empty())
                    goto end;
                // Other instances will produce the same name, skip them.
                break;
            }
end:
    return input_file;
}

References Slic3r::ModelInstance::is_printable(), and propose_export_file_name_and_path().

Referenced by Slic3r::CLI::output_filepath(), propose_export_file_name_and_path(), and propose_export_file_name_and_path().

Here is the call graph for this function:

Here is the caller graph for this function:

propose_export_file_name_and_path() [2/2]

std::string Slic3r::Model::propose_export_file_name_and_path

(

const std::string &

new_extension

)

const

{
    return boost::filesystem::path(this->propose_export_file_name_and_path()).replace_extension(new_extension).string();
}

References propose_export_file_name_and_path().

Here is the call graph for this function:

read_from_archive()

Model Slic3r::Model::read_from_archive ( const std::string & input_file, DynamicPrintConfig * config, ConfigSubstitutionContext * config_substitutions, En3mfType & out_file_type, LoadStrategy options = LoadStrategy::AddDefaultInstances, PlateDataPtrs * plate_data = nullptr, std::vector< Preset * > * project_presets = nullptr, Semver * file_version = nullptr, Import3mfProgressFn proFn = nullptr, BBLProject * project = nullptr )

static

{
    assert(config != nullptr);
    assert(config_substitutions != nullptr);
 
    Model model;
 
    bool result = false;
    bool is_bbl_3mf = false;
    bool is_orca_3mf = false;
    if (boost::algorithm::iends_with(input_file, ".3mf")) {
        PrusaFileParser prusa_file_parser;
        if (prusa_file_parser.check_3mf_from_prusa(input_file)) {
            // for Prusa 3mf
            result = load_3mf(input_file.c_str(), *config, *config_substitutions, &model, true);
            out_file_type = En3mfType::From_Prusa;
        } else {
            // BBS: add part plate related logic
            // BBS: backup & restore
            result = load_bbs_3mf(input_file.c_str(), config, config_substitutions, &model, plate_data, project_presets, &is_bbl_3mf, &is_orca_3mf, file_version, proFn, options, project);
        }
    }
    else if (boost::algorithm::iends_with(input_file, ".zip.amf"))
        result = load_amf(input_file.c_str(), config, config_substitutions, &model, &is_bbl_3mf);
    else
        throw Slic3r::RuntimeError(_L("Unknown file format: input file must have .3mf or .zip.amf extension."));
 
    if (out_file_type != En3mfType::From_Prusa) {
        if (is_orca_3mf)
            out_file_type = En3mfType::From_Orca;
        else
            out_file_type = is_bbl_3mf ? En3mfType::From_BBS : En3mfType::From_Other;
    }
 
    if (!result)
        throw Slic3r::RuntimeError(_L("Loading of a model file failed."));
 
    for (ModelObject *o : model.objects) {
//        if (boost::algorithm::iends_with(input_file, ".zip.amf"))
//        {
//            // we remove the .zip part of the extension to avoid it be added to filenames when exporting
//            o->input_file = boost::ireplace_last_copy(input_file, ".zip.", ".");
//        }
//        else
            o->input_file = input_file;
    }
 
    bool cb_cancel;
    if (options & LoadStrategy::AddDefaultInstances) {
        model.add_default_instances();
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format("import 3mf IMPORT_STAGE_ADD_INSTANCE\n");
        if (proFn) {
            proFn(IMPORT_STAGE_ADD_INSTANCE, 0, 1, cb_cancel);
            if (cb_cancel)
                throw Slic3r::RuntimeError(_L("Canceled"));
        }
    }
 
    //BBS
    //CustomGCode::update_custom_gcode_per_print_z_from_config(model.custom_gcode_per_print_z, config);
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" << __LINE__ << boost::format("import 3mf IMPORT_STAGE_UPDATE_GCODE\n");
    if (proFn) {
        proFn(IMPORT_STAGE_UPDATE_GCODE, 0, 1, cb_cancel);
        if (cb_cancel)
            throw Slic3r::RuntimeError(_L("Canceled"));
    }
 
    //BBS
    for (auto& plate_gcodes : model.plates_custom_gcodes)
        CustomGCode::check_mode_for_custom_gcode_per_print_z(plate_gcodes.second);
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" << __LINE__ << boost::format("import 3mf IMPORT_STAGE_CHECK_MODE_GCODE\n");
    if (proFn) {
        proFn(IMPORT_STAGE_CHECK_MODE_GCODE, 0, 1, cb_cancel);
        if (cb_cancel)
            throw Slic3r::RuntimeError(_L("Canceled"));
    }
 
    handle_legacy_sla(*config);
 
    return model;
}

References Model(), _L, add_default_instances(), Slic3r::AddDefaultInstances, Slic3r::PrusaFileParser::check_3mf_from_prusa(), Slic3r::CustomGCode::check_mode_for_custom_gcode_per_print_z(), Slic3r::From_BBS, Slic3r::From_Orca, Slic3r::From_Other, Slic3r::From_Prusa, Slic3r::handle_legacy_sla(), Slic3r::IMPORT_STAGE_ADD_INSTANCE, Slic3r::IMPORT_STAGE_CHECK_MODE_GCODE, Slic3r::IMPORT_STAGE_UPDATE_GCODE, Slic3r::ModelObject::input_file, Slic3r::load_3mf(), Slic3r::load_amf(), Slic3r::load_bbs_3mf(), objects, plates_custom_gcodes, and read_from_archive().

Referenced by Slic3r::GUI::Plater::priv::load_files(), and read_from_archive().

Here is the call graph for this function:

Here is the caller graph for this function:

read_from_file()

Model Slic3r::Model::read_from_file ( const std::string & input_file, DynamicPrintConfig * config = nullptr, ConfigSubstitutionContext * config_substitutions = nullptr, LoadStrategy options = LoadStrategy::AddDefaultInstances, PlateDataPtrs * plate_data = nullptr, std::vector< Preset * > * project_presets = nullptr, bool * is_xxx = nullptr, Semver * file_version = nullptr, Import3mfProgressFn proFn = nullptr, ImportstlProgressFn stlFn = nullptr, BBLProject * project = nullptr, int plate_id = 0 )

static

{
    Model model;
 
    DynamicPrintConfig temp_config;
    ConfigSubstitutionContext temp_config_substitutions_context(ForwardCompatibilitySubstitutionRule::EnableSilent);
    if (config == nullptr)
        config = &temp_config;
    if (config_substitutions == nullptr)
        config_substitutions = &temp_config_substitutions_context;
    //BBS: plate_data
    PlateDataPtrs temp_plate_data;
    bool temp_is_xxx;
    Semver temp_version;
    if (plate_data == nullptr)
        plate_data = &temp_plate_data;
    if (is_xxx == nullptr)
        is_xxx = &temp_is_xxx;
    if (file_version == nullptr)
        file_version = &temp_version;
 
    bool result = false;
    bool is_cb_cancel = false;
    std::string message;
    if (boost::algorithm::iends_with(input_file, ".stl"))
        result = load_stl(input_file.c_str(), &model, nullptr, stlFn);
    else if (boost::algorithm::iends_with(input_file, ".oltp"))
        result = load_stl(input_file.c_str(), &model, nullptr, stlFn,256);
    else if (boost::algorithm::iends_with(input_file, ".obj")) {
        ObjInfo                 obj_info;
        ObjParser::MtlData      mtl_data;
        result = load_obj(input_file.c_str(), &model, obj_info, message, nullptr, &mtl_data);
        // Keep the model's own UV channel on the volume, whatever the colour import then does with
        // the mesh: it is what TextureProjectionMethod::ModelUV maps a texture-displacement layer
        // through, so a model that arrives with a UV layout is textured on that layout instead of on
        // a fresh unwrap. load_obj() fills obj_info.uvs per face of the mesh it built, in the same
        // order (and only when every face named a known material, hence the size check). V is flipped
        // on the way in, to the convention DecodedHeightTexture samples in - the same flip
        // obj_to_textured_mesh() does for the colour importer.
        if (result && !obj_info.uvs.empty() && !model.objects.empty() && !model.objects.back()->volumes.empty()) {
            ModelVolume                &volume = *model.objects.back()->volumes[0];
            const indexed_triangle_set &its    = volume.mesh().its;
            if (obj_info.uvs.size() == its.indices.size()) {
                volume.texture_uv.resize(its.indices.size() * 3);
                for (size_t fi = 0; fi < obj_info.uvs.size(); ++fi)
                    for (int k = 0; k < 3; ++k)
                        volume.texture_uv[fi * 3 + size_t(k)] =
                            Vec2f(obj_info.uvs[fi][size_t(k)].x(), 1.f - obj_info.uvs[fi][size_t(k)].y());
            }
        }
        if (result && obj_info.has_uv_png && !obj_info.uvs.empty() && !model.objects.empty()) {
            // Textured OBJ: hand the mesh + materials to the texture-to-color importer
            // instead of the flat per-face colour dialog.
            auto tex_mesh = std::make_shared<TexturedMesh>();
            std::string obj_dir = boost::filesystem::path(input_file).parent_path().string();
            if (obj_to_textured_mesh(obj_info,
                    model.objects.back()->volumes[0]->mesh().its,
                    mtl_data, obj_dir, *tex_mesh)) {
                model.texture_mesh = tex_mesh;
            }
        }
        else if (result && !model.objects.empty() && !model.objects.back()->volumes.empty()) {
            // Vertex-colour and MTL face-colour OBJs also go through the texture-to-color
            // importer (as precomputed per-face colors) instead of the flat
            // per-face colour dialog, matching the uv_png branch above.
            auto build_tex_mesh_geometry = [&]() {
                auto tex_mesh = std::make_shared<TexturedMesh>();
                const auto& its = model.objects.back()->volumes[0]->mesh().its;
                tex_mesh->vertices.resize(its.vertices.size());
                for (size_t i = 0; i < its.vertices.size(); ++i)
                    tex_mesh->vertices[i] = {its.vertices[i].x(), its.vertices[i].y(), its.vertices[i].z()};
                tex_mesh->indices.resize(its.indices.size());
                for (size_t i = 0; i < its.indices.size(); ++i)
                    tex_mesh->indices[i] = {its.indices[i][0], its.indices[i][1], its.indices[i][2]};
                return tex_mesh;
            };
            if (obj_info.vertex_colors.size() > 0) {
                auto tex_mesh = build_tex_mesh_geometry();
                const auto& its = model.objects.back()->volumes[0]->mesh().its;
                tex_mesh->precomputed_face_colors.resize(its.indices.size());
                for (size_t i = 0; i < its.indices.size(); ++i) {
                    const auto& f = its.indices[i];
                    auto avg = [&](int ch) -> std::size_t {
                        float v = (obj_info.vertex_colors[f[0]][ch]
                                 + obj_info.vertex_colors[f[1]][ch]
                                 + obj_info.vertex_colors[f[2]][ch]) / 3.0f * 255.0f;
                        return (std::size_t) std::clamp(v, 0.0f, 255.0f);
                    };
                    tex_mesh->precomputed_face_colors[i] = {avg(0), avg(1), avg(2)};
                }
                tex_mesh->precomputed_vertex_colors = obj_info.vertex_colors;
                model.texture_mesh = tex_mesh;
            } else if (obj_info.face_colors.size() > 0 && obj_info.has_uv_png == false) {
                auto tex_mesh = build_tex_mesh_geometry();
                const size_t nf = tex_mesh->indices.size();
                tex_mesh->precomputed_face_colors.resize(nf);
                for (size_t i = 0; i < nf; ++i) {
                    if (i < obj_info.face_colors.size()) {
                        const auto& c = obj_info.face_colors[i];
                        tex_mesh->precomputed_face_colors[i] = {
                            (std::size_t) std::clamp(c[0] * 255.0f, 0.0f, 255.0f),
                            (std::size_t) std::clamp(c[1] * 255.0f, 0.0f, 255.0f),
                            (std::size_t) std::clamp(c[2] * 255.0f, 0.0f, 255.0f)
                        };
                    } else {
                        tex_mesh->precomputed_face_colors[i] = {128, 128, 128};
                    }
                }
                model.texture_mesh = tex_mesh;
            }
        }
    }
    else if (boost::algorithm::iends_with(input_file, ".glb") ||
             boost::algorithm::iends_with(input_file, ".gltf") ||
             boost::algorithm::iends_with(input_file, ".fbx")) {
        // These formats can carry material/texture data, so they go through the textured
        // import path: the geometry becomes a normal object and the texture is handed to the
        // texture-to-color dialog via Model::texture_mesh.
        auto tex_mesh = std::make_shared<TexturedMesh>();
        result = load_assimp_textured_model(input_file, *tex_mesh, &message);
        if (result) {
            model.texture_mesh = tex_mesh;
            add_textured_mesh_to_model(model, *tex_mesh, input_file);
        } else if (!message.empty()) {
            BOOST_LOG_TRIVIAL(error) << "Assimp: failed to load model: " << message
                                     << ", path=" << input_file;
            message = _L("The file format is incompatible and cannot be parsed.");
        }
    }
    else if (boost::algorithm::iends_with(input_file, ".svg"))
        result = load_svg(input_file.c_str(), &model, message);
    //BBS: remove the old .amf.xml files
    //else if (boost::algorithm::iends_with(input_file, ".amf") || boost::algorithm::iends_with(input_file, ".amf.xml"))
    else if (boost::algorithm::iends_with(input_file, ".drc"))
        result = load_drc(input_file.c_str(), &model);
    else if (boost::algorithm::iends_with(input_file, ".amf"))
        //BBS: is_xxx is used for is_inches when load amf
        result = load_amf(input_file.c_str(), config, config_substitutions, &model, is_xxx);
    else if (boost::algorithm::iends_with(input_file, ".3mf"))
        //BBS: add part plate related logic
        // BBS: backup & restore
        //FIXME options & LoadStrategy::CheckVersion ?
        //BBS: is_xxx is used for is_bbs_3mf when load 3mf
        result = load_bbs_3mf(input_file.c_str(), config, config_substitutions, &model, plate_data, project_presets, is_xxx, nullptr, file_version, proFn, options, project, plate_id);
#ifdef __APPLE__
    else if (boost::algorithm::iends_with(input_file, ".usd") || boost::algorithm::iends_with(input_file, ".usda") ||
             boost::algorithm::iends_with(input_file, ".usdc") || boost::algorithm::iends_with(input_file, ".usdz") ||
             boost::algorithm::iends_with(input_file, ".abc") || boost::algorithm::iends_with(input_file, ".ply")) {
        std::string temp_stl = make_temp_stl_with_modelio(input_file);
        if (temp_stl.empty()) {
            throw Slic3r::RuntimeError(_L("Failed to convert asset to STL via ModelIO."));
        }
        result = load_stl(temp_stl.c_str(), &model);
        delete_temp_file(temp_stl);
    }
#endif
    else
        throw Slic3r::RuntimeError(_L("Unknown file format: input file must have .stl, .obj, or .amf(.xml) extension."));
 
    if (is_cb_cancel) {
        Model empty_model;
        return empty_model;
    }
 
    if (!result) {
        if (message.empty())
            throw Slic3r::RuntimeError(_L("Loading of a model file failed."));
        else
            throw Slic3r::RuntimeError(message);
    }
 
    if (model.objects.empty())
        throw Slic3r::RuntimeError(_L("The supplied file couldn\'t be read because it\'s empty."));
 
    for (ModelObject *o : model.objects)
        o->input_file = input_file;
 
    if (options & LoadStrategy::AddDefaultInstances)
        model.add_default_instances();
 
    //BBS
    //CustomGCode::update_custom_gcode_per_print_z_from_config(model.custom_gcode_per_print_z, config);
    //BBS
    for (auto& plate_gcodes : model.plates_custom_gcodes)
        CustomGCode::check_mode_for_custom_gcode_per_print_z(plate_gcodes.second);
 
    sort_remove_duplicates(config_substitutions->substitutions);
    return model;
}

References Model(), Slic3r::EnableSilent, Slic3r::f(), Slic3r::ObjInfo::has_uv_png, Slic3r::TriangleMesh::its, Slic3r::load_obj(), Slic3r::load_stl(), Slic3r::ModelVolume::mesh(), Slic3r::obj_to_textured_mesh(), objects, texture_mesh, Slic3r::ModelVolume::texture_uv, and Slic3r::ObjInfo::uvs.

Referenced by Slic3r::GUI::GLModel::init_from_file(), Slic3r::GUI::Plater::priv::load_files(), Slic3r::GUI::ObjectList::load_modifier(), Slic3r::GUI::BedShapePanel::load_stl(), Slic3r::GUI::read_model_from_file(), Slic3r::GUI::Plater::priv::reload_from_disk(), Slic3r::GUI::Plater::priv::replace_volume_with_stl(), and Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

read_from_step()

Model Slic3r::Model::read_from_step ( const std::string & input_file, LoadStrategy options, ImportStepProgressFn stepFn, StepIsUtf8Fn stepIsUtf8Fn, std::function< int(Slic3r::Step &, double &, double &, bool &)> step_mesh_fn, double linear_deflection, double angle_deflection, bool is_split_compound )

static

{
    Model model;
    bool result = false;
    bool is_cb_cancel = false;
    Step::Step_Status status;
    Step step_file(input_file, stepFn);
    status = step_file.load();
    if(status != Step::Step_Status::LOAD_SUCCESS) {
        goto _finished;
    }
    if (step_mesh_fn) {
        if (step_mesh_fn(step_file, linear_deflection, angle_deflection, is_split_compound) == -1) {
            status = Step::Step_Status::CANCEL;
            goto _finished;
        }
    }
    
    status = step_file.mesh(&model, is_cb_cancel, is_split_compound, linear_deflection, angle_deflection);
 
_finished:
 
    switch (status){
        case Step::Step_Status::CANCEL: {
            Model empty_model;
            return empty_model;
        }
        case Step::Step_Status::LOAD_ERROR:
            throw Slic3r::RuntimeError(_L("Loading of a model file failed."));
        case Step::Step_Status::MESH_ERROR:
            throw Slic3r::RuntimeError(_L("Meshing of a model file failed or no valid shape."));
        default:
            break;
    }
 
    if (model.objects.empty())
        throw Slic3r::RuntimeError(_L("The supplied file couldn\'t be read because it\'s empty."));
 
    for (ModelObject *o : model.objects)
        o->input_file = input_file;
 
    if (options & LoadStrategy::AddDefaultInstances)
        model.add_default_instances();
 
    return model;
}

References Model(), _L, add_default_instances(), Slic3r::AddDefaultInstances, Slic3r::Step::CANCEL, Slic3r::ModelObject::input_file, Slic3r::Step::load(), Slic3r::Step::LOAD_ERROR, Slic3r::Step::LOAD_SUCCESS, Slic3r::Step::mesh(), Slic3r::Step::MESH_ERROR, and objects.

Referenced by Slic3r::GUI::Plater::priv::load_files(), Slic3r::GUI::ObjectList::load_modifier(), 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:

remove_backup_path_if_exist()

void Slic3r::Model::remove_backup_path_if_exist

(

)

{
    if (!backup_path.empty()) {
        boost::filesystem::path temp_path(backup_path);
        if (boost::filesystem::exists(temp_path))
        {
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format("model %1%, id %2% remove backup_path %3%")%this%this->id().id%backup_path;
            boost::filesystem::remove_all(temp_path);
        }
  backup_path.clear();
    }
}

References backup_path, Slic3r::ObjectBase::id(), and remove_backup_path_if_exist().

Referenced by remove_backup_path_if_exist().

Here is the call graph for this function:

Here is the caller graph for this function:

removed_objects_with_zero_volume()

int Slic3r::Model::removed_objects_with_zero_volume

(

)

{
    if (objects.size() == 0)
        return 0;
 
    int removed = 0;
    for (int i = int(objects.size()) - 1; i >= 0; i--)
        if (objects[i]->get_object_stl_stats().volume < zero_volume) {
            delete_object(size_t(i));
            removed++;
        }
    return removed;
}

References delete_object(), objects, removed_objects_with_zero_volume(), and Slic3r::zero_volume.

Referenced by removed_objects_with_zero_volume().

Here is the call graph for this function:

Here is the caller graph for this function:

save()

template<class Archive>

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

inlineprivate

                                                         {
        Internal::StaticSerializationWrapper<ModelWipeTower const> wipe_tower_wrapper(wipe_tower);
        ar(materials, objects, wipe_tower_wrapper);
    }

References materials, objects, and wipe_tower.

serialize()

template<class Archive>

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

inlineprivateinherited

{ ar(m_id); }

References m_id.

set_backup_path()

void Slic3r::Model::set_backup_path

(

const std::string &

path

)

{
    if (backup_path == path)
        return;
    if ("detach" == path) {
        backup_path.clear();
        return;
    }
    if (!backup_path.empty()) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__<<boost::format(", model %1%, id %2%, remove previous backup %3%")%this%this->id().id%backup_path;
        Slic3r::remove_backup(*this, true);
    }
    backup_path = path;
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__<<boost::format(", model %1%, id %2%, set backup to %3%")%this%this->id().id%backup_path;
}

References backup_path, Slic3r::ObjectBase::id(), Slic3r::remove_backup(), and set_backup_path().

Referenced by load_from(), Slic3r::_BBS_3MF_Importer::load_model_from_file(), Slic3r::CLI::run(), and set_backup_path().

Here is the call graph for this function:

Here is the caller graph for this function:

set_invalid_id()

void Slic3r::ObjectBase::set_invalid_id ( )

inlineprotectedinherited

{ m_id = 0; }

References m_id.

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

Here is the caller graph for this function:

set_need_backup()

void Slic3r::Model::set_need_backup

(

)

{
    need_backup = true;
}

References need_backup, and set_need_backup().

Referenced by set_need_backup().

Here is the call graph for this function:

Here is the caller graph for this function:

set_new_unique_id()

void Slic3r::ObjectBase::set_new_unique_id ( )

inlineprotectedinherited

{ m_id = generate_new_id(); }

References generate_new_id(), and m_id.

Referenced by Slic3r::ModelVolume::ModelVolume(), Slic3r::Model::assign_new_unique_ids_recursive(), Slic3r::ModelVolume::assign_new_unique_ids_recursive(), assign_new_unique_ids_recursive(), Slic3r::CutObjectBase::init(), Slic3r::ModelMaterial::set_new_unique_id(), Slic3r::ModelObject::set_new_unique_id(), and Slic3r::ModelVolume::set_new_unique_id().

Here is the call graph for this function:

Here is the caller graph for this function:

set_object_backup_id()

void Slic3r::Model::set_object_backup_id	(	ModelObject const &	object,
		int	uuid )

{
    object_backup_id_map[object.id().id] = uuid;
    if (uuid >= next_object_backup_id) next_object_backup_id = uuid + 1;
}

References next_object_backup_id, object_backup_id_map, and set_object_backup_id().

Referenced by set_object_backup_id().

Here is the call graph for this function:

Here is the caller graph for this function:

SetDesigner()

void Slic3r::Model::SetDesigner ( std::string designer, std::string designer_user_id )

inline

                                                                     {
        if (design_info == nullptr) {
            design_info = std::make_shared<ModelDesignInfo>();
        }
        design_info->Designer = designer;
        //BBS tips: clean design user id when set designer
        design_info->DesignerUserId = designer_user_id;
    }

References design_info.

setExtruderParams()

void Slic3r::Model::setExtruderParams ( const DynamicPrintConfig & config, int extruders_count )

static

                                                                                   {
    extruderParamsMap.clear();
    //Slic3r::DynamicPrintConfig config = wxGetApp().preset_bundle->full_config();
    // BBS
    //int numExtruders = wxGetApp().preset_bundle->filament_presets.size();
    for (unsigned int i = 0; i != extruders_count; ++i) {
        std::string matName = "";
        // BBS
        int bedTemp = 35;
        double endTemp = 0.f;
        if (config.has("filament_type")) {
            matName = config.opt_string("filament_type", i);
        }
        if (config.has("nozzle_temperature")) {
            endTemp = config.opt_int("nozzle_temperature", i);
        }
 
        // FIXME: curr_bed_type is now a plate config rather than a global config.
        // Currently bed temp is not used for brim generation, so just comment it for now.
#if 0
        if (config.has("curr_bed_type")) {
            BedType curr_bed_type = config.opt_enum<BedType>("curr_bed_type");
            bedTemp = config.opt_int(get_bed_temp_key(curr_bed_type), i);
        }
#endif
        if (i == 0) extruderParamsMap.insert({ i,{matName, bedTemp, endTemp} });
        extruderParamsMap.insert({ i + 1,{matName, bedTemp, endTemp} });
    }
}

References Slic3r::curr_bed_type(), extruderParamsMap, Slic3r::get_bed_temp_key(), Slic3r::ConfigOptionResolver::has(), Slic3r::DynamicConfig::opt_enum(), Slic3r::DynamicConfig::opt_int(), Slic3r::DynamicConfig::opt_string(), and setExtruderParams().

Referenced by Slic3r::GUI::has_filaments(), Slic3r::GUI::Plater::priv::on_action_slice_all(), Slic3r::GUI::Plater::priv::on_action_slice_plate(), Slic3r::GUI::ArrangeJob::prepare(), Slic3r::CLI::run(), Slic3r::GUI::Plater::priv::select_view_3D(), and setExtruderParams().

Here is the call graph for this function:

Here is the caller graph for this function:

setPrintSpeedTable()

void Slic3r::Model::setPrintSpeedTable ( const DynamicPrintConfig & config, const PrintConfig & print_config )

static

                                                                                                {
    //Slic3r::DynamicPrintConfig config = wxGetApp().preset_bundle->full_config();
    printSpeedMap.maxSpeed = 0;
    if (config.has("inner_wall_speed")) {
        printSpeedMap.perimeterSpeed = config.opt_float_nullable("inner_wall_speed", 0);
        if (printSpeedMap.perimeterSpeed > printSpeedMap.maxSpeed)
            printSpeedMap.maxSpeed = printSpeedMap.perimeterSpeed;
    }
    if (config.has("outer_wall_speed")) {
        printSpeedMap.externalPerimeterSpeed = config.opt_float_nullable("outer_wall_speed", 0);
        printSpeedMap.maxSpeed = std::max(printSpeedMap.maxSpeed, printSpeedMap.externalPerimeterSpeed);
    }
    if (config.has("sparse_infill_speed")) {
        printSpeedMap.infillSpeed = config.opt_float_nullable("sparse_infill_speed", 0);
        if (printSpeedMap.infillSpeed > printSpeedMap.maxSpeed)
            printSpeedMap.maxSpeed = printSpeedMap.infillSpeed;
    }
    if (config.has("internal_solid_infill_speed")) {
        printSpeedMap.solidInfillSpeed = config.opt_float_nullable("internal_solid_infill_speed", 0);
        if (printSpeedMap.solidInfillSpeed > printSpeedMap.maxSpeed)
            printSpeedMap.maxSpeed = printSpeedMap.solidInfillSpeed;
    }
    if (config.has("top_surface_speed")) {
        printSpeedMap.topSolidInfillSpeed = config.opt_float_nullable("top_surface_speed", 0);
        if (printSpeedMap.topSolidInfillSpeed > printSpeedMap.maxSpeed)
            printSpeedMap.maxSpeed = printSpeedMap.topSolidInfillSpeed;
    }
    if (config.has("support_speed")) {
        printSpeedMap.supportSpeed = config.opt_float_nullable("support_speed", 0);
 
        if (printSpeedMap.supportSpeed > printSpeedMap.maxSpeed)
            printSpeedMap.maxSpeed = printSpeedMap.supportSpeed;
    }
 
 
    //auto& print = wxGetApp().plater()->get_partplate_list().get_current_fff_print();
    //auto print_config = print.config();
    //printSpeedMap.bed_poly.points = get_bed_shape(*(wxGetApp().plater()->config()));
    printSpeedMap.bed_poly.points = get_bed_shape(config);
    // Collision volumes are additive to the legacy bed keep-out. Preserve the
    // established printable-bed polygon so bed-edge and legacy-area brim
    // clipping continue to work when collision volumes are also configured.
    Pointfs excluse_area_points = print_config.bed_exclude_area.values;
    Polygons exclude_polys;
    Polygon exclude_poly;
    for (int i = 0; i < excluse_area_points.size(); i++) {
        auto pt = excluse_area_points[i];
        exclude_poly.points.emplace_back(scale_(pt.x()), scale_(pt.y()));
        if (i % 4 == 3) {  // exclude areas are always rectangle
            exclude_polys.push_back(exclude_poly);
            exclude_poly.points.clear();
        }
    }
    if (!exclude_polys.empty())
        printSpeedMap.bed_poly = diff({ printSpeedMap.bed_poly }, exclude_polys)[0];
}

References Slic3r::diff(), Slic3r::get_bed_shape(), Slic3r::ConfigOptionResolver::has(), Slic3r::DynamicConfig::opt_float_nullable(), Slic3r::MultiPoint::points, printSpeedMap, scale_, and setPrintSpeedTable().

Referenced by Slic3r::GUI::Plater::priv::on_action_slice_all(), Slic3r::GUI::Plater::priv::on_action_slice_plate(), Slic3r::GUI::ArrangeJob::prepare(), Slic3r::CLI::run(), Slic3r::GUI::Plater::priv::select_view_3D(), and setPrintSpeedTable().

Here is the call graph for this function:

Here is the caller graph for this function:

timestamp()

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

inlinevirtualinherited

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

{ return 0; }

translate()

void Slic3r::Model::translate ( coordf_t x, coordf_t y, coordf_t z )

inline

{ for (ModelObject *o : this->objects) o->translate(x, y, z); }

update_links_bottom_up_recursive()

void Slic3r::Model::update_links_bottom_up_recursive ( )

private

{
  for (std::pair<const t_model_material_id, ModelMaterial*> &kvp : this->materials)
    kvp.second->set_model(this);
  for (ModelObject *model_object : this->objects) {
    model_object->set_model(this);
    for (ModelInstance *model_instance : model_object->instances)
      model_instance->set_model_object(model_object);
    for (ModelVolume *model_volume : model_object->volumes)
      model_volume->set_model_object(model_object);
  }
}

References Slic3r::ModelInstance::set_model_object(), and Slic3r::ModelVolume::set_model_object().

Referenced by Slic3r::UndoRedo::StackImpl::load_snapshot().

Here is the call graph for this function:

Here is the caller graph for this function:

update_print_volume_state()

unsigned int Slic3r::Model::update_print_volume_state

(

const BuildVolume &

build_volume

)

{
    unsigned int num_printable = 0;
    for (ModelObject* model_object : this->objects)
        num_printable += model_object->update_instances_print_volume_state(build_volume);
    //BBS: add logs for build_volume
    const BoundingBoxf3& print_volume = build_volume.bounding_volume();
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", print_volume {%1%, %2%, %3%} to {%4%, %5%, %6%}, got %7% printable istances")        %print_volume.min.x() %print_volume.min.y() %print_volume.min.z()%print_volume.max.x() %print_volume.max.y() %print_volume.max.z() %num_printable;
    return num_printable;
}

References Slic3r::BuildVolume::bounding_volume(), Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, and update_print_volume_state().

Referenced by Slic3r::GUI::CalibUtils::process_and_store_3mf(), Slic3r::CLI::run(), and update_print_volume_state().

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Symbol Documentation

cereal::access

friend class cereal::access

friend

References cereal::access.

Referenced by cereal::access.

UndoRedo::StackImpl

friend class UndoRedo::StackImpl

friend

Member Data Documentation

backup_path

std::string Slic3r::Model::backup_path

private

Referenced by ~Model(), get_backup_path(), load_from(), remove_backup_path_if_exist(), and set_backup_path().

cad_recipe

std::string Slic3r::Model::cad_recipe

Referenced by Slic3r::_BBS_3MF_Exporter::_add_cad_recipe_file_to_archive().

calib_pa_pattern

std::unique_ptr<CalibPressureAdvancePattern> Slic3r::Model::calib_pa_pattern

Referenced by Slic3r::GUI::Plater::_calib_pa_pattern(), Slic3r::GUI::Plater::_calib_pa_pattern_gen_gcode(), Slic3r::GUI::CalibUtils::calib_pa_pattern(), load_from(), Slic3r::GUI::Plater::load_project(), Slic3r::GUI::Plater::new_project(), and Slic3r::GUI::CalibUtils::process_and_store_3mf().

curr_plate_index

int Slic3r::Model::curr_plate_index { 0 }

{ 0 };

Referenced by Slic3r::GUI::Plater::calib_temp(), get_curr_plate_custom_gcodes(), Slic3r::CLI::run(), and anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_two_color_cube_and_export().

design_info

std::shared_ptr<ModelDesignInfo> Slic3r::Model::design_info = nullptr

Referenced by Slic3r::_BBS_3MF_Exporter::_add_model_file_to_archive(), Slic3r::GUI::Plater::priv::load_files(), load_from(), Slic3r::GUI::ProjectPanel::on_reload(), and SetDesigner().

extruderParamsMap

std::map< size_t, ExtruderParams > Slic3r::Model::extruderParamsMap = { {0,{"",0,0}}}

static

Referenced by Slic3r::getadhesionCoeff(), Slic3r::getadhesionCoeff(), Slic3r::getTemperatureFromExtruder(), getThermalLength(), Slic3r::GUI::has_filaments(), and setExtruderParams().

m_id

ObjectID Slic3r::ObjectBase::m_id

privateinherited

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

materials

ModelMaterialMap Slic3r::Model::materials

Referenced by Slic3r::check_model_ids_equal(), Slic3r::check_model_ids_validity(), load(), and save().

md_name

std::vector<std::string> Slic3r::Model::md_name

Referenced by Slic3r::_BBS_3MF_Exporter::_add_model_file_to_archive(), load_from(), and Slic3r::CLI::run().

md_value

std::vector<std::string> Slic3r::Model::md_value

Referenced by Slic3r::_BBS_3MF_Exporter::_add_model_file_to_archive(), load_from(), and Slic3r::CLI::run().

mk_name

std::string Slic3r::Model::mk_name

Referenced by Slic3r::_BBS_3MF_Exporter::_add_model_file_to_archive(), load_from(), and Slic3r::CLI::run().

mk_version

std::string Slic3r::Model::mk_version

Referenced by Slic3r::_BBS_3MF_Exporter::_add_model_file_to_archive(), load_from(), and Slic3r::CLI::run().

model_info

std::shared_ptr<ModelInfo> Slic3r::Model::model_info = nullptr

Referenced by Slic3r::_BBS_3MF_Exporter::_add_model_file_to_archive(), Slic3r::GUI::Plater::priv::load_files(), load_from(), Slic3r::GUI::ProjectPanel::on_reload(), PrinterFileSystem::ParseThumbnail(), and Slic3r::_BBS_3MF_Exporter::save_model_to_file().

need_backup

bool Slic3r::Model::need_backup = false

private

Referenced by add_object(), is_need_backup(), and set_need_backup().

next_object_backup_id

int Slic3r::Model::next_object_backup_id = 1

private

Referenced by clear_objects(), get_object_backup_id(), load_from(), and set_object_backup_id().

object_backup_id_map

std::map<int, int> Slic3r::Model::object_backup_id_map

private

Referenced by add_object(), clear_objects(), get_object_backup_id(), get_object_backup_id(), load_from(), and set_object_backup_id().

objects

ModelObjectPtrs Slic3r::Model::objects

Referenced by Slic3r::GUI::anonymous_namespace{Plater.cpp}::SvgArchivePathsRestorer::SvgArchivePathsRestorer(), Slic3r::_BBS_3MF_Exporter::_add_brim_ear_points_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_cut_information_file_to_archive(), Slic3r::_3MF_Exporter::_add_layer_config_ranges_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_layer_config_ranges_file_to_archive(), Slic3r::_3MF_Exporter::_add_layer_height_profile_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_layer_height_profile_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_model_config_file_to_archive(), Slic3r::_3MF_Exporter::_add_model_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_model_file_to_archive(), Slic3r::_3MF_Exporter::_add_sla_drain_holes_file_to_archive(), Slic3r::_3MF_Exporter::_add_sla_support_points_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_slice_info_config_file_to_archive(), Slic3r::GUI::Plater::_calib_apply_belt_mode(), Slic3r::GUI::Plater::_calib_pa_pattern(), Slic3r::GUI::Plater::_calib_pa_tower(), Slic3r::GUI::Plater::_calib_temp_belt_sectioned(), Slic3r::_3MF_Importer::_load_model_from_file(), Slic3r::GUI::Plater::priv::actualize_object_warnings(), adjust_min_z(), Slic3r::GUI::MenuFactory::append_menu_item_edit_svg(), Slic3r::GUI::MenuFactory::append_menu_item_edit_text(), Slic3r::GUI::Plater::priv::apply_textured_mesh_import_result(), Slic3r::GUI::belt_calib_flip_ringing_tower(), Slic3r::GUI::calc_angle(), Slic3r::GUI::calc_distance(), Slic3r::GUI::calc_surface_offset(), Slic3r::GUI::GLGizmoSVG::calculate_scale(), Slic3r::GUI::Plater::Calib_Cornering(), Slic3r::GUI::CalibUtils::calib_flowrate(), Slic3r::GUI::Plater::calib_input_shaping_damp(), Slic3r::GUI::Plater::calib_input_shaping_freq(), Slic3r::GUI::CalibUtils::calib_max_vol_speed(), Slic3r::GUI::Plater::calib_max_vol_speed(), Slic3r::GUI::CalibUtils::calib_pa_pattern(), Slic3r::GUI::CalibUtils::calib_retraction(), Slic3r::GUI::Plater::calib_retraction(), Slic3r::GUI::Plater::calib_temp(), Slic3r::GUI::CalibUtils::calib_temptue(), Slic3r::GUI::CalibUtils::calib_VFA(), Slic3r::GUI::Plater::calib_VFA(), Slic3r::GUI::Plater::changed_mesh(), Slic3r::check_model_ids_equal(), Slic3r::check_model_ids_validity(), Slic3r::GLVolumeCollection::check_outside_state(), Slic3r::GUI::Plater::clear_before_change_mesh(), Slic3r::GUI::ArrangeJob::clear_input(), Slic3r::GUI::OrientJob::clear_input(), collect_reusable_objects(), construct_assemble_list(), Slic3r::_BBS_3MF_Exporter::convert_instance_id_to_resource_id(), Slic3r::GUI::create_meshes(), Slic3r::GUI::cut_model(), Slic3r::GUI::GLGizmoFlatten::data_changed(), delete_object(), delete_object(), Slic3r::GUI::do_local_z_rotate(), anonymous_namespace{SurfaceDrag.cpp}::dragging(), Slic3r::duplicate(), Slic3r::duplicate_objects(), Slic3r::GUI::PartPlateList::duplicate_plate(), Slic3r::GUI::ensure_belt_purge_tower(), Slic3r::GUI::face_selected_volume_to_camera(), anonymous_namespace{EmbossJob.cpp}::CreateObjectJob::finalize(), Slic3r::get_arrange_poly(), Slic3r::get_arrange_polys(), Slic3r::GUI::GLGizmoCut3D::get_cut_matrix(), anonymous_namespace{SurfaceDrag.cpp}::get_fix_transformation(), Slic3r::GUI::GLGizmoAlignment::get_items_count(), Slic3r::GUI::get_model_instance(), Slic3r::GUI::get_model_object(), Slic3r::GUI::get_model_volume(), Slic3r::GUI::get_model_volume(), Slic3r::GUI::GLGizmoAlignment::get_parent_box(), Slic3r::GUI::GLGizmoAlignment::get_selected_objects_info(), Slic3r::GUI::GLGizmoAlignment::get_selected_part_volumes(), Slic3r::GUI::Selection::get_selected_single_object(), Slic3r::GUI::Selection::get_selected_single_volume(), Slic3r::GUI::get_selected_volume(), Slic3r::GUI::get_selected_volume(), Slic3r::GUI::get_volume(), Slic3r::GUI::GLGizmoMeasure::init_plane_glmodel(), anonymous_namespace{GLGizmoEmboss.cpp}::init_text_lines(), Slic3r::MeshInspect::inspect_to_json(), Slic3r::PaintCLI::inspect_to_json(), Slic3r::GUI::Plater::is_empty_project(), load(), Slic3r::load_amf_archive(), Slic3r::load_amf_file(), Slic3r::GUI::Tab::load_current_preset(), Slic3r::GUI::ObjectList::load_mesh_object(), Slic3r::GUI::ObjectList::load_modifier(), Slic3r::GUI::GLCanvas3D::load_object(), Slic3r::load_svg(), main(), Slic3r::Step::mesh(), Slic3r::model_has_advanced_features(), Slic3r::model_has_multi_part_objects(), Slic3r::GUI::GLCanvas3D::CenterOfMass::model_markers(), Slic3r::model_object_list_equal(), Slic3r::model_object_list_extended(), obj_import_face_color_deal(), obj_import_vertex_color_deal(), Slic3r::GUI::Plater::priv::on_process_completed(), Slic3r::GUI::GLGizmoBrimEars::on_render(), Slic3r::GUI::GLGizmoEmboss::on_render(), Slic3r::GUI::Plater::priv::on_right_click(), Slic3r::GUI::CommonGizmosDataObjects::SelectionInfo::on_update(), Slic3r::GUI::Plater::open_3mf_file(), Slic3r::Cut::perform_with_groove(), Slic3r::GUI::FillBedJob::prepare(), Slic3r::GUI::ArrangeJob::prepare_all(), Slic3r::GUI::ArrangeJob::prepare_partplate(), Slic3r::GUI::OrientJob::prepare_partplate(), Slic3r::GUI::ArrangeJob::prepare_selected(), Slic3r::GUI::OrientJob::prepare_selected(), Slic3r::GUI::OrientJob::prepare_selection(), Slic3r::GUI::CalibUtils::process_and_store_3mf(), Slic3r::GUI::GLGizmoCut3D::process_contours(), Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp}::project_used_filament_slots(), Slic3r::GUI::anonymous_namespace{Plater.cpp}::publish(), read_from_archive(), read_from_file(), read_from_step(), Slic3r::GUI::read_model_from_file(), Slic3r::GUI::GLGizmoMeasure::register_single_mesh_pick(), Slic3r::GUI::Plater::priv::reload_from_disk(), Slic3r::remap_model_filament_slots(), removed_objects_with_zero_volume(), Slic3r::GUI::GLCanvas3D::Labels::render(), Slic3r::GUI::Plater::priv::replace_volume_with_stl(), Slic3r::CLI::run(), Slic3r::GUI::Plater::priv::run_textured_mesh_import_dialog(), save(), Slic3r::GUI::GLCanvas3D::LayersEditing::select_object(), Slic3r::GUI::Plater::priv::set_current_panel(), Slic3r::GUI::CalibUtils::set_for_auto_pa_model_and_config(), Slic3r::GUI::GLGizmoSVG::set_volume_by_selection(), Slic3r::GUI::ObjectList::set_volume_type(), Slic3r::GUI::Plater::show_object_info(), Slic3r::sort_object_instances_by_model_order(), Slic3r::GUI::Plater::priv::split_object(), anonymous_namespace{EmbossJob.cpp}::start_create_volume_on_surface_job(), Slic3r::GUI::Emboss::start_create_volume_without_position(), anonymous_namespace{SurfaceDrag.cpp}::start_dragging(), Slic3r::GUI::synchronize_model_after_cut(), Slic3r::GUI::GLGizmoCut3D::toggle_model_objects_visibility(), Slic3r::GUI::ObjectGridTable::update_value_to_object(), Slic3r::GUI::verify_instances_rotation_synchronized(), and Slic3r::GUI::world_matrix_fixed().

plates_custom_gcodes

std::map<int, CustomGCode::Info> Slic3r::Model::plates_custom_gcodes

Referenced by Slic3r::_BBS_3MF_Exporter::_add_custom_gcode_per_print_z_file_to_archive(), Slic3r::GUI::Plater::_calib_pa_pattern_gen_gcode(), Slic3r::GUI::CalibUtils::calib_pa_pattern(), Slic3r::GUI::Plater::calib_temp(), get_curr_plate_custom_gcodes(), Slic3r::GUI::Plater::priv::load_files(), Slic3r::GUI::Plater::load_project(), Slic3r::GUI::Plater::new_project(), Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp}::project_used_filament_slots(), read_from_archive(), and anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_two_color_cube_and_export().

printSpeedMap

GlobalSpeedMap Slic3r::Model::printSpeedMap {}

static

Referenced by findMaxSpeed(), getBedPolygon(), and setPrintSpeedTable().

profile_info

std::shared_ptr<ModelProfileInfo> Slic3r::Model::profile_info = nullptr

Referenced by load_from(), and Slic3r::GUI::ProjectPanel::on_reload().

s_last_id

size_t Slic3r::ObjectBase::s_last_id = 0

staticprivateinherited

Referenced by generate_new_id().

stl_design_country

std::string Slic3r::Model::stl_design_country

Referenced by load_from().

stl_design_id

std::string Slic3r::Model::stl_design_id

Referenced by load_from().

texture_mesh

std::shared_ptr<TexturedMesh> Slic3r::Model::texture_mesh

Referenced by Slic3r::GUI::Plater::priv::apply_textured_mesh_import_result(), clear_objects(), read_from_file(), and Slic3r::GUI::Plater::priv::run_textured_mesh_import_dialog().

wipe_tower

ModelWipeTower Slic3r::Model::wipe_tower

Referenced by load(), and save().

---

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

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