WIP - Sequential print visualization using vertical slider in preview (missing travel moves)

src/libslic3r/Technologies.hpp

@@ -64,4 +64,12 @@
 
 #define ENABLE_CTRL_M_ON_WINDOWS (0 && ENABLE_2_3_0_ALPHA3)
 
+
+//===================
+// 2.3.0.alpha4 techs
+//===================
+#define ENABLE_2_3_0_ALPHA4 1
+
+#define ENABLE_SEQUENTIAL_VSLIDER (1 && ENABLE_GCODE_VIEWER && ENABLE_2_3_0_ALPHA4)
+
 #endif // _prusaslicer_technologies_h_

src/slic3r/GUI/GCodeViewer.cpp

@@ -300,8 +300,13 @@ void GCodeViewer::load(const GCodeProcessor::Result& gcode_result, const Print&
     reset();
 
     load_toolpaths(gcode_result);
+#if ENABLE_SEQUENTIAL_VSLIDER
+    if (m_layers.empty())
+        return;
+#else
     if (m_layers_zs.empty())
         return;
+#endif // ENABLE_SEQUENTIAL_VSLIDER
 
     m_settings_ids = gcode_result.settings_ids;
 
@@ -428,7 +433,12 @@ void GCodeViewer::reset()
     m_extrusions.reset_role_visibility_flags();
     m_extrusions.reset_ranges();
     m_shells.volumes.clear();
+#if ENABLE_SEQUENTIAL_VSLIDER
+    m_layers.reset();
+    m_layers_z_range_2 = { 0, 0 };
+#else
     m_layers_zs = std::vector<double>();
+#endif // ENABLE_SEQUENTIAL_VSLIDER
     m_layers_z_range = { 0.0, 0.0 };
     m_roles = std::vector<ExtrusionRole>();
     m_time_statistics.reset();
@@ -599,6 +609,16 @@ void GCodeViewer::set_options_visibility_from_flags(unsigned int flags)
     enable_legend(is_flag_set(static_cast<unsigned int>(Preview::OptionType::Legend)));
 }
 
+#if ENABLE_SEQUENTIAL_VSLIDER
+void GCodeViewer::set_layers_z_range(const std::array<unsigned int, 2>& layers_z_range)
+{
+    bool keep_sequential_current_first = layers_z_range[0] >= m_layers_z_range_2[0];
+    bool keep_sequential_current_last = layers_z_range[1] <= m_layers_z_range_2[1];
+    m_layers_z_range_2 = layers_z_range;
+    refresh_render_paths(keep_sequential_current_first, keep_sequential_current_last);
+    wxGetApp().plater()->update_preview_moves_slider();
+}
+#else
 void GCodeViewer::set_layers_z_range(const std::array<double, 2>& layers_z_range)
 {
     bool keep_sequential_current_first = layers_z_range[0] >= m_layers_z_range[0];
@@ -607,6 +627,7 @@ void GCodeViewer::set_layers_z_range(const std::array<double, 2>& layers_z_range
     refresh_render_paths(keep_sequential_current_first, keep_sequential_current_last);
     wxGetApp().plater()->update_preview_moves_slider();
 }
+#endif // ENABLE_SEQUENTIAL_VSLIDER
 
 void GCodeViewer::export_toolpaths_to_obj(const char* filename) const
 {
@@ -1531,11 +1552,39 @@ void GCodeViewer::load_toolpaths(const GCodeProcessor::Result& gcode_result)
     // dismiss indices data, no more needed
     std::vector<MultiIndexBuffer>().swap(indices);
 
+#if ENABLE_SEQUENTIAL_VSLIDER
+    // layers zs / roles / extruder ids / cp color ids -> extract from result
+    std::vector<std::pair<double, unsigned int>> averages;    
+    for (size_t i = 0; i < m_moves_count; ++i) {
+        const GCodeProcessor::MoveVertex& move = gcode_result.moves[i];
+        if (move.type == EMoveType::Extrude) {
+            // layers zs
+            const double* const last_z = m_layers.empty() ? nullptr : &m_layers.get_zs().back();
+            double z = static_cast<double>(move.position[2]);
+            if (last_z == nullptr || z < *last_z - EPSILON || *last_z + EPSILON < z)
+                m_layers.append(z, { i - 1, i });
+            else
+                m_layers.get_endpoints().back().last = i;
+            // extruder ids
+            m_extruder_ids.emplace_back(move.extruder_id);
+            // roles
+            if (i > 0)
+                m_roles.emplace_back(move.extrusion_role);
+        }
+    }
+
+    // set layers z range
+    if (!m_layers.empty()) {
+        m_layers_z_range = { m_layers.get_zs().front(), m_layers.get_zs().back() };
+        m_layers_z_range_2 = { 0, static_cast<unsigned int>(m_layers.size() - 1) };
+    }
+#else
     // layers zs -> extract from result
     for (const Path& path : m_buffers[buffer_id(EMoveType::Extrude)].paths) {
         m_layers_zs.emplace_back(static_cast<double>(path.first.position[2]));
 //        m_layers_zs.emplace_back(static_cast<double>(path.last.position[2]));
     }
+
     // roles / extruder ids / cp color ids -> extract from result
     for (size_t i = 0; i < m_moves_count; ++i) {
         const GCodeProcessor::MoveVertex& move = gcode_result.moves[i];
@@ -1544,6 +1593,7 @@ void GCodeViewer::load_toolpaths(const GCodeProcessor::Result& gcode_result)
             m_roles.emplace_back(move.extrusion_role);
     }
 
+
     // layers zs -> replace intervals of layers with similar top positions with their average value.
     std::sort(m_layers_zs.begin(), m_layers_zs.end());
     int n = int(m_layers_zs.size());
@@ -1560,9 +1610,11 @@ void GCodeViewer::load_toolpaths(const GCodeProcessor::Result& gcode_result)
         m_layers_zs.shrink_to_fit();
     }
 
+
     // set layers z range
     if (!m_layers_zs.empty())
         m_layers_z_range = { m_layers_zs.front(), m_layers_zs.back() };
+#endif // ENABLE_SEQUENTIAL_VSLIDER
 
     // roles -> remove duplicates
     std::sort(m_roles.begin(), m_roles.end());
@@ -1671,9 +1723,19 @@ void GCodeViewer::refresh_render_paths(bool keep_sequential_current_first, bool
                 Travel_Colors[0] /* Move */);
     };
 
+#if ENABLE_SEQUENTIAL_VSLIDER
+    auto is_in_layers_range = [this](const Path& path, size_t min_id, size_t max_id) {
+        auto in_layers_range = [this, min_id, max_id](size_t id) {
+            return m_layers.get_endpoints_at(min_id).first <= id && id <= m_layers.get_endpoints_at(max_id).last;
+        };
+
+        return in_layers_range(path.first.s_id) || in_layers_range(path.last.s_id);
+    };
+#endif // ENABLE_SEQUENTIAL_VSLIDER
+
     auto is_in_z_range = [](const Path& path, double min_z, double max_z) {
         auto in_z_range = [min_z, max_z](double z) {
-            return z > min_z - EPSILON && z < max_z + EPSILON;
+            return min_z - EPSILON < z && z < max_z + EPSILON;
         };
 
         return in_z_range(path.first.position[2]) || in_z_range(path.last.position[2]);
@@ -1727,8 +1789,13 @@ void GCodeViewer::refresh_render_paths(bool keep_sequential_current_first, bool
                 if (!is_travel_in_z_range(i, m_layers_z_range[0], m_layers_z_range[1]))
                     continue;
             }
+#if ENABLE_SEQUENTIAL_VSLIDER
+            else if (!is_in_layers_range(path, m_layers_z_range_2[0], m_layers_z_range_2[1]))
+                continue;
+#else
             else if (!is_in_z_range(path, m_layers_z_range[0], m_layers_z_range[1]))
                 continue;
+#endif // ENABLE_SEQUENTIAL_VSLIDER
 
             if (path.type == EMoveType::Extrude && !is_visible(path))
                 continue;
@@ -1746,10 +1813,17 @@ void GCodeViewer::refresh_render_paths(bool keep_sequential_current_first, bool
                         top_layer_endpoints.last = std::max(top_layer_endpoints.last, path.last.s_id);
                     }
                 }
+#if ENABLE_SEQUENTIAL_VSLIDER
+                else if (is_in_layers_range(path, m_layers_z_range_2[1], m_layers_z_range_2[1])) {
+                    top_layer_endpoints.first = std::min(top_layer_endpoints.first, path.first.s_id);
+                    top_layer_endpoints.last = std::max(top_layer_endpoints.last, path.last.s_id);
+                }
+#else
                 else if (is_in_z_range(path, m_layers_z_range[1], m_layers_z_range[1])) {
                     top_layer_endpoints.first = std::min(top_layer_endpoints.first, path.first.s_id);
                     top_layer_endpoints.last = std::max(top_layer_endpoints.last, path.last.s_id);
                 }
+#endif // ENABLE_SEQUENTIAL_VSLIDER
             }
         }
     }
@@ -1803,7 +1877,13 @@ void GCodeViewer::refresh_render_paths(bool keep_sequential_current_first, bool
         switch (path.type)
         {
         case EMoveType::Extrude: {
+#if ENABLE_SEQUENTIAL_VSLIDER
+            if (!top_layer_only ||
+                m_sequential_view.current.last == global_endpoints.last ||
+                is_in_layers_range(path, m_layers_z_range_2[1], m_layers_z_range_2[1]))
+#else
             if (!top_layer_only || m_sequential_view.current.last == global_endpoints.last || is_in_z_range(path, m_layers_z_range[1], m_layers_z_range[1]))
+#endif // ENABLE_SEQUENTIAL_VSLIDER
                 color = extrusion_color(path);
             else
                 color = { 0.25f, 0.25f, 0.25f };
@@ -2197,13 +2277,23 @@ void GCodeViewer::render_legend() const
             if (item.type != ColorChange)
                 continue;
 
+#if ENABLE_SEQUENTIAL_VSLIDER
+            const std::vector<double> zs = m_layers.get_zs();
+            auto lower_b = std::lower_bound(zs.begin(), zs.end(), item.print_z - Slic3r::DoubleSlider::epsilon());
+            if (lower_b == zs.end())
+                continue;
+#else
             auto lower_b = std::lower_bound(m_layers_zs.begin(), m_layers_zs.end(), item.print_z - Slic3r::DoubleSlider::epsilon());
-
             if (lower_b == m_layers_zs.end())
                 continue;
+#endif // ENABLE_SEQUENTIAL_VSLIDER
 
             double current_z = *lower_b;
+#if ENABLE_SEQUENTIAL_VSLIDER
+            double previous_z = (lower_b == zs.begin()) ? 0.0 : *(--lower_b);
+#else
             double previous_z = lower_b == m_layers_zs.begin() ? 0.0 : *(--lower_b);
+#endif // ENABLE_SEQUENTIAL_VSLIDER
 
             // to avoid duplicate values, check adding values
             if (ret.empty() || !(ret.back().second.first == previous_z && ret.back().second.second == current_z))
@@ -2794,10 +2884,18 @@ void GCodeViewer::log_memory_used(const std::string& label, long long additional
                 render_paths_size += SLIC3R_STDVEC_MEMSIZE(path.offsets, size_t);
             }
         }
+#if ENABLE_SEQUENTIAL_VSLIDER
+        long long layers_size = SLIC3R_STDVEC_MEMSIZE(m_layers.get_zs(), double);
+        layers_size += SLIC3R_STDVEC_MEMSIZE(m_layers.get_endpoints(), Layers::Endpoints);
+        BOOST_LOG_TRIVIAL(trace) << label
+            << format_memsize_MB(additional + paths_size + render_paths_size + layers_size)
+            << log_memory_info();
+#else
         long long layers_zs_size = SLIC3R_STDVEC_MEMSIZE(m_layers_zs, double);
         BOOST_LOG_TRIVIAL(trace) << label
             << format_memsize_MB(additional + paths_size + render_paths_size + layers_zs_size)
             << log_memory_info();
+#endif // ENABLE_SEQUENTIAL_VSLIDER
     }
 }
 

src/slic3r/GUI/GCodeViewer.hpp

@@ -272,6 +272,42 @@ class GCodeViewer
         void reset_ranges() { ranges.reset(); }
     };
 
+#if ENABLE_SEQUENTIAL_VSLIDER
+    class Layers
+    {
+    public:
+        struct Endpoints
+        {
+            size_t first{ 0 };
+            size_t last{ 0 };
+        };
+
+    private:
+        std::vector<double> m_zs;
+        std::vector<Endpoints> m_endpoints;
+
+    public:
+        void append(double z, Endpoints endpoints)
+        {
+            m_zs.emplace_back(z);
+            m_endpoints.emplace_back(endpoints);
+        }
+
+        void reset()
+        {
+            m_zs = std::vector<double>();
+            m_endpoints = std::vector<Endpoints>();
+        }
+
+        size_t size() const { return m_zs.size(); }
+        bool empty() const { return m_zs.empty(); }
+        const std::vector<double>& get_zs() const { return m_zs; }
+        const std::vector<Endpoints>& get_endpoints() const { return m_endpoints; }
+        std::vector<Endpoints>& get_endpoints() { return m_endpoints; }
+        Endpoints get_endpoints_at(unsigned int id) const { return (id < m_endpoints.size()) ? m_endpoints[id] : Endpoints(); }
+    };
+#endif // ENABLE_SEQUENTIAL_VSLIDER
+
 #if ENABLE_GCODE_VIEWER_STATISTICS
     struct Statistics
     {
@@ -397,7 +433,12 @@ private:
     // bounding box of toolpaths + marker tools
     BoundingBoxf3 m_max_bounding_box;
     std::vector<Color> m_tool_colors;
+#if ENABLE_SEQUENTIAL_VSLIDER
+    Layers m_layers;
+    std::array<unsigned int, 2> m_layers_z_range_2;
+#else
     std::vector<double> m_layers_zs;
+#endif // ENABLE_SEQUENTIAL_VSLIDER
     std::array<double, 2> m_layers_z_range;
     std::vector<ExtrusionRole> m_roles;
     size_t m_extruders_count;
@@ -431,7 +472,11 @@ public:
 
     const BoundingBoxf3& get_paths_bounding_box() const { return m_paths_bounding_box; }
     const BoundingBoxf3& get_max_bounding_box() const { return m_max_bounding_box; }
+#if ENABLE_SEQUENTIAL_VSLIDER
+    const std::vector<double>& get_layers_zs() const { return m_layers.get_zs(); };
+#else
     const std::vector<double>& get_layers_zs() const { return m_layers_zs; };
+#endif // ENABLE_SEQUENTIAL_VSLIDER
 
     const SequentialView& get_sequential_view() const { return m_sequential_view; }
     void update_sequential_view_current(unsigned int first, unsigned int last);
@@ -450,7 +495,11 @@ public:
     void set_toolpath_role_visibility_flags(unsigned int flags) { m_extrusions.role_visibility_flags = flags; }
     unsigned int get_options_visibility_flags() const;
     void set_options_visibility_from_flags(unsigned int flags);
+#if ENABLE_SEQUENTIAL_VSLIDER
+    void set_layers_z_range(const std::array<unsigned int, 2>& layers_z_range);
+#else
     void set_layers_z_range(const std::array<double, 2>& layers_z_range);
+#endif // ENABLE_SEQUENTIAL_VSLIDER
 
     bool is_legend_enabled() const { return m_legend_enabled; }
     void enable_legend(bool enable) { m_legend_enabled = enable; }

src/slic3r/GUI/GLCanvas3D.cpp

@@ -2182,9 +2182,19 @@ void GLCanvas3D::set_toolpath_view_type(GCodeViewer::EViewType type)
 void GLCanvas3D::set_toolpaths_z_range(const std::array<double, 2>& range)
 {
     m_volumes.set_range(range[0] - 1e-6, range[1] + 1e-6);
+#if !ENABLE_SEQUENTIAL_VSLIDER
+    if (m_gcode_viewer.has_data())
+        m_gcode_viewer.set_layers_z_range(range);
+#endif // !ENABLE_SEQUENTIAL_VSLIDER
+}
+
+#if ENABLE_SEQUENTIAL_VSLIDER
+void GLCanvas3D::set_toolpaths_z_range_2(const std::array<unsigned int, 2>& range)
+{
     if (m_gcode_viewer.has_data())
         m_gcode_viewer.set_layers_z_range(range);
 }
+#endif // ENABLE_SEQUENTIAL_VSLIDER
 #else
 std::vector<double> GLCanvas3D::get_current_print_zs(bool active_only) const
 {

src/slic3r/GUI/GLCanvas3D.hpp

@@ -652,6 +652,9 @@ public:
     void set_toolpath_role_visibility_flags(unsigned int flags);
     void set_toolpath_view_type(GCodeViewer::EViewType type);
     void set_toolpaths_z_range(const std::array<double, 2>& range);
+#if ENABLE_SEQUENTIAL_VSLIDER
+    void set_toolpaths_z_range_2(const std::array<unsigned int, 2>& range);
+#endif // ENABLE_SEQUENTIAL_VSLIDER
 #else
     std::vector<double> get_current_print_zs(bool active_only) const;
 #endif // ENABLE_GCODE_VIEWER

src/slic3r/GUI/GUI_Preview.cpp

@@ -1427,13 +1427,14 @@ void Preview::on_layers_slider_scroll_changed(wxCommandEvent& event)
 void Preview::on_sliders_scroll_changed(wxCommandEvent& event)
 #endif // ENABLE_GCODE_VIEWER
 {
-    if (IsShown())
+    if (IsShown()) {
-    {
         PrinterTechnology tech = m_process->current_printer_technology();
-        if (tech == ptFFF)
+        if (tech == ptFFF) {
-        {
 #if ENABLE_GCODE_VIEWER
             m_canvas->set_toolpaths_z_range({ m_layers_slider->GetLowerValueD(), m_layers_slider->GetHigherValueD() });
+#if ENABLE_SEQUENTIAL_VSLIDER
+            m_canvas->set_toolpaths_z_range_2({ static_cast<unsigned int>(m_layers_slider->GetLowerValue()), static_cast<unsigned int>(m_layers_slider->GetHigherValue()) });
+#endif // ENABLE_SEQUENTIAL_VSLIDER
             m_canvas->set_as_dirty();
 #else
             m_canvas->set_toolpaths_range(m_slider->GetLowerValueD() - 1e-6, m_slider->GetHigherValueD() + 1e-6);
@@ -1441,8 +1442,7 @@ void Preview::on_sliders_scroll_changed(wxCommandEvent& event)
             m_canvas->set_use_clipping_planes(false);
 #endif // ENABLE_GCODE_VIEWER
         }
-        else if (tech == ptSLA)
+        else if (tech == ptSLA) {
-        {
 #if ENABLE_GCODE_VIEWER
             m_canvas->set_clipping_plane(0, ClippingPlane(Vec3d::UnitZ(), -m_layers_slider->GetLowerValueD()));
             m_canvas->set_clipping_plane(1, ClippingPlane(-Vec3d::UnitZ(), m_layers_slider->GetHigherValueD()));