3DPrinting/PrusaSlicer-NonPlainar
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Calculating the transformations is now only performed by the MeshClipper

Browse source 
Attempted to get mirroring right (that never worked correctly with the clipping plane in the sla gizmo)
The transformation of the support mesh is kind of a mystery to me, hopefully it is right
Also cleaned the code a bit (removed commented-out code, unused variables, etc)
This commit is contained in:
Lukas Matena 2019-09-12 16:57:30 +02:00
parent 546917830b
commit 9782701dd4
4 changed files with 85 additions and 117 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

140
src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.cpp
View file

@ -28,7 +28,6 @@ GLGizmoSlaSupports::GLGizmoSlaSupports(GLCanvas3D& parent, const std::string& ic
, m_its(nullptr) , m_its(nullptr)
{ {
m_clipping_plane.reset(new ClippingPlane(Vec3d::Zero(), 0.)); m_clipping_plane.reset(new ClippingPlane(Vec3d::Zero(), 0.));
m_old_clipping_plane.reset(new ClippingPlane(Vec3d::Zero(), 0.));
m_quadric = ::gluNewQuadric(); m_quadric = ::gluNewQuadric();
if (m_quadric != nullptr) if (m_quadric != nullptr)
// using GLU_FILL does not work when the instance's transformation // using GLU_FILL does not work when the instance's transformation
@ -140,117 +139,82 @@ void GLGizmoSlaSupports::render_clipping_plane(const Selection& selection) const
if (m_clipping_plane_distance == 0.f) if (m_clipping_plane_distance == 0.f)
return; return;
const Vec3d& center = m_model_object->instances[m_active_instance]->get_offset() + Vec3d(0., 0., m_z_shift); // Get transformation of the instance
// First cache instance transformation to be used later.
const GLVolume* vol = selection.get_volume(*selection.get_volume_idxs().begin()); const GLVolume* vol = selection.get_volume(*selection.get_volume_idxs().begin());
Geometry::Transformation trafo = vol->get_instance_transformation(); Geometry::Transformation trafo = vol->get_instance_transformation();
Transform3f instance_matrix = trafo.get_matrix().cast<float>(); trafo.set_offset(trafo.get_offset() + Vec3d(0., 0., m_z_shift));
Transform3f instance_matrix_no_translation_no_scaling = trafo.get_matrix(true,false,true).cast<float>();
Vec3f scaling = vol->get_instance_scaling_factor().cast<float>(); // Get transformation of supports
Vec3d instance_offset = vol->get_instance_offset(); Geometry::Transformation supports_trafo;
// Calculate distance from mesh origin to the clipping plane (in mesh coordinates). supports_trafo.set_offset(Vec3d(trafo.get_offset()(0), trafo.get_offset()(1), vol->get_sla_shift_z()));
Vec3f up_noscale = instance_matrix_no_translation_no_scaling.inverse() * m_clipping_plane->get_normal().cast<float>(); supports_trafo.set_rotation(Vec3d(0., 0., trafo.get_rotation()(2)));
Vec3f up = Vec3f(up_noscale(0)*scaling(0), up_noscale(1)*scaling(1), up_noscale(2)*scaling(2)); // I don't know why, but following seems to be correct.
float height_mesh = m_clipping_plane->distance(center) * (up_noscale.norm()/up.norm()); supports_trafo.set_mirror(Vec3d(trafo.get_mirror()(0) * trafo.get_mirror()(1) * trafo.get_mirror()(2),
1,
1.));
// Now initialize the TMS for the object, perform the cut and save the result.
if (! m_object_clipper) {
m_object_clipper.reset(new MeshClipper);
m_object_clipper->set_mesh(*m_mesh);
}
m_object_clipper->set_plane(*m_clipping_plane);
m_object_clipper->set_transformation(trafo);
// Get transformation of the supports and calculate how far from its origin the clipping plane is. // Next, ask the backend if supports are already calculated. If so, we are gonna cut them too.
Transform3d supports_trafo = Transform3d::Identity(); // First we need a pointer to the respective SLAPrintObject. The index into objects vector is
supports_trafo = supports_trafo.rotate(Eigen::AngleAxisd(vol->get_instance_rotation()(2), Vec3d::UnitZ())); // cached so we don't have todo it on each render. We only search for the po if needed:
Vec3f up_supports = (supports_trafo.inverse() * m_clipping_plane->get_normal()).cast<float>(); if (m_print_object_idx < 0 || (int)m_parent.sla_print()->objects().size() != m_print_objects_count) {
supports_trafo = supports_trafo.pretranslate(Vec3d(instance_offset(0), instance_offset(1), vol->get_sla_shift_z())); m_print_objects_count = m_parent.sla_print()->objects().size();
// Instance and supports origin do not coincide, so the following is quite messy: m_print_object_idx = -1;
float height_supports = height_mesh * (up.norm() / up_supports.norm()) + instance_offset(2) * (m_clipping_plane->get_normal()(2)); for (const SLAPrintObject* po : m_parent.sla_print()->objects()) {
++m_print_object_idx;
// In case either of these was recently changed, the cached triangulated ExPolygons are invalid now. if (po->model_object()->id() == m_model_object->id())
// We are gonna recalculate them both for the object and for the support structures. break;
if (*m_old_clipping_plane != *m_clipping_plane) {
*m_old_clipping_plane = *m_clipping_plane;
// Now initialize the TMS for the object, perform the cut and save the result.
if (! m_object_clipper) {
m_object_clipper.reset(new MeshClipper);
m_object_clipper->set_mesh(*m_mesh);
} }
m_object_clipper->set_plane(*m_clipping_plane); }
trafo.set_offset(trafo.get_offset() + Vec3d(0., 0., m_z_shift)); if (m_print_object_idx >= 0) {
m_object_clipper->set_transformation(trafo); const SLAPrintObject* print_object = m_parent.sla_print()->objects()[m_print_object_idx];
if (print_object->is_step_done(slaposSupportTree)) {
// If the supports are already calculated, save the timestamp of the respective step
// so we can later tell they were recalculated.
size_t timestamp = print_object->step_state_with_timestamp(slaposSupportTree).timestamp;
// Next, ask the backend if supports are already calculated. If so, we are gonna cut them too. if (! m_supports_clipper || (int)timestamp != m_old_timestamp) {
// First we need a pointer to the respective SLAPrintObject. The index into objects vector is // The timestamp has changed.
// cached so we don't have todo it on each render. We only search for the po if needed: m_supports_clipper.reset(new MeshClipper);
if (m_print_object_idx < 0 || (int)m_parent.sla_print()->objects().size() != m_print_objects_count) { // The mesh should already have the shared vertices calculated.
m_print_objects_count = m_parent.sla_print()->objects().size(); m_supports_clipper->set_mesh(print_object->support_mesh());
m_print_object_idx = -1; m_old_timestamp = timestamp;
for (const SLAPrintObject* po : m_parent.sla_print()->objects()) {
++m_print_object_idx;
if (po->model_object()->id() == m_model_object->id())
break;
} }
m_supports_clipper->set_plane(*m_clipping_plane);
m_supports_clipper->set_transformation(supports_trafo);
} }
if (m_print_object_idx >= 0) { else
const SLAPrintObject* print_object = m_parent.sla_print()->objects()[m_print_object_idx]; // The supports are not valid. We better dump the cached data.
m_supports_clipper.reset();
if (print_object->is_step_done(slaposSupportTree)) {
// If the supports are already calculated, save the timestamp of the respective step
// so we can later tell they were recalculated.
size_t timestamp = print_object->step_state_with_timestamp(slaposSupportTree).timestamp;
if (! m_supports_clipper || (int)timestamp != m_old_timestamp) {
// The timestamp has changed - stash the mesh and initialize the TMS.
m_supports_mesh = &print_object->support_mesh();
m_supports_clipper.reset(new MeshClipper);
// The mesh should already have the shared vertices calculated.
m_supports_clipper->set_mesh(*m_supports_mesh);
m_old_timestamp = timestamp;
}
// The TMS is initialized - let's do the cutting:
m_supports_clipper->set_plane(*m_clipping_plane);
m_supports_clipper->set_transformation(Geometry::Transformation(supports_trafo));
}
else
// The supports are not valid. We better dump the cached data.
m_supports_clipper.reset();
}
} }
// At this point we have the triangulated cuts for both the object and supports - let's render. // At this point we have the triangulated cuts for both the object and supports - let's render.
if (! m_object_clipper->get_triangles().empty()) { if (! m_object_clipper->get_triangles().empty()) {
::glPushMatrix(); ::glPushMatrix();
::glTranslated(0.0, 0.0, m_z_shift);
::glMultMatrixf(instance_matrix.data());
Eigen::Quaternionf q;
q.setFromTwoVectors(Vec3f::UnitZ(), up);
Eigen::AngleAxisf aa(q);
::glRotatef(aa.angle() * (180./M_PI), aa.axis()(0), aa.axis()(1), aa.axis()(2));
::glTranslatef(0.f, 0.f, 0.01f); // to make sure the cut does not intersect the structure itself
::glColor3f(1.0f, 0.37f, 0.0f); ::glColor3f(1.0f, 0.37f, 0.0f);
::glBegin(GL_TRIANGLES); ::glBegin(GL_TRIANGLES);
for (const Vec2f& point : m_object_clipper->get_triangles()) for (const Vec3f& point : m_object_clipper->get_triangles())
::glVertex3f(point(0), point(1), height_mesh); ::glVertex3f(point(0), point(1), point(2));
::glEnd(); ::glEnd();
::glPopMatrix(); ::glPopMatrix();
} }
if (m_supports_clipper && ! m_supports_clipper->get_triangles().empty() && !m_editing_mode) { if (m_supports_clipper && ! m_supports_clipper->get_triangles().empty() && !m_editing_mode) {
// The supports are hidden in the editing mode, so it makes no sense to render the cuts. // The supports are hidden in the editing mode, so it makes no sense to render the cuts.
::glPushMatrix(); ::glPushMatrix();
::glMultMatrixd(supports_trafo.data());
Eigen::Quaternionf q;
q.setFromTwoVectors(Vec3f::UnitZ(), up_supports);
Eigen::AngleAxisf aa(q);
::glRotatef(aa.angle() * (180./M_PI), aa.axis()(0), aa.axis()(1), aa.axis()(2));
::glTranslatef(0.f, 0.f, 0.01f);
::glColor3f(1.0f, 0.f, 0.37f); ::glColor3f(1.0f, 0.f, 0.37f);
::glBegin(GL_TRIANGLES); ::glBegin(GL_TRIANGLES);
for (const Vec2f& point : m_supports_clipper->get_triangles()) for (const Vec3f& point : m_supports_clipper->get_triangles())
::glVertex3f(point(0), point(1), height_supports); ::glVertex3f(point(0), point(1), point(2));
::glEnd(); ::glEnd();
::glPopMatrix(); ::glPopMatrix();
} }

1
src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.hpp
View file

@ -115,7 +115,6 @@ private:
float m_clipping_plane_distance = 0.f; float m_clipping_plane_distance = 0.f;
std::unique_ptr<ClippingPlane> m_clipping_plane; std::unique_ptr<ClippingPlane> m_clipping_plane;
std::unique_ptr<ClippingPlane> m_old_clipping_plane;
// This map holds all translated description texts, so they can be easily referenced during layout calculations // This map holds all translated description texts, so they can be easily referenced during layout calculations
// etc. When language changes, GUI is recreated and this class constructed again, so the change takes effect. // etc. When language changes, GUI is recreated and this class constructed again, so the change takes effect.

54
src/slic3r/GUI/MeshClipper.cpp
View file

@ -18,7 +18,8 @@ void MeshClipper::set_mesh(const TriangleMesh& mesh)
if (m_mesh != &mesh) { if (m_mesh != &mesh) {
m_mesh = &mesh; m_mesh = &mesh;
m_triangles_valid = false; m_triangles_valid = false;
m_triangles.resize(0); m_triangles2d.resize(0);
m_triangles3d.resize(0);
m_tms.reset(nullptr); m_tms.reset(nullptr);
} }
} }
@ -28,17 +29,19 @@ void MeshClipper::set_transformation(const Geometry::Transformation& trafo)
if (! m_trafo.get_matrix().isApprox(trafo.get_matrix())) { if (! m_trafo.get_matrix().isApprox(trafo.get_matrix())) {
m_trafo = trafo; m_trafo = trafo;
m_triangles_valid = false; m_triangles_valid = false;
m_triangles.resize(0); m_triangles2d.resize(0);
m_triangles3d.resize(0);
} }
} }
const std::vector<Vec2f>& MeshClipper::get_triangles()
const std::vector<Vec3f>& MeshClipper::get_triangles()
{ {
if (! m_triangles_valid) if (! m_triangles_valid)
recalculate_triangles(); recalculate_triangles();
return m_triangles; return m_triangles3d;
} }
void MeshClipper::recalculate_triangles() void MeshClipper::recalculate_triangles()
@ -49,34 +52,37 @@ void MeshClipper::recalculate_triangles()
} }
auto up_and_height = get_mesh_cut_normal(); const Transform3f& instance_matrix_no_translation_no_scaling = m_trafo.get_matrix(true,false,true).cast<float>();
Vec3f up = up_and_height.first; const Vec3f& scaling = m_trafo.get_scaling_factor().cast<float>();
float height_mesh = up_and_height.second; // Calculate clipping plane normal in mesh coordinates.
Vec3f up_noscale = instance_matrix_no_translation_no_scaling.inverse() * m_plane.get_normal().cast<float>();
Vec3f up (up_noscale(0)*scaling(0), up_noscale(1)*scaling(1), up_noscale(2)*scaling(2));
// Calculate distance from mesh origin to the clipping plane (in mesh coordinates).
float height_mesh = m_plane.distance(m_trafo.get_offset()) * (up_noscale.norm()/up.norm());
// Now do the cutting
std::vector<ExPolygons> list_of_expolys; std::vector<ExPolygons> list_of_expolys;
m_tms->set_up_direction(up); m_tms->set_up_direction(up);
m_tms->slice(std::vector<float>{height_mesh}, 0.f, &list_of_expolys, [](){}); m_tms->slice(std::vector<float>{height_mesh}, 0.f, &list_of_expolys, [](){});
m_triangles = triangulate_expolygons_2f(list_of_expolys[0]); m_triangles2d = triangulate_expolygons_2f(list_of_expolys[0], m_trafo.get_matrix().matrix().determinant() < 0.);
// Rotate the cut into world coords:
Eigen::Quaternionf q;
q.setFromTwoVectors(Vec3f::UnitZ(), up);
Transform3f tr = Transform3f::Identity();
tr.rotate(q);
tr = m_trafo.get_matrix().cast<float>() * tr;
m_triangles3d.clear();
m_triangles3d.reserve(m_triangles2d.size());
for (const Vec2f& pt : m_triangles2d) {
m_triangles3d.push_back(Vec3f(pt(0), pt(1), height_mesh+0.001f));
m_triangles3d.back() = tr * m_triangles3d.back();
}
m_triangles_valid = true; m_triangles_valid = true;
} }
std::pair<Vec3f, float> MeshClipper::get_mesh_cut_normal() const
{
Transform3f instance_matrix_no_translation_no_scaling = m_trafo.get_matrix(true,false,true).cast<float>();
Vec3f scaling = m_trafo.get_scaling_factor().cast<float>();
// Calculate distance from mesh origin to the clipping plane (in mesh coordinates).
Vec3f up_noscale = instance_matrix_no_translation_no_scaling.inverse() * m_plane.get_normal().cast<float>();
Vec3f up (up_noscale(0)*scaling(0), up_noscale(1)*scaling(1), up_noscale(2)*scaling(2));
float height_mesh = m_plane.distance(m_trafo.get_offset()) * (up_noscale.norm()/up.norm());
return std::make_pair(up, height_mesh);
}
} // namespace GUI } // namespace GUI

7
src/slic3r/GUI/MeshClipper.hpp
View file

@ -13,17 +13,16 @@ public:
void set_mesh(const TriangleMesh& mesh); void set_mesh(const TriangleMesh& mesh);
void set_transformation(const Geometry::Transformation& trafo); void set_transformation(const Geometry::Transformation& trafo);
const std::vector<Vec2f>& get_triangles(); const std::vector<Vec3f>& get_triangles();
private: private:
void recalculate_triangles(); void recalculate_triangles();
std::pair<Vec3f, float> get_mesh_cut_normal() const;
Geometry::Transformation m_trafo; Geometry::Transformation m_trafo;
const TriangleMesh* m_mesh = nullptr; const TriangleMesh* m_mesh = nullptr;
ClippingPlane m_plane; ClippingPlane m_plane;
std::vector<Vec2f> m_triangles; std::vector<Vec2f> m_triangles2d;
std::vector<Vec3f> m_triangles3d;
bool m_triangles_valid = false; bool m_triangles_valid = false;
std::unique_ptr<TriangleMeshSlicer> m_tms; std::unique_ptr<TriangleMeshSlicer> m_tms;
}; };