Slic3r::GUI::CalibUtils Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/Utils/CalibUtils.hpp>

Collaboration diagram for Slic3r::GUI::CalibUtils:

Public Member Functions
	CalibUtils ()

Static Public Member Functions
static CalibMode	get_calib_mode_by_name (const std::string name, int &cali_stage)
static void	calib_PA (const X1CCalibInfos &calib_infos, int mode, wxString &error_message)
static void	emit_get_PA_calib_results (float nozzle_diameter)
static bool	get_PA_calib_results (std::vector< PACalibResult > &pa_calib_results)
static void	emit_get_PA_calib_infos (const PACalibExtruderInfo &cali_info)
static bool	get_PA_calib_tab (std::vector< PACalibResult > &pa_calib_infos)
static void	set_PA_calib_result (const std::vector< PACalibResult > &pa_calib_values, bool is_auto_cali)
static void	select_PA_calib_result (const PACalibIndexInfo &pa_calib_info)
static void	delete_PA_calib_result (const PACalibIndexInfo &pa_calib_info)
static void	calib_flowrate_X1C (const X1CCalibInfos &calib_infos, wxString &error_message)
static void	emit_get_flow_ratio_calib_results (float nozzle_diameter)
static bool	get_flow_ratio_calib_results (std::vector< FlowRatioCalibResult > &flow_ratio_calib_results)
static bool	calib_flowrate (int pass, const CalibInfo &calib_info, wxString &error_message)
static void	calib_pa_pattern (const CalibInfo &calib_info, Model &model)
static void	set_for_auto_pa_model_and_config (const std::vector< CalibInfo > &calib_info, DynamicPrintConfig &full_config, Model &model)
static bool	calib_generic_auto_pa_cali (const std::vector< CalibInfo > &calib_info, wxString &error_message)
static bool	calib_generic_PA (const CalibInfo &calib_info, wxString &error_message)
static void	calib_temptue (const CalibInfo &calib_info, wxString &error_message)
static void	calib_max_vol_speed (const CalibInfo &calib_info, wxString &error_message)
static void	calib_VFA (const CalibInfo &calib_info, wxString &error_message)
static void	calib_retraction (const CalibInfo &calib_info, wxString &error_message)
static bool	is_support_auto_pa_cali (std::string filament_id)
static int	get_selected_calib_idx (const std::vector< PACalibResult > &pa_calib_values, int cali_idx)
static bool	get_pa_k_n_value_by_cali_idx (const MachineObject *obj, int cali_idx, float &out_k, float &out_n)
static bool	validate_input_name (wxString name)
static bool	validate_input_k_value (wxString k_text, float *output_value)
static bool	validate_input_flow_ratio (wxString flow_ratio, float *output_value)
static bool	check_printable_status_before_cali (const MachineObject *obj, const X1CCalibInfos &cali_infos, wxString &error_message)
static bool	check_printable_status_before_cali (const MachineObject *obj, const CalibInfo &cali_info, wxString &error_message)
static bool	check_printable_status_before_cali (const MachineObject *obj, const std::vector< CalibInfo > &cali_infos, wxString &error_message)

Static Public Attributes
static std::unique_ptr< Worker >	print_worker

Static Private Member Functions
static bool	process_and_store_3mf (Model *model, const DynamicPrintConfig &full_config, const Calib_Params &params, wxString &error_message)
static void	send_to_print (const CalibInfo &calib_info, wxString &error_message, int flow_ratio_mode=0)
static void	send_to_print (const std::vector< CalibInfo > &calib_infos, wxString &error_message, int flow_ratio_mode=0)

Detailed Description

Constructor & Destructor Documentation

CalibUtils()

Slic3r::GUI::CalibUtils::CalibUtils ( )

inline

{};

Member Function Documentation

calib_flowrate()

bool Slic3r::GUI::CalibUtils::calib_flowrate ( int pass, const CalibInfo & calib_info, wxString & error_message )

static

— scale —

{
    DeviceManager *dev = Slic3r::GUI::wxGetApp().getDeviceManager();
    if (!dev) {
        error_message = _L("Need select printer");
        return false;
    }
 
    MachineObject *obj_ = dev->get_selected_machine();
    if (obj_ == nullptr) {
        error_message = _L("Need select printer");
        return false;
    }
 
    if (!check_printable_status_before_cali(obj_, calib_info, error_message))
        return false;
 
    if (pass != 1 && pass != 2)
        return false;
 
    Model       model;
    std::string input_file;
    if (pass == 1)
        input_file = Slic3r::resources_dir() + "/calib/filament_flow/flowrate-test-pass1.3mf";
    else
        input_file = Slic3r::resources_dir() + "/calib/filament_flow/flowrate-test-pass2.3mf";
 
    read_model_from_file(input_file, model);
 
    DynamicPrintConfig print_config    = calib_info.print_prest->config;
    DynamicPrintConfig filament_config = calib_info.filament_prest->config;
    DynamicPrintConfig printer_config  = calib_info.printer_prest->config;

    // model is created for a 0.4 nozzle, scale z with nozzle size.
    const ConfigOptionFloats *nozzle_diameter_config = printer_config.option<ConfigOptionFloats>("nozzle_diameter");
    assert(nozzle_diameter_config->values.size() > 0);
    float nozzle_diameter = nozzle_diameter_config->values[0];
    float xyScale         = nozzle_diameter / 0.6;
    // scale z to have 7 layers
    double first_layer_height = print_config.option<ConfigOptionFloat>("initial_layer_print_height")->value;
    double layer_height       = nozzle_diameter / 2.0; // prefer 0.2 layer height for 0.4 nozzle
    first_layer_height        = std::max(first_layer_height, layer_height);
 
    float zscale = (first_layer_height + 6 * layer_height) / 1.4;
    for (auto _obj : model.objects) _obj->scale(1, 1, zscale);
    // only enlarge
    //if (xyScale > 1.2) {
    //    for (auto _obj : model.objects) _obj->scale(xyScale, xyScale, zscale);
    //} else {
    //    for (auto _obj : model.objects) _obj->scale(1, 1, zscale);
    //}
 
    Flow   infill_flow                   = Flow(nozzle_diameter * 1.2f, layer_height, nozzle_diameter);
 
    int index = get_index_for_extruder_parameter(filament_config, "filament_max_volumetric_speed", calib_info.extruder_id, calib_info.extruder_type, calib_info.nozzle_volume_type);
    double filament_max_volumetric_speed = filament_config.option<ConfigOptionFloats>("filament_max_volumetric_speed")->get_at(index);
    double max_infill_speed              = filament_max_volumetric_speed / (infill_flow.mm3_per_mm() * (pass == 1 ? 1.2 : 1));
    double internal_solid_speed          = std::floor(std::min(print_config.opt_float_nullable("internal_solid_infill_speed", 0), max_infill_speed));
    double top_surface_speed             = std::floor(std::min(print_config.opt_float_nullable("top_surface_speed", 0), max_infill_speed));
 
    // adjust parameters
    filament_config.set_key_value("curr_bed_type", new ConfigOptionEnum<BedType>(calib_info.bed_type));
 
    for (auto _obj : model.objects) {
        _obj->ensure_on_bed();
        _obj->config.set_key_value("wall_loops", new ConfigOptionInt(3));
        _obj->config.set_key_value("only_one_wall_top", new ConfigOptionBool(true));
        _obj->config.set_key_value("sparse_infill_density", new ConfigOptionPercent(35));
        _obj->config.set_key_value("bottom_shell_layers", new ConfigOptionInt(1));
        _obj->config.set_key_value("top_shell_layers", new ConfigOptionInt(5));
        _obj->config.set_key_value("detect_thin_wall", new ConfigOptionBool(true));
        _obj->config.set_key_value("filter_out_gap_fill", new ConfigOptionFloat(0));  // OrcaSlicer parameter
        _obj->config.set_key_value("sparse_infill_pattern", new ConfigOptionEnum<InfillPattern>(ipRectilinear));
        _obj->config.set_key_value("top_surface_line_width", new ConfigOptionFloatOrPercent(nozzle_diameter * 1.2f, false));
        _obj->config.set_key_value("internal_solid_infill_line_width", new ConfigOptionFloatOrPercent(nozzle_diameter * 1.2f, false));
        _obj->config.set_key_value("top_surface_pattern", new ConfigOptionEnum<InfillPattern>(ipMonotonic));
        const auto *top_solid_flow = dynamic_cast<const ConfigOptionFloatsNullable *>(_obj->config.option("top_solid_infill_flow_ratio"));
        _obj->config.set_key_value("top_solid_infill_flow_ratio",
                                   new ConfigOptionFloatsNullable(top_solid_flow ? top_solid_flow->size() : 1, 1.0f));
        _obj->config.set_key_value("infill_direction", new ConfigOptionFloat(45));
        _obj->config.set_key_value("ironing_type", new ConfigOptionEnum<IroningType>(IroningType::NoIroning));
        _obj->config.set_key_value("internal_solid_infill_speed", new ConfigOptionFloatsNullable({internal_solid_speed}));
        _obj->config.set_key_value("top_surface_speed", new ConfigOptionFloatsNullable({top_surface_speed}));
 
        // extract flowrate from name, filename format: flowrate_xxx
        std::string obj_name = _obj->name;
        assert(obj_name.length() > 9);
        obj_name = obj_name.substr(9);
        if (obj_name[0] == 'm') obj_name[0] = '-';
        auto modifier = stof(obj_name);
        _obj->config.set_key_value("print_flow_ratio", new ConfigOptionFloat(1.0f + modifier / 100.f));
    }
    print_config.set_key_value("alternate_extra_wall", new ConfigOptionBool(false));
    print_config.set_key_value("layer_height", new ConfigOptionFloat(layer_height));
    print_config.set_key_value("initial_layer_print_height", new ConfigOptionFloat(first_layer_height));
    print_config.set_key_value("reduce_crossing_wall", new ConfigOptionBool(true));
 
    // apply preset
    DynamicPrintConfig full_config;
    full_config.apply(FullPrintConfig::defaults());
    full_config.apply(print_config);
    full_config.apply(filament_config);
    full_config.apply(printer_config);
 
    full_config.set_key_value("filament_ids", new ConfigOptionStrings({calib_info.filament_prest->filament_id}));
    full_config.set_key_value("enable_wrapping_detection", new ConfigOptionBool(false));
 
    init_multi_extruder_params_for_cali(full_config, calib_info);
 
    Calib_Params params;
    params.mode = CalibMode::Calib_Flow_Rate;
    if (!process_and_store_3mf(&model, full_config, params, error_message))
        return false;
 
    send_to_print(calib_info, error_message, pass);
    return true;
}

References _L, Slic3r::ConfigBase::apply(), Slic3r::GUI::CalibInfo::bed_type, Slic3r::Calib_Flow_Rate, check_printable_status_before_cali(), Slic3r::Preset::config, Slic3r::ConfigOptionFloat, Slic3r::GUI::CalibInfo::extruder_id, Slic3r::GUI::CalibInfo::extruder_type, Slic3r::Preset::filament_id, Slic3r::GUI::CalibInfo::filament_prest, Slic3r::get_index_for_extruder_parameter(), Slic3r::DeviceManager::get_selected_machine(), Slic3r::GUI::init_multi_extruder_params_for_cali(), Slic3r::ipMonotonic, Slic3r::ipRectilinear, Slic3r::GUI::layer_height, Slic3r::Flow::mm3_per_mm(), Slic3r::Calib_Params::mode, Slic3r::NoIroning, Slic3r::nozzle_diameter(), Slic3r::GUI::CalibInfo::nozzle_volume_type, Slic3r::Model::objects, Slic3r::DynamicConfig::opt_float_nullable(), Slic3r::ConfigBase::option(), Slic3r::GUI::CalibInfo::print_prest, Slic3r::GUI::printer_config(), Slic3r::GUI::CalibInfo::printer_prest, process_and_store_3mf(), Slic3r::GUI::read_model_from_file(), Slic3r::resources_dir(), send_to_print(), Slic3r::DynamicConfig::set_key_value(), and Slic3r::ConfigOptionVector< double >::values.

Referenced by Slic3r::GUI::FlowRateWizard::on_cali_start().

Here is the call graph for this function:

Here is the caller graph for this function:

calib_flowrate_X1C()

void Slic3r::GUI::CalibUtils::calib_flowrate_X1C ( const X1CCalibInfos & calib_infos, wxString & error_message )

static

{
    DeviceManager *dev = Slic3r::GUI::wxGetApp().getDeviceManager();
    if (!dev)
        return;
 
    MachineObject *obj_ = dev->get_selected_machine();
    if (obj_ == nullptr)
        return;
 
    if (calib_infos.calib_datas.size() > 0) {
         if (!check_printable_status_before_cali(obj_, calib_infos, error_message))
            return;
        obj_->command_start_flow_ratio_calibration(calib_infos);
    }
    else {
        BOOST_LOG_TRIVIAL(info) << "flow_rate_cali: auto | send info | cali_datas is empty.";
    }
}

References Slic3r::X1CCalibInfos::calib_datas, check_printable_status_before_cali(), Slic3r::MachineObject::command_start_flow_ratio_calibration(), and Slic3r::DeviceManager::get_selected_machine().

Referenced by Slic3r::GUI::FlowRateWizard::on_cali_start().

Here is the call graph for this function:

Here is the caller graph for this function:

calib_generic_auto_pa_cali()

bool Slic3r::GUI::CalibUtils::calib_generic_auto_pa_cali ( const std::vector< CalibInfo > & calib_info, wxString & error_message )

static

{
    DeviceManager *dev = Slic3r::GUI::wxGetApp().getDeviceManager();
    if (!dev) {
        error_message = _L("Need select printer");
        return false;
    }
 
    MachineObject *obj_ = dev->get_selected_machine();
    if (obj_ == nullptr) {
        error_message = _L("Need select printer");
        return false;
    }
 
    if (!check_printable_status_before_cali(obj_, calib_infos, error_message))
        return false;
 
    const Calib_Params &params = calib_infos[0].params;
    if (params.mode != CalibMode::Calib_Auto_PA_Line)
        return false;
 
    Model       model;
    std::string input_file;
    if (obj_->is_multi_extruders())
        input_file = Slic3r::resources_dir() + "/calib/pressure_advance/auto_pa_line_dual.3mf";
    else
        input_file = Slic3r::resources_dir() + "/calib/pressure_advance/auto_pa_line_single.3mf";
 
    read_model_from_file(input_file, model);
 
    DynamicPrintConfig print_config    = calib_infos[0].print_prest->config;
    DynamicPrintConfig filament_config = calib_infos[0].filament_prest->config;
    DynamicPrintConfig printer_config  = calib_infos[0].printer_prest->config;
 
    Preset printer_preset = *calib_infos[0].printer_prest;
    Preset print_preset = *calib_infos[0].print_prest;
    std::vector<Preset> filament_presets;
    std::vector<int>    filament_map;
    filament_map.resize(calib_infos.size());
    std::vector<int> physical_extruder_maps = dynamic_cast<ConfigOptionInts *>(printer_config.option("physical_extruder_map", true))->values;
    for (size_t i = 0; i < calib_infos.size(); ++i) {
        CalibInfo calib_info = calib_infos[i];
        calib_info.filament_prest->config.set_key_value("curr_bed_type", new ConfigOptionEnum<BedType>(calib_info.bed_type));
        filament_presets.emplace_back(*calib_info.filament_prest);
        for (size_t index = 0; index < physical_extruder_maps.size(); ++index) {
            if (physical_extruder_maps[index] == calib_info.extruder_id) {
                filament_map[i] = index;
                break;
            }
        }
    }
 
    PresetBundle *preset_bundle = wxGetApp().preset_bundle;
    DynamicPrintConfig full_config   = PresetBundle::construct_full_config(printer_preset, print_preset, preset_bundle->project_config, filament_presets, false, filament_map);
 
    set_for_auto_pa_model_and_config(calib_infos, full_config, model);
    if (!process_and_store_3mf(&model, full_config, params, error_message))
        return false;
 
    try {
        json js;
        if (params.mode == CalibMode::Calib_PA_Line)
            js["cali_type"] = "cali_pa_line";
        else if (params.mode == CalibMode::Calib_PA_Pattern)
            js["cali_type"] = "cali_pa_pattern";
        else if (params.mode == CalibMode::Calib_Auto_PA_Line)
            js["cali_type"] = "cali_auto_pa_line";
 
        const ConfigOptionFloats *nozzle_diameter_config = printer_config.option<ConfigOptionFloats>("nozzle_diameter");
        assert(nozzle_diameter_config->values.size() > 0);
        float nozzle_diameter = nozzle_diameter_config->values[0];
 
        js["nozzle_diameter"] = nozzle_diameter;
        std::string filament_ids;
        for (const auto& calib_info : calib_infos) {
            filament_ids += calib_info.filament_prest->filament_id;
            filament_ids += " ";
        }
        js["filament_id"]     = filament_ids;
        js["printer_type"]    = obj_->printer_type;
        NetworkAgent* agent   = GUI::wxGetApp().getAgent();
        if (agent)
            agent->track_event("cali", js.dump());
    } catch (...) {}
 
    send_to_print(calib_infos, error_message);
    return true;
}

References _L, Slic3r::GUI::CalibInfo::bed_type, Slic3r::Calib_Auto_PA_Line, Slic3r::Calib_PA_Line, Slic3r::Calib_PA_Pattern, check_printable_status_before_cali(), Slic3r::Preset::config, Slic3r::PresetBundle::construct_full_config(), Slic3r::GUI::CalibInfo::extruder_id, Slic3r::filament_ids(), Slic3r::filament_map(), Slic3r::GUI::CalibInfo::filament_prest, Slic3r::DeviceManager::get_selected_machine(), Slic3r::MachineObject::is_multi_extruders(), Slic3r::Calib_Params::mode, Slic3r::nozzle_diameter(), Slic3r::GUI::printer_config(), Slic3r::MachineObject::printer_type, process_and_store_3mf(), Slic3r::PresetBundle::project_config, Slic3r::GUI::read_model_from_file(), Slic3r::resources_dir(), send_to_print(), set_for_auto_pa_model_and_config(), Slic3r::DynamicConfig::set_key_value(), Slic3r::NetworkAgent::track_event(), and Slic3r::ConfigOptionVector< double >::values.

Referenced by Slic3r::GUI::PressureAdvanceWizard::on_cali_start().

Here is the call graph for this function:

Here is the caller graph for this function:

calib_generic_PA()

bool Slic3r::GUI::CalibUtils::calib_generic_PA ( const CalibInfo & calib_info, wxString & error_message )

static

{
    DeviceManager *dev = Slic3r::GUI::wxGetApp().getDeviceManager();
    if (!dev) {
        error_message = _L("Need select printer");
        return false;
    }
 
    MachineObject *obj_ = dev->get_selected_machine();
    if (obj_ == nullptr) {
        error_message = _L("Need select printer");
        return false;
    }
 
    if (!check_printable_status_before_cali(obj_, calib_info, error_message))
        return false;
 
    const Calib_Params &params = calib_info.params;
    if (params.mode != CalibMode::Calib_PA_Line && params.mode != CalibMode::Calib_PA_Pattern)
        return false;
 
    Model model;
    std::string input_file;
    if (params.mode == CalibMode::Calib_PA_Line)
        input_file = Slic3r::resources_dir() + "/calib/pressure_advance/pressure_advance_test.drc";
    else if (params.mode == CalibMode::Calib_PA_Pattern)
        input_file = Slic3r::resources_dir() + "/calib/pressure_advance/pa_pattern.3mf";
 
    read_model_from_file(input_file, model);
 
    if (params.mode == CalibMode::Calib_PA_Pattern)
        calib_pa_pattern(calib_info, model);
 
    DynamicPrintConfig print_config    = calib_info.print_prest->config;
    print_config.set_key_value("wipe_inward", new ConfigOptionBool(false));
    DynamicPrintConfig filament_config = calib_info.filament_prest->config;
    DynamicPrintConfig printer_config  = calib_info.printer_prest->config;
 
    filament_config.set_key_value("curr_bed_type", new ConfigOptionEnum<BedType>(calib_info.bed_type));
 
    DynamicPrintConfig full_config;
    full_config.apply(FullPrintConfig::defaults());
    full_config.apply(print_config);
    full_config.apply(filament_config);
    full_config.apply(printer_config);
 
    full_config.set_key_value("filament_ids", new ConfigOptionStrings({calib_info.filament_prest->filament_id}));
    full_config.set_key_value("enable_wrapping_detection", new ConfigOptionBool(false));
 
    init_multi_extruder_params_for_cali(full_config, calib_info);
 
    if (!process_and_store_3mf(&model, full_config, params, error_message))
        return false;
 
    send_to_print(calib_info, error_message);
    return true;
}

References _L, Slic3r::ConfigBase::apply(), Slic3r::GUI::CalibInfo::bed_type, Slic3r::Calib_PA_Line, Slic3r::Calib_PA_Pattern, calib_pa_pattern(), check_printable_status_before_cali(), Slic3r::Preset::config, Slic3r::Preset::filament_id, Slic3r::GUI::CalibInfo::filament_prest, Slic3r::DeviceManager::get_selected_machine(), Slic3r::GUI::init_multi_extruder_params_for_cali(), Slic3r::Calib_Params::mode, Slic3r::GUI::CalibInfo::params, Slic3r::GUI::CalibInfo::print_prest, Slic3r::GUI::printer_config(), Slic3r::GUI::CalibInfo::printer_prest, process_and_store_3mf(), Slic3r::GUI::read_model_from_file(), Slic3r::resources_dir(), send_to_print(), and Slic3r::DynamicConfig::set_key_value().

Referenced by Slic3r::GUI::PressureAdvanceWizard::on_cali_start().

Here is the call graph for this function:

Here is the caller graph for this function:

calib_max_vol_speed()

void Slic3r::GUI::CalibUtils::calib_max_vol_speed ( const CalibInfo & calib_info, wxString & error_message )

static

{
    const Calib_Params &params = calib_info.params;
    if (params.mode != CalibMode::Calib_Vol_speed_Tower)
        return;
 
    Model       model;
    std::string input_file = Slic3r::resources_dir() + "/calib/volumetric_speed/SpeedTestStructure.drc";
    read_model_from_file(input_file, model);
 
    DynamicPrintConfig print_config    = calib_info.print_prest->config;
    DynamicPrintConfig filament_config = calib_info.filament_prest->config;
    DynamicPrintConfig printer_config  = calib_info.printer_prest->config;
 
    auto obj             = model.objects[0];
    auto         bed_shape = printer_config.option<ConfigOptionPoints>("printable_area")->values;
    BoundingBoxf bed_ext   = get_extents(bed_shape);
    auto         scale_obj = (bed_ext.size().x() - 10) / obj->bounding_box_exact().size().x();
    if (scale_obj < 1.0)
        obj->scale(scale_obj, 1, 1);
 
    const ConfigOptionFloats *nozzle_diameter_config = printer_config.option<ConfigOptionFloats>("nozzle_diameter");
    assert(nozzle_diameter_config->values.size() > 0);
    double nozzle_diameter = nozzle_diameter_config->values[0];
    double line_width      = nozzle_diameter * 1.75;
    double layer_height    = nozzle_diameter * 0.8;
 
    auto max_lh = printer_config.option<ConfigOptionFloats>("max_layer_height");
    if (max_lh->values[0] < layer_height) max_lh->values[0] = {layer_height};
 
    filament_config.set_key_value("filament_max_volumetric_speed", new ConfigOptionFloats{50});
    filament_config.set_key_value("slow_down_layer_time", new ConfigOptionInts{0});
    filament_config.set_key_value("curr_bed_type", new ConfigOptionEnum<BedType>(calib_info.bed_type));
 
    print_config.set_key_value("enable_overhang_speed", new ConfigOptionBoolsNullable({false}));
    print_config.set_key_value("timelapse_type", new ConfigOptionEnum<TimelapseType>(tlTraditional));
    print_config.set_key_value("wall_loops", new ConfigOptionInt(1));
    print_config.set_key_value("alternate_extra_wall", new ConfigOptionBool(false));
    print_config.set_key_value("top_shell_layers", new ConfigOptionInt(0));
    print_config.set_key_value("bottom_shell_layers", new ConfigOptionInt(1));
    print_config.set_key_value("sparse_infill_density", new ConfigOptionPercent(0));
    print_config.set_key_value("overhang_reverse", new ConfigOptionBool(false));
    print_config.set_key_value("spiral_mode", new ConfigOptionBool(true));
    print_config.set_key_value("outer_wall_line_width", new ConfigOptionFloat(line_width));
    print_config.set_key_value("initial_layer_print_height", new ConfigOptionFloat(layer_height));
    print_config.set_key_value("layer_height", new ConfigOptionFloat(layer_height));
    obj->config.set_key_value("brim_type", new ConfigOptionEnum<BrimType>(btOuterAndInner));
    obj->config.set_key_value("brim_width", new ConfigOptionFloat(3.0));
    obj->config.set_key_value("brim_object_gap", new ConfigOptionFloat(0.0));
 
    //  cut upper
    auto obj_bb = obj->bounding_box_exact();
    double height = (params.end - params.start + 1) / params.step;
    if (height < obj_bb.size().z()) {
        cut_model(model, height, ModelObjectCutAttribute::KeepLower);
    }
 
    auto new_params  = params;
    auto mm3_per_mm  = Flow(line_width, layer_height, nozzle_diameter).mm3_per_mm() * filament_config.option<ConfigOptionFloatsNullable>("filament_flow_ratio")->get_at(0);
    new_params.end   = params.end / mm3_per_mm;
    new_params.start = params.start / mm3_per_mm;
    new_params.step  = params.step / mm3_per_mm;
 
    DynamicPrintConfig full_config;
    full_config.apply(FullPrintConfig::defaults());
    full_config.apply(print_config);
    full_config.apply(filament_config);
    full_config.apply(printer_config);
 
    init_multi_extruder_params_for_cali(full_config, calib_info);
 
    process_and_store_3mf(&model, full_config, new_params, error_message);
    if (!error_message.empty())
        return;
 
    send_to_print(calib_info, error_message);
}

References Slic3r::ConfigBase::apply(), Slic3r::GUI::CalibInfo::bed_type, Slic3r::btOuterAndInner, Slic3r::Calib_Vol_speed_Tower, Slic3r::Preset::config, Slic3r::ConfigOptionFloat, Slic3r::GUI::cut_model(), Slic3r::Calib_Params::end, Slic3r::GUI::CalibInfo::filament_prest, Slic3r::get_extents(), Slic3r::GUI::init_multi_extruder_params_for_cali(), Slic3r::KeepLower, Slic3r::GUI::layer_height, Slic3r::Flow::mm3_per_mm(), Slic3r::Calib_Params::mode, Slic3r::nozzle_diameter(), Slic3r::Model::objects, Slic3r::ConfigBase::option(), Slic3r::GUI::CalibInfo::params, Slic3r::GUI::CalibInfo::print_prest, Slic3r::GUI::printer_config(), Slic3r::GUI::CalibInfo::printer_prest, process_and_store_3mf(), Slic3r::GUI::read_model_from_file(), Slic3r::resources_dir(), send_to_print(), Slic3r::DynamicConfig::set_key_value(), Slic3r::Calib_Params::start, Slic3r::Calib_Params::step, Slic3r::tlTraditional, and Slic3r::ConfigOptionVector< double >::values.

Referenced by Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_start().

Here is the call graph for this function:

Here is the caller graph for this function:

calib_PA()

void Slic3r::GUI::CalibUtils::calib_PA ( const X1CCalibInfos & calib_infos, int mode, wxString & error_message )

static

{
    DeviceManager *dev = Slic3r::GUI::wxGetApp().getDeviceManager();
    if (!dev)
        return;
 
    MachineObject *obj_ = dev->get_selected_machine();
    if (obj_ == nullptr)
        return;
 
    if (calib_infos.calib_datas.size() > 0) {
        if (!check_printable_status_before_cali(obj_, calib_infos, error_message))
            return;
        obj_->command_start_pa_calibration(calib_infos, mode);
    }
}

References Slic3r::X1CCalibInfos::calib_datas, check_printable_status_before_cali(), Slic3r::MachineObject::command_start_pa_calibration(), and Slic3r::DeviceManager::get_selected_machine().

Referenced by Slic3r::GUI::PressureAdvanceWizard::on_cali_start().

Here is the call graph for this function:

Here is the caller graph for this function:

calib_pa_pattern()

void Slic3r::GUI::CalibUtils::calib_pa_pattern ( const CalibInfo & calib_info, Model & model )

static

{
    DynamicPrintConfig& print_config    = calib_info.print_prest->config;
    DynamicPrintConfig& filament_config = calib_info.filament_prest->config;
    DynamicPrintConfig& printer_config  = calib_info.printer_prest->config;
 
    DynamicPrintConfig full_config;
    full_config.apply(FullPrintConfig::defaults());
    full_config.apply(print_config);
    full_config.apply(filament_config);
    full_config.apply(printer_config);
    const auto& config_pattern = SuggestedConfigCalibPAPattern();
 
    float nozzle_diameter = printer_config.option<ConfigOptionFloats>("nozzle_diameter")->get_at(0);
 
    for (const auto& opt : config_pattern.floats_pairs) {
        print_config.set_key_value(opt.first, new ConfigOptionFloatsNullable(opt.second));
    }
 
    int index = get_index_for_extruder_parameter(print_config, "outer_wall_speed", calib_info.extruder_id, calib_info.extruder_type, calib_info.nozzle_volume_type);
    float wall_speed = CalibPressureAdvance::find_optimal_PA_speed(full_config, print_config.get_abs_value("line_width"), print_config.get_abs_value("layer_height"), calib_info.extruder_id, 0);
    ConfigOptionFloatsNullable *wall_speed_speed_opt = print_config.option<ConfigOptionFloatsNullable>("outer_wall_speed");
    wall_speed_speed_opt->values[index]              = wall_speed;
 
    for (const auto& opt : config_pattern.nozzle_ratio_pairs) {
        print_config.set_key_value(opt.first, new ConfigOptionFloatOrPercent(nozzle_diameter * opt.second / 100, false));
    }
 
    for (const auto& opt : config_pattern.int_pairs) {
        print_config.set_key_value(opt.first, new ConfigOptionInt(opt.second));
    }
 
    print_config.set_key_value(config_pattern.brim_pair.first,
        new ConfigOptionEnum<BrimType>(config_pattern.brim_pair.second));
 
    //DynamicPrintConfig full_config;
    full_config.apply(FullPrintConfig::defaults());
    full_config.apply(print_config);
    full_config.apply(filament_config);
    full_config.apply(printer_config);
 
    Vec3d plate_origin(0, 0, 0);
    auto *object = model.objects[0];
    CalibPressureAdvancePattern pa_pattern(calib_info.params, full_config, true, *object, plate_origin);
 
    Pointfs bedfs         = full_config.opt<ConfigOptionPoints>("printable_area")->values;
    double  current_width = bedfs[2].x() - bedfs[0].x();
    double  current_depth = bedfs[2].y() - bedfs[0].y();
    Vec3d   half_pattern_size = Vec3d(pa_pattern.print_size_x() / 2, pa_pattern.print_size_y() / 2, 0);
    Vec3d   offset            = Vec3d(current_width / 2, current_depth / 2, 0) - half_pattern_size;
    pa_pattern.set_start_offset(offset);
 
    model.plates_custom_gcodes[0] = pa_pattern.generate_custom_gcodes(full_config, true, *object, plate_origin);
    model.calib_pa_pattern = std::make_unique<CalibPressureAdvancePattern>(pa_pattern);
}

References Slic3r::ConfigBase::apply(), Slic3r::Model::calib_pa_pattern, Slic3r::Preset::config, Slic3r::GUI::CalibInfo::extruder_id, Slic3r::GUI::CalibInfo::extruder_type, Slic3r::GUI::CalibInfo::filament_prest, Slic3r::CalibPressureAdvance::find_optimal_PA_speed(), Slic3r::CalibPressureAdvancePattern::generate_custom_gcodes(), Slic3r::ConfigBase::get_abs_value(), Slic3r::get_index_for_extruder_parameter(), Slic3r::nozzle_diameter(), Slic3r::GUI::CalibInfo::nozzle_volume_type, Slic3r::Model::objects, Slic3r::offset(), Slic3r::DynamicConfig::opt(), Slic3r::ConfigBase::option(), Slic3r::GUI::CalibInfo::params, Slic3r::Model::plates_custom_gcodes, Slic3r::GUI::CalibInfo::print_prest, Slic3r::CalibPressureAdvancePattern::print_size_x(), Slic3r::CalibPressureAdvancePattern::print_size_y(), Slic3r::GUI::printer_config(), Slic3r::GUI::CalibInfo::printer_prest, Slic3r::DynamicConfig::set_key_value(), Slic3r::CalibPressureAdvancePattern::set_start_offset(), and Slic3r::ConfigOptionVector< double >::values.

Referenced by calib_generic_PA().

Here is the call graph for this function:

Here is the caller graph for this function:

calib_retraction()

void Slic3r::GUI::CalibUtils::calib_retraction ( const CalibInfo & calib_info, wxString & error_message )

static

{
    const Calib_Params &params = calib_info.params;
    if (params.mode != CalibMode::Calib_Retraction_tower)
        return;
 
    Model model;
    std::string input_file = Slic3r::resources_dir() + "/calib/retraction/retraction_tower.drc";
    read_model_from_file(input_file, model);
 
    DynamicPrintConfig print_config    = calib_info.print_prest->config;
    print_config.set_key_value("wipe_inward", new ConfigOptionBool(false));
    DynamicPrintConfig filament_config = calib_info.filament_prest->config;
    DynamicPrintConfig printer_config  = calib_info.printer_prest->config;
 
    auto obj = model.objects[0];
 
    double layer_height = 0.2;
 
    auto max_lh = printer_config.option<ConfigOptionFloats>("max_layer_height");
    if (max_lh->values[0] < layer_height) max_lh->values[0] = {layer_height};
 
    filament_config.set_key_value("curr_bed_type", new ConfigOptionEnum<BedType>(calib_info.bed_type));
 
    obj->config.set_key_value("wall_loops", new ConfigOptionInt(2));
    obj->config.set_key_value("alternate_extra_wall", new ConfigOptionBool(false));
    obj->config.set_key_value("top_shell_layers", new ConfigOptionInt(0));
    obj->config.set_key_value("bottom_shell_layers", new ConfigOptionInt(3));
    obj->config.set_key_value("sparse_infill_density", new ConfigOptionPercent(0));
    obj->config.set_key_value("initial_layer_print_height", new ConfigOptionFloat(layer_height));
    obj->config.set_key_value("layer_height", new ConfigOptionFloat(layer_height));
 
    //  cut upper
    auto obj_bb = obj->bounding_box_exact();
    auto height = 1.0 + 0.4 + ((params.end - params.start)) / params.step;
    if (height < obj_bb.size().z()) {
        cut_model(model, height, ModelObjectCutAttribute::KeepLower);
    }
 
    DynamicPrintConfig full_config;
    full_config.apply(FullPrintConfig::defaults());
    full_config.apply(print_config);
    full_config.apply(filament_config);
    full_config.apply(printer_config);
 
    init_multi_extruder_params_for_cali(full_config, calib_info);
 
    process_and_store_3mf(&model, full_config, params, error_message);
    if (!error_message.empty())
        return;
 
    send_to_print(calib_info, error_message);
}

References Slic3r::ConfigBase::apply(), Slic3r::GUI::CalibInfo::bed_type, Slic3r::Calib_Retraction_tower, Slic3r::Preset::config, Slic3r::ConfigOptionFloat, Slic3r::GUI::cut_model(), Slic3r::Calib_Params::end, Slic3r::GUI::CalibInfo::filament_prest, Slic3r::GUI::init_multi_extruder_params_for_cali(), Slic3r::KeepLower, Slic3r::GUI::layer_height, Slic3r::Calib_Params::mode, Slic3r::Model::objects, Slic3r::GUI::CalibInfo::params, Slic3r::GUI::CalibInfo::print_prest, Slic3r::GUI::printer_config(), Slic3r::GUI::CalibInfo::printer_prest, process_and_store_3mf(), Slic3r::GUI::read_model_from_file(), Slic3r::resources_dir(), send_to_print(), Slic3r::DynamicConfig::set_key_value(), Slic3r::Calib_Params::start, and Slic3r::Calib_Params::step.

Here is the call graph for this function:

calib_temptue()

void Slic3r::GUI::CalibUtils::calib_temptue ( const CalibInfo & calib_info, wxString & error_message )

static

{
    const Calib_Params &params = calib_info.params;
    if (params.mode != CalibMode::Calib_Temp_Tower)
        return;
 
    Model                     model;
    std::string               input_file = Slic3r::resources_dir() + "/calib/temperature_tower/temperature_tower.stl";
    read_model_from_file(input_file, model);
 
    // cut upper
    auto obj_bb      = model.objects[0]->bounding_box_exact();
    auto block_count = lround((350 - params.start) / 5 + 1);
    if (block_count > 0) {
        // add EPSILON offset to avoid cutting at the exact location where the flat surface is
        auto new_height = block_count * 10.0 + EPSILON;
        if (new_height < obj_bb.size().z()) {
            cut_model(model, new_height, ModelObjectCutAttribute::KeepLower);
        }
    }
 
    // cut bottom
    obj_bb      = model.objects[0]->bounding_box_exact();
    block_count = lround((350 - params.end) / 5);
    if (block_count > 0) {
        auto new_height = block_count * 10.0 + EPSILON;
        if (new_height < obj_bb.size().z()) {
            cut_model(model, new_height, ModelObjectCutAttribute::KeepUpper);
        }
    }
 
    // edit preset
    DynamicPrintConfig print_config    = calib_info.print_prest->config;
    DynamicPrintConfig filament_config = calib_info.filament_prest->config;
    DynamicPrintConfig printer_config  = calib_info.printer_prest->config;
 
    auto start_temp      = lround(params.start);
    filament_config.set_key_value("nozzle_temperature_initial_layer", new ConfigOptionInts(1, (int) start_temp));
    filament_config.set_key_value("nozzle_temperature", new ConfigOptionInts(1, (int) start_temp));
    filament_config.set_key_value("curr_bed_type", new ConfigOptionEnum<BedType>(calib_info.bed_type));
 
    model.objects[0]->config.set_key_value("brim_type", new ConfigOptionEnum<BrimType>(btOuterOnly));
    model.objects[0]->config.set_key_value("brim_width", new ConfigOptionFloat(5.0));
    model.objects[0]->config.set_key_value("brim_object_gap", new ConfigOptionFloat(0.0));
    model.objects[0]->config.set_key_value("enable_support", new ConfigOptionBool(false));
 
    // apply preset
    DynamicPrintConfig full_config;
    full_config.apply(FullPrintConfig::defaults());
    full_config.apply(print_config);
    full_config.apply(filament_config);
    full_config.apply(printer_config);
 
    init_multi_extruder_params_for_cali(full_config, calib_info);
 
    process_and_store_3mf(&model, full_config, params, error_message);
    if (!error_message.empty())
        return;
 
    send_to_print(calib_info, error_message);
}

References Slic3r::ConfigBase::apply(), Slic3r::GUI::CalibInfo::bed_type, Slic3r::btOuterOnly, Slic3r::Calib_Temp_Tower, Slic3r::Preset::config, Slic3r::ConfigOptionFloat, Slic3r::GUI::cut_model(), Slic3r::Calib_Params::end, EPSILON, Slic3r::GUI::CalibInfo::filament_prest, Slic3r::GUI::init_multi_extruder_params_for_cali(), Slic3r::KeepLower, Slic3r::KeepUpper, Slic3r::Calib_Params::mode, Slic3r::Model::objects, Slic3r::GUI::CalibInfo::params, Slic3r::GUI::CalibInfo::print_prest, Slic3r::GUI::printer_config(), Slic3r::GUI::CalibInfo::printer_prest, process_and_store_3mf(), Slic3r::GUI::read_model_from_file(), Slic3r::resources_dir(), send_to_print(), Slic3r::DynamicConfig::set_key_value(), and Slic3r::Calib_Params::start.

Here is the call graph for this function:

calib_VFA()

void Slic3r::GUI::CalibUtils::calib_VFA ( const CalibInfo & calib_info, wxString & error_message )

static

{
    const Calib_Params &params = calib_info.params;
    if (params.mode != CalibMode::Calib_VFA_Tower)
        return;
 
    Model model;
    std::string input_file = Slic3r::resources_dir() + "/calib/vfa/vfa.drc";
    read_model_from_file(input_file, model);
 
    DynamicPrintConfig print_config    = calib_info.print_prest->config;
    DynamicPrintConfig filament_config = calib_info.filament_prest->config;
    DynamicPrintConfig printer_config  = calib_info.printer_prest->config;
 
    const ConfigOptionFloats* nozzle_diameter_config = printer_config.option<ConfigOptionFloats>("nozzle_diameter");
    size_t nozzle_id = static_cast<size_t>(std::max(params.extruder_id, 0));
    double nozzle_diameter = vfa_base_nozzle_diameter;
    if (nozzle_diameter_config && !nozzle_diameter_config->values.empty()) {
        nozzle_id = std::min(nozzle_id, nozzle_diameter_config->values.size() - 1);
        nozzle_diameter = nozzle_diameter_config->values[nozzle_id];
    }
    if (nozzle_diameter <= 0.0)
        nozzle_diameter = vfa_base_nozzle_diameter;
 
    // Resolved layer height: use the (possibly auto-adjusted) value if provided, else default to nozzle/2.
    double layer_height = params.vfa_layer_height > 0.0 ? params.vfa_layer_height : nozzle_diameter / 2.0;
 
    filament_config.set_key_value("slow_down_layer_time", new ConfigOptionInts{0});
    filament_config.set_key_value("filament_max_volumetric_speed", new ConfigOptionFloats{200});
    filament_config.set_key_value("curr_bed_type", new ConfigOptionEnum<BedType>(calib_info.bed_type));
 
    print_config.set_key_value("enable_overhang_speed", new ConfigOptionBoolsNullable({false}));
    print_config.set_key_value("timelapse_type", new ConfigOptionEnum<TimelapseType>(tlTraditional));
    print_config.set_key_value("wall_loops", new ConfigOptionInt(1));
    print_config.set_key_value("detect_thin_wall", new ConfigOptionBool(false));
    print_config.set_key_value("alternate_extra_wall", new ConfigOptionBool(false));
    print_config.set_key_value("detect_thin_wall", new ConfigOptionBool(false));
    print_config.set_key_value("top_shell_layers", new ConfigOptionInt(0));
    print_config.set_key_value("bottom_shell_layers", new ConfigOptionInt(1));
    print_config.set_key_value("sparse_infill_density", new ConfigOptionPercent(0));
    print_config.set_key_value("overhang_reverse", new ConfigOptionBool(false));
    print_config.set_key_value("spiral_mode", new ConfigOptionBool(true));
    print_config.set_key_value("initial_layer_print_height", new ConfigOptionFloat(layer_height));
    model.objects[0]->config.set_key_value("layer_height", new ConfigOptionFloat(layer_height));
    model.objects[0]->config.set_key_value("brim_type", new ConfigOptionEnum<BrimType>(btOuterOnly));
    model.objects[0]->config.set_key_value("brim_width", new ConfigOptionFloat(3.0));
    model.objects[0]->config.set_key_value("brim_object_gap", new ConfigOptionFloat(0.0));
 
    // cut upper (on the unscaled model, using the base block height); the scaling below keeps the physical
    // block height (vfa_layers_per_block * layer_height) in sync with the speed stepping in GCode::process_layer.
    // Subtract EPSILON (as the temperature tower does) so the cut lands just below the flat block surface instead
    // of exactly on it, which would otherwise add a degenerate extra layer.
    auto obj_bb = model.objects[0]->bounding_box_exact();
    auto height = vfa_base_block_height * ((params.end - params.start) / params.step + 1) - EPSILON;
    if (height < obj_bb.size().z()) {
        cut_model(model, height, ModelObjectCutAttribute::KeepLower);
    }
    else {
        error_message = _L("The start, end or step is not valid value.");
        return;
    }
 
    // XY scales with the nozzle; Z scales so each base block becomes vfa_layers_per_block layers of layer_height.
    const double xy_scale = nozzle_diameter / vfa_base_nozzle_diameter;
    const double z_scale  = (vfa_layers_per_block * layer_height) / vfa_base_block_height;
    if (std::abs(xy_scale - 1.0) > EPSILON || std::abs(z_scale - 1.0) > EPSILON)
        model.objects[0]->scale(xy_scale, xy_scale, z_scale);
    model.objects[0]->ensure_on_bed();
 
    DynamicPrintConfig full_config;
    full_config.apply(FullPrintConfig::defaults());
    full_config.apply(print_config);
    full_config.apply(filament_config);
    full_config.apply(printer_config);
 
    init_multi_extruder_params_for_cali(full_config, calib_info);
 
    // Pass the resolved layer height on so the GCode speed stepping matches the geometry.
    Calib_Params store_params = params;
    store_params.vfa_layer_height = layer_height;
    process_and_store_3mf(&model, full_config, store_params, error_message);
    if (!error_message.empty())
        return;
 
    send_to_print(calib_info, error_message);
}

References _L, Slic3r::ConfigBase::apply(), Slic3r::GUI::CalibInfo::bed_type, Slic3r::btOuterOnly, Slic3r::Calib_VFA_Tower, Slic3r::Preset::config, Slic3r::ConfigOptionFloat, Slic3r::GUI::cut_model(), Slic3r::Calib_Params::end, EPSILON, Slic3r::Calib_Params::extruder_id, Slic3r::GUI::CalibInfo::filament_prest, Slic3r::GUI::init_multi_extruder_params_for_cali(), Slic3r::KeepLower, Slic3r::GUI::layer_height, Slic3r::Calib_Params::mode, Slic3r::nozzle_diameter(), Slic3r::Model::objects, Slic3r::GUI::CalibInfo::params, Slic3r::GUI::CalibInfo::print_prest, Slic3r::GUI::printer_config(), Slic3r::GUI::CalibInfo::printer_prest, process_and_store_3mf(), Slic3r::GUI::read_model_from_file(), Slic3r::resources_dir(), send_to_print(), Slic3r::DynamicConfig::set_key_value(), Slic3r::Calib_Params::start, Slic3r::Calib_Params::step, Slic3r::tlTraditional, Slic3r::ConfigOptionVector< double >::values, Slic3r::vfa_base_block_height, Slic3r::vfa_base_nozzle_diameter, Slic3r::Calib_Params::vfa_layer_height, and Slic3r::vfa_layers_per_block.

Here is the call graph for this function:

check_printable_status_before_cali() [1/3]

bool Slic3r::GUI::CalibUtils::check_printable_status_before_cali ( const MachineObject * obj, const CalibInfo & cali_info, wxString & error_message )

static

{
    return check_printable_status_before_cali(obj, std::vector<CalibInfo>{cali_info}, error_message);
}

References check_printable_status_before_cali().

Here is the call graph for this function:

check_printable_status_before_cali() [2/3]

bool Slic3r::GUI::CalibUtils::check_printable_status_before_cali ( const MachineObject * obj, const std::vector< CalibInfo > & cali_infos, wxString & error_message )

static

{
    if (!obj) {
        error_message = _L("Need select printer");
        return false;
    }
 
    if (cali_infos.empty())
        return true;
 
    bool is_multi_extruder = obj->is_multi_extruders();
 
    for (const auto &cali_info : cali_infos) {
        wxString name = "";
        if (is_multi_extruder) { name = cali_info.extruder_id == MAIN_EXTRUDER_ID ? _L("right") : _L("left"); }
 
        if (cali_info.params.mode == CalibMode::Calib_Auto_PA_Line && !is_support_auto_pa_cali(cali_info.filament_prest->filament_id)) {
            error_message = _L("TPU 90A/TPU 85A is too soft and does not support automatic Flow Dynamics calibration.");
            return false;
        }
 
 
        if (is_approx(double(cali_info.nozzle_diameter), 0.2) && !obj->is_series_x()) {
            error_message = wxString::Format(_L("The nozzle diameter of %s extruder is 0.2mm which does not support automatic Flow Dynamics calibration."), name);
            return false;
        }
 
        float cali_diameter = cali_info.nozzle_diameter;
        int   extruder_id   = cali_info.extruder_id;
        if (extruder_id >= obj->GetExtderSystem()->GetTotalExtderSize()) {
            error_message = _L("The number of printer extruders and the printer selected for calibration does not match.");
            return false;
        }
 
        if (!obj->GetExtderSystem()->NozzleDiameterMatchesOrUnknown(extruder_id, cali_info.nozzle_diameter)) {
            if (is_multi_extruder)
                error_message = wxString::Format(_L("The currently selected nozzle diameter of %s extruder does not match the actual nozzle diameter.\n"
                                                    "Please click the Sync button above and restart the calibration."), name);
            else
                error_message = _L("The nozzle diameter does not match the actual printer nozzle diameter.\n"
                                   "Please click the Sync button above and restart the calibration.");
            return false;
        }
 
                
        NozzleFlowType nozzle_volume_type = obj->GetExtderSystem()->GetNozzleFlowType(extruder_id);
        
        if (nozzle_volume_type == NozzleFlowType::NONE_FLOWTYPE) {
            if (is_multi_extruder)
                error_message = wxString::Format(_L("Printer %s nozzle information has not been set. Please configure it before proceeding with the calibration."), name);
            else
                error_message = nozzle_not_set_text;
            return false;
        }
 
        if (NozzleVolumeType(nozzle_volume_type - 1) != cali_info.nozzle_volume_type) {
            if (is_multi_extruder)
                error_message = wxString::Format(_L("The currently selected nozzle type of %s extruder does not match the actual printer nozzle type.\n"
                                                "Please click the Sync button above and restart the calibration."), name);
            else
                error_message = nozzle_volume_type_not_match_text;
            return false;
        }
    }
 
    return true;
}

References _L, Slic3r::Calib_Auto_PA_Line, Slic3r::MachineObject::GetExtderSystem(), Slic3r::DevExtderSystem::GetNozzleFlowType(), Slic3r::DevExtderSystem::GetTotalExtderSize(), Slic3r::is_approx(), Slic3r::MachineObject::is_multi_extruders(), Slic3r::MachineObject::is_series_x(), is_support_auto_pa_cali(), MAIN_EXTRUDER_ID, Slic3r::NONE_FLOWTYPE, Slic3r::GUI::nozzle_not_set_text, Slic3r::nozzle_volume_type(), Slic3r::GUI::nozzle_volume_type_not_match_text, and Slic3r::DevExtderSystem::NozzleDiameterMatchesOrUnknown().

Here is the call graph for this function:

check_printable_status_before_cali() [3/3]

bool Slic3r::GUI::CalibUtils::check_printable_status_before_cali ( const MachineObject * obj, const X1CCalibInfos & cali_infos, wxString & error_message )

static

{
    if (!obj) {
        error_message = _L("Need select printer");
        return false;
    }
 
    for (const auto& cali_info : cali_infos.calib_datas) {
        if (cali_infos.cali_mode == CalibMode::Calib_PA_Line && !is_support_auto_pa_cali(cali_info.filament_id)) {
            error_message = _L("TPU 90A/TPU 85A is too soft and does not support automatic Flow Dynamics calibration.");
            return false;
        }
    }
 
    bool  is_multi_extruder = obj->is_multi_extruders();
 
    for (const auto &cali_info : cali_infos.calib_datas) {
        wxString name = "";
        if (is_multi_extruder) { name = cali_info.extruder_id == MAIN_EXTRUDER_ID ? _L("right") : _L("left"); }
 
        float cali_diameter = cali_info.nozzle_diameter;
        int   extruder_id   = cali_info.extruder_id;
        if (extruder_id >= obj->GetExtderSystem()->GetTotalExtderSize()) {
            error_message = _L("The number of printer extruders and the printer selected for calibration does not match.");
            return false;
        }
 
 
        if (is_approx(double(cali_info.nozzle_diameter), 0.2) && !obj->is_series_x()) {
            // TRN %s is "left" or "right".
            error_message = wxString::Format(_L("The nozzle diameter of %s extruder is 0.2mm which does not support automatic Flow Dynamics calibration."), name);
            return false;
        }
 
        
        NozzleFlowType nozzle_volume_type = obj->GetExtderSystem()->GetNozzleFlowType(extruder_id);
        if (!obj->GetExtderSystem()->NozzleDiameterMatchesOrUnknown(extruder_id, cali_info.nozzle_diameter)) {
            if (is_multi_extruder)
                // TRN %s is "left" or "right".
                error_message = wxString::Format(_L("The currently selected nozzle diameter of %s extruder does not match the actual nozzle diameter.\n"
                               "Please click the Sync button above and restart the calibration."), name);
            else
                error_message = _L("The nozzle diameter does not match the actual printer nozzle diameter.\n"
                               "Please click the Sync button above and restart the calibration.");
            return false;
        }
 
        if (nozzle_volume_type == NozzleFlowType::NONE_FLOWTYPE) {
            if (is_multi_extruder)
                // TRN %s is "left" or "right".
                error_message = wxString::Format(_L("Printer %s nozzle information has not been set. Please configure it before proceeding with the calibration."), name);
            else
                error_message = nozzle_not_set_text;
            return false;
        }
 
        if (NozzleVolumeType(nozzle_volume_type - 1) != cali_info.nozzle_volume_type) {
            if (is_multi_extruder)
                // TRN %s is "left" or "right".
                error_message = wxString::Format(_L("The currently selected nozzle type of %s extruder does not match the actual printer nozzle type.\n"
                                                "Please click the Sync button above and restart the calibration."), name);
            else
                error_message = nozzle_volume_type_not_match_text;
            return false;
        }
    }
    return true;
}

References _L, Slic3r::X1CCalibInfos::cali_mode, Slic3r::X1CCalibInfos::calib_datas, Slic3r::Calib_PA_Line, Slic3r::MachineObject::GetExtderSystem(), Slic3r::DevExtderSystem::GetNozzleFlowType(), Slic3r::DevExtderSystem::GetTotalExtderSize(), Slic3r::is_approx(), Slic3r::MachineObject::is_multi_extruders(), Slic3r::MachineObject::is_series_x(), is_support_auto_pa_cali(), MAIN_EXTRUDER_ID, Slic3r::NONE_FLOWTYPE, Slic3r::GUI::nozzle_not_set_text, Slic3r::nozzle_volume_type(), Slic3r::GUI::nozzle_volume_type_not_match_text, and Slic3r::DevExtderSystem::NozzleDiameterMatchesOrUnknown().

Referenced by calib_flowrate(), calib_flowrate_X1C(), calib_generic_auto_pa_cali(), calib_generic_PA(), calib_PA(), and check_printable_status_before_cali().

Here is the call graph for this function:

Here is the caller graph for this function:

delete_PA_calib_result()

void Slic3r::GUI::CalibUtils::delete_PA_calib_result ( const PACalibIndexInfo & pa_calib_info )

static

{
    DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
    if (!dev)
        return;
 
    MachineObject* obj_ = dev->get_selected_machine();
    if (obj_ == nullptr)
        return;
 
    obj_->command_delete_pa_calibration(pa_calib_info);
}

References Slic3r::MachineObject::command_delete_pa_calibration(), and Slic3r::DeviceManager::get_selected_machine().

Referenced by Slic3r::GUI::HistoryWindow::sync_history_data().

Here is the call graph for this function:

Here is the caller graph for this function:

emit_get_flow_ratio_calib_results()

void Slic3r::GUI::CalibUtils::emit_get_flow_ratio_calib_results ( float nozzle_diameter )

static

{
    DeviceManager *dev = Slic3r::GUI::wxGetApp().getDeviceManager();
    if (!dev)
        return;
 
    MachineObject *obj_ = dev->get_selected_machine();
    if (obj_ == nullptr)
        return;
 
    obj_->command_get_flow_ratio_calibration_result(nozzle_diameter);
}

References Slic3r::MachineObject::command_get_flow_ratio_calibration_result(), Slic3r::DeviceManager::get_selected_machine(), and Slic3r::nozzle_diameter().

Referenced by Slic3r::GUI::CalibrationCaliPage::update().

Here is the call graph for this function:

Here is the caller graph for this function:

emit_get_PA_calib_infos()

void Slic3r::GUI::CalibUtils::emit_get_PA_calib_infos ( const PACalibExtruderInfo & cali_info )

static

{
    DeviceManager *dev = Slic3r::GUI::wxGetApp().getDeviceManager();
    if (!dev)
        return;
 
    MachineObject *obj_ = dev->get_selected_machine();
    if (obj_ == nullptr)
        return;
 
    obj_->command_get_pa_calibration_tab(cali_info);
}

References Slic3r::MachineObject::command_get_pa_calibration_tab(), and Slic3r::DeviceManager::get_selected_machine().

Referenced by Slic3r::GUI::HistoryWindow::reqeust_history_result(), Slic3r::GUI::PressureAdvanceWizard::update(), and Slic3r::GUI::StatusPanel::update_ams().

Here is the call graph for this function:

Here is the caller graph for this function:

emit_get_PA_calib_results()

void Slic3r::GUI::CalibUtils::emit_get_PA_calib_results ( float nozzle_diameter )

static

{
    DeviceManager *dev = Slic3r::GUI::wxGetApp().getDeviceManager();
    if (!dev)
        return;
 
    MachineObject *obj_ = dev->get_selected_machine();
    if (obj_ == nullptr)
        return;
 
    obj_->command_get_pa_calibration_result(nozzle_diameter);
}

References Slic3r::MachineObject::command_get_pa_calibration_result(), Slic3r::DeviceManager::get_selected_machine(), and Slic3r::nozzle_diameter().

Referenced by Slic3r::GUI::CalibrationCaliPage::update().

Here is the call graph for this function:

Here is the caller graph for this function:

get_calib_mode_by_name()

CalibMode Slic3r::GUI::CalibUtils::get_calib_mode_by_name ( const std::string name, int & cali_stage )

static

{
    if (name == "pa_line_calib_mode") {
        cali_stage = 0;
        return CalibMode::Calib_PA_Line;
    }
    else if (name == "pa_pattern_calib_mode") {
        cali_stage = 1;
        return CalibMode::Calib_PA_Line;
    }
    else if (name == "auto_pa_line_calib_mode") {
        cali_stage = 2;
        return CalibMode::Calib_PA_Line;
    }
    else if (name == "flow_rate_coarse_calib_mode") {
        cali_stage = 1;
        return CalibMode::Calib_Flow_Rate;
    }
    else if (name == "flow_rate_fine_calib_mode") {
        cali_stage = 2;
        return CalibMode::Calib_Flow_Rate;
    }
    else if (name == "temp_tower_calib_mode")
        return CalibMode::Calib_Temp_Tower;
    else if (name == "vol_speed_tower_calib_mode")
        return CalibMode::Calib_Vol_speed_Tower;
    else if (name == "vfa_tower_calib_mode")
        return CalibMode::Calib_VFA_Tower;
    else if (name == "retration_tower_calib_mode")
        return CalibMode::Calib_Retraction_tower;
    else if (name == "input_shaping_freq_calib_mode")
        return CalibMode::Calib_Input_shaping_freq;
    else if (name == "input_shaping_damp_calib_mode")
        return CalibMode::Calib_Input_shaping_damp;
    else if (name == "cornering_calib_mode")
        return CalibMode::Calib_Cornering;
    return CalibMode::Calib_None;
}

References Slic3r::Calib_Cornering, Slic3r::Calib_Flow_Rate, Slic3r::Calib_Input_shaping_damp, Slic3r::Calib_Input_shaping_freq, Slic3r::Calib_None, Slic3r::Calib_PA_Line, Slic3r::Calib_Retraction_tower, Slic3r::Calib_Temp_Tower, Slic3r::Calib_VFA_Tower, and Slic3r::Calib_Vol_speed_Tower.

Referenced by Slic3r::GUI::PrintingTaskPanel::enable_partskip_button(), Slic3r::GUI::get_obj_calibration_mode(), Slic3r::GUI::FlowRateWizard::on_cali_job_finished(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_job_finished(), and Slic3r::GUI::PressureAdvanceWizard::on_cali_job_finished().

Here is the caller graph for this function:

get_flow_ratio_calib_results()

bool Slic3r::GUI::CalibUtils::get_flow_ratio_calib_results ( std::vector< FlowRatioCalibResult > & flow_ratio_calib_results )

static

{
    DeviceManager *dev = Slic3r::GUI::wxGetApp().getDeviceManager();
    if (!dev)
        return false;
 
    MachineObject *obj_ = dev->get_selected_machine();
    if (obj_ == nullptr)
        return false;
 
    flow_ratio_calib_results = obj_->flow_ratio_results;
    return flow_ratio_calib_results.size() > 0;
}

References Slic3r::MachineObject::flow_ratio_results, and Slic3r::DeviceManager::get_selected_machine().

Here is the call graph for this function:

get_PA_calib_results()

bool Slic3r::GUI::CalibUtils::get_PA_calib_results ( std::vector< PACalibResult > & pa_calib_results )

static

{
    DeviceManager *dev = Slic3r::GUI::wxGetApp().getDeviceManager();
    if (!dev)
        return false;
 
    MachineObject *obj_ = dev->get_selected_machine();
    if (obj_ == nullptr)
        return false;
 
    pa_calib_results = obj_->pa_calib_results;
    return pa_calib_results.size() > 0;
}

References Slic3r::DeviceManager::get_selected_machine(), and Slic3r::MachineObject::pa_calib_results.

Here is the call graph for this function:

get_PA_calib_tab()

bool Slic3r::GUI::CalibUtils::get_PA_calib_tab ( std::vector< PACalibResult > & pa_calib_infos )

static

{
    DeviceManager *dev = Slic3r::GUI::wxGetApp().getDeviceManager();
    if (!dev)
        return false;
 
    MachineObject *obj_ = dev->get_selected_machine();
    if (obj_ == nullptr)
        return false;
 
    if (obj_->has_get_pa_calib_tab) {
        pa_calib_infos.assign(obj_->pa_calib_tab.begin(), obj_->pa_calib_tab.end());
    }
    return obj_->has_get_pa_calib_tab;
}

References Slic3r::DeviceManager::get_selected_machine(), Slic3r::MachineObject::has_get_pa_calib_tab, and Slic3r::MachineObject::pa_calib_tab.

Here is the call graph for this function:

get_pa_k_n_value_by_cali_idx()

bool Slic3r::GUI::CalibUtils::get_pa_k_n_value_by_cali_idx ( const MachineObject * obj, int cali_idx, float & out_k, float & out_n )

static

                                                                                                                {
    if (!obj)
        return false;
 
    for (auto pa_calib_info : obj->pa_calib_tab) {
        if (pa_calib_info.cali_idx == cali_idx) {
            out_k = pa_calib_info.k_value;
            out_n = pa_calib_info.n_coef;
            return true;
        }
    }
    return false;
}

References Slic3r::MachineObject::pa_calib_tab.

Referenced by Slic3r::GUI::AMSinfo::parse_ams_info(), and Slic3r::GUI::AMSinfo::parse_ext_info().

Here is the caller graph for this function:

get_selected_calib_idx()

int Slic3r::GUI::CalibUtils::get_selected_calib_idx ( const std::vector< PACalibResult > & pa_calib_values, int cali_idx )

static

                                                                                                    {
    for (int i = 0; i < pa_calib_values.size(); ++i) {
        if(pa_calib_values[i].cali_idx == cali_idx)
            return i;
    }
    return -1;
}

Referenced by Slic3r::GUI::AMSMaterialsSetting::on_select_filament(), and Slic3r::GUI::AMSLib::render_generic_text().

Here is the caller graph for this function:

is_support_auto_pa_cali()

bool Slic3r::GUI::CalibUtils::is_support_auto_pa_cali ( std::string filament_id )

static

{
    // filament_id is our OF id; not_support_auto_pa_cali_filaments holds the printer's own ids.
    auto* agent = wxGetApp().getAgent();
    const std::string printer_filament_id = agent ? agent->from_orca_filament_id(filament_id) : filament_id;
    auto iter = std::find(not_support_auto_pa_cali_filaments.begin(), not_support_auto_pa_cali_filaments.end(), printer_filament_id);
    if (iter != not_support_auto_pa_cali_filaments.end()) {
        return false;
    }
    return true;
}

References Slic3r::GUI::not_support_auto_pa_cali_filaments.

Referenced by check_printable_status_before_cali(), and check_printable_status_before_cali().

Here is the caller graph for this function:

process_and_store_3mf()

bool Slic3r::GUI::CalibUtils::process_and_store_3mf ( Model * model, const DynamicPrintConfig & full_config, const Calib_Params & params, wxString & error_message )

staticprivate

{
    Pointfs bedfs         = make_counter_clockwise(full_config.opt<ConfigOptionPoints>("printable_area")->values);
    std::vector<Pointfs> extruder_areas = full_config.option<ConfigOptionPointsGroups>("extruder_printable_area")->values;
    std::vector<double> extruder_heights = full_config.option<ConfigOptionFloatsNullable>("extruder_printable_height")->values;
    double  print_height  = full_config.opt_float("printable_height");
    double  current_width = bedfs[2].x() - bedfs[0].x();
    double  current_depth = bedfs[2].y() - bedfs[0].y();
    Vec3i32   plate_size;
    plate_size[0] = bedfs[2].x() - bedfs[0].x();
    plate_size[1] = bedfs[2].y() - bedfs[0].y();
    plate_size[2] = print_height;
 
    if (params.mode == CalibMode::Calib_PA_Line) {
        double space_y       = 3.5;
        int    max_line_nums = int(plate_size[1] - 10) / space_y;
        int    count         = std::llround(std::ceil((params.end - params.start) / params.step)) + 1;
        if (count > max_line_nums) {
            error_message = _L("Unable to calibrate: maybe because the set calibration value range is too large, or the step is too small");
            return false;
        }
    }
 
    if (params.mode == CalibMode::Calib_PA_Pattern) {
        ModelInstance *instance = model->objects[0]->instances[0];
        Vec3d offset = model->calib_pa_pattern->get_start_offset() +
                       Vec3d(model->calib_pa_pattern->handle_xy_size() / 2, -model->calib_pa_pattern->handle_xy_size() / 2 - model->calib_pa_pattern->handle_spacing(), 0);
        instance->set_offset(offset);
    }
    else if (model->objects.size() == 1) {
        ModelInstance *instance = model->objects[0]->instances[0];
        instance->set_offset(instance->get_offset() + Vec3d(current_width / 2, current_depth / 2, 0));
    } else {
        BoundingBoxf3 bbox = model->bounding_box_exact();
        Vec3d bbox_center = bbox.center();
        for (auto object : model->objects) {
            ModelInstance *instance = object->instances[0];
            instance->set_offset(instance->get_offset() + Vec3d(current_width / 2 - bbox_center.x(), current_depth / 2 - bbox_center.y(), 0));
        }
    }
 
    Slic3r::GUI::PartPlateList partplate_list(nullptr, model, PrinterTechnology::ptFFF);
    partplate_list.reset_size(plate_size.x(), plate_size.y(), plate_size.z(), false);
 
    Slic3r::GUI::PartPlate *part_plate = partplate_list.get_plate(0);
 
    PrintBase *               print        = NULL;
    Slic3r::GUI::GCodeResult *gcode_result = NULL;
    int                       print_index;
    part_plate->get_print(&print, &gcode_result, &print_index);
 
    BuildVolume build_volume(bedfs, print_height, extruder_areas, extruder_heights);
    unsigned int count = model->update_print_volume_state(build_volume);
    if (count == 0 && params.mode != CalibMode::Calib_Auto_PA_Line) {
        error_message = _L("Unable to calibrate: maybe because the set calibration value range is too large, or the step is too small");
        return false;
    }
 
    // apply the new print config
    DynamicPrintConfig new_print_config = full_config;
    print->apply(*model, new_print_config);
 
    Print *fff_print = dynamic_cast<Print *>(print);
    fff_print->set_calib_params(params);
    fff_print->is_BBL_printer() = true;
 
    //StringObjectException warning;
    //auto err = print->validate(&warning);
    //if (!err.string.empty()) {
    //    error_message = "slice validate: " + err.string;
    //    return;
    //}
 
    if (!check_nozzle_diameter_and_type(full_config, error_message))
        return false;
 
    fff_print->process();
    part_plate->update_slice_result_valid_state(true);
 
    gcode_result->reset();
    fff_print->export_gcode(calib_temp_file(gcode_filename), gcode_result, nullptr);
 
    std::vector<ThumbnailData*> thumbnails;
    PlateDataPtrs plate_data_list;
    partplate_list.store_to_3mf_structure(plate_data_list, true, 0);
 
    DeviceManager *dev = Slic3r::GUI::wxGetApp().getDeviceManager();
    if (!dev) {
        error_message = _L("Need select printer");
        return false;
    }
 
    MachineObject *obj_ = dev->get_selected_machine();
    if (obj_ == nullptr) {
        error_message = _L("Need select printer");
        return false;
    }
 
    for (auto plate_data : plate_data_list) {
        plate_data->gcode_file      = calib_temp_file(gcode_filename);
        plate_data->is_sliced_valid = true;
        plate_data->printer_model_id = obj_->printer_type;
        FilamentInfo& filament_info = plate_data->slice_filaments_info.front();
        filament_info.type          = full_config.opt_string("filament_type", 0);
    }
 
    //draw thumbnails
    {
        GLVolumeCollection glvolume_collection;
        std::vector<ColorRGBA> colors_out(1);
        unsigned char  rgb_color[4] = {255, 255, 255, 255};
        ColorRGBA new_color {1.0f, 1.0f, 1.0f, 1.0f};
        colors_out.push_back(new_color);
 
        ThumbnailData* thumbnail_data = &plate_data_list[0]->plate_thumbnail;
        unsigned int thumbnail_width = 512, thumbnail_height = 512;
        const ThumbnailsParams thumbnail_params = {{}, false, true, true, true, 0};
        GLShaderProgram* shader = wxGetApp().get_shader("thumbnail");
 
        for (unsigned int obj_idx = 0; obj_idx < (unsigned int)model->objects.size(); ++ obj_idx) {
            const ModelObject &model_object = *model->objects[obj_idx];
 
            for (int volume_idx = 0; volume_idx < (int)model_object.volumes.size(); ++ volume_idx) {
                const ModelVolume &model_volume = *model_object.volumes[volume_idx];
                for (int instance_idx = 0; instance_idx < (int)model_object.instances.size(); ++ instance_idx) {
                    const ModelInstance &model_instance = *model_object.instances[instance_idx];
                    glvolume_collection.load_object_volume(&model_object, obj_idx, volume_idx, instance_idx, "volume", true, false, true);
                    glvolume_collection.volumes.back()->set_render_color(new_color);
                    glvolume_collection.volumes.back()->set_color(new_color);
                    //glvolume_collection.volumes.back()->printable = model_instance.printable;
                }
            }
        }
 
        switch (Slic3r::GUI::OpenGLManager::get_framebuffers_type())
        {
            case Slic3r::GUI::OpenGLManager::EFramebufferType::Arb:
            {
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__<< boost::format(": framebuffer_type: ARB");
                Slic3r::GUI::GLCanvas3D::render_thumbnail_framebuffer(*thumbnail_data,
                   thumbnail_width, thumbnail_height, thumbnail_params,
                   partplate_list, model->objects, glvolume_collection, colors_out, shader, Slic3r::GUI::Camera::EType::Ortho);
                break;
            }
            case Slic3r::GUI::OpenGLManager::EFramebufferType::Ext:
            {
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__<< boost::format(": framebuffer_type: EXT");
                Slic3r::GUI::GLCanvas3D::render_thumbnail_framebuffer_ext(*thumbnail_data,
                   thumbnail_width, thumbnail_height, thumbnail_params,
                   partplate_list, model->objects, glvolume_collection, colors_out, shader, Slic3r::GUI::Camera::EType::Ortho);
                break;
            }
            default:{
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__<< boost::format(": framebuffer_type: others");
                Slic3r::GUI::GLCanvas3D::render_thumbnail_legacy(*thumbnail_data, thumbnail_width, thumbnail_height, thumbnail_params, partplate_list, model->objects, glvolume_collection, colors_out, shader, Slic3r::GUI::Camera::EType::Ortho);
                break;
            }
        }
        thumbnails.push_back(thumbnail_data);
    }
 
    StoreParams store_params;
    store_params.path            = calib_temp_file(model_filename);
    store_params.model           = model;
    store_params.plate_data_list = plate_data_list;
    store_params.config = &new_print_config;
 
    store_params.export_plate_idx = 0;
    store_params.thumbnail_data = thumbnails;
 
 
    store_params.strategy = SaveStrategy::Silence | SaveStrategy::WithGcode | SaveStrategy::SplitModel | SaveStrategy::SkipModel;
 
    bool success = Slic3r::store_bbs_3mf(store_params);
 
    store_params.strategy = SaveStrategy::Silence | SaveStrategy::SplitModel | SaveStrategy::WithSliceInfo | SaveStrategy::SkipAuxiliary;
    store_params.path = calib_temp_file(config_filename);
    success           = Slic3r::store_bbs_3mf(store_params);
 
    release_PlateData_list(plate_data_list);
    return true;
}

References _L, Slic3r::PrintBase::apply(), Slic3r::GUI::OpenGLManager::Arb, Slic3r::Model::bounding_box_exact(), Slic3r::Calib_Auto_PA_Line, Slic3r::Calib_PA_Line, Slic3r::Calib_PA_Pattern, Slic3r::Model::calib_pa_pattern, Slic3r::GUI::calib_temp_file(), Slic3r::BoundingBox3Base< PointType >::center(), Slic3r::GUI::check_nozzle_diameter_and_type(), Slic3r::StoreParams::config, Slic3r::GUI::config_filename, count, Slic3r::Calib_Params::end, Slic3r::Print::export_gcode(), Slic3r::StoreParams::export_plate_idx, Slic3r::GUI::OpenGLManager::Ext, Slic3r::GUI::gcode_filename, Slic3r::GUI::OpenGLManager::get_framebuffers_type(), Slic3r::ModelInstance::get_offset(), Slic3r::GUI::PartPlateList::get_plate(), Slic3r::GUI::PartPlate::get_print(), Slic3r::DeviceManager::get_selected_machine(), Slic3r::ModelObject::instances, Slic3r::Print::is_BBL_printer(), Slic3r::GLVolumeCollection::load_object_volume(), Slic3r::make_counter_clockwise(), Slic3r::Calib_Params::mode, Slic3r::StoreParams::model, Slic3r::GUI::model_filename, Slic3r::Model::objects, Slic3r::offset(), Slic3r::DynamicConfig::opt(), Slic3r::DynamicConfig::opt_float(), Slic3r::DynamicConfig::opt_string(), Slic3r::ConfigBase::option(), Slic3r::GUI::Camera::Ortho, Slic3r::StoreParams::path, Slic3r::StoreParams::plate_data_list, Slic3r::MachineObject::printer_type, Slic3r::Print::process(), Slic3r::ptFFF, Slic3r::release_PlateData_list(), Slic3r::GUI::GLCanvas3D::render_thumbnail_framebuffer(), Slic3r::GUI::GLCanvas3D::render_thumbnail_framebuffer_ext(), Slic3r::GUI::GLCanvas3D::render_thumbnail_legacy(), Slic3r::GCodeProcessorResult::reset(), Slic3r::GUI::PartPlateList::reset_size(), Slic3r::Print::set_calib_params(), Slic3r::ModelInstance::set_offset(), Slic3r::Silence, Slic3r::SkipAuxiliary, Slic3r::SkipModel, Slic3r::SplitModel, Slic3r::Calib_Params::start, Slic3r::Calib_Params::step, Slic3r::store_bbs_3mf(), Slic3r::GUI::PartPlateList::store_to_3mf_structure(), Slic3r::StoreParams::strategy, Slic3r::StoreParams::thumbnail_data, Slic3r::FilamentGroupUtils::FilamentInfo::type, Slic3r::Model::update_print_volume_state(), Slic3r::GUI::PartPlate::update_slice_result_valid_state(), Slic3r::ConfigOptionVector< T >::values, Slic3r::GLVolumeCollection::volumes, Slic3r::ModelObject::volumes, Slic3r::WithGcode, and Slic3r::WithSliceInfo.

Referenced by calib_flowrate(), calib_generic_auto_pa_cali(), calib_generic_PA(), calib_max_vol_speed(), calib_retraction(), calib_temptue(), and calib_VFA().

Here is the call graph for this function:

Here is the caller graph for this function:

select_PA_calib_result()

void Slic3r::GUI::CalibUtils::select_PA_calib_result ( const PACalibIndexInfo & pa_calib_info )

static

{
    DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
    if (!dev)
        return;
 
    MachineObject* obj_ = dev->get_selected_machine();
    if (obj_ == nullptr)
        return;
 
    obj_->commnad_select_pa_calibration(pa_calib_info);
}

References Slic3r::MachineObject::commnad_select_pa_calibration(), and Slic3r::DeviceManager::get_selected_machine().

Referenced by Slic3r::GUI::AMSMaterialsSetting::on_select_ok(), and Slic3r::GUI::AMSMaterialsSetting::on_select_reset().

Here is the call graph for this function:

Here is the caller graph for this function:

send_to_print() [1/2]

void Slic3r::GUI::CalibUtils::send_to_print ( const CalibInfo & calib_info, wxString & error_message, int flow_ratio_mode = 0 )

staticprivate

{
    {  // before send
        json j;
        j["print"]["cali_mode"]       = calib_info.params.mode;
        j["print"]["start"]           = calib_info.params.start;
        j["print"]["end"]             = calib_info.params.end;
        j["print"]["step"]            = calib_info.params.step;
        j["print"]["print_numbers"]   = calib_info.params.print_numbers;
        j["print"]["flow_ratio_mode"] = flow_ratio_mode;
        j["print"]["tray_id"]         = calib_info.select_ams;
        j["print"]["dev_id"]          = calib_info.dev_id;
        j["print"]["bed_type"]        = calib_info.bed_type;
        j["print"]["printer_prest"]   = calib_info.printer_prest ? calib_info.printer_prest->name : "";
        j["print"]["filament_prest"]  = calib_info.filament_prest ? calib_info.filament_prest->name : "";
        j["print"]["print_prest"]     = calib_info.print_prest ? calib_info.print_prest->name : "";
        BOOST_LOG_TRIVIAL(info) << "send_cali_job - before send: " << j.dump();
    }
 
    std::string dev_id = calib_info.dev_id;
    std::string select_ams = calib_info.select_ams;
    std::shared_ptr<ProgressIndicator> process_bar = calib_info.process_bar;
    BedType bed_type = calib_info.bed_type;
 
    DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
    if (!dev) {
        error_message = _L("Need select printer");
        return;
    }
 
    MachineObject* obj_ = dev->get_selected_machine();
    if (obj_ == nullptr) {
        error_message = _L("Need select printer");
        return;
    }
 
    if (obj_->is_in_upgrading()) {
        error_message = _L("Cannot send a print job while the printer is updating firmware.");
        return;
    }
    else if (obj_->is_system_printing()) {
        error_message = _L("The printer is executing instructions. Please restart printing after it ends.");
        return;
    }
    else if (obj_->is_in_printing()) {
        error_message = _L("The printer is busy with another print job.");
        return;
    }
 
    else if (!obj_->GetConfig()->SupportPrintWithoutSD() && (obj_->GetStorage()->get_sdcard_state() == DevStorage::SdcardState::NO_SDCARD)) {
        error_message = _L("Storage needs to be inserted before printing.");
        return;
    }
    if (obj_->is_lan_mode_printer()) {
        if (obj_->GetStorage()->get_sdcard_state() == DevStorage::SdcardState::NO_SDCARD) {
            error_message = _L("Storage needs to be inserted before printing via LAN.");
            return;
        }
    }
 
    print_worker = std::make_unique<PlaterWorker<BoostThreadWorker>>(wxGetApp().plater(), std::move(process_bar), "calib_worker");
 
    auto print_job              = std::make_unique<PrintJob>(dev_id);
    print_job->m_dev_ip         = obj_->get_dev_ip();
    print_job->m_ftp_folder     = obj_->get_ftp_folder();
    print_job->m_access_code    = obj_->get_access_code();
 
 
#if !BBL_RELEASE_TO_PUBLIC
    print_job->m_local_use_ssl_for_ftp = wxGetApp().app_config->get("enable_ssl_for_ftp") == "true" ? true : false;
    print_job->m_local_use_ssl = wxGetApp().app_config->get("enable_ssl_for_mqtt") == "true" ? true : false;
#else
    print_job->m_local_use_ssl_for_ftp = obj_->local_use_ssl_for_ftp;
    print_job->m_local_use_ssl = obj_->local_use_ssl;
#endif
 
    print_job->connection_type  = obj_->connection_type();
    print_job->cloud_print_only = obj_->is_support_cloud_print_only;
 
    PrintPrepareData job_data;
    job_data.is_from_plater = false;
    job_data.plate_idx = 0;
    job_data._3mf_config_path = calib_temp_file(config_filename);
    job_data._3mf_path = calib_temp_file(model_filename);
    job_data._temp_path = calib_temp_dir();
 
    PlateListData plate_data;
    plate_data.is_valid = true;
    plate_data.plate_count = 1;
    plate_data.cur_plate_index = 0;
    plate_data.bed_type = bed_type;
 
    print_job->job_data = job_data;
    print_job->plate_data = plate_data;
    print_job->m_print_type = "from_normal";
 
    print_job->task_ams_mapping = "[" + select_ams + "]";
    print_job->task_ams_mapping_info = "";
    print_job->task_use_ams = !devPrinterUtil::IsVirtualSlot(select_ams);
 
    std::string new_ams_mapping = "[{\"ams_id\":" + std::to_string(calib_info.ams_id) + ", \"slot_id\":" + std::to_string(calib_info.slot_id) + "}]";
    print_job->task_ams_mapping2 = new_ams_mapping;
 
    CalibMode cali_mode       = calib_info.params.mode;
    print_job->m_project_name = get_calib_mode_name(cali_mode, flow_ratio_mode);
    print_job->set_calibration_task(true);
 
    print_job->sdcard_state = obj_->GetStorage()->get_sdcard_state();
    print_job->has_sdcard =  wxGetApp().app_config->get("allow_abnormal_storage") == "true"
            ? (print_job->sdcard_state == DevStorage::SdcardState::HAS_SDCARD_NORMAL
               || print_job->sdcard_state == DevStorage::SdcardState::HAS_SDCARD_ABNORMAL)
            : print_job->sdcard_state == DevStorage::SdcardState::HAS_SDCARD_NORMAL;
    print_job->could_emmc_print = obj_->can_use_emmc_print();
    print_job->set_print_config(MachineBedTypeString[bed_type], true, false, false, false, true, false, 0, 0, 0);
    print_job->set_print_job_finished_event(wxGetApp().plater()->get_send_calibration_finished_event(), print_job->m_project_name);
 
    {  // after send: record the print job
        json j;
        j["print"]["project_name"]    = print_job->m_project_name;
        j["print"]["is_cali_task"]    = print_job->m_is_calibration_task;
        BOOST_LOG_TRIVIAL(info) << "send_cali_job - after send: " << j.dump();
    }
 
    replace_job(*print_worker, std::move(print_job));
}

References Slic3r::GUI::PrintPrepareData::_3mf_config_path, Slic3r::GUI::PrintPrepareData::_3mf_path, _L, Slic3r::GUI::PrintPrepareData::_temp_path, Slic3r::GUI::CalibInfo::ams_id, Slic3r::GUI::CalibInfo::bed_type, Slic3r::GUI::PlateListData::bed_type, Slic3r::GUI::calib_temp_dir(), Slic3r::GUI::calib_temp_file(), Slic3r::MachineObject::can_use_emmc_print(), Slic3r::GUI::config_filename, Slic3r::MachineObject::connection_type(), Slic3r::GUI::PlateListData::cur_plate_index, Slic3r::GUI::CalibInfo::dev_id, Slic3r::Calib_Params::end, Slic3r::GUI::CalibInfo::filament_prest, Slic3r::MachineObject::get_access_code(), Slic3r::GUI::get_calib_mode_name(), Slic3r::MachineObject::get_dev_ip(), Slic3r::MachineObject::get_ftp_folder(), Slic3r::DevStorage::get_sdcard_state(), Slic3r::DeviceManager::get_selected_machine(), Slic3r::MachineObject::GetConfig(), Slic3r::MachineObject::GetStorage(), Slic3r::DevStorage::HAS_SDCARD_ABNORMAL, Slic3r::DevStorage::HAS_SDCARD_NORMAL, Slic3r::GUI::PrintPrepareData::is_from_plater, Slic3r::MachineObject::is_in_printing(), Slic3r::MachineObject::is_in_upgrading(), Slic3r::MachineObject::is_lan_mode_printer(), Slic3r::MachineObject::is_support_cloud_print_only, Slic3r::MachineObject::is_system_printing(), Slic3r::GUI::PlateListData::is_valid, Slic3r::devPrinterUtil::IsVirtualSlot(), Slic3r::MachineObject::local_use_ssl, Slic3r::MachineObject::local_use_ssl_for_ftp, Slic3r::GUI::MachineBedTypeString, Slic3r::Calib_Params::mode, Slic3r::GUI::model_filename, Slic3r::Preset::name, Slic3r::DevStorage::NO_SDCARD, Slic3r::GUI::CalibInfo::params, Slic3r::GUI::PlateListData::plate_count, Slic3r::GUI::PrintPrepareData::plate_idx, Slic3r::GUI::plater(), Slic3r::Calib_Params::print_numbers, Slic3r::GUI::CalibInfo::print_prest, print_worker, Slic3r::GUI::CalibInfo::printer_prest, Slic3r::GUI::CalibInfo::process_bar, Slic3r::GUI::replace_job(), Slic3r::GUI::CalibInfo::select_ams, Slic3r::GUI::CalibInfo::slot_id, Slic3r::Calib_Params::start, Slic3r::Calib_Params::step, and Slic3r::DevConfig::SupportPrintWithoutSD().

Referenced by calib_flowrate(), calib_generic_auto_pa_cali(), calib_generic_PA(), calib_max_vol_speed(), calib_retraction(), calib_temptue(), and calib_VFA().

Here is the call graph for this function:

Here is the caller graph for this function:

send_to_print() [2/2]

void Slic3r::GUI::CalibUtils::send_to_print ( const std::vector< CalibInfo > & calib_infos, wxString & error_message, int flow_ratio_mode = 0 )

staticprivate

{
    std::string                        dev_id      = calib_infos[0].dev_id;
    std::shared_ptr<ProgressIndicator> process_bar = calib_infos[0].process_bar;
    BedType                            bed_type    = calib_infos[0].bed_type;
 
    DeviceManager *dev = Slic3r::GUI::wxGetApp().getDeviceManager();
    if (!dev) {
        error_message = _L("Need select printer");
        return;
    }
 
    MachineObject *obj_ = dev->get_selected_machine();
    if (obj_ == nullptr) {
        error_message = _L("Need select printer");
        return;
    }
 
    if (obj_->is_in_upgrading()) {
        error_message = _L("Cannot send a print job while the printer is updating firmware.");
        return;
    } else if (obj_->is_system_printing()) {
        error_message = _L("The printer is executing instructions. Please restart printing after it ends.");
        return;
    } else if (obj_->is_in_printing()) {
        error_message = _L("The printer is busy with another print job.");
        return;
    }
 
    else if (!obj_->GetConfig()->SupportPrintWithoutSD() && (obj_->GetStorage()->get_sdcard_state() == DevStorage::SdcardState::NO_SDCARD)) {
        error_message = _L("Storage needs to be inserted before printing.");
        return;
    }
    if (obj_->is_lan_mode_printer()) {
        if (obj_->GetStorage()->get_sdcard_state() == DevStorage::SdcardState::NO_SDCARD) {
            error_message = _L("Storage needs to be inserted before printing via LAN.");
            return;
        }
    }
 
    print_worker = std::make_unique<PlaterWorker<BoostThreadWorker>>(wxGetApp().plater(), std::move(process_bar), "calib_worker");
 
    auto print_job                = std::make_shared<PrintJob>(dev_id);
    print_job->m_dev_ip      = obj_->get_dev_ip();
    print_job->m_ftp_folder  = obj_->get_ftp_folder();
    print_job->m_access_code = obj_->get_access_code();
 
#if !BBL_RELEASE_TO_PUBLIC
    print_job->m_local_use_ssl_for_ftp  = wxGetApp().app_config->get("enable_ssl_for_ftp") == "true" ? true : false;
    print_job->m_local_use_ssl = wxGetApp().app_config->get("enable_ssl_for_mqtt") == "true" ? true : false;
#else
    print_job->m_local_use_ssl_for_ftp  = obj_->local_use_ssl_for_ftp;
    print_job->m_local_use_ssl = obj_->local_use_ssl;
#endif
 
    print_job->connection_type  = obj_->connection_type();
    print_job->cloud_print_only = obj_->is_support_cloud_print_only;
 
    PrintPrepareData job_data;
    job_data.is_from_plater   = false;
    job_data.plate_idx        = 0;
    job_data._3mf_config_path = calib_temp_file(config_filename);
    job_data._3mf_path        = calib_temp_file(model_filename);
    job_data._temp_path       = calib_temp_dir();
 
    PlateListData plate_data;
    plate_data.is_valid        = true;
    plate_data.plate_count     = 1;
    plate_data.cur_plate_index = 0;
    plate_data.bed_type        = bed_type;
 
    print_job->job_data     = job_data;
    print_job->plate_data   = plate_data;
    print_job->m_print_type = "from_normal";
 
    // set AMS mapping
    std::string select_ams     = "[";
    std::string new_select_ams = "[";
    for (size_t i = 0; i < calib_infos.size(); ++i) {
        select_ams += calib_infos[i].select_ams;
        new_select_ams += "{\"ams_id\":" + std::to_string(calib_infos[i].ams_id) + ", \"slot_id\":" + std::to_string(calib_infos[i].slot_id) + "}";
        if (i != calib_infos.size() - 1) {
            select_ams += ",";
            new_select_ams += ",";
        }
    }
    select_ams += "]";
    new_select_ams += "]";
    print_job->task_ams_mapping      = select_ams;
    print_job->task_ams_mapping_info = "";
    print_job->task_ams_mapping2     = new_select_ams;
 
    print_job->task_use_ams = false;
    for (const CalibInfo& calib_info : calib_infos) {
        if (calib_info.select_ams != VIRTUAL_AMS_MAIN_ID_STR && calib_info.select_ams != VIRTUAL_AMS_DEPUTY_ID_STR) {
            print_job->task_use_ams = true;
            break;
        }
    }
 
    CalibMode cali_mode       = calib_infos[0].params.mode;
    print_job->m_project_name = get_calib_mode_name(cali_mode, flow_ratio_mode);
    print_job->set_calibration_task(true);
 
    print_job->sdcard_state = obj_->GetStorage()->get_sdcard_state();
    print_job->has_sdcard =  wxGetApp().app_config->get("allow_abnormal_storage") == "true"
            ? (print_job->sdcard_state == DevStorage::SdcardState::HAS_SDCARD_NORMAL
               || print_job->sdcard_state == DevStorage::SdcardState::HAS_SDCARD_ABNORMAL)
            : print_job->sdcard_state == DevStorage::SdcardState::HAS_SDCARD_NORMAL;
    print_job->could_emmc_print = obj_->can_use_emmc_print();
    print_job->set_print_config(MachineBedTypeString[bed_type], true, true, false, false, true, false, 0, 1, 0);
    print_job->set_print_job_finished_event(wxGetApp().plater()->get_send_calibration_finished_event(), print_job->m_project_name);
 
    { // after send: record the print job
        json j;
        j["print"]["ams_mapping"] = print_job->task_ams_mapping;
        j["print"]["ams_mapping_2"] = print_job->task_ams_mapping2;
        j["print"]["project_name"] = print_job->m_project_name;
        j["print"]["is_cali_task"] = print_job->m_is_calibration_task;
        BOOST_LOG_TRIVIAL(info) << "send_cali_job - after send: " << j.dump();
    }
 
    replace_job(*print_worker, std::move(print_job));
}

References Slic3r::GUI::PrintPrepareData::_3mf_config_path, Slic3r::GUI::PrintPrepareData::_3mf_path, _L, Slic3r::GUI::PrintPrepareData::_temp_path, Slic3r::GUI::PlateListData::bed_type, Slic3r::GUI::calib_temp_dir(), Slic3r::GUI::calib_temp_file(), Slic3r::MachineObject::can_use_emmc_print(), Slic3r::GUI::config_filename, Slic3r::MachineObject::connection_type(), Slic3r::GUI::PlateListData::cur_plate_index, Slic3r::MachineObject::get_access_code(), Slic3r::GUI::get_calib_mode_name(), Slic3r::MachineObject::get_dev_ip(), Slic3r::MachineObject::get_ftp_folder(), Slic3r::DevStorage::get_sdcard_state(), Slic3r::DeviceManager::get_selected_machine(), Slic3r::MachineObject::GetConfig(), Slic3r::MachineObject::GetStorage(), Slic3r::DevStorage::HAS_SDCARD_ABNORMAL, Slic3r::DevStorage::HAS_SDCARD_NORMAL, Slic3r::GUI::PrintPrepareData::is_from_plater, Slic3r::MachineObject::is_in_printing(), Slic3r::MachineObject::is_in_upgrading(), Slic3r::MachineObject::is_lan_mode_printer(), Slic3r::MachineObject::is_support_cloud_print_only, Slic3r::MachineObject::is_system_printing(), Slic3r::GUI::PlateListData::is_valid, Slic3r::MachineObject::local_use_ssl, Slic3r::MachineObject::local_use_ssl_for_ftp, Slic3r::GUI::MachineBedTypeString, Slic3r::GUI::model_filename, Slic3r::DevStorage::NO_SDCARD, Slic3r::GUI::PlateListData::plate_count, Slic3r::GUI::PrintPrepareData::plate_idx, Slic3r::GUI::plater(), print_worker, Slic3r::GUI::replace_job(), Slic3r::DevConfig::SupportPrintWithoutSD(), VIRTUAL_AMS_DEPUTY_ID_STR, and VIRTUAL_AMS_MAIN_ID_STR.

Here is the call graph for this function:

set_for_auto_pa_model_and_config()

void Slic3r::GUI::CalibUtils::set_for_auto_pa_model_and_config ( const std::vector< CalibInfo > & calib_info, DynamicPrintConfig & full_config, Model & model )

static

{
    DynamicPrintConfig print_config    = calib_infos[0].print_prest->config;
 
    float nozzle_diameter = full_config.option<ConfigOptionFloats>("nozzle_diameter")->get_at(0);
    int extruder_count = full_config.option<ConfigOptionFloats>("nozzle_diameter")->values.size();
 
    const auto& config_pattern = SuggestedConfigCalibPAPattern();
 
    for (const auto& opt : config_pattern.floats_pairs) { print_config.set_key_value(opt.first, new ConfigOptionFloatsNullable(opt.second)); }
 
    std::vector<CalibInfo> sorted_calib_infos = calib_infos;
    std::sort(sorted_calib_infos.begin(), sorted_calib_infos.end(), [](const CalibInfo &left_item, const CalibInfo &right_item) {
        return left_item.index < right_item.index;
    });
 
    for (const CalibInfo &calib_info : calib_infos) {
        int   index      = get_index_for_extruder_parameter(print_config, "outer_wall_speed", calib_info.extruder_id, calib_info.extruder_type, calib_info.nozzle_volume_type);
        float wall_speed = CalibPressureAdvance::find_optimal_PA_speed(full_config, print_config.get_abs_value("line_width"), print_config.get_abs_value("layer_height"),
                                                                       calib_info.extruder_id, 0);
 
        ConfigOptionFloatsNullable *wall_speed_speed_opt = print_config.option<ConfigOptionFloatsNullable>("outer_wall_speed");
        std::vector<double> new_speeds = wall_speed_speed_opt->values;
        new_speeds[index] = wall_speed;
        ModelObject* object = model.objects[calib_info.index];
        object->config.set_key_value("outer_wall_speed", new ConfigOptionFloatsNullable(new_speeds));
    }
 
    for (const auto& opt : config_pattern.nozzle_ratio_pairs) {
        print_config.set_key_value(opt.first, new ConfigOptionFloatOrPercent(nozzle_diameter * opt.second / 100, false));
    }
 
    for (const auto& opt : config_pattern.int_pairs) { print_config.set_key_value(opt.first, new ConfigOptionInt(opt.second)); }
 
    print_config.set_key_value(config_pattern.brim_pair.first, new ConfigOptionEnum<BrimType>(config_pattern.brim_pair.second));
 
    auto* _wall_generator = print_config.option<ConfigOptionEnum<PerimeterGeneratorType>>("wall_generator");
    _wall_generator->value   = PerimeterGeneratorType::Arachne;
 
    print_config.option<ConfigOptionBool>("enable_prime_tower")->value = false;
    print_config.option<ConfigOptionBool>("enable_wrapping_detection")->value = false;
 
    auto get_new_filament_id = [&sorted_calib_infos](int index) -> int {
        for (size_t i = 0; i < sorted_calib_infos.size(); ++i) {
            if (index == sorted_calib_infos[i].index) {
                return (int) (i + 1); // 1 base filament_id
            }
        }
        return 0;
    };
 
    // set printable and reset filament_id
    for (size_t i = 0; i < model.objects.size(); ++i) {
        auto iter = std::find_if(calib_infos.begin(), calib_infos.end(), [i](const CalibInfo &item) { return item.index == i; });
 
        if (iter == calib_infos.end()) {
            model.objects[i]->printable = false;
        } else {
            ModelObject *object = model.objects[i];
            object->config.set_key_value("extruder", new ConfigOptionInt(get_new_filament_id(iter->index)));
            for (auto *volume : object->volumes) {
                if (volume->config.has("extruder")) volume->config.erase("extruder");
            }
        }
    }
 
    // DynamicPrintConfig full_config;
    full_config.apply(print_config);
    full_config.option<ConfigOptionEnum<FilamentMapMode>>("filament_map_mode", true)->value = FilamentMapMode::fmmManual;
 
    // nozzle volume type
    std::vector<int>& nozzle_volume_types = full_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type", true)->values;
    nozzle_volume_types.resize(extruder_count, NozzleVolumeType::nvtStandard);
    auto nozzle_flush_dataset = full_config.option<ConfigOptionIntsNullable>("nozzle_flush_dataset", true)->values;
    nozzle_flush_dataset.resize(extruder_count, 0);
 
    int               filament_nums = calib_infos.size();
    std::vector<int> physical_extruder_maps = dynamic_cast<ConfigOptionInts *>(full_config.option("physical_extruder_map", true))->values;
    for (size_t filament_index = 0; filament_index < calib_infos.size(); ++filament_index) {
        CalibInfo calib_info  = calib_infos[filament_index];
        int extruder_id = calib_info.extruder_id;
        for (size_t index = 0; index < extruder_count; ++index) {
            if (physical_extruder_maps[index] == extruder_id) {
                extruder_id = index;
                break;
            }
        }
        nozzle_volume_types[extruder_id] = (int)calib_info.nozzle_volume_type;
    }
 
    // filament map transform to 1 base
    std::vector<int> &filament_maps = full_config.option<ConfigOptionInts>("filament_map", true)->values;
    std::transform(filament_maps.begin(), filament_maps.end(), filament_maps.begin(), [](int value) { return value + 1; });
 
    std::vector<std::string> &filament_colors = full_config.option<ConfigOptionStrings>("filament_colour")->values;
    filament_colors.resize(sorted_calib_infos.size(), "#000000");
    for (size_t i = 0; i < sorted_calib_infos.size(); ++i) {
        filament_colors[i] = sorted_calib_infos[i].filament_color;
    }
 
    // Add flush volume matrix
    std::vector<double> flush_matrix_vec;
    for (int e_idx = 0; e_idx < extruder_count; ++e_idx) {
        const std::vector<int> &min_flush_volumes = get_min_flush_volumes(full_config, e_idx);
        for (size_t from_idx = 0; from_idx < filament_nums; ++from_idx) {
            for (size_t to_idx = 0; to_idx < filament_nums; ++to_idx) {
                if (from_idx == to_idx) {
                    flush_matrix_vec.emplace_back(0);
                }
                else {
                    Slic3r::FlushVolCalculator calculator(min_flush_volumes[from_idx], Slic3r::g_max_flush_volume, nozzle_flush_dataset[e_idx]);
                    wxColour from = wxColour(filament_colors[from_idx]);
                    wxColour to = wxColour(filament_colors[to_idx]);
                    int volume = calculator.calc_flush_vol(from.Alpha(), from.Red(), from.Green(), from.Blue(), to.Alpha(), to.Red(), to.Green(), to.Blue());
                    flush_matrix_vec.emplace_back(double(volume));
                }
            }
        }
 
    }
    std::vector<double> &config_matrix = full_config.option<ConfigOptionFloats>("flush_volumes_matrix")->values;
    set_flush_volumes_matrix(config_matrix, flush_matrix_vec, -1, extruder_count);
}

References Slic3r::ConfigBase::apply(), Slic3r::Arachne, Slic3r::FlushVolCalculator::calc_flush_vol(), Slic3r::GUI::CalibInfo::extruder_id, Slic3r::CalibPressureAdvance::find_optimal_PA_speed(), Slic3r::fmmManual, Slic3r::g_max_flush_volume, Slic3r::ConfigBase::get_abs_value(), Slic3r::get_index_for_extruder_parameter(), Slic3r::GUI::get_min_flush_volumes(), Slic3r::nozzle_diameter(), Slic3r::GUI::CalibInfo::nozzle_volume_type, Slic3r::nvtStandard, Slic3r::Model::objects, Slic3r::ConfigBase::option(), Slic3r::set_flush_volumes_matrix(), Slic3r::DynamicConfig::set_key_value(), Slic3r::ConfigOptionSingle< T >::value, Slic3r::ConfigOptionVector< double >::values, and Slic3r::ModelObject::volumes.

Referenced by calib_generic_auto_pa_cali().

Here is the call graph for this function:

Here is the caller graph for this function:

set_PA_calib_result()

void Slic3r::GUI::CalibUtils::set_PA_calib_result ( const std::vector< PACalibResult > & pa_calib_values, bool is_auto_cali )

static

{
    DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
    if (!dev)
        return;
 
    MachineObject* obj_ = dev->get_selected_machine();
    if (obj_ == nullptr)
        return;
 
    obj_->command_set_pa_calibration(pa_calib_values, is_auto_cali);
}

References Slic3r::MachineObject::command_set_pa_calibration(), and Slic3r::DeviceManager::get_selected_machine().

Referenced by Slic3r::GUI::PressureAdvanceWizard::on_cali_save(), and Slic3r::GUI::HistoryWindow::sync_history_data().

Here is the call graph for this function:

Here is the caller graph for this function:

validate_input_flow_ratio()

bool Slic3r::GUI::CalibUtils::validate_input_flow_ratio ( wxString flow_ratio, float * output_value )

static

                                                                                   {
    float default_flow_ratio = 1.0f;
 
    if (flow_ratio.IsEmpty()) {
        *output_value = default_flow_ratio;
        return false;
    }
 
    double flow_ratio_value = 0.0;
    try {
        flow_ratio.ToDouble(&flow_ratio_value);
    }
    catch (...) {
        ;
    }
 
    if (flow_ratio_value <= 0.0 || flow_ratio_value >= 2.0) {
        *output_value = default_flow_ratio;
        return false;
    }
 
    *output_value = flow_ratio_value;
    return true;
}

Referenced by Slic3r::GUI::CaliPresetCaliStagePanel::create_panel(), and Slic3r::GUI::CalibrationFlowX1SavePage::save_to_result_from_widgets().

Here is the caller graph for this function:

validate_input_k_value()

bool Slic3r::GUI::CalibUtils::validate_input_k_value ( wxString k_text, float * output_value )

static

{
    float default_k = 0.0f;
    if (k_text.IsEmpty()) {
        *output_value = default_k;
        return false;
    }
 
    double k_value = 0.0;
    try {
        if(!k_text.ToDouble(&k_value))
            return false;
    }
    catch (...) {
        ;
    }
 
    if (k_value <= MIN_PA_K_VALUE || k_value >= MAX_PA_K_VALUE) {
        *output_value = default_k;
        return false;
    }
 
    *output_value = k_value;
    return true;
};

References Slic3r::GUI::MAX_PA_K_VALUE.

Referenced by Slic3r::GUI::CaliPASaveManualPanel::get_result(), Slic3r::GUI::CaliPASaveP1PPanel::get_result(), Slic3r::GUI::NewCalibrationHistoryDialog::on_ok(), Slic3r::GUI::EditCalibrationHistoryDialog::on_save(), and Slic3r::GUI::CaliPASaveAutoPanel::save_to_result_from_widgets().

Here is the caller graph for this function:

validate_input_name()

bool Slic3r::GUI::CalibUtils::validate_input_name ( wxString name )

static

{
    if (name.Length() > 40) {
        MessageDialog msg_dlg(nullptr, _L("The name cannot exceed 40 characters."), wxEmptyString, wxICON_WARNING | wxOK);
        msg_dlg.ShowModal();
        return false;
    }
 
    name.erase(std::remove(name.begin(), name.end(), L' '), name.end());
    if (name.IsEmpty()) {
        MessageDialog msg_dlg(nullptr, _L("The name cannot be empty."), wxEmptyString, wxICON_WARNING | wxOK);
        msg_dlg.ShowModal();
        return false;
    }
 
    return true;
}

References _L, L, and Slic3r::GUI::DPIAware< P >::ShowModal().

Referenced by Slic3r::GUI::CaliPASaveManualPanel::get_result(), Slic3r::GUI::FlowRateWizard::on_cali_save(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_save(), Slic3r::GUI::NewCalibrationHistoryDialog::on_ok(), and Slic3r::GUI::EditCalibrationHistoryDialog::on_save().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

print_worker

std::unique_ptr< Worker > Slic3r::GUI::CalibUtils::print_worker

static

Referenced by Slic3r::GUI::CalibrationFlowCoarseSavePage::on_cali_cancel_job(), Slic3r::GUI::CalibrationPresetPage::on_cali_cancel_job(), send_to_print(), and send_to_print().

---

The documentation for this class was generated from the following files:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/Utils/CalibUtils.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/Utils/CalibUtils.cpp