Slic3r::DoExport Namespace Reference

Functions
static void	update_print_estimated_stats (const GCodeProcessor &processor, const std::vector< Extruder > &extruders, PrintStatistics &print_statistics, const PrintConfig &config)
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, const std::shared_ptr< MultiNozzleUtils::NozzleGroupResultBase > &nozzle_group_result=nullptr)
static void	init_ooze_prevention (const Print &print, OozePrevention &ooze_prevention)
static int	total_toolchanges_from_ordering (const ToolOrdering &tool_ordering)
static int	resolve_total_toolchanges (const WipeTowerData &wipe_tower_data, const ToolOrdering &tool_ordering)
static std::string	update_print_stats_and_format_filament_stats (const bool has_wipe_tower, const WipeTowerData &wipe_tower_data, const std::vector< Extruder > &extruders, PrintStatistics &print_statistics, const ToolOrdering &tool_ordering)

Function Documentation

init_gcode_processor()

void Slic3r::DoExport::init_gcode_processor ( const PrintConfig & config, GCodeProcessor & processor, const std::shared_ptr< MultiNozzleUtils::NozzleGroupResultBase > & nozzle_group_result = nullptr )

static

    {
        processor.reset();
        // Slot-resolution context for the streaming replay (reset() just cleared it). This is NOT
        // the post-stream result-field handover at the end of do_export, which gates the richer
        // change-time model and must stay after the stream.
        processor.initialize_from_context(nozzle_group_result);
        processor.initialize_result_moves();
        processor.apply_config(config);
        processor.configure_exclusion_volume_path_check(config);
    }

References Slic3r::GCodeProcessor::apply_config(), Slic3r::GCodeProcessor::configure_exclusion_volume_path_check(), init_gcode_processor(), Slic3r::GCodeProcessor::initialize_from_context(), 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()

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(), init_ooze_prevention(), and Slic3r::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:

resolve_total_toolchanges()

int Slic3r::DoExport::resolve_total_toolchanges ( const WipeTowerData & wipe_tower_data, const ToolOrdering & tool_ordering )

static

    {
        int changes = wipe_tower_data.number_of_toolchanges;
        if (changes < 0)
            changes = total_toolchanges_from_ordering(tool_ordering);
        return std::max(0, changes);
    }

References Slic3r::WipeTowerData::number_of_toolchanges, resolve_total_toolchanges(), and total_toolchanges_from_ordering().

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

Here is the call graph for this function:

Here is the caller graph for this function:

total_toolchanges_from_ordering()

int Slic3r::DoExport::total_toolchanges_from_ordering ( const ToolOrdering & tool_ordering )

static

    {
        int changes = 0;
        int last    = -1;
        for (const LayerTools &lt : tool_ordering)
            for (unsigned int extruder : lt.extruders) {
                if (last >= 0 && int(extruder) != last)
                    ++ changes;
                last = int(extruder);
            }
        return changes;
    }

References total_toolchanges_from_ordering().

Referenced by resolve_total_toolchanges(), and total_toolchanges_from_ordering().

Here is the call graph for this function:

Here is the caller graph for this function:

update_print_estimated_stats()

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

static

    {
        const GCodeProcessorResult& result = processor.get_result();
        double normal_print_time = result.print_statistics.modes[static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Normal)].time;
        print_statistics.estimated_normal_print_time = get_time_dhms(normal_print_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.total_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;
        }
 
        total_cost += config.time_cost.getFloat() * (normal_print_time/3600.0);
 
        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.model_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::model_volumes_per_extruder, Slic3r::PrintEstimatedStatistics::modes, Slic3r::PrintEstimatedStatistics::Normal, PI, Slic3r::GCodeProcessorResult::print_statistics, Slic3r::sqr(), Slic3r::PrintEstimatedStatistics::Stealth, Slic3r::PrintStatistics::total_cost, Slic3r::PrintStatistics::total_extruded_volume, Slic3r::PrintStatistics::total_used_filament, Slic3r::PrintEstimatedStatistics::total_volumes_per_extruder, Slic3r::PrintStatistics::total_weight, and update_print_estimated_stats().

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()

std::string Slic3r::DoExport::update_print_stats_and_format_filament_stats ( const bool has_wipe_tower, const WipeTowerData & wipe_tower_data, const std::vector< Extruder > & extruders, PrintStatistics & print_statistics, const ToolOrdering & tool_ordering )

static

    {
    std::string filament_stats_string_out;
 
      print_statistics.clear();
        print_statistics.total_toolchanges = resolve_total_toolchanges(wipe_tower_data, tool_ordering);
      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) {
              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;
            filament_stats_string_out += "\n";
        }
        return filament_stats_string_out;
    }

References Slic3r::append(), Slic3r::PrintStatistics::clear(), Slic3r::filament_cost(), Slic3r::is_decimal_separator_point(), resolve_total_toolchanges(), 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()

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, is_bbl_printer = print.is_BBL_printer()](const std::string& source, const std::string& gcode) {
            std::vector<std::string> tags;
            if (GCodeProcessor::contains_reserved_tags(gcode, MAX_TAGS_COUNT, tags, is_bbl_printer)) {
                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(_(L("Machine start G-code")), config.machine_start_gcode.value);
        if (ret.size() < MAX_TAGS_COUNT) check(_(L("Machine end G-code")), config.machine_end_gcode.value);
        if (ret.size() < MAX_TAGS_COUNT) check(_(L("Before layer change G-code")), config.before_layer_change_gcode.value);
        if (ret.size() < MAX_TAGS_COUNT) check(_(L("Layer change G-code")), config.layer_change_gcode.value);
        if (ret.size() < MAX_TAGS_COUNT) check(_(L("Timelapse G-code")), config.time_lapse_gcode.value);
        if (ret.size() < MAX_TAGS_COUNT) check(_(L("Timelapse G-code")), config.wrapping_detection_gcode.value);
        if (ret.size() < MAX_TAGS_COUNT) check(_(L("Change filament G-code")), config.change_filament_gcode.value);
        if (ret.size() < MAX_TAGS_COUNT) check(_(L("Printing by object G-code")), config.printing_by_object_gcode.value);
        //if (ret.size() < MAX_TAGS_COUNT) check(_(L("Color Change G-code")), config.color_change_gcode.value);
        //Orca
        if (ret.size() < MAX_TAGS_COUNT) check(_(L("Change extrusion role G-code")), config.change_extrusion_role_gcode.value);
        if (ret.size() < MAX_TAGS_COUNT) check(_(L("Process change extrusion role G-code")), config.process_change_extrusion_role_gcode.value);
        if (ret.size() < MAX_TAGS_COUNT) check(_(L("Pause G-code")), config.machine_pause_gcode.value);
        if (ret.size() < MAX_TAGS_COUNT) check(_(L("Template Custom G-code")), config.template_custom_gcode.value);
        if (ret.size() < MAX_TAGS_COUNT) {
            for (const std::string& value : config.filament_start_gcode.values) {
                check(_(L("Filament start G-code")), value);
                if (ret.size() == MAX_TAGS_COUNT)
                    break;
            }
        }
        if (ret.size() < MAX_TAGS_COUNT) {
            for (const std::string& value : config.filament_end_gcode.values) {
                check(_(L("Filament end G-code")), value);
                if (ret.size() == MAX_TAGS_COUNT)
                    break;
            }
        }
        if (ret.size() < MAX_TAGS_COUNT) {
            for (const std::string& value : config.filament_change_extrusion_role_gcode.values) {
                check(_(L("Filament change extrusion role G-code")), value);
                if (ret.size() == MAX_TAGS_COUNT)
                    break;
            }
        }
        //BBS: no custom_gcode_per_print_z, don't need to check
        //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(_(L("Custom G-code")), gcode.extra);
        //        if (ret.size() == MAX_TAGS_COUNT)
        //            break;
        //    }
        //}
 
        return ret;
    }

References _, Slic3r::Print::config(), Slic3r::GCodeProcessor::contains_reserved_tags(), Slic3r::GCodeConfig, Slic3r::Print::is_BBL_printer(), L, 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: