Time estimation improvement

src/libslic3r/PrintExport.hpp

@@ -16,8 +16,12 @@ namespace Slic3r {
 
 enum ePrintStatistics
 {
-    psObjectsUsedMaterial = 0,
+    psUsedMaterial = 0,
-    psSupportUsedMaterial
+    psNumFade,
+    psNumSlow,
+    psNumFast,
+
+    psCnt
 };
 
 enum class FilePrinterFormat {
@@ -124,40 +128,45 @@ template<> class FilePrinter<FilePrinterFormat::SLA_PNGZIP>
     double m_layer_height = .0;
     Raster::Origin m_o = Raster::Origin::TOP_LEFT;
 
-    double m_objects_used_material = 0.0;
+    double m_used_material = 0.0;
-    double m_support_used_material = 0.0;
+    int    m_cnt_fade_layers = 0;
+    int    m_cnt_slow_layers = 0;
+    int    m_cnt_fast_layers = 0;
 
     std::string createIniContent(const std::string& projectname) {
-        double layer_height = m_layer_height;
+//         double layer_height = m_layer_height;
 
         using std::string;
         using std::to_string;
 
         auto expt_str = to_string(m_exp_time_s);
         auto expt_first_str = to_string(m_exp_time_first_s);
-        auto stepnum_str = to_string(static_cast<unsigned>(800*layer_height));
+//         auto stepnum_str = to_string(static_cast<unsigned>(800*layer_height));
-        auto layerh_str = to_string(layer_height);
+        auto layerh_str = to_string(m_layer_height);
 
-        const std::string objects_used_material = to_string(m_objects_used_material);
+        const std::string cnt_fade_layers = to_string(m_cnt_fade_layers);
-        const std::string support_used_material = to_string(m_support_used_material);
+        const std::string cnt_slow_layers = to_string(m_cnt_slow_layers);
+        const std::string cnt_fast_layers = to_string(m_cnt_fast_layers);
+        const std::string used_material   = to_string(m_used_material);
 
         return string(
         "action = print\n"
         "jobDir = ") + projectname + "\n" +
         "expTime = " + expt_str + "\n"
         "expTimeFirst = " + expt_first_str + "\n"
-        "stepNum = " + stepnum_str + "\n"
+//         "stepNum = " + stepnum_str + "\n"
-        "wifiOn = 1\n"
+//         "wifiOn = 1\n"
-        "tiltSlow = 60\n"
+//         "tiltSlow = 60\n"
-        "tiltFast = 15\n"
+//         "tiltFast = 15\n"
-        "numFade = 10\n"
+        "numFade = " + cnt_fade_layers + "\n"
-        "startdelay = 0\n"
+//         "startdelay = 0\n"
         "layerHeight = " + layerh_str + "\n"
         "noteInfo = "
         "expTime = "+expt_str+" + resinType = generic+layerHeight = "
                   +layerh_str+" + printer = DWARF3\n"
-        "objUsedMaterial=" + objects_used_material + "\n"
+        "usedMaterial = " + used_material + "\n"
-        "supUsedMaterial=" + support_used_material + "\n";
+        "numSlow = " + cnt_slow_layers + "\n"
+        "numFast = " + cnt_fast_layers + "\n";
     }
 
 public:
@@ -294,8 +303,13 @@ public:
 
     void set_statistics(const std::vector<double> statistics)
     {
-        m_objects_used_material = statistics[psObjectsUsedMaterial];
+        if (statistics.size() != psCnt)
-        m_support_used_material = statistics[psSupportUsedMaterial];
+            return;
+
+        m_used_material   = statistics[psUsedMaterial];
+        m_cnt_fade_layers = int(statistics[psNumFade]);
+        m_cnt_slow_layers = int(statistics[psNumSlow]);
+        m_cnt_fast_layers = int(statistics[psNumFast]);
     }
 };
 

src/libslic3r/SLAPrint.cpp

@@ -971,8 +971,11 @@ void SLAPrint::process()
     fill_statistics();
     // Set statistics values to the printer
     SLAPrinter& printer = *m_printer;
-    printer.set_statistics({m_print_statistics.objects_used_material,
+    printer.set_statistics({(m_print_statistics.objects_used_material + m_print_statistics.support_used_material)/1000,
-                            m_print_statistics.support_used_material});
+                            10.0,
+                            double(m_print_statistics.slow_layers_count),
+                            double(m_print_statistics.fast_layers_count)
+                            });
 
     // If everything vent well
     report_status(*this, 100, L("Slicing done"));
@@ -1037,43 +1040,105 @@ bool SLAPrint::invalidate_state_by_config_options(const std::vector<t_config_opt
 
 void SLAPrint::fill_statistics()
 {
-    float supports_volume = 0.0;
+    const double init_layer_height  = m_material_config.initial_layer_height.getFloat();
-    float models_volume = 0.0;
+    const double layer_height       = m_default_object_config.layer_height.getFloat();
 
-    int max_layers_cnt = 0;
+    // TODO : slow_fast_limit, fast_tilt, slow_tilt should be filled in the future
+    // These variables will be a part of the printer preset
+    const double slow_fast_limit    = 0.5; // if printing area is more than 50% of the bed area, then use a slow tilt
+    const double fast_tilt          = 5.0;
+    const double slow_tilt          = 8.0;
 
-    const float init_layer_height = m_material_config.initial_layer_height.getFloat();
+    const double init_exp_time      = m_material_config.initial_exposure_time.getFloat();
-    const float layer_height = m_default_object_config.layer_height.getFloat();
+    const double exp_time           = m_material_config.exposure_time.getFloat();
 
-    // Used material
+    // TODO : fade_layers_cnt should be filled in the future
+    // This variable will be a part of the print preset
+    const int fade_layers_cnt       = 10; // [3;20]
+
+    const double width  = m_printer_config.display_width.getFloat() / SCALING_FACTOR;
+    const double height = m_printer_config.display_width.getFloat() / SCALING_FACTOR;
+    const double display_area       = width*height;
+
+    double supports_volume = 0.0;
+    double models_volume = 0.0;
+
+    double estim_time = 0.0;
+
+    size_t slow_layers = 0;
+    size_t fast_layers = 0;
+
+    // find highest object
+    size_t max_layers_cnt = 0;
+    size_t highest_obj_idx = 0;
     for (SLAPrintObject * po : m_objects) {
-        // Calculate full volume of the supports (+pad) 
-        for (const ExPolygons& polygons : po->get_support_slices())
-            for (const ExPolygon& polygon : polygons)
-                supports_volume += polygon.area() *layer_height;
-
-        // Calculate full volume of the object 
-        for (const ExPolygons& polygons : po->get_model_slices())
-            for (const ExPolygon& polygon : polygons)
-                models_volume += polygon.area() *layer_height;
-
         const SLAPrintObject::SliceIndex& slice_index = po->get_slice_index();
-
+        if (max_layers_cnt < slice_index.size()) {
-        // If init_layer_height isn't equivalent to the layer_height,
+            max_layers_cnt = slice_index.size();
-        // let correct volume of the first(initial) layer
+            highest_obj_idx = std::find(m_objects.begin(), m_objects.end(), po) - m_objects.begin();
-        if (init_layer_height != layer_height) 
+        }
-        {
-            const auto index = slice_index.begin();
-            if (index->second.support_slices_idx != SLAPrintObject::SliceRecord::NONE)
-                for (const ExPolygon& polygon : po->get_support_slices().front())
-                    supports_volume += polygon.area() *(init_layer_height - layer_height);
-            if (index->second.model_slices_idx != SLAPrintObject::SliceRecord::NONE)
-                for (const ExPolygon& polygon : po->get_model_slices().front())
-                    models_volume += polygon.area() *(init_layer_height - layer_height);
     }
 
-        if (max_layers_cnt < slice_index.size())
+    const SLAPrintObject * highest_obj = m_objects[highest_obj_idx];
-            max_layers_cnt = slice_index.size();
+    const SLAPrintObject::SliceIndex& highest_obj_slice_index = highest_obj->get_slice_index();
+
+    const double delta_fade_time = (init_exp_time - exp_time) / (fade_layers_cnt + 1);
+    double fade_layer_time = init_exp_time;
+
+    int sliced_layer_cnt = 0;
+    for (const auto& layer : highest_obj_slice_index)
+    {
+        const double l_height = (layer.first == highest_obj_slice_index.begin()->first &&
+                                init_layer_height != layer_height) ? 
+                                init_layer_height : layer_height;
+
+        // Calculation of the consumed material 
+
+        double layer_model_area = 0;
+        double layer_support_area = 0;
+        for (SLAPrintObject * po : m_objects)
+        {
+            const auto index = po->get_slice_index();
+            if (index.find(layer.first) == index.end())
+                continue;
+                        
+            if (index.at(layer.first).model_slices_idx != SLAPrintObject::SliceRecord::NONE) {
+                for (const ExPolygon& polygon : po->get_model_slices().at(index.at(layer.first).model_slices_idx))
+                    layer_model_area += polygon.area();
+            }
+            /*else */if (index.at(layer.first).support_slices_idx != SLAPrintObject::SliceRecord::NONE) {
+                for (const ExPolygon& polygon : po->get_support_slices().front())
+                    layer_support_area += polygon.area();
+            }
+        }
+        models_volume += layer_model_area * l_height;
+        supports_volume += layer_support_area * l_height;
+
+        // Calculation of the slow and fast layers to the future controlling those values on FW
+
+        const bool is_fast_layer = (layer_model_area + layer_support_area) <= display_area*slow_fast_limit;
+        const double tilt_time = is_fast_layer ? fast_tilt : slow_tilt;
+        if (is_fast_layer)
+            fast_layers++;
+        else
+            slow_layers++;
+
+
+        // Calculation of the printing time
+
+        if (sliced_layer_cnt < 3)
+            estim_time += init_exp_time;
+        else if (fade_layer_time > exp_time)
+        {
+            fade_layer_time -= delta_fade_time;
+            estim_time += fade_layer_time;
+        }
+        else
+            estim_time += exp_time;
+
+        estim_time += tilt_time;
+
+        sliced_layer_cnt++;
     }
 
     m_print_statistics.support_used_material = supports_volume * SCALING_FACTOR * SCALING_FACTOR; 
@@ -1083,34 +1148,11 @@ void SLAPrint::fill_statistics()
     // A layers count o the highest object 
     if (max_layers_cnt == 0)
         m_print_statistics.estimated_print_time = "N/A";
-    float init_exp_time = m_material_config.initial_exposure_time.getFloat();//35;
+    else
-    float exp_time = m_material_config.exposure_time.getFloat();//8;
+        m_print_statistics.estimated_print_time = get_time_dhms(float(estim_time));
 
-    // TODO : fade_layers_cnt should be filled in the future
+    m_print_statistics.fast_layers_count = fast_layers;
-    // This variable will be a part of the print(material) preset
+    m_print_statistics.slow_layers_count = slow_layers;
-    const int fade_layers_cnt = 10; // [3;20]
-
-    // TODO : tilt_delay_before_time & tilt_delay_after_time should be filled in the future
-    // These values are received from the printer after a printing start
-    const float tilt_delay_before_time = 0.0;
-    const float tilt_delay_after_time = 0.0;
-    if (tilt_delay_before_time + tilt_delay_after_time > 0.0)
-    {
-        init_exp_time += tilt_delay_before_time + tilt_delay_after_time;
-        exp_time += tilt_delay_before_time + tilt_delay_after_time;
-    }
-
-    float estim_time = init_exp_time * 3 + exp_time * (max_layers_cnt - 3 - fade_layers_cnt);
-
-    const float delta_time = (init_exp_time - exp_time) / (fade_layers_cnt+1);
-    double fade_layer_time = init_exp_time;
-    while (fade_layer_time > exp_time)
-    {
-        fade_layer_time -= delta_time;
-        estim_time += fade_layer_time;
-    }
-
-    m_print_statistics.estimated_print_time = get_time_dhms(estim_time);
 }
 
 // Returns true if an object step is done on all objects and there's at least one object.

src/libslic3r/SLAPrint.hpp

@@ -177,6 +177,8 @@ struct SLAPrintStatistics
     std::string                     estimated_print_time;
     double                          objects_used_material;
     double                          support_used_material;
+    size_t                          slow_layers_count;
+    size_t                          fast_layers_count;
     double                          total_cost;
     double                          total_weight;
 
@@ -191,6 +193,8 @@ struct SLAPrintStatistics
         estimated_print_time.clear();
         objects_used_material = 0.;
         support_used_material = 0.;
+        slow_layers_count = 0;
+        fast_layers_count = 0;
         total_cost = 0.;
         total_weight = 0.;
     }

src/slic3r/GUI/Plater.cpp

@@ -822,16 +822,16 @@ void Sidebar::show_sliced_info_sizer(const bool show)
         if (p->plater->printer_technology() == ptSLA)
         {
             const SLAPrintStatistics& ps = p->plater->sla_print().print_statistics();
-            wxString new_label = _(L("Used Material (mm³)")) + " :";
+            wxString new_label = _(L("Used Material (ml)")) + " :";
             const bool is_supports = ps.support_used_material > 0.0;
             if (is_supports)
                 new_label += wxString::Format("\n    - %s\n    - %s", _(L("object(s)")), _(L("supports and pad")));
 
             wxString info_text = is_supports ?
-                wxString::Format("%.2f \n%.2f \n%.2f", ps.objects_used_material + ps.support_used_material/* / 1000*/,
+                wxString::Format("%.2f \n%.2f \n%.2f", (ps.objects_used_material + ps.support_used_material) / 1000,
-                                                       ps.objects_used_material/* / 1000*/,
+                                                       ps.objects_used_material / 1000,
-                                                       ps.support_used_material/* / 1000*/) :
+                                                       ps.support_used_material / 1000) :
-                wxString::Format("%.2f", ps.objects_used_material + ps.support_used_material/* / 1000*/);
+                wxString::Format("%.2f", ps.objects_used_material + ps.support_used_material / 1000);
             p->sliced_info->SetTextAndShow(siMateril_unit, info_text, new_label);
 
             p->sliced_info->SetTextAndShow(siCost, "N/A"/*wxString::Format("%.2f", ps.total_cost)*/);