2014-04-29 23:04:49 +00:00
|
|
|
#include "Model.hpp"
|
2015-04-16 19:22:04 +00:00
|
|
|
#include "Geometry.hpp"
|
2014-04-29 23:04:49 +00:00
|
|
|
|
2017-08-02 14:05:18 +00:00
|
|
|
#include "Format/AMF.hpp"
|
|
|
|
#include "Format/OBJ.hpp"
|
|
|
|
#include "Format/PRUS.hpp"
|
|
|
|
#include "Format/STL.hpp"
|
2018-01-30 08:27:10 +00:00
|
|
|
#include "Format/3mf.hpp"
|
2017-08-02 14:05:18 +00:00
|
|
|
|
2017-06-21 12:12:11 +00:00
|
|
|
#include <float.h>
|
|
|
|
|
2017-08-02 14:05:18 +00:00
|
|
|
#include <boost/algorithm/string/predicate.hpp>
|
|
|
|
#include <boost/filesystem.hpp>
|
2017-08-03 15:31:31 +00:00
|
|
|
#include <boost/nowide/iostream.hpp>
|
2018-02-22 14:27:32 +00:00
|
|
|
#include <boost/algorithm/string/replace.hpp>
|
2017-08-02 14:05:18 +00:00
|
|
|
|
2018-07-13 09:26:59 +00:00
|
|
|
#include "SVG.hpp"
|
2018-06-21 06:37:04 +00:00
|
|
|
#include <Eigen/Dense>
|
2018-06-05 10:02:45 +00:00
|
|
|
|
2014-04-29 23:04:49 +00:00
|
|
|
namespace Slic3r {
|
|
|
|
|
2018-10-18 16:06:40 +00:00
|
|
|
unsigned int Model::s_auto_extruder_id = 1;
|
2018-04-10 10:17:55 +00:00
|
|
|
|
2018-11-02 13:47:13 +00:00
|
|
|
size_t ModelBase::s_last_id = 0;
|
2018-10-17 09:12:38 +00:00
|
|
|
|
2018-11-02 13:47:13 +00:00
|
|
|
Model& Model::assign_copy(const Model &rhs)
|
2014-04-29 23:04:49 +00:00
|
|
|
{
|
2018-11-02 13:47:13 +00:00
|
|
|
this->copy_id(rhs);
|
2014-05-09 12:24:35 +00:00
|
|
|
// copy materials
|
2018-11-02 18:49:40 +00:00
|
|
|
this->clear_materials();
|
|
|
|
this->materials = rhs.materials;
|
|
|
|
for (std::pair<const t_model_material_id, ModelMaterial*> &m : this->materials) {
|
|
|
|
// Copy including the ID and m_model.
|
|
|
|
m.second = new ModelMaterial(*m.second);
|
|
|
|
m.second->set_model(this);
|
|
|
|
}
|
2014-05-09 12:24:35 +00:00
|
|
|
// copy objects
|
2018-11-02 18:49:40 +00:00
|
|
|
this->clear_objects();
|
2018-10-18 16:06:40 +00:00
|
|
|
this->objects.reserve(rhs.objects.size());
|
2018-11-02 18:49:40 +00:00
|
|
|
for (const ModelObject *model_object : rhs.objects) {
|
|
|
|
// Copy including the ID, leave ID set to invalid (zero).
|
|
|
|
auto mo = ModelObject::new_copy(*model_object);
|
|
|
|
mo->set_model(this);
|
|
|
|
this->objects.emplace_back(mo);
|
|
|
|
}
|
2018-11-02 13:47:13 +00:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
Model& Model::assign_copy(Model &&rhs)
|
|
|
|
{
|
|
|
|
this->copy_id(rhs);
|
2018-11-02 18:49:40 +00:00
|
|
|
// Move materials, adjust the parent pointer.
|
|
|
|
this->clear_materials();
|
|
|
|
this->materials = std::move(rhs.materials);
|
|
|
|
for (std::pair<const t_model_material_id, ModelMaterial*> &m : this->materials)
|
|
|
|
m.second->set_model(this);
|
2018-11-02 13:47:13 +00:00
|
|
|
rhs.materials.clear();
|
2018-11-02 18:49:40 +00:00
|
|
|
// Move objects, adjust the parent pointer.
|
|
|
|
this->clear_objects();
|
2018-11-02 13:47:13 +00:00
|
|
|
this->objects = std::move(rhs.objects);
|
2018-11-02 18:49:40 +00:00
|
|
|
for (ModelObject *model_object : this->objects)
|
|
|
|
model_object->set_model(this);
|
2018-11-02 13:47:13 +00:00
|
|
|
rhs.objects.clear();
|
2014-05-08 11:33:43 +00:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2018-11-02 13:47:13 +00:00
|
|
|
void Model::assign_new_unique_ids_recursive()
|
|
|
|
{
|
|
|
|
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();
|
|
|
|
}
|
|
|
|
|
2018-09-25 09:53:05 +00:00
|
|
|
Model Model::read_from_file(const std::string &input_file, DynamicPrintConfig *config, bool add_default_instances)
|
2014-04-29 23:04:49 +00:00
|
|
|
{
|
2017-08-02 14:05:18 +00:00
|
|
|
Model model;
|
2018-09-25 09:53:05 +00:00
|
|
|
|
|
|
|
DynamicPrintConfig temp_config;
|
|
|
|
if (config == nullptr)
|
|
|
|
config = &temp_config;
|
|
|
|
|
2017-08-02 14:05:18 +00:00
|
|
|
bool result = false;
|
|
|
|
if (boost::algorithm::iends_with(input_file, ".stl"))
|
|
|
|
result = load_stl(input_file.c_str(), &model);
|
|
|
|
else if (boost::algorithm::iends_with(input_file, ".obj"))
|
|
|
|
result = load_obj(input_file.c_str(), &model);
|
2018-02-14 13:30:03 +00:00
|
|
|
else if (!boost::algorithm::iends_with(input_file, ".zip.amf") && (boost::algorithm::iends_with(input_file, ".amf") ||
|
|
|
|
boost::algorithm::iends_with(input_file, ".amf.xml")))
|
2018-09-25 09:53:05 +00:00
|
|
|
result = load_amf(input_file.c_str(), config, &model);
|
|
|
|
else if (boost::algorithm::iends_with(input_file, ".3mf"))
|
|
|
|
result = load_3mf(input_file.c_str(), config, &model);
|
2017-08-02 14:05:18 +00:00
|
|
|
else if (boost::algorithm::iends_with(input_file, ".prusa"))
|
|
|
|
result = load_prus(input_file.c_str(), &model);
|
|
|
|
else
|
2018-02-13 14:19:55 +00:00
|
|
|
throw std::runtime_error("Unknown file format. Input file must have .stl, .obj, .amf(.xml) or .prusa extension.");
|
2018-01-30 08:27:10 +00:00
|
|
|
|
2017-08-02 14:05:18 +00:00
|
|
|
if (! result)
|
|
|
|
throw std::runtime_error("Loading of a model file failed.");
|
|
|
|
|
|
|
|
if (model.objects.empty())
|
|
|
|
throw std::runtime_error("The supplied file couldn't be read because it's empty");
|
|
|
|
|
|
|
|
for (ModelObject *o : model.objects)
|
|
|
|
o->input_file = input_file;
|
|
|
|
|
|
|
|
if (add_default_instances)
|
|
|
|
model.add_default_instances();
|
|
|
|
|
|
|
|
return model;
|
2014-04-29 23:04:49 +00:00
|
|
|
}
|
|
|
|
|
2018-09-25 09:53:05 +00:00
|
|
|
Model Model::read_from_archive(const std::string &input_file, DynamicPrintConfig *config, bool add_default_instances)
|
2018-02-13 14:19:55 +00:00
|
|
|
{
|
|
|
|
Model model;
|
|
|
|
|
|
|
|
bool result = false;
|
|
|
|
if (boost::algorithm::iends_with(input_file, ".3mf"))
|
2018-09-25 09:53:05 +00:00
|
|
|
result = load_3mf(input_file.c_str(), config, &model);
|
2018-02-14 13:30:03 +00:00
|
|
|
else if (boost::algorithm::iends_with(input_file, ".zip.amf"))
|
2018-09-25 09:53:05 +00:00
|
|
|
result = load_amf(input_file.c_str(), config, &model);
|
2018-02-13 14:19:55 +00:00
|
|
|
else
|
2018-02-14 13:30:03 +00:00
|
|
|
throw std::runtime_error("Unknown file format. Input file must have .3mf or .zip.amf extension.");
|
2018-02-13 14:19:55 +00:00
|
|
|
|
|
|
|
if (!result)
|
|
|
|
throw std::runtime_error("Loading of a model file failed.");
|
|
|
|
|
|
|
|
if (model.objects.empty())
|
|
|
|
throw std::runtime_error("The supplied file couldn't be read because it's empty");
|
|
|
|
|
|
|
|
for (ModelObject *o : model.objects)
|
2018-02-22 14:27:32 +00:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
2018-02-13 14:19:55 +00:00
|
|
|
|
|
|
|
if (add_default_instances)
|
|
|
|
model.add_default_instances();
|
|
|
|
|
|
|
|
return model;
|
|
|
|
}
|
|
|
|
|
2018-09-20 14:48:13 +00:00
|
|
|
void Model::repair()
|
|
|
|
{
|
|
|
|
for (ModelObject *o : this->objects)
|
|
|
|
o->repair();
|
|
|
|
}
|
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
ModelObject* Model::add_object()
|
2014-05-09 12:24:35 +00:00
|
|
|
{
|
2017-06-13 09:35:24 +00:00
|
|
|
this->objects.emplace_back(new ModelObject(this));
|
|
|
|
return this->objects.back();
|
2014-05-09 12:24:35 +00:00
|
|
|
}
|
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
ModelObject* Model::add_object(const char *name, const char *path, const TriangleMesh &mesh)
|
2017-02-26 21:03:03 +00:00
|
|
|
{
|
|
|
|
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_object->invalidate_bounding_box();
|
|
|
|
return new_object;
|
|
|
|
}
|
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
ModelObject* Model::add_object(const char *name, const char *path, TriangleMesh &&mesh)
|
2017-02-26 21:03:03 +00:00
|
|
|
{
|
|
|
|
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_object->invalidate_bounding_box();
|
|
|
|
return new_object;
|
|
|
|
}
|
|
|
|
|
2018-11-02 13:47:13 +00:00
|
|
|
ModelObject* Model::add_object(const ModelObject &other)
|
2014-04-29 23:04:49 +00:00
|
|
|
{
|
2018-11-02 18:49:40 +00:00
|
|
|
ModelObject* new_object = ModelObject::new_clone(other);
|
|
|
|
new_object->set_model(this);
|
2014-05-09 12:24:35 +00:00
|
|
|
this->objects.push_back(new_object);
|
|
|
|
return new_object;
|
2014-04-29 23:04:49 +00:00
|
|
|
}
|
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
void Model::delete_object(size_t idx)
|
2014-04-29 23:04:49 +00:00
|
|
|
{
|
|
|
|
ModelObjectPtrs::iterator i = this->objects.begin() + idx;
|
|
|
|
delete *i;
|
|
|
|
this->objects.erase(i);
|
|
|
|
}
|
|
|
|
|
2018-11-02 18:49:40 +00:00
|
|
|
bool Model::delete_object(ModelObject* object)
|
2018-01-30 08:27:10 +00:00
|
|
|
{
|
2018-11-02 18:49:40 +00:00
|
|
|
if (object != nullptr) {
|
|
|
|
size_t idx = 0;
|
|
|
|
for (ModelObject *model_object : objects) {
|
|
|
|
if (model_object == object) {
|
|
|
|
delete model_object;
|
|
|
|
objects.erase(objects.begin() + idx);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
++ idx;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
2018-01-30 08:27:10 +00:00
|
|
|
|
2018-11-02 18:49:40 +00:00
|
|
|
bool Model::delete_object(ModelID id)
|
|
|
|
{
|
|
|
|
if (id.id != 0) {
|
|
|
|
size_t idx = 0;
|
|
|
|
for (ModelObject *model_object : objects) {
|
|
|
|
if (model_object->id() == id) {
|
|
|
|
delete model_object;
|
|
|
|
objects.erase(objects.begin() + idx);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
++ idx;
|
2018-01-30 08:27:10 +00:00
|
|
|
}
|
|
|
|
}
|
2018-11-02 18:49:40 +00:00
|
|
|
return false;
|
2018-01-30 08:27:10 +00:00
|
|
|
}
|
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
void Model::clear_objects()
|
2014-04-29 23:04:49 +00:00
|
|
|
{
|
2017-06-13 09:35:24 +00:00
|
|
|
for (ModelObject *o : this->objects)
|
|
|
|
delete o;
|
|
|
|
this->objects.clear();
|
2014-04-29 23:04:49 +00:00
|
|
|
}
|
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
void Model::delete_material(t_model_material_id material_id)
|
2014-04-29 23:04:49 +00:00
|
|
|
{
|
2014-05-06 22:58:29 +00:00
|
|
|
ModelMaterialMap::iterator i = this->materials.find(material_id);
|
|
|
|
if (i != this->materials.end()) {
|
2014-04-29 23:04:49 +00:00
|
|
|
delete i->second;
|
2014-05-06 22:58:29 +00:00
|
|
|
this->materials.erase(i);
|
2014-04-29 23:04:49 +00:00
|
|
|
}
|
2014-05-06 22:58:29 +00:00
|
|
|
}
|
2014-04-29 23:04:49 +00:00
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
void Model::clear_materials()
|
2014-05-06 22:58:29 +00:00
|
|
|
{
|
2017-06-13 09:35:24 +00:00
|
|
|
for (auto &m : this->materials)
|
|
|
|
delete m.second;
|
|
|
|
this->materials.clear();
|
2014-04-29 23:04:49 +00:00
|
|
|
}
|
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
ModelMaterial* Model::add_material(t_model_material_id material_id)
|
2014-04-29 23:04:49 +00:00
|
|
|
{
|
2018-11-05 16:52:55 +00:00
|
|
|
assert(! material_id.empty());
|
2014-05-09 12:24:35 +00:00
|
|
|
ModelMaterial* material = this->get_material(material_id);
|
2017-06-13 09:35:24 +00:00
|
|
|
if (material == nullptr)
|
2014-05-09 12:24:35 +00:00
|
|
|
material = this->materials[material_id] = new ModelMaterial(this);
|
|
|
|
return material;
|
|
|
|
}
|
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
ModelMaterial* Model::add_material(t_model_material_id material_id, const ModelMaterial &other)
|
2014-05-09 12:24:35 +00:00
|
|
|
{
|
2018-11-05 16:52:55 +00:00
|
|
|
assert(! material_id.empty());
|
2014-05-09 12:24:35 +00:00
|
|
|
// delete existing material if any
|
|
|
|
ModelMaterial* material = this->get_material(material_id);
|
2017-06-13 09:35:24 +00:00
|
|
|
delete material;
|
2014-05-09 12:24:35 +00:00
|
|
|
// set new material
|
2018-11-02 18:49:40 +00:00
|
|
|
material = new ModelMaterial(other);
|
|
|
|
material->set_model(this);
|
2014-05-09 12:24:35 +00:00
|
|
|
this->materials[material_id] = material;
|
|
|
|
return material;
|
|
|
|
}
|
|
|
|
|
2014-08-08 19:48:59 +00:00
|
|
|
// makes sure all objects have at least one instance
|
2017-06-13 09:35:24 +00:00
|
|
|
bool Model::add_default_instances()
|
2014-08-08 19:48:59 +00:00
|
|
|
{
|
|
|
|
// apply a default position to all objects not having one
|
2017-06-13 09:35:24 +00:00
|
|
|
for (ModelObject *o : this->objects)
|
|
|
|
if (o->instances.empty())
|
|
|
|
o->add_instance();
|
2014-08-08 19:48:59 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2014-09-21 08:51:36 +00:00
|
|
|
// this returns the bounding box of the *transformed* instances
|
2018-03-09 09:40:42 +00:00
|
|
|
BoundingBoxf3 Model::bounding_box() const
|
2014-09-21 08:51:36 +00:00
|
|
|
{
|
2015-01-19 17:53:04 +00:00
|
|
|
BoundingBoxf3 bb;
|
2017-06-13 09:35:24 +00:00
|
|
|
for (ModelObject *o : this->objects)
|
|
|
|
bb.merge(o->bounding_box());
|
2015-01-19 17:53:04 +00:00
|
|
|
return bb;
|
2014-09-21 08:51:36 +00:00
|
|
|
}
|
|
|
|
|
2018-10-23 13:27:31 +00:00
|
|
|
unsigned int Model::update_print_volume_state(const BoundingBoxf3 &print_volume)
|
|
|
|
{
|
|
|
|
unsigned int num_printable = 0;
|
|
|
|
for (ModelObject *model_object : this->objects)
|
|
|
|
num_printable += model_object->check_instances_print_volume_state(print_volume);
|
|
|
|
return num_printable;
|
|
|
|
}
|
|
|
|
|
2018-11-08 19:18:40 +00:00
|
|
|
bool Model::center_instances_around_point(const Vec2d &point)
|
2014-09-21 08:51:36 +00:00
|
|
|
{
|
2017-06-13 09:35:24 +00:00
|
|
|
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));
|
|
|
|
|
2018-09-17 13:12:13 +00:00
|
|
|
Vec2d shift2 = point - to_2d(bb.center());
|
2018-11-08 19:18:40 +00:00
|
|
|
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;
|
2014-09-21 08:51:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// flattens everything to a single mesh
|
2017-06-13 09:35:24 +00:00
|
|
|
TriangleMesh Model::mesh() const
|
2014-09-21 08:51:36 +00:00
|
|
|
{
|
2015-01-19 17:53:04 +00:00
|
|
|
TriangleMesh mesh;
|
2017-06-13 09:35:24 +00:00
|
|
|
for (const ModelObject *o : this->objects)
|
|
|
|
mesh.merge(o->mesh());
|
2015-01-19 17:53:04 +00:00
|
|
|
return mesh;
|
2014-09-21 08:51:36 +00:00
|
|
|
}
|
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
static bool _arrange(const Pointfs &sizes, coordf_t dist, const BoundingBoxf* bb, Pointfs &out)
|
2015-12-01 20:51:16 +00:00
|
|
|
{
|
2018-05-02 12:55:17 +00:00
|
|
|
if (sizes.empty())
|
|
|
|
// return if the list is empty or the following call to BoundingBoxf constructor will lead to a crash
|
|
|
|
return true;
|
|
|
|
|
2015-12-01 20:51:16 +00:00
|
|
|
// we supply unscaled data to arrange()
|
2017-06-13 09:43:25 +00:00
|
|
|
bool result = Slic3r::Geometry::arrange(
|
2015-12-01 20:51:16 +00:00
|
|
|
sizes.size(), // number of parts
|
|
|
|
BoundingBoxf(sizes).max, // width and height of a single cell
|
|
|
|
dist, // distance between cells
|
2016-11-04 14:03:51 +00:00
|
|
|
bb, // bounding box of the area to fill
|
|
|
|
out // output positions
|
2015-12-01 20:51:16 +00:00
|
|
|
);
|
2017-06-13 09:43:25 +00:00
|
|
|
|
|
|
|
if (!result && bb != nullptr) {
|
|
|
|
// Try to arrange again ignoring bb
|
|
|
|
result = Slic3r::Geometry::arrange(
|
|
|
|
sizes.size(), // number of parts
|
|
|
|
BoundingBoxf(sizes).max, // width and height of a single cell
|
|
|
|
dist, // distance between cells
|
|
|
|
nullptr, // bounding box of the area to fill
|
|
|
|
out // output positions
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
2015-12-01 20:51:16 +00:00
|
|
|
}
|
|
|
|
|
2018-07-30 14:41:35 +00:00
|
|
|
/* arrange objects preserving their instance count
|
|
|
|
but altering their instance positions */
|
|
|
|
bool Model::arrange_objects(coordf_t dist, const BoundingBoxf* bb)
|
2018-05-17 08:37:26 +00:00
|
|
|
{
|
2018-07-30 14:41:35 +00:00
|
|
|
// get the (transformed) size of each instance so that we take
|
|
|
|
// into account their different transformations when packing
|
|
|
|
Pointfs instance_sizes;
|
|
|
|
Pointfs instance_centers;
|
|
|
|
for (const ModelObject *o : this->objects)
|
|
|
|
for (size_t i = 0; i < o->instances.size(); ++ i) {
|
|
|
|
// an accurate snug bounding box around the transformed mesh.
|
|
|
|
BoundingBoxf3 bbox(o->instance_bounding_box(i, true));
|
2018-08-21 15:43:05 +00:00
|
|
|
instance_sizes.emplace_back(to_2d(bbox.size()));
|
|
|
|
instance_centers.emplace_back(to_2d(bbox.center()));
|
2018-05-17 08:37:26 +00:00
|
|
|
}
|
|
|
|
|
2018-07-30 14:41:35 +00:00
|
|
|
Pointfs positions;
|
|
|
|
if (! _arrange(instance_sizes, dist, bb, positions))
|
|
|
|
return false;
|
2018-05-17 08:37:26 +00:00
|
|
|
|
2018-07-30 14:41:35 +00:00
|
|
|
size_t idx = 0;
|
|
|
|
for (ModelObject *o : this->objects) {
|
|
|
|
for (ModelInstance *i : o->instances) {
|
2018-09-17 13:12:13 +00:00
|
|
|
Vec2d offset_xy = positions[idx] - instance_centers[idx];
|
|
|
|
i->set_offset(Vec3d(offset_xy(0), offset_xy(1), i->get_offset(Z)));
|
|
|
|
++idx;
|
2015-12-01 20:51:16 +00:00
|
|
|
}
|
2018-07-30 14:41:35 +00:00
|
|
|
o->invalidate_bounding_box();
|
2015-12-01 20:51:16 +00:00
|
|
|
}
|
2018-05-17 08:37:26 +00:00
|
|
|
|
2018-07-30 14:41:35 +00:00
|
|
|
return true;
|
2015-12-01 20:51:16 +00:00
|
|
|
}
|
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
// Duplicate the entire model preserving instance relative positions.
|
|
|
|
void Model::duplicate(size_t copies_num, coordf_t dist, const BoundingBoxf* bb)
|
2015-12-02 17:06:18 +00:00
|
|
|
{
|
2018-08-21 15:43:05 +00:00
|
|
|
Pointfs model_sizes(copies_num-1, to_2d(this->bounding_box().size()));
|
2016-11-04 14:03:51 +00:00
|
|
|
Pointfs positions;
|
2017-06-13 09:35:24 +00:00
|
|
|
if (! _arrange(model_sizes, dist, bb, positions))
|
2018-09-18 08:09:58 +00:00
|
|
|
throw std::invalid_argument("Cannot duplicate part as the resulting objects would not fit on the print bed.\n");
|
2015-12-02 17:06:18 +00:00
|
|
|
|
|
|
|
// note that this will leave the object count unaltered
|
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
for (ModelObject *o : this->objects) {
|
2015-12-02 17:06:18 +00:00
|
|
|
// make a copy of the pointers in order to avoid recursion when appending their copies
|
2017-06-13 09:35:24 +00:00
|
|
|
ModelInstancePtrs instances = o->instances;
|
|
|
|
for (const ModelInstance *i : instances) {
|
2018-08-21 19:05:24 +00:00
|
|
|
for (const Vec2d &pos : positions) {
|
2017-06-13 09:35:24 +00:00
|
|
|
ModelInstance *instance = o->add_instance(*i);
|
2018-09-17 13:12:13 +00:00
|
|
|
instance->set_offset(instance->get_offset() + Vec3d(pos(0), pos(1), 0.0));
|
2015-12-02 17:06:18 +00:00
|
|
|
}
|
|
|
|
}
|
2017-06-13 09:35:24 +00:00
|
|
|
o->invalidate_bounding_box();
|
2015-12-02 17:06:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* this will append more instances to each object
|
|
|
|
and then automatically rearrange everything */
|
2017-06-13 09:35:24 +00:00
|
|
|
void Model::duplicate_objects(size_t copies_num, coordf_t dist, const BoundingBoxf* bb)
|
2015-12-02 17:06:18 +00:00
|
|
|
{
|
2017-06-13 09:35:24 +00:00
|
|
|
for (ModelObject *o : this->objects) {
|
2015-12-02 17:06:18 +00:00
|
|
|
// make a copy of the pointers in order to avoid recursion when appending their copies
|
2017-06-13 09:35:24 +00:00
|
|
|
ModelInstancePtrs instances = o->instances;
|
|
|
|
for (const ModelInstance *i : instances)
|
|
|
|
for (size_t k = 2; k <= copies_num; ++ k)
|
|
|
|
o->add_instance(*i);
|
2015-12-02 17:06:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
this->arrange_objects(dist, bb);
|
|
|
|
}
|
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
void Model::duplicate_objects_grid(size_t x, size_t y, coordf_t dist)
|
2015-12-02 17:06:18 +00:00
|
|
|
{
|
|
|
|
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();
|
|
|
|
|
2018-09-17 13:12:13 +00:00
|
|
|
Vec3d ext_size = object->bounding_box().size() + dist * Vec3d::Ones();
|
2015-12-02 17:06:18 +00:00
|
|
|
|
|
|
|
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();
|
2018-09-17 13:12:13 +00:00
|
|
|
instance->set_offset(Vec3d(ext_size(0) * (double)(x_copy - 1), ext_size(1) * (double)(y_copy - 1), 0.0));
|
2015-12-02 17:06:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-02 14:05:18 +00:00
|
|
|
bool 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;
|
|
|
|
for (const ModelVolume *vol : obj->volumes) {
|
2018-08-17 13:53:43 +00:00
|
|
|
double zmin_this = vol->mesh.bounding_box().min(2);
|
2017-08-02 14:05:18 +00:00
|
|
|
if (zmin == std::numeric_limits<double>::max())
|
|
|
|
zmin = zmin_this;
|
|
|
|
else if (std::abs(zmin - zmin_this) > EPSILON)
|
|
|
|
// The volumes don't share zmin.
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2018-05-07 14:13:58 +00:00
|
|
|
void Model::convert_multipart_object(unsigned int max_extruders)
|
2017-08-02 14:05:18 +00:00
|
|
|
{
|
|
|
|
if (this->objects.empty())
|
|
|
|
return;
|
|
|
|
|
2017-08-28 12:54:46 +00:00
|
|
|
ModelObject* object = new ModelObject(this);
|
2017-08-02 14:05:18 +00:00
|
|
|
object->input_file = this->objects.front()->input_file;
|
2018-10-19 09:02:50 +00:00
|
|
|
object->name = this->objects.front()->name;
|
2018-11-02 18:49:40 +00:00
|
|
|
//FIXME copy the config etc?
|
2018-04-10 10:17:55 +00:00
|
|
|
|
|
|
|
reset_auto_extruder_id();
|
2018-04-09 12:57:23 +00:00
|
|
|
|
2017-08-02 14:05:18 +00:00
|
|
|
for (const ModelObject* o : this->objects)
|
|
|
|
for (const ModelVolume* v : o->volumes)
|
2018-04-09 12:57:23 +00:00
|
|
|
{
|
|
|
|
ModelVolume* new_v = object->add_volume(*v);
|
|
|
|
if (new_v != nullptr)
|
|
|
|
{
|
|
|
|
new_v->name = o->name;
|
2018-05-07 14:13:58 +00:00
|
|
|
new_v->config.set_deserialize("extruder", get_auto_extruder_id_as_string(max_extruders));
|
2018-04-09 12:57:23 +00:00
|
|
|
}
|
|
|
|
}
|
2017-08-02 14:05:18 +00:00
|
|
|
|
|
|
|
for (const ModelInstance* i : this->objects.front()->instances)
|
|
|
|
object->add_instance(*i);
|
|
|
|
|
2017-08-28 12:54:46 +00:00
|
|
|
this->clear_objects();
|
|
|
|
this->objects.push_back(object);
|
2017-08-02 14:05:18 +00:00
|
|
|
}
|
|
|
|
|
2018-03-06 09:26:39 +00:00
|
|
|
void Model::adjust_min_z()
|
|
|
|
{
|
|
|
|
if (objects.empty())
|
|
|
|
return;
|
|
|
|
|
2018-08-17 13:53:43 +00:00
|
|
|
if (bounding_box().min(2) < 0.0)
|
2018-03-06 09:26:39 +00:00
|
|
|
{
|
|
|
|
for (ModelObject* obj : objects)
|
|
|
|
{
|
|
|
|
if (obj != nullptr)
|
|
|
|
{
|
2018-08-17 13:53:43 +00:00
|
|
|
coordf_t obj_min_z = obj->bounding_box().min(2);
|
2018-03-06 09:26:39 +00:00
|
|
|
if (obj_min_z < 0.0)
|
|
|
|
obj->translate(0.0, 0.0, -obj_min_z);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-05-07 14:13:58 +00:00
|
|
|
unsigned int Model::get_auto_extruder_id(unsigned int max_extruders)
|
2018-04-10 10:17:55 +00:00
|
|
|
{
|
|
|
|
unsigned int id = s_auto_extruder_id;
|
|
|
|
|
2018-05-07 14:13:58 +00:00
|
|
|
if (++s_auto_extruder_id > max_extruders)
|
2018-04-10 10:17:55 +00:00
|
|
|
reset_auto_extruder_id();
|
|
|
|
|
|
|
|
return id;
|
|
|
|
}
|
|
|
|
|
2018-05-07 14:13:58 +00:00
|
|
|
std::string Model::get_auto_extruder_id_as_string(unsigned int max_extruders)
|
2018-04-10 10:17:55 +00:00
|
|
|
{
|
|
|
|
char str_extruder[64];
|
2018-05-07 14:13:58 +00:00
|
|
|
sprintf(str_extruder, "%ud", get_auto_extruder_id(max_extruders));
|
2018-04-10 10:17:55 +00:00
|
|
|
return str_extruder;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Model::reset_auto_extruder_id()
|
|
|
|
{
|
|
|
|
s_auto_extruder_id = 1;
|
|
|
|
}
|
|
|
|
|
2014-04-29 23:04:49 +00:00
|
|
|
ModelObject::~ModelObject()
|
|
|
|
{
|
|
|
|
this->clear_volumes();
|
|
|
|
this->clear_instances();
|
|
|
|
}
|
|
|
|
|
2018-11-02 13:47:13 +00:00
|
|
|
// maintains the m_model pointer
|
|
|
|
ModelObject& ModelObject::assign_copy(const ModelObject &rhs)
|
2018-10-17 09:12:38 +00:00
|
|
|
{
|
2018-11-02 13:47:13 +00:00
|
|
|
this->copy_id(rhs);
|
2018-10-17 09:12:38 +00:00
|
|
|
|
2018-11-02 13:47:13 +00:00
|
|
|
this->name = rhs.name;
|
|
|
|
this->input_file = rhs.input_file;
|
|
|
|
this->config = rhs.config;
|
|
|
|
this->sla_support_points = rhs.sla_support_points;
|
|
|
|
this->layer_height_ranges = rhs.layer_height_ranges;
|
|
|
|
this->layer_height_profile = rhs.layer_height_profile;
|
|
|
|
this->layer_height_profile_valid = rhs.layer_height_profile_valid;
|
|
|
|
this->origin_translation = rhs.origin_translation;
|
|
|
|
m_bounding_box = rhs.m_bounding_box;
|
|
|
|
m_bounding_box_valid = rhs.m_bounding_box_valid;
|
|
|
|
|
2018-11-02 18:49:40 +00:00
|
|
|
this->clear_volumes();
|
2018-11-02 13:47:13 +00:00
|
|
|
this->volumes.reserve(rhs.volumes.size());
|
2018-11-02 18:49:40 +00:00
|
|
|
for (ModelVolume *model_volume : rhs.volumes) {
|
|
|
|
this->volumes.emplace_back(new ModelVolume(*model_volume));
|
|
|
|
this->volumes.back()->set_model_object(this);
|
|
|
|
}
|
|
|
|
this->clear_instances();
|
2018-11-02 13:47:13 +00:00
|
|
|
this->instances.reserve(rhs.instances.size());
|
2018-11-02 18:49:40 +00:00
|
|
|
for (const ModelInstance *model_instance : rhs.instances) {
|
|
|
|
this->instances.emplace_back(new ModelInstance(*model_instance));
|
|
|
|
this->instances.back()->set_model_object(this);
|
2018-10-30 14:24:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2018-11-02 13:47:13 +00:00
|
|
|
// maintains the m_model pointer
|
|
|
|
ModelObject& ModelObject::assign_copy(ModelObject &&rhs)
|
|
|
|
{
|
|
|
|
this->copy_id(rhs);
|
|
|
|
|
|
|
|
this->name = std::move(rhs.name);
|
|
|
|
this->input_file = std::move(rhs.input_file);
|
|
|
|
this->config = std::move(rhs.config);
|
|
|
|
this->sla_support_points = std::move(rhs.sla_support_points);
|
|
|
|
this->layer_height_ranges = std::move(rhs.layer_height_ranges);
|
|
|
|
this->layer_height_profile = std::move(rhs.layer_height_profile);
|
|
|
|
this->layer_height_profile_valid = std::move(rhs.layer_height_profile_valid);
|
|
|
|
this->origin_translation = std::move(rhs.origin_translation);
|
|
|
|
m_bounding_box = std::move(rhs.m_bounding_box);
|
|
|
|
m_bounding_box_valid = std::move(rhs.m_bounding_box_valid);
|
|
|
|
|
2018-11-02 18:49:40 +00:00
|
|
|
this->clear_volumes();
|
2018-11-02 13:47:13 +00:00
|
|
|
this->volumes = std::move(rhs.volumes);
|
|
|
|
rhs.volumes.clear();
|
2018-11-02 18:49:40 +00:00
|
|
|
for (ModelVolume *model_volume : this->volumes)
|
|
|
|
model_volume->set_model_object(this);
|
|
|
|
this->clear_instances();
|
2018-11-02 13:47:13 +00:00
|
|
|
this->instances = std::move(rhs.instances);
|
|
|
|
rhs.instances.clear();
|
2018-11-02 18:49:40 +00:00
|
|
|
for (ModelInstance *model_instance : this->instances)
|
|
|
|
model_instance->set_model_object(this);
|
2018-11-02 13:47:13 +00:00
|
|
|
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
void ModelObject::assign_new_unique_ids_recursive()
|
|
|
|
{
|
|
|
|
this->set_new_unique_id();
|
|
|
|
for (ModelVolume *model_volume : this->volumes)
|
|
|
|
model_volume->assign_new_unique_ids_recursive();
|
|
|
|
for (ModelInstance *model_instance : this->instances)
|
|
|
|
model_instance->assign_new_unique_ids_recursive();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Clone this ModelObject including its volumes and instances, keep the IDs of the copies equal to the original.
|
|
|
|
// Called by Print::apply() to clone the Model / ModelObject hierarchy to the back end for background processing.
|
|
|
|
//ModelObject* ModelObject::clone(Model *parent)
|
|
|
|
//{
|
|
|
|
// return new ModelObject(parent, *this, true);
|
|
|
|
//}
|
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
ModelVolume* ModelObject::add_volume(const TriangleMesh &mesh)
|
2014-05-09 12:24:35 +00:00
|
|
|
{
|
|
|
|
ModelVolume* v = new ModelVolume(this, mesh);
|
|
|
|
this->volumes.push_back(v);
|
|
|
|
this->invalidate_bounding_box();
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
ModelVolume* ModelObject::add_volume(TriangleMesh &&mesh)
|
2017-02-26 21:03:03 +00:00
|
|
|
{
|
|
|
|
ModelVolume* v = new ModelVolume(this, std::move(mesh));
|
|
|
|
this->volumes.push_back(v);
|
|
|
|
this->invalidate_bounding_box();
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
ModelVolume* ModelObject::add_volume(const ModelVolume &other)
|
2014-04-29 23:04:49 +00:00
|
|
|
{
|
2014-05-09 12:24:35 +00:00
|
|
|
ModelVolume* v = new ModelVolume(this, other);
|
2014-04-29 23:04:49 +00:00
|
|
|
this->volumes.push_back(v);
|
|
|
|
this->invalidate_bounding_box();
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
2018-11-02 13:47:13 +00:00
|
|
|
ModelVolume* ModelObject::add_volume(const ModelVolume &other, TriangleMesh &&mesh)
|
|
|
|
{
|
|
|
|
ModelVolume* v = new ModelVolume(this, other, std::move(mesh));
|
|
|
|
this->volumes.push_back(v);
|
|
|
|
this->invalidate_bounding_box();
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
void ModelObject::delete_volume(size_t idx)
|
2014-04-29 23:04:49 +00:00
|
|
|
{
|
|
|
|
ModelVolumePtrs::iterator i = this->volumes.begin() + idx;
|
|
|
|
delete *i;
|
|
|
|
this->volumes.erase(i);
|
|
|
|
this->invalidate_bounding_box();
|
|
|
|
}
|
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
void ModelObject::clear_volumes()
|
2014-04-29 23:04:49 +00:00
|
|
|
{
|
2017-06-13 09:35:24 +00:00
|
|
|
for (ModelVolume *v : this->volumes)
|
|
|
|
delete v;
|
|
|
|
this->volumes.clear();
|
|
|
|
this->invalidate_bounding_box();
|
2014-04-29 23:04:49 +00:00
|
|
|
}
|
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
ModelInstance* ModelObject::add_instance()
|
2014-04-29 23:04:49 +00:00
|
|
|
{
|
2014-05-09 12:24:35 +00:00
|
|
|
ModelInstance* i = new ModelInstance(this);
|
|
|
|
this->instances.push_back(i);
|
|
|
|
this->invalidate_bounding_box();
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
ModelInstance* ModelObject::add_instance(const ModelInstance &other)
|
2014-05-09 12:24:35 +00:00
|
|
|
{
|
|
|
|
ModelInstance* i = new ModelInstance(this, other);
|
2014-04-29 23:04:49 +00:00
|
|
|
this->instances.push_back(i);
|
|
|
|
this->invalidate_bounding_box();
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
2018-10-11 08:03:38 +00:00
|
|
|
ModelInstance* ModelObject::add_instance(const Vec3d &offset, const Vec3d &scaling_factor, const Vec3d &rotation)
|
|
|
|
{
|
|
|
|
auto *instance = add_instance();
|
|
|
|
instance->set_offset(offset);
|
|
|
|
instance->set_scaling_factor(scaling_factor);
|
|
|
|
instance->set_rotation(rotation);
|
|
|
|
return instance;
|
|
|
|
}
|
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
void ModelObject::delete_instance(size_t idx)
|
2014-04-29 23:04:49 +00:00
|
|
|
{
|
2014-05-06 22:58:29 +00:00
|
|
|
ModelInstancePtrs::iterator i = this->instances.begin() + idx;
|
|
|
|
delete *i;
|
|
|
|
this->instances.erase(i);
|
2014-04-29 23:04:49 +00:00
|
|
|
this->invalidate_bounding_box();
|
|
|
|
}
|
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
void ModelObject::delete_last_instance()
|
2014-04-29 23:04:49 +00:00
|
|
|
{
|
2014-05-06 22:58:29 +00:00
|
|
|
this->delete_instance(this->instances.size() - 1);
|
|
|
|
}
|
2014-04-29 23:04:49 +00:00
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
void ModelObject::clear_instances()
|
2014-05-06 22:58:29 +00:00
|
|
|
{
|
2017-06-13 09:35:24 +00:00
|
|
|
for (ModelInstance *i : this->instances)
|
|
|
|
delete i;
|
|
|
|
this->instances.clear();
|
|
|
|
this->invalidate_bounding_box();
|
2014-04-29 23:04:49 +00:00
|
|
|
}
|
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
// Returns the bounding box of the transformed instances.
|
|
|
|
// This bounding box is approximate and not snug.
|
2018-05-25 13:56:14 +00:00
|
|
|
const BoundingBoxf3& ModelObject::bounding_box() const
|
2014-09-21 08:51:36 +00:00
|
|
|
{
|
2017-06-13 09:35:24 +00:00
|
|
|
if (! m_bounding_box_valid) {
|
|
|
|
BoundingBoxf3 raw_bbox;
|
|
|
|
for (const ModelVolume *v : this->volumes)
|
2018-09-17 13:12:13 +00:00
|
|
|
if (v->is_model_part())
|
2018-11-02 11:11:28 +00:00
|
|
|
#if ENABLE_MODELVOLUME_TRANSFORM
|
|
|
|
{
|
|
|
|
TriangleMesh m = v->mesh;
|
2018-11-02 12:47:47 +00:00
|
|
|
m.transform(v->get_matrix());
|
2018-11-02 11:11:28 +00:00
|
|
|
raw_bbox.merge(m.bounding_box());
|
|
|
|
}
|
|
|
|
#else
|
2018-09-17 13:12:13 +00:00
|
|
|
// mesh.bounding_box() returns a cached value.
|
2017-06-13 09:35:24 +00:00
|
|
|
raw_bbox.merge(v->mesh.bounding_box());
|
2018-11-02 11:11:28 +00:00
|
|
|
#endif // ENABLE_MODELVOLUME_TRANSFORM
|
2017-06-13 09:35:24 +00:00
|
|
|
BoundingBoxf3 bb;
|
|
|
|
for (const ModelInstance *i : this->instances)
|
|
|
|
bb.merge(i->transform_bounding_box(raw_bbox));
|
|
|
|
m_bounding_box = bb;
|
|
|
|
m_bounding_box_valid = true;
|
2016-11-16 10:53:29 +00:00
|
|
|
}
|
2017-06-13 09:35:24 +00:00
|
|
|
return m_bounding_box;
|
2014-09-21 08:51:36 +00:00
|
|
|
}
|
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
// A mesh containing all transformed instances of this object.
|
|
|
|
TriangleMesh ModelObject::mesh() const
|
2014-09-21 08:51:36 +00:00
|
|
|
{
|
2015-01-19 17:53:04 +00:00
|
|
|
TriangleMesh mesh;
|
|
|
|
TriangleMesh raw_mesh = this->raw_mesh();
|
2017-06-13 09:35:24 +00:00
|
|
|
for (const ModelInstance *i : this->instances) {
|
2014-09-21 08:51:36 +00:00
|
|
|
TriangleMesh m = raw_mesh;
|
2017-06-13 09:35:24 +00:00
|
|
|
i->transform_mesh(&m);
|
2015-01-19 17:53:04 +00:00
|
|
|
mesh.merge(m);
|
2014-09-21 08:51:36 +00:00
|
|
|
}
|
2015-01-19 17:53:04 +00:00
|
|
|
return mesh;
|
2014-09-21 08:51:36 +00:00
|
|
|
}
|
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
// Non-transformed (non-rotated, non-scaled, non-translated) sum of non-modifier object volumes.
|
|
|
|
// Currently used by ModelObject::mesh(), to calculate the 2D envelope for 2D platter
|
|
|
|
// and to display the object statistics at ModelObject::print_info().
|
|
|
|
TriangleMesh ModelObject::raw_mesh() const
|
2014-08-03 18:33:16 +00:00
|
|
|
{
|
2015-01-19 17:53:04 +00:00
|
|
|
TriangleMesh mesh;
|
2017-06-13 09:35:24 +00:00
|
|
|
for (const ModelVolume *v : this->volumes)
|
2018-09-17 13:12:13 +00:00
|
|
|
if (v->is_model_part())
|
2018-11-02 11:11:28 +00:00
|
|
|
#if ENABLE_MODELVOLUME_TRANSFORM
|
|
|
|
{
|
|
|
|
TriangleMesh vol_mesh(v->mesh);
|
2018-11-02 12:47:47 +00:00
|
|
|
vol_mesh.transform(v->get_matrix());
|
2018-11-02 11:11:28 +00:00
|
|
|
mesh.merge(vol_mesh);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
mesh.merge(v->mesh);
|
|
|
|
#endif // ENABLE_MODELVOLUME_TRANSFORM
|
2015-01-19 17:53:04 +00:00
|
|
|
return mesh;
|
2014-08-03 18:33:16 +00:00
|
|
|
}
|
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
// 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 ModelObject::raw_bounding_box() const
|
2014-09-21 08:51:36 +00:00
|
|
|
{
|
2015-01-19 17:53:04 +00:00
|
|
|
BoundingBoxf3 bb;
|
2017-06-13 09:35:24 +00:00
|
|
|
for (const ModelVolume *v : this->volumes)
|
2018-09-17 13:12:13 +00:00
|
|
|
if (v->is_model_part()) {
|
2018-09-18 08:09:58 +00:00
|
|
|
if (this->instances.empty())
|
|
|
|
throw std::invalid_argument("Can't call raw_bounding_box() with no instances");
|
2018-11-09 09:31:58 +00:00
|
|
|
bb.merge(this->instances.front()->transform_mesh_bounding_box(v->mesh, true));
|
2017-06-13 09:35:24 +00:00
|
|
|
}
|
2015-01-19 17:53:04 +00:00
|
|
|
return bb;
|
2014-09-21 08:51:36 +00:00
|
|
|
}
|
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
// This returns an accurate snug bounding box of the transformed object instance, without the translation applied.
|
|
|
|
BoundingBoxf3 ModelObject::instance_bounding_box(size_t instance_idx, bool dont_translate) const
|
2014-09-21 08:51:36 +00:00
|
|
|
{
|
2016-11-16 10:53:29 +00:00
|
|
|
BoundingBoxf3 bb;
|
2018-11-09 09:31:58 +00:00
|
|
|
#if ENABLE_MODELVOLUME_TRANSFORM
|
|
|
|
for (ModelVolume *v : this->volumes)
|
|
|
|
{
|
|
|
|
if (v->is_model_part())
|
|
|
|
{
|
|
|
|
TriangleMesh mesh(v->mesh);
|
|
|
|
mesh.transform(v->get_matrix());
|
|
|
|
bb.merge(this->instances[instance_idx]->transform_mesh_bounding_box(mesh, dont_translate));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
2017-06-13 09:35:24 +00:00
|
|
|
for (ModelVolume *v : this->volumes)
|
2018-09-17 13:12:13 +00:00
|
|
|
if (v->is_model_part())
|
2017-06-13 09:35:24 +00:00
|
|
|
bb.merge(this->instances[instance_idx]->transform_mesh_bounding_box(&v->mesh, dont_translate));
|
2018-11-09 09:31:58 +00:00
|
|
|
#endif // ENABLE_MODELVOLUME_TRANSFORM
|
2016-11-16 10:53:29 +00:00
|
|
|
return bb;
|
2014-09-21 08:51:36 +00:00
|
|
|
}
|
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
void ModelObject::center_around_origin()
|
2014-09-21 08:51:36 +00:00
|
|
|
{
|
|
|
|
// calculate the displacements needed to
|
|
|
|
// center this object around the origin
|
2016-11-16 10:53:29 +00:00
|
|
|
BoundingBoxf3 bb;
|
2017-06-13 09:35:24 +00:00
|
|
|
for (ModelVolume *v : this->volumes)
|
2018-09-17 13:12:13 +00:00
|
|
|
if (v->is_model_part())
|
2017-06-13 09:35:24 +00:00
|
|
|
bb.merge(v->mesh.bounding_box());
|
2014-09-21 08:51:36 +00:00
|
|
|
|
2018-10-08 12:02:12 +00:00
|
|
|
// Shift is the vector from the center of the bounding box to the origin
|
|
|
|
Vec3d shift = -bb.center();
|
2018-09-04 12:42:14 +00:00
|
|
|
|
|
|
|
this->translate(shift);
|
|
|
|
this->origin_translation += shift;
|
|
|
|
|
2018-11-02 11:11:28 +00:00
|
|
|
#if !ENABLE_MODELVOLUME_TRANSFORM
|
2014-09-21 08:51:36 +00:00
|
|
|
if (!this->instances.empty()) {
|
2017-06-13 09:35:24 +00:00
|
|
|
for (ModelInstance *i : this->instances) {
|
2018-10-22 11:27:53 +00:00
|
|
|
i->set_offset(i->get_offset() - shift);
|
2014-09-21 08:51:36 +00:00
|
|
|
}
|
2015-12-13 23:15:04 +00:00
|
|
|
this->invalidate_bounding_box();
|
2014-09-21 08:51:36 +00:00
|
|
|
}
|
2018-11-02 11:11:28 +00:00
|
|
|
#endif // !ENABLE_MODELVOLUME_TRANSFORM
|
2014-09-21 08:51:36 +00:00
|
|
|
}
|
|
|
|
|
2018-10-30 15:03:03 +00:00
|
|
|
void ModelObject::ensure_on_bed()
|
|
|
|
{
|
|
|
|
translate_instances(Vec3d(0.0, 0.0, -get_min_z()));
|
|
|
|
}
|
|
|
|
|
|
|
|
void ModelObject::translate_instances(const Vec3d& vector)
|
|
|
|
{
|
|
|
|
for (size_t i = 0; i < instances.size(); ++i)
|
|
|
|
{
|
|
|
|
translate_instance(i, vector);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void ModelObject::translate_instance(size_t instance_idx, const Vec3d& vector)
|
|
|
|
{
|
|
|
|
ModelInstance* i = instances[instance_idx];
|
|
|
|
i->set_offset(i->get_offset() + vector);
|
|
|
|
invalidate_bounding_box();
|
|
|
|
}
|
|
|
|
|
2018-11-01 13:25:10 +00:00
|
|
|
void ModelObject::translate(double x, double y, double z)
|
2014-12-12 21:43:04 +00:00
|
|
|
{
|
2017-06-13 09:35:24 +00:00
|
|
|
for (ModelVolume *v : this->volumes)
|
2018-08-15 10:50:06 +00:00
|
|
|
{
|
2018-11-02 11:11:28 +00:00
|
|
|
v->translate(x, y, z);
|
2018-08-15 10:50:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (m_bounding_box_valid)
|
2017-06-13 09:35:24 +00:00
|
|
|
m_bounding_box.translate(x, y, z);
|
2014-12-12 21:43:04 +00:00
|
|
|
}
|
|
|
|
|
2018-08-21 15:43:05 +00:00
|
|
|
void ModelObject::scale(const Vec3d &versor)
|
2014-09-21 08:51:36 +00:00
|
|
|
{
|
2017-06-13 09:35:24 +00:00
|
|
|
for (ModelVolume *v : this->volumes)
|
2018-08-15 10:50:06 +00:00
|
|
|
{
|
2018-11-02 13:41:08 +00:00
|
|
|
v->scale(versor);
|
2018-08-15 10:50:06 +00:00
|
|
|
}
|
2018-11-02 13:41:08 +00:00
|
|
|
#if !ENABLE_MODELVOLUME_TRANSFORM
|
2015-01-08 23:47:40 +00:00
|
|
|
// reset origin translation since it doesn't make sense anymore
|
2018-08-21 18:34:45 +00:00
|
|
|
this->origin_translation = Vec3d::Zero();
|
2018-11-02 13:41:08 +00:00
|
|
|
#endif // !ENABLE_MODELVOLUME_TRANSFORM
|
2014-09-21 08:51:36 +00:00
|
|
|
this->invalidate_bounding_box();
|
|
|
|
}
|
|
|
|
|
2018-11-05 07:31:54 +00:00
|
|
|
void ModelObject::rotate(double angle, Axis axis)
|
2018-08-27 12:00:53 +00:00
|
|
|
{
|
|
|
|
for (ModelVolume *v : this->volumes)
|
|
|
|
{
|
2018-11-05 07:31:54 +00:00
|
|
|
v->rotate(angle, axis);
|
2018-08-27 12:00:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
center_around_origin();
|
|
|
|
|
2018-11-05 07:31:54 +00:00
|
|
|
#if !ENABLE_MODELVOLUME_TRANSFORM
|
2018-08-27 12:00:53 +00:00
|
|
|
this->origin_translation = Vec3d::Zero();
|
2018-11-05 07:31:54 +00:00
|
|
|
#endif // !ENABLE_MODELVOLUME_TRANSFORM
|
2014-09-21 08:51:36 +00:00
|
|
|
this->invalidate_bounding_box();
|
|
|
|
}
|
|
|
|
|
2018-11-05 07:31:54 +00:00
|
|
|
void ModelObject::rotate(double angle, const Vec3d& axis)
|
2015-04-16 19:22:04 +00:00
|
|
|
{
|
2017-06-13 09:35:24 +00:00
|
|
|
for (ModelVolume *v : this->volumes)
|
2018-07-30 09:38:36 +00:00
|
|
|
{
|
2018-11-05 07:31:54 +00:00
|
|
|
v->rotate(angle, axis);
|
2018-07-30 09:38:36 +00:00
|
|
|
}
|
|
|
|
|
2018-08-13 14:16:37 +00:00
|
|
|
center_around_origin();
|
2018-07-30 09:38:36 +00:00
|
|
|
|
2018-11-05 07:31:54 +00:00
|
|
|
#if !ENABLE_MODELVOLUME_TRANSFORM
|
2018-08-21 18:34:45 +00:00
|
|
|
this->origin_translation = Vec3d::Zero();
|
2018-11-05 07:31:54 +00:00
|
|
|
#endif // !ENABLE_MODELVOLUME_TRANSFORM
|
2015-04-16 19:22:04 +00:00
|
|
|
this->invalidate_bounding_box();
|
|
|
|
}
|
|
|
|
|
2018-11-05 07:51:00 +00:00
|
|
|
void ModelObject::mirror(Axis axis)
|
2015-04-16 19:22:04 +00:00
|
|
|
{
|
2017-06-13 09:35:24 +00:00
|
|
|
for (ModelVolume *v : this->volumes)
|
2018-08-15 10:50:06 +00:00
|
|
|
{
|
2018-11-05 07:51:00 +00:00
|
|
|
v->mirror(axis);
|
2018-08-15 10:50:06 +00:00
|
|
|
}
|
|
|
|
|
2018-11-05 07:51:00 +00:00
|
|
|
#if !ENABLE_MODELVOLUME_TRANSFORM
|
2018-08-23 13:37:38 +00:00
|
|
|
this->origin_translation = Vec3d::Zero();
|
2018-11-05 07:51:00 +00:00
|
|
|
#endif // !ENABLE_MODELVOLUME_TRANSFORM
|
2015-04-16 19:22:04 +00:00
|
|
|
this->invalidate_bounding_box();
|
|
|
|
}
|
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
size_t ModelObject::materials_count() const
|
2014-09-21 08:51:36 +00:00
|
|
|
{
|
|
|
|
std::set<t_model_material_id> material_ids;
|
2017-06-13 09:35:24 +00:00
|
|
|
for (const ModelVolume *v : this->volumes)
|
|
|
|
material_ids.insert(v->material_id());
|
2014-09-21 08:51:36 +00:00
|
|
|
return material_ids.size();
|
|
|
|
}
|
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
size_t ModelObject::facets_count() const
|
2014-08-08 19:48:59 +00:00
|
|
|
{
|
|
|
|
size_t num = 0;
|
2017-06-13 09:35:24 +00:00
|
|
|
for (const ModelVolume *v : this->volumes)
|
2018-09-17 13:12:13 +00:00
|
|
|
if (v->is_model_part())
|
2017-06-13 09:35:24 +00:00
|
|
|
num += v->mesh.stl.stats.number_of_facets;
|
2014-08-08 19:48:59 +00:00
|
|
|
return num;
|
|
|
|
}
|
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
bool ModelObject::needed_repair() const
|
2014-08-08 19:48:59 +00:00
|
|
|
{
|
2017-06-13 09:35:24 +00:00
|
|
|
for (const ModelVolume *v : this->volumes)
|
2018-09-17 13:12:13 +00:00
|
|
|
if (v->is_model_part() && v->mesh.needed_repair())
|
2017-06-13 09:35:24 +00:00
|
|
|
return true;
|
2014-08-08 19:48:59 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
void ModelObject::cut(coordf_t z, Model* model) const
|
2014-09-21 08:51:36 +00:00
|
|
|
{
|
|
|
|
// clone this one to duplicate instances, materials etc.
|
|
|
|
ModelObject* upper = model->add_object(*this);
|
|
|
|
ModelObject* lower = model->add_object(*this);
|
2018-10-10 09:14:09 +00:00
|
|
|
upper->sla_support_points.clear();
|
|
|
|
lower->sla_support_points.clear();
|
2014-09-21 08:51:36 +00:00
|
|
|
upper->clear_volumes();
|
|
|
|
lower->clear_volumes();
|
2016-12-17 20:47:45 +00:00
|
|
|
upper->input_file = "";
|
|
|
|
lower->input_file = "";
|
2014-09-21 08:51:36 +00:00
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
for (ModelVolume *volume : this->volumes) {
|
2018-09-17 13:12:13 +00:00
|
|
|
if (! volume->is_model_part()) {
|
2014-09-21 08:51:36 +00:00
|
|
|
// don't cut modifiers
|
|
|
|
upper->add_volume(*volume);
|
|
|
|
lower->add_volume(*volume);
|
|
|
|
} else {
|
|
|
|
TriangleMesh upper_mesh, lower_mesh;
|
2018-04-12 10:56:42 +00:00
|
|
|
TriangleMeshSlicer tms(&volume->mesh);
|
|
|
|
tms.cut(z, &upper_mesh, &lower_mesh);
|
2017-02-26 21:03:03 +00:00
|
|
|
|
2014-09-21 08:51:36 +00:00
|
|
|
upper_mesh.repair();
|
|
|
|
lower_mesh.repair();
|
|
|
|
upper_mesh.reset_repair_stats();
|
|
|
|
lower_mesh.reset_repair_stats();
|
|
|
|
|
|
|
|
if (upper_mesh.facets_count() > 0) {
|
|
|
|
ModelVolume* vol = upper->add_volume(upper_mesh);
|
|
|
|
vol->name = volume->name;
|
|
|
|
vol->config = volume->config;
|
|
|
|
vol->set_material(volume->material_id(), *volume->material());
|
|
|
|
}
|
|
|
|
if (lower_mesh.facets_count() > 0) {
|
|
|
|
ModelVolume* vol = lower->add_volume(lower_mesh);
|
|
|
|
vol->name = volume->name;
|
|
|
|
vol->config = volume->config;
|
|
|
|
vol->set_material(volume->material_id(), *volume->material());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
void ModelObject::split(ModelObjectPtrs* new_objects)
|
2014-11-12 22:50:09 +00:00
|
|
|
{
|
|
|
|
if (this->volumes.size() > 1) {
|
|
|
|
// We can't split meshes if there's more than one volume, because
|
|
|
|
// we can't group the resulting meshes by object afterwards
|
2018-11-02 18:49:40 +00:00
|
|
|
new_objects->emplace_back(this);
|
2014-11-12 22:50:09 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
ModelVolume* volume = this->volumes.front();
|
|
|
|
TriangleMeshPtrs meshptrs = volume->mesh.split();
|
2017-06-19 12:26:19 +00:00
|
|
|
for (TriangleMesh *mesh : meshptrs) {
|
|
|
|
// Snap the mesh to Z=0.
|
|
|
|
float z0 = FLT_MAX;
|
|
|
|
|
|
|
|
mesh->repair();
|
2014-11-12 22:50:09 +00:00
|
|
|
|
2018-11-02 13:47:13 +00:00
|
|
|
ModelObject* new_object = m_model->add_object();
|
|
|
|
new_object->name = this->name;
|
|
|
|
new_object->config = this->config;
|
|
|
|
new_object->instances.reserve(this->instances.size());
|
|
|
|
for (const ModelInstance *model_instance : this->instances)
|
|
|
|
new_object->add_instance(*model_instance);
|
|
|
|
new_object->add_volume(*volume, std::move(*mesh));
|
2018-11-02 18:49:40 +00:00
|
|
|
new_objects->emplace_back(new_object);
|
2017-06-19 12:26:19 +00:00
|
|
|
delete mesh;
|
2014-11-12 22:50:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-09-20 14:48:13 +00:00
|
|
|
void ModelObject::repair()
|
2018-07-18 07:37:25 +00:00
|
|
|
{
|
2018-09-20 14:48:13 +00:00
|
|
|
for (ModelVolume *v : this->volumes)
|
|
|
|
v->mesh.repair();
|
|
|
|
}
|
2018-07-18 12:26:42 +00:00
|
|
|
|
2018-10-30 15:03:03 +00:00
|
|
|
double ModelObject::get_min_z() const
|
|
|
|
{
|
|
|
|
if (instances.empty())
|
|
|
|
return 0.0;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
double min_z = DBL_MAX;
|
|
|
|
for (size_t i = 0; i < instances.size(); ++i)
|
|
|
|
{
|
|
|
|
min_z = std::min(min_z, get_instance_min_z(i));
|
|
|
|
}
|
|
|
|
return min_z;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
double ModelObject::get_instance_min_z(size_t instance_idx) const
|
|
|
|
{
|
|
|
|
double min_z = DBL_MAX;
|
|
|
|
|
|
|
|
ModelInstance* inst = instances[instance_idx];
|
2018-11-02 11:11:28 +00:00
|
|
|
const Transform3d& mi = inst->get_matrix(true);
|
2018-10-30 15:03:03 +00:00
|
|
|
|
2018-11-02 11:11:28 +00:00
|
|
|
for (const ModelVolume* v : volumes)
|
2018-10-30 15:03:03 +00:00
|
|
|
{
|
2018-11-06 14:51:33 +00:00
|
|
|
if (!v->is_model_part())
|
|
|
|
continue;
|
|
|
|
|
2018-11-02 11:11:28 +00:00
|
|
|
#if ENABLE_MODELVOLUME_TRANSFORM
|
|
|
|
Transform3d mv = mi * v->get_matrix();
|
|
|
|
const TriangleMesh& hull = v->get_convex_hull();
|
|
|
|
for (uint32_t f = 0; f < hull.stl.stats.number_of_facets; ++f)
|
|
|
|
{
|
|
|
|
const stl_facet* facet = hull.stl.facet_start + f;
|
|
|
|
min_z = std::min(min_z, Vec3d::UnitZ().dot(mv * facet->vertex[0].cast<double>()));
|
|
|
|
min_z = std::min(min_z, Vec3d::UnitZ().dot(mv * facet->vertex[1].cast<double>()));
|
|
|
|
min_z = std::min(min_z, Vec3d::UnitZ().dot(mv * facet->vertex[2].cast<double>()));
|
|
|
|
}
|
|
|
|
#else
|
2018-10-30 15:03:03 +00:00
|
|
|
for (uint32_t f = 0; f < v->mesh.stl.stats.number_of_facets; ++f)
|
|
|
|
{
|
|
|
|
const stl_facet* facet = v->mesh.stl.facet_start + f;
|
2018-11-02 11:11:28 +00:00
|
|
|
min_z = std::min(min_z, Vec3d::UnitZ().dot(mi * facet->vertex[0].cast<double>()));
|
|
|
|
min_z = std::min(min_z, Vec3d::UnitZ().dot(mi * facet->vertex[1].cast<double>()));
|
|
|
|
min_z = std::min(min_z, Vec3d::UnitZ().dot(mi * facet->vertex[2].cast<double>()));
|
2018-10-30 15:03:03 +00:00
|
|
|
}
|
2018-11-02 11:11:28 +00:00
|
|
|
#endif // ENABLE_MODELVOLUME_TRANSFORM
|
2018-10-30 15:03:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return min_z + inst->get_offset(Z);
|
|
|
|
}
|
|
|
|
|
2018-10-23 13:27:31 +00:00
|
|
|
unsigned int ModelObject::check_instances_print_volume_state(const BoundingBoxf3& print_volume)
|
2018-07-18 07:37:25 +00:00
|
|
|
{
|
2018-10-23 13:27:31 +00:00
|
|
|
unsigned int num_printable = 0;
|
|
|
|
enum {
|
|
|
|
INSIDE = 1,
|
|
|
|
OUTSIDE = 2
|
|
|
|
};
|
|
|
|
for (ModelInstance *model_instance : this->instances) {
|
|
|
|
unsigned int inside_outside = 0;
|
|
|
|
for (const ModelVolume *vol : this->volumes)
|
|
|
|
if (vol->is_model_part()) {
|
2018-11-06 15:04:30 +00:00
|
|
|
#if ENABLE_MODELVOLUME_TRANSFORM
|
|
|
|
BoundingBoxf3 bb = vol->get_convex_hull().transformed_bounding_box(model_instance->get_matrix() * vol->get_matrix());
|
|
|
|
#else
|
2018-11-01 13:25:10 +00:00
|
|
|
BoundingBoxf3 bb = vol->get_convex_hull().transformed_bounding_box(model_instance->get_matrix());
|
2018-11-06 15:04:30 +00:00
|
|
|
#endif // ENABLE_MODELVOLUME_TRANSFORM
|
2018-07-18 12:26:42 +00:00
|
|
|
if (print_volume.contains(bb))
|
2018-10-23 13:27:31 +00:00
|
|
|
inside_outside |= INSIDE;
|
2018-07-18 12:26:42 +00:00
|
|
|
else if (print_volume.intersects(bb))
|
2018-10-23 13:27:31 +00:00
|
|
|
inside_outside |= INSIDE | OUTSIDE;
|
2018-07-18 12:26:42 +00:00
|
|
|
else
|
2018-10-23 13:27:31 +00:00
|
|
|
inside_outside |= OUTSIDE;
|
2018-07-18 07:37:25 +00:00
|
|
|
}
|
2018-10-23 13:27:31 +00:00
|
|
|
model_instance->print_volume_state =
|
|
|
|
(inside_outside == (INSIDE | OUTSIDE)) ? ModelInstance::PVS_Partly_Outside :
|
|
|
|
(inside_outside == INSIDE) ? ModelInstance::PVS_Inside : ModelInstance::PVS_Fully_Outside;
|
|
|
|
if (inside_outside == INSIDE)
|
|
|
|
++ num_printable;
|
2018-07-18 07:37:25 +00:00
|
|
|
}
|
2018-10-23 13:27:31 +00:00
|
|
|
return num_printable;
|
2018-07-18 07:37:25 +00:00
|
|
|
}
|
|
|
|
|
2017-08-02 14:05:18 +00:00
|
|
|
void ModelObject::print_info() const
|
|
|
|
{
|
|
|
|
using namespace std;
|
|
|
|
cout << fixed;
|
2017-08-03 15:31:31 +00:00
|
|
|
boost::nowide::cout << "[" << boost::filesystem::path(this->input_file).filename().string() << "]" << endl;
|
2017-08-02 14:05:18 +00:00
|
|
|
|
|
|
|
TriangleMesh mesh = this->raw_mesh();
|
|
|
|
mesh.check_topology();
|
|
|
|
BoundingBoxf3 bb = mesh.bounding_box();
|
2018-08-21 15:43:05 +00:00
|
|
|
Vec3d size = bb.size();
|
2018-08-17 13:53:43 +00:00
|
|
|
cout << "size_x = " << size(0) << endl;
|
|
|
|
cout << "size_y = " << size(1) << endl;
|
|
|
|
cout << "size_z = " << size(2) << endl;
|
|
|
|
cout << "min_x = " << bb.min(0) << endl;
|
|
|
|
cout << "min_y = " << bb.min(1) << endl;
|
|
|
|
cout << "min_z = " << bb.min(2) << endl;
|
|
|
|
cout << "max_x = " << bb.max(0) << endl;
|
|
|
|
cout << "max_y = " << bb.max(1) << endl;
|
|
|
|
cout << "max_z = " << bb.max(2) << endl;
|
2017-08-02 14:05:18 +00:00
|
|
|
cout << "number_of_facets = " << mesh.stl.stats.number_of_facets << endl;
|
|
|
|
cout << "manifold = " << (mesh.is_manifold() ? "yes" : "no") << endl;
|
|
|
|
|
|
|
|
mesh.repair(); // this calculates number_of_parts
|
|
|
|
if (mesh.needed_repair()) {
|
|
|
|
mesh.repair();
|
|
|
|
if (mesh.stl.stats.degenerate_facets > 0)
|
|
|
|
cout << "degenerate_facets = " << mesh.stl.stats.degenerate_facets << endl;
|
|
|
|
if (mesh.stl.stats.edges_fixed > 0)
|
|
|
|
cout << "edges_fixed = " << mesh.stl.stats.edges_fixed << endl;
|
|
|
|
if (mesh.stl.stats.facets_removed > 0)
|
|
|
|
cout << "facets_removed = " << mesh.stl.stats.facets_removed << endl;
|
|
|
|
if (mesh.stl.stats.facets_added > 0)
|
|
|
|
cout << "facets_added = " << mesh.stl.stats.facets_added << endl;
|
|
|
|
if (mesh.stl.stats.facets_reversed > 0)
|
|
|
|
cout << "facets_reversed = " << mesh.stl.stats.facets_reversed << endl;
|
|
|
|
if (mesh.stl.stats.backwards_edges > 0)
|
|
|
|
cout << "backwards_edges = " << mesh.stl.stats.backwards_edges << endl;
|
|
|
|
}
|
|
|
|
cout << "number_of_parts = " << mesh.stl.stats.number_of_parts << endl;
|
|
|
|
cout << "volume = " << mesh.volume() << endl;
|
|
|
|
}
|
|
|
|
|
2018-10-17 09:12:38 +00:00
|
|
|
void ModelVolume::set_material_id(t_model_material_id material_id)
|
2014-05-10 14:59:17 +00:00
|
|
|
{
|
2018-10-17 09:12:38 +00:00
|
|
|
m_material_id = material_id;
|
|
|
|
// ensure m_material_id references an existing material
|
2018-11-05 16:52:55 +00:00
|
|
|
if (! material_id.empty())
|
|
|
|
this->object->get_model()->add_material(material_id);
|
2014-05-10 14:59:17 +00:00
|
|
|
}
|
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
ModelMaterial* ModelVolume::material() const
|
|
|
|
{
|
2018-10-17 09:12:38 +00:00
|
|
|
return this->object->get_model()->get_material(m_material_id);
|
2014-05-10 14:59:17 +00:00
|
|
|
}
|
2014-04-29 23:04:49 +00:00
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
void ModelVolume::set_material(t_model_material_id material_id, const ModelMaterial &material)
|
2014-09-21 08:51:36 +00:00
|
|
|
{
|
2018-10-17 09:12:38 +00:00
|
|
|
m_material_id = material_id;
|
2018-11-05 16:52:55 +00:00
|
|
|
if (! material_id.empty())
|
|
|
|
this->object->get_model()->add_material(material_id, material);
|
2014-08-03 18:33:16 +00:00
|
|
|
}
|
|
|
|
|
2018-11-06 14:51:33 +00:00
|
|
|
#if ENABLE_MODELVOLUME_TRANSFORM
|
2018-11-12 07:54:22 +00:00
|
|
|
void ModelVolume::center_geometry()
|
2018-11-06 14:51:33 +00:00
|
|
|
{
|
2018-11-12 07:54:22 +00:00
|
|
|
Vec3d shift = -mesh.bounding_box().center();
|
|
|
|
mesh.translate((float)shift(0), (float)shift(1), (float)shift(2));
|
|
|
|
m_convex_hull.translate((float)shift(0), (float)shift(1), (float)shift(2));
|
|
|
|
translate(-shift);
|
2018-11-06 14:51:33 +00:00
|
|
|
}
|
|
|
|
#endif // ENABLE_MODELVOLUME_TRANSFORM
|
|
|
|
|
2018-08-15 10:50:06 +00:00
|
|
|
void ModelVolume::calculate_convex_hull()
|
|
|
|
{
|
|
|
|
m_convex_hull = mesh.convex_hull_3d();
|
|
|
|
}
|
|
|
|
|
|
|
|
const TriangleMesh& ModelVolume::get_convex_hull() const
|
|
|
|
{
|
|
|
|
return m_convex_hull;
|
|
|
|
}
|
|
|
|
|
2018-09-17 13:12:13 +00:00
|
|
|
ModelVolume::Type ModelVolume::type_from_string(const std::string &s)
|
|
|
|
{
|
|
|
|
// Legacy support
|
|
|
|
if (s == "1")
|
|
|
|
return PARAMETER_MODIFIER;
|
|
|
|
// New type (supporting the support enforcers & blockers)
|
|
|
|
if (s == "ModelPart")
|
|
|
|
return MODEL_PART;
|
|
|
|
if (s == "ParameterModifier")
|
|
|
|
return PARAMETER_MODIFIER;
|
|
|
|
if (s == "SupportEnforcer")
|
|
|
|
return SUPPORT_ENFORCER;
|
|
|
|
if (s == "SupportBlocker")
|
|
|
|
return SUPPORT_BLOCKER;
|
|
|
|
assert(s == "0");
|
|
|
|
// Default value if invalud type string received.
|
|
|
|
return MODEL_PART;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string ModelVolume::type_to_string(const Type t)
|
|
|
|
{
|
|
|
|
switch (t) {
|
|
|
|
case MODEL_PART: return "ModelPart";
|
|
|
|
case PARAMETER_MODIFIER: return "ParameterModifier";
|
|
|
|
case SUPPORT_ENFORCER: return "SupportEnforcer";
|
|
|
|
case SUPPORT_BLOCKER: return "SupportBlocker";
|
|
|
|
default:
|
|
|
|
assert(false);
|
|
|
|
return "ModelPart";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-15 13:38:15 +00:00
|
|
|
// 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.
|
2018-05-07 14:13:58 +00:00
|
|
|
size_t ModelVolume::split(unsigned int max_extruders)
|
2017-06-15 13:38:15 +00:00
|
|
|
{
|
|
|
|
TriangleMeshPtrs meshptrs = this->mesh.split();
|
|
|
|
if (meshptrs.size() <= 1) {
|
|
|
|
delete meshptrs.front();
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t idx = 0;
|
|
|
|
size_t ivolume = std::find(this->object->volumes.begin(), this->object->volumes.end(), this) - this->object->volumes.begin();
|
|
|
|
std::string name = this->name;
|
2018-04-10 10:17:55 +00:00
|
|
|
|
|
|
|
Model::reset_auto_extruder_id();
|
2018-11-13 07:36:10 +00:00
|
|
|
#if ENABLE_MODELVOLUME_TRANSFORM
|
|
|
|
Vec3d offset = this->get_offset();
|
|
|
|
#endif // ENABLE_MODELVOLUME_TRANSFORM
|
2018-04-10 10:17:55 +00:00
|
|
|
|
2017-06-15 13:38:15 +00:00
|
|
|
for (TriangleMesh *mesh : meshptrs) {
|
|
|
|
mesh->repair();
|
|
|
|
if (idx == 0)
|
|
|
|
this->mesh = std::move(*mesh);
|
|
|
|
else
|
2018-11-13 07:36:10 +00:00
|
|
|
this->object->volumes.insert(this->object->volumes.begin() + (++ivolume), new ModelVolume(object, *this, std::move(*mesh)));
|
|
|
|
|
|
|
|
#if ENABLE_MODELVOLUME_TRANSFORM
|
|
|
|
this->object->volumes[ivolume]->center_geometry();
|
|
|
|
this->object->volumes[ivolume]->translate(offset);
|
|
|
|
#endif // ENABLE_MODELVOLUME_TRANSFORM
|
|
|
|
this->object->volumes[ivolume]->name = name + "_" + std::to_string(idx + 1);
|
2018-05-07 14:13:58 +00:00
|
|
|
this->object->volumes[ivolume]->config.set_deserialize("extruder", Model::get_auto_extruder_id_as_string(max_extruders));
|
2017-06-15 13:38:15 +00:00
|
|
|
delete mesh;
|
|
|
|
++ idx;
|
|
|
|
}
|
|
|
|
|
|
|
|
return idx;
|
|
|
|
}
|
|
|
|
|
2018-11-01 13:25:10 +00:00
|
|
|
void ModelVolume::translate(const Vec3d& displacement)
|
|
|
|
{
|
2018-11-02 11:11:28 +00:00
|
|
|
#if ENABLE_MODELVOLUME_TRANSFORM
|
2018-11-07 13:01:03 +00:00
|
|
|
set_offset(get_offset() + displacement);
|
2018-11-02 11:11:28 +00:00
|
|
|
#else
|
2018-11-01 13:25:10 +00:00
|
|
|
mesh.translate((float)displacement(0), (float)displacement(1), (float)displacement(2));
|
|
|
|
m_convex_hull.translate((float)displacement(0), (float)displacement(1), (float)displacement(2));
|
2018-11-02 11:11:28 +00:00
|
|
|
#endif // ENABLE_MODELVOLUME_TRANSFORM
|
2018-11-01 13:25:10 +00:00
|
|
|
}
|
|
|
|
|
2018-11-02 13:41:08 +00:00
|
|
|
void ModelVolume::scale(const Vec3d& scaling_factors)
|
|
|
|
{
|
|
|
|
#if ENABLE_MODELVOLUME_TRANSFORM
|
2018-11-07 13:01:03 +00:00
|
|
|
set_scaling_factor(get_scaling_factor().cwiseProduct(scaling_factors));
|
2018-11-02 13:41:08 +00:00
|
|
|
#else
|
|
|
|
mesh.scale(scaling_factors);
|
|
|
|
m_convex_hull.scale(scaling_factors);
|
|
|
|
#endif // ENABLE_MODELVOLUME_TRANSFORM
|
|
|
|
}
|
|
|
|
|
2018-11-05 07:31:54 +00:00
|
|
|
void ModelVolume::rotate(double angle, Axis axis)
|
|
|
|
{
|
|
|
|
#if ENABLE_MODELVOLUME_TRANSFORM
|
|
|
|
switch (axis)
|
|
|
|
{
|
|
|
|
case X: { rotate(angle, Vec3d::UnitX()); break; }
|
|
|
|
case Y: { rotate(angle, Vec3d::UnitY()); break; }
|
|
|
|
case Z: { rotate(angle, Vec3d::UnitZ()); break; }
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
mesh.rotate(angle, axis);
|
|
|
|
m_convex_hull.rotate(angle, axis);
|
|
|
|
#endif // ENABLE_MODELVOLUME_TRANSFORM
|
|
|
|
}
|
|
|
|
|
|
|
|
void ModelVolume::rotate(double angle, const Vec3d& axis)
|
|
|
|
{
|
|
|
|
#if ENABLE_MODELVOLUME_TRANSFORM
|
2018-11-07 13:01:03 +00:00
|
|
|
set_rotation(get_rotation() + Geometry::extract_euler_angles(Eigen::Quaterniond(Eigen::AngleAxisd(angle, axis)).toRotationMatrix()));
|
2018-11-05 07:31:54 +00:00
|
|
|
#else
|
|
|
|
mesh.rotate(angle, axis);
|
|
|
|
m_convex_hull.rotate(angle, axis);
|
|
|
|
#endif // ENABLE_MODELVOLUME_TRANSFORM
|
|
|
|
}
|
|
|
|
|
2018-11-05 07:51:00 +00:00
|
|
|
void ModelVolume::mirror(Axis axis)
|
|
|
|
{
|
|
|
|
#if ENABLE_MODELVOLUME_TRANSFORM
|
2018-11-07 13:01:03 +00:00
|
|
|
Vec3d mirror = get_mirror();
|
2018-11-05 07:51:00 +00:00
|
|
|
switch (axis)
|
|
|
|
{
|
|
|
|
case X: { mirror(0) *= -1.0; break; }
|
|
|
|
case Y: { mirror(1) *= -1.0; break; }
|
|
|
|
case Z: { mirror(2) *= -1.0; break; }
|
|
|
|
}
|
2018-11-07 13:01:03 +00:00
|
|
|
set_mirror(mirror);
|
2018-11-05 07:51:00 +00:00
|
|
|
#else
|
|
|
|
mesh.mirror(axis);
|
|
|
|
m_convex_hull.mirror(axis);
|
|
|
|
#endif // ENABLE_MODELVOLUME_TRANSFORM
|
|
|
|
}
|
|
|
|
|
2018-10-31 13:56:51 +00:00
|
|
|
#if !ENABLE_MODELVOLUME_TRANSFORM
|
2018-09-20 13:00:40 +00:00
|
|
|
void ModelInstance::set_rotation(const Vec3d& rotation)
|
|
|
|
{
|
|
|
|
set_rotation(X, rotation(0));
|
|
|
|
set_rotation(Y, rotation(1));
|
|
|
|
set_rotation(Z, rotation(2));
|
|
|
|
}
|
|
|
|
|
|
|
|
void ModelInstance::set_rotation(Axis axis, double rotation)
|
|
|
|
{
|
|
|
|
static const double TWO_PI = 2.0 * (double)PI;
|
|
|
|
while (rotation < 0.0)
|
|
|
|
{
|
|
|
|
rotation += TWO_PI;
|
|
|
|
}
|
|
|
|
while (TWO_PI < rotation)
|
|
|
|
{
|
|
|
|
rotation -= TWO_PI;
|
|
|
|
}
|
|
|
|
m_rotation(axis) = rotation;
|
|
|
|
}
|
|
|
|
|
2018-10-18 13:50:51 +00:00
|
|
|
void ModelInstance::set_scaling_factor(const Vec3d& scaling_factor)
|
|
|
|
{
|
|
|
|
set_scaling_factor(X, scaling_factor(0));
|
|
|
|
set_scaling_factor(Y, scaling_factor(1));
|
|
|
|
set_scaling_factor(Z, scaling_factor(2));
|
|
|
|
}
|
|
|
|
|
|
|
|
void ModelInstance::set_scaling_factor(Axis axis, double scaling_factor)
|
|
|
|
{
|
|
|
|
m_scaling_factor(axis) = std::abs(scaling_factor);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ModelInstance::set_mirror(const Vec3d& mirror)
|
|
|
|
{
|
|
|
|
set_mirror(X, mirror(0));
|
|
|
|
set_mirror(Y, mirror(1));
|
|
|
|
set_mirror(Z, mirror(2));
|
|
|
|
}
|
|
|
|
|
|
|
|
void ModelInstance::set_mirror(Axis axis, double mirror)
|
|
|
|
{
|
|
|
|
double abs_mirror = std::abs(mirror);
|
|
|
|
if (abs_mirror == 0.0)
|
|
|
|
mirror = 1.0;
|
|
|
|
else if (abs_mirror != 1.0)
|
|
|
|
mirror /= abs_mirror;
|
|
|
|
|
|
|
|
m_mirror(axis) = mirror;
|
|
|
|
}
|
2018-10-31 13:56:51 +00:00
|
|
|
#endif // !ENABLE_MODELVOLUME_TRANSFORM
|
2018-09-20 13:00:40 +00:00
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
void ModelInstance::transform_mesh(TriangleMesh* mesh, bool dont_translate) const
|
2014-08-03 18:33:16 +00:00
|
|
|
{
|
2018-11-02 12:47:47 +00:00
|
|
|
mesh->transform(get_matrix(dont_translate));
|
2014-08-03 18:33:16 +00:00
|
|
|
}
|
|
|
|
|
2018-11-09 09:31:58 +00:00
|
|
|
BoundingBoxf3 ModelInstance::transform_mesh_bounding_box(const TriangleMesh& mesh, bool dont_translate) const
|
2016-11-16 10:53:29 +00:00
|
|
|
{
|
2017-06-13 09:35:24 +00:00
|
|
|
// Rotate around mesh origin.
|
2018-11-09 09:31:58 +00:00
|
|
|
TriangleMesh copy(mesh);
|
2018-11-02 12:47:47 +00:00
|
|
|
copy.transform(get_matrix(true, false, true, true));
|
2018-09-04 12:42:14 +00:00
|
|
|
BoundingBoxf3 bbox = copy.bounding_box();
|
|
|
|
|
|
|
|
if (!empty(bbox)) {
|
2018-09-24 13:54:09 +00:00
|
|
|
// Scale the bounding box along the three axes.
|
|
|
|
for (unsigned int i = 0; i < 3; ++i)
|
|
|
|
{
|
2018-10-31 13:56:51 +00:00
|
|
|
#if ENABLE_MODELVOLUME_TRANSFORM
|
2018-11-07 13:01:03 +00:00
|
|
|
if (std::abs(get_scaling_factor((Axis)i)-1.0) > EPSILON)
|
2018-10-31 13:56:51 +00:00
|
|
|
{
|
2018-11-07 13:01:03 +00:00
|
|
|
bbox.min(i) *= get_scaling_factor((Axis)i);
|
|
|
|
bbox.max(i) *= get_scaling_factor((Axis)i);
|
2018-10-31 13:56:51 +00:00
|
|
|
#else
|
2018-09-24 13:54:09 +00:00
|
|
|
if (std::abs(this->m_scaling_factor(i) - 1.0) > EPSILON)
|
|
|
|
{
|
|
|
|
bbox.min(i) *= this->m_scaling_factor(i);
|
|
|
|
bbox.max(i) *= this->m_scaling_factor(i);
|
2018-10-31 13:56:51 +00:00
|
|
|
#endif // ENABLE_MODELVOLUME_TRANSFORM
|
2018-09-24 13:54:09 +00:00
|
|
|
}
|
|
|
|
}
|
2018-09-25 08:42:11 +00:00
|
|
|
|
|
|
|
// Translate the bounding box.
|
|
|
|
if (! dont_translate) {
|
2018-10-31 13:56:51 +00:00
|
|
|
#if ENABLE_MODELVOLUME_TRANSFORM
|
2018-11-07 13:01:03 +00:00
|
|
|
bbox.min += get_offset();
|
|
|
|
bbox.max += get_offset();
|
2018-10-31 13:56:51 +00:00
|
|
|
#else
|
2018-09-25 08:42:11 +00:00
|
|
|
bbox.min += this->m_offset;
|
|
|
|
bbox.max += this->m_offset;
|
2018-10-31 13:56:51 +00:00
|
|
|
#endif // ENABLE_MODELVOLUME_TRANSFORM
|
2018-09-25 08:42:11 +00:00
|
|
|
}
|
2017-06-13 09:35:24 +00:00
|
|
|
}
|
2016-11-16 10:53:29 +00:00
|
|
|
return bbox;
|
|
|
|
}
|
|
|
|
|
|
|
|
BoundingBoxf3 ModelInstance::transform_bounding_box(const BoundingBoxf3 &bbox, bool dont_translate) const
|
|
|
|
{
|
2018-11-01 13:25:10 +00:00
|
|
|
return bbox.transformed(get_matrix(dont_translate));
|
2016-11-16 10:53:29 +00:00
|
|
|
}
|
|
|
|
|
2018-09-06 07:16:32 +00:00
|
|
|
Vec3d ModelInstance::transform_vector(const Vec3d& v, bool dont_translate) const
|
|
|
|
{
|
2018-11-01 13:25:10 +00:00
|
|
|
return get_matrix(dont_translate) * v;
|
2018-09-06 07:16:32 +00:00
|
|
|
}
|
|
|
|
|
2017-06-13 09:35:24 +00:00
|
|
|
void ModelInstance::transform_polygon(Polygon* polygon) const
|
2014-08-03 18:33:16 +00:00
|
|
|
{
|
2018-10-31 13:56:51 +00:00
|
|
|
#if ENABLE_MODELVOLUME_TRANSFORM
|
|
|
|
// CHECK_ME -> Is the following correct or it should take in account all three rotations ?
|
2018-11-07 13:01:03 +00:00
|
|
|
polygon->rotate(get_rotation(Z)); // rotate around polygon origin
|
2018-10-31 13:56:51 +00:00
|
|
|
// CHECK_ME -> Is the following correct ?
|
2018-11-07 13:01:03 +00:00
|
|
|
polygon->scale(get_scaling_factor(X), get_scaling_factor(Y)); // scale around polygon origin
|
2018-10-31 13:56:51 +00:00
|
|
|
#else
|
2018-09-20 13:00:40 +00:00
|
|
|
// CHECK_ME -> Is the following correct or it should take in account all three rotations ?
|
|
|
|
polygon->rotate(this->m_rotation(2)); // rotate around polygon origin
|
2018-09-24 13:54:09 +00:00
|
|
|
// CHECK_ME -> Is the following correct ?
|
|
|
|
polygon->scale(this->m_scaling_factor(0), this->m_scaling_factor(1)); // scale around polygon origin
|
2018-10-31 13:56:51 +00:00
|
|
|
#endif // ENABLE_MODELVOLUME_TRANSFORM
|
2014-08-03 18:33:16 +00:00
|
|
|
}
|
|
|
|
|
2018-10-31 13:56:51 +00:00
|
|
|
#if !ENABLE_MODELVOLUME_TRANSFORM
|
2018-11-01 13:41:18 +00:00
|
|
|
Transform3d ModelInstance::get_matrix(bool dont_translate, bool dont_rotate, bool dont_scale, bool dont_mirror) const
|
2018-09-04 12:42:14 +00:00
|
|
|
{
|
2018-10-12 08:09:16 +00:00
|
|
|
Vec3d translation = dont_translate ? Vec3d::Zero() : m_offset;
|
|
|
|
Vec3d rotation = dont_rotate ? Vec3d::Zero() : m_rotation;
|
|
|
|
Vec3d scale = dont_scale ? Vec3d::Ones() : m_scaling_factor;
|
2018-10-18 13:50:51 +00:00
|
|
|
Vec3d mirror = dont_mirror ? Vec3d::Ones() : m_mirror;
|
|
|
|
return Geometry::assemble_transform(translation, rotation, scale, mirror);
|
2018-09-04 12:42:14 +00:00
|
|
|
}
|
2018-10-31 13:56:51 +00:00
|
|
|
#endif // !ENABLE_MODELVOLUME_TRANSFORM
|
2018-09-04 12:42:14 +00:00
|
|
|
|
2014-04-29 23:04:49 +00:00
|
|
|
}
|