Slic3r::DoExport Namespace Reference

Functions
static void	update_print_estimated_stats (const GCodeProcessor &processor, const std::vector< Extruder > &extruders, PrintStatistics &print_statistics)
static std::vector< std::pair< std::string, std::string > >	validate_custom_gcode (const Print &print)
static void	init_gcode_processor (const PrintConfig &config, GCodeProcessor &processor, bool &silent_time_estimator_enabled)
static double	autospeed_volumetric_limit (const Print &print)
static void	init_ooze_prevention (const Print &print, OozePrevention &ooze_prevention)
static std::string	update_print_stats_and_format_filament_stats (const bool has_wipe_tower, const WipeTowerData &wipe_tower_data, const FullPrintConfig &config, const std::vector< Extruder > &extruders, unsigned int initial_extruder_id, PrintStatistics &print_statistics)

Function Documentation

autospeed_volumetric_limit()

static double Slic3r::DoExport::autospeed_volumetric_limit ( const Print &  print )

static

  {
      // get the minimum cross-section used in the print
      std::vector<double> mm3_per_mm;
      for (auto object : print.objects()) {
          for (size_t region_id = 0; region_id < object->num_printing_regions(); ++ region_id) {
              const PrintRegion &region = object->printing_region(region_id);
              for (auto layer : object->layers()) {
                  const LayerRegion* layerm = layer->regions()[region_id];
                  if (region.config().get_abs_value("perimeter_speed") == 0 ||
                      region.config().get_abs_value("small_perimeter_speed") == 0 ||
                      region.config().get_abs_value("external_perimeter_speed") == 0 ||
                      region.config().get_abs_value("bridge_speed") == 0)
                      mm3_per_mm.push_back(layerm->perimeters().min_mm3_per_mm());
                  if (region.config().get_abs_value("infill_speed") == 0 ||
                      region.config().get_abs_value("solid_infill_speed") == 0 ||
                      region.config().get_abs_value("top_solid_infill_speed") == 0 ||
                        region.config().get_abs_value("bridge_speed") == 0)
                    {
                        // Minimal volumetric flow should not be calculated over ironing extrusions.
                        // Use following lambda instead of the built-it method.
                        // https://github.com/prusa3d/PrusaSlicer/issues/5082
                        auto min_mm3_per_mm_no_ironing = [](const ExtrusionEntityCollection& eec) -> double {
                            double min = std::numeric_limits<double>::max();
                            for (const ExtrusionEntity* ee : eec.entities)
                                if (ee->role() != ExtrusionRole::Ironing)
                                    min = std::min(min, ee->min_mm3_per_mm());
                            return min;
                        };
 
                        mm3_per_mm.push_back(min_mm3_per_mm_no_ironing(layerm->fills()));
                    }
              }
          }
          if (object->config().get_abs_value("support_material_speed") == 0 ||
              object->config().get_abs_value("support_material_interface_speed") == 0)
              for (auto layer : object->support_layers())
                  mm3_per_mm.push_back(layer->support_fills.min_mm3_per_mm());
      }
      // filter out 0-width segments
      mm3_per_mm.erase(std::remove_if(mm3_per_mm.begin(), mm3_per_mm.end(), [](double v) { return v < 0.000001; }), mm3_per_mm.end());
      double volumetric_speed = 0.;
      if (! mm3_per_mm.empty()) {
          // In order to honor max_print_speed we need to find a target volumetric
          // speed that we can use throughout the print. So we define this target 
          // volumetric speed as the volumetric speed produced by printing the 
          // smallest cross-section at the maximum speed: any larger cross-section
          // will need slower feedrates.
          volumetric_speed = *std::min_element(mm3_per_mm.begin(), mm3_per_mm.end()) * print.config().max_print_speed.value;
          // limit such volumetric speed with max_volumetric_speed if set
          if (print.config().max_volumetric_speed.value > 0)
              volumetric_speed = std::min(volumetric_speed, print.config().max_volumetric_speed.value);
      }
      return volumetric_speed;
  }

References autospeed_volumetric_limit(), Slic3r::PrintRegion::config(), Slic3r::Print::config(), Slic3r::LayerRegion::fills(), Slic3r::ExtrusionEntityCollection::min_mm3_per_mm(), Slic3r::Print::objects(), and Slic3r::LayerRegion::perimeters().

Referenced by Slic3r::GCode::_do_export(), and autospeed_volumetric_limit().

Here is the call graph for this function:

Here is the caller graph for this function:

init_gcode_processor()

static void Slic3r::DoExport::init_gcode_processor ( const PrintConfig &  config, GCodeProcessor &  processor, bool &  silent_time_estimator_enabled  )

static

    {
        silent_time_estimator_enabled = (config.gcode_flavor == gcfMarlinLegacy || config.gcode_flavor == gcfMarlinFirmware)
                                        && config.silent_mode;
        processor.reset();
        processor.initialize_result_moves();
        processor.apply_config(config);
        processor.enable_stealth_time_estimator(silent_time_estimator_enabled);
    }

References Slic3r::GCodeProcessor::apply_config(), Slic3r::GCodeProcessor::enable_stealth_time_estimator(), Slic3r::gcfMarlinFirmware, Slic3r::gcfMarlinLegacy, init_gcode_processor(), Slic3r::GCodeProcessor::initialize_result_moves(), and Slic3r::GCodeProcessor::reset().

Referenced by Slic3r::GCode::_do_export(), and init_gcode_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

init_ooze_prevention()

static void Slic3r::DoExport::init_ooze_prevention ( const Print &  print, OozePrevention &  ooze_prevention  )

static

  {
      ooze_prevention.enable = print.config().ooze_prevention.value && ! print.config().single_extruder_multi_material;
  }

References Slic3r::Print::config(), Slic3r::OozePrevention::enable, and init_ooze_prevention().

Referenced by Slic3r::GCode::_do_export(), and init_ooze_prevention().

Here is the call graph for this function:

Here is the caller graph for this function:

update_print_estimated_stats()

static void Slic3r::DoExport::update_print_estimated_stats ( const GCodeProcessor &  processor, const std::vector< Extruder > &  extruders, PrintStatistics &  print_statistics  )

static

    {
        const GCodeProcessorResult& result = processor.get_result();
        print_statistics.estimated_normal_print_time = get_time_dhms(result.print_statistics.modes[static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Normal)].time);
        print_statistics.estimated_silent_print_time = processor.is_stealth_time_estimator_enabled() ?
            get_time_dhms(result.print_statistics.modes[static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Stealth)].time) : "N/A";
 
        // update filament statictics
        double total_extruded_volume = 0.0;
        double total_used_filament   = 0.0;
        double total_weight          = 0.0;
        double total_cost            = 0.0;
        for (auto volume : result.print_statistics.volumes_per_extruder) {
            total_extruded_volume += volume.second;
 
            size_t extruder_id = volume.first;
            auto extruder = std::find_if(extruders.begin(), extruders.end(), [extruder_id](const Extruder& extr) { return extr.id() == extruder_id; });
            if (extruder == extruders.end())
                continue;
 
            double s = PI * sqr(0.5* extruder->filament_diameter());
            double weight = volume.second * extruder->filament_density() * 0.001;
            total_used_filament += volume.second/s;
            total_weight        += weight;
            total_cost          += weight * extruder->filament_cost() * 0.001;
        }
 
        print_statistics.total_extruded_volume = total_extruded_volume;
        print_statistics.total_used_filament   = total_used_filament;
        print_statistics.total_weight          = total_weight;
        print_statistics.total_cost            = total_cost;
 
        print_statistics.filament_stats        = result.print_statistics.volumes_per_extruder;
    }

References Slic3r::PrintStatistics::estimated_normal_print_time, Slic3r::PrintStatistics::estimated_silent_print_time, Slic3r::PrintStatistics::filament_stats, Slic3r::GCodeProcessor::get_result(), Slic3r::get_time_dhms(), Slic3r::GCodeProcessor::is_stealth_time_estimator_enabled(), Slic3r::PrintEstimatedStatistics::modes, PI, Slic3r::GCodeProcessorResult::print_statistics, Slic3r::sqr(), Slic3r::PrintStatistics::total_cost, Slic3r::PrintStatistics::total_extruded_volume, Slic3r::PrintStatistics::total_used_filament, Slic3r::PrintStatistics::total_weight, update_print_estimated_stats(), and Slic3r::PrintEstimatedStatistics::volumes_per_extruder.

Referenced by Slic3r::GCode::do_export(), and update_print_estimated_stats().

Here is the call graph for this function:

Here is the caller graph for this function:

update_print_stats_and_format_filament_stats()

static std::string Slic3r::DoExport::update_print_stats_and_format_filament_stats ( const bool  has_wipe_tower, const WipeTowerData &  wipe_tower_data, const FullPrintConfig &  config, const std::vector< Extruder > &  extruders, unsigned int  initial_extruder_id, PrintStatistics &  print_statistics  )

static

    {
    std::string filament_stats_string_out;
 
      print_statistics.clear();
        print_statistics.total_toolchanges = std::max(0, wipe_tower_data.number_of_toolchanges);
        print_statistics.initial_extruder_id = initial_extruder_id;
        std::vector<std::string> filament_types;
      if (! extruders.empty()) {
          std::pair<std::string, unsigned int> out_filament_used_mm ("; filament used [mm] = ", 0);
          std::pair<std::string, unsigned int> out_filament_used_cm3("; filament used [cm3] = ", 0);
          std::pair<std::string, unsigned int> out_filament_used_g  ("; filament used [g] = ", 0);
          std::pair<std::string, unsigned int> out_filament_cost    ("; filament cost = ", 0);
          for (const Extruder &extruder : extruders) {
                print_statistics.printing_extruders.emplace_back(extruder.id());
                filament_types.emplace_back(config.filament_type.get_at(extruder.id()));
 
              double used_filament   = extruder.used_filament() + (has_wipe_tower ? wipe_tower_data.used_filament[extruder.id()] : 0.f);
              double extruded_volume = extruder.extruded_volume() + (has_wipe_tower ? wipe_tower_data.used_filament[extruder.id()] * 2.4052f : 0.f); // assumes 1.75mm filament diameter
              double filament_weight = extruded_volume * extruder.filament_density() * 0.001;
              double filament_cost   = filament_weight * extruder.filament_cost()    * 0.001;
                auto append = [&extruder](std::pair<std::string, unsigned int> &dst, const char *tmpl, double value) {
                    assert(is_decimal_separator_point());
                  while (dst.second < extruder.id()) {
                      // Fill in the non-printing extruders with zeros.
                      dst.first += (dst.second > 0) ? ", 0" : "0";
                      ++ dst.second;
                  }
                  if (dst.second > 0)
                      dst.first += ", ";
                  char buf[64];
          sprintf(buf, tmpl, value);
                  dst.first += buf;
                  ++ dst.second;
              };
              append(out_filament_used_mm,  "%.2lf", used_filament);
              append(out_filament_used_cm3, "%.2lf", extruded_volume * 0.001);
              if (filament_weight > 0.) {
                  print_statistics.total_weight = print_statistics.total_weight + filament_weight;
                  append(out_filament_used_g, "%.2lf", filament_weight);
                  if (filament_cost > 0.) {
                      print_statistics.total_cost = print_statistics.total_cost + filament_cost;
                      append(out_filament_cost, "%.2lf", filament_cost);
                  }
              }
              print_statistics.total_used_filament += used_filament;
              print_statistics.total_extruded_volume += extruded_volume;
              print_statistics.total_wipe_tower_filament += has_wipe_tower ? used_filament - extruder.used_filament() : 0.;
              print_statistics.total_wipe_tower_cost += has_wipe_tower ? (extruded_volume - extruder.extruded_volume())* extruder.filament_density() * 0.001 * extruder.filament_cost() * 0.001 : 0.;
          }
          filament_stats_string_out += out_filament_used_mm.first;
            filament_stats_string_out += "\n" + out_filament_used_cm3.first;
            if (out_filament_used_g.second)
                filament_stats_string_out += "\n" + out_filament_used_g.first;
            if (out_filament_cost.second)
                filament_stats_string_out += "\n" + out_filament_cost.first;
            print_statistics.initial_filament_type = config.filament_type.get_at(initial_extruder_id);
            std::sort(filament_types.begin(), filament_types.end());
            print_statistics.printing_filament_types = filament_types.front();
            for (size_t i = 1; i < filament_types.size(); ++ i) {
                print_statistics.printing_filament_types += ",";
                print_statistics.printing_filament_types += filament_types[i];
            }
        }
        return filament_stats_string_out;
    }

