OrcaSlicer latest
OrcaSlicer
Loading...
Searching...
No Matches
Model.hpp File Reference
#include "BoundingBox.hpp"
#include "Polygon.hpp"
#include "Semver.hpp"
#include "libslic3r.h"
#include "enum_bitmask.hpp"
#include "Geometry.hpp"
#include "ObjectID.hpp"
#include "Point.hpp"
#include "AppConfig.hpp"
#include "PrintConfig.hpp"
#include "Slicing.hpp"
#include "SLA/SupportPoint.hpp"
#include "SLA/Hollowing.hpp"
#include "BrimEarsPoint.hpp"
#include "TriangleMesh.hpp"
#include "CustomGCode.hpp"
#include "calib.hpp"
#include "TextConfiguration.hpp"
#include "EmbossShape.hpp"
#include "TriangleSelector.hpp"
#include "TextureDisplacement.hpp"
#include "Format/bbs_3mf.hpp"
#include "Format/STEP.hpp"
#include "Format/STL.hpp"
#include "Format/OBJ.hpp"
#include <array>
#include <cereal/access.hpp>
#include <cereal/types/base_class.hpp>
#include <cassert>
#include <cstddef>
#include <iterator>
#include <initializer_list>
#include <cereal/specialize.hpp>
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include <algorithm>
#include <functional>
#include <optional>
Include dependency graph for Model.hpp:

Go to the source code of this file.

Classes

class  Slic3r::ModelConfigObject
class  Slic3r::Internal::StaticSerializationWrapper< T >
class  Slic3r::ModelMaterial
class  Slic3r::LayerHeightProfile
struct  Slic3r::CutConnectorParas
struct  Slic3r::CutConnectorAttributes
struct  Slic3r::CutConnector
class  Slic3r::ModelObject
class  Slic3r::FacetsAnnotation
class  Slic3r::ModelVolume
struct  Slic3r::ModelVolume::Source
struct  Slic3r::ModelVolume::CutInfo
class  Slic3r::ModelInstance
class  Slic3r::ModelWipeTower
struct  Slic3r::ExtruderParams
struct  Slic3r::GlobalSpeedMap
class  Slic3r::ModelProfileInfo
class  Slic3r::ModelDesignInfo
class  Slic3r::ModelInfo
class  Slic3r::Model
struct  cereal::specialize< Archive, Slic3r::ModelVolume, cereal::specialization::member_load_save >
struct  cereal::specialize< Archive, Slic3r::Model, cereal::specialization::member_load_save >
struct  cereal::specialize< Archive, Slic3r::ModelObject, cereal::specialization::member_load_save >
struct  cereal::specialize< Archive, Slic3r::ModelConfigObject, cereal::specialization::member_serialize >

Namespaces

namespace  cereal
 External Cereal serialization of ExPolygons.
namespace  Slic3r
 |/ Copyright (c) Prusa Research 2020 - 2023 Enrico Turri @enricoturri1966 |/ |/ PrusaSlicer is released under the terms of the AGPLv3 or higher |/
namespace  Slic3r::UndoRedo
namespace  Slic3r::Internal

Macros

#define OBJECTBASE_DERIVED_COPY_MOVE_CLONE(TYPE)

Typedefs

typedef std::string Slic3r::t_model_material_id
typedef std::string Slic3r::t_model_material_attribute
typedef std::map< t_model_material_attribute, std::string > Slic3r::t_model_material_attributes
typedef std::map< t_model_material_id, ModelMaterial * > Slic3r::ModelMaterialMap
typedef std::vector< ModelVolume * > Slic3r::ModelVolumePtrs
using Slic3r::ModelInstancePtrs = std::vector<ModelInstance*>
using Slic3r::CutConnectors = std::vector<CutConnector>

Enumerations

enum class  Slic3r::CutMode : int { Slic3r::cutPlanar , Slic3r::cutTongueAndGroove }
enum class  Slic3r::CutConnectorType : int { Slic3r::Plug , Slic3r::Dowel , Slic3r::Snap , Slic3r::Undef }
enum class  Slic3r::CutConnectorStyle : int { Slic3r::Prism , Slic3r::Frustum , Slic3r::Undef }
enum class  Slic3r::CutConnectorShape : int {
  Slic3r::Triangle , Slic3r::Square , Slic3r::Hexagon , Slic3r::Circle ,
  Slic3r::Undef
}
enum class  Slic3r::ModelVolumeType : int {
  Slic3r::INVALID = -1 , Slic3r::MODEL_PART = 0 , Slic3r::NEGATIVE_VOLUME , Slic3r::PARAMETER_MODIFIER ,
  Slic3r::SUPPORT_BLOCKER , Slic3r::SUPPORT_ENFORCER , Slic3r::PRECISE_SEAM_CENTER , Slic3r::PRECISE_SEAM_LEFT ,
  Slic3r::PRECISE_SEAM_RIGHT , Slic3r::PRECISE_SEAM_ENFORCED , Slic3r::PRECISE_SEAM_BLOCKED , Slic3r::PRECISE_SEAM_NEUTRAL
}
enum class  Slic3r::ConversionType : int { Slic3r::CONV_TO_INCH , Slic3r::CONV_FROM_INCH , Slic3r::CONV_TO_METER , Slic3r::CONV_FROM_METER }
enum class  Slic3r::En3mfType : int { Slic3r::From_Orca , Slic3r::From_BBS , Slic3r::From_Prusa , Slic3r::From_Other }
enum  Slic3r::ModelInstanceEPrintVolumeState : unsigned char {
  Slic3r::ModelInstancePVS_Inside , Slic3r::ModelInstancePVS_Limited , Slic3r::ModelInstancePVS_Partly_Outside , Slic3r::ModelInstancePVS_Fully_Outside ,
  Slic3r::ModelInstanceNum_BedStates
}

Functions

template<class T>
void cereal::load_optional (BinaryInputArchive &ar, std::shared_ptr< const T > &ptr)
template<class T>
void cereal::save_optional (BinaryOutputArchive &ar, const std::shared_ptr< const T > &ptr)
template<class T>
void cereal::load_by_value (BinaryInputArchive &ar, T &obj)
template<class T>
void cereal::save_by_value (BinaryOutputArchive &ar, const T &obj)
bool Slic3r::is_precise_seam (ModelVolumeType t)
bool Slic3r::is_precise_seam_strong (ModelVolumeType t)
bool Slic3r::is_precise_seam_weak (ModelVolumeType t)
void Slic3r::model_volumes_sort_by_id (ModelVolumePtrs &model_volumes)
const ModelVolume * Slic3r::model_volume_find_by_id (const ModelVolumePtrs &model_volumes, const ObjectID id)
bool Slic3r::model_object_list_equal (const Model &model_old, const Model &model_new)
bool Slic3r::model_object_list_extended (const Model &model_old, const Model &model_new)
bool Slic3r::model_volume_list_changed (const ModelObject &model_object_old, const ModelObject &model_object_new, const ModelVolumeType type)
bool Slic3r::model_volume_list_changed (const ModelObject &model_object_old, const ModelObject &model_object_new, const std::initializer_list< ModelVolumeType > &types)
bool Slic3r::model_custom_supports_data_changed (const ModelObject &mo, const ModelObject &mo_new)
bool Slic3r::model_custom_seam_data_changed (const ModelObject &mo, const ModelObject &mo_new)
bool Slic3r::model_mmu_segmentation_data_changed (const ModelObject &mo, const ModelObject &mo_new)
bool Slic3r::model_fuzzy_skin_data_changed (const ModelObject &mo, const ModelObject &mo_new)
bool Slic3r::model_brim_points_data_changed (const ModelObject &mo, const ModelObject &mo_new)
bool Slic3r::model_has_multi_part_objects (const Model &model)
bool Slic3r::model_has_advanced_features (const Model &model)
void Slic3r::remap_model_filament_slots (Model &model, const std::map< int, int > &slot_relocations)
void Slic3r::check_model_ids_validity (const Model &model)
void Slic3r::check_model_ids_equal (const Model &model1, const Model &model2)

Variables

static const float Slic3r::SINKING_Z_THRESHOLD = -0.001f
static const double Slic3r::SINKING_MIN_Z_THRESHOLD = 0.05

Class Documentation

◆ Slic3r::CutConnectorParas

struct Slic3r::CutConnectorParas
Class Members
float snap_bulge_proportion {0.15}
float snap_space_proportion {0.3}

◆ Slic3r::ExtruderParams

struct Slic3r::ExtruderParams
Collaboration diagram for Slic3r::ExtruderParams:
Class Members
int bedTemp
double heatEndTemp
string materialName

◆ Slic3r::GlobalSpeedMap

struct Slic3r::GlobalSpeedMap
Collaboration diagram for Slic3r::GlobalSpeedMap:
Class Members
Polygon bed_poly
double externalPerimeterSpeed
double infillSpeed
double maxSpeed
double perimeterSpeed
double smallPerimeterSpeed
double smallSupportPerimeterSpeed
double solidInfillSpeed
double supportSpeed
double topSolidInfillSpeed

◆ Slic3r::ModelProfileInfo

class Slic3r::ModelProfileInfo
Collaboration diagram for Slic3r::ModelProfileInfo:
Class Members
string ProfileCover
string ProfileDescription
string ProfileTile
string ProfileUserId
string ProfileUserName

◆ Slic3r::ModelDesignInfo

class Slic3r::ModelDesignInfo
Collaboration diagram for Slic3r::ModelDesignInfo:
Class Members
string Designer
string DesignerUserId
string DesignId

◆ cereal::specialize< Archive, Slic3r::ModelVolume, cereal::specialization::member_load_save >

struct cereal::specialize< Archive, Slic3r::ModelVolume, cereal::specialization::member_load_save >
template<class Archive>
struct cereal::specialize< Archive, Slic3r::ModelVolume, cereal::specialization::member_load_save >

◆ cereal::specialize< Archive, Slic3r::Model, cereal::specialization::member_load_save >

struct cereal::specialize< Archive, Slic3r::Model, cereal::specialization::member_load_save >
template<class Archive>
struct cereal::specialize< Archive, Slic3r::Model, cereal::specialization::member_load_save >

◆ cereal::specialize< Archive, Slic3r::ModelObject, cereal::specialization::member_load_save >

struct cereal::specialize< Archive, Slic3r::ModelObject, cereal::specialization::member_load_save >
template<class Archive>
struct cereal::specialize< Archive, Slic3r::ModelObject, cereal::specialization::member_load_save >

◆ cereal::specialize< Archive, Slic3r::ModelConfigObject, cereal::specialization::member_serialize >

struct cereal::specialize< Archive, Slic3r::ModelConfigObject, cereal::specialization::member_serialize >
template<class Archive>
struct cereal::specialize< Archive, Slic3r::ModelConfigObject, cereal::specialization::member_serialize >

Macro Definition Documentation

◆ OBJECTBASE_DERIVED_COPY_MOVE_CLONE

#define OBJECTBASE_DERIVED_COPY_MOVE_CLONE ( TYPE)
Value:
/* Copy a model, copy the IDs. The Print::apply() will call the TYPE::copy() method */ \
/* to make a private copy for background processing. */ \
static TYPE* new_copy(const TYPE &rhs) { auto *ret = new TYPE(rhs); assert(ret->id() == rhs.id()); return ret; } \
static TYPE* new_copy(TYPE &&rhs) { auto *ret = new TYPE(std::move(rhs)); assert(ret->id() == rhs.id()); return ret; } \
static TYPE make_copy(const TYPE &rhs) { TYPE ret(rhs); assert(ret.id() == rhs.id()); return ret; } \
static TYPE make_copy(TYPE &&rhs) { TYPE ret(std::move(rhs)); assert(ret.id() == rhs.id()); return ret; } \
TYPE& assign_copy(const TYPE &rhs); \
TYPE& assign_copy(TYPE &&rhs); \
/* Copy a TYPE, generate new IDs. The front end will use this call. */ \
static TYPE* new_clone(const TYPE &rhs) { \
/* Default constructor assigning an invalid ID. */ \
auto obj = new TYPE(-1); \
obj->assign_clone(rhs); \
assert(obj->id().valid() && obj->id() != rhs.id()); \
return obj; \
} \
TYPE make_clone(const TYPE &rhs) { \
/* Default constructor assigning an invalid ID. */ \
TYPE obj(-1); \
obj.assign_clone(rhs); \
assert(obj.id().valid() && obj.id() != rhs.id()); \
return obj; \
} \
TYPE& assign_clone(const TYPE &rhs) { \
this->assign_copy(rhs); \
assert(this->id().valid() && this->id() == rhs.id()); \
this->assign_new_unique_ids_recursive(); \
assert(this->id().valid() && this->id() != rhs.id()); \
return *this; \
}
142#define OBJECTBASE_DERIVED_COPY_MOVE_CLONE(TYPE) \
143 /* Copy a model, copy the IDs. The Print::apply() will call the TYPE::copy() method */ \
144 /* to make a private copy for background processing. */ \
145 static TYPE* new_copy(const TYPE &rhs) { auto *ret = new TYPE(rhs); assert(ret->id() == rhs.id()); return ret; } \
146 static TYPE* new_copy(TYPE &&rhs) { auto *ret = new TYPE(std::move(rhs)); assert(ret->id() == rhs.id()); return ret; } \
147 static TYPE make_copy(const TYPE &rhs) { TYPE ret(rhs); assert(ret.id() == rhs.id()); return ret; } \
148 static TYPE make_copy(TYPE &&rhs) { TYPE ret(std::move(rhs)); assert(ret.id() == rhs.id()); return ret; } \
149 TYPE& assign_copy(const TYPE &rhs); \
150 TYPE& assign_copy(TYPE &&rhs); \
151 /* Copy a TYPE, generate new IDs. The front end will use this call. */ \
152 static TYPE* new_clone(const TYPE &rhs) { \
153 /* Default constructor assigning an invalid ID. */ \
154 auto obj = new TYPE(-1); \
155 obj->assign_clone(rhs); \
156 assert(obj->id().valid() && obj->id() != rhs.id()); \
157 return obj; \
158 } \
159 TYPE make_clone(const TYPE &rhs) { \
160 /* Default constructor assigning an invalid ID. */ \
161 TYPE obj(-1); \
162 obj.assign_clone(rhs); \
163 assert(obj.id().valid() && obj.id() != rhs.id()); \
164 return obj; \
165 } \
166 TYPE& assign_clone(const TYPE &rhs) { \
167 this->assign_copy(rhs); \
168 assert(this->id().valid() && this->id() == rhs.id()); \
169 this->assign_new_unique_ids_recursive(); \
170 assert(this->id().valid() && this->id() != rhs.id()); \
171 return *this; \
172 }