From ac1459e3385a78bcda51c0f707cf415f2de5f93e Mon Sep 17 00:00:00 2001 From: "zhou.xu" Date: Tue, 27 Feb 2024 19:25:33 +0800 Subject: [PATCH] NEW: upgrade Measure class SurfaceFeature is global,Measuring is local Jira: STUDIO-6166 Change-Id: I62dc58c51f0ac5d9c587e2debe3d774f02a3158a --- src/libslic3r/Measure.cpp | 94 +++++++++++++++++++++++++++++++-------- src/libslic3r/Measure.hpp | 34 ++++++++++++-- 2 files changed, 107 insertions(+), 21 deletions(-) diff --git a/src/libslic3r/Measure.cpp b/src/libslic3r/Measure.cpp index 8a4a5ce72..d50156ed2 100644 --- a/src/libslic3r/Measure.cpp +++ b/src/libslic3r/Measure.cpp @@ -73,10 +73,12 @@ public: bool features_extracted = false; }; - std::optional get_feature(size_t face_idx, const Vec3d& point); + std::optional get_feature(size_t face_idx, const Vec3d& point, const Transform3d &world_tran); int get_num_of_planes() const; const std::vector& get_plane_triangle_indices(int idx) const; + std::vector* get_plane_tri_indices(int idx); const std::vector& get_plane_features(unsigned int plane_id); + std::vector* get_plane_features_pointer(unsigned int plane_id); const indexed_triangle_set& get_its() const; private: @@ -504,7 +506,7 @@ void MeasuringImpl::extract_features(int plane_idx) plane.features_extracted = true; } -std::optional MeasuringImpl::get_feature(size_t face_idx, const Vec3d& point) +std::optional MeasuringImpl::get_feature(size_t face_idx, const Vec3d& point, const Transform3d &world_tran) { if (face_idx >= m_face_to_plane.size()) return std::optional(); @@ -544,18 +546,33 @@ std::optional MeasuringImpl::get_feature(size_t face_idx, const const auto& [sp, ep] = f.get_edge(); double len_sq = (ep-sp).squaredNorm(); double limit_sq = std::max(0.025*0.025, std::min(0.5*0.5, 0.1 * 0.1 * len_sq)); - - if ((point-sp).squaredNorm() < limit_sq) - return std::make_optional(SurfaceFeature(sp)); - if ((point-ep).squaredNorm() < limit_sq) - return std::make_optional(SurfaceFeature(ep)); + if ((point - sp).squaredNorm() < limit_sq) { + SurfaceFeature local_f(sp); + local_f.origin_surface_feature = std::make_shared(local_f); + local_f.translate(world_tran); + return std::make_optional(local_f); + } + + if ((point - ep).squaredNorm() < limit_sq) { + SurfaceFeature local_f(ep); + local_f.origin_surface_feature = std::make_shared(local_f); + local_f.translate(world_tran); + return std::make_optional(local_f); + } } - return std::make_optional(f); + SurfaceFeature f_tran(f); + f_tran.origin_surface_feature = std::make_shared(f); + f_tran.translate(world_tran); + return std::make_optional(f_tran); } // Nothing detected, return the plane as a whole. assert(plane.surface_features.back().get_type() == SurfaceFeatureType::Plane); - return std::make_optional(plane.surface_features.back()); + auto cur_plane = const_cast(&plane); + SurfaceFeature f_tran(cur_plane->surface_features.back()); + f_tran.origin_surface_feature = std::make_shared(cur_plane->surface_features.back()); + f_tran.translate(world_tran); + return std::make_optional(f_tran); } @@ -575,6 +592,12 @@ const std::vector& MeasuringImpl::get_plane_triangle_indices(int idx) const return m_planes[idx].facets; } +std::vector* MeasuringImpl::get_plane_tri_indices(int idx) +{ + assert(idx >= 0 && idx < int(m_planes.size())); + return &m_planes[idx].facets; +} + const std::vector& MeasuringImpl::get_plane_features(unsigned int plane_id) { assert(plane_id < m_planes.size()); @@ -583,6 +606,13 @@ const std::vector& MeasuringImpl::get_plane_features(unsigned in return m_planes[plane_id].surface_features; } +std::vector* MeasuringImpl::get_plane_features_pointer(unsigned int plane_id) { + assert(plane_id < m_planes.size()); + if (!m_planes[plane_id].features_extracted) + extract_features(plane_id); + return &m_planes[plane_id].surface_features; +} + const indexed_triangle_set& MeasuringImpl::get_its() const { return this->m_its; @@ -596,9 +626,8 @@ Measuring::~Measuring() {} -std::optional Measuring::get_feature(size_t face_idx, const Vec3d& point) const -{ - return priv->get_feature(face_idx, point); +std::optional Measuring::get_feature(size_t face_idx, const Vec3d &point, const Transform3d &world_tran) const { + return priv->get_feature(face_idx, point,world_tran); } @@ -778,7 +807,7 @@ static AngleAndEdges angle_plane_plane(const std::tuple& p1, return ret; } -MeasurementResult get_measurement(const SurfaceFeature& a, const SurfaceFeature& b, const Measuring* measuring) +MeasurementResult get_measurement(const SurfaceFeature& a, const SurfaceFeature& b) { assert(a.get_type() != SurfaceFeatureType::Undef && b.get_type() != SurfaceFeatureType::Undef); @@ -920,9 +949,9 @@ MeasurementResult get_measurement(const SurfaceFeature& a, const SurfaceFeature& result.distance_infinite = std::make_optional(DistAndPoints{ it->dist, it->from, it->to }); } else { - const std::vector& plane_features = measuring->get_plane_features(idx); + std::vector* plane_features = f2.world_plane_features; std::vector distances; - for (const SurfaceFeature& sf : plane_features) { + for (const SurfaceFeature& sf : *plane_features) { if (sf.get_type() == SurfaceFeatureType::Edge) { const auto m = get_measurement(sf, f1); if (!m.distance_infinite.has_value()) { @@ -1174,9 +1203,9 @@ MeasurementResult get_measurement(const SurfaceFeature& a, const SurfaceFeature& const bool coplanar = are_parallel(normal1, normal2) && Eigen::Hyperplane(normal1, center).absDistance(origin2) < EPSILON; if (!coplanar) { - const std::vector& plane_features = measuring->get_plane_features(idx2); + std::vector* plane_features = f2.world_plane_features; std::vector distances; - for (const SurfaceFeature& sf : plane_features) { + for (const SurfaceFeature& sf : *plane_features) { if (sf.get_type() == SurfaceFeatureType::Edge) { const auto m = get_measurement(sf, f1); if (!m.distance_infinite.has_value()) { @@ -1243,5 +1272,34 @@ void SurfaceFeature::translate(const Vec3d& displacement) { } } -}} // namespace Slic3r +void SurfaceFeature::translate(const Transform3d &tran) +{ + switch (get_type()) { + case Measure::SurfaceFeatureType::Point: { + m_pt1 = tran * m_pt1; + break; + } + case Measure::SurfaceFeatureType::Edge: { + m_pt1 = tran * m_pt1; + m_pt2 = tran * m_pt2; + if (m_pt3.has_value()) { // extra_point() + m_pt3 = tran * *m_pt3; + } + break; + } + case Measure::SurfaceFeatureType::Plane: { + // m_pt1 is normal; + m_pt2 = tran * m_pt2; + break; + } + case Measure::SurfaceFeatureType::Circle: { + m_pt1 = tran * m_pt1; + // m_pt2 is normal; + break; + } + default: break; + } +} + }//namespace Measure +} // namespace Slic3r diff --git a/src/libslic3r/Measure.hpp b/src/libslic3r/Measure.hpp index 823d2c757..af3a61a8a 100644 --- a/src/libslic3r/Measure.hpp +++ b/src/libslic3r/Measure.hpp @@ -30,10 +30,27 @@ public: SurfaceFeature(SurfaceFeatureType type, const Vec3d& pt1, const Vec3d& pt2, std::optional pt3 = std::nullopt, double value = 0.0) : m_type(type), m_pt1(pt1), m_pt2(pt2), m_pt3(pt3), m_value(value) {} - explicit SurfaceFeature(const Vec3d& pt) + SurfaceFeature(const Vec3d& pt) : m_type{SurfaceFeatureType::Point}, m_pt1{pt} {} + SurfaceFeature(const SurfaceFeature& sf){ + this->clone(sf); + } + + void clone(const SurfaceFeature &sf) + { + m_type = sf.get_type(); + m_pt1 = sf.get_pt1(); + m_pt2 = sf.get_pt2(); + m_pt3 = sf.get_pt3(); + m_value = sf.get_value(); + mesh = sf.mesh; + plane_indices = sf.plane_indices; + world_tran = sf.world_tran; + world_plane_features = sf.world_plane_features; + } void translate(const Vec3d& displacement); + void translate(const Transform3d& tran); // Get type of this feature. SurfaceFeatureType get_type() const { return m_type; } @@ -74,6 +91,17 @@ public: return !operator == (other); } + indexed_triangle_set* mesh{nullptr}; + std::vector* plane_indices{nullptr}; + Transform3d world_tran; + std::vector* world_plane_features{nullptr}; + std::shared_ptr origin_surface_feature{nullptr}; + + Vec3d get_pt1() const{ return m_pt1; } + Vec3d get_pt2() const { return m_pt2; } + const std::optional& get_pt3() const { return m_pt3; } + double get_value() const { return m_value; } + private: SurfaceFeatureType m_type{ SurfaceFeatureType::Undef }; Vec3d m_pt1{ Vec3d::Zero() }; @@ -96,7 +124,7 @@ public: // Given a face_idx where the mouse cursor points, return a feature that // should be highlighted (if any). - std::optional get_feature(size_t face_idx, const Vec3d& point) const; + std::optional get_feature(size_t face_idx, const Vec3d& point, const Transform3d & world_tran) const; // Return total number of planes. int get_num_of_planes() const; @@ -151,7 +179,7 @@ struct MeasurementResult { }; // Returns distance/angle between two SurfaceFeatures. -MeasurementResult get_measurement(const SurfaceFeature& a, const SurfaceFeature& b, const Measuring* measuring = nullptr); +MeasurementResult get_measurement(const SurfaceFeature& a, const SurfaceFeature& b); inline Vec3d edge_direction(const Vec3d& from, const Vec3d& to) { return (to - from).normalized(); } inline Vec3d edge_direction(const std::pair& e) { return edge_direction(e.first, e.second); }