687 lines
33 KiB
C++
687 lines
33 KiB
C++
#ifndef slic3r_Model_hpp_
|
|
#define slic3r_Model_hpp_
|
|
|
|
#include "libslic3r.h"
|
|
#include "PrintConfig.hpp"
|
|
#include "Layer.hpp"
|
|
#include "Point.hpp"
|
|
#include "TriangleMesh.hpp"
|
|
#include "Slicing.hpp"
|
|
#include <map>
|
|
#include <string>
|
|
#include <utility>
|
|
#include <vector>
|
|
#if ENABLE_MODELVOLUME_TRANSFORM
|
|
#include "Geometry.hpp"
|
|
#endif // ENABLE_MODELVOLUME_TRANSFORM
|
|
|
|
namespace Slic3r {
|
|
|
|
class Model;
|
|
class ModelInstance;
|
|
class ModelMaterial;
|
|
class ModelObject;
|
|
class ModelVolume;
|
|
class Print;
|
|
class SLAPrint;
|
|
|
|
typedef std::string t_model_material_id;
|
|
typedef std::string t_model_material_attribute;
|
|
typedef std::map<t_model_material_attribute, std::string> t_model_material_attributes;
|
|
|
|
typedef std::map<t_model_material_id, ModelMaterial*> ModelMaterialMap;
|
|
typedef std::vector<ModelObject*> ModelObjectPtrs;
|
|
typedef std::vector<ModelVolume*> ModelVolumePtrs;
|
|
typedef std::vector<ModelInstance*> ModelInstancePtrs;
|
|
|
|
// Unique identifier of a Model, ModelObject, ModelVolume, ModelInstance or ModelMaterial.
|
|
// Used to synchronize the front end (UI) with the back end (BackgroundSlicingProcess / Print / PrintObject)
|
|
// Valid IDs are strictly positive (non zero).
|
|
// It is declared as an object, as some compilers (notably msvcc) consider a typedef size_t equivalent to size_t
|
|
// for parameter overload.
|
|
struct ModelID
|
|
{
|
|
ModelID(size_t id) : id(id) {}
|
|
|
|
bool operator==(const ModelID &rhs) const { return this->id == rhs.id; }
|
|
bool operator!=(const ModelID &rhs) const { return this->id != rhs.id; }
|
|
bool operator< (const ModelID &rhs) const { return this->id < rhs.id; }
|
|
bool operator> (const ModelID &rhs) const { return this->id > rhs.id; }
|
|
bool operator<=(const ModelID &rhs) const { return this->id <= rhs.id; }
|
|
bool operator>=(const ModelID &rhs) const { return this->id >= rhs.id; }
|
|
|
|
size_t id;
|
|
};
|
|
|
|
// Base for Model, ModelObject, ModelVolume, ModelInstance or ModelMaterial to provide a unique ID
|
|
// to synchronize the front end (UI) with the back end (BackgroundSlicingProcess / Print / PrintObject).
|
|
// Achtung! The s_last_id counter is not thread safe, so it is expected, that the ModelBase derived instances
|
|
// are only instantiated from the main thread.
|
|
class ModelBase
|
|
{
|
|
public:
|
|
ModelID id() const { return m_id; }
|
|
|
|
protected:
|
|
// Constructors to be only called by derived classes.
|
|
// Default constructor to assign a unique ID.
|
|
ModelBase() : m_id(generate_new_id()) {}
|
|
// Constructor with ignored int parameter to assign an invalid ID, to be replaced
|
|
// by an existing ID copied from elsewhere.
|
|
ModelBase(int) : m_id(ModelID(0)) {}
|
|
|
|
// Use with caution!
|
|
void set_new_unique_id() { m_id = generate_new_id(); }
|
|
void set_invalid_id() { m_id = 0; }
|
|
// Use with caution!
|
|
void copy_id(const ModelBase &rhs) { m_id = rhs.id(); }
|
|
|
|
// Override this method if a ModelBase derived class owns other ModelBase derived instances.
|
|
void assign_new_unique_ids_recursive() { this->set_new_unique_id(); }
|
|
|
|
private:
|
|
ModelID m_id;
|
|
|
|
static inline ModelID generate_new_id() { return ModelID(++ s_last_id); }
|
|
static size_t s_last_id;
|
|
};
|
|
|
|
#define MODELBASE_DERIVED_COPY_MOVE_CLONE(TYPE) \
|
|
/* 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) { return new TYPE(rhs); } \
|
|
static TYPE* new_copy(TYPE &&rhs) { return new TYPE(std::move(rhs)); } \
|
|
static TYPE make_copy(const TYPE &rhs) { return TYPE(rhs); } \
|
|
static TYPE make_copy(TYPE &&rhs) { return TYPE(std::move(rhs)); } \
|
|
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); \
|
|
return obj; \
|
|
} \
|
|
TYPE make_clone(const TYPE &rhs) { \
|
|
/* Default constructor assigning an invalid ID. */ \
|
|
TYPE obj(-1); \
|
|
obj.assign_clone(rhs); \
|
|
return obj; \
|
|
} \
|
|
TYPE& assign_clone(const TYPE &rhs) { \
|
|
this->assign_copy(rhs); \
|
|
this->assign_new_unique_ids_recursive(); \
|
|
return *this; \
|
|
}
|
|
|
|
#define MODELBASE_DERIVED_PRIVATE_COPY_MOVE(TYPE) \
|
|
private: \
|
|
/* Private constructor with an unused int parameter will create a TYPE instance with an invalid ID. */ \
|
|
explicit TYPE(int) : ModelBase(-1) {}; \
|
|
void assign_new_unique_ids_recursive();
|
|
|
|
// Material, which may be shared across multiple ModelObjects of a single Model.
|
|
class ModelMaterial : public ModelBase
|
|
{
|
|
public:
|
|
// Attributes are defined by the AMF file format, but they don't seem to be used by Slic3r for any purpose.
|
|
t_model_material_attributes attributes;
|
|
// Dynamic configuration storage for the object specific configuration values, overriding the global configuration.
|
|
DynamicPrintConfig config;
|
|
|
|
Model* get_model() const { return m_model; }
|
|
void apply(const t_model_material_attributes &attributes)
|
|
{ this->attributes.insert(attributes.begin(), attributes.end()); }
|
|
|
|
protected:
|
|
friend class Model;
|
|
// Constructor, which assigns a new unique ID.
|
|
ModelMaterial(Model *model) : m_model(model) {}
|
|
// Copy constructor copies the ID and m_model!
|
|
ModelMaterial(const ModelMaterial &rhs) = default;
|
|
void set_model(Model *model) { m_model = model; }
|
|
|
|
private:
|
|
// Parent, owning this material.
|
|
Model *m_model;
|
|
|
|
ModelMaterial() = delete;
|
|
ModelMaterial(ModelMaterial &&rhs) = delete;
|
|
ModelMaterial& operator=(const ModelMaterial &rhs) = delete;
|
|
ModelMaterial& operator=(ModelMaterial &&rhs) = delete;
|
|
};
|
|
|
|
// A printable object, possibly having multiple print volumes (each with its own set of parameters and materials),
|
|
// and possibly having multiple modifier volumes, each modifier volume with its set of parameters and materials.
|
|
// Each ModelObject may be instantiated mutliple times, each instance having different placement on the print bed,
|
|
// different rotation and different uniform scaling.
|
|
class ModelObject : public ModelBase
|
|
{
|
|
friend class Model;
|
|
public:
|
|
std::string name;
|
|
std::string input_file; // XXX: consider fs::path
|
|
// Instances of this ModelObject. Each instance defines a shift on the print bed, rotation around the Z axis and a uniform scaling.
|
|
// Instances are owned by this ModelObject.
|
|
ModelInstancePtrs instances;
|
|
// Printable and modifier volumes, each with its material ID and a set of override parameters.
|
|
// ModelVolumes are owned by this ModelObject.
|
|
ModelVolumePtrs volumes;
|
|
// Configuration parameters specific to a single ModelObject, overriding the global Slic3r settings.
|
|
DynamicPrintConfig config;
|
|
// Variation of a layer thickness for spans of Z coordinates.
|
|
t_layer_height_ranges layer_height_ranges;
|
|
// Profile of increasing z to a layer height, to be linearly interpolated when calculating the layers.
|
|
// The pairs of <z, layer_height> are packed into a 1D array to simplify handling by the Perl XS.
|
|
std::vector<coordf_t> layer_height_profile;
|
|
// layer_height_profile is initialized when the layer editing mode is entered.
|
|
// Only if the user really modified the layer height, layer_height_profile_valid is set
|
|
// and used subsequently by the PrintObject.
|
|
bool layer_height_profile_valid;
|
|
|
|
// This vector holds position of selected support points for SLA. The data are
|
|
// saved in mesh coordinates to allow using them for several instances.
|
|
std::vector<Vec3f> sla_support_points;
|
|
|
|
/* This vector accumulates the total translation applied to the object by the
|
|
center_around_origin() method. Callers might want to apply the same translation
|
|
to new volumes before adding them to this object in order to preserve alignment
|
|
when user expects that. */
|
|
Vec3d origin_translation;
|
|
|
|
Model* get_model() { return m_model; };
|
|
const Model* get_model() const { return m_model; };
|
|
|
|
ModelVolume* add_volume(const TriangleMesh &mesh);
|
|
ModelVolume* add_volume(TriangleMesh &&mesh);
|
|
ModelVolume* add_volume(const ModelVolume &volume);
|
|
ModelVolume* add_volume(const ModelVolume &volume, TriangleMesh &&mesh);
|
|
void delete_volume(size_t idx);
|
|
void clear_volumes();
|
|
bool is_multiparts() const { return volumes.size() > 1; }
|
|
|
|
ModelInstance* add_instance();
|
|
ModelInstance* add_instance(const ModelInstance &instance);
|
|
ModelInstance* add_instance(const Vec3d &offset, const Vec3d &scaling_factor, const Vec3d &rotation);
|
|
void delete_instance(size_t idx);
|
|
void delete_last_instance();
|
|
void clear_instances();
|
|
|
|
// Returns the bounding box of the transformed instances.
|
|
// This bounding box is approximate and not snug.
|
|
// This bounding box is being cached.
|
|
const BoundingBoxf3& bounding_box() const;
|
|
void invalidate_bounding_box() { m_bounding_box_valid = false; }
|
|
|
|
// A mesh containing all transformed instances of this object.
|
|
TriangleMesh mesh() const;
|
|
// Non-transformed (non-rotated, non-scaled, non-translated) sum of non-modifier object volumes.
|
|
// Currently used by ModelObject::mesh() and to calculate the 2D envelope for 2D platter.
|
|
TriangleMesh raw_mesh() const;
|
|
// A transformed snug bounding box around the non-modifier object volumes, without the translation applied.
|
|
// This bounding box is only used for the actual slicing.
|
|
BoundingBoxf3 raw_bounding_box() const;
|
|
// A snug bounding box around the transformed non-modifier object volumes.
|
|
BoundingBoxf3 instance_bounding_box(size_t instance_idx, bool dont_translate = false) const;
|
|
void center_around_origin();
|
|
void ensure_on_bed();
|
|
void translate_instances(const Vec3d& vector);
|
|
void translate_instance(size_t instance_idx, const Vec3d& vector);
|
|
void translate(const Vec3d &vector) { this->translate(vector(0), vector(1), vector(2)); }
|
|
void translate(double x, double y, double z);
|
|
void scale(const Vec3d &versor);
|
|
void scale(const double s) { this->scale(Vec3d(s, s, s)); }
|
|
void scale(double x, double y, double z) { this->scale(Vec3d(x, y, z)); }
|
|
void rotate(double angle, Axis axis);
|
|
void rotate(double angle, const Vec3d& axis);
|
|
void mirror(Axis axis);
|
|
size_t materials_count() const;
|
|
size_t facets_count() const;
|
|
bool needed_repair() const;
|
|
ModelObjectPtrs cut(size_t instance, coordf_t z, bool keep_upper = true, bool keep_lower = true, bool rotate_lower = false); // Note: z is in world coordinates
|
|
void split(ModelObjectPtrs* new_objects);
|
|
void repair();
|
|
|
|
double get_min_z() const;
|
|
double get_instance_min_z(size_t instance_idx) const;
|
|
|
|
// Called by Print::validate() from the UI thread.
|
|
unsigned int check_instances_print_volume_state(const BoundingBoxf3& print_volume);
|
|
|
|
// Print object statistics to console.
|
|
void print_info() const;
|
|
|
|
protected:
|
|
friend class Print;
|
|
friend class SLAPrint;
|
|
// Called by Print::apply() to set the model pointer after making a copy.
|
|
void set_model(Model *model) { m_model = model; }
|
|
|
|
private:
|
|
ModelObject(Model *model) : layer_height_profile_valid(false), m_model(model), origin_translation(Vec3d::Zero()), m_bounding_box_valid(false) {}
|
|
~ModelObject();
|
|
|
|
/* To be able to return an object from own copy / clone methods. Hopefully the compiler will do the "Copy elision" */
|
|
/* (Omits copy and move(since C++11) constructors, resulting in zero - copy pass - by - value semantics). */
|
|
ModelObject(const ModelObject &rhs) : ModelBase(-1), m_model(rhs.m_model) { this->assign_copy(rhs); }
|
|
explicit ModelObject(ModelObject &&rhs) : ModelBase(-1) { this->assign_copy(std::move(rhs)); }
|
|
ModelObject& operator=(const ModelObject &rhs) { this->assign_copy(rhs); m_model = rhs.m_model; return *this; }
|
|
ModelObject& operator=(ModelObject &&rhs) { this->assign_copy(std::move(rhs)); m_model = rhs.m_model; return *this; }
|
|
|
|
MODELBASE_DERIVED_COPY_MOVE_CLONE(ModelObject)
|
|
MODELBASE_DERIVED_PRIVATE_COPY_MOVE(ModelObject)
|
|
|
|
// Parent object, owning this ModelObject. Set to nullptr here, so the macros above will have it initialized.
|
|
Model *m_model = nullptr;
|
|
|
|
// Bounding box, cached.
|
|
mutable BoundingBoxf3 m_bounding_box;
|
|
mutable bool m_bounding_box_valid;
|
|
};
|
|
|
|
// An object STL, or a modifier volume, over which a different set of parameters shall be applied.
|
|
// ModelVolume instances are owned by a ModelObject.
|
|
class ModelVolume : public ModelBase
|
|
{
|
|
public:
|
|
std::string name;
|
|
// The triangular model.
|
|
TriangleMesh mesh;
|
|
// Configuration parameters specific to an object model geometry or a modifier volume,
|
|
// overriding the global Slic3r settings and the ModelObject settings.
|
|
DynamicPrintConfig config;
|
|
|
|
enum Type {
|
|
MODEL_TYPE_INVALID = -1,
|
|
MODEL_PART = 0,
|
|
PARAMETER_MODIFIER,
|
|
SUPPORT_ENFORCER,
|
|
SUPPORT_BLOCKER,
|
|
};
|
|
|
|
// A parent object owning this modifier volume.
|
|
ModelObject* get_object() const { return this->object; };
|
|
Type type() const { return m_type; }
|
|
void set_type(const Type t) { m_type = t; }
|
|
bool is_model_part() const { return m_type == MODEL_PART; }
|
|
bool is_modifier() const { return m_type == PARAMETER_MODIFIER; }
|
|
bool is_support_enforcer() const { return m_type == SUPPORT_ENFORCER; }
|
|
bool is_support_blocker() const { return m_type == SUPPORT_BLOCKER; }
|
|
bool is_support_modifier() const { return m_type == SUPPORT_BLOCKER || m_type == SUPPORT_ENFORCER; }
|
|
t_model_material_id material_id() const { return m_material_id; }
|
|
void set_material_id(t_model_material_id material_id);
|
|
ModelMaterial* material() const;
|
|
void set_material(t_model_material_id material_id, const ModelMaterial &material);
|
|
// Extract the current extruder ID based on this ModelVolume's config and the parent ModelObject's config.
|
|
// Extruder ID is only valid for FFF. Returns -1 for SLA or if the extruder ID is not applicable (support volumes).
|
|
int extruder_id() const;
|
|
|
|
// Split this volume, append the result to the object owning this volume.
|
|
// Return the number of volumes created from this one.
|
|
// This is useful to assign different materials to different volumes of an object.
|
|
size_t split(unsigned int max_extruders);
|
|
void translate(double x, double y, double z) { translate(Vec3d(x, y, z)); }
|
|
void translate(const Vec3d& displacement);
|
|
void scale(const Vec3d& scaling_factors);
|
|
void scale(double x, double y, double z) { scale(Vec3d(x, y, z)); }
|
|
void scale(double s) { scale(Vec3d(s, s, s)); }
|
|
void rotate(double angle, Axis axis);
|
|
void rotate(double angle, const Vec3d& axis);
|
|
void mirror(Axis axis);
|
|
|
|
#if ENABLE_MODELVOLUME_TRANSFORM
|
|
// translates the mesh and the convex hull so that the origin of their vertices is in the center of this volume's bounding box
|
|
void center_geometry();
|
|
#endif // ENABLE_MODELVOLUME_TRANSFORM
|
|
|
|
void calculate_convex_hull();
|
|
const TriangleMesh& get_convex_hull() const;
|
|
|
|
// Helpers for loading / storing into AMF / 3MF files.
|
|
static Type type_from_string(const std::string &s);
|
|
static std::string type_to_string(const Type t);
|
|
|
|
#if ENABLE_MODELVOLUME_TRANSFORM
|
|
const Geometry::Transformation& get_transformation() const { return m_transformation; }
|
|
void set_transformation(const Geometry::Transformation& transformation) { m_transformation = transformation; }
|
|
|
|
const Vec3d& get_offset() const { return m_transformation.get_offset(); }
|
|
double get_offset(Axis axis) const { return m_transformation.get_offset(axis); }
|
|
|
|
void set_offset(const Vec3d& offset) { m_transformation.set_offset(offset); }
|
|
void set_offset(Axis axis, double offset) { m_transformation.set_offset(axis, offset); }
|
|
|
|
const Vec3d& get_rotation() const { return m_transformation.get_rotation(); }
|
|
double get_rotation(Axis axis) const { return m_transformation.get_rotation(axis); }
|
|
|
|
void set_rotation(const Vec3d& rotation) { m_transformation.set_rotation(rotation); }
|
|
void set_rotation(Axis axis, double rotation) { m_transformation.set_rotation(axis, rotation); }
|
|
|
|
Vec3d get_scaling_factor() const { return m_transformation.get_scaling_factor(); }
|
|
double get_scaling_factor(Axis axis) const { return m_transformation.get_scaling_factor(axis); }
|
|
|
|
void set_scaling_factor(const Vec3d& scaling_factor) { m_transformation.set_scaling_factor(scaling_factor); }
|
|
void set_scaling_factor(Axis axis, double scaling_factor) { m_transformation.set_scaling_factor(axis, scaling_factor); }
|
|
|
|
const Vec3d& get_mirror() const { return m_transformation.get_mirror(); }
|
|
double get_mirror(Axis axis) const { return m_transformation.get_mirror(axis); }
|
|
|
|
void set_mirror(const Vec3d& mirror) { m_transformation.set_mirror(mirror); }
|
|
void set_mirror(Axis axis, double mirror) { m_transformation.set_mirror(axis, mirror); }
|
|
|
|
const Transform3d& get_matrix(bool dont_translate = false, bool dont_rotate = false, bool dont_scale = false, bool dont_mirror = false) const { return m_transformation.get_matrix(dont_translate, dont_rotate, dont_scale, dont_mirror); }
|
|
#endif // ENABLE_MODELVOLUME_TRANSFORM
|
|
|
|
protected:
|
|
friend class Print;
|
|
friend class SLAPrint;
|
|
friend class ModelObject;
|
|
|
|
explicit ModelVolume(const ModelVolume &rhs) = default;
|
|
void set_model_object(ModelObject *model_object) { object = model_object; }
|
|
|
|
private:
|
|
// Parent object owning this ModelVolume.
|
|
ModelObject* object;
|
|
// Is it an object to be printed, or a modifier volume?
|
|
Type m_type;
|
|
t_model_material_id m_material_id;
|
|
// The convex hull of this model's mesh.
|
|
TriangleMesh m_convex_hull;
|
|
#if ENABLE_MODELVOLUME_TRANSFORM
|
|
Geometry::Transformation m_transformation;
|
|
#endif // ENABLE_MODELVOLUME_TRANSFORM
|
|
|
|
ModelVolume(ModelObject *object, const TriangleMesh &mesh) : mesh(mesh), m_type(MODEL_PART), object(object)
|
|
{
|
|
if (mesh.stl.stats.number_of_facets > 1)
|
|
calculate_convex_hull();
|
|
}
|
|
ModelVolume(ModelObject *object, TriangleMesh &&mesh, TriangleMesh &&convex_hull) :
|
|
mesh(std::move(mesh)), m_convex_hull(std::move(convex_hull)), m_type(MODEL_PART), object(object) {}
|
|
|
|
#if ENABLE_MODELVOLUME_TRANSFORM
|
|
// Copying an existing volume, therefore this volume will get a copy of the ID assigned.
|
|
ModelVolume(ModelObject *object, const ModelVolume &other) :
|
|
ModelBase(other), // copy the ID
|
|
name(other.name), mesh(other.mesh), m_convex_hull(other.m_convex_hull), config(other.config), m_type(other.m_type), object(object), m_transformation(other.m_transformation)
|
|
{
|
|
this->set_material_id(other.material_id());
|
|
}
|
|
// Providing a new mesh, therefore this volume will get a new unique ID assigned.
|
|
ModelVolume(ModelObject *object, const ModelVolume &other, const TriangleMesh &&mesh) :
|
|
name(other.name), mesh(std::move(mesh)), config(other.config), m_type(other.m_type), object(object), m_transformation(other.m_transformation)
|
|
{
|
|
this->set_material_id(other.material_id());
|
|
if (mesh.stl.stats.number_of_facets > 1)
|
|
calculate_convex_hull();
|
|
}
|
|
#else
|
|
// Copying an existing volume, therefore this volume will get a copy of the ID assigned.
|
|
ModelVolume(ModelObject *object, const ModelVolume &other) :
|
|
ModelBase(other), // copy the ID
|
|
name(other.name), mesh(other.mesh), m_convex_hull(other.m_convex_hull), config(other.config), m_type(other.m_type), object(object)
|
|
{
|
|
if (! other.material_id().empty())
|
|
this->set_material_id(other.material_id());
|
|
}
|
|
// Providing a new mesh, therefore this volume will get a new unique ID assigned.
|
|
ModelVolume(ModelObject *object, const ModelVolume &other, TriangleMesh &&mesh) :
|
|
name(other.name), mesh(std::move(mesh)), config(other.config), m_type(other.m_type), object(object)
|
|
{
|
|
if (! other.material_id().empty())
|
|
this->set_material_id(other.material_id());
|
|
if (mesh.stl.stats.number_of_facets > 1)
|
|
calculate_convex_hull();
|
|
}
|
|
#endif // ENABLE_MODELVOLUME_TRANSFORM
|
|
|
|
ModelVolume& operator=(ModelVolume &rhs) = delete;
|
|
};
|
|
|
|
// A single instance of a ModelObject.
|
|
// Knows the affine transformation of an object.
|
|
class ModelInstance : public ModelBase
|
|
{
|
|
public:
|
|
enum EPrintVolumeState : unsigned char
|
|
{
|
|
PVS_Inside,
|
|
PVS_Partly_Outside,
|
|
PVS_Fully_Outside,
|
|
Num_BedStates
|
|
};
|
|
|
|
private:
|
|
#if ENABLE_MODELVOLUME_TRANSFORM
|
|
Geometry::Transformation m_transformation;
|
|
#else
|
|
Vec3d m_offset; // in unscaled coordinates
|
|
Vec3d m_rotation; // Rotation around the three axes, in radians around mesh center point
|
|
Vec3d m_scaling_factor; // Scaling factors along the three axes
|
|
Vec3d m_mirror; // Mirroring along the three axes
|
|
#endif // ENABLE_MODELVOLUME_TRANSFORM
|
|
|
|
public:
|
|
// flag showing the position of this instance with respect to the print volume (set by Print::validate() using ModelObject::check_instances_print_volume_state())
|
|
EPrintVolumeState print_volume_state;
|
|
|
|
ModelObject* get_object() const { return this->object; }
|
|
|
|
#if ENABLE_MODELVOLUME_TRANSFORM
|
|
const Geometry::Transformation& get_transformation() const { return m_transformation; }
|
|
void set_transformation(const Geometry::Transformation& transformation) { m_transformation = transformation; }
|
|
|
|
const Vec3d& get_offset() const { return m_transformation.get_offset(); }
|
|
double get_offset(Axis axis) const { return m_transformation.get_offset(axis); }
|
|
|
|
void set_offset(const Vec3d& offset) { m_transformation.set_offset(offset); }
|
|
void set_offset(Axis axis, double offset) { m_transformation.set_offset(axis, offset); }
|
|
|
|
const Vec3d& get_rotation() const { return m_transformation.get_rotation(); }
|
|
double get_rotation(Axis axis) const { return m_transformation.get_rotation(axis); }
|
|
|
|
void set_rotation(const Vec3d& rotation) { m_transformation.set_rotation(rotation); }
|
|
void set_rotation(Axis axis, double rotation) { m_transformation.set_rotation(axis, rotation); }
|
|
|
|
Vec3d get_scaling_factor() const { return m_transformation.get_scaling_factor(); }
|
|
double get_scaling_factor(Axis axis) const { return m_transformation.get_scaling_factor(axis); }
|
|
|
|
void set_scaling_factor(const Vec3d& scaling_factor) { m_transformation.set_scaling_factor(scaling_factor); }
|
|
void set_scaling_factor(Axis axis, double scaling_factor) { m_transformation.set_scaling_factor(axis, scaling_factor); }
|
|
|
|
const Vec3d& get_mirror() const { return m_transformation.get_mirror(); }
|
|
double get_mirror(Axis axis) const { return m_transformation.get_mirror(axis); }
|
|
|
|
void set_mirror(const Vec3d& mirror) { m_transformation.set_mirror(mirror); }
|
|
void set_mirror(Axis axis, double mirror) { m_transformation.set_mirror(axis, mirror); }
|
|
#else
|
|
const Vec3d& get_offset() const { return m_offset; }
|
|
double get_offset(Axis axis) const { return m_offset(axis); }
|
|
|
|
void set_offset(const Vec3d& offset) { m_offset = offset; }
|
|
void set_offset(Axis axis, double offset) { m_offset(axis) = offset; }
|
|
|
|
const Vec3d& get_rotation() const { return m_rotation; }
|
|
double get_rotation(Axis axis) const { return m_rotation(axis); }
|
|
|
|
void set_rotation(const Vec3d& rotation);
|
|
void set_rotation(Axis axis, double rotation);
|
|
|
|
Vec3d get_scaling_factor() const { return m_scaling_factor; }
|
|
double get_scaling_factor(Axis axis) const { return m_scaling_factor(axis); }
|
|
|
|
void set_scaling_factor(const Vec3d& scaling_factor);
|
|
void set_scaling_factor(Axis axis, double scaling_factor);
|
|
|
|
const Vec3d& get_mirror() const { return m_mirror; }
|
|
double get_mirror(Axis axis) const { return m_mirror(axis); }
|
|
|
|
void set_mirror(const Vec3d& mirror);
|
|
void set_mirror(Axis axis, double mirror);
|
|
#endif // ENABLE_MODELVOLUME_TRANSFORM
|
|
|
|
// To be called on an external mesh
|
|
void transform_mesh(TriangleMesh* mesh, bool dont_translate = false) const;
|
|
// Calculate a bounding box of a transformed mesh. To be called on an external mesh.
|
|
BoundingBoxf3 transform_mesh_bounding_box(const TriangleMesh& mesh, bool dont_translate = false) const;
|
|
// Transform an external bounding box.
|
|
BoundingBoxf3 transform_bounding_box(const BoundingBoxf3 &bbox, bool dont_translate = false) const;
|
|
// Transform an external vector.
|
|
Vec3d transform_vector(const Vec3d& v, bool dont_translate = false) const;
|
|
// To be called on an external polygon. It does not translate the polygon, only rotates and scales.
|
|
void transform_polygon(Polygon* polygon) const;
|
|
|
|
#if ENABLE_MODELVOLUME_TRANSFORM
|
|
const Transform3d& get_matrix(bool dont_translate = false, bool dont_rotate = false, bool dont_scale = false, bool dont_mirror = false) const { return m_transformation.get_matrix(dont_translate, dont_rotate, dont_scale, dont_mirror); }
|
|
#else
|
|
Transform3d get_matrix(bool dont_translate = false, bool dont_rotate = false, bool dont_scale = false, bool dont_mirror = false) const;
|
|
#endif // ENABLE_MODELVOLUME_TRANSFORM
|
|
|
|
bool is_printable() const { return print_volume_state == PVS_Inside; }
|
|
|
|
protected:
|
|
friend class Print;
|
|
friend class SLAPrint;
|
|
friend class ModelObject;
|
|
|
|
explicit ModelInstance(const ModelInstance &rhs) = default;
|
|
void set_model_object(ModelObject *model_object) { object = model_object; }
|
|
|
|
private:
|
|
// Parent object, owning this instance.
|
|
ModelObject* object;
|
|
|
|
#if ENABLE_MODELVOLUME_TRANSFORM
|
|
// Constructor, which assigns a new unique ID.
|
|
explicit ModelInstance(ModelObject *object) : object(object), print_volume_state(PVS_Inside) {}
|
|
// Constructor, which assigns a new unique ID.
|
|
explicit ModelInstance(ModelObject *object, const ModelInstance &other) :
|
|
m_transformation(other.m_transformation), object(object), print_volume_state(PVS_Inside) {}
|
|
#else
|
|
explicit ModelInstance(ModelObject *object) : m_offset(Vec3d::Zero()), m_rotation(Vec3d::Zero()), m_scaling_factor(Vec3d::Ones()), m_mirror(Vec3d::Ones()), object(object), print_volume_state(PVS_Inside) {}
|
|
explicit ModelInstance(ModelObject *object, const ModelInstance &other) :
|
|
m_offset(other.m_offset), m_rotation(other.m_rotation), m_scaling_factor(other.m_scaling_factor), m_mirror(other.m_mirror), object(object), print_volume_state(PVS_Inside) {}
|
|
#endif // ENABLE_MODELVOLUME_TRANSFORM
|
|
|
|
ModelInstance() = delete;
|
|
explicit ModelInstance(ModelInstance &&rhs) = delete;
|
|
ModelInstance& operator=(const ModelInstance &rhs) = delete;
|
|
ModelInstance& operator=(ModelInstance &&rhs) = delete;
|
|
};
|
|
|
|
// The print bed content.
|
|
// Description of a triangular model with multiple materials, multiple instances with various affine transformations
|
|
// and with multiple modifier meshes.
|
|
// A model groups multiple objects, each object having possibly multiple instances,
|
|
// all objects may share mutliple materials.
|
|
class Model : public ModelBase
|
|
{
|
|
static unsigned int s_auto_extruder_id;
|
|
|
|
public:
|
|
// Materials are owned by a model and referenced by objects through t_model_material_id.
|
|
// Single material may be shared by multiple models.
|
|
ModelMaterialMap materials;
|
|
// Objects are owned by a model. Each model may have multiple instances, each instance having its own transformation (shift, scale, rotation).
|
|
ModelObjectPtrs objects;
|
|
|
|
// Default constructor assigns a new ID to the model.
|
|
Model() {}
|
|
~Model() { this->clear_objects(); this->clear_materials(); }
|
|
|
|
/* To be able to return an object from own copy / clone methods. Hopefully the compiler will do the "Copy elision" */
|
|
/* (Omits copy and move(since C++11) constructors, resulting in zero - copy pass - by - value semantics). */
|
|
Model(const Model &rhs) : ModelBase(-1) { this->assign_copy(rhs); }
|
|
explicit Model(Model &&rhs) : ModelBase(-1) { this->assign_copy(std::move(rhs)); }
|
|
Model& operator=(const Model &rhs) { this->assign_copy(rhs); return *this; }
|
|
Model& operator=(Model &&rhs) { this->assign_copy(std::move(rhs)); return *this; }
|
|
|
|
MODELBASE_DERIVED_COPY_MOVE_CLONE(Model)
|
|
|
|
static Model read_from_file(const std::string &input_file, DynamicPrintConfig *config = nullptr, bool add_default_instances = true);
|
|
static Model read_from_archive(const std::string &input_file, DynamicPrintConfig *config, bool add_default_instances = true);
|
|
|
|
/// Repair the ModelObjects of the current Model.
|
|
/// This function calls repair function on each TriangleMesh of each model object volume
|
|
void repair();
|
|
|
|
// Add a new ModelObject to this Model, generate a new ID for this ModelObject.
|
|
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(ModelID id);
|
|
bool delete_object(ModelObject* object);
|
|
void clear_objects();
|
|
|
|
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) {
|
|
ModelMaterialMap::iterator i = this->materials.find(material_id);
|
|
return (i == this->materials.end()) ? nullptr : i->second;
|
|
}
|
|
|
|
void delete_material(t_model_material_id material_id);
|
|
void clear_materials();
|
|
bool add_default_instances();
|
|
// Returns approximate axis aligned bounding box of this model
|
|
BoundingBoxf3 bounding_box() const;
|
|
// Set the print_volume_state of PrintObject::instances,
|
|
// return total number of printable objects.
|
|
unsigned int update_print_volume_state(const BoundingBoxf3 &print_volume);
|
|
// Returns true if any ModelObject was modified.
|
|
bool center_instances_around_point(const Vec2d &point);
|
|
void translate(coordf_t x, coordf_t y, coordf_t z) { for (ModelObject *o : this->objects) o->translate(x, y, z); }
|
|
TriangleMesh mesh() const;
|
|
bool arrange_objects(coordf_t dist, const BoundingBoxf* bb = NULL);
|
|
// Croaks if the duplicated objects do not fit the print bed.
|
|
void duplicate(size_t copies_num, coordf_t dist, const BoundingBoxf* bb = NULL);
|
|
void duplicate_objects(size_t copies_num, coordf_t dist, const BoundingBoxf* bb = NULL);
|
|
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);
|
|
|
|
// Ensures that the min z of the model is not negative
|
|
void adjust_min_z();
|
|
|
|
void print_info() const { for (const ModelObject *o : this->objects) o->print_info(); }
|
|
|
|
static unsigned int get_auto_extruder_id(unsigned int max_extruders);
|
|
static std::string get_auto_extruder_id_as_string(unsigned int max_extruders);
|
|
static void reset_auto_extruder_id();
|
|
|
|
// Propose an output file name based on the first printable object's name.
|
|
std::string propose_export_file_name() const;
|
|
|
|
private:
|
|
MODELBASE_DERIVED_PRIVATE_COPY_MOVE(Model)
|
|
};
|
|
|
|
#undef MODELBASE_DERIVED_COPY_MOVE_CLONE
|
|
#undef MODELBASE_DERIVED_PRIVATE_COPY_MOVE
|
|
|
|
// Test whether the two models contain the same number of ModelObjects with the same set of IDs
|
|
// ordered in the same order. In that case it is not necessary to kill the background processing.
|
|
extern bool model_object_list_equal(const Model &model_old, const Model &model_new);
|
|
|
|
// Test whether the new model is just an extension of the old model (new objects were added
|
|
// to the end of the original list. In that case it is not necessary to kill the background processing.
|
|
extern bool model_object_list_extended(const Model &model_old, const Model &model_new);
|
|
|
|
// Test whether the new ModelObject contains a different set of volumes (or sorted in a different order)
|
|
// than the old ModelObject.
|
|
extern bool model_volume_list_changed(const ModelObject &model_object_old, const ModelObject &model_object_new, const ModelVolume::Type type);
|
|
|
|
#ifdef _DEBUG
|
|
// Verify whether the IDs of Model / ModelObject / ModelVolume / ModelInstance / ModelMaterial are valid and unique.
|
|
void check_model_ids_validity(const Model &model);
|
|
void check_model_ids_equal(const Model &model1, const Model &model2);
|
|
#endif /* _DEBUG */
|
|
|
|
}
|
|
|
|
#endif
|