wip

src/slic3r/CMakeLists.txt

@@ -278,7 +278,8 @@ set(SLIC3R_GUI_SOURCES
     GUI/wxExtensions.cpp
     GUI/wxExtensions.hpp
     GUI/WipeTowerDialog.cpp
-    GUI/WipeTowerDialog.hpp
+    GUI/RammingChart.cpp
+    GUI/RammingChart.hpp
     GUI/RemovableDriveManager.cpp
     GUI/RemovableDriveManager.hpp
     GUI/SendSystemInfoDialog.cpp

src/slic3r/GUI/ConfigManipulation.cpp

@@ -645,6 +645,12 @@ void ConfigManipulation::toggle_print_fff_options(DynamicPrintConfig *config, co
     bool have_ooze_prevention = config->opt_bool("ooze_prevention");
     toggle_field("standby_temperature_delta", have_ooze_prevention);
 
+    // Orca todo: enable/disable wipe tower parameters
+    // for (auto el :
+    //      {"wipe_tower_x", "wipe_tower_y", "wipe_tower_width", "wipe_tower_rotation_angle", "wipe_tower_brim_width", "wipe_tower_cone_angle",
+    //       "wipe_tower_extra_spacing", "wipe_tower_bridging", "wipe_tower_no_sparse_layers", "single_extruder_multi_material_priming"})
+    //     toggle_field(el, have_wipe_tower);
+
     bool have_prime_tower = config->opt_bool("enable_prime_tower");
     for (auto el : { "prime_tower_width", "prime_volume", "prime_tower_brim_width"})
         toggle_line(el, have_prime_tower);
@@ -692,7 +698,6 @@ void ConfigManipulation::toggle_print_fff_options(DynamicPrintConfig *config, co
     toggle_line("exclude_object", gcflavor == gcfKlipper);
 
     toggle_line("min_width_top_surface",config->opt_bool("only_one_wall_top"));
-
 }
 
 void ConfigManipulation::update_print_sla_config(DynamicPrintConfig* config, const bool is_global_config/* = false*/)

src/slic3r/GUI/Plater.cpp

@@ -2328,7 +2328,8 @@ Plater::priv::priv(Plater *q, MainFrame *main_frame)
         "layer_height", "initial_layer_print_height", "min_layer_height", "max_layer_height",
         "brim_width", "wall_loops", "wall_filament", "sparse_infill_density", "sparse_infill_filament", "top_shell_layers",
         "enable_support", "support_filament", "support_interface_filament",
-        "support_top_z_distance", "support_bottom_z_distance", "raft_layers"
+        "support_top_z_distance", "support_bottom_z_distance", "raft_layers",
+        "wipe_tower_rotation_angle", "wipe_tower_cone_angle", "wipe_tower_extra_spacing", "wipe_tower_extruder",
         }))
     , sidebar(new Sidebar(q))
     , notification_manager(std::make_unique<NotificationManager>(q))

src/slic3r/GUI/RammingChart.cpp

@@ -0,0 +1,292 @@
+#include <algorithm>
+#include <wx/dcbuffer.h>
+
+#include "RammingChart.hpp"
+#include "GUI.hpp"
+#include "GUI_App.hpp"
+#include "I18N.hpp"
+
+wxDEFINE_EVENT(EVT_WIPE_TOWER_CHART_CHANGED, wxCommandEvent);
+
+
+void Chart::draw() {
+    wxAutoBufferedPaintDC dc(this); // unbuffered DC caused flickering on win
+
+    dc.SetBrush(GetBackgroundColour());
+    dc.SetPen(GetBackgroundColour());
+    dc.DrawRectangle(GetClientRect());  // otherwise the background would end up black on windows
+
+#ifdef _WIN32
+    dc.SetPen(wxPen(GetForegroundColour()));
+    dc.SetBrush(wxBrush(Slic3r::GUI::wxGetApp().get_highlight_default_clr()));
+#else
+    dc.SetPen(*wxBLACK_PEN);
+    dc.SetBrush(*wxWHITE_BRUSH);
+#endif
+    dc.DrawRectangle(m_rect);
+    
+    if (visible_area.m_width < 0.499) {
+        dc.DrawText(_(L("NO RAMMING AT ALL")),wxPoint(m_rect.GetLeft()+m_rect.GetWidth()/2-legend_side,m_rect.GetBottom()-m_rect.GetHeight()/2));
+        return;
+    }
+    
+    
+    if (!m_line_to_draw.empty()) {
+        for (unsigned int i=0;i<m_line_to_draw.size()-2;++i) {
+            int color = 510*((m_rect.GetBottom()-(m_line_to_draw)[i])/double(m_rect.GetHeight()));
+            dc.SetPen( wxPen( wxColor(std::min(255,color),255-std::max(color-255,0),0), 1 ) );
+            dc.DrawLine(m_rect.GetLeft()+1+i,(m_line_to_draw)[i],m_rect.GetLeft()+1+i,m_rect.GetBottom());        
+        }
+#ifdef _WIN32
+        dc.SetPen(wxPen(GetForegroundColour()));
+#else
+        dc.SetPen( wxPen( wxColor(0,0,0), 1 ) );
+#endif
+        for (unsigned int i=0;i<m_line_to_draw.size()-2;++i) {
+            if (splines)
+                dc.DrawLine(m_rect.GetLeft()+i,(m_line_to_draw)[i],m_rect.GetLeft()+i+1,(m_line_to_draw)[i+1]);
+            else {
+                dc.DrawLine(m_rect.GetLeft()+i,(m_line_to_draw)[i],m_rect.GetLeft()+i+1,(m_line_to_draw)[i]);
+                dc.DrawLine(m_rect.GetLeft()+i+1,(m_line_to_draw)[i],m_rect.GetLeft()+i+1,(m_line_to_draw)[i+1]);
+            }
+        }
+    }
+    
+    // draw draggable buttons
+    dc.SetBrush(*wxBLUE_BRUSH);
+#ifdef _WIN32
+        dc.SetPen(wxPen(GetForegroundColour()));
+#else
+        dc.SetPen( wxPen( wxColor(0,0,0), 1 ) );
+#endif
+    for (auto& button : m_buttons)
+        //dc.DrawRectangle(math_to_screen(button.get_pos())-wxPoint(side/2.,side/2.), wxSize(side,side));
+        dc.DrawCircle(math_to_screen(button.get_pos()),side/2.);
+        //dc.DrawRectangle(math_to_screen(button.get_pos()-wxPoint2DDouble(0.125,0))-wxPoint(0,5),wxSize(50,10));
+
+    // draw x-axis:
+    float last_mark = -10000;
+    for (float math_x=int(visible_area.m_x*10)/10 ; math_x < (visible_area.m_x+visible_area.m_width) ; math_x+=0.1f) {
+        int x = math_to_screen(wxPoint2DDouble(math_x,visible_area.m_y)).x;
+        int y = m_rect.GetBottom();
+        if (x-last_mark < legend_side) continue;
+        dc.DrawLine(x,y+3,x,y-3);
+        dc.DrawText(wxString().Format(wxT("%.1f"), math_x),wxPoint(x-scale_unit,y+0.5*scale_unit));
+        last_mark = x;
+    }
+    
+    // draw y-axis:
+    last_mark=10000;
+    for (int math_y=visible_area.m_y ; math_y < (visible_area.m_y+visible_area.m_height) ; math_y+=1) {
+        int y = math_to_screen(wxPoint2DDouble(visible_area.m_x,math_y)).y;
+        int x = m_rect.GetLeft();
+        if (last_mark-y < legend_side) continue;    
+        dc.DrawLine(x-3,y,x+3,y);
+        dc.DrawText(wxString()<<math_y,wxPoint(x-2*scale_unit,y-0.5*scale_unit));
+        last_mark = y;
+    }
+    
+    // axis labels:
+    wxString label = _(L("Time")) + " ("+_(L("s"))+")";
+    int text_width = 0;
+    int text_height = 0;
+    dc.GetTextExtent(label,&text_width,&text_height);
+    dc.DrawText(label,wxPoint(0.5*(m_rect.GetRight()+m_rect.GetLeft())-text_width/2.f, m_rect.GetBottom()+0.5*legend_side));
+    label = _(L("Volumetric speed")) + " (" + _(L("mm³/s")) + ")";
+    dc.GetTextExtent(label,&text_width,&text_height);
+    dc.DrawRotatedText(label,wxPoint(0,0.5*(m_rect.GetBottom()+m_rect.GetTop())+text_width/2.f),90);
+}
+
+void Chart::mouse_right_button_clicked(wxMouseEvent& event) {
+    if (!manual_points_manipulation)
+        return;
+    wxPoint point = event.GetPosition();
+    int button_index = which_button_is_clicked(point);
+    if (button_index != -1 && m_buttons.size()>2) {
+        m_buttons.erase(m_buttons.begin()+button_index);
+        recalculate_line();
+    }
+}
+    
+
+
+void Chart::mouse_clicked(wxMouseEvent& event) {
+    wxPoint point = event.GetPosition();
+    int button_index = which_button_is_clicked(point);
+    if ( button_index != -1) {
+        m_dragged = &m_buttons[button_index];
+        m_previous_mouse = point;            
+    }
+}
+    
+    
+    
+void Chart::mouse_moved(wxMouseEvent& event) {
+    if (!event.Dragging() || !m_dragged) return;
+    wxPoint pos = event.GetPosition();    
+    wxRect rect = m_rect;
+    rect.Deflate(side/2.);
+    if (!(rect.Contains(pos))) {  // the mouse left chart area
+        mouse_left_window(event);
+        return;
+    }    
+    int delta_x = pos.x - m_previous_mouse.x;
+    int delta_y = pos.y - m_previous_mouse.y;
+    m_dragged->move(fixed_x?0:double(delta_x)/m_rect.GetWidth() * visible_area.m_width,-double(delta_y)/m_rect.GetHeight() * visible_area.m_height); 
+    m_previous_mouse = pos;
+    recalculate_line();
+}
+
+
+
+void Chart::mouse_double_clicked(wxMouseEvent& event) {
+    if (!manual_points_manipulation)
+        return;
+    wxPoint point = event.GetPosition();
+    if (!m_rect.Contains(point))     // the click is outside the chart
+        return;
+    m_buttons.push_back(screen_to_math(point));
+    std::sort(m_buttons.begin(),m_buttons.end());
+    recalculate_line();
+    return;
+}
+
+
+
+
+void Chart::recalculate_line() {
+    m_line_to_draw.clear();
+    m_total_volume = 0.f;
+
+    std::vector<wxPoint> points;
+    for (auto& but : m_buttons) {
+        points.push_back(wxPoint(math_to_screen(but.get_pos())));
+        if (points.size()>1 && points.back().x==points[points.size()-2].x) points.pop_back();
+        if (points.size()>1 && points.back().x > m_rect.GetRight()) {
+            points.pop_back();
+            break;
+        }
+    }
+
+    // The calculation wouldn't work in case the ramming is to be turned off completely.
+    if (points.size()>1) {
+        std::sort(points.begin(),points.end(),[](wxPoint& a,wxPoint& b) { return a.x < b.x; });
+
+        // Cubic spline interpolation: see https://en.wikiversity.org/wiki/Cubic_Spline_Interpolation#Methods
+        const bool boundary_first_derivative = true; // true - first derivative is 0 at the leftmost and rightmost point
+                                                     // false - second ---- || -------
+        const int N = points.size()-1; // last point can be accessed as N, we have N+1 total points
+        std::vector<float> diag(N+1);
+        std::vector<float> mu(N+1);
+        std::vector<float> lambda(N+1);
+        std::vector<float> h(N+1);
+        std::vector<float> rhs(N+1);
+        
+        // let's fill in inner equations
+        for (int i=1;i<=N;++i) h[i] = points[i].x-points[i-1].x;
+        std::fill(diag.begin(),diag.end(),2.f);
+        for (int i=1;i<=N-1;++i) {
+            mu[i] = h[i]/(h[i]+h[i+1]);
+            lambda[i] = 1.f - mu[i];
+            rhs[i] = 6 * ( float(points[i+1].y-points[i].y  )/(h[i+1]*(points[i+1].x-points[i-1].x)) -
+                           float(points[i].y  -points[i-1].y)/(h[i]  *(points[i+1].x-points[i-1].x))   );
+        }
+
+        // now fill in the first and last equations, according to boundary conditions:
+        if (boundary_first_derivative) {
+            const float endpoints_derivative = 0;
+            lambda[0] = 1;
+            mu[N]     = 1;
+            rhs[0] = (6.f/h[1]) * (float(points[0].y-points[1].y)/(points[0].x-points[1].x) - endpoints_derivative);
+            rhs[N] = (6.f/h[N]) * (endpoints_derivative - float(points[N-1].y-points[N].y)/(points[N-1].x-points[N].x));
+        }
+        else {
+            lambda[0] = 0;
+            mu[N]     = 0;
+            rhs[0]    = 0;
+            rhs[N]    = 0;
+        }
+
+        // the trilinear system is ready to be solved:
+        for (int i=1;i<=N;++i) {
+            float multiple = mu[i]/diag[i-1];    // let's subtract proper multiple of above equation
+            diag[i]-= multiple * lambda[i-1];
+            rhs[i] -= multiple * rhs[i-1];
+        }
+        // now the back substitution (vector mu contains invalid values from now on):
+        rhs[N] = rhs[N]/diag[N];
+        for (int i=N-1;i>=0;--i)
+            rhs[i] = (rhs[i]-lambda[i]*rhs[i+1])/diag[i];
+
+        unsigned int i=1;
+        float y=0.f;
+        for (int x=m_rect.GetLeft(); x<=m_rect.GetRight() ; ++x) {
+            if (splines) {
+                if (i<points.size()-1 && points[i].x < x ) {
+                    ++i;
+                }
+                if (points[0].x > x)
+                    y = points[0].y;
+                else
+                    if (points[N].x < x)
+                        y = points[N].y;
+                    else
+                        y = (rhs[i-1]*pow(points[i].x-x,3)+rhs[i]*pow(x-points[i-1].x,3)) / (6*h[i]) +
+                            (points[i-1].y-rhs[i-1]*h[i]*h[i]/6.f) * (points[i].x-x)/h[i] +
+                            (points[i].y  -rhs[i]  *h[i]*h[i]/6.f) * (x-points[i-1].x)/h[i];
+                m_line_to_draw.push_back(y);
+            }
+            else {
+                float x_math = screen_to_math(wxPoint(x,0)).m_x;
+                if (i+2<=points.size() && m_buttons[i+1].get_pos().m_x-0.125 < x_math)
+                    ++i;
+                m_line_to_draw.push_back(math_to_screen(wxPoint2DDouble(x_math,m_buttons[i].get_pos().m_y)).y);
+            }
+
+            m_line_to_draw.back() = std::max(m_line_to_draw.back(), m_rect.GetTop()-1);
+            m_line_to_draw.back() = std::min(m_line_to_draw.back(), m_rect.GetBottom()-1);
+            m_total_volume += (m_rect.GetBottom() - m_line_to_draw.back()) * (visible_area.m_width / m_rect.GetWidth()) * (visible_area.m_height / m_rect.GetHeight());
+        }
+    }
+
+    wxPostEvent(this->GetParent(), wxCommandEvent(EVT_WIPE_TOWER_CHART_CHANGED));
+    Refresh();
+}
+
+
+
+std::vector<float> Chart::get_ramming_speed(float sampling) const {
+    std::vector<float> speeds_out;
+    
+    const int number_of_samples = std::round( visible_area.m_width / sampling);
+    if (number_of_samples>0) {
+        const int dx = (m_line_to_draw.size()-1) / number_of_samples;
+        for (int j=0;j<number_of_samples;++j) {
+            float left =  screen_to_math(wxPoint(0,m_line_to_draw[j*dx])).m_y;
+            float right = screen_to_math(wxPoint(0,m_line_to_draw[(j+1)*dx])).m_y;
+            speeds_out.push_back((left+right)/2.f);            
+        }
+    }
+    return speeds_out;
+}
+
+
+std::vector<std::pair<float,float>> Chart::get_buttons() const {
+    std::vector<std::pair<float, float>> buttons_out;
+    for (const auto& button : m_buttons)
+        buttons_out.push_back(std::make_pair(float(button.get_pos().m_x),float(button.get_pos().m_y)));
+    return buttons_out;
+}
+    
+    
+    
+
+BEGIN_EVENT_TABLE(Chart, wxWindow)
+EVT_MOTION(Chart::mouse_moved)
+EVT_LEFT_DOWN(Chart::mouse_clicked)
+EVT_LEFT_UP(Chart::mouse_released)
+EVT_LEFT_DCLICK(Chart::mouse_double_clicked)
+EVT_RIGHT_DOWN(Chart::mouse_right_button_clicked)
+EVT_LEAVE_WINDOW(Chart::mouse_left_window)
+EVT_PAINT(Chart::paint_event)
+END_EVENT_TABLE()

src/slic3r/GUI/RammingChart.hpp

@@ -0,0 +1,120 @@
+#ifndef RAMMING_CHART_H_
+#define RAMMING_CHART_H_
+
+#include <vector>
+#include <wx/wxprec.h>
+#ifndef WX_PRECOMP
+    #include <wx/wx.h>
+#endif
+
+wxDECLARE_EVENT(EVT_WIPE_TOWER_CHART_CHANGED, wxCommandEvent);
+
+
+class Chart : public wxWindow {
+        
+public:
+    Chart(wxWindow* parent, wxRect rect,const std::vector<std::pair<float,float>>& initial_buttons,int ramming_speed_size, float sampling, int scale_unit=10) :
+        wxWindow(parent,wxID_ANY,rect.GetTopLeft(),rect.GetSize()),
+        scale_unit(scale_unit), legend_side(5*scale_unit)
+    {
+        SetBackgroundStyle(wxBG_STYLE_PAINT);
+        m_rect = wxRect(wxPoint(legend_side,0),rect.GetSize()-wxSize(legend_side,legend_side));
+        visible_area = wxRect2DDouble(0.0, 0.0, sampling*ramming_speed_size, 20.);
+        m_buttons.clear();
+        if (initial_buttons.size()>0)
+            for (const auto& pair : initial_buttons)
+                m_buttons.push_back(wxPoint2DDouble(pair.first,pair.second));
+        recalculate_line();
+    }
+    void set_xy_range(float x,float y) {
+        x = int(x/0.5) * 0.5;
+        if (x>=0) visible_area.SetRight(x);
+        if (y>=0) visible_area.SetBottom(y);
+        recalculate_line();
+    }
+    float get_volume() const { return m_total_volume; }
+    float get_time()   const { return visible_area.m_width; }
+    
+    std::vector<float> get_ramming_speed(float sampling) const; //returns sampled ramming speed
+    std::vector<std::pair<float,float>> get_buttons() const; // returns buttons position   
+    
+    void draw();
+    
+    void mouse_clicked(wxMouseEvent& event);
+    void mouse_right_button_clicked(wxMouseEvent& event);
+    void mouse_moved(wxMouseEvent& event);
+    void mouse_double_clicked(wxMouseEvent& event);
+    void mouse_left_window(wxMouseEvent&) { m_dragged = nullptr; }        
+    void mouse_released(wxMouseEvent&)    { m_dragged = nullptr; }
+    void paint_event(wxPaintEvent&) { draw(); }
+    DECLARE_EVENT_TABLE()
+    
+
+
+        
+private:
+    static const bool fixed_x = true;
+    static const bool splines = true;
+    static const bool manual_points_manipulation = false;
+    static const int side = 10; // side of draggable button
+
+    const int scale_unit;
+    int legend_side;
+
+    class ButtonToDrag {
+    public:
+        bool operator<(const ButtonToDrag& a) const { return m_pos.m_x < a.m_pos.m_x; }
+        ButtonToDrag(wxPoint2DDouble pos) : m_pos{pos} {};
+        wxPoint2DDouble get_pos() const { return m_pos; }            
+        void move(double x,double y) { m_pos.m_x+=x; m_pos.m_y+=y; }
+    private:
+        wxPoint2DDouble m_pos;              // position in math coordinates                       
+    };
+    
+    
+    
+    wxPoint math_to_screen(const wxPoint2DDouble& math) const {
+        wxPoint screen;
+        screen.x = (math.m_x-visible_area.m_x) * (m_rect.GetWidth()  / visible_area.m_width  );
+        screen.y = (math.m_y-visible_area.m_y) * (m_rect.GetHeight() / visible_area.m_height );
+        screen.y *= -1;
+        screen += m_rect.GetLeftBottom();            
+        return screen;
+    }
+    wxPoint2DDouble screen_to_math(const wxPoint& screen) const {
+        wxPoint2DDouble math = screen;
+        math -= m_rect.GetLeftBottom();
+        math.m_y *= -1;
+        math.m_x *= visible_area.m_width   / m_rect.GetWidth();    // scales to [0;1]x[0,1]
+        math.m_y *= visible_area.m_height / m_rect.GetHeight();
+        return (math+visible_area.GetLeftTop());
+    }
+        
+    int which_button_is_clicked(const wxPoint& point) const {
+        if (!m_rect.Contains(point))
+            return -1;
+        for (unsigned int i=0;i<m_buttons.size();++i) {
+            wxRect rect(math_to_screen(m_buttons[i].get_pos())-wxPoint(side/2.,side/2.),wxSize(side,side)); // bounding rectangle of this button
+            if ( rect.Contains(point) )
+                return i;
+        }
+        return (-1);
+    }
+        
+        
+    void recalculate_line();
+    void recalculate_volume();
+     
+    
+    wxRect m_rect;                  // rectangle on screen the chart is mapped into (screen coordinates)
+    wxPoint m_previous_mouse;        
+    std::vector<ButtonToDrag> m_buttons;
+    std::vector<int> m_line_to_draw;
+    wxRect2DDouble visible_area;
+    ButtonToDrag* m_dragged = nullptr;
+    float m_total_volume = 0.f;  
+    
+};
+
+
+#endif // RAMMING_CHART_H_

src/slic3r/GUI/Tab.cpp

@@ -7,6 +7,7 @@
 #include "libslic3r/Utils.hpp"
 #include "libslic3r/Model.hpp"
 #include "libslic3r/GCode/GCodeProcessor.hpp"
+#include "WipeTowerDialog.hpp"
 
 #include "Search.hpp"
 #include "OG_CustomCtrl.hpp"
@@ -2072,6 +2073,13 @@ void TabPrint::build()
         optgroup->append_single_option_line("prime_tower_width");
         optgroup->append_single_option_line("prime_volume");
         optgroup->append_single_option_line("prime_tower_brim_width");
+        optgroup->append_single_option_line("wipe_tower_rotation_angle");
+        optgroup->append_single_option_line("wipe_tower_bridging");
+        optgroup->append_single_option_line("wipe_tower_cone_angle");
+        optgroup->append_single_option_line("wipe_tower_extra_spacing");
+        optgroup->append_single_option_line("wipe_tower_no_sparse_layers");
+        optgroup->append_single_option_line("single_extruder_multi_material_priming");
+
 
         optgroup = page->new_optgroup(L("Flush options"), L"param_flush");
         optgroup->append_single_option_line("flush_into_infill", "reduce-wasting-during-filament-change#wipe-into-infill");
@@ -2844,6 +2852,46 @@ void TabFilament::build()
         option.opt.height = gcode_field_height;// 150;
         optgroup->append_single_option_line(option);
 
+    page = add_options_page(L("MMU"), "advanced");
+    optgroup = page->new_optgroup(L("Wipe tower parameters"));
+        optgroup->append_single_option_line("filament_minimal_purge_on_wipe_tower");
+
+        optgroup = page->new_optgroup(L("Toolchange parameters with single extruder MM printers"));
+        optgroup->append_single_option_line("filament_loading_speed_start");
+        optgroup->append_single_option_line("filament_loading_speed");
+        optgroup->append_single_option_line("filament_unloading_speed_start");
+        optgroup->append_single_option_line("filament_unloading_speed");
+        optgroup->append_single_option_line("filament_load_time");
+        optgroup->append_single_option_line("filament_unload_time");
+        optgroup->append_single_option_line("filament_toolchange_delay");
+        optgroup->append_single_option_line("filament_cooling_moves");
+        optgroup->append_single_option_line("filament_cooling_initial_speed");
+        optgroup->append_single_option_line("filament_cooling_final_speed");
+
+        create_line_with_widget(optgroup.get(), "filament_ramming_parameters", "", [this](wxWindow* parent) {
+            auto ramming_dialog_btn = new wxButton(parent, wxID_ANY, _(L("Ramming settings"))+dots, wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT);
+            wxGetApp().UpdateDarkUI(ramming_dialog_btn);
+            ramming_dialog_btn->SetFont(Slic3r::GUI::wxGetApp().normal_font());
+            ramming_dialog_btn->SetSize(ramming_dialog_btn->GetBestSize());
+            auto sizer = new wxBoxSizer(wxHORIZONTAL);
+            sizer->Add(ramming_dialog_btn);
+
+            ramming_dialog_btn->Bind(wxEVT_BUTTON, [this](wxCommandEvent& e) {
+                RammingDialog dlg(this,(m_config->option<ConfigOptionStrings>("filament_ramming_parameters"))->get_at(0));
+                if (dlg.ShowModal() == wxID_OK) {
+                    load_key_value("filament_ramming_parameters", dlg.get_parameters());
+                    update_changed_ui();
+                }
+            });
+            return sizer;
+        });
+
+
+        optgroup = page->new_optgroup(L("Toolchange parameters with multi extruder MM printers"));
+        optgroup->append_single_option_line("filament_multitool_ramming");
+        optgroup->append_single_option_line("filament_multitool_ramming_volume");
+        optgroup->append_single_option_line("filament_multitool_ramming_flow");
+
     page = add_options_page(L("Notes"), "note");
         optgroup = page->new_optgroup(L("Notes"),"note", 0);
         optgroup->label_width = 0;

src/slic3r/GUI/WipeTowerDialog.cpp

@@ -35,11 +35,163 @@ static const wxColour g_text_color = wxColour(107, 107, 107, 255);
 #define MAX_FLUSH_VALUE         999
 #define MIN_WIPING_DIALOG_WIDTH FromDIP(400)
 
+
 static void update_ui(wxWindow* window)
 {
     Slic3r::GUI::wxGetApp().UpdateDarkUI(window);
 }
 
+RammingDialog::RammingDialog(wxWindow* parent,const std::string& parameters)
+: wxDialog(parent, wxID_ANY, _(L("Ramming customization")), wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE/* | wxRESIZE_BORDER*/)
+{
+    update_ui(this);
+    m_panel_ramming  = new RammingPanel(this,parameters);
+
+    // Not found another way of getting the background colours of RammingDialog, RammingPanel and Chart correct than setting
+    // them all explicitely. Reading the parent colour yielded colour that didn't really match it, no wxSYS_COLOUR_... matched
+    // colour used for the dialog. Same issue (and "solution") here : https://forums.wxwidgets.org/viewtopic.php?f=1&t=39608
+    // Whoever can fix this, feel free to do so.
+#ifndef _WIN32
+    this->           SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_FRAMEBK));
+    m_panel_ramming->SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_FRAMEBK));
+#endif
+    m_panel_ramming->Show(true);
+    this->Show();
+
+    auto main_sizer = new wxBoxSizer(wxVERTICAL);
+    main_sizer->Add(m_panel_ramming, 1, wxEXPAND | wxTOP | wxLEFT | wxRIGHT, 5);
+    main_sizer->Add(CreateButtonSizer(wxOK | wxCANCEL), 0, wxALIGN_CENTER_HORIZONTAL | wxTOP | wxBOTTOM, 10);
+    SetSizer(main_sizer);
+    main_sizer->SetSizeHints(this);
+
+    update_ui(static_cast<wxButton*>(this->FindWindowById(wxID_OK, this)));
+    update_ui(static_cast<wxButton*>(this->FindWindowById(wxID_CANCEL, this)));
+
+    this->Bind(wxEVT_CLOSE_WINDOW, [this](wxCloseEvent& e) { EndModal(wxCANCEL); });
+
+    this->Bind(wxEVT_BUTTON,[this](wxCommandEvent&) {
+        m_output_data = m_panel_ramming->get_parameters();
+        EndModal(wxID_OK);
+        },wxID_OK);
+    this->Show();
+//    wxMessageDialog dlg(this, _(L("Ramming denotes the rapid extrusion just before a tool change in a single-extruder MM printer. Its purpose is to "
+    Slic3r::GUI::MessageDialog dlg(this, _(L("Ramming denotes the rapid extrusion just before a tool change in a single-extruder MM printer. Its purpose is to "
+        "properly shape the end of the unloaded filament so it does not prevent insertion of the new filament and can itself "
+        "be reinserted later. This phase is important and different materials can require different extrusion speeds to get "
+        "the good shape. For this reason, the extrusion rates during ramming are adjustable.\n\nThis is an expert-level "
+        "setting, incorrect adjustment will likely lead to jams, extruder wheel grinding into filament etc.")), _(L("Warning")), wxOK | wxICON_EXCLAMATION);// .ShowModal();
+    dlg.ShowModal();
+}
+
+
+#ifdef _WIN32
+#define style wxSP_ARROW_KEYS | wxBORDER_SIMPLE
+#else 
+#define style wxSP_ARROW_KEYS
+#endif
+
+
+
+RammingPanel::RammingPanel(wxWindow* parent, const std::string& parameters)
+: wxPanel(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize/*,wxPoint(50,50), wxSize(800,350),wxBORDER_RAISED*/)
+{
+    update_ui(this);
+	auto sizer_chart = new wxBoxSizer(wxVERTICAL);
+	auto sizer_param = new wxBoxSizer(wxVERTICAL);
+
+	std::stringstream stream{ parameters };
+	stream >> m_ramming_line_width_multiplicator >> m_ramming_step_multiplicator;
+	int ramming_speed_size = 0;
+	float dummy = 0.f;
+	while (stream >> dummy)
+		++ramming_speed_size;
+	stream.clear();
+	stream.get();
+
+	std::vector<std::pair<float, float>> buttons;
+	float x = 0.f;
+	float y = 0.f;
+	while (stream >> x >> y)
+		buttons.push_back(std::make_pair(x, y));
+
+	m_chart = new Chart(this, wxRect(scale(1),scale(1),scale(48),scale(36)), buttons, ramming_speed_size, 0.25f, scale(1));
+#ifdef _WIN32
+    update_ui(m_chart);
+#else
+    m_chart->SetBackgroundColour(parent->GetBackgroundColour()); // see comment in RammingDialog constructor
+#endif
+ 	sizer_chart->Add(m_chart, 0, wxALL, 5);
+
+    m_widget_time						= new wxSpinCtrlDouble(this,wxID_ANY,wxEmptyString,wxDefaultPosition,wxSize(ITEM_WIDTH(), -1),style,0.,5.0,3.,0.5);        
+    m_widget_volume							  = new wxSpinCtrl(this,wxID_ANY,wxEmptyString,wxDefaultPosition,wxSize(ITEM_WIDTH(), -1),style,0,10000,0);        
+    m_widget_ramming_line_width_multiplicator = new wxSpinCtrl(this,wxID_ANY,wxEmptyString,wxDefaultPosition,wxSize(ITEM_WIDTH(), -1),style,10,200,100);        
+    m_widget_ramming_step_multiplicator		  = new wxSpinCtrl(this,wxID_ANY,wxEmptyString,wxDefaultPosition,wxSize(ITEM_WIDTH(), -1),style,10,200,100);
+
+#ifdef _WIN32
+    update_ui(m_widget_time->GetText());
+    update_ui(m_widget_volume);
+    update_ui(m_widget_ramming_line_width_multiplicator);
+    update_ui(m_widget_ramming_step_multiplicator);
+#endif
+
+	auto gsizer_param = new wxFlexGridSizer(2, 5, 15);
+	gsizer_param->Add(new wxStaticText(this, wxID_ANY, wxString(_(L("Total ramming time")) + " (" + _(L("s")) + "):")), 0, wxALIGN_CENTER_VERTICAL);
+	gsizer_param->Add(m_widget_time);
+	gsizer_param->Add(new wxStaticText(this, wxID_ANY, wxString(_(L("Total rammed volume")) + " (" + _(L("mm")) + wxString("³):", wxConvUTF8))), 0, wxALIGN_CENTER_VERTICAL);
+	gsizer_param->Add(m_widget_volume);
+	gsizer_param->AddSpacer(20);
+	gsizer_param->AddSpacer(20);
+	gsizer_param->Add(new wxStaticText(this, wxID_ANY, wxString(_(L("Ramming line width")) + " (%):")), 0, wxALIGN_CENTER_VERTICAL);
+	gsizer_param->Add(m_widget_ramming_line_width_multiplicator);
+	gsizer_param->Add(new wxStaticText(this, wxID_ANY, wxString(_(L("Ramming line spacing")) + " (%):")), 0, wxALIGN_CENTER_VERTICAL);
+	gsizer_param->Add(m_widget_ramming_step_multiplicator);
+
+	sizer_param->Add(gsizer_param, 0, wxTOP, scale(10));
+
+    m_widget_time->SetValue(m_chart->get_time());
+    m_widget_time->SetDigits(2);
+    m_widget_volume->SetValue(m_chart->get_volume());
+    m_widget_volume->Disable();
+    m_widget_ramming_line_width_multiplicator->SetValue(m_ramming_line_width_multiplicator);
+    m_widget_ramming_step_multiplicator->SetValue(m_ramming_step_multiplicator);        
+    
+    m_widget_ramming_step_multiplicator->Bind(wxEVT_TEXT,[this](wxCommandEvent&) { line_parameters_changed(); });
+    m_widget_ramming_line_width_multiplicator->Bind(wxEVT_TEXT,[this](wxCommandEvent&) { line_parameters_changed(); });
+
+	auto sizer = new wxBoxSizer(wxHORIZONTAL);
+	sizer->Add(sizer_chart, 0, wxALL, 5);
+	sizer->Add(sizer_param, 0, wxALL, 10);
+
+	sizer->SetSizeHints(this);
+	SetSizer(sizer);
+
+    m_widget_time->Bind(wxEVT_TEXT,[this](wxCommandEvent&) {m_chart->set_xy_range(m_widget_time->GetValue(),-1);});
+    m_widget_time->Bind(wxEVT_CHAR,[](wxKeyEvent&){});      // do nothing - prevents the user to change the value
+    m_widget_volume->Bind(wxEVT_CHAR,[](wxKeyEvent&){});    // do nothing - prevents the user to change the value   
+    Bind(EVT_WIPE_TOWER_CHART_CHANGED,[this](wxCommandEvent&) {m_widget_volume->SetValue(m_chart->get_volume()); m_widget_time->SetValue(m_chart->get_time());} );
+    Refresh(true); // erase background
+}
+
+void RammingPanel::line_parameters_changed() {
+    m_ramming_line_width_multiplicator = m_widget_ramming_line_width_multiplicator->GetValue();
+    m_ramming_step_multiplicator = m_widget_ramming_step_multiplicator->GetValue();
+}
+
+std::string RammingPanel::get_parameters()
+{
+    std::vector<float> speeds = m_chart->get_ramming_speed(0.25f);
+    std::vector<std::pair<float,float>> buttons = m_chart->get_buttons();
+    std::stringstream stream;
+    stream << m_ramming_line_width_multiplicator << " " << m_ramming_step_multiplicator;
+    for (const float& speed_value : speeds)
+        stream << " " << speed_value;
+    stream << "|";    
+    for (const auto& button : buttons)
+        stream << " " << button.first << " " << button.second;
+    return stream.str();
+}
+
+
 #ifdef _WIN32
 #define style wxSP_ARROW_KEYS | wxBORDER_SIMPLE
 #else 
@@ -233,7 +385,7 @@ void WipingPanel::create_panels(wxWindow* parent, const int num) {
         sizer->AddSpacer(ROW_BEG_PADDING);
         sizer->Add(icon, 0, wxALIGN_CENTER_VERTICAL | wxTOP | wxBOTTOM, ROW_VERT_PADDING);
 
-        for (unsigned int j = 0; j < num; ++j) {
+        for (int j = 0; j < num; ++j) {
             edit_boxes[j][i]->Reparent(panel);
             edit_boxes[j][i]->SetBackgroundColour(panel->GetBackgroundColour());
             sizer->AddSpacer(EDIT_BOXES_GAP);

src/slic3r/GUI/WipeTowerDialog.hpp

@@ -9,8 +9,38 @@
 #include <wx/checkbox.h>
 #include <wx/msgdlg.h>
 
+#include "RammingChart.hpp"
 class Button;
 
+
+class RammingPanel : public wxPanel {
+public:
+    RammingPanel(wxWindow* parent);
+    RammingPanel(wxWindow* parent,const std::string& data);
+    std::string get_parameters();
+
+private:
+    Chart* m_chart = nullptr;
+    wxSpinCtrl* m_widget_volume = nullptr;
+    wxSpinCtrl* m_widget_ramming_line_width_multiplicator = nullptr;
+    wxSpinCtrl* m_widget_ramming_step_multiplicator = nullptr;
+    wxSpinCtrlDouble* m_widget_time = nullptr;
+    int m_ramming_step_multiplicator;
+    int m_ramming_line_width_multiplicator;
+      
+    void line_parameters_changed();
+};
+
+
+class RammingDialog : public wxDialog {
+public:
+    RammingDialog(wxWindow* parent,const std::string& parameters);    
+    std::string get_parameters() { return m_output_data; }
+private:
+    RammingPanel* m_panel_ramming = nullptr;
+    std::string m_output_data;
+};
+
 class WipingPanel : public wxPanel {
 public:
     // BBS