References Slic3r::PrintStatistics::clear(), Slic3r::filament_cost(), Slic3r::PrintStatistics::initial_extruder_id, Slic3r::PrintStatistics::initial_filament_type, Slic3r::is_decimal_separator_point(), Slic3r::WipeTowerData::number_of_toolchanges, Slic3r::PrintStatistics::printing_extruders, Slic3r::PrintStatistics::printing_filament_types, Slic3r::PrintStatistics::total_cost, Slic3r::PrintStatistics::total_extruded_volume, Slic3r::PrintStatistics::total_toolchanges, Slic3r::PrintStatistics::total_used_filament, Slic3r::PrintStatistics::total_weight, Slic3r::PrintStatistics::total_wipe_tower_cost, Slic3r::PrintStatistics::total_wipe_tower_filament, update_print_stats_and_format_filament_stats(), and Slic3r::WipeTowerData::used_filament.

Referenced by Slic3r::GCode::_do_export(), and update_print_stats_and_format_filament_stats().

Here is the call graph for this function:

Here is the caller graph for this function:

validate_custom_gcode()

static std::vector< std::pair< std::string, std::string > > Slic3r::DoExport::validate_custom_gcode ( const Print &  print )

static

                                                                                              {
        static const unsigned int MAX_TAGS_COUNT = 5;
        std::vector<std::pair<std::string, std::string>> ret;
 
        auto check = [&ret](const std::string& source, const std::string& gcode) {
            std::vector<std::string> tags;
            if (GCodeProcessor::contains_reserved_tags(gcode, MAX_TAGS_COUNT, tags)) {
                if (!tags.empty()) {
                    size_t i = 0;
                    while (ret.size() < MAX_TAGS_COUNT && i < tags.size()) {
                        ret.push_back({ source, tags[i] });
                        ++i;
                    }
                }
            }
        };
 
        const GCodeConfig& config = print.config();
        check(_u8L("Start G-code"), config.start_gcode.value);
        if (ret.size() < MAX_TAGS_COUNT) check(_u8L("End G-code"), config.end_gcode.value);
        if (ret.size() < MAX_TAGS_COUNT) check(_u8L("Before layer change G-code"), config.before_layer_gcode.value);
        if (ret.size() < MAX_TAGS_COUNT) check(_u8L("After layer change G-code"), config.layer_gcode.value);
        if (ret.size() < MAX_TAGS_COUNT) check(_u8L("Tool change G-code"), config.toolchange_gcode.value);
        if (ret.size() < MAX_TAGS_COUNT) check(_u8L("Between objects G-code (for sequential printing)"), config.between_objects_gcode.value);
        if (ret.size() < MAX_TAGS_COUNT) check(_u8L("Color Change G-code"), config.color_change_gcode.value);
        if (ret.size() < MAX_TAGS_COUNT) check(_u8L("Pause Print G-code"), config.pause_print_gcode.value);
        if (ret.size() < MAX_TAGS_COUNT) check(_u8L("Template Custom G-code"), config.template_custom_gcode.value);
        if (ret.size() < MAX_TAGS_COUNT) {
            for (const std::string& value : config.start_filament_gcode.values) {
                check(_u8L("Filament Start G-code"), value);
                if (ret.size() == MAX_TAGS_COUNT)
                    break;
            }
        }
        if (ret.size() < MAX_TAGS_COUNT) {
            for (const std::string& value : config.end_filament_gcode.values) {
                check(_u8L("Filament End G-code"), value);
                if (ret.size() == MAX_TAGS_COUNT)
                    break;
            }
        }
        if (ret.size() < MAX_TAGS_COUNT) {
            const CustomGCode::Info& custom_gcode_per_print_z = print.model().custom_gcode_per_print_z;
            for (const auto& gcode : custom_gcode_per_print_z.gcodes) {
                check(_u8L("Custom G-code"), gcode.extra);
                if (ret.size() == MAX_TAGS_COUNT)
                    break;
            }
        }
 
        return ret;
    }

References _u8L, Slic3r::Print::config(), Slic3r::Model::custom_gcode_per_print_z, Slic3r::CustomGCode::Info::gcodes, Slic3r::PrintBase::model(), and validate_custom_gcode().

Referenced by Slic3r::GCode::do_export(), and validate_custom_gcode().

Here is the call graph for this function:

Here is the caller graph for this function: