From 4d98d321996de6e6d036403c319b6ef044144dcd Mon Sep 17 00:00:00 2001 From: Enrico Turri Date: Wed, 15 Aug 2018 12:50:06 +0200 Subject: Use of bounding box of rotated 3D convex hull for out of print volume detection --- xs/src/libslic3r/Format/3mf.cpp | 1 + xs/src/libslic3r/Format/AMF.cpp | 1 + xs/src/libslic3r/Model.cpp | 129 +++++++++++------------------------- xs/src/libslic3r/Model.hpp | 36 +++++++---- xs/src/libslic3r/TriangleMesh.cpp | 133 ++++++++++++++++++++++++++++++++++++++ xs/src/libslic3r/TriangleMesh.hpp | 6 +- xs/src/slic3r/GUI/3DScene.cpp | 76 +++++++++++++++------- xs/src/slic3r/GUI/3DScene.hpp | 16 +++-- xs/src/slic3r/GUI/GLCanvas3D.cpp | 2 +- xs/src/slic3r/GUI/GLGizmo.cpp | 14 ++-- xs/src/slic3r/GUI/GLGizmo.hpp | 2 +- xs/xsp/GUI_3DScene.xsp | 1 - 12 files changed, 276 insertions(+), 141 deletions(-) diff --git a/xs/src/libslic3r/Format/3mf.cpp b/xs/src/libslic3r/Format/3mf.cpp index dd3500eba..5de1d26c5 100644 --- a/xs/src/libslic3r/Format/3mf.cpp +++ b/xs/src/libslic3r/Format/3mf.cpp @@ -1491,6 +1491,7 @@ namespace Slic3r { stl_get_size(&stl); volume->mesh.repair(); + volume->calculate_convex_hull(); // apply volume's name and config data for (const Metadata& metadata : volume_data.metadata) diff --git a/xs/src/libslic3r/Format/AMF.cpp b/xs/src/libslic3r/Format/AMF.cpp index 600aa6cd9..886bbae97 100644 --- a/xs/src/libslic3r/Format/AMF.cpp +++ b/xs/src/libslic3r/Format/AMF.cpp @@ -406,6 +406,7 @@ void AMFParserContext::endElement(const char * /* name */) } stl_get_size(&stl); m_volume->mesh.repair(); + m_volume->calculate_convex_hull(); m_volume_facets.clear(); m_volume = nullptr; break; diff --git a/xs/src/libslic3r/Model.cpp b/xs/src/libslic3r/Model.cpp index f9936537f..23d447748 100644 --- a/xs/src/libslic3r/Model.cpp +++ b/xs/src/libslic3r/Model.cpp @@ -17,6 +17,11 @@ #include "SVG.hpp" #include +static const float UNIT_MATRIX[] = { 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f }; + namespace Slic3r { unsigned int Model::s_auto_extruder_id = 1; @@ -235,14 +240,6 @@ BoundingBoxf3 Model::bounding_box() const return bb; } -BoundingBoxf3 Model::transformed_bounding_box() const -{ - BoundingBoxf3 bb; - for (const ModelObject* obj : this->objects) - bb.merge(obj->tight_bounding_box(false)); - return bb; -} - void Model::center_instances_around_point(const Pointf &point) { // BoundingBoxf3 bb = this->bounding_box(); @@ -623,54 +620,6 @@ const BoundingBoxf3& ModelObject::bounding_box() const return m_bounding_box; } -BoundingBoxf3 ModelObject::tight_bounding_box(bool include_modifiers) const -{ - BoundingBoxf3 bb; - - for (const ModelVolume* vol : this->volumes) - { - if (include_modifiers || !vol->modifier) - { - for (const ModelInstance* inst : this->instances) - { - double c = cos(inst->rotation); - double s = sin(inst->rotation); - - for (int f = 0; f < vol->mesh.stl.stats.number_of_facets; ++f) - { - const stl_facet& facet = vol->mesh.stl.facet_start[f]; - - for (int i = 0; i < 3; ++i) - { - // original point - const stl_vertex& v = facet.vertex[i]; - Pointf3 p((double)v.x, (double)v.y, (double)v.z); - - // scale - p.x *= inst->scaling_factor; - p.y *= inst->scaling_factor; - p.z *= inst->scaling_factor; - - // rotate Z - double x = p.x; - double y = p.y; - p.x = c * x - s * y; - p.y = s * x + c * y; - - // translate - p.x += inst->offset.x; - p.y += inst->offset.y; - - bb.merge(p); - } - } - } - } - } - - return bb; -} - // A mesh containing all transformed instances of this object. TriangleMesh ModelObject::mesh() const { @@ -755,15 +704,22 @@ void ModelObject::center_around_origin() void ModelObject::translate(coordf_t x, coordf_t y, coordf_t z) { for (ModelVolume *v : this->volumes) + { v->mesh.translate(float(x), float(y), float(z)); - if (m_bounding_box_valid) + v->m_convex_hull.translate(float(x), float(y), float(z)); + } + + if (m_bounding_box_valid) m_bounding_box.translate(x, y, z); } void ModelObject::scale(const Pointf3 &versor) { for (ModelVolume *v : this->volumes) + { v->mesh.scale(versor); + v->m_convex_hull.scale(versor); + } // reset origin translation since it doesn't make sense anymore this->origin_translation = Pointf3(0,0,0); this->invalidate_bounding_box(); @@ -774,6 +730,7 @@ void ModelObject::rotate(float angle, const Axis &axis) for (ModelVolume *v : this->volumes) { v->mesh.rotate(angle, axis); + v->m_convex_hull.rotate(angle, axis); } center_around_origin(); @@ -790,6 +747,7 @@ void ModelObject::transform(const float* matrix3x4) for (ModelVolume* v : volumes) { v->mesh.transform(matrix3x4); + v->m_convex_hull.transform(matrix3x4); } origin_translation = Pointf3(0.0, 0.0, 0.0); @@ -799,8 +757,12 @@ void ModelObject::transform(const float* matrix3x4) void ModelObject::mirror(const Axis &axis) { for (ModelVolume *v : this->volumes) + { v->mesh.mirror(axis); - this->origin_translation = Pointf3(0,0,0); + v->m_convex_hull.mirror(axis); + } + + this->origin_translation = Pointf3(0, 0, 0); this->invalidate_bounding_box(); } @@ -904,45 +866,20 @@ void ModelObject::split(ModelObjectPtrs* new_objects) void ModelObject::check_instances_print_volume_state(const BoundingBoxf3& print_volume) { - for (ModelVolume* vol : this->volumes) + for (const ModelVolume* vol : this->volumes) { if (!vol->modifier) { for (ModelInstance* inst : this->instances) { - BoundingBoxf3 bb; - - double c = cos(inst->rotation); - double s = sin(inst->rotation); - - for (int f = 0; f < vol->mesh.stl.stats.number_of_facets; ++f) - { - const stl_facet& facet = vol->mesh.stl.facet_start[f]; + std::vector world_mat(UNIT_MATRIX, std::end(UNIT_MATRIX)); + Eigen::Transform m = Eigen::Transform::Identity(); + m.translate(Eigen::Vector3f((float)inst->offset.x, (float)inst->offset.y, 0.0f)); + m.rotate(Eigen::AngleAxisf(inst->rotation, Eigen::Vector3f::UnitZ())); + m.scale(inst->scaling_factor); + ::memcpy((void*)world_mat.data(), (const void*)m.data(), 16 * sizeof(float)); - for (int i = 0; i < 3; ++i) - { - // original point - const stl_vertex& v = facet.vertex[i]; - Pointf3 p((double)v.x, (double)v.y, (double)v.z); - - // scale - p.x *= inst->scaling_factor; - p.y *= inst->scaling_factor; - p.z *= inst->scaling_factor; - - // rotate Z - double x = p.x; - double y = p.y; - p.x = c * x - s * y; - p.y = s * x + c * y; - - // translate - p.x += inst->offset.x; - p.y += inst->offset.y; - - bb.merge(p); - } - } + BoundingBoxf3 bb = vol->get_convex_hull().transformed_bounding_box(world_mat); if (print_volume.contains(bb)) inst->print_volume_state = ModelInstance::PVS_Inside; @@ -1025,6 +962,16 @@ ModelMaterial* ModelVolume::assign_unique_material() return model->add_material(this->_material_id); } +void ModelVolume::calculate_convex_hull() +{ + m_convex_hull = mesh.convex_hull_3d(); +} + +const TriangleMesh& ModelVolume::get_convex_hull() const +{ + return m_convex_hull; +} + // 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. diff --git a/xs/src/libslic3r/Model.hpp b/xs/src/libslic3r/Model.hpp index 4c650f0de..23af9fb1c 100644 --- a/xs/src/libslic3r/Model.hpp +++ b/xs/src/libslic3r/Model.hpp @@ -105,9 +105,6 @@ public: // This bounding box is being cached. const BoundingBoxf3& bounding_box() const; void invalidate_bounding_box() { m_bounding_box_valid = false; } - // Returns a snug bounding box of the transformed instances. - // This bounding box is not being cached. - BoundingBoxf3 tight_bounding_box(bool include_modifiers) const; // A mesh containing all transformed instances of this object. TriangleMesh mesh() const; @@ -157,6 +154,10 @@ private: class ModelVolume { friend class ModelObject; + + // The convex hull of this model's mesh. + TriangleMesh m_convex_hull; + public: std::string name; // The triangular model. @@ -180,19 +181,32 @@ public: ModelMaterial* assign_unique_material(); + void calculate_convex_hull(); + const TriangleMesh& get_convex_hull() const; + private: // Parent object owning this ModelVolume. ModelObject* object; t_model_material_id _material_id; - ModelVolume(ModelObject *object, const TriangleMesh &mesh) : mesh(mesh), modifier(false), object(object) {} - ModelVolume(ModelObject *object, TriangleMesh &&mesh) : mesh(std::move(mesh)), modifier(false), object(object) {} - ModelVolume(ModelObject *object, const ModelVolume &other) : - name(other.name), mesh(other.mesh), config(other.config), modifier(other.modifier), object(object) - { this->material_id(other.material_id()); } - ModelVolume(ModelObject *object, const ModelVolume &other, const TriangleMesh &&mesh) : + ModelVolume(ModelObject *object, const TriangleMesh &mesh) : mesh(mesh), modifier(false), 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)), modifier(false), object(object) {} + ModelVolume(ModelObject *object, const ModelVolume &other) : + name(other.name), mesh(other.mesh), m_convex_hull(other.m_convex_hull), config(other.config), modifier(other.modifier), object(object) + { + this->material_id(other.material_id()); + } + ModelVolume(ModelObject *object, const ModelVolume &other, const TriangleMesh &&mesh) : name(other.name), mesh(std::move(mesh)), config(other.config), modifier(other.modifier), object(object) - { this->material_id(other.material_id()); } + { + this->material_id(other.material_id()); + if (mesh.stl.stats.number_of_facets > 1) + calculate_convex_hull(); + } }; // A single instance of a ModelObject. @@ -285,8 +299,6 @@ public: bool add_default_instances(); // Returns approximate axis aligned bounding box of this model BoundingBoxf3 bounding_box() const; - // Returns tight axis aligned bounding box of this model - BoundingBoxf3 transformed_bounding_box() const; void center_instances_around_point(const Pointf &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; diff --git a/xs/src/libslic3r/TriangleMesh.cpp b/xs/src/libslic3r/TriangleMesh.cpp index 45e4b6f5d..fc72a45aa 100644 --- a/xs/src/libslic3r/TriangleMesh.cpp +++ b/xs/src/libslic3r/TriangleMesh.cpp @@ -1,6 +1,9 @@ #include "TriangleMesh.hpp" #include "ClipperUtils.hpp" #include "Geometry.hpp" +#include "qhull/src/libqhullcpp/Qhull.h" +#include "qhull/src/libqhullcpp/QhullFacetList.h" +#include "qhull/src/libqhullcpp/QhullVertexSet.h" #include #include #include @@ -15,6 +18,8 @@ #include +#include + #if 0 #define DEBUG #define _DEBUG @@ -597,6 +602,134 @@ TriangleMesh::bounding_box() const return bb; } +BoundingBoxf3 TriangleMesh::transformed_bounding_box(const std::vector& matrix) const +{ + bool has_shared = (stl.v_shared != nullptr); + if (!has_shared) + stl_generate_shared_vertices(&stl); + + unsigned int vertices_count = (stl.stats.shared_vertices > 0) ? (unsigned int)stl.stats.shared_vertices : 3 * (unsigned int)stl.stats.number_of_facets; + + if (vertices_count == 0) + return BoundingBoxf3(); + + Eigen::MatrixXf src_vertices(3, vertices_count); + + if (stl.stats.shared_vertices > 0) + { + stl_vertex* vertex_ptr = stl.v_shared; + for (int i = 0; i < stl.stats.shared_vertices; ++i) + { + src_vertices(0, i) = vertex_ptr->x; + src_vertices(1, i) = vertex_ptr->y; + src_vertices(2, i) = vertex_ptr->z; + vertex_ptr += 1; + } + } + else + { + stl_facet* facet_ptr = stl.facet_start; + unsigned int v_id = 0; + while (facet_ptr < stl.facet_start + stl.stats.number_of_facets) + { + for (int i = 0; i < 3; ++i) + { + src_vertices(0, v_id) = facet_ptr->vertex[i].x; + src_vertices(1, v_id) = facet_ptr->vertex[i].y; + src_vertices(2, v_id) = facet_ptr->vertex[i].z; + } + facet_ptr += 1; + ++v_id; + } + } + + if (!has_shared && (stl.stats.shared_vertices > 0)) + stl_invalidate_shared_vertices(&stl); + + Eigen::Transform m; + ::memcpy((void*)m.data(), (const void*)matrix.data(), 16 * sizeof(float)); + + Eigen::MatrixXf dst_vertices(3, vertices_count); + dst_vertices = m * src_vertices.colwise().homogeneous(); + + float min_x = dst_vertices(0, 0); + float max_x = dst_vertices(0, 0); + float min_y = dst_vertices(1, 0); + float max_y = dst_vertices(1, 0); + float min_z = dst_vertices(2, 0); + float max_z = dst_vertices(2, 0); + + for (int i = 1; i < vertices_count; ++i) + { + min_x = std::min(min_x, dst_vertices(0, i)); + max_x = std::max(max_x, dst_vertices(0, i)); + min_y = std::min(min_y, dst_vertices(1, i)); + max_y = std::max(max_y, dst_vertices(1, i)); + min_z = std::min(min_z, dst_vertices(2, i)); + max_z = std::max(max_z, dst_vertices(2, i)); + } + + return BoundingBoxf3(Pointf3((coordf_t)min_x, (coordf_t)min_y, (coordf_t)min_z), Pointf3((coordf_t)max_x, (coordf_t)max_y, (coordf_t)max_z)); +} + +TriangleMesh TriangleMesh::convex_hull_3d() const +{ + // Helper struct for qhull: + struct PointForQHull{ + PointForQHull(float x_p, float y_p, float z_p) : x((realT)x_p), y((realT)y_p), z((realT)z_p) {} + realT x, y, z; + }; + std::vector src_vertices; + + // We will now fill the vector with input points for computation: + stl_facet* facet_ptr = stl.facet_start; + while (facet_ptr < stl.facet_start + stl.stats.number_of_facets) + { + for (int i = 0; i < 3; ++i) + { + const stl_vertex& v = facet_ptr->vertex[i]; + src_vertices.emplace_back(v.x, v.y, v.z); + } + + facet_ptr += 1; + } + + // The qhull call: + orgQhull::Qhull qhull; + qhull.disableOutputStream(); // we want qhull to be quiet + try + { + qhull.runQhull("", 3, (int)src_vertices.size(), (const realT*)(src_vertices.data()), "Qt"); + } + catch (...) + { + std::cout << "Unable to create convex hull" << std::endl; + return TriangleMesh(); + } + + // Let's collect results: + Pointf3s det_vertices; + std::vector facets; + auto facet_list = qhull.facetList().toStdVector(); + for (const orgQhull::QhullFacet& facet : facet_list) + { // iterate through facets + orgQhull::QhullVertexSet vertices = facet.vertices(); + for (int i = 0; i < 3; ++i) + { // iterate through facet's vertices + + orgQhull::QhullPoint p = vertices[i].point(); + const float* coords = p.coordinates(); + det_vertices.emplace_back(coords[0], coords[1], coords[2]); + } + unsigned int size = (unsigned int)det_vertices.size(); + facets.emplace_back(size - 3, size - 2, size - 1); + } + + TriangleMesh output_mesh(det_vertices, facets); + output_mesh.repair(); + return output_mesh; +} + void TriangleMesh::require_shared_vertices() { diff --git a/xs/src/libslic3r/TriangleMesh.hpp b/xs/src/libslic3r/TriangleMesh.hpp index c700784a5..6ab52efe2 100644 --- a/xs/src/libslic3r/TriangleMesh.hpp +++ b/xs/src/libslic3r/TriangleMesh.hpp @@ -55,6 +55,10 @@ public: ExPolygons horizontal_projection() const; Polygon convex_hull(); BoundingBoxf3 bounding_box() const; + // Returns the bbox of this TriangleMesh transformed by the given matrix + BoundingBoxf3 transformed_bounding_box(const std::vector& matrix) const; + // Returns the convex hull of this TriangleMesh + TriangleMesh convex_hull_3d() const; void reset_repair_stats(); bool needed_repair() const; size_t facets_count() const; @@ -66,7 +70,7 @@ public: // Count disconnected triangle patches. size_t number_of_patches() const; - stl_file stl; + mutable stl_file stl; bool repaired; private: diff --git a/xs/src/slic3r/GUI/3DScene.cpp b/xs/src/slic3r/GUI/3DScene.cpp index 3f01eb20c..0709271b8 100644 --- a/xs/src/slic3r/GUI/3DScene.cpp +++ b/xs/src/slic3r/GUI/3DScene.cpp @@ -202,7 +202,8 @@ const float GLVolume::SELECTED_OUTSIDE_COLOR[4] = { 0.19f, 0.58f, 1.0f, 1.0f }; GLVolume::GLVolume(float r, float g, float b, float a) : m_angle_z(0.0f) , m_scale_factor(1.0f) - , m_dirty(true) + , m_transformed_bounding_box_dirty(true) + , m_transformed_convex_hull_bounding_box_dirty(true) , composite_id(-1) , select_group_id(-1) , drag_group_id(-1) @@ -219,8 +220,6 @@ GLVolume::GLVolume(float r, float g, float b, float a) , tverts_range(0, size_t(-1)) , qverts_range(0, size_t(-1)) { - m_world_mat = std::vector(UNIT_MATRIX, std::end(UNIT_MATRIX)); - color[0] = r; color[1] = g; color[2] = b; @@ -264,45 +263,76 @@ const Pointf3& GLVolume::get_origin() const void GLVolume::set_origin(const Pointf3& origin) { - m_origin = origin; - m_dirty = true; + if (m_origin != origin) + { + m_origin = origin; + m_transformed_bounding_box_dirty = true; + m_transformed_convex_hull_bounding_box_dirty = true; + } } void GLVolume::set_angle_z(float angle_z) { - m_angle_z = angle_z; - m_dirty = true; + if (m_angle_z != angle_z) + { + m_angle_z = angle_z; + m_transformed_bounding_box_dirty = true; + m_transformed_convex_hull_bounding_box_dirty = true; + } } void GLVolume::set_scale_factor(float scale_factor) { - m_scale_factor = scale_factor; - m_dirty = true; + if (m_scale_factor != scale_factor) + { + m_scale_factor = scale_factor; + m_transformed_bounding_box_dirty = true; + m_transformed_convex_hull_bounding_box_dirty = true; + } } -const std::vector& GLVolume::world_matrix() const +void GLVolume::set_convex_hull(const TriangleMesh& convex_hull) { - if (m_dirty) - { - Eigen::Transform m = Eigen::Transform::Identity(); - m.translate(Eigen::Vector3f((float)m_origin.x, (float)m_origin.y, (float)m_origin.z)); - m.rotate(Eigen::AngleAxisf(m_angle_z, Eigen::Vector3f::UnitZ())); - m.scale(m_scale_factor); - ::memcpy((void*)m_world_mat.data(), (const void*)m.data(), 16 * sizeof(float)); - m_dirty = false; - } + m_convex_hull = convex_hull; +} - return m_world_mat; +std::vector GLVolume::world_matrix() const +{ + std::vector world_mat(UNIT_MATRIX, std::end(UNIT_MATRIX)); + Eigen::Transform m = Eigen::Transform::Identity(); + m.translate(Eigen::Vector3f((float)m_origin.x, (float)m_origin.y, (float)m_origin.z)); + m.rotate(Eigen::AngleAxisf(m_angle_z, Eigen::Vector3f::UnitZ())); + m.scale(m_scale_factor); + ::memcpy((void*)world_mat.data(), (const void*)m.data(), 16 * sizeof(float)); + return world_mat; } BoundingBoxf3 GLVolume::transformed_bounding_box() const { - if (m_dirty) + if (m_transformed_bounding_box_dirty) + { m_transformed_bounding_box = bounding_box.transformed(world_matrix()); + m_transformed_bounding_box_dirty = false; + } return m_transformed_bounding_box; } +BoundingBoxf3 GLVolume::transformed_convex_hull_bounding_box() const +{ + if (m_transformed_convex_hull_bounding_box_dirty) + { + if (m_convex_hull.stl.stats.number_of_facets > 0) + m_transformed_convex_hull_bounding_box = m_convex_hull.transformed_bounding_box(world_matrix()); + else + m_transformed_convex_hull_bounding_box = bounding_box.transformed(world_matrix()); + + m_transformed_convex_hull_bounding_box_dirty = false; + } + + return m_transformed_convex_hull_bounding_box; +} + void GLVolume::set_range(double min_z, double max_z) { this->qverts_range.first = 0; @@ -629,6 +659,7 @@ std::vector GLVolumeCollection::load_object( if (!model_volume->modifier) { + v.set_convex_hull(model_volume->get_convex_hull()); v.layer_height_texture = layer_height_texture; if (extruder_id != -1) v.extruder_id = extruder_id; @@ -716,6 +747,7 @@ int GLVolumeCollection::load_wipe_tower_preview( v.drag_group_id = obj_idx * 1000; v.is_wipe_tower = true; v.shader_outside_printer_detection_enabled = ! size_unknown; + v.set_convex_hull(mesh.convex_hull_3d()); return int(this->volumes.size() - 1); } @@ -803,7 +835,7 @@ bool GLVolumeCollection::check_outside_state(const DynamicPrintConfig* config, M { if ((volume != nullptr) && !volume->is_modifier) { - const BoundingBoxf3& bb = volume->transformed_bounding_box(); + const BoundingBoxf3& bb = volume->transformed_convex_hull_bounding_box(); bool contained = print_volume.contains(bb); all_contained &= contained; diff --git a/xs/src/slic3r/GUI/3DScene.hpp b/xs/src/slic3r/GUI/3DScene.hpp index a552b32a7..1265bc20d 100644 --- a/xs/src/slic3r/GUI/3DScene.hpp +++ b/xs/src/slic3r/GUI/3DScene.hpp @@ -260,12 +260,16 @@ private: float m_angle_z; // Scale factor of the volume to be rendered. float m_scale_factor; - // World matrix of the volume to be rendered. - std::vector m_world_mat; // Bounding box of this volume, in unscaled coordinates. mutable BoundingBoxf3 m_transformed_bounding_box; - // Whether or not is needed to recalculate the world matrix. - mutable bool m_dirty; + // Whether or not is needed to recalculate the transformed bounding box. + mutable bool m_transformed_bounding_box_dirty; + // Convex hull of the original mesh, if any. + TriangleMesh m_convex_hull; + // Bounding box of this volume, in unscaled coordinates. + mutable BoundingBoxf3 m_transformed_convex_hull_bounding_box; + // Whether or not is needed to recalculate the transformed convex hull bounding box. + mutable bool m_transformed_convex_hull_bounding_box_dirty; public: @@ -323,13 +327,15 @@ public: void set_origin(const Pointf3& origin); void set_angle_z(float angle_z); void set_scale_factor(float scale_factor); + void set_convex_hull(const TriangleMesh& convex_hull); int object_idx() const { return this->composite_id / 1000000; } int volume_idx() const { return (this->composite_id / 1000) % 1000; } int instance_idx() const { return this->composite_id % 1000; } - const std::vector& world_matrix() const; + std::vector world_matrix() const; BoundingBoxf3 transformed_bounding_box() const; + BoundingBoxf3 transformed_convex_hull_bounding_box() const; bool empty() const { return this->indexed_vertex_array.empty(); } bool indexed() const { return this->indexed_vertex_array.indexed(); } diff --git a/xs/src/slic3r/GUI/GLCanvas3D.cpp b/xs/src/slic3r/GUI/GLCanvas3D.cpp index ab4095e6f..92bde34ce 100644 --- a/xs/src/slic3r/GUI/GLCanvas3D.cpp +++ b/xs/src/slic3r/GUI/GLCanvas3D.cpp @@ -3243,7 +3243,7 @@ BoundingBoxf3 GLCanvas3D::_selected_volumes_bounding_box() const { for (const GLVolume* volume : selected_volumes) { - bb.merge(volume->transformed_bounding_box()); + bb.merge(volume->transformed_convex_hull_bounding_box()); } } diff --git a/xs/src/slic3r/GUI/GLGizmo.cpp b/xs/src/slic3r/GUI/GLGizmo.cpp index 47b01e8a2..7207022bd 100644 --- a/xs/src/slic3r/GUI/GLGizmo.cpp +++ b/xs/src/slic3r/GUI/GLGizmo.cpp @@ -189,7 +189,7 @@ GLGizmoRotate::GLGizmoRotate() , m_angle_z(0.0f) , m_center(Pointf(0.0, 0.0)) , m_radius(0.0f) - , m_keep_radius(false) + , m_keep_initial_values(false) { } @@ -229,7 +229,7 @@ bool GLGizmoRotate::on_init() void GLGizmoRotate::on_set_state() { - m_keep_radius = (m_state == On) ? false : true; + m_keep_initial_values = (m_state == On) ? false : true; } void GLGizmoRotate::on_update(const Pointf& mouse_pos) @@ -255,19 +255,19 @@ void GLGizmoRotate::on_update(const Pointf& mouse_pos) void GLGizmoRotate::on_refresh() { - m_keep_radius = false; + m_keep_initial_values = false; } void GLGizmoRotate::on_render(const BoundingBoxf3& box) const { ::glDisable(GL_DEPTH_TEST); - const Pointf3& size = box.size(); - m_center = box.center(); - if (!m_keep_radius) + if (!m_keep_initial_values) { + const Pointf3& size = box.size(); + m_center = box.center(); m_radius = Offset + ::sqrt(sqr(0.5f * size.x) + sqr(0.5f * size.y)); - m_keep_radius = true; + m_keep_initial_values = true; } ::glLineWidth(2.0f); diff --git a/xs/src/slic3r/GUI/GLGizmo.hpp b/xs/src/slic3r/GUI/GLGizmo.hpp index 506b3972e..839969090 100644 --- a/xs/src/slic3r/GUI/GLGizmo.hpp +++ b/xs/src/slic3r/GUI/GLGizmo.hpp @@ -101,7 +101,7 @@ class GLGizmoRotate : public GLGizmoBase mutable Pointf m_center; mutable float m_radius; - mutable bool m_keep_radius; + mutable bool m_keep_initial_values; public: GLGizmoRotate(); diff --git a/xs/xsp/GUI_3DScene.xsp b/xs/xsp/GUI_3DScene.xsp index 0e0a03f5e..1a0fc9b9f 100644 --- a/xs/xsp/GUI_3DScene.xsp +++ b/xs/xsp/GUI_3DScene.xsp @@ -65,7 +65,6 @@ %}; Clone bounding_box() const %code%{ RETVAL = THIS->bounding_box; %}; - Clone transformed_bounding_box() const; bool empty() const; bool indexed() const; -- cgit v1.2.3