Slic3r::CLI Class Reference

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

Collaboration diagram for Slic3r::CLI:

Public Member Functions
int	run (int argc, char **argv)

Private Member Functions
bool	setup (int argc, char **argv)
void	print_help (bool include_print_options=false, PrinterTechnology printer_technology=ptAny) const
	Prints usage of the CLI.
bool	export_models (IO::ExportFormat format, std::string path=std::string())
	Exports loaded models to a file of the specified format, according to the options affecting output filename.
bool	export_project (Model *model, std::string &path, PlateDataPtrs &partplate_data, std::vector< Preset * > &project_presets, std::vector< ThumbnailData * > &thumbnails, std::vector< ThumbnailData * > &no_light_thumbnails, std::vector< ThumbnailData * > &top_thumbnails, std::vector< ThumbnailData * > &pick_thumbnails, std::vector< ThumbnailData * > &calibration_thumbnails, std::vector< PlateBBoxData * > &plate_bboxes, const DynamicPrintConfig *config, bool minimum_save, int plate_to_export=-1)
bool	has_print_action () const
std::string	output_filepath (const Model &model, IO::ExportFormat format) const
std::string	output_filepath (const ModelObject &object, unsigned int index, IO::ExportFormat format, std::string path_dir) const

Private Attributes
DynamicPrintAndCLIConfig	m_config
DynamicPrintConfig	m_print_config
DynamicPrintConfig	m_extra_config
std::vector< std::string >	m_input_files
std::vector< std::string >	m_actions
std::vector< std::string >	m_transforms
std::set< std::string >	m_given_option_keys
std::vector< Model >	m_models

Detailed Description

Member Function Documentation

export_models()

bool CLI::export_models ( IO::ExportFormat format, std::string path = std::string() )

private

Exports loaded models to a file of the specified format, according to the options affecting output filename.

{
    for (Model &model : m_models) {
        const std::string path = this->output_filepath(model, format);
        bool success = true;
        switch (format) {
            //case IO::AMF: success = Slic3r::store_amf(path.c_str(), &model, nullptr, false); break;
            case IO::OBJ:
                success = Slic3r::store_obj(path.c_str(), &model);
                if (success)
                    BOOST_LOG_TRIVIAL(info) << "Model successfully exported to " << path << std::endl;
                else {
                    boost::nowide::cerr << "Model export to " << path << " failed" << std::endl;
                    return false;
                }
                break;
            case IO::STL:
            {
                unsigned int index = 1;
                for (ModelObject* model_object : model.objects)
                {
                    const std::string path = this->output_filepath(*model_object, index++, format, path_dir);
                    if (path.empty()) {
                        boost::nowide::cerr << "Could not create output directory for STL export" << std::endl;
                        return false;
                    }
                    success = Slic3r::store_stl(path.c_str(), model_object, true);
                    if (success)
                        BOOST_LOG_TRIVIAL(info) << "Model successfully exported to " << path << std::endl;
                    else {
                        boost::nowide::cerr << "Model export to " << path << " failed" << std::endl;
                        return false;
                    }
                }
                break;
            }
            //BBS: use bbs 3mf instead of original
            //case IO::TMF: success = Slic3r::store_bbs_3mf(path.c_str(), &model, nullptr, false); break;
            default: assert(false); break;
        }
    }
    return true;
}

References Slic3r::format(), m_models, Slic3r::IO::OBJ, output_filepath(), Slic3r::IO::STL, Slic3r::store_obj(), and Slic3r::store_stl().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

export_project()

bool CLI::export_project ( Model * model, std::string & path, PlateDataPtrs & partplate_data, std::vector< Preset * > & project_presets, std::vector< ThumbnailData * > & thumbnails, std::vector< ThumbnailData * > & no_light_thumbnails, std::vector< ThumbnailData * > & top_thumbnails, std::vector< ThumbnailData * > & pick_thumbnails, std::vector< ThumbnailData * > & calibration_thumbnails, std::vector< PlateBBoxData * > & plate_bboxes, const DynamicPrintConfig * config, bool minimum_save, int plate_to_export = -1 )

private

{
    //const std::string path = this->output_filepath(*model, IO::TMF);
    bool success = false;
 
    StoreParams store_params;
    store_params.path = path;
    store_params.model = model;
    store_params.plate_data_list = partplate_data;
    store_params.project_presets = project_presets;
    store_params.config = (DynamicPrintConfig*)config;
    store_params.thumbnail_data = thumbnails;
    store_params.no_light_thumbnail_data    = no_light_thumbnails;
    store_params.top_thumbnail_data = top_thumbnails;
    store_params.pick_thumbnail_data = pick_thumbnails;
    store_params.calibration_thumbnail_data = calibration_thumbnails;
    store_params.id_bboxes = plate_bboxes;
    store_params.strategy = SaveStrategy::Silence|SaveStrategy::WithGcode|SaveStrategy::SplitModel|SaveStrategy::UseLoadedId|SaveStrategy::ShareMesh;
    store_params.export_plate_idx = plate_to_export;
    if (minimum_save)
        store_params.strategy = store_params.strategy | SaveStrategy::SkipModel;
 
    success = Slic3r::store_bbs_3mf(store_params);
 
    if (success)
        BOOST_LOG_TRIVIAL(info) << "Project exported to " << path << std::endl;
    else {
        boost::nowide::cerr << "Project export to " << path << " failed" << std::endl;
        return false;
    }
    return true;
}

References Slic3r::StoreParams::calibration_thumbnail_data, Slic3r::StoreParams::config, Slic3r::StoreParams::export_plate_idx, Slic3r::StoreParams::id_bboxes, Slic3r::StoreParams::model, Slic3r::StoreParams::no_light_thumbnail_data, Slic3r::StoreParams::path, Slic3r::StoreParams::pick_thumbnail_data, Slic3r::StoreParams::plate_data_list, Slic3r::StoreParams::project_presets, Slic3r::ShareMesh, Slic3r::Silence, Slic3r::SkipModel, Slic3r::SplitModel, Slic3r::store_bbs_3mf(), Slic3r::StoreParams::strategy, Slic3r::StoreParams::thumbnail_data, Slic3r::StoreParams::top_thumbnail_data, Slic3r::UseLoadedId, and Slic3r::WithGcode.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

has_print_action()

bool Slic3r::CLI::has_print_action ( ) const

inlineprivate

{ return m_config.opt_bool("export_gcode") || m_config.opt_bool("export_sla"); }

References m_config.

output_filepath() [1/2]

std::string CLI::output_filepath ( const Model & model, IO::ExportFormat format ) const

private

{
    std::string ext;
    switch (format) {
        case IO::AMF: ext = ".zip.amf"; break;
        case IO::OBJ: ext = ".obj"; break;
        case IO::STL: ext = ".stl"; break;
        case IO::TMF: ext = ".3mf"; break;
        default: assert(false); break;
    };
    auto proposed_path = boost::filesystem::path(model.propose_export_file_name_and_path(ext));
    // use --output when available
    std::string cmdline_param = m_config.opt_string("outputdir");
    if (! cmdline_param.empty()) {
        // if we were supplied a directory, use it and append our automatically generated filename
        boost::filesystem::path cmdline_path(cmdline_param);
        if (boost::filesystem::is_directory(cmdline_path))
            proposed_path = cmdline_path / proposed_path.filename();
        else
            proposed_path = cmdline_param + ext;
    }
    return proposed_path.string();
}

References Slic3r::IO::AMF, Slic3r::format(), m_config, Slic3r::IO::OBJ, Slic3r::Model::propose_export_file_name_and_path(), Slic3r::IO::STL, and Slic3r::IO::TMF.

Referenced by export_models().

Here is the call graph for this function:

Here is the caller graph for this function:

output_filepath() [2/2]

std::string CLI::output_filepath ( const ModelObject & object, unsigned int index, IO::ExportFormat format, std::string path_dir ) const

private

{
    std::string ext, subdir, file_name, output_path;
    switch (format) {
        case IO::AMF:
            ext = ".zip.amf";
            subdir = "amf";
            break;
        case IO::OBJ:
            ext = ".obj";
            subdir = "obj";
            break;
        case IO::STL:
            ext = ".stl";
            subdir = "stl";
            break;
        case IO::TMF:
            ext = ".3mf";
            subdir = "3mf";
            break;
        default: assert(false); break;
    };
    // use --outputdir when available
    file_name = object.name.empty()?object.input_file:object.name;
    file_name = "obj_"+std::to_string(index)+"_"+file_name;
    size_t pos = file_name.rfind(ext), ext_pos = file_name.size() - ext.size();
    if ((pos == std::string::npos) || (pos != ext_pos))
        file_name += ext;
 
    BOOST_LOG_TRIVIAL(trace) << __FUNCTION__ << ": dir = "<< path_dir<<", file_name="<<file_name<< ", pos = "<<pos<<", ext_pos="<<ext_pos;
    if (path_dir.empty()) {
        std::string cmdline_param = m_config.opt_string("outputdir");
        if (! cmdline_param.empty()) {
            subdir = cmdline_param + "/" + subdir;
        }
    }
    else {
        subdir = path_dir;
    }
 
    output_path = subdir + "/"+file_name;
 
    boost::filesystem::path subdir_path(subdir);
    if (!boost::filesystem::exists(subdir_path)) {
        try {
            boost::filesystem::create_directories(subdir_path);
        } catch (const boost::filesystem::filesystem_error &ex) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": failed to create output directory " << subdir_path.string() << ": " << ex.what();
        }
        if (!boost::filesystem::exists(subdir_path)) {
            // Directory creation failed and won't succeed on a retry (same path, same cause) -
            // signal failure now instead of letting every object in the model repeat the same
            // doomed attempt and fail with a less specific "export failed" error later.
            return std::string();
        }
    }
    return output_path;
}

References Slic3r::IO::AMF, Slic3r::format(), m_config, Slic3r::IO::OBJ, Slic3r::IO::STL, Slic3r::IO::TMF, and Slic3r::trace().

Here is the call graph for this function:

print_help()

void CLI::print_help ( bool include_print_options = false, PrinterTechnology printer_technology = ptAny ) const

private

Prints usage of the CLI.

{
    attach_console_on_demand();
 
    boost::nowide::cout
        << SLIC3R_APP_KEY <<"-"<< SoftFever_VERSION << ":"
        << std::endl
        << "Usage: orca-slicer [ OPTIONS ] [ file.3mf/file.stl ... ]" << std::endl
        << std::endl
        << "OPTIONS:" << std::endl;
    cli_misc_config_def.print_cli_help(boost::nowide::cout, false);
    cli_transform_config_def.print_cli_help(boost::nowide::cout, false);
    cli_actions_config_def.print_cli_help(boost::nowide::cout, false);
 
    boost::nowide::cout
        << std::endl
        << "Print setting priorities:" << std::endl
        << "\t1) setting values from the command line (highest priority)"<< std::endl
        << "\t2) setting values loaded with --load-settings and --load-filaments" << std::endl
      << "\t3) setting values loaded from 3mf(lowest priority)" << std::endl;
 
    /*if (include_print_options) {
        boost::nowide::cout << std::endl;
        print_config_def.print_cli_help(boost::nowide::cout, true, [printer_technology](const ConfigOptionDef &def)
            { return printer_technology == ptAny || def.printer_technology == ptAny || printer_technology == def.printer_technology; });
    } else {
        boost::nowide::cout
            << std::endl
            << "Run --help-fff / --help-sla to see the full listing of print options." << std::endl;
    }*/
    // flush the output buffer
    boost::nowide::cout.flush();
    boost::nowide::cerr.flush();
}

References attach_console_on_demand(), Slic3r::cli_actions_config_def, Slic3r::cli_misc_config_def, Slic3r::cli_transform_config_def, and Slic3r::printer_technology().

Referenced by run(), and setup().

Here is the call graph for this function:

Here is the caller graph for this function:

run()

int CLI::run	(	int	argc,
		char **	argv )

{
    // Mark the main thread for the debugger and for runtime checks.
    set_current_thread_name("orcaslicer_main");
    // Save the thread ID of the main thread.
    save_main_thread_id();
 
#ifdef __WXGTK__
    // ------------------------------------------------------------------
    // Linux backend selection — runtime, based on GDK_BACKEND env var.
    //
    //   GDK_BACKEND unset (DEFAULT)    Wayland path.
    //                                  GTK auto-picks Wayland on Wayland
    //                                  sessions and X11 otherwise. WebKit
    //                                  XWayland-compositing workaround
    //                                  applied only when actually on
    //                                  XWayland. XInitThreads gated on
    //                                  DISPLAY presence.
    //
    //   GDK_BACKEND=x11   (OPT-IN)     X11/XWayland mode. Applies the
    //                                  v2.3.2 workarounds that the X11
    //                                  path benefits from: DRI_PRIME for
    //                                  AMD/nouveau PRIME, NVIDIA PRIME
    //                                  render offload (when nvidia.ko is
    //                                  loaded), XInitThreads. 
    //                                  Multi monitor is compromised
    //
    // WEBKIT_DISABLE_COMPOSITING_MODE is deliberately NOT set on the X11
    // opt-in path. The ~2020-era WebKit2GTK XWayland compositor bug it
    // worked around appears fixed in WebKit2GTK >= 2.42; leaving it
    // unset preserves WebKit hardware acceleration on Device / Setup
    // Wizard / login / store. The default path applies it only where it
    // forces GDK_BACKEND=x11 below (a build without EGL, so the app really
    // runs through XWayland), and only when the linked WebKitGTK predates
    // the fix (< 2.42), as a conservative fallback for older WebKit.
    // ------------------------------------------------------------------
    {
        const char* gdk_backend = ::getenv("GDK_BACKEND");
        // Match "x11" and comma-prefixed forms like "x11,wayland" (GTK
        // honours the first backend in the comma-separated list).
        const bool x11_opt_in = gdk_backend && boost::starts_with(gdk_backend, "x11");
 
        // NVIDIA's proprietary driver cannot back WebKitGTK's DMABUF renderer.
        // Force the shared-memory transport, which keeps compositing and threaded
        // scrolling; the second variable clears Debian/Ubuntu/openSUSE's isNVIDIA().
        if (::access("/proc/driver/nvidia/version", F_OK) == 0 && WebView::SupportsForceSharedMemory()) {
            ::setenv("WEBKIT_DMABUF_RENDERER_FORCE_SHM", "1", /* replace */ false);
            ::setenv("WEBKIT_FORCE_DMABUF_RENDERER", "1", /* replace */ false);
        }
 
        if (is_hypervisor_guest() && WebView::SupportsForceSharedMemory())
            ::setenv("WEBKIT_DMABUF_RENDERER_FORCE_SHM", "1", /* replace */ false);
 
        if (x11_opt_in) {
            // ===== X11 / XWayland (opted in via GDK_BACKEND=x11) =====
            BOOST_LOG_TRIVIAL(info) << "GDK_BACKEND=x11 detected; applying v2.3.2 X11/XWayland workarounds.";
 
            // On Linux dual-GPU systems, request the high-performance
            // discrete GPU. DRI_PRIME=1 handles AMD and nouveau PRIME
            // setups; harmless on single-GPU systems (Mesa ignores it).
            ::setenv("DRI_PRIME", "1", /* replace */ false);
 
            // For NVIDIA proprietary driver PRIME render offload, set
            // additional variables. Only set if the NVIDIA kernel module
            // is loaded to avoid breaking systems without NVIDIA.
            if (::access("/proc/driver/nvidia/version", F_OK) == 0) {
                ::setenv("__NV_PRIME_RENDER_OFFLOAD", "1", /* replace */ false);
                ::setenv("__GLX_VENDOR_LIBRARY_NAME", "nvidia", /* replace */ false);
            }
 
            // Tell Xlib we will be using threads, lest we crash when
            // GStreamer fires up. Safe to call here since the user has
            // explicitly opted into X11.
            #if __has_include(<X11/Xlib.h>)
            XInitThreads();
            #endif
        } else {
            // ===== Wayland default =====
 
            // Safety fallback: if wxWidgets was not built with EGL
            // support, native Wayland will crash in
            // wxGLCanvas::IsDisplaySupported() because the GLX backend
            // cannot access an X11 display. Force X11 mode in that case.
            // NOTE: Do NOT remove this block even after enabling
            // wxHAS_EGL in the build — it protects against builds where
            // deps were not rebuilt.
            #if !defined(wxHAS_EGL) || !wxHAS_EGL
            {
                const char* wayland_env = ::getenv("WAYLAND_DISPLAY");
                if (wayland_env && *wayland_env) {
                    BOOST_LOG_TRIVIAL(warning) << "Wayland detected but wxWidgets has no EGL support (wxHAS_EGL is OFF). Forcing X11 backend.";
                    ::setenv("GDK_BACKEND", "x11", true);
 
                    // GTK will use X11 in a Wayland session here, which is the
                    // one default-path case that really runs through XWayland.
                    // WebKit2GTK accelerated compositing could fail silently
                    // there on releases before 2.42, so force it off. Disabling
                    // it also turns off threaded scrolling, hence the gate.
                    if (WebView::NeedsCompositingWorkaround())
                        ::setenv("WEBKIT_DISABLE_COMPOSITING_MODE", "1", /* replace */ false);
                }
            }
            #endif
 
            // XInitThreads is needed before GStreamer may use Xlib. On
            // native Wayland without DISPLAY, GStreamer uses waylandsink
            // (no Xlib involved), so the call is skipped.
            #if __has_include(<X11/Xlib.h>)
            {
                const char* display_env = ::getenv("DISPLAY");
                if (display_env && *display_env) {
                    XInitThreads();
                }
            }
            #endif
        }
    }
#endif // __WXGTK__
 
  // Switch boost::filesystem to utf8.
    try {
        boost::nowide::nowide_filesystem();
    } catch (const std::runtime_error& ex) {
        std::string caption = std::string(SLIC3R_APP_FULL_NAME) + " Error";
        std::string text = std::string("boost::nowide::nowide_filesystem Failed!\n") + (
          SLIC3R_APP_FULL_NAME " will now terminate.\n\n") + ex.what();
    #if defined(_WIN32) && defined(SLIC3R_GUI)
        if (m_actions.empty())
          // Empty actions means Slicer is executed in the GUI mode. Show a GUI message.
            MessageBoxA(NULL, text.c_str(), caption.c_str(), MB_OK | MB_ICONERROR);
    #endif
        boost::nowide::cerr << text.c_str() << std::endl;
        return CLI_ENVIRONMENT_ERROR;
    }
 
    if (!this->setup(argc, argv))
    {
        boost::nowide::cerr << "setup params error" << std::endl;
        return CLI_INVALID_PARAMS;
    }
    BOOST_LOG_TRIVIAL(info) << "finished setup params, argc="<< argc << std::endl;
    std::string temp_path = per_user_temp_dir(wxFileName::GetTempDir().utf8_str().data(), per_user_temp_id());
    // Some consumers write into the temp root directly, so create it up front.
    try {
        boost::filesystem::create_directories(temp_path);
    } catch (const std::exception &ex) {
        BOOST_LOG_TRIVIAL(warning) << "failed to create per-user temp dir " << temp_path << ": " << ex.what();
    }
    set_temporary_dir(temp_path);
 
    // The Filament Track Switch flags are live-device state with no meaning in headless slicing;
    // default both off unless explicitly provided on the command line, so an old 3MF that had
    // them enabled still slices without the switch behavior.
    if (!m_extra_config.has("has_filament_switcher"))
        m_extra_config.set_key_value("has_filament_switcher", new ConfigOptionBool(false));
    if (!m_extra_config.has("enable_filament_dynamic_map"))
        m_extra_config.set_key_value("enable_filament_dynamic_map", new ConfigOptionBool(false));
 
    m_extra_config.apply(m_config, true);
    m_extra_config.normalize_fdm();
 
    PrinterTechnology printer_technology = get_printer_technology(m_config);
 
    //BBS: remove GCodeViewer as separate APP logic
    /*bool              start_as_gcodeviewer =
#ifdef _WIN32
            false;
#else
            // On Unix systems, the prusa-slicer binary may be symlinked to give the application a different meaning.
            boost::algorithm::iends_with(boost::filesystem::path(argv[0]).filename().string(), "gcodeviewer");
#endif // _WIN32*/
 
    bool translate_old = false, regenerate_thumbnails = false, keep_old_params = false, remove_wrapping_detect = false, filament_color_changed = false, downward_check = false;
    int current_printable_width, current_printable_depth, current_printable_height, shrink_to_new_bed = 0;
    int old_printable_height = 0, old_printable_width = 0, old_printable_depth = 0;
    Pointfs old_printable_area, old_exclude_area;
    float old_max_radius = 0.f, old_height_to_rod = 0.f, old_height_to_lid = 0.f;
    std::vector<double> old_max_layer_height, old_min_layer_height;
    std::string outfile_dir              =  m_config.opt_string("outputdir", true);
    const std::vector<std::string>              &load_configs               = m_config.option<ConfigOptionStrings>("load_settings", true)->values;
    const std::vector<std::string>              &uptodate_configs          = m_config.option<ConfigOptionStrings>("uptodate_settings", true)->values;
    const std::vector<std::string>              &uptodate_filaments          = m_config.option<ConfigOptionStrings>("uptodate_filaments", true)->values;
    std::vector<std::string>                    downward_settings          = m_config.option<ConfigOptionStrings>("downward_settings", true)->values;
    std::vector<std::string> downward_compatible_machines;
    //BBS: always use ForwardCompatibilitySubstitutionRule::Enable
    //const ForwardCompatibilitySubstitutionRule   config_substitution_rule = m_config.option<ConfigOptionEnum<ForwardCompatibilitySubstitutionRule>>("config_compatibility", true)->value;
    const ForwardCompatibilitySubstitutionRule   config_substitution_rule = ForwardCompatibilitySubstitutionRule::Enable;
    const std::vector<std::string>              &load_filaments           = m_config.option<ConfigOptionStrings>("load_filaments", true)->values;
    //skip model object logic
    const std::vector<int>                      &skip_objects             = m_config.option<ConfigOptionInts>("skip_objects", true)->values;
    std::map<int, bool>     skip_maps;
    bool   need_skip      = (skip_objects.size() > 0)?true:false;
    long long global_begin_time = 0, global_current_time;
    sliced_info_t sliced_info;
    // Read up front so result.json reports it for early failures too.
    sliced_info.strict_mode = m_config.opt_bool("strict");
    // --no-check skips the check behind the only NON_CRITICAL warning --strict acts on
    // (support needed but disabled), from the point it appears among the actions. The pair
    // would make --strict a no-op or depend on argument order, so refuse it.
    if (sliced_info.strict_mode && m_config.opt_bool("no_check")) {
        boost::nowide::cerr << "--strict cannot be combined with --no-check" << std::endl;
        record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
        flush_and_exit(CLI_INVALID_PARAMS);
    }
    std::map<std::string, std::string> record_key_values;
 
    ConfigOptionBool* downward_check_option = m_config.option<ConfigOptionBool>("downward_check");
    if (downward_check_option)
        downward_check = downward_check_option->value;
 
    // --inspect-mesh prints its JSON and exits, so any action that does work of its
    // own (slicing, exporting) would be skipped without notice. Reject those up front;
    // only options that merely tune how the input is loaded may come along.
    if (std::find(m_actions.begin(), m_actions.end(), "inspect_mesh") != m_actions.end()) {
        static const std::set<std::string> inspect_compatible = { "inspect_mesh", "uptodate", "load_defaultfila", "min_save",
                                                                  "mtcpp", "mstpp", "no_check", "normative_check", "pipe" };
        for (const std::string &action : m_actions) {
            if (inspect_compatible.count(action) == 0) {
                std::string flag = action;
                std::replace(flag.begin(), flag.end(), '_', '-');
                boost::nowide::cerr << "--inspect-mesh cannot be combined with --" << flag << std::endl;
                record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
                flush_and_exit(CLI_INVALID_PARAMS);
            }
        }
        // Without input there is nothing to inspect; fail rather than print nothing and exit 0.
        if (m_input_files.empty() && m_config.opt_string("load_assemble_list").empty()) {
            boost::nowide::cerr << "--inspect-mesh needs an input file or --load-assemble-list" << std::endl;
            record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
            flush_and_exit(CLI_INVALID_PARAMS);
        }
    }
 
    // --inspect-paint prints its JSON and exits, so any action that does work of its
    // own (slicing, exporting) would be skipped without notice. Reject those up front;
    // only options that merely tune how the input is loaded may come along.
    if (std::find(m_actions.begin(), m_actions.end(), "inspect_paint") != m_actions.end()) {
        static const std::set<std::string> inspect_compatible = { "inspect_paint", "uptodate", "load_defaultfila", "min_save",
                                                                  "mtcpp", "mstpp", "no_check", "normative_check", "pipe" };
        for (const std::string &action : m_actions) {
            if (inspect_compatible.count(action) == 0) {
                std::string flag = action;
                std::replace(flag.begin(), flag.end(), '_', '-');
                boost::nowide::cerr << "--inspect-paint cannot be combined with --" << flag << std::endl;
                record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
                flush_and_exit(CLI_INVALID_PARAMS);
            }
        }
        // Without input there is nothing to inspect; fail rather than print nothing and exit 0.
        if (m_input_files.empty() && m_config.opt_string("load_assemble_list").empty()) {
            boost::nowide::cerr << "--inspect-paint needs an input file or --load-assemble-list" << std::endl;
            record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
            flush_and_exit(CLI_INVALID_PARAMS);
        }
    }
 
    // --export-settings - writes its JSON to stdout, so reject every action or transform that may write there
    // too (--info, --help, --orient, slicing and exporting). The allowed ones do nothing when nothing is
    // sliced or exported.
    if (std::find(m_actions.begin(), m_actions.end(), "export_settings") != m_actions.end() && m_config.opt_string("export_settings") == "-") {
        static const std::set<std::string> stdout_compatible = { "export_settings", "uptodate", "load_defaultfila", "min_save",
                                                                 "mtcpp", "mstpp", "no_check", "normative_check", "pipe" };
        for (const std::vector<std::string> *opt_keys : { &m_actions, &m_transforms }) {
            for (const std::string &opt_key : *opt_keys) {
                if (stdout_compatible.count(opt_key) == 0) {
                    std::string flag = opt_key;
                    std::replace(flag.begin(), flag.end(), '_', '-');
                    boost::nowide::cerr << "--export-settings - cannot be combined with --" << flag << std::endl;
                    record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
                    flush_and_exit(CLI_INVALID_PARAMS);
                }
            }
        }
    }
 
    bool start_gui = m_actions.empty() && !downward_check;
    if (start_gui) {
        BOOST_LOG_TRIVIAL(info) << "no action, start gui directly" << std::endl;
#ifdef SLIC3R_GUI
    #if !defined(_WIN32) && !defined(__APPLE__)
        // likely some linux / unix system
        const char *display = boost::nowide::getenv("DISPLAY");
        const char *wayland_display = boost::nowide::getenv("WAYLAND_DISPLAY");
        if (! ((display && *display) || (wayland_display && *wayland_display))) {
            boost::nowide::cerr << "Neither DISPLAY nor WAYLAND_DISPLAY set, GUI mode not available." << std::endl << std::endl;
            this->print_help(false);
            // Indicate an error.
            return 1;
        }
    #endif // some linux / unix system
        Slic3r::GUI::GUI_InitParams params;
        params.argc = argc;
        params.argv = argv;
        params.load_configs = load_configs;
        params.extra_config = std::move(m_extra_config);
 
        std::vector<std::string>    gcode_files;
        std::vector<std::string>    non_gcode_files;
        for (const auto& filename : m_input_files) {
            if (is_gcode_file(filename))
                gcode_files.emplace_back(filename);
            else {
                non_gcode_files.emplace_back(filename);
            }
        }
        if (non_gcode_files.empty() && !gcode_files.empty()) {
            params.input_gcode = true;
            params.input_files  = std::move(gcode_files);
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ", gcode only, gcode_files size = "<<params.input_files.size();
        }
        else {
            params.input_files  = std::move(m_input_files);
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ", normal mode, input_files size = "<<params.input_files.size();
        }
        //BBS: remove GCodeViewer as separate APP logic
        //params.start_as_gcodeviewer = start_as_gcodeviewer;
 
        BOOST_LOG_TRIVIAL(info) << "begin to launch OrcaSlicer GUI soon";
        return Slic3r::GUI::GUI_Run(params);
#else // SLIC3R_GUI
        // No GUI support. Just print out a help.
        this->print_help(false);
        // If started without a parameter, consider it to be OK, otherwise report an error code (no action etc).
        return (argc == 0) ? 0 : 1;
#endif // SLIC3R_GUI
    }
 
    // Setup logging for CLI
    const ConfigOptionInt* opt_loglevel = m_config.opt<ConfigOptionInt>("debug");
    if (opt_loglevel) {
        set_logging_level(opt_loglevel->value);
    }
    else {
        set_logging_level(2);
    }
    const ConfigOptionString* opt_logfile = m_config.opt<ConfigOptionString>("logfile");
    if (opt_logfile) {
        set_logging_file(opt_logfile->value);
    }
 
    global_begin_time = (long long)Slic3r::Utils::get_current_time_utc();
    BOOST_LOG_TRIVIAL(warning) << boost::format("cli mode, Current OrcaSlicer Version %1%")%SoftFever_VERSION;
 
    //BBS: add plate data related logic
    PlateDataPtrs plate_data_src;
    std::vector<plate_obj_size_info_t> plate_obj_size_infos;
    //int arrange_option;
    int plate_to_slice = 0, filament_count = 0, duplicate_count = 0, real_duplicate_count = 0, current_extruder_count = 1, new_extruder_count = 1, current_printer_variant_count = 1, current_print_variant_count = 1, new_printer_variant_count = 1;
    bool first_file = true, is_bbl_3mf = false, need_arrange = true, has_thumbnails = false, up_config_to_date = false, normative_check = true, duplicate_single_object = false, use_first_fila_as_default = false, minimum_save = false, enable_timelapse = false;
    bool allow_rotations = false, skip_modified_gcodes = false, avoid_extrusion_cali_region = false, skip_useless_pick = false, allow_newer_file = false, current_is_multi_extruder = false, new_is_multi_extruder = false, allow_mix_temp = false, enable_wrapping_detect = false;
    Semver file_version;
    std::map<size_t, bool> orients_requirement;
    std::vector<Preset*> project_presets;
    std::vector<NozzleVolumeType> current_nozzle_volume_type, new_nozzle_volume_type;
    std::string new_printer_name, current_printer_name, new_process_name, current_process_name, current_printer_system_name, current_process_system_name, new_process_system_name, new_printer_system_name, printer_model_id, current_printer_model, printer_model, new_default_process_name;
    std::vector<std::string> upward_compatible_printers, new_print_compatible_printers, current_print_compatible_printers, current_different_settings;
    std::vector<std::string> current_filaments_name, current_filaments_system_name, current_inherits_group, current_extruder_variants, new_extruder_variants, current_print_extruder_variants, new_printer_extruder_variants;
    DynamicPrintConfig load_process_config, load_machine_config;
    //ORCA: full configs of the "current" (3MF-embedded) process/printer presets, kept so that
    //      compatible_printers_condition can be evaluated for them below. Previously only the
    //      literal compatible_printers list was extracted.
    DynamicPrintConfig current_process_full_config, current_printer_full_config;
    bool new_process_config_is_system = true, new_printer_config_is_system = true;
    std::string pipe_name, makerlab_name, makerlab_version, different_process_setting;
    const std::vector<std::string>              &metadata_name               = m_config.option<ConfigOptionStrings>("metadata_name", true)->values;
    const std::vector<std::string>              &metadata_value              = m_config.option<ConfigOptionStrings>("metadata_value", true)->values;
 
    if (metadata_name.size() != metadata_value.size())
    {
        BOOST_LOG_TRIVIAL(error) << boost::format("metadata_name should be the same size with metadata_value");
        record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
        flush_and_exit(CLI_INVALID_PARAMS);
    }
 
    // Read input file(s) if any.
    BOOST_LOG_TRIVIAL(info) << "Will start to read model file now, file count :" << m_input_files.size() << "\n";
    ConfigOptionInt* slice_option = m_config.option<ConfigOptionInt>("slice");
    if (slice_option)
        plate_to_slice = slice_option->value;
 
    ConfigOptionBool* normative_check_option = m_config.option<ConfigOptionBool>("normative_check");
    if (normative_check_option)
        normative_check = normative_check_option->value;
 
    ConfigOptionBool* uptodate_option = m_config.option<ConfigOptionBool>("uptodate");
    if (uptodate_option)
        up_config_to_date = uptodate_option->value;
 
    ConfigOptionBool* load_defaultfila_option = m_config.option<ConfigOptionBool>("load_defaultfila");
    if (load_defaultfila_option)
        use_first_fila_as_default = load_defaultfila_option->value;
 
    ConfigOptionBool* min_save_option = m_config.option<ConfigOptionBool>("min_save");
    if (min_save_option)
        minimum_save = min_save_option->value;
 
    ConfigOptionBool* enable_timelapse_option = m_config.option<ConfigOptionBool>("enable_timelapse");
    if (enable_timelapse_option)
        enable_timelapse = enable_timelapse_option->value;
 
    ConfigOptionBool* allow_rotations_option = m_config.option<ConfigOptionBool>("allow_rotations");
    if (allow_rotations_option)
        allow_rotations = allow_rotations_option->value;
    // Only an explicit --align-to-y-axis overrides the printer-structure default.
    std::optional<bool> align_to_y_axis;
    if (m_given_option_keys.count("align_to_y_axis") > 0)
        align_to_y_axis = m_config.opt_bool("align_to_y_axis");
 
    ConfigOptionBool* skip_modified_gcodes_option = m_config.option<ConfigOptionBool>("skip_modified_gcodes");
    if (skip_modified_gcodes_option)
        skip_modified_gcodes = skip_modified_gcodes_option->value;
 
    ConfigOptionBool* skip_useless_picks_option = m_config.option<ConfigOptionBool>("skip_useless_pick");
    if (skip_useless_picks_option)
        skip_useless_pick = skip_useless_picks_option->value;
 
    ConfigOptionBool* allow_newer_file_option = m_config.option<ConfigOptionBool>("allow_newer_file");
    if (allow_newer_file_option)
        allow_newer_file = allow_newer_file_option->value;
 
    ConfigOptionBool* allow_mix_temp_option = m_config.option<ConfigOptionBool>("allow_mix_temp");
    if (allow_mix_temp_option)
        allow_mix_temp = allow_mix_temp_option->value;
 
    const ConfigOptionBool* export_statistics_option = m_config.option<ConfigOptionBool>("export_statistics");
    const bool              export_statistics        = export_statistics_option != nullptr && export_statistics_option->value;
 
    ConfigOptionBool* avoid_extrusion_cali_region_option = m_config.option<ConfigOptionBool>("avoid_extrusion_cali_region");
    if (avoid_extrusion_cali_region_option)
        avoid_extrusion_cali_region = avoid_extrusion_cali_region_option->value;
 
    ConfigOptionString* pipe_option = m_config.option<ConfigOptionString>("pipe");
    if (pipe_option) {
        pipe_name = pipe_option->value;
        if (!pipe_name.empty()) {
            BOOST_LOG_TRIVIAL(info) << boost::format("Will use pipe %1%")%pipe_name;
#if defined(__linux__) || defined(__LINUX__)
            g_cli_callback_mgr.start(pipe_name);
            PrintBase::SlicingStatus slicing_status{1, "Start to load files"};
            cli_status_callback(slicing_status);
#endif
        }
    }
 
    ConfigOptionString* makerlab_name_option = m_config.option<ConfigOptionString>("makerlab_name");
    if (makerlab_name_option)
        makerlab_name = makerlab_name_option->value;
 
    ConfigOptionString* makerlab_version_option = m_config.option<ConfigOptionString>("makerlab_version");
    if (makerlab_version_option)
        makerlab_version = makerlab_version_option->value;
 
    //skip model object map construct
    if (need_skip) {
        BOOST_LOG_TRIVIAL(info) << boost::format("need to skip objects, size %1%:")%skip_objects.size();
        for (int index = 0; index < skip_objects.size(); index++)
        {
            skip_maps[skip_objects[index]] = false;
            BOOST_LOG_TRIVIAL(info) << boost::format("object %1%, id %2%")%index %skip_objects[index];
        }
    }
 
    std::string custom_gcode_file;
    ConfigOptionString* custom_gcode_option = m_config.option<ConfigOptionString>("load_custom_gcodes");
    if (custom_gcode_option)
        custom_gcode_file = custom_gcode_option->value;
 
    std::string load_assemble_list;
    std::vector<assemble_plate_info_t> assemble_plate_info_list;
    ConfigOptionString* load_assemble_list_option = m_config.option<ConfigOptionString>("load_assemble_list");
    if (load_assemble_list_option)
        load_assemble_list = load_assemble_list_option->value;
 
    bool allow_multicolor_oneplate = m_config.option<ConfigOptionBool>("allow_multicolor_oneplate", true)->value;
    const std::vector<int>  loaded_filament_ids  = m_config.option<ConfigOptionInts>("load_filament_ids", true)->values;
    const std::vector<int>  clone_objects  = m_config.option<ConfigOptionInts>("clone_objects", true)->values;
    //when load objects from stl/obj, the total used filaments set
    std::set<int> used_filament_set;
    BOOST_LOG_TRIVIAL(info) << boost::format("allow_multicolor_oneplate %1%, allow_rotations %2% skip_modified_gcodes %3% avoid_extrusion_cali_region %4% loaded_filament_ids size %5%, clone_objects size %6%, skip_useless_pick %7%, allow_newer_file %8%, allow_mix_temp %9%")
        %allow_multicolor_oneplate %allow_rotations %skip_modified_gcodes %avoid_extrusion_cali_region %loaded_filament_ids.size() %clone_objects.size() %skip_useless_pick %allow_newer_file %allow_mix_temp;
    if (clone_objects.size() > 0)
    {
        if (clone_objects.size() != m_input_files.size())
        {
            BOOST_LOG_TRIVIAL(error) << boost::format("clone_objects size %1% should be the same with input files size %2%")%clone_objects.size() %m_input_files.size();
            record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
            flush_and_exit(CLI_INVALID_PARAMS);
        }
        else if (load_filaments.size() == 0)
        {
            BOOST_LOG_TRIVIAL(error) << boost::format("clone_objects should be used with load_filaments together");
            record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
            flush_and_exit(CLI_INVALID_PARAMS);
        }
    }
    if (loaded_filament_ids.size() > 0)
    {
        if (loaded_filament_ids.size() != m_input_files.size())
        {
            BOOST_LOG_TRIVIAL(error) << boost::format("loaded_filament_ids size %1% should be the same with input files size %2%")%loaded_filament_ids.size() %m_input_files.size();
            record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
            flush_and_exit(CLI_INVALID_PARAMS);
        }
        else if (load_filaments.size() == 0)
        {
            BOOST_LOG_TRIVIAL(error) << boost::format("loaded_filament_ids should be used with load_filaments together");
            record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
            flush_and_exit(CLI_INVALID_PARAMS);
        }
    }
 
    /*for (const std::string& file : m_input_files)
        if (is_gcode_file(file) && boost::filesystem::exists(file)) {
            start_as_gcodeviewer = true;
            BOOST_LOG_TRIVIAL(info) << "found a gcode file:" << file << ", will start as gcode viewer\n";
            break;
        }*/
    BOOST_LOG_TRIVIAL(info) << boost::format("plate_to_slice=%1%, normative_check=%2%, use_first_fila_as_default=%3%")%plate_to_slice %normative_check %use_first_fila_as_default;
    unsigned int input_index = 0;
    std::vector<RGBA> input_obj_colours;
    if (!load_assemble_list.empty() && ((m_input_files.size() > 0) || (m_transforms.size() > 0)))
    {
        BOOST_LOG_TRIVIAL(error) << boost::format("load_assemble_list should not be used with input model files to load and should not be sued with transforms");
        record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
        flush_and_exit(CLI_INVALID_PARAMS);
    }
    if (load_assemble_list.empty()) {
        for (const std::string& file : m_input_files) {
            if (!boost::filesystem::exists(file)) {
                boost::nowide::cerr << "No such file: " << file << std::endl;
                record_exit_reson(outfile_dir, CLI_FILE_NOTFOUND, 0, cli_errors[CLI_FILE_NOTFOUND], sliced_info);
                flush_and_exit(CLI_FILE_NOTFOUND);
            }
            Model model;
            //BBS: add plate related logic
            //bool load_aux = false;
            BOOST_LOG_TRIVIAL(info) << "read model file:" << file << "\n";
            try {
                // When loading an AMF or 3MF, config is imported as well, including the printer technology.
                DynamicPrintConfig config;
                ConfigSubstitutionContext config_substitutions(config_substitution_rule);
 
                //FIXME should we check the version here? // | LoadStrategy::CheckVersion ?
                is_bbl_3mf = false;
                LoadStrategy strategy;
                if (boost::algorithm::iends_with(file, ".3mf") && first_file) {
                    if ((clone_objects.size() > 0) || (loaded_filament_ids.size() > 0))
                    {
                        BOOST_LOG_TRIVIAL(error) << boost::format("can not load 3mf when set loaded_filament_ids or clone_objects");
                        record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
                        flush_and_exit(CLI_INVALID_PARAMS);
                    }
                    strategy = LoadStrategy::LoadModel | LoadStrategy::LoadConfig|LoadStrategy::AddDefaultInstances | LoadStrategy::LoadAuxiliary;
                    //load_aux = true;
                }
                else {
                    strategy = LoadStrategy::LoadModel | LoadStrategy::AddDefaultInstances;
                }
                // BBS: adjust whebackup
                //LoadStrategy strategy = LoadStrategy::LoadModel | LoadStrategy::LoadConfig|LoadStrategy::AddDefaultInstances;
                //if (load_aux) strategy = strategy | LoadStrategy::LoadAuxiliary;
                model = Model::read_from_file(file, &config, &config_substitutions, strategy, &plate_data_src, &project_presets, &is_bbl_3mf, &file_version, nullptr, nullptr, nullptr, plate_to_slice);
                if (is_bbl_3mf)
                {
                    if (!first_file)
                    {
                        BOOST_LOG_TRIVIAL(info) << "The BBL 3mf file should be placed at the first position, filename=" << file << "\n";
                        record_exit_reson(outfile_dir, CLI_FILELIST_INVALID_ORDER, 0, cli_errors[CLI_FILELIST_INVALID_ORDER], sliced_info);
                        flush_and_exit(CLI_FILELIST_INVALID_ORDER);
                    }
                    BOOST_LOG_TRIVIAL(info) << boost::format("the first file is a 3mf, version %1%, got plate count %2%") %file_version.to_string() %plate_data_src.size();
                    need_arrange = false;
                    /*for (ModelObject* o : model.objects)
                    {
                        orients_requirement.insert(std::pair<size_t, bool>(o->id().id, false));
                        BOOST_LOG_TRIVIAL(info) << "object "<<o->name <<", id :" << o->id().id << ", from bbl 3mf\n";
                    }*/
 
                    Semver cli_ver = *Semver::parse(SoftFever_VERSION);
                    if (!allow_newer_file && ((cli_ver.maj() < file_version.maj()) || ((cli_ver.maj() == file_version.maj()) && (cli_ver.min() < file_version.min())))){
                        BOOST_LOG_TRIVIAL(error) << boost::format("Version Check: File Version %1% not supported by current cli version %2%")%file_version.to_string() %SoftFever_VERSION;
                        record_exit_reson(outfile_dir, CLI_FILE_VERSION_NOT_SUPPORTED, 0, cli_errors[CLI_FILE_VERSION_NOT_SUPPORTED], sliced_info);
                        flush_and_exit(CLI_FILE_VERSION_NOT_SUPPORTED);
                    }
                    Semver old_version(1, 5, 9), old_version2(1, 5, 9), old_version3(2, 0, 0), old_version4(2, 2, 0);
                    if ((file_version < old_version) && !config.empty()) {
                        translate_old = true;
                        BOOST_LOG_TRIVIAL(info) << boost::format("old 3mf version %1%, need to translate")%file_version.to_string();
                    }
                    if ((file_version < old_version2) && !config.empty()) {
                        regenerate_thumbnails = true;
                        BOOST_LOG_TRIVIAL(info) << boost::format("old 3mf version %1%, need to regenerate_thumbnails for all")%file_version.to_string();
                    }
 
                    if (file_version < old_version4) {
                        remove_wrapping_detect = true;
                        BOOST_LOG_TRIVIAL(info) << boost::format("old 3mf version %1%, need to set enable_wrapping_detection to false")%file_version.to_string();
                    }
 
                    // ORCA: legacy feature-filament default migration (1 -> 0) is now handled
                    // uniformly in PrintConfigDef::handle_legacy() via the old->new key rename
                    // (wall_filament -> wall_filament_id, etc.), which covers presets too.
 
                    if (normative_check) {
                        ConfigOptionStrings* postprocess_scripts = config.option<ConfigOptionStrings>("post_process");
                        if (postprocess_scripts) {
                            std::vector<std::string> postprocess_values = postprocess_scripts->values;
                            if (postprocess_values.size() > 0) {
                                BOOST_LOG_TRIVIAL(error) << boost::format("normative_check: postprocess not supported, array size %1%")%postprocess_values.size();
                                record_exit_reson(outfile_dir, CLI_POSTPROCESS_NOT_SUPPORTED, 0, cli_errors[CLI_POSTPROCESS_NOT_SUPPORTED], sliced_info);
                                flush_and_exit(CLI_POSTPROCESS_NOT_SUPPORTED);
                            }
                        }
                    }
 
                    /*for (ModelObject *model_object : model.objects)
                        for (ModelInstance *model_instance : model_object->instances)
                        {
                            const Vec3d &instance_offset = model_instance->get_offset();
                            BOOST_LOG_TRIVIAL(info) << boost::format("instance %1% transform {%2%,%3%,%4%} at %5%:%6%")% model_object->name % instance_offset.x() % instance_offset.y() %instance_offset.z() % __FUNCTION__ % __LINE__<< std::endl;
                        }*/
                    // Read defensively — a 3mf missing preset ids (e.g. one produced
                    // by a non-GUI writer) would otherwise crash here on the deref.
                    if (const auto *o = config.option<ConfigOptionString>("printer_settings_id"))  current_printer_name  = o->value;
                    if (const auto *o = config.option<ConfigOptionString>("print_settings_id"))    current_process_name  = o->value;
                    current_printer_model = config.option<ConfigOptionString>("printer_model", true)->value;
                    if (const auto *o = config.option<ConfigOptionStrings>("filament_settings_id")) current_filaments_name = o->values;
                    if (const auto *o = config.option<ConfigOptionFloats>("nozzle_diameter"))       current_extruder_count = o->values.size();
                    current_printer_variant_count = config.option<ConfigOptionStrings>("printer_extruder_variant", true)->values.size();
                    current_print_variant_count = config.option<ConfigOptionStrings>("print_extruder_variant", true)->values.size();
                    current_is_multi_extruder = current_extruder_count > 1;
                    //if (current_is_multi_extruder || (current_printer_variant_count > 1)) {
                        auto opt_extruder_type = dynamic_cast<const ConfigOptionEnumsGeneric*>(config.option("extruder_type"));
                        auto opt_nozzle_volume_type = dynamic_cast<const ConfigOptionEnumsGeneric*>(config.option("nozzle_volume_type"));
                        if (opt_nozzle_volume_type) {
                            int nozzle_volume_type_size = opt_nozzle_volume_type->values.size();
                            current_nozzle_volume_type.resize(nozzle_volume_type_size, nvtStandard);
                            for (int i = 0; i < nozzle_volume_type_size; i++)
                            {
                                current_nozzle_volume_type[i] = (NozzleVolumeType)(opt_nozzle_volume_type->values[i]);
                            }
                        }
 
                        current_extruder_variants.resize(current_extruder_count, "");
                        for (int e_index = 0; e_index < current_extruder_count; e_index++)
                        {
                            ExtruderType extruder_type = opt_extruder_type ? (ExtruderType)(opt_extruder_type->get_at(e_index)):etDirectDrive;
                            NozzleVolumeType nozzle_volume_type = opt_nozzle_volume_type?(NozzleVolumeType)(opt_nozzle_volume_type->get_at(e_index)) : nvtStandard;
                            current_extruder_variants[e_index] = get_extruder_variant_string(extruder_type, nozzle_volume_type);
                        }
                    //}
 
                    BOOST_LOG_TRIVIAL(info) << boost::format("current_printer_name %1%, current_process_name %2%")%current_printer_name %current_process_name;
                    ConfigOptionStrings* option_strings = config.option<ConfigOptionStrings>("inherits_group");
                    // One entry for the process, one per filament and one for the printer. A group of another
                    // length still has the process first and the printer last; one too short for that is ignored.
                    if (option_strings && option_strings->values.size() != current_filaments_name.size() + 2) {
                        boost::nowide::cerr << "Warning: inherits_group has " << option_strings->values.size() << " entries, expected "
                                            << current_filaments_name.size() + 2 << " for " << current_filaments_name.size() << " filaments" << std::endl;
                        if (option_strings->values.size() < 2)
                            option_strings = nullptr;
                    }
                    if (option_strings) {
                        current_inherits_group = option_strings->values;
                        size_t size = current_inherits_group.size();
                        if (current_inherits_group[size-1].empty()) {
                            current_printer_system_name = current_printer_name;
                            BOOST_LOG_TRIVIAL(info) << boost::format("inherits of printer is null, should be system preset");
                        }
                        else {
                            current_printer_system_name = current_inherits_group[size-1];
                            BOOST_LOG_TRIVIAL(info) << boost::format("inherits of printer valid, current_printer_system_name is %1%") %current_printer_system_name;
                        }
 
                        if (current_inherits_group[0].empty()) {
                            current_process_system_name = current_process_name;
                            BOOST_LOG_TRIVIAL(info) << boost::format("inherits of process is null, should be system preset");
                        }
                        else {
                            current_process_system_name = current_inherits_group[0];
                            BOOST_LOG_TRIVIAL(info) << boost::format("inherits of process valid, current_process_system_name is %1%") %current_process_system_name;
                        }
 
                        // A filament without an entry of its own counts as a system preset.
                        current_filaments_system_name = current_filaments_name;
                        for (size_t index = 1; index < size - 1 && index <= current_filaments_name.size(); index++) {
                            if (!current_inherits_group[index].empty())
                                current_filaments_system_name[index-1] = current_inherits_group[index];
                        }
                    }
                    else {
                        current_printer_system_name = current_printer_name;
                        current_process_system_name = current_process_name;
                        current_filaments_system_name = current_filaments_name;
                        BOOST_LOG_TRIVIAL(info) << boost::format("no inherits_group: use system name the same as current name");
                    }
                    filament_count = current_filaments_name.size();
                    upward_compatible_printers = config.option<ConfigOptionStrings>("upward_compatible_machine", true)->values;
                    current_print_compatible_printers  = config.option<ConfigOptionStrings>("print_compatible_printers", true)->values;
                    current_different_settings = config.option<ConfigOptionStrings>("different_settings_to_system", true)->values;
 
                    //use Pointfs insteadof Points
                    old_printable_area = config.option<ConfigOptionPoints>("printable_area", true)->values;
                    old_exclude_area = legacy_bed_exclude_area_points(config);
                    if (old_printable_area.size() >= 4) {
                        BoundingBoxf old_printable_bbox(old_printable_area);
                        old_printable_width = static_cast<int>(old_printable_bbox.size().x());
                        old_printable_depth = static_cast<int>(old_printable_bbox.size().y());
                    }
                    // A 3mf can carry an empty project_settings.config - the models in
                    // resources/handy_models do - and opt_float() dereferences without checking.
                    if (config.option<ConfigOptionFloat>("printable_height"))
                        old_printable_height = (int)(config.opt_float("printable_height"));
 
                    if (config.option<ConfigOptionFloat>("extruder_clearance_height_to_rod"))
                        old_height_to_rod = config.opt_float("extruder_clearance_height_to_rod");
                    if (config.option<ConfigOptionFloat>("extruder_clearance_height_to_lid"))
                        old_height_to_lid = config.opt_float("extruder_clearance_height_to_lid");
                    if (config.option<ConfigOptionFloat>("extruder_clearance_radius"))
                        old_max_radius = config.opt_float("extruder_clearance_radius");
                    if (config.option<ConfigOptionFloats>("max_layer_height"))
                        old_max_layer_height = config.option<ConfigOptionFloats>("max_layer_height")->values;
                    if (config.option<ConfigOptionFloats>("min_layer_height"))
                        old_min_layer_height = config.option<ConfigOptionFloats>("min_layer_height")->values;
                    BOOST_LOG_TRIVIAL(info) << boost::format("old printable size from 3mf: {%1%, %2%, %3%}")%old_printable_width %old_printable_depth %old_printable_height;
                    BOOST_LOG_TRIVIAL(info) << boost::format("old extruder_clearance_height_to_rod %1%, extruder_clearance_height_to_lid %2%, extruder_clearance_radius %3%}")%old_height_to_rod %old_height_to_lid %old_max_radius;
                }
                else
                {
                    need_arrange = true;
                    int object_extruder_id = 0, clone_count = 1;
                    if (loaded_filament_ids.size() > input_index) {
                        if (loaded_filament_ids[input_index] > 0) {
                            if (loaded_filament_ids[input_index] > load_filaments.size()) {
                                BOOST_LOG_TRIVIAL(error) << boost::format("invalid filament_id %1% at index %2%, max %3%")%loaded_filament_ids[input_index] % (input_index + 1) %load_filaments.size();
                                record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
                                flush_and_exit(CLI_INVALID_PARAMS);
                            }
                            object_extruder_id = loaded_filament_ids[input_index];
                            used_filament_set.emplace(object_extruder_id);
                        }
                    }
 
                    if (clone_objects.size() > input_index) {
                        if (clone_objects[input_index] > 0) {
                            if (clone_objects[input_index] > MAX_CLONEABLE_SIZE) {
                                BOOST_LOG_TRIVIAL(error) << boost::format("invalid clone count %1% at index %2%, max %3%")%clone_objects[input_index] % (input_index + 1) %MAX_CLONEABLE_SIZE;
                                record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
                                flush_and_exit(CLI_INVALID_PARAMS);
                            }
                            clone_count = clone_objects[input_index];
                        }
                    }
 
                    //clone objects process
                    if (clone_count > 1)
                    {
                        unsigned int object_count = model.objects.size();
 
                        for (unsigned int obj_index = 0; obj_index < object_count; obj_index++)
                        {
                            ModelObject* object = model.objects[obj_index];
 
                            for (unsigned int clone_index = 1; clone_index < clone_count; clone_index++)
                            {
                                ModelObject* newObj = model.add_object(*object);
                                newObj->name = object->name +"_"+ std::to_string(clone_index+1);
                            }
                            object->name = object->name +"_"+ std::to_string(1);
                        }
                    }
 
                    for (ModelObject* o : model.objects)
                    {
                        if (object_extruder_id != 0) {
                            o->config.set_key_value("extruder", new ConfigOptionInt(object_extruder_id));
                        }
 
                        //default not orient for all, if need to orient use the action
                        //orients_requirement.insert(std::pair<size_t, bool>(o->id().id, false));
                        BOOST_LOG_TRIVIAL(info) << "object "<<o->name <<", id :"  << o->id().id << ", from stl or other 3mf\n";
                        o->ensure_on_bed();
                    }
                }
                first_file = false;
 
                PrinterTechnology other_printer_technology = get_printer_technology(config);
                if (printer_technology == ptUnknown) {
                    printer_technology = other_printer_technology;
                }
                if ((printer_technology != other_printer_technology) && (other_printer_technology != ptUnknown)) {
                    boost::nowide::cerr << "invalid printer_technology " <<printer_technology<<", from source file "<< file <<std::endl;
                    record_exit_reson(outfile_dir, CLI_INVALID_PRINTER_TECH, 0, cli_errors[CLI_INVALID_PRINTER_TECH], sliced_info);
                    flush_and_exit(CLI_INVALID_PRINTER_TECH);
                }
                if (!config_substitutions.substitutions.empty()) {
                    BOOST_LOG_TRIVIAL(info) << "Found legacy configuration values, substituted when loading " << file << ":\n";
                    for (const ConfigSubstitution &subst : config_substitutions.substitutions)
                        BOOST_LOG_TRIVIAL(info) << "\tkey = \"" << subst.opt_def->opt_key << "\"\t old_value = \"" << subst.old_value << "\tnew_value = \"" << subst.new_value->serialize() << "\"\n";
                }
 
                // config is applied to m_print_config before the current m_config values.
                config += std::move(m_print_config);
                m_print_config = std::move(config);
                input_index++;
            }
            catch (std::exception& e) {
                boost::nowide::cerr << file << ": " << e.what() << std::endl;
                record_exit_reson(outfile_dir, CLI_DATA_FILE_ERROR, 0, cli_errors[CLI_DATA_FILE_ERROR], sliced_info);
                flush_and_exit(CLI_DATA_FILE_ERROR);
            }
            if (model.objects.empty()) {
                boost::nowide::cerr << "Error: file is empty: " << file << std::endl;
                continue;
            }
            m_models.push_back(std::move(model));
        }
    }
    else {
        //parse the json and assemble object here
        Model model;
 
        AssembleListResult list_result = load_assemble_plate_list(load_assemble_list, assemble_plate_info_list, MAX_PLATE_COUNT);
        int ret = CLI_SUCCESS;
        if (list_result == AssembleListResult::FileNotFound)
            ret = CLI_FILE_NOTFOUND;
        else if (list_result == AssembleListResult::ConfigError)
            ret = CLI_CONFIG_FILE_ERROR;
        if (ret) {
            record_exit_reson(outfile_dir, ret, 0, cli_errors[ret], sliced_info);
            flush_and_exit(ret);
        }
 
        try {
            ret = construct_assemble_list(assemble_plate_info_list, model, plate_data_src, input_obj_colours);
            if (ret) {
                record_exit_reson(outfile_dir, ret, 0, cli_errors[ret], sliced_info);
                flush_and_exit(ret);
            }
        }
        catch (std::exception& e) {
            boost::nowide::cerr << "construct_assemble_list: " << e.what() << std::endl;
            record_exit_reson(outfile_dir, CLI_DATA_FILE_ERROR, 0, cli_errors[CLI_DATA_FILE_ERROR], sliced_info);
            flush_and_exit(CLI_DATA_FILE_ERROR);
        }
        model.add_default_instances();
        m_models.push_back(std::move(model));
    }
 
    if (!is_bbl_3mf && plate_to_slice > 0)
    {
        BOOST_LOG_TRIVIAL(warning) << boost::format("%1%: not support to slice plate %2%, reset to 0")%__LINE__ %plate_to_slice;
        plate_to_slice = 0;
    }
 
    //load custom gcode file
    std::map<int, CustomGCode::Info> custom_gcodes_map;
    if (!custom_gcode_file.empty()) {
        // parse the custom gcode json file
        std::string file = custom_gcode_file;
        if(!boost::filesystem::exists(file)) {
            boost::nowide::cerr << __FUNCTION__ << ": can not find custom_gcode file: " << file << std::endl;
            record_exit_reson(outfile_dir, CLI_FILE_NOTFOUND, 0, cli_errors[CLI_FILE_NOTFOUND], sliced_info);
            flush_and_exit(CLI_FILE_NOTFOUND);
        }
        try {
            nlohmann::json jj;
            boost::nowide::ifstream ifs(file);
            ifs >> jj;
            ifs.close();
 
            int plate_id = 0;
            if (plate_to_slice == 0)
                plate_id = 0;
            else
                plate_id = plate_to_slice-1;
 
            CustomGCode::Info info;
            info.from_json(jj);
 
            custom_gcodes_map.emplace(plate_id, info);
            BOOST_LOG_TRIVIAL(info) << boost::format("load custom_gcode from file %1% success, store custom gcodes to plate %2%")%file %(plate_id+1);
        }
        catch (std::exception &ex) {
            boost::nowide::cerr << __FUNCTION__<< ":Loading custom-gcode file \"" << file << "\" failed: " << ex.what() << std::endl;
            record_exit_reson(outfile_dir, CLI_CONFIG_FILE_ERROR, 0, cli_errors[CLI_CONFIG_FILE_ERROR], sliced_info);
            flush_and_exit(CLI_CONFIG_FILE_ERROR);
        }
    }
 
    std::unique_ptr<PresetBundle> cli_preset_bundle;
    auto ensure_cli_preset_bundle = [&cli_preset_bundle](std::string &error) -> PresetBundle * {
        if (cli_preset_bundle)
            return cli_preset_bundle.get();
        try {
            AppConfig app_config;
            const std::string app_config_error = app_config.load_if_exists();
            if (!app_config_error.empty()) {
                BOOST_LOG_TRIVIAL(warning) << "Ignoring invalid app config during CLI preset resolution: " << app_config_error;
                app_config.reset();
            }
 
            auto bundle = std::make_unique<PresetBundle>();
            std::string load_error;
            bundle->load_presets(app_config, config_substitution_rule,
                                 PresetBundle::PresetPreferences(), &load_error, true);
            if (!load_error.empty()) {
                error = "Failed to load presets for inheritance resolution: " + load_error;
                return nullptr;
            }
            cli_preset_bundle = std::move(bundle);
            return cli_preset_bundle.get();
        } catch (const std::exception &ex) {
            error = ex.what();
            return nullptr;
        }
    };
 
    // One resolver for the whole run, so presets from the same vendor tree share its load.
    std::unique_ptr<PresetBundle> system_preset_resolver;
    auto ensure_system_preset_resolver = [&system_preset_resolver]() -> PresetBundle & {
        if (!system_preset_resolver)
            system_preset_resolver = std::make_unique<PresetBundle>();
        return *system_preset_resolver;
    };
    auto resolve_preset = [&ensure_cli_preset_bundle, &ensure_system_preset_resolver](const std::string &file, DynamicPrintConfig &config,
                                                                                      std::string &config_type, const std::string &config_from,
                                                                                      bool probe_type, std::string &error) {
        const auto *inherits = config.option<ConfigOptionString>(BBL_JSON_KEY_INHERITS);
        if (!probe_type && (inherits == nullptr || inherits->value.empty()))
            return true;
 
        PresetBundle                 *bundle = nullptr;
        bool                          allow_source_manifest = false;
        if (config_from == "system") {
            bundle                = &ensure_system_preset_resolver();
            allow_source_manifest = true;
        } else {
            bundle = ensure_cli_preset_bundle(error);
            if (bundle == nullptr)
                return false;
        }
 
        if (probe_type) {
            Preset::Type preset_type;
            if (!bundle->resolve_preset_config_type(config, preset_type, file, config_substitution_rule,
                                                    error, allow_source_manifest))
                return false;
            config_type = Preset::get_type_string(preset_type);
            return true;
        }
 
        Preset::Type preset_type;
        if (config_type == "process")
            preset_type = Preset::TYPE_PRINT;
        else if (config_type == "filament")
            preset_type = Preset::TYPE_FILAMENT;
        else if (config_type == "machine")
            preset_type = Preset::TYPE_PRINTER;
        else {
            error = "Unsupported preset type: " + config_type;
            return false;
        }
        return bundle->resolve_preset_config(config, preset_type, file, config_substitution_rule,
                                             error, allow_source_manifest);
    };
 
    //ORCA: list the keys a user preset overrides relative to its system parent, for the
    //      `different_settings_to_system` column of an exported 3MF. Without it the CLI
    //      writes an empty column, so re-opening a CLI-exported project in the GUI shows
    //      spurious "unsaved changes" and can revert inherited process/filament/machine
    //      values to system defaults.
    //
    //      The parent comes from the preset bundle that inherits resolution already builds,
    //      so this adds no extra loading. Returns "" whenever the parent cannot be resolved,
    //      which is exactly the previous behaviour.
    auto cli_different_settings = [&ensure_cli_preset_bundle](const DynamicPrintConfig &resolved,
                                                              const std::string        &parent_name,
                                                              Preset::Type              type) -> std::string {
        if (parent_name.empty())
            return std::string();
        std::string   error;
        PresetBundle *bundle = ensure_cli_preset_bundle(error);
        if (bundle == nullptr) {
            BOOST_LOG_TRIVIAL(warning) << "CLI: no preset bundle for different_settings_to_system: " << error;
            return std::string();
        }
        const PresetCollection *collection = nullptr;
        switch (type) {
        case Preset::TYPE_PRINT:    collection = &bundle->prints;    break;
        case Preset::TYPE_FILAMENT: collection = &bundle->filaments; break;
        case Preset::TYPE_PRINTER:  collection = &bundle->printers;  break;
        default:                    return std::string();
        }
        const Preset *parent = collection->find_preset2(parent_name, true);
        if (parent == nullptr) {
            BOOST_LOG_TRIVIAL(warning) << boost::format("CLI: parent preset '%1%' not found; leaving different_settings_to_system empty")%parent_name;
            return std::string();
        }
        std::vector<std::string> keys = resolved.diff(parent->config);
        //ORCA: preset metadata, not user-tunable settings. compatible_printers /
        //      compatible_prints have their own tracking columns and would double-count.
        keys.erase(std::remove_if(keys.begin(), keys.end(), [](const std::string &k) {
                       return k == "inherits" || k == "compatible_printers" || k == "compatible_prints"
                           || k == "compatible_printers_condition" || k == "compatible_prints_condition"
                           || k == "print_settings_id" || k == "filament_settings_id" || k == "printer_settings_id";
                   }),
                   keys.end());
        BOOST_LOG_TRIVIAL(info) << boost::format("CLI: %1% overrides vs parent '%2%'")%keys.size()%parent_name;
        return Slic3r::escape_strings_cstyle(keys);
    };
 
    auto load_config_file = [&resolve_preset](const std::string& file, DynamicPrintConfig& config, std::string& config_type,
                                std::string& config_name, std::string& filament_id, std::string& config_from) {
        if (! boost::filesystem::exists(file)) {
            boost::nowide::cerr << __FUNCTION__<< ": can not find setting file: " << file << std::endl;
            return CLI_FILE_NOTFOUND;
        }
        ConfigSubstitutions config_substitutions;
        try {
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__<< ":load setting file "<< file << ", with rule "<< config_substitution_rule << std::endl;
            std::map<std::string, std::string> key_values;
            std::string reason;
 
            config_substitutions = config.load_from_json(file, config_substitution_rule, key_values, reason);
            if (!reason.empty()) {
                BOOST_LOG_TRIVIAL(error) <<__FUNCTION__<<  ":Can not load config from file "<<file<<"\n";
                return CLI_CONFIG_FILE_ERROR;
            }
 
            config_name = key_values[BBL_JSON_KEY_NAME];
            auto from_iter = key_values.find(BBL_JSON_KEY_FROM);
            if (from_iter != key_values.end()) {
                config_from = from_iter->second;
            }
            if ((config_from != "system")&&(config_from != "User")&&(config_from != "user")) {
                boost::nowide::cerr <<__FUNCTION__ << boost::format(":file %1%'s from %2% unsupported") % file % config_from;
                return CLI_CONFIG_FILE_ERROR;
            }
 
            auto type_iter = key_values.find(BBL_JSON_KEY_TYPE);
            const bool probe_type = type_iter == key_values.end();
            if (!probe_type)
                config_type = type_iter->second;
 
            if (!resolve_preset(file, config, config_type, config_from, probe_type, reason)) {
                boost::nowide::cerr << __FUNCTION__ << boost::format(": can not resolve preset %1%: %2%") % file % reason << std::endl;
                return CLI_CONFIG_FILE_ERROR;
            }
 
            if (config_type == "machine") {
                //config.set("printer_settings_id", config_name, true);
                //printer_inherits = config.option<ConfigOptionString>("inherits", true)->value;
            }
            else if (config_type == "process") {
                //config.set("print_settings_id", config_name, true);
                //print_inherits = config.option<ConfigOptionString>("inherits", true)->value;
            }
            else if (config_type == "filament") {
                auto filament_id_iter = key_values.find(BBL_JSON_KEY_FILAMENT_ID);
                if (filament_id_iter != key_values.end())
                    filament_id = filament_id_iter->second;
            }
            else {
                boost::nowide::cerr <<__FUNCTION__ << boost::format(": unknown config type %1% of file %2% in load-settings") % config_type % file;
                return CLI_CONFIG_FILE_ERROR;
            }
            config.normalize_fdm();
 
            if (! config_substitutions.empty()) {
                BOOST_LOG_TRIVIAL(info) << "Found legacy configuration values, substituted when loading " << file << ":\n";
                for (const ConfigSubstitution &subst : config_substitutions)
                    BOOST_LOG_TRIVIAL(info) << "\tkey = \"" << subst.opt_def->opt_key << "\"\t old_value = \"" << subst.old_value << "\tnew_value = \"" << subst.new_value->serialize() << "\"\n";
            }
            else {
                BOOST_LOG_TRIVIAL(info) << "no substitutions performed from file " << file << "\n";
            }
            //config.erase("inherits");
            //config.erase("compatible_printers");
            //BOOST_LOG_TRIVIAL(info) << "got printable_area "<< config.option("printable_area")->serialize() << std::endl;
        } catch (std::exception &ex) {
            boost::nowide::cerr << __FUNCTION__<< ":Loading setting file \"" << file << "\" failed: " << ex.what() << std::endl;
            return CLI_CONFIG_FILE_ERROR;
        }
        return 0;
    };
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__<< ":before load settings, file count="<< load_configs.size() << std::endl;
    //std::vector<std::string> filament_compatible_printers;
    // load config files supplied via --load
    for (auto const &file : load_configs) {
        DynamicPrintConfig  config;
        std::string config_type, config_name, filament_id, config_from;
        int ret = load_config_file(file, config, config_type, config_name, filament_id, config_from);
        if (ret) {
            record_exit_reson(outfile_dir, ret, 0, cli_errors[ret], sliced_info);
            flush_and_exit(ret);
        }
 
        if (config_type == "machine") {
            if (!new_printer_name.empty()) {
                boost::nowide::cerr << "duplicate machine config file: " << file << std::endl;
                record_exit_reson(outfile_dir, CLI_CONFIG_FILE_ERROR, 0, cli_errors[CLI_CONFIG_FILE_ERROR], sliced_info);
                flush_and_exit(CLI_CONFIG_FILE_ERROR);
            }
            new_printer_name = config_name;
            if (config_from == "system") {
                new_printer_system_name = new_printer_name;
                new_printer_config_is_system = true;
            }
            else {
                new_printer_system_name = config.option<ConfigOptionString>("inherits", true)->value;
                new_printer_config_is_system = false;
            }
            config.set("printer_settings_id", new_printer_name, true);
 
            //get printer_model_id
            printer_model = config.option<ConfigOptionString>("printer_model", true)->value;
            if (!printer_model.empty()) {
                std::string printer_model_path = resources_dir() + "/profiles/BBL/machine_full/"+printer_model+".json";
                if (boost::filesystem::exists(printer_model_path))
                {
                    std::map<std::string, std::string> key_values;
 
                    load_key_values_from_json(printer_model_path, key_values);
                    if (key_values.find("model_id") != key_values.end()) {
                        printer_model_id = key_values["model_id"];
                        BOOST_LOG_TRIVIAL(info) << __FUNCTION__<< boost::format(":%1%, load printer_model_id %2% from current printer model %3%")%__LINE__ %printer_model_id %printer_model;
                    }
                }
            }
            //new_default_process_name
            if (config.option<ConfigOptionString>("default_print_profile"))
                new_default_process_name = config.option<ConfigOptionString>("default_print_profile")->value;
 
            //printer_inherits = config.option<ConfigOptionString>("inherits", true)->value;
            load_machine_config = std::move(config);
            BOOST_LOG_TRIVIAL(info) << boost::format("loaded machine config %1%, type %2%, name %3%, inherits %4%, printer_model_id %5%")%file %config_name %config_from % new_printer_system_name %printer_model_id;
        }
        else if (config_type == "process") {
            if (!new_process_name.empty()) {
                boost::nowide::cerr << "duplicate process config file: " << file << std::endl;
                record_exit_reson(outfile_dir, CLI_CONFIG_FILE_ERROR, 0, cli_errors[CLI_CONFIG_FILE_ERROR], sliced_info);
                flush_and_exit(CLI_CONFIG_FILE_ERROR);
            }
            new_process_name = config_name;
            if (config_from == "system") {
                new_process_system_name = new_process_name;
                new_process_config_is_system = true;
            }
            else {
                new_process_system_name = config.option<ConfigOptionString>("inherits", true)->value;
                new_process_config_is_system = false;
            }
            config.set("print_settings_id", new_process_name, true);
            //print_inherits = config.option<ConfigOptionString>("inherits", true)->value;
            new_print_compatible_printers = config.option<ConfigOptionStrings>("compatible_printers", true)->values;
 
            if (!is_bbl_3mf && config.option<ConfigOptionStrings>("different_settings_to_system")) {
                std::vector<std::string> diff_settings = config.option<ConfigOptionStrings>("different_settings_to_system")->values;
                different_process_setting = diff_settings[0];
            }
            load_process_config = std::move(config);
            BOOST_LOG_TRIVIAL(info) << boost::format("loaded process config %1%, type %2%, name %3%, inherits %4%")%file %config_name %config_from % new_process_system_name;
        }
 
        PrinterTechnology other_printer_technology = get_printer_technology(config);
        if (printer_technology == ptUnknown) {
            printer_technology = other_printer_technology;
        }
 
        if ((printer_technology != other_printer_technology)&&(other_printer_technology != ptUnknown)){
            boost::nowide::cerr << "invalid printer_technology " <<printer_technology<<", from config "<< file <<std::endl;
            record_exit_reson(outfile_dir, CLI_INVALID_PRINTER_TECH, 0, cli_errors[CLI_INVALID_PRINTER_TECH], sliced_info);
            flush_and_exit(CLI_INVALID_PRINTER_TECH);
        }
    }
 
    //load filaments files
    int load_filament_count = load_filaments.size();
    std::vector<int> load_filaments_index;
    std::set<std::string> load_filaments_set;
    bool disable_wipe_tower_after_mapping = false;
    std::vector<DynamicPrintConfig> load_filaments_config;
    std::vector<std::string> load_filaments_id;
    std::vector<std::string> load_filaments_name, load_filaments_inherit;
    int current_index = 0;
    std::string default_load_fila_name, default_load_fila_id, default_filament_file, default_filament_inherit;
    DynamicPrintConfig  default_load_fila_config;
    if (use_first_fila_as_default) {
        //construct default filament
        for (int index = 0; index < load_filament_count; index++) {
            const std::string& file = load_filaments[index];
            if (default_filament_file.empty() && !file.empty()) {
                DynamicPrintConfig  config;
                std::string config_type, config_name, filament_id, config_from;
                int ret = load_config_file(file, config, config_type, config_name, filament_id, config_from);
                if (ret) {
                    record_exit_reson(outfile_dir, ret, 0, cli_errors[ret], sliced_info);
                    flush_and_exit(ret);
                }
 
                if (config_type != "filament") {
                    BOOST_LOG_TRIVIAL(error) <<__FUNCTION__ << boost::format(": unknown config type %1% of file %2% in load-filaments") % config_type % file;
                    record_exit_reson(outfile_dir, CLI_CONFIG_FILE_ERROR, 0, cli_errors[CLI_CONFIG_FILE_ERROR], sliced_info);
                    flush_and_exit(CLI_CONFIG_FILE_ERROR);
                }
 
                if ((config_from == "User")||(config_from == "user")) {
                    default_filament_inherit = config.option<ConfigOptionString>("inherits", true)->value;
                }
 
                default_filament_file = file;
                default_load_fila_name = config_name;
                default_load_fila_id = filament_id;
                default_load_fila_config = std::move(config);
 
                BOOST_LOG_TRIVIAL(info) << boost::format("loaded default filament config %1%, type %2%, name %3%, inherits %4%")%file  %config_from %config_name % default_filament_inherit;
                break;
            }
        }
        if ((load_filament_count > 0) && default_filament_file.empty())
        {
            BOOST_LOG_TRIVIAL(error) <<__FUNCTION__ << boost::format(": load_filament_count is %1%, but can not load a default filament") % load_filament_count;
            record_exit_reson(outfile_dir, CLI_CONFIG_FILE_ERROR, 0, cli_errors[CLI_CONFIG_FILE_ERROR], sliced_info);
            flush_and_exit(CLI_CONFIG_FILE_ERROR);
        }
    }
    for (int index = 0; index < load_filament_count; index++) {
        const std::string& file = load_filaments[index];
        current_index++;
        if (!file.empty()) {
            DynamicPrintConfig  config;
            std::string config_type, config_name, filament_id, config_from;
            int ret = load_config_file(file, config, config_type, config_name, filament_id, config_from);
            if (ret) {
                record_exit_reson(outfile_dir, ret, 0, cli_errors[ret], sliced_info);
                flush_and_exit(ret);
            }
 
            if (config_type != "filament") {
                BOOST_LOG_TRIVIAL(error) <<__FUNCTION__ << boost::format(": unknown config type %1% of file %2% in load-filaments") % config_type % file;
                record_exit_reson(outfile_dir, CLI_CONFIG_FILE_ERROR, 0, cli_errors[CLI_CONFIG_FILE_ERROR], sliced_info);
                flush_and_exit(CLI_CONFIG_FILE_ERROR);
            }
 
            PrinterTechnology other_printer_technology = get_printer_technology(config);
            if (printer_technology == ptUnknown) {
                printer_technology = other_printer_technology;
            }
            if ((printer_technology != other_printer_technology) && (other_printer_technology != ptUnknown)) {
                BOOST_LOG_TRIVIAL(error) << "invalid printer_technology " <<printer_technology<<", from filament file "<< file;
                record_exit_reson(outfile_dir, CLI_INVALID_PRINTER_TECH, 0, cli_errors[CLI_INVALID_PRINTER_TECH], sliced_info);
                flush_and_exit(CLI_INVALID_PRINTER_TECH);
            }
            std::string inherits;
            if ((config_from == "User")||(config_from == "user")) {
                inherits = config.option<ConfigOptionString>("inherits", true)->value;
            }
            load_filaments_inherit.push_back(inherits);
            load_filaments_id.push_back(filament_id);
            load_filaments_name.push_back(config_name);
            load_filaments_config.push_back(std::move(config));
            load_filaments_index.push_back(current_index);
 
            load_filaments_set.emplace(config_name);
 
            BOOST_LOG_TRIVIAL(info) << boost::format("loaded filament %1% from file %2%, type %3%, name %4%, inherits %5%")%(index+1) %file %config_from %config_name % inherits;
        }
        else {
            if (use_first_fila_as_default) {
                BOOST_LOG_TRIVIAL(info)<<__FUNCTION__ << boost::format(": load filament %1% from default, config name %2%, filament_id %3%, current_index %4%") % (index+1) % default_load_fila_name %default_load_fila_id %current_index;
                load_filaments_id.push_back(default_load_fila_id);
                load_filaments_name.push_back(default_load_fila_name);
                load_filaments_config.push_back(default_load_fila_config);
                load_filaments_index.push_back(current_index);
                load_filaments_inherit.push_back(default_filament_inherit);
 
                load_filaments_set.emplace(default_load_fila_name);
            }
            continue;
        }
    }
 
    //add logic for obj auto colors
    if (input_obj_colours.size() > 0) {
        BOOST_LOG_TRIVIAL(info) << boost::format("%1%:%2%, got input obj colors %3%")%__FUNCTION__ %__LINE__ %input_obj_colours.size();
        int input_color_count = input_obj_colours.size();
        if (load_filament_count == 0) {
            BOOST_LOG_TRIVIAL(error) << boost::format("filament config not loaded when loading colored obj");
            record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
            flush_and_exit(CLI_INVALID_PARAMS);
        }
 
        //check filament_color from extra config
        ConfigOptionStrings *selected_filament_colors_option = m_extra_config.option<ConfigOptionStrings>("filament_colour");
        if (selected_filament_colors_option) {
            BOOST_LOG_TRIVIAL(error) << boost::format("filament_colour should not be set when loading colored obj");
            record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
            flush_and_exit(CLI_INVALID_PARAMS);
        }
        if (load_filament_count < input_color_count) {
            int delta = input_color_count - load_filament_count;
            for (int index = 0; index < delta; index++) {
                load_filaments_id.push_back(load_filaments_id[0]);
                load_filaments_name.push_back(load_filaments_name[0]);
                load_filaments_config.push_back(load_filaments_config[0]);
                load_filaments_index.push_back(index+1+load_filament_count);
                load_filaments_inherit.push_back(load_filaments_inherit[0]);
            }
            load_filament_count = input_color_count;
        }
 
        selected_filament_colors_option = m_extra_config.option<ConfigOptionStrings>("filament_colour", true);
        std::vector<std::string>& filament_colors = selected_filament_colors_option->values;
        filament_colors.resize(input_color_count);
        for (int index = 0; index < input_color_count; index++)
        {
            std::string color_string;
            int color[4];
            color[0] = std::clamp((int) (input_obj_colours[index][0] * 255.f), 0, 255);
            color[1] = std::clamp((int) (input_obj_colours[index][1] * 255.f), 0, 255);
            color[2] = std::clamp((int) (input_obj_colours[index][2] * 255.f), 0, 255);
            color[3] = std::clamp((int) (input_obj_colours[index][3] * 255.f), 0, 255);
 
            std::stringstream stream;
            stream << std::hex << std::uppercase << std::setfill('0') << std::setw(2) << color[0];
            stream << std::hex << std::uppercase << std::setfill('0') << std::setw(2) << color[1];
            stream << std::hex << std::uppercase << std::setfill('0') << std::setw(2) << color[2];
            stream << std::hex << std::uppercase << std::setfill('0') << std::setw(2) << color[3];
            std::string result(stream.str());
 
            filament_colors[index] = "#" + result;
 
            BOOST_LOG_TRIVIAL(info) << boost::format("%1%:%2%, index %3%, argb {%4%,%5%,%6%,%7%} to string %8%")%__FUNCTION__ %__LINE__ %(index+1) %color[0] %color[1] %color[2] %color[3] %filament_colors[index];
        }
    }
 
    if (filament_count == 0)
        filament_count = load_filament_count;
 
    if (is_bbl_3mf && (load_filament_count > 0) && (load_filaments_set.size() == 1))
    {
        disable_wipe_tower_after_mapping = true;
        BOOST_LOG_TRIVIAL(info) << boost::format("map all the filaments to the same one, load_filament_count %1%")%load_filament_count;
    }
 
    //load system config if needed
    bool fetch_compatible_values = false, fetch_upward_values = false;
    if (is_bbl_3mf && up_config_to_date) {
        if (uptodate_configs.size() > 0)
        {
            for (auto const &file : uptodate_configs) {
                DynamicPrintConfig  config;
                std::string config_type, config_name, filament_id, config_from;
                int ret = load_config_file(file, config, config_type, config_name, filament_id, config_from);
                if (ret) {
                    record_exit_reson(outfile_dir, ret, 0, cli_errors[ret], sliced_info);
                    flush_and_exit(ret);
                }
 
                if (config_type == "machine") {
                    if ( config_name != current_printer_system_name ) {
                        BOOST_LOG_TRIVIAL(error) << boost::format("wrong machine config file %1% loaded, current machine config name %2% ")%config_name %current_printer_system_name;
                        record_exit_reson(outfile_dir, CLI_CONFIG_FILE_ERROR, 0, cli_errors[CLI_CONFIG_FILE_ERROR], sliced_info);
                        flush_and_exit(CLI_CONFIG_FILE_ERROR);
                    }
                    upward_compatible_printers = config.option<ConfigOptionStrings>("upward_compatible_machine", true)->values;
                    BOOST_LOG_TRIVIAL(info) << boost::format("load a machine config %1% from file %2%, upward_compatible_printers size is %3% ")%config_name %file %upward_compatible_printers.size();
                    if (new_printer_name.empty() && !current_printer_system_name.empty())
                    {
                        config.set("printer_settings_id", config_name, true);
 
                        //get printer_model_id
                        printer_model = config.option<ConfigOptionString>("printer_model", true)->value;
                        if (!printer_model.empty()) {
                            std::string printer_model_path = resources_dir() + "/profiles/BBL/machine_full/"+printer_model+".json";
                            if (boost::filesystem::exists(printer_model_path))
                            {
                                std::map<std::string, std::string> key_values;
 
                                load_key_values_from_json(printer_model_path, key_values);
                                if (key_values.find("model_id") != key_values.end()) {
                                    printer_model_id = key_values["model_id"];
                                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__<< boost::format(":%1%, load printer_model_id %2% from current printer model %3%")%__LINE__ %printer_model_id %printer_model;
                                }
                            }
                        }
 
                        int orig_printable_width = 0, orig_printable_depth = 0, orig_printable_height = 0;
                        Pointfs orig_printable_area;
                        orig_printable_area = config.option<ConfigOptionPoints>("printable_area", true)->values;
                        if (orig_printable_area.size() >= 4) {
                            BoundingBoxf orig_printable_bbox(orig_printable_area);
                            orig_printable_width = static_cast<int>(orig_printable_bbox.size().x());
                            orig_printable_depth = static_cast<int>(orig_printable_bbox.size().y());
                        }
                        if (config.option<ConfigOptionFloat>("printable_height"))
                            orig_printable_height = (int)(config.opt_float("printable_height"));
                        BOOST_LOG_TRIVIAL(info) << __FUNCTION__<< boost::format(":%1%, check printable size: old_printable_width=%2%, orig_printable_width=%3%, old_printable_depth=%4%, orig_printable_depth=%5%, old_printable_height=%6%, orig_printable_height=%7%")
                                    %__LINE__ %old_printable_width %orig_printable_width %old_printable_depth %orig_printable_depth %old_printable_height %orig_printable_height;
                        if ((orig_printable_width > 0) && (orig_printable_depth > 0) && (orig_printable_height > 0))
                        {
                            if ((old_printable_width > orig_printable_width) || (old_printable_depth > orig_printable_depth) || (old_printable_height > orig_printable_height))
                            {
                                std::string error_str = (boost::format("Printer Settings: the printable size {%1%, %2%, %3%} exceeds the default size.")%old_printable_width %old_printable_depth %old_printable_height).str();
                                BOOST_LOG_TRIVIAL(error) << error_str;
                                record_exit_reson(outfile_dir, CLI_MODIFIED_PARAMS_TO_PRINTER, 0, error_str, sliced_info);
                                flush_and_exit(CLI_MODIFIED_PARAMS_TO_PRINTER);
                            }
                        }
 
                        load_machine_config = std::move(config);
                    }
                }
                else if (config_type == "process") {
                    if ( config_name != current_process_system_name ) {
                        BOOST_LOG_TRIVIAL(error) << boost::format("wrong process config file %1% loaded, current process config name %2% ")%config_name %current_process_system_name;
                        record_exit_reson(outfile_dir, CLI_CONFIG_FILE_ERROR, 0, cli_errors[CLI_CONFIG_FILE_ERROR], sliced_info);
                        flush_and_exit(CLI_CONFIG_FILE_ERROR);
                    }
                    current_print_compatible_printers  = config.option<ConfigOptionStrings>("compatible_printers", true)->values;
                    BOOST_LOG_TRIVIAL(info) << boost::format("load a process config %1% from file %2%, current_print_compatible_printers size is %3% ")%config_name %file %current_print_compatible_printers.size();
                    if (new_process_name.empty() && !current_process_system_name.empty())
                    {
                        config.set("print_settings_id", config_name, true);
                        load_process_config = std::move(config);
                    }
                }
                else {
                    BOOST_LOG_TRIVIAL(error) << boost::format("found invalid config type %1% from config %2% ")%config_type %file;
                    record_exit_reson(outfile_dir, CLI_CONFIG_FILE_ERROR, 0, cli_errors[CLI_CONFIG_FILE_ERROR], sliced_info);
                    flush_and_exit(CLI_CONFIG_FILE_ERROR);
                }
            }
        }
        else {
            if (new_printer_name.empty() && !current_printer_system_name.empty()) {
                //use the original printer name in 3mf
                std::string system_printer_path = resources_dir() + "/profiles/BBL/machine_full/"+current_printer_system_name+".json";
                if (! boost::filesystem::exists(system_printer_path)) {
                    BOOST_LOG_TRIVIAL(warning) << __FUNCTION__<< boost::format(":%1%, can not find system preset file: %2% ")%__LINE__ %system_printer_path;
                    //use original one
                }
                else {
                    DynamicPrintConfig  config;
                    std::string config_type, config_name, filament_id, config_from;
                    int ret = load_config_file(system_printer_path, config, config_type, config_name, filament_id, config_from);
                    if (ret) {
                        record_exit_reson(outfile_dir, ret, 0, cli_errors[ret], sliced_info);
                        flush_and_exit(ret);
                    }
 
                    upward_compatible_printers = config.option<ConfigOptionStrings>("upward_compatible_machine", true)->values;
                    config.set("printer_settings_id", config_name, true);
 
                    //get printer_model_id
                    printer_model = config.option<ConfigOptionString>("printer_model", true)->value;
                    if (!printer_model.empty()) {
                        std::string printer_model_path = resources_dir() + "/profiles/BBL/machine_full/"+printer_model+".json";
                        if (boost::filesystem::exists(printer_model_path))
                        {
                            std::map<std::string, std::string> key_values;
 
                            load_key_values_from_json(printer_model_path, key_values);
                            if (key_values.find("model_id") != key_values.end()) {
                                printer_model_id = key_values["model_id"];
                                BOOST_LOG_TRIVIAL(info) << __FUNCTION__<< boost::format(":%1%, load printer_model_id %2% from current printer model %3%")%__LINE__ %printer_model_id %printer_model;
                            }
                        }
                    }
 
                    load_machine_config = std::move(config);
                }
            }
            else
                fetch_upward_values = true;
 
            if (new_process_name.empty() && !current_process_system_name.empty()) {
                //use the original printer name in 3mf
                std::string system_process_path = resources_dir() + "/profiles/BBL/process_full/"+current_process_system_name+".json";
                if (! boost::filesystem::exists(system_process_path)) {
                    BOOST_LOG_TRIVIAL(warning) << __FUNCTION__<< boost::format(":%1%, can not find system preset file: %2% ")%__LINE__ %system_process_path;
                    //use original one
                }
                else {
                    DynamicPrintConfig  config;
                    std::string config_type, config_name, filament_id, config_from;
                    int ret = load_config_file(system_process_path, config, config_type, config_name, filament_id, config_from);
                    if (ret) {
                        record_exit_reson(outfile_dir, ret, 0, cli_errors[ret], sliced_info);
                        flush_and_exit(ret);
                    }
                    current_print_compatible_printers  = config.option<ConfigOptionStrings>("compatible_printers", true)->values;
                    config.set("print_settings_id", config_name, true);
                    load_process_config = std::move(config);
                }
            }
            else
                fetch_compatible_values = true;
        }
 
        //filament processes
        if (load_filament_count == 0)
        {
            if (uptodate_filaments.size() > 0)
            {
                if (uptodate_filaments.size() != (size_t)filament_count)
                {
                    BOOST_LOG_TRIVIAL(error) << boost::format("uptodate_filaments size %1% not equal to filament_count %2% ")%uptodate_filaments.size() %filament_count;
                    record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
                    flush_and_exit(CLI_INVALID_PARAMS);
                }
                for (int index = 0; index < filament_count; index ++)
                {
                    std::string file = uptodate_filaments[index];
                    DynamicPrintConfig  config;
                    std::string config_type, config_name, filament_id, config_from;
                    int ret = load_config_file(file, config, config_type, config_name, filament_id, config_from);
                    if (ret) {
                        BOOST_LOG_TRIVIAL(error) << boost::format("load uptodate_filaments %1% fail, index %2%!")%file %index;
                        record_exit_reson(outfile_dir, ret, 0, cli_errors[ret], sliced_info);
                        flush_and_exit(ret);
                    }
 
                    if (config_type != "filament") {
                        BOOST_LOG_TRIVIAL(error) <<__FUNCTION__ << boost::format(": unknown config type %1% of file %2% in load-filaments") % config_type % file;
                        record_exit_reson(outfile_dir, CLI_CONFIG_FILE_ERROR, 0, cli_errors[CLI_CONFIG_FILE_ERROR], sliced_info);
                        flush_and_exit(CLI_CONFIG_FILE_ERROR);
                    }
 
                    if (config_name != current_filaments_system_name[index]) {
                        BOOST_LOG_TRIVIAL(error) << boost::format("wrong filament config file %1% loaded, current filament config name %2%, index %3%")%config_name %current_filaments_system_name[index] %index;
                        record_exit_reson(outfile_dir, CLI_CONFIG_FILE_ERROR, 0, cli_errors[CLI_CONFIG_FILE_ERROR], sliced_info);
                        flush_and_exit(CLI_CONFIG_FILE_ERROR);
                    }
 
                    load_filaments_id.push_back(filament_id);
                    load_filaments_name.push_back(config_name);
                    load_filaments_config.push_back(std::move(config));
                    load_filaments_index.push_back(index+1);
                    load_filaments_inherit.push_back(config_name);
                    BOOST_LOG_TRIVIAL(info) << boost::format("load a filament config %1% from file %2%, using uptodate_filaments index %3%")%config_name %file %index;
                }
            }
            else
            {
                current_index = 0;
                for (int index = 0; index < current_filaments_system_name.size(); index++)
                {
                    std::string system_filament_path = resources_dir() + "/profiles/BBL/filament_full/"+current_filaments_system_name[index]+".json";
                    current_index++;
                    if (! boost::filesystem::exists(system_filament_path)) {
                        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__<< boost::format(":%1%, can not find system preset file: %2% ")%__LINE__ %system_filament_path;
                        continue;
                    }
                    DynamicPrintConfig  config;
                    std::string config_type, config_name, filament_id, config_from;
                    int ret = load_config_file(system_filament_path, config, config_type, config_name, filament_id, config_from);
                    if (ret) {
                        record_exit_reson(outfile_dir, ret, 0, cli_errors[ret], sliced_info);
                        flush_and_exit(ret);
                    }
 
                    if (config_type != "filament") {
                        BOOST_LOG_TRIVIAL(error) <<__FUNCTION__ << boost::format(": unknown config type %1% of file %2% in load-filaments") % config_type % system_filament_path;
                        record_exit_reson(outfile_dir, CLI_CONFIG_FILE_ERROR, 0, cli_errors[CLI_CONFIG_FILE_ERROR], sliced_info);
                        flush_and_exit(CLI_CONFIG_FILE_ERROR);
                    }
 
                    load_filaments_id.push_back(filament_id);
                    load_filaments_name.push_back(config_name);
                    load_filaments_config.push_back(std::move(config));
                    load_filaments_index.push_back(current_index);
                    load_filaments_inherit.push_back(config_name);
                    BOOST_LOG_TRIVIAL(info) << boost::format("LINE %4%: load a filament config %1% from file %2%, index %3%")%config_name %system_filament_path %index %__LINE__;
                }
            }
        }
    }
    else if (is_bbl_3mf){
        fetch_upward_values = true;
        fetch_compatible_values = true;
    }
 
    // A project whose different_settings_to_system is missing or empty in every entry does not say which of its
    // values were changed: the GUI saves it that way when its presets match their parents, but also when it cannot
    // find those parents. Only --uptodate then replaces the stored values with system ones.
    const bool refresh_unlisted = up_config_to_date || std::any_of(current_different_settings.begin(), current_different_settings.end(),
                                                                   [](const std::string &keys) { return !keys.empty(); });
 
    // Refresh every project filament no loaded filament replaces from its current system preset, as the GUI
    // does when it loads the project; the filament merge below keeps the keys the project lists as changed.
    // Without refresh_unlisted it keeps every key the project has except filament_extruder_variant, whose
    // system layout the kept values are mapped onto.
    // Entries stay in slot order, which the merge's variant bookkeeping relies on.
    std::vector<bool> load_filaments_refresh(load_filaments_config.size(), false);
    std::set<std::string> project_keys;
    if (!refresh_unlisted) {
        for (const std::string &key : m_print_config.keys())
            project_keys.insert(key);
        project_keys.erase("filament_extruder_variant");
    }
    if (is_bbl_3mf && new_printer_name.empty()) {
        const ConfigOptionStrings *project_filament_ids = m_print_config.option<ConfigOptionStrings>("filament_ids");
        for (size_t index = 0; index < current_filaments_system_name.size(); index++) {
            const int slot = static_cast<int>(index) + 1;
            if (std::find(load_filaments_index.begin(), load_filaments_index.end(), slot) != load_filaments_index.end())
                continue;
            std::string system_name = current_filaments_system_name[index];
            if (system_name.empty())
                continue;
            PresetBundle::convert_filament_preset_name(current_printer_name, system_name);
            DynamicPrintConfig config;
            std::string        error;
            if (!ensure_system_preset_resolver().resolve_system_preset(config, Preset::TYPE_FILAMENT, system_name, config_substitution_rule, error)) {
                BOOST_LOG_TRIVIAL(warning) << boost::format("CLI: system filament preset '%1%' not resolved (%2%); filament %3% keeps its values") % system_name % error % slot;
                continue;
            }
            const size_t at = std::upper_bound(load_filaments_index.begin(), load_filaments_index.end(), slot) - load_filaments_index.begin();
            load_filaments_id.insert(load_filaments_id.begin() + at,
                project_filament_ids != nullptr && index < project_filament_ids->size() ? project_filament_ids->values[index] : std::string());
            load_filaments_name.insert(load_filaments_name.begin() + at, system_name);
            load_filaments_config.insert(load_filaments_config.begin() + at, std::move(config));
            load_filaments_index.insert(load_filaments_index.begin() + at, slot);
            load_filaments_inherit.insert(load_filaments_inherit.begin() + at, system_name);
            load_filaments_refresh.insert(load_filaments_refresh.begin() + at, true);
        }
    }
 
    //fetch upward_compatible_machine
    if (fetch_upward_values) {
        if (!current_printer_system_name.empty()) {
            //use the original printer name in 3mf
            std::string system_printer_path = resources_dir() + "/profiles/BBL/machine_full/"+current_printer_system_name+".json";
            if (! boost::filesystem::exists(system_printer_path)) {
                BOOST_LOG_TRIVIAL(warning) << __FUNCTION__<< boost::format(":%1%, can not find system preset file: %2% ")%__LINE__ %system_printer_path;
                //skip
            }
            else {
                DynamicPrintConfig  config;
                std::string config_type, config_name, filament_id, config_from;
                int ret = load_config_file(system_printer_path, config, config_type, config_name, filament_id, config_from);
                if (ret) {
                    record_exit_reson(outfile_dir, ret, 0, cli_errors[ret], sliced_info);
                    flush_and_exit(ret);
                }
                upward_compatible_printers = config.option<ConfigOptionStrings>("upward_compatible_machine", true)->values;
                //ORCA: keep the full config so compatible_printers_condition can be evaluated against it below
                current_printer_full_config = std::move(config);
            }
        }
    }
 
    //fetch print_compatible_printers
    if (fetch_compatible_values) {
        if (!current_process_system_name.empty()) {
            //use the original printer name in 3mf
            std::string system_process_path = resources_dir() + "/profiles/BBL/process_full/"+current_process_system_name+".json";
            if (! boost::filesystem::exists(system_process_path)) {
                BOOST_LOG_TRIVIAL(warning) << __FUNCTION__<< boost::format(":%1%, can not find system preset file: %2% ")%__LINE__ %system_process_path;
                //use original one
            }
            else {
                DynamicPrintConfig  config;
                std::string config_type, config_name, filament_id, config_from;
                int ret = load_config_file(system_process_path, config, config_type, config_name, filament_id, config_from);
                if (ret) {
                    record_exit_reson(outfile_dir, ret, 0, cli_errors[ret], sliced_info);
                    flush_and_exit(ret);
                }
                current_print_compatible_printers  = config.option<ConfigOptionStrings>("compatible_printers", true)->values;
                //ORCA: keep the full config so compatible_printers_condition can be evaluated against it below
                current_process_full_config = std::move(config);
            }
        }
    }
 
    //upwards check
    bool process_compatible = false, machine_upwards = false, machine_switch = false;
    BOOST_LOG_TRIVIAL(info) << boost::format("current printer %1%, new printer %2%, current process %3%, new process %4%")%current_printer_name %new_printer_name %current_process_name %new_process_name;
    BOOST_LOG_TRIVIAL(info) << boost::format("current printer inherits %1%, new printer inherits %2%, current process inherits %3%, new process inherits %4%")
        %current_printer_system_name %new_printer_system_name %current_process_system_name %new_process_system_name;
    for (int index = 0; index < current_print_compatible_printers.size(); index++) {
        BOOST_LOG_TRIVIAL(info) << boost::format("index %1%, current print compatible printer %2%")%index %current_print_compatible_printers[index];
    }
    for (int index = 0; index < new_print_compatible_printers.size(); index++) {
        BOOST_LOG_TRIVIAL(info) << boost::format("index %1%, new print compatible printer %2%")%index %new_print_compatible_printers[index];
    }
    for (int index = 0; index < upward_compatible_printers.size(); index++) {
        BOOST_LOG_TRIVIAL(info) << boost::format("index %1%, upward_compatible_printers %2%")%index %upward_compatible_printers[index];
    }
    //ORCA: Replace the four manual equality-loop checks below with is_compatible_with_printer(), the
    //      same helper the GUI uses, which also evaluates compatible_printers_condition. Process
    //      profiles that declare compatibility via condition only -- leaving compatible_printers
    //      empty -- were always reported incompatible by the literal-name match, so a CLI slice with
    //      such a preset exited with CLI_PROCESS_NOT_COMPATIBLE (-17) even though the GUI accepts the
    //      same pair. Behaviour is unchanged where an explicit list exists: is_compatible_with_printer
    //      does the same name match, and returns true when both list and condition are empty (which
    //      matches the "old 3mf, no compatible printers" path below).
    auto check_compat = [](const DynamicPrintConfig &process_cfg,
                           const DynamicPrintConfig &printer_cfg,
                           const std::string        &printer_name) -> bool {
        return is_compatible_with_printer(process_cfg, Preset::TYPE_PRINT, printer_cfg, printer_name);
    };
 
    //ORCA: a 3MF's project config does not carry compatible_printers / compatible_printers_condition.
    //      PresetBundle::construct_full_config() erases both and re-emits them as
    //      print_compatible_printers and compatible_machine_expression_group; they are renamed back
    //      only on the PresetBundle load path, which the CLI does not take. Feeding the project config
    //      to the check as-is therefore presents no list and no condition, and
    //      is_compatible_with_printer() reads that as "no constraint" and accepts every printer.
    //      Translate the two keys back. Index 0 of the expression group is the print preset -- the
    //      group is filled print, filaments, printer (PresetBundle.cpp).
    //      The raw keys win whenever they carry something. A project the CLI exported itself has the
    //      real compatible_printers_condition AND an all-empty compatible_machine_expression_group,
    //      so copying the group's first entry unconditionally would overwrite a valid condition with
    //      "" and accept every printer. The renamed keys are only a fallback, and an empty value is
    //      never written over a real one.
    auto cli_process_compat_config = [](const DynamicPrintConfig &project_cfg) -> DynamicPrintConfig {
        DynamicPrintConfig cfg = project_cfg;
        const auto *raw_list = project_cfg.option<ConfigOptionStrings>("compatible_printers");
        const auto *list     = project_cfg.option<ConfigOptionStrings>("print_compatible_printers");
        if ((raw_list == nullptr || raw_list->values.empty()) && list != nullptr && !list->values.empty())
            cfg.set_key_value("compatible_printers", new ConfigOptionStrings(list->values));
        const auto *raw_cond = project_cfg.option<ConfigOptionString>("compatible_printers_condition");
        const auto *group    = project_cfg.option<ConfigOptionStrings>("compatible_machine_expression_group");
        if ((raw_cond == nullptr || raw_cond->value.empty()) && group != nullptr && !group->values.empty() &&
            !group->values.front().empty())
            cfg.set_key_value("compatible_printers_condition", new ConfigOptionString(group->values.front()));
        return cfg;
    };
    if (!new_printer_name.empty()) {
        if (!new_process_name.empty()) {
            //new process + new printer: both configs came from --load-settings
            process_compatible = check_compat(load_process_config, load_machine_config, new_printer_system_name);
            BOOST_LOG_TRIVIAL(info) << boost::format("new printer %1%, inherited from %2%, new process %3%, inherited from %4% ,compatible %5%")
                %new_printer_name %new_printer_system_name %new_process_name %new_process_system_name %process_compatible;
        }
        else {
            //3MF-embedded process vs new printer. current_process_full_config is only populated from
            //profiles/BBL/process_full/, so for every other vendor fall back to the 3MF's own project
            //config in m_print_config, with its renamed compatibility keys translated back (see
            //cli_process_compat_config above). Without this a 3MF built from a condition-only process
            //is rejected when re-sliced with the very printer it was made for.
            {
                //ORCA: profiles/BBL/{process,machine}_full/ are gitignored and not generated in-tree,
                //      so current_*_full_config is always empty and this fallback is the only live path.
                const DynamicPrintConfig process_cfg = current_process_full_config.empty()
                                                           ? cli_process_compat_config(m_print_config)
                                                           : current_process_full_config;
                process_compatible = check_compat(process_cfg, load_machine_config, new_printer_system_name);
            }
            BOOST_LOG_TRIVIAL(info) << boost::format("new printer %1%, inherited from %2%, old process %3%, inherited from %4% ,compatible %5%")
                %new_printer_name %new_printer_system_name %current_process_name %current_process_system_name %process_compatible;
        }
    }
    else if (!new_process_name.empty()) {
        //new process vs 3MF-embedded printer. As above, current_printer_full_config only resolves for
        //BBL profiles; otherwise evaluate against the 3MF's own project config in m_print_config, which
        //holds the embedded printer's printer_notes / nozzle_diameter.
        {
            const DynamicPrintConfig &printer_cfg = current_printer_full_config.empty() ? m_print_config : current_printer_full_config;
            process_compatible = check_compat(load_process_config, printer_cfg, current_printer_system_name);
        }
        BOOST_LOG_TRIVIAL(info) << boost::format("old printer %1%, inherited from %2%, new process %3%, inherited from %4% ,compatible %5%")
            %current_printer_name %current_printer_system_name %new_process_name %new_process_system_name %process_compatible;
    }
    else {
        //both sides 3MF-embedded (pure reprocess)
        if (!current_process_full_config.empty() && !current_printer_full_config.empty())
            process_compatible = check_compat(current_process_full_config, current_printer_full_config, current_printer_system_name);
        else
            process_compatible = std::find(current_print_compatible_printers.begin(), current_print_compatible_printers.end(), current_printer_system_name) != current_print_compatible_printers.end();
        if (!process_compatible && current_print_compatible_printers.empty())
        {
            BOOST_LOG_TRIVIAL(info) << boost::format("old 3mf, no compatible printers, set to compatible");
            process_compatible = true;
        }
        BOOST_LOG_TRIVIAL(info) << boost::format("old printer %1%, inherited from %2%, old process %3%, inherited from %4% ,compatible %5%")
            %current_printer_name %current_printer_system_name %current_process_name %current_process_system_name %process_compatible;
    }
    if (!process_compatible && !new_printer_name.empty() && !current_printer_name.empty() && (new_printer_name != current_printer_name)) {
        //set all printer to compatible
        if (new_process_name.empty())
            process_compatible = true;
        machine_switch = true;
        BOOST_LOG_TRIVIAL(info) << boost::format("switch to new printers, set to compatible");
        if (upward_compatible_printers.size() > 0) {
            for (int index = 0; index < upward_compatible_printers.size(); index++) {
                if (upward_compatible_printers[index] == new_printer_system_name) {
                    process_compatible = true;
                    machine_upwards = true;
                    BOOST_LOG_TRIVIAL(info) << boost::format("new printer is upward_compatible");
                    break;
                }
            }
            if (!process_compatible) {
                BOOST_LOG_TRIVIAL(error) <<__FUNCTION__ << boost::format(" %1% : current 3mf file not support the new printer %2%, new_printer_system_name %3%")%__LINE__%new_printer_name %new_printer_system_name;
                record_exit_reson(outfile_dir, CLI_3MF_NEW_MACHINE_NOT_SUPPORTED, 0, cli_errors[CLI_3MF_NEW_MACHINE_NOT_SUPPORTED], sliced_info);
                flush_and_exit(CLI_3MF_NEW_MACHINE_NOT_SUPPORTED);
            }
        }
        /*else {
            BOOST_LOG_TRIVIAL(error) <<__FUNCTION__ << boost::format(" %1%: current 3mf file not support upward_compatible_printers, can not change machine preset.")%__LINE__;
            record_exit_reson(outfile_dir, CLI_3MF_NOT_SUPPORT_MACHINE_CHANGE, 0, cli_errors[CLI_3MF_NOT_SUPPORT_MACHINE_CHANGE], sliced_info);
            flush_and_exit(CLI_3MF_NOT_SUPPORT_MACHINE_CHANGE);
        }*/
    }
 
    if (!process_compatible) {
        BOOST_LOG_TRIVIAL(error) <<__FUNCTION__ << boost::format(" %1%: process not compatible with printer.")%__LINE__;
        record_exit_reson(outfile_dir, CLI_PROCESS_NOT_COMPATIBLE, 0, cli_errors[CLI_PROCESS_NOT_COMPATIBLE], sliced_info);
        flush_and_exit(CLI_PROCESS_NOT_COMPATIBLE);
    }
    sliced_info.upward_machines = upward_compatible_printers;
 
    //create project embedded preset if needed
    Preset *new_preset = NULL;
    if (is_bbl_3mf && machine_switch) {
        //we need to update the compatible printer and create a new process here, or if we load the 3mf in studio, the process preset can not be loaded as not compatible
        Preset *current_preset = NULL;
        size_t project_presets_count = project_presets.size();
        for (int index = 0; index < project_presets_count; index++)
        {
            if (project_presets[index]->name == current_process_name) {
                current_preset = project_presets[index];
                break;
            }
        }
        new_preset = new Preset(Preset::TYPE_PRINT, current_process_name);
        if (current_preset) {
            *new_preset = *current_preset;
            std::vector<std::string>& compatible_printers = new_preset->config.option<ConfigOptionStrings>("compatible_printers", true)->values;
            bool need_insert = true;
            for (int index = 0; index < compatible_printers.size(); index++) {
                if (compatible_printers[index] == new_printer_system_name) {
                    need_insert = false;
                    break;
                }
            }
            if (need_insert)
                compatible_printers.push_back(new_printer_system_name);
        }
        else {
            //store a project-embedded preset
            const std::vector<std::string>& process_keys = Preset::print_options();
            new_preset->config.apply_only(m_print_config, process_keys);
            std::vector<std::string>& compatible_printers = new_preset->config.option<ConfigOptionStrings>("compatible_printers", true)->values;
            compatible_printers = current_print_compatible_printers;
            compatible_printers.push_back(new_printer_system_name);
            if (current_process_system_name != current_process_name) {
                std::string& inherits = new_preset->config.option<ConfigOptionString>("inherits", true)->value;
                inherits = current_process_system_name;
            }
            new_preset->is_project_embedded = true;
            new_preset->type = Preset::TYPE_PRINT;
            //new_preset->name = current_process_name;
        }
        new_preset->name += "(auto)";
        new_preset->config.set("print_settings_id", new_preset->name, true);
        m_print_config.set("print_settings_id", new_preset->name, true);
        project_presets.push_back(new_preset);
    }
 
    //compute extruder variant index
    auto compute_variant_index = [](DynamicPrintConfig& full_config, const DynamicPrintConfig& new_config, std::string id_name, std::string variant_name, std::vector<int>& new_index, bool& count_changed) {
        auto curr_variant_opt = dynamic_cast<const ConfigOptionStrings*>(full_config.option(variant_name));
        auto new_variant_opt = dynamic_cast<const ConfigOptionStrings*>(new_config.option(variant_name));
        auto curr_id_opt = dynamic_cast<const ConfigOptionInts*>(full_config.option(id_name));
        auto new_id_opt = dynamic_cast<const ConfigOptionInts*>(new_config.option(id_name));
        if (!new_variant_opt || !new_id_opt) {
            BOOST_LOG_TRIVIAL(error) << boost::format("%1%:%2%, can not get %3% or %4% from new config")%__FUNCTION__ %__LINE__ % variant_name %id_name;
            count_changed = false;
            return;
        }
        int new_variant_count = new_variant_opt->size(), curr_variant_count = 0;
        new_index.clear();
        new_index.resize(new_variant_count, -1);
        if (curr_variant_opt && curr_id_opt) {
            if (curr_variant_opt->size() != curr_id_opt->size()) {
                BOOST_LOG_TRIVIAL(error) << boost::format("%1%:%2%, %3%'s size %4% not equal to %5%'s size %6%")%__FUNCTION__ %__LINE__ % variant_name %curr_variant_opt->size() %id_name %curr_id_opt->size();
                count_changed = false;
                return;
            }
            curr_variant_count = curr_variant_opt->size();
            count_changed = (curr_variant_count != new_variant_count);
        }
        else
            count_changed = (new_variant_count != 1);
 
 
        for (int i = 0; i < new_variant_count; i++)
        {
            if (curr_variant_count > 0) {
                for (int j = 0; j < curr_variant_count; j++)
                {
                    if ((curr_variant_opt->values[j] == new_variant_opt->values[i]) && (curr_id_opt->values[j] == new_id_opt->values[i])) {
                        new_index[i] = j;
                        break;
                    }
                }
            }
            else if ((new_variant_opt->values[i] == "Direct Drive Standard") && (new_id_opt->values[i] == 1))
                new_index[i] = 0;
        }
    };
 
    //update separate configs into full config
    auto update_full_config = [](DynamicPrintConfig& full_config, const DynamicPrintConfig& config, std::set<std::string>& diff_key_sets, bool variant_count_changed, std::set<std::string>& key_set_1, std::set<std::string>& key_set_2, std::vector<int> variant_index, bool update_all = false, bool skip_gcodes = false) {
        const t_config_option_keys& config_keys = config.keys();
        BOOST_LOG_TRIVIAL(info) << boost::format("update_full_config: config keys count %1%")%config_keys.size();
        for (const t_config_option_key &opt_key : config_keys) {
            if (!update_all && !diff_key_sets.empty()) {
                std::set<std::string>::iterator iter = diff_key_sets.find(opt_key);
                if ( iter != diff_key_sets.end()) {
                    if (skip_gcodes && (gcodes_key_set.find(opt_key) != gcodes_key_set.end()))
                    {
                        diff_key_sets.erase(iter);
                        BOOST_LOG_TRIVIAL(info) << boost::format("%1%, gcodes %2% modified, reset to default.")%__LINE__ %opt_key;
                    }
                    else {
                        //uptodate, diff keys, continue
                        BOOST_LOG_TRIVIAL(info) << boost::format("%1%, keep key %2%")%__LINE__ %opt_key;
                        if (variant_count_changed) {
                            //
                            int stride = 0;
                            if (key_set_1.count(opt_key) > 0)
                            {
                                stride = 1;
                            }
                            else if (key_set_2.count(opt_key) > 0)
                            {
                                stride = 2;
                            }
 
                            if (stride > 0) {
                                const ConfigOption *source_opt = config.option(opt_key);
                                ConfigOption *dest_opt = full_config.option(opt_key, true);
                                const ConfigOptionVectorBase* opt_vec_src = static_cast<const ConfigOptionVectorBase*>(source_opt);
                                ConfigOptionVectorBase* opt_vec_dest = static_cast<ConfigOptionVectorBase*>(dest_opt);
 
                                opt_vec_dest->set_with_restore(opt_vec_src, variant_index, stride);
                            }
                            else
                                continue;
                        }
                        else
                            continue;
                    }
                }
            }
            const ConfigOption *source_opt = config.option(opt_key);
            if (source_opt == nullptr) {
                // The key was not found in the source config, therefore it will not be initialized!
                boost::nowide::cerr << __FUNCTION__<<": can not found option " <<opt_key<<"from config." <<std::endl;
                return CLI_CONFIG_FILE_ERROR;
            }
            if (opt_key == "compatible_prints" || opt_key == "compatible_printers" || opt_key == "model_id" || opt_key == "inherits" ||opt_key == "dev_model_name"
                || opt_key == "name" || opt_key == "from" || opt_key == "type" || opt_key == "version" || opt_key == "setting_id" || opt_key == "instantiation" )
                continue;
            else {
                ConfigOption *dest_opt = full_config.option(opt_key, true);
                if (dest_opt == nullptr) {
                    boost::nowide::cerr << __FUNCTION__<<":can not create option " <<opt_key<<" to full_config "<<std::endl;
                    return CLI_CONFIG_FILE_ERROR;
                }
                dest_opt->set(source_opt);
                //*dest_opt = *source_opt;
            }
        }
        return 0;
    };
 
    // Load the project's printer and process settings as the GUI loads its presets: over the default preset,
    // with every key the project does not list as changed, including keys saved before an option existed,
    // taken from its current system preset. Without refresh_unlisted the project only gets the keys it lacks.
    auto load_project_preset = [this, &ensure_system_preset_resolver, &current_different_settings, refresh_unlisted, filament_count](const std::string &system_name, Preset::Type type) {
        if (system_name.empty())
            return;
        // Preset bookkeeping the CLI keeps in its own groups, e.g. inherits_group and print_compatible_printers.
        static const std::set<std::string> bookkeeping_keys = {"inherits", "compatible_printers", "compatible_prints", "compatible_printers_condition",
                                                               "compatible_prints_condition", "print_settings_id", "printer_settings_id"};
        const size_t       index = type == Preset::TYPE_PRINTER ? filament_count + 1 : 0;
        PresetBundle      &resolver = ensure_system_preset_resolver();
        DynamicPrintConfig system_config;
        t_config_option_keys keys;
        const DynamicPrintConfig config = Preset::load_external_config(type,
            type == Preset::TYPE_PRINTER ? resolver.printers.default_preset_for(m_print_config).config : resolver.prints.default_preset().config,
            m_print_config, PresetBundle::project_different_keys(index < current_different_settings.size() ? current_different_settings[index] : std::string()),
            [&](const std::string &) -> DynamicPrintConfig * {
                std::string error;
                if (resolver.resolve_system_preset(system_config, type, system_name, config_substitution_rule, error))
                    return &system_config;
                BOOST_LOG_TRIVIAL(warning) << boost::format("CLI: system preset '%1%' not resolved (%2%); the project keeps its values") % system_name % error;
                return nullptr;
            }, &keys);
        for (const std::string &key : keys) {
            const ConfigOption *opt = config.option(key);
            const ConfigOption *old = m_print_config.option(key);
            if (bookkeeping_keys.count(key) != 0 || opt == nullptr || (old != nullptr && (!refresh_unlisted || *old == *opt)))
                continue;
            BOOST_LOG_TRIVIAL(info) << boost::format("CLI: %1% from '%2%': %3% -> %4%") % key % system_name % (old ? old->serialize() : std::string("(missing)")) % opt->serialize();
            m_print_config.set_key_value(key, opt->clone());
        }
    };
    // The --uptodate path refreshes the project from its own system configs.
    if (new_printer_name.empty() && load_machine_config.empty())
        load_project_preset(current_printer_system_name, Preset::TYPE_PRINTER);
    if (new_process_name.empty() && load_process_config.empty())
        load_project_preset(current_process_system_name, Preset::TYPE_PRINT);
 
    std::vector<std::string>& different_settings = m_print_config.option<ConfigOptionStrings>("different_settings_to_system", true)->values;
    std::vector<std::string>& inherits_group = m_print_config.option<ConfigOptionStrings>("inherits_group", true)->values;
    inherits_group.resize(filament_count + 2, std::string());
    different_settings.resize(filament_count + 2, std::string());
    if (!is_bbl_3mf && !different_process_setting.empty()) {
        different_settings[0] = different_process_setting;
    }
 
    std::vector<int> new_variant_index;
    bool variant_count_changed = false;
    //set the machine settings into print config
    if (!new_printer_name.empty() || up_config_to_date) {
        std::vector<std::string> different_keys;
 
        if (new_printer_name.empty()) {
            std::string diff_settings;
            if (!different_settings.empty()) {
                diff_settings = different_settings[filament_count+1];
                Slic3r::unescape_strings_cstyle(diff_settings, different_keys);
            }
        }
        else {
            //ORCA: was a //todo — compute the user's overrides instead of writing an empty column.
            different_settings[filament_count+1] = new_printer_config_is_system
                ? std::string()
                : cli_different_settings(load_machine_config, new_printer_system_name, Preset::TYPE_PRINTER);
            if (new_printer_config_is_system)
                inherits_group[filament_count+1] = "";
            else
                inherits_group[filament_count+1] = new_printer_system_name;
        }
 
        std::set<std::string> different_keys_set(different_keys.begin(), different_keys.end());
        BOOST_LOG_TRIVIAL(info) << boost::format("update printer config to newest, different size %1%, different_settings: %2%")%different_keys_set.size() %different_settings[filament_count+1];
 
        int ret;
 
        load_default_gcodes_to_config(load_machine_config, Preset::TYPE_PRINTER);
        if (new_printer_name.empty()) {
            int diff_keys_size = different_keys_set.size();
            compute_variant_index(m_print_config, load_machine_config, "printer_extruder_id", "printer_extruder_variant", new_variant_index, variant_count_changed);
            ret = update_full_config(m_print_config, load_machine_config, different_keys_set, variant_count_changed, printer_options_with_variant_1, printer_options_with_variant_2, new_variant_index, false, skip_modified_gcodes);
            if (diff_keys_size != different_keys_set.size()) {
                //changed
                BOOST_LOG_TRIVIAL(info) << boost::format("new different key size %1%")%different_keys_set.size();
                different_keys.clear();
 
                for (std::set<std::string>::iterator iter=different_keys_set.begin(); iter !=different_keys_set.end(); ++iter)
                    different_keys.emplace_back(*iter);
                different_settings[filament_count+1] = Slic3r::escape_strings_cstyle(different_keys);
            }
            BOOST_LOG_TRIVIAL(info) << boost::format("no new printer, only update the different key, new different_settings: %1%")%different_settings[filament_count+1];
        }
        else {
            ret = update_full_config(m_print_config, load_machine_config, different_keys_set, variant_count_changed, printer_options_with_variant_1, printer_options_with_variant_2, new_variant_index, true);
            BOOST_LOG_TRIVIAL(info) << boost::format("load a new printer, update all the keys, different_settings: %1%")%different_settings[filament_count+1];
            if (new_printer_name != current_printer_name)
            {
                //printer safe check
                BOOST_LOG_TRIVIAL(info) << boost::format("check printer cli safe params, current_printer_name %1%, new_printer_name %2%, printer_model %3%")%current_printer_name %new_printer_name %printer_model;
                std::map<std::string, std::string> printer_params;
                std::string cli_config_file = resources_dir() + "/profiles/BBL/cli_config.json";
                boost::filesystem::path directory_path(cli_config_file);
 
                BOOST_LOG_TRIVIAL(info) << boost::format("line %1% , will parse file %2%")%__LINE__ % cli_config_file;
                if (!fs::exists(directory_path)) {
                    BOOST_LOG_TRIVIAL(warning) << boost::format("file %1% not exist.")%cli_config_file;
                }
                else {
                    try {
                        json root_json;
                        boost::nowide::ifstream ifs(cli_config_file);
                        ifs >> root_json;
                        ifs.close();
 
                        if (root_json.contains("printer")) {
                            json printer_json = root_json["printer"];
                            if (!printer_model.empty() && printer_json.contains(printer_model)) {
                                json printer_model_json = printer_json[printer_model];
 
                                if (printer_model_json.contains("machine_limits")) {
                                    json machine_limits_json = printer_model_json["machine_limits"];
                                    printer_params = machine_limits_json.get<std::map<std::string, std::string>>();
 
                                    for (auto param_iter = printer_params.begin(); param_iter != printer_params.end(); param_iter++)
                                    {
                                        std::string key = param_iter->first;
                                        //replace "cli_safe" with "machine_max"
                                        key.replace(0, 8, "machine_max");
 
                                        ConfigOptionFloats* option = m_print_config.option<ConfigOptionFloats>(key);
                                        if (option) {
                                            //de-serialize the values from param_iter->second, and do the compare here
                                            unsigned int array_count = option->size();
                                            ConfigOptionFloats new_option;
                                            new_option.deserialize(param_iter->second);
                                            unsigned int new_array_count = new_option.size();
                                            for (unsigned int index = 0; index < array_count; index++)
                                            {
                                                if ((index < new_array_count) && new_option.values[index] != 0.f && (new_option.values[index] < option->values[index]))
                                                {
                                                    BOOST_LOG_TRIVIAL(info) << boost::format("set key %1%  index %2%, from %3%  to %4%") % key %index %option->values[index] % new_option.values[index];
                                                    option->values[index] = new_option.values[index];
                                                }
                                            }
                                        }
                                        else
                                            BOOST_LOG_TRIVIAL(warning) << boost::format("can not find key %1% in config") %key;
                                    }
                                }
                                else {
                                    BOOST_LOG_TRIVIAL(info) << boost::format("can not find machine_limits for printer %1% in cli_config.json")%printer_model;
                                }
                            }
                            else {
                                BOOST_LOG_TRIVIAL(info) << boost::format("can not find key %1% in the file")%printer_model;
                            }
                        }
                        else {
                            BOOST_LOG_TRIVIAL(warning) << boost::format("can not find key printer in the file");
                        }
                    }
                    catch (std::exception &err) {
                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< ": parse file "<<cli_config_file<<" got a generic exception, reason = " << err.what();
                    }
                }
            }
        }
 
        if (ret) {
            record_exit_reson(outfile_dir, ret, 0, cli_errors[ret], sliced_info);
            flush_and_exit(ret);
        }
    }
    if (m_print_config.option<ConfigOptionFloats>("nozzle_diameter")) {
        new_extruder_count = m_print_config.option<ConfigOptionFloats>("nozzle_diameter")->values.size();
        new_is_multi_extruder = new_extruder_count > 1;
        new_printer_extruder_variants = m_print_config.option<ConfigOptionStrings>("printer_extruder_variant", true)->values;
        new_printer_variant_count = new_printer_extruder_variants.size();
    }
 
    //set the process settings into print config
    std::vector<std::string>& print_compatible_printers = m_print_config.option<ConfigOptionStrings>("print_compatible_printers", true)->values;
    if (!new_process_name.empty() || up_config_to_date) {
        std::vector<std::string> different_keys;
 
        if (new_process_name.empty()) {
            std::string diff_settings;
            if (!different_settings.empty()) {
                diff_settings = different_settings[0];
                Slic3r::unescape_strings_cstyle(diff_settings, different_keys);
                int remove_index = -1;
                for (int index = 0; index < different_keys.size(); index++) {
                    if (different_keys[index] == "compatible_printers") {
                        remove_index = index;
                        break;
                    }
                }
                if (remove_index != -1) {
                    different_keys[remove_index] = different_keys[different_keys.size() - 1];
                    different_keys.erase(different_keys.begin() + different_keys.size() - 1);
                    different_settings[0] = Slic3r::escape_strings_cstyle(different_keys);
                }
            }
            print_compatible_printers = std::move(current_print_compatible_printers);
        }
        else {
            //ORCA: was a //todo. Prefer a value the loaded JSON already carried, otherwise
            //      compute the overrides against the system parent.
            if (!different_process_setting.empty())
                different_settings[0] = different_process_setting;
            else
                different_settings[0] = new_process_config_is_system
                    ? std::string()
                    : cli_different_settings(load_process_config, new_process_system_name, Preset::TYPE_PRINT);
            if (new_process_config_is_system)
                inherits_group[0] = "";
            else
                inherits_group[0] = new_process_system_name;
            print_compatible_printers = std::move(new_print_compatible_printers);
        }
 
        std::set<std::string> different_keys_set(different_keys.begin(), different_keys.end());
        BOOST_LOG_TRIVIAL(info) << boost::format("update process config to newest, different size %1%, different_settings: %2%")%different_keys_set.size() %different_settings[0];
 
        int ret;
 
        load_default_gcodes_to_config(load_process_config, Preset::TYPE_PRINT);
        if (new_process_name.empty()) {
            int diff_keys_size = different_keys_set.size();
            compute_variant_index(m_print_config, load_process_config, "print_extruder_id", "print_extruder_variant", new_variant_index, variant_count_changed);
            ret = update_full_config(m_print_config, load_process_config, different_keys_set, variant_count_changed, print_options_with_variant, empty_options, new_variant_index, false, skip_modified_gcodes);
            if (diff_keys_size != different_keys_set.size()) {
                //changed
                BOOST_LOG_TRIVIAL(info) << boost::format("new different key size %1%")%different_keys_set.size();
                different_keys.clear();
 
                for (std::set<std::string>::iterator iter=different_keys_set.begin(); iter !=different_keys_set.end(); ++iter)
                    different_keys.emplace_back(*iter);
                different_settings[0] = Slic3r::escape_strings_cstyle(different_keys);
            }
            BOOST_LOG_TRIVIAL(info) << boost::format("no new process, only update the different key, new different_settings: %1%")%different_settings[0];
        }
        else {
            ret = update_full_config(m_print_config, load_process_config, different_keys_set, variant_count_changed, print_options_with_variant, empty_options, new_variant_index, true);
            BOOST_LOG_TRIVIAL(info) << boost::format("load a new process, update all the keys, different_settings: %1%")%different_settings[0];
        }
        current_print_variant_count = m_print_config.option<ConfigOptionStrings>("print_extruder_variant", true)->values.size();
 
        if (ret) {
            record_exit_reson(outfile_dir, ret, 0, cli_errors[ret], sliced_info);
            flush_and_exit(ret);
        }
    }
 
    //get nozzle_volume_type
    if(m_extra_config.has("nozzle_volume_type")) {
        auto opt_nozzle_volume_type = dynamic_cast<const ConfigOptionEnumsGeneric*>(m_extra_config.option("nozzle_volume_type"));
        if (opt_nozzle_volume_type) {
            int nozzle_volume_type_size = opt_nozzle_volume_type->values.size();
            new_nozzle_volume_type.resize(nozzle_volume_type_size, nvtStandard);
            for (int i = 0; i < nozzle_volume_type_size; i++)
            {
                new_nozzle_volume_type[i] = (NozzleVolumeType) (opt_nozzle_volume_type->values[i]);
            }
        }
    }
    else {
        new_nozzle_volume_type.resize(new_extruder_count, nvtStandard);
    }
    new_extruder_variants.resize(new_extruder_count, "");
    const ConfigOptionEnumsGeneric *opt_extruder_type = dynamic_cast<const ConfigOptionEnumsGeneric *>(m_print_config.option("extruder_type"));
    for (int e_index = 0; e_index < new_extruder_count; e_index++) {
        ExtruderType extruder_type     = opt_extruder_type ? (ExtruderType) (opt_extruder_type->get_at(e_index)) : etDirectDrive;
        new_extruder_variants[e_index] = get_extruder_variant_string(extruder_type, new_nozzle_volume_type[e_index]);
    }
 
    if (current_nozzle_volume_type.empty())
    {
        current_nozzle_volume_type.resize(current_extruder_count, nvtStandard);
    }
    current_print_extruder_variants = m_print_config.option<ConfigOptionStrings>("print_extruder_variant", true)->values;
 
    if (machine_switch) {
        print_compatible_printers.push_back(new_printer_system_name);
 
        std::string old_setting = different_settings[0];
        if (old_setting.empty())
            different_settings[0] = "compatible_printers";
        else {
            std::vector<std::string> different_keys;
            Slic3r::unescape_strings_cstyle(old_setting, different_keys);
            bool need_insert = true;
            for (int index = 0; index < different_keys.size(); index++) {
                if (different_keys[index] == "compatible_printers") {
                    need_insert = false;
                    break;
                }
            }
            if (need_insert)
                different_settings[0] = old_setting + ";compatible_printers";
        }
 
        //add multi-extruder related logic
        if (new_process_name.empty() && ((current_extruder_count != new_extruder_count) || (current_print_variant_count != new_printer_variant_count))) {
            if (new_default_process_name.empty()) {
                BOOST_LOG_TRIVIAL(error) << boost::format("machine_switch: default process configis null, should not happen, new_printer_name %1%")%new_printer_name;
                record_exit_reson(outfile_dir, CLI_CONFIG_FILE_ERROR, 0, cli_errors[CLI_CONFIG_FILE_ERROR], sliced_info);
                flush_and_exit(CLI_CONFIG_FILE_ERROR);
            }
            else {
                std::string default_path = resources_dir() + "/profiles/BBL/process_full/";
                std::string file_path = default_path + new_default_process_name + ".json";
                DynamicPrintConfig  config;
                std::string config_type, config_name, filament_id, config_from, downward_printer;
                int ret = load_config_file(file_path, config, config_type, config_name, filament_id, config_from);
                if (ret) {
                    record_exit_reson(outfile_dir, ret, 0, cli_errors[ret], sliced_info);
                    flush_and_exit(ret);
                }
                if ((config_type != "process") || (config_from != "system")) {
                    BOOST_LOG_TRIVIAL(error) << boost::format("found invalid config type %1% or from %2% in file %3% when downward_check")%config_type %config_from %file_path;
                    record_exit_reson(outfile_dir, CLI_CONFIG_FILE_ERROR, 0, cli_errors[CLI_CONFIG_FILE_ERROR], sliced_info);
                    flush_and_exit(CLI_CONFIG_FILE_ERROR);
                }
                BOOST_LOG_TRIVIAL(info) << boost::format("%1%, machine_switch: loaded default process config %2%, from %3%")%__LINE__ %config_name %file_path ;
                BOOST_LOG_TRIVIAL(info) << boost::format("%1%, current_is_multi_extruder: %2%, new_is_multi_extruder: %3%, current_print_variant_count: %4%, new_printer_variant_count: %5%")
                    %__LINE__ %current_is_multi_extruder %new_is_multi_extruder %current_print_variant_count %new_printer_variant_count;
 
                if (!current_is_multi_extruder && new_is_multi_extruder && (current_print_variant_count == 1)) {
                    //single -> multiple
                    ret = m_print_config.update_values_from_single_to_multi(config, print_options_with_variant, "print_extruder_id", "print_extruder_variant");
                }
                else {
                    //multiple -> single
                    ret = m_print_config.update_values_from_multi_to_multi(config, print_options_with_variant, "print_extruder_id", "print_extruder_variant", new_extruder_variants);
                }
 
                if (ret) {
                    BOOST_LOG_TRIVIAL(error) << boost::format("current_is_multi_extruder %1% new_is_multi_extruder %2%, update_values failed") % current_is_multi_extruder % new_is_multi_extruder;
                    record_exit_reson(outfile_dir, CLI_CONFIG_FILE_ERROR, 0, cli_errors[CLI_CONFIG_FILE_ERROR], sliced_info);
                    flush_and_exit(CLI_CONFIG_FILE_ERROR);
                }
            }
        }
    }
 
    //set the filament settings into print config
    if ((load_filament_count > 0) || (up_config_to_date) || !load_filaments_config.empty())
    {
        //std::vector<int> filament_variant_count(filament_count, 1);
        std::vector<int> old_start_indice(filament_count, 0);
        std::vector<int> old_variant_counts(filament_count, 1), new_variant_counts;
 
        ConfigOptionInts* filament_self_index_opt = m_print_config.option<ConfigOptionInts>("filament_self_index");
        bool need_regenerate_self_index = !filament_self_index_opt;
        if (filament_self_index_opt) {
            // a filament_self_index carried over from a stale project can disagree with the
            // current filament_count. old_start_indice/old_variant_counts below are sized to
            // filament_count and walked with 1-based group indices, so an index above
            // filament_count overruns old_start_indice[++k], and a non-positive first index
            // writes old_variant_counts[-1] - both heap corruption.
            int max_self_index = 0, min_self_index = 1;
            for (int v : filament_self_index_opt->values) {
                max_self_index = std::max(max_self_index, v);
                min_self_index = std::min(min_self_index, v);
            }
            // And a project saved with FEWER filaments than are now loaded (a
            // one-filament project sliced with two --load-filaments) leaves the tables half filled:
            // the variant matching below then reads past filament_extruder_variant and
            // set_with_restore_2 throws an uncaught size error. Regenerate in that case too.
            if (max_self_index > filament_count || min_self_index < 1 || max_self_index < filament_count
                || (int) filament_self_index_opt->values.size() < filament_count) {
                BOOST_LOG_TRIVIAL(warning) << boost::format("filament_self_index range [%1%, %2%] (size %4%) is invalid for filament_count %3%, regenerating")
                        % min_self_index % max_self_index % filament_count % filament_self_index_opt->values.size();
                need_regenerate_self_index = true;
            }
        }
        if (need_regenerate_self_index) {
            filament_self_index_opt = m_print_config.option<ConfigOptionInts>("filament_self_index", true);
            std::vector<int>& filament_self_indice = filament_self_index_opt->values;
            filament_self_indice.resize(filament_count);
            for (int index = 0; index < filament_count; index++)
                filament_self_indice[index] = index + 1;
        }
 
        std::vector<int> old_self_indice= filament_self_index_opt->values;
        int old_self_indice_size = old_self_indice.size();
        int k = -1, current_filament = 0;
        for (size_t i = 0; i < old_self_indice_size; i++) {
            if (old_self_indice[i] > current_filament) {
                current_filament = old_self_indice[i];
                old_start_indice[++k] = i;
                old_variant_counts[k] = 1;
            }
            else {
                old_variant_counts[k] = old_variant_counts[k] + 1;
            }
        }
        new_variant_counts = old_variant_counts;
        //filament_variant_count = old_variant_counts;
        //ORCA: lay the per-variant options out one value per variant of the current filaments before each
        //      loaded filament replaces its own variants, including an option only a loaded filament
        //      defines, which otherwise starts as a single default value and never reaches the others.
        for (const DynamicPrintConfig &config : load_filaments_config)
            for (const std::string &opt_key : filament_options_with_variant)
                if (opt_key != "filament_extruder_variant" && config.has(opt_key))
                    m_print_config.option(opt_key, true);
        normalize_filament_values_to_variants(m_print_config);
        for (int index = 0; index < load_filaments_config.size(); index++) {
            DynamicPrintConfig&  config = load_filaments_config[index];
            int filament_index = load_filaments_index[index];
            // A filament given with --load-filaments replaces the slot; a refreshed one keeps the project's changed keys.
            const bool loaded = load_filament_count > 0 && !load_filaments_refresh[index];
            // A refreshed filament of a project that lists no changed settings keeps every key it has.
            const bool keep_project = load_filaments_refresh[index] && !refresh_unlisted;
            std::vector<std::string> different_keys;
 
            //ORCA: diff before load_default_gcodes_to_config, the way the process and machine
            //      slots above already do. That call materialises absent gcode keys via
            //      option(..., true), and DynamicConfig::diff only compares keys present in
            //      both configs -- so a gcode key the leaf did not carry would go from "not
            //      compared" to "compared as empty against the parent" and land in the column
            //      as an override the user never made.
            std::string filament_different_settings;
            if (loaded)
                filament_different_settings = cli_different_settings(config, load_filaments_inherit[index], Preset::TYPE_FILAMENT);
 
            load_default_gcodes_to_config(config, Preset::TYPE_FILAMENT);
 
            if (loaded) {
                ConfigOptionStrings *opt_filament_settings = static_cast<ConfigOptionStrings *> (m_print_config.option("filament_settings_id", true));
                std::string& filament_name = load_filaments_name[index];
                ConfigOptionString* filament_name_setting = new ConfigOptionString(filament_name);
                if (opt_filament_settings->size() < filament_count)
                    opt_filament_settings->resize(filament_count, filament_name_setting);
                opt_filament_settings->set_at(filament_name_setting, filament_index-1, 0);
                config.erase("filament_settings_id");
 
                //ORCA: was a //todo — same treatment as process/machine above.
                different_settings[filament_index] = filament_different_settings;
                inherits_group[filament_index] = load_filaments_inherit[index];
            }
            else if (keep_project)
                different_keys.assign(project_keys.begin(), project_keys.end());
            else {
                std::string diff_settings;
 
                if (!different_settings.empty()) {
                    diff_settings = different_settings[filament_index];
                    Slic3r::unescape_strings_cstyle(diff_settings, different_keys);
                }
            }
 
            //add filament_id
            std::string& filament_id = load_filaments_id[index];
            ConfigOptionStrings *opt_filament_ids = static_cast<ConfigOptionStrings *> (m_print_config.option("filament_ids", true));
            ConfigOptionString* filament_id_setting = new ConfigOptionString(filament_id);
            if (opt_filament_ids->size() < filament_count)
                opt_filament_ids->resize(filament_count, filament_id_setting);
            opt_filament_ids->set_at(filament_id_setting,  filament_index-1, 0);
 
            //compute the variant index logic
            ConfigOptionStrings *curr_variant_opt = m_print_config.option<ConfigOptionStrings>("filament_extruder_variant");
            if (!curr_variant_opt) {
                curr_variant_opt = m_print_config.option<ConfigOptionStrings>("filament_extruder_variant", true);
                std::vector<std::string>& filament_variants = curr_variant_opt->values;
                filament_variants.resize(filament_count, get_extruder_variant_string(etDirectDrive, nvtStandard));
            }
            // See the filament_self_index note above: one variant per filament for
            // the filaments the project did not know about.
            if ((int) curr_variant_opt->values.size() < filament_count)
                curr_variant_opt->values.resize(filament_count, get_extruder_variant_string(etDirectDrive, nvtStandard));
            const ConfigOptionStrings *new_variant_opt = dynamic_cast<const ConfigOptionStrings*>(config.option("filament_extruder_variant", true));
 
            std::vector<int> new_variant_indice;
            int new_variant_count = new_variant_opt->size(), old_variant_count = old_variant_counts[filament_index - 1];
            new_variant_indice.resize(new_variant_count, -1);
 
            for (int i = 0; i < new_variant_count; i++)
            {
                for (int j = old_start_indice[filament_index - 1]; j < old_start_indice[filament_index - 1] + old_variant_count && j < (int) curr_variant_opt->values.size(); j++)
                {
                    if (curr_variant_opt->values[j] == new_variant_opt->values[i]) {
                        new_variant_indice[i] = j;
                        break;
                    }
                }
            }
 
            //parse the filament value to index th
            //loop through options and apply them
            std::set<std::string> different_keys_set(different_keys.begin(), different_keys.end());
            int diff_keys_size = different_keys_set.size();
            BOOST_LOG_TRIVIAL(info) << boost::format("update filament %1%'s config to newest, different size %2%, name %3%, different_settings %4%")
                %filament_index%different_keys_set.size()%load_filaments_name[index] % different_settings[filament_index];
            for (const t_config_option_key &opt_key : config.keys()) {
                // Create a new option with default value for the key.
                // If the key is not in the parameter definition, or this ConfigBase is a static type and it does not support the parameter,
                // an exception is thrown if not ignore_nonexistent.
                const ConfigOption *source_opt = config.option(opt_key);
                if (source_opt == nullptr) {
                    // The key was not found in the source config, therefore it will not be initialized!
                    BOOST_LOG_TRIVIAL(error) << boost::format("can not find %1% from filament %2%: %3%")%opt_key%filament_index%load_filaments_name[index];
                    record_exit_reson(outfile_dir, CLI_CONFIG_FILE_ERROR, 0, cli_errors[CLI_CONFIG_FILE_ERROR], sliced_info);
                    flush_and_exit(CLI_CONFIG_FILE_ERROR);
                }
 
                if (!loaded && !different_keys_set.empty())
                {
                    std::set<std::string>::iterator iter = different_keys_set.find(opt_key);
                    if ( iter != different_keys_set.end()) {
                        if (skip_modified_gcodes && (gcodes_key_set.find(opt_key) != gcodes_key_set.end()))
                        {
                            different_keys_set.erase(iter);
                            BOOST_LOG_TRIVIAL(info) << boost::format("%1%, filament %2%'s gcodes %3% modified, reset to default.")%__LINE__ %filament_index %opt_key;
                        }
                        else {
                            //uptodate, diff keys, continue
                            BOOST_LOG_TRIVIAL(info) << boost::format("%1%, keep key %2%")%__LINE__ %opt_key;
                            if (filament_options_with_variant.find(opt_key) != filament_options_with_variant.end())
                            {
                                ConfigOption *opt = m_print_config.option(opt_key);
                                if (opt == nullptr) {
                                    // opt_key does not exist in this ConfigBase and it cannot be created, because it is not defined by this->def().
                                    // This is only possible if other is of DynamicConfig type.
                                    BOOST_LOG_TRIVIAL(error) << boost::format("can not find option %1% from config, but can find it in different settings")%opt_key;
                                    record_exit_reson(outfile_dir, CLI_CONFIG_FILE_ERROR, 0, cli_errors[CLI_CONFIG_FILE_ERROR], sliced_info);
                                    flush_and_exit(CLI_CONFIG_FILE_ERROR);
                                }
                                ConfigOptionVectorBase* opt_vec_dst = static_cast<ConfigOptionVectorBase*>(opt);
                                const ConfigOptionVectorBase* opt_vec_src = static_cast<const ConfigOptionVectorBase*>(source_opt);
                                //set with index
                                try {
                                    // A project with fewer filaments than are loaded: grow the
                                    // destination to the filament's slot first (set_with_restore_2 only restores).
                                    if (opt_vec_src->size() > 0 && opt_vec_dst->size() < size_t(old_start_indice[filament_index - 1] + old_variant_count))
                                        opt_vec_dst->resize(size_t(old_start_indice[filament_index - 1] + old_variant_count), opt_vec_src);
                                    // A kept key is padded like a refreshed one below rather than failing the run.
                                    opt_vec_dst->set_with_restore_2(opt_vec_src, new_variant_indice, old_start_indice[filament_index - 1], old_variant_count, keep_project);
                                } catch (const std::exception &ex) {   // Was an uncaught abort
                                    BOOST_LOG_TRIVIAL(error) << boost::format("filament %1%: option %2% could not be applied: %3%") % filament_index % opt_key % ex.what();
                                    boost::nowide::cerr << "filament " << filament_index << ": option " << opt_key << " could not be applied: " << ex.what() << std::endl;
                                    record_exit_reson(outfile_dir, CLI_CONFIG_FILE_ERROR, 0, cli_errors[CLI_CONFIG_FILE_ERROR], sliced_info);
                                    flush_and_exit(CLI_CONFIG_FILE_ERROR);
                                }
                            }
 
                            continue;
                        }
                    }
                }
 
                if (source_opt->is_scalar()) {
                    if (opt_key == "compatible_printers_condition") {
                        ConfigOption *opt = m_print_config.option("compatible_machine_expression_group", true);
                        ConfigOptionStrings* opt_vec_dst = static_cast<ConfigOptionStrings*>(opt);
                        if (opt_vec_dst->size() == 0)
                            opt_vec_dst->resize(filament_count+2, new ConfigOptionString());
                        opt_vec_dst->set_at(source_opt, filament_index, 0);
                    }
                    else if (opt_key == "compatible_prints_condition") {
                        ConfigOption *opt = m_print_config.option("compatible_process_expression_group", true);
                        ConfigOptionStrings* opt_vec_dst = static_cast<ConfigOptionStrings*>(opt);
                        if (opt_vec_dst->size() == 0)
                            opt_vec_dst->resize(filament_count, new ConfigOptionString());
                        opt_vec_dst->set_at(source_opt, filament_index-1, 0);
                    }
                    else {
                        //skip the scalar values
                        BOOST_LOG_TRIVIAL(info) << boost::format("skip scalar option %1% from filament %2%: %3%")%opt_key%filament_index%load_filaments_name[index];;
                        continue;
                    }
                }
                else
                {
                    if (opt_key == "compatible_prints" || opt_key == "compatible_printers" || opt_key == "model_id" || opt_key == "dev_model_name" || opt_key == "filament_settings_id")
                        continue;
                    // rebuilt from every filament after this loop
                    if (filament_dev_options.find(opt_key) != filament_dev_options.end())
                        continue;
                    ConfigOption *opt = m_print_config.option(opt_key, true);
                    if (opt == nullptr) {
                        // opt_key does not exist in this ConfigBase and it cannot be created, because it is not defined by this->def().
                        // This is only possible if other is of DynamicConfig type.
                        BOOST_LOG_TRIVIAL(error) << boost::format("can not create option %1% to config, from filament %2%: %3%")%opt_key%filament_index%load_filaments_name[index];
                        record_exit_reson(outfile_dir, CLI_CONFIG_FILE_ERROR, 0, cli_errors[CLI_CONFIG_FILE_ERROR], sliced_info);
                        flush_and_exit(CLI_CONFIG_FILE_ERROR);
                    }
                    ConfigOptionVectorBase* opt_vec_dst = static_cast<ConfigOptionVectorBase*>(opt);
                    const ConfigOptionVectorBase* opt_vec_src = static_cast<const ConfigOptionVectorBase*>(source_opt);
                    if (filament_options_with_variant.find(opt_key) != filament_options_with_variant.end()) {
                        std::vector<int> temp_variant_indice;
                        temp_variant_indice.resize(new_variant_count, -1);
                        try {
                            if (opt_vec_src->size() > 0 && opt_vec_dst->size() < size_t(old_start_indice[filament_index - 1] + old_variant_count))   // See above
                                opt_vec_dst->resize(size_t(old_start_indice[filament_index - 1] + old_variant_count), opt_vec_src);
                            opt_vec_dst->set_with_restore_2(opt_vec_src, temp_variant_indice, old_start_indice[filament_index - 1], old_variant_count, true);
                        } catch (const std::exception &ex) {   // Was an uncaught abort
                            BOOST_LOG_TRIVIAL(error) << boost::format("filament %1%: option %2% could not be applied: %3%") % filament_index % opt_key % ex.what();
                            boost::nowide::cerr << "filament " << filament_index << ": option " << opt_key << " could not be applied: " << ex.what() << std::endl;
                            record_exit_reson(outfile_dir, CLI_CONFIG_FILE_ERROR, 0, cli_errors[CLI_CONFIG_FILE_ERROR], sliced_info);
                            flush_and_exit(CLI_CONFIG_FILE_ERROR);
                        }
 
                        if (opt_key == "filament_extruder_variant")
                            new_variant_counts[filament_index - 1] = opt_vec_src->size();
                    }
                    else {
                        opt_vec_dst->set_at(opt_vec_src, filament_index - 1, 0);
                    }
                }
            }
 
            //ORCA: a per-variant option the loaded filament does not define keeps the values of the
            //      variants the filament already had, and a variant new to it takes its first one's.
            const int old_start = old_start_indice[filament_index - 1];
            std::vector<int> kept_variant_indice = new_variant_indice;
            for (int &i : kept_variant_indice)
                if (i < 0)
                    i = old_start;
            for (const std::string &opt_key : filament_options_with_variant) {
                if (config.has(opt_key))
                    continue;
                auto *opt_vec_dst = dynamic_cast<ConfigOptionVectorBase *>(m_print_config.option(opt_key));
                if (opt_vec_dst == nullptr || opt_vec_dst->size() < size_t(old_start + old_variant_count))
                    continue;
                // set_with_restore_2() pads its source in place
                std::unique_ptr<ConfigOption> old_values(opt_vec_dst->clone());
                opt_vec_dst->set_with_restore_2(static_cast<ConfigOptionVectorBase *>(old_values.get()), kept_variant_indice, old_start,
                                                old_variant_count, true);
            }
 
            //update the old index
            if (old_variant_count != new_variant_count)
            {
                for (int i = index + 1; i < filament_count; i++ )
                {
                    old_start_indice[i] += new_variant_count - old_variant_count;
                }
            }
 
            if (!keep_project && diff_keys_size != different_keys_set.size()) {
                //changed
                different_keys.clear();
 
                for (std::set<std::string>::iterator iter=different_keys_set.begin(); iter !=different_keys_set.end(); ++iter)
                    different_keys.emplace_back(*iter);
                different_settings[filament_index] = Slic3r::escape_strings_cstyle(different_keys);
                BOOST_LOG_TRIVIAL(info) << boost::format("filament %1% new different key size %2%, different_settings %3%")%filament_index %different_keys_set.size() %different_settings[filament_index];
            }
        }
 
        // The stored values cannot be told apart per filament, so they are kept as they are unless every slot has a config.
        std::vector<const DynamicPrintConfig *> filament_configs(filament_count, nullptr);
        for (size_t index = 0; index < load_filaments_config.size(); index++)
            if (load_filaments_index[index] >= 1 && load_filaments_index[index] <= filament_count)
                filament_configs[load_filaments_index[index] - 1] = &load_filaments_config[index];
        // Without refresh_unlisted and with no filament loaded from a file, only the keys the project lacks are
        // filled, with the option defaults for a filament that has no system preset. A loaded filament still
        // replaces them all.
        if (refresh_unlisted || std::find(load_filaments_refresh.begin(), load_filaments_refresh.end(), false) != load_filaments_refresh.end()) {
            if (std::find(filament_configs.begin(), filament_configs.end(), nullptr) == filament_configs.end())
                set_filament_dev_options(m_print_config, filament_configs);
        } else {
            const DynamicPrintConfig no_preset;
            std::replace(filament_configs.begin(), filament_configs.end(), static_cast<const DynamicPrintConfig *>(nullptr), &no_preset);
            DynamicPrintConfig dev_config;
            set_filament_dev_options(dev_config, filament_configs);
            for (const std::string &key : dev_config.keys())
                if (project_keys.count(key) == 0)
                    m_print_config.set_key_value(key, dev_config.option(key)->clone());
        }
 
        if (m_print_config.option<ConfigOptionStrings>("filament_extruder_variant")) {
            std::vector<int>& filament_self_indice = m_print_config.option<ConfigOptionInts>("filament_self_index", true)->values;
            int index_size = m_print_config.option<ConfigOptionStrings>("filament_extruder_variant")->size();
            filament_self_indice.resize(index_size, 1);
            int k = 0;
            for (size_t i = 0; i < filament_count; i++) {
                for (size_t j = 0; j < new_variant_counts[i]; j++) {
                    filament_self_indice[k++] = i + 1;
                }
            }
        }
    }
 
    //compute the flush volume
    ConfigOptionStrings *selected_filament_colors_option = m_extra_config.option<ConfigOptionStrings>("filament_colour");
    ConfigOptionStrings *project_filament_colors_option = m_print_config.option<ConfigOptionStrings>("filament_colour");
    if ((!project_filament_colors_option || (project_filament_colors_option->values.size() == 0)) && selected_filament_colors_option)
    {
        BOOST_LOG_TRIVIAL(info) << boost::format("initial project_filament_colors is null, create it due to filament_colour set in cli");
        project_filament_colors_option = m_print_config.option<ConfigOptionStrings>("filament_colour", true);
        std::vector<std::string>& project_filament_colors = project_filament_colors_option->values;
        project_filament_colors.resize(filament_count, "#FFFFFF");
    }
 
    if (project_filament_colors_option &&
        (selected_filament_colors_option || !m_print_config.option<ConfigOptionFloats>("flush_volumes_matrix") || (current_extruder_count != new_extruder_count) || (new_nozzle_volume_type != current_nozzle_volume_type)))
    {
        std::vector<std::string>  selected_filament_colors;
        if (selected_filament_colors_option) {
            selected_filament_colors = selected_filament_colors_option->values;
            //erase here
            m_extra_config.erase("filament_colour");
 
            if (disable_wipe_tower_after_mapping) {
                std::set<std::string> filament_color_set;
                for (unsigned int color_index = 0; color_index <selected_filament_colors.size(); color_index++)
                {
                    if (!selected_filament_colors[color_index].empty()) {
                        filament_color_set.emplace(selected_filament_colors[color_index]);
                        BOOST_LOG_TRIVIAL(info) << boost::format("add color, index %1%, value %2% to set")%color_index %selected_filament_colors[color_index];
                    }
                    else
                        BOOST_LOG_TRIVIAL(info) << boost::format("skip empty color %1%")%color_index;
                }
 
                if (filament_color_set.size() > 1) {
                    disable_wipe_tower_after_mapping = false;
                    BOOST_LOG_TRIVIAL(info) << boost::format("different filament colours,  switch disable_wipe_tower_after_mapping back to false");
                }
                else {
                    BOOST_LOG_TRIVIAL(warning) << boost::format("only %1% filament colour,  finally set disable_wipe_tower_after_mapping to true")%filament_color_set.size();
                }
 
            }
        }
 
        std::vector<std::string>  &project_filament_colors = project_filament_colors_option->values;
        size_t project_filament_count = project_filament_colors.size();
        BOOST_LOG_TRIVIAL(info) << boost::format("select filament color from cli, size %1%")%selected_filament_colors.size();
        BOOST_LOG_TRIVIAL(info) << boost::format("project filament colors size %1%")%project_filament_colors.size();
        if (project_filament_count > 0)
        {
            for ( size_t index = 0; index < project_filament_count; index++ )
            {
                BOOST_LOG_TRIVIAL(info) << boost::format("project filament %1% original color %2%")%index %project_filament_colors[index];
                if (selected_filament_colors.size() > index)
                {
                    if (!selected_filament_colors[index].empty())
                    {
                        BOOST_LOG_TRIVIAL(info) << boost::format("changed to new color %1%")%selected_filament_colors[index];
                        unsigned char ori_rgb_color[4] = {}, new_rgb_color[4] = {};
                        Slic3r::GUI::BitmapCache::parse_color4(project_filament_colors[index], ori_rgb_color);
                        Slic3r::GUI::BitmapCache::parse_color4(selected_filament_colors[index], new_rgb_color);
                        if ((ori_rgb_color[0] != new_rgb_color[0]) || (ori_rgb_color[1] != new_rgb_color[1]) || (ori_rgb_color[2] != new_rgb_color[2]) || (ori_rgb_color[3] != new_rgb_color[3]))
                        {
                            BOOST_LOG_TRIVIAL(info) << boost::format("found color changes, need to regenerate thumbnail");
                            filament_color_changed = true;
                        }
                        project_filament_colors[index] = selected_filament_colors[index];
                    }
                }
            }
 
            //computing
            ConfigOptionBools* filament_is_support = m_print_config.option<ConfigOptionBools>("filament_is_support", true);
 
            const std::vector<int> &min_flush_volumes = Slic3r::GUI::get_min_flush_volumes(m_print_config, 0);
 
            if (filament_is_support->size() != project_filament_count)
            {
                BOOST_LOG_TRIVIAL(error) << boost::format("filament_is_support's count %1% not equal to filament_colour's size %2%")%filament_is_support->size() %project_filament_count;
                record_exit_reson(outfile_dir, CLI_CONFIG_FILE_ERROR, 0, cli_errors[CLI_CONFIG_FILE_ERROR], sliced_info);
                flush_and_exit(CLI_CONFIG_FILE_ERROR);
            }
 
            {
                std::ostringstream volumes_str;
                std::copy(min_flush_volumes.begin(), min_flush_volumes.end(), std::ostream_iterator<int>(volumes_str, ","));
                BOOST_LOG_TRIVIAL(info) << boost::format("extra_flush_volume: %1%") % volumes_str.str();
                BOOST_LOG_TRIVIAL(info) << boost::format("filament_is_support: %1%") % filament_is_support->serialize();
                BOOST_LOG_TRIVIAL(info) << boost::format("flush_volumes_matrix before computing: %1%") % m_print_config.option<ConfigOptionFloats>("flush_volumes_matrix", true)->serialize();
            }
 
            std::vector<double> &flush_vol_matrix = m_print_config.option<ConfigOptionFloats>("flush_volumes_matrix", true)->values;
            flush_vol_matrix.resize(project_filament_count * project_filament_count * new_extruder_count, 0.f);
 
            // set multiplier to 1?
            std::vector<double>& flush_multipliers = m_print_config.option<ConfigOptionFloats>("flush_multiplier", true)->values;
            flush_multipliers.resize(new_extruder_count, 1.f);
 
            std::vector<int> nozzle_flush_dataset(new_extruder_count, 0);
            {
                std::vector<int> nozzle_flush_dataset_full = m_print_config.option<ConfigOptionIntsNullable>("nozzle_flush_dataset",true)->values;
                if (m_print_config.has("printer_extruder_variant"))
                    nozzle_flush_dataset_full.resize(new_printer_variant_count, 0);
                else
                    nozzle_flush_dataset_full.resize(1, 0);
 
                std::vector<int> extruders;
                if (m_print_config.has("extruder_type"))
                    extruders = m_print_config.option<ConfigOptionEnumsGeneric>("extruder_type")->values;
                else
                    extruders.resize(1,int(ExtruderType::etDirectDrive));
 
                std::vector<int> volume_types;
                if (m_print_config.has("nozzle_volume_type"))
                    volume_types = m_print_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type")->values; // get volume type from 3mf
                else
                    volume_types.resize(1, int(NozzleVolumeType::nvtStandard));
 
                if(m_extra_config.has("nozzle_volume_type")) // get volume type from input
                    volume_types = m_extra_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type")->values;
 
                for (int eidx = 0; eidx < new_extruder_count; ++eidx) {
                    int index = 0;
                    if (m_print_config.has("printer_extruder_id") && m_print_config.has("printer_extruder_variant"))
                        index = m_print_config.get_index_for_extruder(eidx + 1, "printer_extruder_id", ExtruderType(extruders[eidx]), NozzleVolumeType(volume_types[eidx]), "printer_extruder_variant");
                    nozzle_flush_dataset[eidx] = nozzle_flush_dataset_full[index];
                }
            }
 
            // A mixed slot never reaches a nozzle, so its row and column stay empty, as in the GUI.
            // Command line options are not merged into m_print_config yet, so they win here.
            const ConfigOptionBools *is_mixed_opt = m_extra_config.option<ConfigOptionBools>("filament_is_mixed");
            if (!is_mixed_opt)
                is_mixed_opt = m_print_config.option<ConfigOptionBools>("filament_is_mixed");
            auto is_mixed_slot = [is_mixed_opt](int idx) {
                return is_mixed_opt && idx < static_cast<int>(is_mixed_opt->values.size()) && is_mixed_opt->values[idx];
            };
 
            for (size_t nozzle_id = 0; nozzle_id < new_extruder_count; ++nozzle_id) {
            std::vector<double> flush_vol_mtx = get_flush_volumes_matrix(flush_vol_matrix, nozzle_id, new_extruder_count);
                for (int from_idx = 0; from_idx < project_filament_count; from_idx++) {
                    const std::string &from_color  = project_filament_colors[from_idx];
                    unsigned char      from_rgb[4] = {};
                    Slic3r::GUI::BitmapCache::parse_color4(from_color, from_rgb);
                    bool is_from_support = filament_is_support->get_at(from_idx);
                    for (int to_idx = 0; to_idx < project_filament_count; to_idx++) {
                        bool is_to_support = filament_is_support->get_at(to_idx);
                        if (from_idx == to_idx || is_mixed_slot(from_idx) || is_mixed_slot(to_idx)) {
                            flush_vol_mtx[project_filament_count * from_idx + to_idx] = 0.f;
                        } else {
                            int flushing_volume = 0;
                            if (is_to_support) {
                                flushing_volume = Slic3r::g_flush_volume_to_support;
                            } else {
                                const std::string &to_color  = project_filament_colors[to_idx];
                                unsigned char      to_rgb[4] = {};
                                Slic3r::GUI::BitmapCache::parse_color4(to_color, to_rgb);
 
                                Slic3r::FlushVolCalculator calculator(min_flush_volumes[from_idx], Slic3r::g_max_flush_volume,nozzle_flush_dataset[nozzle_id]);
                                flushing_volume = calculator.calc_flush_vol(from_rgb[3], from_rgb[0], from_rgb[1], from_rgb[2], to_rgb[3], to_rgb[0], to_rgb[1], to_rgb[2]);
                                if (is_from_support) { flushing_volume = std::max(Slic3r::g_min_flush_volume_from_support, flushing_volume); }
                            }
 
                            flush_vol_mtx[project_filament_count * from_idx + to_idx] = flushing_volume;
                        }
                    }
                    set_flush_volumes_matrix(flush_vol_matrix, flush_vol_mtx, nozzle_id, new_extruder_count);
                }
            }
            BOOST_LOG_TRIVIAL(info) << boost::format("flush_volumes_matrix after computed: %1%")%m_print_config.option<ConfigOptionFloats>("flush_volumes_matrix")->serialize();
        }
        else
        {
            BOOST_LOG_TRIVIAL(warning) << boost::format("filament colors count is 0 in projects");
        }
    }
    else
    {
        BOOST_LOG_TRIVIAL(warning) << boost::format("no filament colors found in projects");
    }
 
    //BBS: set default to ptFFF
    if (printer_technology == ptUnknown)
        printer_technology = ptFFF;
 
    //BBS: merge these models into one
    BOOST_LOG_TRIVIAL(info) << "total " << m_models.size() << " models, "<<orients_requirement.size()<<" objects"<<std::endl;
    if (m_models.size() > 1)
    {
        BOOST_LOG_TRIVIAL(info) << "merge all the models into one\n";
        Model m;
        m.set_backup_path(m_models[0].get_backup_path());
        for (auto& model : m_models)
            for (ModelObject* o : model.objects)
            {
                ModelObject* new_object = m.add_object(*o);
                //BOOST_LOG_TRIVIAL(info) << "object "<<o->name <<", id :" << o->id().id << "\n";
                //orients_requirement.emplace(new_object->id().id, orients_requirement[o->id().id]);
                //orients_requirement.erase(o->id().id);
            }
        m.add_default_instances();
        m_models.clear();
        m_models.emplace_back(std::move(m));
    }
 
 
    //update the object config due to extruder count change
    if ((machine_switch) && ((current_extruder_count != new_extruder_count) || (current_print_variant_count != new_printer_variant_count)))
    {
        //process the object params here
        size_t num_objects = m_models[0].objects.size();
        for (int i = 0; i < num_objects; ++i) {
            ModelObject* object = m_models[0].objects[i];
            DynamicPrintConfig object_config = object->config.get();
            if (!object_config.empty()) {
                /* if (current_extruder_count < new_extruder_count)
                    object_config.update_values_from_single_to_multi_2(m_print_config, print_options_with_variant);
                else
                    object_config.update_values_from_multi_to_single_2(print_options_with_variant);*/
                object_config.update_values_from_multi_to_multi_2(current_print_extruder_variants, new_printer_extruder_variants, m_print_config, print_options_with_variant);
                object->config.assign_config(std::move(object_config));
            }
            for (ModelVolume* v : object->volumes) {
                if (v->is_model_part() || v->is_modifier()) {
                    DynamicPrintConfig volume_config = v->config.get();
                    if (!volume_config.empty()) {
                        /* if (current_extruder_count < new_extruder_count)
                           volume_config.update_values_from_single_to_multi_2(m_print_config, print_options_with_variant);
                        else
                           volume_config.update_values_from_multi_to_single_2(print_options_with_variant);*/
                        volume_config.update_values_from_multi_to_multi_2(current_print_extruder_variants, new_printer_extruder_variants, m_print_config, print_options_with_variant);
                        v->config.assign_config(std::move(volume_config));
                    }
                }
            }
 
            for (auto &layer_config_it : object->layer_config_ranges) {
                ModelConfig& layer_model_config = layer_config_it.second;
                DynamicPrintConfig layer_config = layer_model_config.get();
                if (!layer_config.empty()) {
                   /*if (current_extruder_count < new_extruder_count)
                       layer_config.update_values_from_single_to_multi_2(m_print_config, print_options_with_variant);
                   else
                       layer_config.update_values_from_multi_to_single_2(print_options_with_variant);*/
                    layer_config.update_values_from_multi_to_multi_2(current_print_extruder_variants, new_printer_extruder_variants, m_print_config, print_options_with_variant);
                   layer_model_config.assign_config(std::move(layer_config));
               }
            }
       }
   }
 
    //load custom gcodes into model if needed
    if ((custom_gcodes_map.size() > 0)&&(m_models.size() > 0))
    {
        m_models[0].plates_custom_gcodes = custom_gcodes_map;
        /*m_models[0].plates_custom_gcodes.clear();
 
        for (auto& custom_gcode: custom_gcodes_map)
        {
            BOOST_LOG_TRIVIAL(info) << boost::format("insert custom_gocde %1% into plate %2%")%plate_id;
            m_models[0].plates_custom_gcodes.emplace(custom_gcode.first, custom_gcode.second);
        }*/
    }
 
    if (skip_modified_gcodes)
    {
        std::map<int, CustomGCode::Info>::iterator gcodes_iter;
        for (gcodes_iter = m_models[0].plates_custom_gcodes.begin(); gcodes_iter != m_models[0].plates_custom_gcodes.end(); gcodes_iter++)
        {
            CustomGCode::Info &gcode_info = gcodes_iter->second;
            std::vector<CustomGCode::Item>::iterator item_iter = gcode_info.gcodes.begin();
 
            while ( item_iter != gcode_info.gcodes.end() )
            {
                if (item_iter->type == CustomGCode::Custom) {
                    BOOST_LOG_TRIVIAL(warning) << boost::format("skip_modified_gcodes: remove custom gcodes %1% in plate %2%") %item_iter->extra %gcodes_iter->first;
                    item_iter = gcode_info.gcodes.erase(item_iter);
                }
                else
                    item_iter++;
            }
        }
    }
 
    //ORCA: settings passed on the command line (--sparse-infill-density 25% ...) override the loaded
    //      presets right here, so they belong in different_settings_to_system just as a preset
    //      override does. Without them re-opening the exported project in the GUI shows nothing
    //      modified and reverts those values to the system presets'.
    //
    //      The keys come from m_config, not m_extra_config: read_cli() puts only what the user typed
    //      into m_config (setup() adds nothing but CLI-own defaults), whereas the CLI writes its own
    //      values into m_extra_config. Only keys whose value the override actually changed are
    //      recorded -- a typed value equal to the loaded one modifies nothing -- and each lands in
    //      the column(s) whose preset type owns it: [0] process, [1..n-2] filaments, [n-1] printer.
    //
    //      "Changed" is judged the way the value is read: a list is compared entry by entry with a
    //      missing entry read as the first, as get_at() does -- so --nozzle-temperature 245 against
    //      245,245,245 is no change, although the two serialize differently.
    //
    //      A key the loaded config does not carry at all is always recorded, even if the typed value
    //      equals the built-in default. On reopen the GUI restores an unlisted key from the SYSTEM
    //      preset, which need not match that default: a 3MF written before an option existed leaves
    //      it absent here, and --sparse-infill-density 20% (the default) against a Prusa system 15%
    //      would otherwise go unrecorded and be reverted. Over-recording is cosmetic; under-recording
    //      loses the value.
    std::map<std::string, std::unique_ptr<ConfigOption>> cli_override_before;
    for (const std::string &key : m_config.keys()) {
        if (!m_extra_config.has(key))
            continue;
        const ConfigOption *loaded = m_print_config.option(key);
        cli_override_before[key].reset(loaded != nullptr ? loaded->clone() : nullptr); // null: always recorded
    }
 
    // Apply command line options to a more specific DynamicPrintConfig which provides normalize()
    // (command line options override --load files)
    m_print_config.apply(m_extra_config, true);
 
    if (!cli_override_before.empty()) {
        std::vector<std::string> &columns = m_print_config.option<ConfigOptionStrings>("different_settings_to_system", true)->values;
        auto owned_by = [](const std::vector<std::string> &options, const std::string &key) {
            return std::find(options.begin(), options.end(), key) != options.end();
        };
        auto add_to_column = [&columns](size_t index, const std::string &key) {
            std::vector<std::string> keys;
            Slic3r::unescape_strings_cstyle(columns[index], keys);
            if (std::find(keys.begin(), keys.end(), key) == keys.end()) {
                keys.push_back(key);
                columns[index] = Slic3r::escape_strings_cstyle(keys);
            }
        };
        auto same_value = [](const ConfigOption *a, const ConfigOption *b) {
            if (a == nullptr || b == nullptr)
                return false;
            const auto *va = dynamic_cast<const ConfigOptionVectorBase *>(a);
            const auto *vb = dynamic_cast<const ConfigOptionVectorBase *>(b);
            if (va == nullptr || vb == nullptr)
                return va == vb && a->serialize() == b->serialize();
            const std::vector<std::string> ea = va->vserialize(), eb = vb->vserialize();
            if (ea.empty() || eb.empty())
                return ea.empty() && eb.empty();
            for (size_t i = 0; i < std::max(ea.size(), eb.size()); ++i)
                if (ea[i < ea.size() ? i : 0] != eb[i < eb.size() ? i : 0])
                    return false;
            return true;
        };
        //ORCA: always true after the resize to filament_count + 2 above, and nothing in between can
        //      shrink the column vector -- different_settings_to_system is not a CLI option. Kept as
        //      a check rather than an assert: release builds compile asserts out, so an assert would
        //      protect nothing, while a build with _GLIBCXX_ASSERTIONS would abort on columns[0].
        if (columns.size() >= 2) {
            for (const auto &[key, before] : cli_override_before) {
                if (same_value(before.get(), m_print_config.option(key)))
                    continue;
                bool recorded = false;
                if (owned_by(Preset::print_options(), key)) {
                    add_to_column(0, key);
                    recorded = true;
                }
                if (owned_by(Preset::filament_options(), key)) {
                    for (size_t i = 1; i + 1 < columns.size(); ++i)
                        add_to_column(i, key);
                    recorded = true;
                }
                if (owned_by(Preset::printer_options(), key)) {
                    add_to_column(columns.size() - 1, key);
                    recorded = true;
                }
                if (recorded)
                    BOOST_LOG_TRIVIAL(info) << boost::format("CLI: override %1% recorded in different_settings_to_system") % key;
            }
        }
    }
    // Normalizing after importing the 3MFs / AMFs
    m_print_config.normalize_fdm();
 
    // A mixed slot is virtual but still needs a filament entry of its own. Without one, feature
    // filament ids aimed at it fall outside the filament count, are reset to the first filament
    // and the model silently prints in a single colour.
    if (const auto *is_mixed_opt = m_print_config.option<ConfigOptionBools>("filament_is_mixed")) {
        const auto &is_mixed = is_mixed_opt->values;
        for (size_t slot = static_cast<size_t>(std::max(filament_count, 0)); slot < is_mixed.size(); ++slot) {
            if (!is_mixed[slot])
                continue;
            BOOST_LOG_TRIVIAL(error) << boost::format("mixed filament slot %1% has no filament of its own, only %2% filaments are loaded; "
                                                      "load one filament per slot, including each mixed one")
                                            % (slot + 1) % filament_count;
            record_exit_reson(outfile_dir, CLI_MIXED_FILAMENT_INVALID, 0, cli_errors[CLI_MIXED_FILAMENT_INVALID], sliced_info);
            flush_and_exit(CLI_MIXED_FILAMENT_INVALID);
        }
    }
    if (filament_count > 0)
        resize_mixed_filament_metadata(m_print_config, size_t(filament_count), size_t(filament_count));
 
    m_print_config.option<ConfigOptionEnum<PrinterTechnology>>("printer_technology", true)->value = printer_technology;
 
    bool has_wipe_tower_position = m_print_config.option<ConfigOptionFloats>("wipe_tower_x") && m_print_config.option<ConfigOptionFloats>("wipe_tower_y");
    // Initialize full print configs for both the FFF and SLA technologies.
    FullPrintConfig    fff_print_config;
    //SLAFullPrintConfig sla_print_config;
 
    // Synchronize the default parameters and the ones received on the command line.
    if (printer_technology == ptFFF) {
        fff_print_config.apply(m_print_config, true);
        m_print_config.apply(fff_print_config, true);
        //ORCA: an option no preset or project defines has just come in as its single default value, and a
        //      command line override may hold one value per filament.
        normalize_filament_values_to_variants(m_print_config);
    } else {
        boost::nowide::cerr << "invalid printer_technology " << std::endl;
        record_exit_reson(outfile_dir, CLI_INVALID_PRINTER_TECH, 0, cli_errors[CLI_INVALID_PRINTER_TECH], sliced_info);
        flush_and_exit(CLI_INVALID_PRINTER_TECH);
        /*assert(printer_technology == ptSLA);
        sla_print_config.filename_format.value = "[input_filename_base].sl1";
 
        // The default bed shape should reflect the default display parameters
        // and not the fff defaults.
        double w = sla_print_config.display_width.getFloat();
        double h = sla_print_config.display_height.getFloat();
        sla_print_config.printable_area.values = { Vec2d(0, 0), Vec2d(w, 0), Vec2d(w, h), Vec2d(0, h) };
 
        sla_print_config.apply(m_print_config, true);
        m_print_config.apply(sla_print_config, true);*/
    }
 
    std::map<std::string, std::string> validity = m_print_config.validate(true);
    if (!validity.empty()) {
        boost::nowide::cerr << "Param values in 3mf/config error: "<< std::endl;
        for (std::map<std::string, std::string>::iterator it=validity.begin(); it!=validity.end(); ++it)
            boost::nowide::cerr << it->first <<": "<< it->second << std::endl;
        record_exit_reson(outfile_dir, CLI_INVALID_VALUES_IN_3MF, 0, cli_errors[CLI_INVALID_VALUES_IN_3MF], sliced_info);
        flush_and_exit(CLI_INVALID_VALUES_IN_3MF);
    }
 
    ConfigOptionBool* enable_wrapping_detection_option = m_print_config.option<ConfigOptionBool>("enable_wrapping_detection", true);
    BOOST_LOG_TRIVIAL(info) << boost::format("%1%, remove_wrapping_detect %2%, old value %3%")%__LINE__ %remove_wrapping_detect %enable_wrapping_detection_option->value;
    if (is_bbl_3mf && remove_wrapping_detect) {
        enable_wrapping_detection_option->value = false;
    }
    enable_wrapping_detect = enable_wrapping_detection_option->value;
    Pointfs current_wrapping_exclude_area = m_print_config.opt<ConfigOptionPoints>("wrapping_exclude_area", true)->values;
    if (disable_wipe_tower_after_mapping && enable_wrapping_detect && !current_wrapping_exclude_area.empty())
    {
        disable_wipe_tower_after_mapping = false;
        BOOST_LOG_TRIVIAL(info) << boost::format("%1%, set disable_wipe_tower_after_mapping back to false due to wrapping detect")%__LINE__;
    }
 
    // Belt printers never get the classic wipe tower (see Print::has_wipe_tower()), so reserve no space for it.
    const ConfigOptionBool* belt_printer_opt = m_print_config.option<ConfigOptionBool>("belt_printer");
    const bool is_belt_printer = belt_printer_opt && belt_printer_opt->value;
 
    auto timelapse_type_opt = m_print_config.option("timelapse_type");
    bool is_smooth_timelapse = false;
    if (enable_timelapse && timelapse_type_opt && (timelapse_type_opt->getInt() == TimelapseType::tlSmooth))
        is_smooth_timelapse = true;
    // A mixed filament swaps between its components every layer, so it needs the tower even when
    // every loaded preset is the same.
    if (disable_wipe_tower_after_mapping) {
        if (const auto *is_mixed_opt = m_print_config.option<ConfigOptionBools>("filament_is_mixed");
            is_mixed_opt && has_any_mixed_filament(is_mixed_opt->values)) {
            disable_wipe_tower_after_mapping = false;
            BOOST_LOG_TRIVIAL(info) << boost::format("%1%, set disable_wipe_tower_after_mapping back to false due to a mixed filament")%__LINE__;
        }
    }
    if (disable_wipe_tower_after_mapping) {
        if (is_smooth_timelapse)
        {
            disable_wipe_tower_after_mapping = false;
            BOOST_LOG_TRIVIAL(warning) << boost::format("%1%: disable_wipe_tower_after_mapping: set back to false due to smooth timelapse!")%__LINE__;
        }
        else {
            ConfigOptionBool* enable_wipe_op = m_print_config.option<ConfigOptionBool>("enable_prime_tower", true);
            enable_wipe_op->value = false;
            BOOST_LOG_TRIVIAL(warning) << boost::format("%1%: disable_wipe_tower_after_mapping: disable prime tower for only one filament!")%__LINE__;
 
            std::string diff_settings = different_settings[0];
 
            if (diff_settings.empty())
                different_settings[0] = "enable_prime_tower";
            else {
                std::vector<std::string> different_keys;
                Slic3r::unescape_strings_cstyle(diff_settings, different_keys);
                bool need_insert = true;
                for (int index = 0; index < different_keys.size(); index++) {
                    if (different_keys[index] == "enable_prime_tower") {
                        need_insert = false;
                        break;
                    }
                }
                if (need_insert)
                    different_settings[0] = diff_settings + ";enable_prime_tower";
            }
        }
    }
 
    //BBS: partplate list
    Slic3r::GUI::PartPlateList partplate_list(NULL, m_models.data(), printer_technology);
    //use Pointfs insteadof Points
    Pointfs current_printable_area = m_print_config.opt<ConfigOptionPoints>("printable_area")->values;
    Pointfs current_exclude_area = legacy_bed_exclude_area_points(m_print_config);
    std::vector<Pointfs> current_extruder_areas;
    //update part plate's size
    double print_height = m_print_config.opt_float("printable_height");
    std::vector<double> current_extruder_print_heights;
    double height_to_lid = m_print_config.opt_float("extruder_clearance_height_to_lid");
    double height_to_rod = m_print_config.opt_float("extruder_clearance_height_to_rod");
    double clearance_radius = m_print_config.opt_float("extruder_clearance_radius");
    double nozzle_height = m_print_config.opt_float("nozzle_height");
    Vec2d align_center = m_print_config.option<ConfigOptionPoint>("best_object_pos")->value;
    int shared_printable_width = 0, shared_printable_depth = 0, shared_printable_height = 0, shared_center_x = 0, shared_center_y = 0;
    //double plate_stride;
    std::string bed_texture;
 
    if (m_print_config.opt<ConfigOptionPointsGroups>("extruder_printable_area")) {
        current_extruder_areas = m_print_config.opt<ConfigOptionPointsGroups>("extruder_printable_area")->values;
    }
    if (m_print_config.opt<ConfigOptionFloatsNullable>("extruder_printable_height")) {
        current_extruder_print_heights = m_print_config.opt<ConfigOptionFloatsNullable>("extruder_printable_height")->values;
    }
    {
        BoundingBoxf current_printable_bbox(current_printable_area);
        current_printable_width = static_cast<int>(current_printable_bbox.size().x());
        current_printable_depth = static_cast<int>(current_printable_bbox.size().y());
    }
    current_printable_height = print_height;
    if (old_printable_width == 0)
        old_printable_width = current_printable_width;
    if (old_printable_depth == 0)
        old_printable_depth = current_printable_depth;
    if (old_printable_height == 0)
        old_printable_height = current_printable_height;
    if ((current_extruder_areas.size() > 0) && (current_extruder_areas.size() == current_extruder_print_heights.size())) {
        BoundingBox current_bbox({0, 0}, {current_printable_width, current_printable_depth});
        int temp_height = current_printable_height;
 
        for (unsigned int temp_index = 0; temp_index < current_extruder_areas.size(); temp_index++)
        {
            BoundingBox temp_bbox;
            Pointfs& temp_extruder_shape = current_extruder_areas[temp_index];
            for (unsigned int temp_index2 = 0; temp_index2 < temp_extruder_shape.size(); temp_index2++)
                temp_bbox.merge({temp_extruder_shape[temp_index2].x(), temp_extruder_shape[temp_index2].y()});
 
            if (current_bbox.min.x() < temp_bbox.min.x())
                current_bbox.min.x() = temp_bbox.min.x();
            if (current_bbox.min.y() < temp_bbox.min.y())
                current_bbox.min.y() = temp_bbox.min.y();
            if (current_bbox.max.x() > temp_bbox.max.x())
                current_bbox.max.x() = temp_bbox.max.x();
            if (current_bbox.max.y() > temp_bbox.max.y())
                current_bbox.max.y() = temp_bbox.max.y();
            if ((int)(current_extruder_print_heights[temp_index]) < temp_height)
                temp_height = current_extruder_print_heights[temp_index];
        }
        shared_printable_width = current_bbox.size().x();
        shared_printable_depth = current_bbox.size().y();
        shared_printable_height = temp_height;
        shared_center_x = current_bbox.center().x();
        shared_center_y = current_bbox.center().y();
 
        BOOST_LOG_TRIVIAL(info) << boost::format("Line %1%: shared_printable_size {%2%, %3%, %4%}, shared_center {%5%, %6%}")
                    %__LINE__ %shared_printable_width %shared_printable_depth %shared_printable_height %shared_center_x %shared_center_y;
    }
    if (is_bbl_3mf && (old_printable_width > 0) && (old_printable_depth > 0) && (old_printable_height > 0))
    {
        //check the printable size logic
        //if ((old_printable_width > current_printable_width) || (old_printable_depth > current_printable_depth) || (old_printable_height > current_printable_height))
        if ((old_printable_width > current_printable_width) || (old_printable_depth > current_printable_depth) || (old_printable_height > current_printable_height))
        {
            BOOST_LOG_TRIVIAL(error) << boost::format("old printable size {%1%, %2%, %3%} is larger than new printable size {%4%, %5%, %6%}, the object size should be limited")
                %old_printable_width %old_printable_depth %old_printable_height %current_printable_width %current_printable_depth %current_printable_height;
            /*record_exit_reson(outfile_dir, CLI_PRINTABLE_SIZE_REDUCED, 0, cli_errors[CLI_PRINTABLE_SIZE_REDUCED], sliced_info);
            flush_and_exit(CLI_PRINTABLE_SIZE_REDUCED);*/
            shrink_to_new_bed = 2;
        }
        else if ((old_printable_width < current_printable_width) || (old_printable_depth < current_printable_depth))
        {
            BOOST_LOG_TRIVIAL(info) << boost::format("old printable size {%1%, %2%, %3%} is smaller than new printable size {%4%, %5%, %6%}, need to center the model")
                %old_printable_width %old_printable_depth %old_printable_height %current_printable_width %current_printable_depth %current_printable_height;
            shrink_to_new_bed = 1;
        }
        else {
            if ((current_exclude_area.size() > 0)&&(current_exclude_area != old_exclude_area)) {
                BOOST_LOG_TRIVIAL(info) << boost::format("old printable size {%1%, %2%, %3%}, new printable size {%4%, %5%, %6%}, exclude_area different, need to shrink")
                   %old_printable_width %old_printable_depth %old_printable_height %current_printable_width %current_printable_depth %current_printable_height;
                shrink_to_new_bed = 2;
            }
            else {
                BOOST_LOG_TRIVIAL(info) << boost::format("old printable size {%1%, %2%, %3%}, new printable size {%4%, %5%, %6%}, extract the same, no need shrink")
                   %old_printable_width %old_printable_depth %old_printable_height %current_printable_width %current_printable_depth %current_printable_height;
            }
        }
    }
 
    if (m_models.size() > 0)
    {
        BOOST_LOG_TRIVIAL(info) << boost::format("translate_old %1%, shrink_to_new_bed %2%, old bed size {%3%, %4%, %5%}")%translate_old%shrink_to_new_bed %old_printable_width %old_printable_depth %old_printable_height;
        if (translate_old) {
            BOOST_LOG_TRIVIAL(info) << boost::format("translate old 3mf, switch to older bed size,{%1%, %2%, %3%}")%(old_printable_width + bed3d_ax3s_default_tip_radius)%(old_printable_depth+bed3d_ax3s_default_tip_radius) %old_printable_height;
            partplate_list.reset_size(old_printable_width + bed3d_ax3s_default_tip_radius, old_printable_depth + bed3d_ax3s_default_tip_radius, old_printable_height, false);
        }
        else {
            partplate_list.reset_size(old_printable_width, old_printable_depth, old_printable_height, false);
        }
        partplate_list.set_shapes(make_counter_clockwise(current_printable_area), current_exclude_area, current_wrapping_exclude_area, current_extruder_areas, current_extruder_print_heights, bed_texture,
                                  height_to_lid, height_to_rod);
        //plate_stride = partplate_list.plate_stride_x();
    }
 
    //process some old params
    if (is_bbl_3mf && keep_old_params) {
        std::vector<std::string> different_keys;
        Slic3r::unescape_strings_cstyle(different_settings[0], different_keys);
        std::set<std::string> different_key_set(different_keys.begin(), different_keys.end());
        BOOST_LOG_TRIVIAL(info) << boost::format("%1%, process old params for support and wipe tower")%__LINE__;
 
        //wipe tower params process
        ConfigOptionEnum<WipeTowerWallType> *prime_tower_rib_wall_option = m_print_config.option<ConfigOptionEnum<WipeTowerWallType>>("wipe_tower_wall_type", true);
        prime_tower_rib_wall_option->value = WipeTowerWallType::wtwRectangle;
 
        ConfigOptionPercent *prime_tower_infill_gap_option = m_print_config.option<ConfigOptionPercent>("prime_tower_infill_gap", true);
        prime_tower_infill_gap_option->value = 100;
 
        ConfigOptionInts *filament_adhesiveness_category_option = m_print_config.option<ConfigOptionInts>("filament_adhesiveness_category", true);
        std::vector<int>& filament_adhesiveness_category_values = filament_adhesiveness_category_option->values;
        filament_adhesiveness_category_values.resize(filament_count);
        for (int index = 0; index < filament_count; index++)
            filament_adhesiveness_category_values[index] = 100;
 
        //support params process
        ConfigOptionBool *enable_support_option = m_print_config.option<ConfigOptionBool>("enable_support", true);
        ConfigOptionEnum<SupportType>* support_type_option  = m_print_config.option<ConfigOptionEnum<SupportType>>("support_type", true);
        ConfigOptionEnum<SupportMaterialStyle>* support_style_option = m_print_config.option<ConfigOptionEnum<SupportMaterialStyle>>("support_style", true);
        ConfigOptionFloat *support_top_z_distance_option = m_print_config.option<ConfigOptionFloat>("support_top_z_distance", true);
        if (support_type_option->value == stTreeAuto)
        {
            if (different_key_set.find("support_type") == different_key_set.end())
                support_type_option->value = stNormalAuto;
        }
 
        //traverse each object one by one
        size_t num_objects = m_models[0].objects.size();
        for (int i = 0; i < num_objects; ++i) {
            ModelObject* object = m_models[0].objects[i];
            DynamicPrintConfig object_config = object->config.get();
            ConfigOptionBool *obj_enable_support_option = object_config.option<ConfigOptionBool>("enable_support");
            if (enable_support_option->value || (obj_enable_support_option && obj_enable_support_option->value)) {
                ConfigOptionEnum<SupportType>* obj_support_type_option  = object_config.option<ConfigOptionEnum<SupportType>>("support_type");
                ConfigOptionEnum<SupportMaterialStyle>* obj_support_style_option = object_config.option<ConfigOptionEnum<SupportMaterialStyle>>("support_style");
                ConfigOptionFloat *obj_support_top_z_distance_option = object_config.option<ConfigOptionFloat>("support_top_z_distance");
 
                SupportType obj_support_type = obj_support_type_option? obj_support_type_option->value: support_type_option->value;
                SupportMaterialStyle obj_support_style =  obj_support_style_option? obj_support_style_option->value: support_style_option->value;
                if ((obj_support_type == stTreeAuto) && (obj_support_style == smsDefault ))
                {
                    float support_top_z_distance = obj_support_top_z_distance_option? obj_support_top_z_distance_option->value: support_top_z_distance_option->value;
                    if (!object->has_custom_layering() && (support_top_z_distance == 0)) {
                        obj_support_style_option = object_config.option<ConfigOptionEnum<SupportMaterialStyle>>("support_style", true);
                        obj_support_style_option->value = smsTreeOrganic;
                    }
                }
            }
        }
 
        //travel_acceleration
        ConfigOptionFloatsNullable *travel_acceleration_option = m_print_config.option<ConfigOptionFloatsNullable>("travel_acceleration", true);
        ConfigOptionFloatsNullable *default_acceleration_option = m_print_config.option<ConfigOptionFloatsNullable>("default_acceleration");
        travel_acceleration_option->values = default_acceleration_option->values;
 
        ConfigOptionFloatsNullable *initial_layer_travel_acceleration_option = m_print_config.option<ConfigOptionFloatsNullable>("initial_layer_travel_acceleration", true);
        ConfigOptionFloatsNullable *initial_layer_acceleration_option = m_print_config.option<ConfigOptionFloatsNullable>("initial_layer_acceleration");
        initial_layer_travel_acceleration_option->values = initial_layer_acceleration_option->values;
    }
 
    auto get_print_sequence = [](Slic3r::GUI::PartPlate* plate, DynamicPrintConfig& print_config, bool &is_seq_print) {
        PrintSequence curr_plate_seq = plate->get_print_seq();
        if (curr_plate_seq == PrintSequence::ByDefault) {
            auto seq_print = print_config.option<ConfigOptionEnum<PrintSequence>>("print_sequence");
            if (seq_print && (seq_print->value == PrintSequence::ByObject)) {
                BOOST_LOG_TRIVIAL(info) << boost::format("plate print by object, set from global");
                is_seq_print = true;
            }
        }
        else if (curr_plate_seq == PrintSequence::ByObject) {
            BOOST_LOG_TRIVIAL(info) << boost::format("plate print by object, set from plate self");
            is_seq_print = true;
        }
    };
 
    auto check_plate_wipe_tower = [get_print_sequence, is_smooth_timelapse, is_belt_printer](Slic3r::GUI::PartPlate* plate, int plate_index, DynamicPrintConfig& print_config, plate_obj_size_info_t &plate_obj_size_info) {
        plate_obj_size_info.obj_bbox= plate->get_objects_bounding_box();
        BOOST_LOG_TRIVIAL(info) << boost::format("plate %1%, object bbox: min {%2%, %3%, %4%} - max {%5%, %6%, %7%}")
                    %(plate_index+1) %plate_obj_size_info.obj_bbox.min.x() % plate_obj_size_info.obj_bbox.min.y() % plate_obj_size_info.obj_bbox.min.z() %plate_obj_size_info.obj_bbox.max.x() % plate_obj_size_info.obj_bbox.max.y() % plate_obj_size_info.obj_bbox.max.z();
        if (is_belt_printer || !print_config.has("wipe_tower_x")) {
            plate_obj_size_info.has_wipe_tower = false;
            BOOST_LOG_TRIVIAL(info) << boost::format("can not found wipe_tower_x in config, set to no wipe tower");
            return;
        }
 
        int valid_count = plate->printable_instance_size();
        if (valid_count <= 0){
            plate_obj_size_info.has_wipe_tower = false;
            BOOST_LOG_TRIVIAL(info) << boost::format("no printable object found, set to no wipe tower");
            return;
        }
 
        bool is_sequence = false;
        get_print_sequence(plate, print_config, is_sequence);
        if (is_sequence && valid_count > 1) {
            plate_obj_size_info.has_wipe_tower = false;
            BOOST_LOG_TRIVIAL(info) << boost::format("sequence print, valid_count=%1%, set to no wipe tower")%valid_count;
            return;
        }
 
        std::vector<int> extruders = plate->get_extruders_under_cli(true, print_config);
        unsigned int filaments_cnt = extruders.size();
        if ((filaments_cnt <= 1) && !is_smooth_timelapse){
            plate_obj_size_info.has_wipe_tower = false;
            BOOST_LOG_TRIVIAL(info) << boost::format("filaments_cnt=%1%, set to no wipe tower")%filaments_cnt;
            return;
        }
 
        ConfigOptionFloats *wipe_x_option = dynamic_cast<ConfigOptionFloats *>(print_config.option("wipe_tower_x"));
        ConfigOptionFloats *wipe_y_option = dynamic_cast<ConfigOptionFloats *>(print_config.option("wipe_tower_y"));
 
        // get_at() silently clamps an out-of-range index to entry 0 - make the reuse visible
        if (static_cast<size_t>(plate_index) >= wipe_x_option->values.size() || static_cast<size_t>(plate_index) >= wipe_y_option->values.size()) {
            BOOST_LOG_TRIVIAL(warning) << boost::format("plate %1%: wipe_tower_x/y only has %2%/%3% entries, reusing entry 0's position")
                    %(plate_index+1) %wipe_x_option->values.size() %wipe_y_option->values.size();
        }
        plate_obj_size_info.wipe_x = wipe_x_option->get_at(plate_index);
        plate_obj_size_info.wipe_y = wipe_y_option->get_at(plate_index);
 
        // Body and brim from one estimate: resolving an auto (-1) brim against a different
        // height would size the two halves of the same tower from two different objects.
        const WipeTowerFootprint footprint = plate->estimate_wipe_tower_footprint(print_config, filaments_cnt);
        float brim_width = float(footprint.brim_width);
 
        plate_obj_size_info.wipe_width = footprint.width;
        plate_obj_size_info.wipe_depth = footprint.depth;
 
        Vec3d origin = plate->get_origin();
        Vec3d start(origin(0) + plate_obj_size_info.wipe_x - brim_width, origin(1) + plate_obj_size_info.wipe_y, 0.f);
        plate_obj_size_info.obj_bbox.merge(start);
        Vec3d end(origin(0) + plate_obj_size_info.wipe_x + plate_obj_size_info.wipe_width + brim_width, origin(1) + plate_obj_size_info.wipe_y + plate_obj_size_info.wipe_depth, 0.f);
        plate_obj_size_info.obj_bbox.merge(end);
        plate_obj_size_info.has_wipe_tower = true;
        BOOST_LOG_TRIVIAL(info) << boost::format("plate %1%, has wipe tower, wipe bbox: min {%2%, %3%, %4%} - max {%5%, %6%, %7%}")
                %(plate_index+1) %start.x() % start.y() % start.z() %end.x() % end.y() % end.z();
    };
 
    auto translate_models = [translate_old, shrink_to_new_bed, old_printable_width, old_printable_depth, old_printable_height, current_printable_width, current_printable_depth, current_printable_height, shared_center_x, shared_center_y, current_exclude_area, &plate_obj_size_infos] (Slic3r::GUI::PartPlateList& plate_list, DynamicPrintConfig& print_config) {
        //BBS: translate old 3mf to correct positions
        if (translate_old) {
            //translate the objects
            int plate_count = plate_list.get_plate_count();
            for (int index = 1; index < plate_count; index ++) {
                Slic3r::GUI::PartPlate* cur_plate = (Slic3r::GUI::PartPlate *)plate_list.get_plate(index);
 
                Vec3d cur_origin = cur_plate->get_origin();
                Vec3d new_origin = plate_list.compute_origin_using_new_size(index, old_printable_width, old_printable_depth);
 
                cur_plate->translate_all_instance(new_origin - cur_origin);
            }
            BOOST_LOG_TRIVIAL(info) << boost::format("translate old 3mf, switch back to current bed size,{%1%, %2%, %3%}")%old_printable_width %old_printable_depth %old_printable_height;
            plate_list.reset_size(old_printable_width, old_printable_depth, old_printable_height, true, true);
        }
 
        if (shrink_to_new_bed > 0)
        {
            int plate_count = plate_list.get_plate_count();
            ConfigOptionFloats *wipe_x_option = nullptr, *wipe_y_option = nullptr;
            Vec3d wipe_offset;
            if (print_config.has("wipe_tower_x")) {
                wipe_x_option = dynamic_cast<ConfigOptionFloats *>(print_config.option("wipe_tower_x"));
                wipe_y_option = dynamic_cast<ConfigOptionFloats *>(print_config.option("wipe_tower_y"));
            }
            double exclude_width = 0.f, exclude_depth = 0.f;
 
            if (current_exclude_area.size() >= 4) {
                exclude_width = current_exclude_area[2].x() - current_exclude_area[0].x();
                exclude_depth = current_exclude_area[2].y() - current_exclude_area[0].y();
            }
            for (int index = 0; index < plate_count; index ++) {
                Slic3r::GUI::PartPlate* cur_plate = (Slic3r::GUI::PartPlate *)plate_list.get_plate(index);
                Vec3d cur_origin = cur_plate->get_origin();
                Vec3d new_origin = plate_list.compute_origin_using_new_size(index, current_printable_width, current_printable_depth);
                Vec3d offset;
 
 
                if (shrink_to_new_bed == 1) {
                    Vec3d cur_center_offset { ((double)old_printable_width)/2, ((double)old_printable_depth)/2, 0}, new_center_offset { ((double)current_printable_width)/2, ((double)current_printable_depth)/2, 0};
                    Vec3d cur_center = cur_origin + cur_center_offset;
                    Vec3d new_center = new_origin + new_center_offset;
 
                    offset  = new_center - cur_center;
 
                    if (index == 0)
                        wipe_offset = offset;
 
                    BOOST_LOG_TRIVIAL(info) << boost::format("shrink_to_new_bed 1, plate %1%, cur_origin: {%2%, %3%}, new_origin: {%4%, %5%}, cur_center {%6%, %7%} new_center {%8%, %9%}")
                        %(index+1) %cur_origin(0) %cur_origin(1) %new_origin(0) %new_origin(1)  %cur_center(0) %cur_center(1) %new_center(0) %new_center(1);
                }
                else {
                    //center the object
                    Vec3d new_center_offset { ((double)current_printable_width + exclude_width)/2, ((double)current_printable_depth + exclude_depth)/2, 0};
                    BoundingBoxf3& bbox = plate_obj_size_infos[index].obj_bbox;
                    Vec3d size = bbox.size();
                    if (shared_center_x != 0)
                        new_center_offset(0) = (double)shared_center_x;
                    else if (exclude_width > 0) {
                        if (size.x() > (current_printable_width - exclude_width))
                            new_center_offset(0) = ((double)current_printable_width)/2;
                    }
                    if (shared_center_y != 0)
                        new_center_offset(1) = (double)shared_center_y;
                    else if (exclude_depth > 0) {
                        if (size.y() > (current_printable_depth - exclude_depth))
                            new_center_offset(1) = ((double)current_printable_depth)/2;
                    }
                    Vec3d new_center = new_origin + new_center_offset;
 
                    offset  = new_center - bbox.center();
 
                    wipe_offset = offset + cur_origin - new_origin;
                    BOOST_LOG_TRIVIAL(info) << boost::format("shrink_to_new_bed 2, plate %1%, new_origin: {%2%, %3%}, new_center: {%4%, %5%}, obj bbox(including wipe tower) min {%6%, %7%} max {%8%, %9%}")
                        %(index+1) %new_origin(0) %new_origin(1)  %new_center(0) %new_center(1) %bbox.min(0) %bbox.min(1)  %bbox.max(0) %bbox.max(1);
                }
                offset(2) = 0.f;
                BOOST_LOG_TRIVIAL(info) << boost::format("shrink_to_new_bed %1%, plate %2% translate offset: {%3%, %4%} wipe_offset {%5%, %6%}") %shrink_to_new_bed %(index+1) %offset[0] %offset[1] %wipe_offset[0]  %wipe_offset[1];
                cur_plate->translate_all_instance(offset);
 
                if (wipe_x_option) {
                    BOOST_LOG_TRIVIAL(info) << boost::format("shrink_to_new_bed %4%, plate %1%: wipe tower src: {%2%, %3%}")%(index+1) %wipe_x_option->get_at(index) %wipe_y_option->get_at(index)%shrink_to_new_bed;
                    ConfigOptionFloat wipe_tower_x(wipe_x_option->get_at(index) + wipe_offset(0));
                    ConfigOptionFloat wipe_tower_y(wipe_y_option->get_at(index) + wipe_offset(1));
 
                    wipe_x_option->set_at(&wipe_tower_x, index, 0);
                    wipe_y_option->set_at(&wipe_tower_y, index, 0);
                    BOOST_LOG_TRIVIAL(info) << boost::format("shrink_to_new_bed %4%, plate %1% wipe tower changes to: {%2%, %3%}")%(index+1) %wipe_x_option->get_at(index) %wipe_y_option->get_at(index) %shrink_to_new_bed;
                }
 
 
            }
            BOOST_LOG_TRIVIAL(info) << boost::format("shrink_to_new_bed, shrink all the models to current bed size,{%1%, %2%, %3%}")%current_printable_width %current_printable_depth %current_printable_height;
            plate_list.reset_size(current_printable_width, current_printable_depth, current_printable_height, true, true);
        }
    };
    if (plate_data_src.size() > 0)
    {
        partplate_list.load_from_3mf_structure(plate_data_src);
 
        int plate_count = partplate_list.get_plate_count();
        plate_obj_size_infos.resize(plate_count, plate_obj_size_info_t());
        for (int index = 0; index < plate_count; index ++) {
            Slic3r::GUI::PartPlate* cur_plate = (Slic3r::GUI::PartPlate *)partplate_list.get_plate(index);
 
            check_plate_wipe_tower(cur_plate, index, m_print_config, plate_obj_size_infos[index]);
            BOOST_LOG_TRIVIAL(info) << boost::format("plate %1%,  has_wipe_tower %2%, wipe_x %3%, wipe_y %4%, width %5%, depth %6%")
                %(index+1) %plate_obj_size_infos[index].has_wipe_tower %plate_obj_size_infos[index].wipe_x %plate_obj_size_infos[index].wipe_y %plate_obj_size_infos[index].wipe_width %plate_obj_size_infos[index].wipe_depth;
        }
 
        translate_models(partplate_list, m_print_config);
    }
 
    /*for (ModelObject *model_object : m_models[0].objects)
        for (ModelInstance *model_instance : model_object->instances)
        {
            const Vec3d &instance_offset = model_instance->get_offset();
            BOOST_LOG_TRIVIAL(info) << boost::format("instance %1% transform {%2%,%3%,%4%} at %5%:%6%")% model_object->name % instance_offset.x() % instance_offset.y() %instance_offset.z() % __FUNCTION__ % __LINE__<< std::endl;
        }*/
 
    //doing downward_check
    std::vector<printer_plate_info_t> downward_check_printers;
    std::vector<bool> downward_check_status;
    if (downward_check) {
        bool use_default = false;
        std::string default_path;
        if (downward_settings.size() == 0) {
            //parse from internal
            std::string cli_config_file = resources_dir() + "/profiles/BBL/cli_config.json";
            load_downward_settings_list_from_config(cli_config_file, current_printer_system_name, current_printer_model, downward_settings);
            use_default = true;
            default_path = resources_dir() + "/profiles/BBL/machine_full/";
        }
        for (auto const &file : downward_settings) {
            DynamicPrintConfig  config;
            std::string config_type, config_name, filament_id, config_from, downward_printer;
            std::string file_path = use_default?(default_path+file+".json"):file;
            int ret = load_config_file(file_path, config, config_type, config_name, filament_id, config_from);
            if (ret) {
                record_exit_reson(outfile_dir, ret, 0, cli_errors[ret], sliced_info);
                flush_and_exit(ret);
            }
            if ((config_type != "machine") || (config_from != "system")) {
                BOOST_LOG_TRIVIAL(info) << boost::format("found invalid config type %1% or from %2% in file %3% when downward_check")%config_type %config_from %file_path;
                record_exit_reson(outfile_dir, ret, 0, cli_errors[CLI_CONFIG_FILE_ERROR], sliced_info);
                flush_and_exit(ret);
 
            }
            BOOST_LOG_TRIVIAL(info) << boost::format("downward_check: loaded machine config %1%, from %2%")%config_name %file_path ;
 
            printer_plate_info_t printer_plate;
            Pointfs temp_printable_area, temp_exclude_area, temp_wrapping_area;
            std::vector<Pointfs> temp_extruder_areas;
            std::vector<double> temp_extruder_print_heights;
 
            printer_plate.printer_name = config_name;
 
            temp_printable_area = config.option<ConfigOptionPoints>("printable_area", true)->values;
            temp_exclude_area = legacy_bed_exclude_area_points(config);
            temp_wrapping_area = config.option<ConfigOptionPoints>("wrapping_exclude_area", true)->values;
            temp_extruder_areas = config.option<ConfigOptionPointsGroups>("extruder_printable_area", true)->values;
            temp_extruder_print_heights = config.option<ConfigOptionFloatsNullable>("extruder_printable_height", true)->values;
 
            if (temp_printable_area.size() >= 4) {
                BoundingBoxf temp_printable_bbox(temp_printable_area);
                printer_plate.printable_width = static_cast<int>(temp_printable_bbox.size().x());
                printer_plate.printable_depth = static_cast<int>(temp_printable_bbox.size().y());
                if (config.option<ConfigOptionFloat>("printable_height"))
                    printer_plate.printable_height = (int)(config.opt_float("printable_height"));
            }
            if (temp_exclude_area.size() >= 4) {
                printer_plate.exclude_width = (int)(temp_exclude_area[2].x() - temp_exclude_area[0].x());
                printer_plate.exclude_depth = (int)(temp_exclude_area[2].y() - temp_exclude_area[0].y());
                printer_plate.exclude_x = (int)temp_exclude_area[0].x();
                printer_plate.exclude_y = (int)temp_exclude_area[0].y();
            }
            if (temp_wrapping_area.size() >= 4) {
                printer_plate.wrapping_width = (int)(temp_wrapping_area[2].x() - temp_wrapping_area[0].x());
                printer_plate.wrapping_depth = (int)(temp_wrapping_area[2].y() - temp_wrapping_area[0].y());
                printer_plate.wrapping_x = (int)temp_wrapping_area[0].x();
                printer_plate.wrapping_y = (int)temp_wrapping_area[0].y();
            }
            if ((temp_extruder_areas.size() > 0) && (temp_extruder_print_heights.size() == temp_extruder_areas.size())) {
                double temp_extruder_height = printer_plate.printable_height;
                BoundingBox current_bbox({0, 0}, {printer_plate.printable_width, printer_plate.printable_depth});
 
                for (unsigned int temp_index = 0; temp_index < temp_extruder_areas.size(); temp_index++)
                {
                    BoundingBox temp_bbox;
                    Pointfs& temp_extruder_shape = temp_extruder_areas[temp_index];
                    for (unsigned int temp_index2 = 0; temp_index2 < temp_extruder_shape.size(); temp_index2++)
                        temp_bbox.merge({temp_extruder_shape[temp_index2].x(), temp_extruder_shape[temp_index2].y()});
 
                    if (current_bbox.min.x() < temp_bbox.min.x())
                        current_bbox.min.x() = temp_bbox.min.x();
                    if (current_bbox.min.y() < temp_bbox.min.y())
                        current_bbox.min.y() = temp_bbox.min.y();
                    if (current_bbox.max.x() > temp_bbox.max.x())
                        current_bbox.max.x() = temp_bbox.max.x();
                    if (current_bbox.max.y() > temp_bbox.max.y())
                        current_bbox.max.y() = temp_bbox.max.y();
                    if (temp_extruder_height > temp_extruder_print_heights[temp_index])
                        temp_extruder_height = temp_extruder_print_heights[temp_index];
                }
                printer_plate.printable_width  = current_bbox.size().x();
                printer_plate.printable_depth  = current_bbox.size().y();
                printer_plate.printable_height = temp_extruder_height;
 
                BOOST_LOG_TRIVIAL(info) << boost::format("downward_check: for multi-extruder printer, change printable size to bbox {%1%, %2%, 0} - {%3%, %4%, %5%}")
                            %current_bbox.min.x() %current_bbox.min.y() %current_bbox.max.x() %current_bbox.max.y() %temp_extruder_height;
            }
            BOOST_LOG_TRIVIAL(info) << boost::format("downward_check: printable size{%1%,%2%, %3%}, exclude area{%4%, %5%: %6% x %7%}, wrapping area{%8%, %9%: %10% x %11%}, enable_wrapping_detect %12%")
                %printer_plate.printable_width %printer_plate.printable_depth %printer_plate.printable_height
                %printer_plate.exclude_x %printer_plate.exclude_y %printer_plate.exclude_width %printer_plate.exclude_depth
                %printer_plate.wrapping_x %printer_plate.wrapping_y %printer_plate.wrapping_width %printer_plate.wrapping_depth %enable_wrapping_detect;
 
            downward_check_printers.push_back(std::move(printer_plate));
        }
    }
 
    int downward_check_size = downward_check_printers.size();
    if (downward_check_size > 0)
    {
        downward_check_status.resize(downward_check_size, false);
        int plate_count = partplate_list.get_plate_count();
        int failed_count = 0;
        for (int index = 0; index < plate_count; index ++)
        {
            if (failed_count == downward_check_size) {
                BOOST_LOG_TRIVIAL(info) << boost::format("downward_check: all failed, size %1%")%downward_check_size;
                break;
            }
            Slic3r::GUI::PartPlate* cur_plate = (Slic3r::GUI::PartPlate *)partplate_list.get_plate(index);
            Vec3d size = plate_obj_size_infos[index].obj_bbox.size();
 
            for (int index2 = 0; index2 < downward_check_size; index2 ++)
            {
                if (failed_count == downward_check_size) {
                    break;
                }
                if (downward_check_status[index2])
                    continue;
                printer_plate_info_t& plate_info = downward_check_printers[index2];
                if ((size.z() > plate_info.printable_height) || (size.y() > plate_info.printable_depth) || (size.x() > plate_info.printable_width)) {
                    BOOST_LOG_TRIVIAL(info) << boost::format("plate %1%, downward_check index %2%, name %3%, bbox {%4%, %5%, %6%} exceeds printer size {%7%, %8%, %9%}")
                        %(index+1) %(index2+1) %plate_info.printer_name
                        %size.x() % size.y() % size.z() %plate_info.printable_width %plate_info.printable_depth %plate_info.printable_height;
                    downward_check_status[index2] = true;
                    failed_count ++;
                    continue;
                }
                if (plate_info.exclude_width > 0) {
                    int real_width = plate_info.printable_width - plate_info.exclude_width;
                    int real_depth = plate_info.printable_depth - plate_info.exclude_depth;
                    if ((size.x() > real_width) && (size.y() > real_depth)) {
                        BOOST_LOG_TRIVIAL(info) << boost::format("plate %1%, downward_check index %2%, name %3%, bbox {%4%, %5%} exceeds real size without exclude_area {%6%, %7%}")
                            %(index+1) %(index2+1) %plate_info.printer_name
                            %size.x() % size.y() %real_width %real_depth;
                        downward_check_status[index2] = true;
                        failed_count ++;
                        continue;
                    }
                }
                if (enable_wrapping_detect && plate_info.wrapping_width > 0) {
                    //int real_width = plate_info.printable_width - plate_info.wrapping_width;
                    int real_depth = plate_info.printable_depth - plate_info.wrapping_depth;
                    if ( size.y() > real_depth) {
                        BOOST_LOG_TRIVIAL(info) << boost::format("plate %1%, downward_check index %2%, name %3%, bbox {%4%, %5%} exceeds real size without wrapping_area {%6%, %7%}")
                            %(index+1) %(index2+1) %plate_info.printer_name
                            %size.x() % size.y() %plate_info.printable_width %real_depth;
                        downward_check_status[index2] = true;
                        failed_count ++;
                        continue;
                    }
                }
            }
        }
        if (failed_count < downward_check_size)
        {
            //has success ones
            BOOST_LOG_TRIVIAL(info) << boost::format("downward_check: downward_check_size %1%, failed_count %2%")%downward_check_size %failed_count;
            for (int index2 = 0; index2 < downward_check_size; index2 ++)
            {
                if (downward_check_status[index2])
                    continue;
                printer_plate_info_t& plate_info = downward_check_printers[index2];
                BOOST_LOG_TRIVIAL(info) << boost::format("downward_check: found compatible printer %1%")%plate_info.printer_name;
                downward_compatible_machines.push_back(plate_info.printer_name);
            }
            sliced_info.downward_machines = downward_compatible_machines;
        }
    }
 
    // Loop through transform options.
    bool user_center_specified = false;
    Points beds = get_bed_shape(m_print_config);
    ArrangeParams arrange_cfg;
 
    BOOST_LOG_TRIVIAL(info) << "will start transforms, commands count " << m_transforms.size() << "\n";
#if defined(__linux__) || defined(__LINUX__)
    if (g_cli_callback_mgr.is_started()) {
        PrintBase::SlicingStatus slicing_status{2, "Loading files finished"};
        cli_status_callback(slicing_status);
    }
#endif
 
    for (auto const &opt_key : m_transforms) {
        BOOST_LOG_TRIVIAL(info) << "process transform " << opt_key << "\n";
        if (opt_key == "assemble") {
            if (clone_objects.size() > 0) {
                BOOST_LOG_TRIVIAL(error) << "Invalid params: can not set assemble and clone_objects together." << std::endl;
                record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
                flush_and_exit(CLI_INVALID_PARAMS);
            }
            if (m_models.empty()) {
                boost::nowide::cerr << "Invalid params: --assemble needs at least one input model." << std::endl;
                record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
                flush_and_exit(CLI_INVALID_PARAMS);
            }
            Model m;
            ModelObject* new_object = m.add_object();
            new_object->name = _u8L("Assembly");
            new_object->add_instance();
            int idx = 0;
            for (auto& model : m_models)
                for (ModelObject* o : model.objects) {
                    for (auto volume : o->volumes) {
                        ModelVolume* new_volume = new_object->add_volume(*volume);
                        // set extruder id
                        new_volume->config.set_key_value("extruder", new ConfigOptionInt(o->config.extruder()));
                    }
                }
            m_models.clear();
            m_models.emplace_back(std::move(m));
        }
        else if (opt_key == "repetitions") {
            int repetitions_count = m_config.option<ConfigOptionInt>("repetitions")->value;
            if (repetitions_count <= 1)
            {
                BOOST_LOG_TRIVIAL(info) << "invalid repetitions value " << repetitions_count << ", just skip\n";
            }
            else {
                if (plate_to_slice == 0) {
                    BOOST_LOG_TRIVIAL(error) << "Invalid params: can not set repetitions when slice all." << std::endl;
                    record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
                    flush_and_exit(CLI_INVALID_PARAMS);
                }
                else if (plate_to_slice > partplate_list.get_plate_count()) {
                    BOOST_LOG_TRIVIAL(error) << boost::format("Invalid params:invalid plate %1% to slice, total %2%")%plate_to_slice %partplate_list.get_plate_count();
                    record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
                    flush_and_exit(CLI_INVALID_PARAMS);
                }
 
                BOOST_LOG_TRIVIAL(info) << "repetitions value " << repetitions_count << std::endl;
 
                duplicate_count = repetitions_count - 1;
            }
        }
        else if (opt_key == "convert_unit") {
            for (auto& model : m_models) {
                if (model.looks_like_saved_in_meters()) {
                    BOOST_LOG_TRIVIAL(info) << "convert from meter to millimeter\n";
                    model.convert_from_meters(true);
                }
                else if (model.looks_like_imperial_units()) {
                    BOOST_LOG_TRIVIAL(info) << "convert from inch to millimeter\n";
                    model.convert_from_imperial_units(true);
                }
            }
        }
        else if (opt_key == "orient") {
            //BBS: orient 0 means disable, 1 means force orient, others means auto
            int orient_option = m_config.option<ConfigOptionInt>("orient")->value;
 
            if (orient_option == 0)
            {
                //orients_requirement.clear();
                for (auto& model : m_models)
                    for (ModelObject* o : model.objects)
                    {
                        orients_requirement.insert(std::pair<size_t, bool>(o->id().id, false));
                        BOOST_LOG_TRIVIAL(info) << "object "<<o->name <<", id :"  << o->id().id << ", no need to orient when setting orient to 0\n";
                    }
            }
            else if (orient_option == 1)
            {
                //force orient
                //orients_requirement.clear();
                for (auto& model : m_models)
                    for (ModelObject* o : model.objects)
                    {
                        orients_requirement.insert(std::pair<size_t, bool>(o->id().id, true));
                        BOOST_LOG_TRIVIAL(info) << "object "<<o->name <<", id :"  << o->id().id << ", need to orient when setting orient to 1\n";
                    }
            }
            else
            {
                //auto arrange, keep the original logic
            }
            BOOST_LOG_TRIVIAL(info) << boost::format("orient_option %1%")%orient_option;
        }
        else if (opt_key == "copy") {
            for (auto &model : m_models) {
                const bool all_objects_have_instances = std::none_of(
                    model.objects.begin(), model.objects.end(),
                    [](ModelObject* o){ return o->instances.empty(); }
                );
 
                int dups = m_config.opt_int("copy");
                if (!all_objects_have_instances) model.add_default_instances();
 
                try {
                    if (dups > 1) {
                        // if all input objects have defined position(s) apply duplication to the whole model
                        duplicate(model, size_t(dups), beds, arrange_cfg);
                    } else {
                        arrange_objects(model, beds, arrange_cfg);
                    }
                } catch (std::exception &ex) {
                    boost::nowide::cerr << "error: " << ex.what() << std::endl;
                    record_exit_reson(outfile_dir, CLI_COPY_OBJECTS_ERROR, 0, cli_errors[CLI_COPY_OBJECTS_ERROR], sliced_info);
                    flush_and_exit(CLI_COPY_OBJECTS_ERROR);
                }
            }
        } else if (opt_key == "center") {
          user_center_specified = true;
            for (auto &model : m_models) {
                model.add_default_instances();
                // this affects instances:
                model.center_instances_around_point(m_config.option<ConfigOptionPoint>("center")->value);
                // this affects volumes:
                //FIXME Vojtech: Who knows why the complete model should be aligned with Z as a single rigid body?
                //model.align_to_ground();
                BoundingBoxf3 bbox;
                for (ModelObject *model_object : model.objects)
                    // We are interested into the Z span only, therefore it is sufficient to measure the bounding box of the 1st instance only.
                    bbox.merge(model_object->instance_bounding_box(0, false));
                for (ModelObject *model_object : model.objects)
                    for (ModelInstance *model_instance : model_object->instances)
                        model_instance->set_offset(Z, model_instance->get_offset(Z) - bbox.min.z());
            }
        } else if (opt_key == "align_xy") {
            const Vec2d &p = m_config.option<ConfigOptionPoint>("align_xy")->value;
            for (auto &model : m_models) {
                BoundingBoxf3 bb = model.bounding_box_exact();
                // this affects volumes:
                model.translate(-(bb.min.x() - p.x()), -(bb.min.y() - p.y()), -bb.min.z());
            }
        } else if (opt_key == "arrange") {
            //BBS: arrange 0 means disable, 1 means force arrange, others means auto
            int arrange_option = m_config.option<ConfigOptionInt>("arrange")->value;
 
            if (arrange_option == 0)
            {
                need_arrange = false;
            }
            else if (arrange_option == 1)
            {
                need_arrange = true;
            }
            else
            {
                //auto arrange, keep the original logic
            }
        } else if (opt_key == "ensure_on_bed") {
            // do nothing, the value is used later
        } else if (opt_key == "rotate") {
            for (auto &model : m_models)
                for (auto &o : model.objects)
                    // this affects volumes:
                    o->rotate(Geometry::deg2rad(m_config.opt_float(opt_key)), Z);
        } else if (opt_key == "rotate_x") {
            for (auto &model : m_models)
                for (auto &o : model.objects)
                    // this affects volumes:
                    o->rotate(Geometry::deg2rad(m_config.opt_float(opt_key)), X);
        } else if (opt_key == "rotate_y") {
            for (auto &model : m_models)
                for (auto &o : model.objects)
                    // this affects volumes:
                    o->rotate(Geometry::deg2rad(m_config.opt_float(opt_key)), Y);
        } else if (opt_key == "ground_largest_face" || opt_key == "ground_face_normal" || opt_key == "ground_face_point") {
            // Each instance is laid on one of its lay-on-face planes, which are computed from the current part
            // transformations, so the rotations given before this option are respected. A direction or point is in
            // object coordinates, so it names the same face for every instance of an object.
            std::function<int(const std::vector<LayOnFacePlane>&, const Transform3d&)> pick;
            if (opt_key == "ground_largest_face") {
                if (m_config.opt_bool(opt_key))
                    pick = [](const std::vector<LayOnFacePlane>& planes, const Transform3d&) { return find_largest_plane(planes); };
            } else {
                // Only options given on the command line reach this loop, so an empty value is malformed input too.
                const std::string& value = m_config.opt_string(opt_key);
                Vec3d v;
                int   consumed = 0;
                if (sscanf(value.c_str(), "%lf,%lf,%lf%n", &v.x(), &v.y(), &v.z(), &consumed) != 3 || consumed != int(value.size()) ||
                    !v.allFinite() || (opt_key == "ground_face_normal" && v.norm() < EPSILON)) {
                    BOOST_LOG_TRIVIAL(error) << boost::format("Invalid params: %1% expects three comma-separated numbers, got \"%2%\"") % opt_key % value;
                    record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
                    flush_and_exit(CLI_INVALID_PARAMS);
                }
                if (opt_key == "ground_face_normal")
                    pick = [v](const std::vector<LayOnFacePlane>& planes, const Transform3d&) { return find_plane_by_normal(planes, v); };
                else
                    pick = [v](const std::vector<LayOnFacePlane>& planes, const Transform3d& inst_matrix) {
                        return find_plane_at_point(planes, inst_matrix, v, 0.01);
                    };
            }
            if (pick) {
                size_t laid = 0, missed = 0;
                for (auto& model : m_models) {
                    model.add_default_instances();
                    for (ModelObject* o : model.objects)
                        for (size_t i = 0; i < o->instances.size(); ++i) {
                            const Transform3d                 inst_matrix = o->instances[i]->get_matrix_no_offset();
                            const std::vector<LayOnFacePlane> planes      = lay_on_face_planes(*o, inst_matrix);
                            if (planes.empty()) {
                                // Small or smooth parts (e.g. a sphere) have no face to rest on; the gizmo offers none either.
                                BOOST_LOG_TRIVIAL(warning) << boost::format("%1%: object %2% has no face large enough to lay on, left as it is") % opt_key % o->name;
                                continue;
                            }
                            const int idx = pick(planes, inst_matrix);
                            if (idx < 0) {
                                // Only a point can miss: with several objects it usually belongs to one of them.
                                BOOST_LOG_TRIVIAL(warning) << boost::format("%1%: no face of object %2% contains the point, left as it is") % opt_key % o->name;
                                ++missed;
                                continue;
                            }
                            BOOST_LOG_TRIVIAL(info) << boost::format("%1%: object %2% instance %3% laid on the %4% mm2 face with normal %5%")
                                                        % opt_key % o->name % i % planes[idx].area % planes[idx].normal.transpose();
                            lay_on_face(*o, i, planes[idx].normal);
                            ++laid;
                        }
                }
                if (laid == 0 && missed > 0) {
                    BOOST_LOG_TRIVIAL(error) << boost::format("Invalid params: %1%: no face of any object contains the point") % opt_key;
                    record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
                    flush_and_exit(CLI_INVALID_PARAMS);
                }
            }
        } else if (opt_key == "scale") {
            float ratio = m_config.opt_float(opt_key);
            if (ratio <= 0.f) {
                BOOST_LOG_TRIVIAL(error) << boost::format("Invalid params:invalid scale ratio %1%")%ratio;
                record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
                flush_and_exit(CLI_INVALID_PARAMS);
            }
            for (auto &model : m_models)
                for (auto &o : model.objects)
                    // this affects volumes:
                    o->scale(ratio);
        } else if (opt_key == "scale_to_fit") {
            const Vec3d &opt = m_config.opt<ConfigOptionPoint3>(opt_key)->value;
            if (opt.x() <= 0 || opt.y() <= 0 || opt.z() <= 0) {
                boost::nowide::cerr << "--scale-to-fit requires a positive volume" << std::endl;
                record_exit_reson(outfile_dir, CLI_SCALE_TO_FIT_ERROR, 0, cli_errors[CLI_SCALE_TO_FIT_ERROR], sliced_info);
                flush_and_exit(CLI_SCALE_TO_FIT_ERROR);
            }
            for (auto &model : m_models)
                for (auto &o : model.objects)
                    // this affects volumes:
                    o->scale_to_fit(opt);
        } else if (opt_key == "cut" || opt_key == "cut_x" || opt_key == "cut_y") {
            boost::nowide::cerr << "Cut operation is not supported yet" << std::endl;
            return CLI_INVALID_PARAMS;
 
            //             std::vector<Model> new_models;
            //             for (auto &model : m_models) {
            //                 model.translate(0, 0, -model.bounding_box().min.z());  // align to z = 0
            //                 size_t num_objects = model.objects.size();
            //                 for (size_t i = 0; i < num_objects; ++ i) {
 
            // #if 0
            //                     if (opt_key == "cut_x") {
            //                         o->cut(X, m_config.opt_float("cut_x"), &out);
            //                     } else if (opt_key == "cut_y") {
            //                         o->cut(Y, m_config.opt_float("cut_y"), &out);
            //                     } else if (opt_key == "cut") {
            //                         o->cut(Z, m_config.opt_float("cut"), &out);
            //                     }
            // #else
            //                     ModelObject* object = model.objects.front();
            //                     const BoundingBoxf3& box = object->bounding_box();
            //                     const float Margin = 20.0;
            //                     const float max_x = box.size()(0) / 2.0 + Margin;
            //                     const float min_x = -max_x;
            //                     const float max_y = box.size()(1) / 2.0 + Margin;
            //                     const float min_y = -max_y;
 
            //                     std::array<Vec3d, 4> plane_points;
            //                     plane_points[0] = { min_x, min_y, 0 };
            //                     plane_points[1] = { max_x, min_y, 0 };
            //                     plane_points[2] = { max_x, max_y, 0 };
            //                     plane_points[3] = { min_x, max_y, 0 };
            //                     for (Vec3d& point : plane_points) {
            //                         point += box.center();
            //                     }
            //                     model.objects.front()->cut(0, plane_points, ModelObjectCutAttribute::KeepUpper |
            //                     ModelObjectCutAttribute::KeepLower);
            // #endif
            //                     model.delete_object(size_t(0));
            //                 }
            //             }
 
            //             // TODO: copy less stuff around using pointers
            //             m_models = new_models;
 
            //             if (m_actions.empty())
            //                 m_actions.push_back("export_stl");
        }
#if 0
        else if (opt_key == "cut_grid") {
            std::vector<Model> new_models;
            for (auto &model : m_models) {
                TriangleMesh mesh = model.mesh();
                mesh.repair();
 
                std::vector<TriangleMesh> meshes = mesh.cut_by_grid(m_config.option<ConfigOptionPoint>("cut_grid")->value);
                size_t i = 0;
                for (TriangleMesh* m : meshes) {
                    Model out;
                    auto o = out.add_object();
                    o->add_volume(*m);
                    o->input_file += "_" + std::to_string(i++);
                    delete m;
                }
            }
 
            // TODO: copy less stuff around using pointers
            m_models = new_models;
 
            if (m_actions.empty())
                m_actions.push_back("export_stl");
        }
#endif
        else if (opt_key == "split") {
            for (Model &model : m_models) {
                size_t num_objects = model.objects.size();
                for (size_t i = 0; i < num_objects; ++ i) {
                    ModelObjectPtrs new_objects;
                    model.objects.front()->split(&new_objects, false); // TODO: add cli option to enable this?
                    model.delete_object(size_t(0));
                }
            }
        } else if (opt_key == "repair") {
            if (m_config.opt_bool(opt_key))
                for (Model &model : m_models)
                    for (ModelObject *object : model.objects) {
                        for (ModelVolume *volume : object->volumes) {
                            MeshRepairStats stats;
                            std::string     error;
                            if (!volume->repair(true, &stats, &error))
                                BOOST_LOG_TRIVIAL(warning) << "repair of " << object->name << " / " << volume->name << " failed: " << error;
                            else if (stats.modified)
                                BOOST_LOG_TRIVIAL(info) << "repaired " << object->name << " / " << volume->name;
                        }
                        object->invalidate_bounding_box();
                    }
        } else {
            boost::nowide::cerr << "error: option not implemented yet: " << opt_key << std::endl;
            record_exit_reson(outfile_dir, CLI_UNSUPPORTED_OPERATION, 0, cli_errors[CLI_UNSUPPORTED_OPERATION], sliced_info);
            flush_and_exit(CLI_UNSUPPORTED_OPERATION);
        }
    }
 
    BOOST_LOG_TRIVIAL(info) << "finished model pre-process commands\n";
    bool oriented_or_arranged = false;
    bool arranged_without_rotations = false;
    //BBS: add orient and arrange logic here
    for (auto& model : m_models)
    {
        for (ModelObject* o : model.objects)
        {
            if (orients_requirement[o->id().id])
            {
                BOOST_LOG_TRIVIAL(info) << "Before process command, Orient object, name=" << o->name <<",id="<<o->id().id<<std::endl;
                orientation::orient(o);
                oriented_or_arranged = true;
            }
            else
            {
                BOOST_LOG_TRIVIAL(debug) << "Before process command, no need to orient, object id :" << o->id().id<<std::endl;
            }
        }
    }
    //BBS: clear the orient objects lists
    orients_requirement.clear();
 
    bool is_seq_print_for_curr_plate = false;
    if ((plate_to_slice < 0) || (plate_to_slice > partplate_list.get_plate_count()))
    {
        BOOST_LOG_TRIVIAL(error) << boost::format("invalid plate id %1%, total %2%")%plate_to_slice %partplate_list.get_plate_count();
        record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
        flush_and_exit(CLI_INVALID_PARAMS);
    }
    else if (plate_to_slice > 0){
        Slic3r::GUI::PartPlate* cur_plate = (Slic3r::GUI::PartPlate *)partplate_list.get_plate(plate_to_slice-1);
        PrintSequence curr_plate_seq = cur_plate->get_print_seq();
 
        if (curr_plate_seq == PrintSequence::ByDefault) {
            auto seq_print  = m_print_config.option<ConfigOptionEnum<PrintSequence>>("print_sequence");
            if (seq_print && (seq_print->value == PrintSequence::ByObject)) {
                BOOST_LOG_TRIVIAL(info) << boost::format("Check whether need to arrange by print_sequence: plate %1% print by object, set from global")%plate_to_slice;
                is_seq_print_for_curr_plate = true;
            }
        }
        else if (curr_plate_seq == PrintSequence::ByObject) {
            BOOST_LOG_TRIVIAL(info) << boost::format("Check whether need to arrange by print_sequence: plate %1% print by object, set from plate self")%plate_to_slice;
            is_seq_print_for_curr_plate = true;
        }
 
        if (duplicate_count > 0) {
            const ConfigOptionBool* spiral_vase = m_print_config.option<ConfigOptionBool>("spiral_mode");
            if ((spiral_vase != nullptr) && spiral_vase->value)
            {
                //spiral mode can only be duplicated with by-object
                if (!is_seq_print_for_curr_plate) {
                    BOOST_LOG_TRIVIAL(warning) << boost::format("Spiral mode can not be duplicated under by-object print, skip duplicate");
                    duplicate_count = 0;
                }
            }
        }
 
        if (duplicate_count > 0)
            need_arrange = true;
    }
 
    if ((!need_arrange) && is_bbl_3mf && !shrink_to_new_bed && (plate_to_slice > 0))
    {
        if (((old_height_to_rod != 0.f) && (old_height_to_rod != height_to_rod))
            || ((old_height_to_lid != 0.f) && (old_height_to_lid != height_to_lid))
            || ((old_max_radius != 0.f) && (old_max_radius != clearance_radius)))
        {
            if (is_seq_print_for_curr_plate) {
                need_arrange = true;
                BOOST_LOG_TRIVIAL(info) << boost::format("old_height_to_rod %1%, old_height_to_lid %2%,  old_max_radius %3%, current height_to_rod %4%, height_to_lid %5%, clearance_radius %6%, need arrange!")
                    %old_height_to_rod %old_height_to_lid %old_max_radius %height_to_rod %height_to_lid %clearance_radius;
            }
        }
    }
 
    oriented_or_arranged |= need_arrange;
 
    BOOST_LOG_TRIVIAL(info) << boost::format("before arrange, need_arrange=%1%, duplicate_count %2%, filament_color_changed %3%")%need_arrange %duplicate_count %filament_color_changed;
    if (need_arrange || filament_color_changed)
    {
        for (int index = 0; index < partplate_list.get_plate_count(); index ++)
        {
            if ((plate_to_slice != 0) && (plate_to_slice != (index + 1))) {
                continue;
            }
 
            if (plate_data_src.size() > index) {
                if (!plate_data_src[index]->thumbnail_file.empty()) {
                    BOOST_LOG_TRIVIAL(info) << boost::format("Plate %1%: clear loaded thumbnail %2%.")%(index+1)%plate_data_src[index]->thumbnail_file;
                    plate_data_src[index]->thumbnail_file.clear();
                }
                if (!plate_data_src[index]->no_light_thumbnail_file.empty()) {
                    BOOST_LOG_TRIVIAL(info) << boost::format("Plate %1%: clear loaded no_light_thumbnail %2%.")%(index+1)%plate_data_src[index]->no_light_thumbnail_file;
                    plate_data_src[index]->no_light_thumbnail_file.clear();
                }
                if (!plate_data_src[index]->top_file.empty()) {
                    BOOST_LOG_TRIVIAL(info) << boost::format("Plate %1%: clear loaded top_thumbnail %2%.")%(index+1)%plate_data_src[index]->top_file;
                    plate_data_src[index]->top_file.clear();
                }
                if (!plate_data_src[index]->pick_file.empty()) {
                    BOOST_LOG_TRIVIAL(info) << boost::format("Plate %1%: clear loaded pick_thumbnail %2%.")%(index+1)%plate_data_src[index]->pick_file;
                    plate_data_src[index]->pick_file.clear();
                }
            }
        }
    }
 
    if (!assemble_plate_info_list.empty())
    {
        //need to arrange for assemble cases
        int plate_count = assemble_plate_info_list.size();
        if (plate_count != partplate_list.get_plate_count())
        {
            BOOST_LOG_TRIVIAL(error) << boost::format("mismatch plate count, to_assemble %1%, generated %2%") % plate_count % partplate_list.get_plate_count();
            record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
            flush_and_exit(CLI_INVALID_PARAMS);
        }
 
        for (size_t i = 0; i < plate_count; i++)
        {
            Slic3r::GUI::PartPlate* cur_plate = (Slic3r::GUI::PartPlate*)partplate_list.get_plate(i);
            //lock those plates no need to arrange
            if (!assemble_plate_info_list[i].need_arrange)
                cur_plate->lock(true);
        }
 
        for (size_t i = 0; i < plate_count; i++)
        {
            assemble_plate_info_t& assemble_plate = assemble_plate_info_list[i];
            Slic3r::GUI::PartPlate* cur_plate = (Slic3r::GUI::PartPlate*)partplate_list.get_plate(i);
            BOOST_LOG_TRIVIAL(info) << boost::format("plate %1%, need arrange %2%, filaments_count %3%") % (i+1) % assemble_plate.need_arrange % assemble_plate.filaments_count;
            if (assemble_plate.need_arrange)
            {
                //do arrange for plate
                ArrangePolygons selected, unselected;
                Model& model = m_models[0];
                arrange_cfg = ArrangeParams();  // reset all params
                get_print_sequence(cur_plate, m_print_config, arrange_cfg.is_seq_print);
 
                //Step-1: prepare the arranged data
                partplate_list.lock_plate(i, false);
                partplate_list.select_plate(i);
                BOOST_LOG_TRIVIAL(info) << boost::format("plate %1% set to selected") % i;
                size_t plate_obj_count = assemble_plate.loaded_obj_list.size();
                for (size_t oidx = 0; oidx < plate_obj_count; ++oidx)
                {
                    ModelObject* mo = assemble_plate.loaded_obj_list[oidx];
 
                    for (size_t inst_idx = 0; inst_idx < mo->instances.size(); ++inst_idx)
                    {
                        ModelInstance* minst = mo->instances[inst_idx];
                        ArrangePolygon   ap = get_instance_arrange_poly(minst, m_print_config);
                        ap.itemid = selected.size();
                        selected.emplace_back(std::move(ap));
                        BOOST_LOG_TRIVIAL(debug) << boost::format("plate %1%: add object %2%  object index %3%, into selected") % (i+1) % ap.name %(oidx+1);
                    }
                }
 
                if (!is_belt_printer && ((!arrange_cfg.is_seq_print && (assemble_plate.filaments_count > 1)) || (enable_wrapping_detect && !current_wrapping_exclude_area.empty())))
                {
                    //prepare the wipe tower
                    int plate_count = partplate_list.get_plate_count();
 
                    auto printer_structure_opt = m_print_config.option<ConfigOptionEnum<PrinterStructure>>("printer_structure");
                    // This margin only pre-adjusts the default away from the near edges;
                    // estimate_wipe_tower_polygon below computes the real clamped position.
                    float tower_brim_width = m_print_config.option<ConfigOptionFloat>("prime_tower_brim_width", true)->value;
                    if (tower_brim_width < 0.f) tower_brim_width = 8.f; // auto: object heights unknown here, 8 mm is the auto cap
                    const float tower_margin = WIPE_TOWER_MARGIN + tower_brim_width;
 
                    // set the default position, the same with print config(left top)
                    float x = WIPE_TOWER_DEFAULT_X_POS;
                    float y = WIPE_TOWER_DEFAULT_Y_POS;
                    if (printer_structure_opt && printer_structure_opt->value == PrinterStructure::psI3) {
                        x = I3_WIPE_TOWER_DEFAULT_X_POS;
                        y = I3_WIPE_TOWER_DEFAULT_Y_POS;
                    }
                    if (x < tower_margin) {
                        x = tower_margin;
                    }
                    if (y < tower_margin) {
                        y = tower_margin;
                    }
 
                    //create the options using default if necessary
                    ConfigOptionFloats* wipe_x_option = m_print_config.option<ConfigOptionFloats>("wipe_tower_x", true);
                    ConfigOptionFloats* wipe_y_option = m_print_config.option<ConfigOptionFloats>("wipe_tower_y", true);
                    ConfigOptionFloat* width_option = m_print_config.option<ConfigOptionFloat>("prime_tower_width", true);
                    ConfigOptionFloat* rotation_angle_option = m_print_config.option<ConfigOptionFloat>("wipe_tower_rotation_angle", true);
                    ConfigOptionFloat* volume_option = m_print_config.option<ConfigOptionFloat>("prime_volume", true);
                    ConfigOptionEnum<WipeTowerWallType> *prime_tower_rib_wall_option = m_print_config.option<ConfigOptionEnum<WipeTowerWallType>>("wipe_tower_wall_type", true);
 
                    BOOST_LOG_TRIVIAL(info) << boost::format("prime_tower_width %1% wipe_tower_rotation_angle %2% prime_volume %3%, rib_wall %4%") % width_option->value % rotation_angle_option->value % volume_option->value %prime_tower_rib_wall_option->value;
 
                    ConfigOptionFloat wt_x_opt(x);
                    ConfigOptionFloat wt_y_opt(y);
 
                    wipe_x_option->set_at(&wt_x_opt, i, 0);
                    wipe_y_option->set_at(&wt_y_opt, i, 0);
 
                    Vec3d wipe_tower_size, wipe_tower_pos;
                    ArrangePolygon wipe_tower_ap = cur_plate->estimate_wipe_tower_polygon(m_print_config, i, wipe_tower_pos, wipe_tower_size, assemble_plate.filaments_count, true);
 
                    //update the new wp position
                    wt_x_opt.value = wipe_tower_pos(0);
                    wt_y_opt.value = wipe_tower_pos(1);
                    BOOST_LOG_TRIVIAL(info) << boost::format("%1%, after estimate_wipe_tower_polygon pos {%2%, %3%}, size {%4%, %5%}")%__LINE__ % wipe_tower_pos(0) % wipe_tower_pos(1) % wipe_tower_size(0) %wipe_tower_size(1);
 
                    wipe_x_option->set_at(&wt_x_opt, i, 0);
                    wipe_y_option->set_at(&wt_y_opt, i, 0);
 
                    wipe_tower_ap.bed_idx = i;
                    unselected.emplace_back(wipe_tower_ap);
                }
 
                // add the virtual object into unselect list if has
                partplate_list.preprocess_exclude_areas(unselected, m_print_config, enable_wrapping_detect, i + 1);
                if (avoid_extrusion_cali_region)
                    partplate_list.preprocess_nonprefered_areas(unselected, i + 1);
 
                //Step-2:prepare the arrange params
                arrange_cfg.allow_rotations = allow_rotations;
                arrange_cfg.allow_multi_materials_on_same_plate = allow_multicolor_oneplate;
                arrange_cfg.avoid_extrusion_cali_region = avoid_extrusion_cali_region;
                arrange_cfg.clearance_height_to_rod = height_to_rod;
                arrange_cfg.clearance_height_to_lid = height_to_lid;
                arrange_cfg.clearance_radius = clearance_radius;
                arrange_cfg.nozzle_height = nozzle_height;
                arrange_cfg.align_center = align_center;
                arrange_cfg.printable_height = print_height;
                arrange_cfg.min_obj_distance = 0;
                if (arrange_cfg.is_seq_print) {
                    arrange_cfg.bed_shrink_x = BED_SHRINK_SEQ_PRINT;
                    arrange_cfg.bed_shrink_y = BED_SHRINK_SEQ_PRINT;
                }
                if (align_to_y_axis.has_value()) {
                    arrange_cfg.align_to_y_axis = *align_to_y_axis;
                } else if (auto printer_structure_opt = m_print_config.option<ConfigOptionEnum<PrinterStructure>>("printer_structure")) {
                    arrange_cfg.align_to_y_axis = (printer_structure_opt->value == PrinterStructure::psI3);
                }
 
                arrangement::update_arrange_params(arrange_cfg, &m_print_config, selected);
                arrangement::update_selected_items_inflation(selected, &m_print_config, arrange_cfg);
                arrangement::update_unselected_items_inflation(unselected, &m_print_config, arrange_cfg);
                arrangement::update_selected_items_axis_align(selected, &m_print_config, arrange_cfg);
 
                beds = get_shrink_bedpts(&m_print_config, arrange_cfg);
 
                partplate_list.preprocess_exclude_areas(
                    arrange_cfg.excluded_regions, m_print_config, enable_wrapping_detect, 1, scale_(1));
 
                {
                    BOOST_LOG_TRIVIAL(debug) << "arrange bedpts:" << beds[0].transpose() << ", " << beds[1].transpose() << ", " << beds[2].transpose() << ", " << beds[3].transpose();
                    BOOST_LOG_TRIVIAL(info) << "Arrange full params: " << arrange_cfg.to_json();
                    BOOST_LOG_TRIVIAL(info) << boost::format("arrange: items selected before arranging: %1%") % selected.size();
                    for (auto item : selected)
                        BOOST_LOG_TRIVIAL(trace) << item.name << ", extruder: " << item.extrude_ids.back() << ", bed: " << item.bed_idx
                        << ", trans: " << item.translation.transpose();
                    BOOST_LOG_TRIVIAL(info) << boost::format("arrange: items unselected before arranging: %1%") % unselected.size();
                    for (auto item : unselected)
                        BOOST_LOG_TRIVIAL(trace) << item.name << ", bed: " << item.bed_idx << ", trans: " << item.translation.transpose();
                }
                arrange_cfg.progressind = [](unsigned st, std::string str = "") {
                    //boost::nowide::cout << "st=" << st << ", " << str << std::endl;
                };
 
                //Step-3:do the arrange
                BOOST_LOG_TRIVIAL(info) << boost::format("start plate %1%'s arranging...") % (i + 1);
                arrangement::arrange(selected, unselected, beds, arrange_cfg);
                //arrangement::arrange(unprintable, {}, beds, arrange_cfg);
                arranged_without_rotations |= !arrange_cfg.allow_rotations;
                BOOST_LOG_TRIVIAL(info) << boost::format("finished plate %1%'s arranging") % (i + 1);
 
                //step-4: postprocess the bed index and result
                partplate_list.clear(false, false, true, i);
 
                for (ArrangePolygon& ap : selected) {
                    partplate_list.postprocess_bed_index_for_current_plate(ap);
                    if (ap.bed_idx != i)
                    {
                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(":arrange failed: ap.name %1% ap.bed_idx %2%, plate index %3%") % ap.name % ap.bed_idx % i;
                        record_exit_reson(outfile_dir, CLI_OBJECT_ARRANGE_FAILED, 0, cli_errors[CLI_OBJECT_ARRANGE_FAILED], sliced_info);
                        flush_and_exit(CLI_OBJECT_ARRANGE_FAILED);
                    }
                }
 
                // Apply the arrange result to all selected objects
                for (ArrangePolygon& ap : selected) {
                    //BBS: partplate postprocess
                    partplate_list.postprocess_arrange_polygon(ap, true);
 
                    ap.apply();
                }
                //lock here
                cur_plate->lock(true);
            }
            else {
                size_t plate_obj_count = assemble_plate.loaded_obj_list.size();
                Vec3d plate_origin = cur_plate->get_origin();
 
                for (size_t oidx = 0; oidx < plate_obj_count; ++oidx)
                {
                    ModelObject* mo = assemble_plate.loaded_obj_list[oidx];
 
                    mo->translate_instances(plate_origin);
 
                    BOOST_LOG_TRIVIAL(debug) << boost::format("plate %1%: no arrange, directly translate object %2%  by {%3%, %4%}") % (i+1) % mo->name %plate_origin(0) %plate_origin(1);
                }
 
                bool is_seq_print = false;
                get_print_sequence(cur_plate, m_print_config, is_seq_print);
 
                if (!is_belt_printer && !is_seq_print && (assemble_plate.filaments_count > 1) && !has_wipe_tower_position)
                {
                    //prepare the wipe tower
                    auto printer_structure_opt = m_print_config.option<ConfigOptionEnum<PrinterStructure>>("printer_structure");
                    // set the default position, the same with print config(left top)
                    float x = WIPE_TOWER_DEFAULT_X_POS;
                    float y = WIPE_TOWER_DEFAULT_Y_POS;
                    if (printer_structure_opt && printer_structure_opt->value == PrinterStructure::psI3) {
                        x = I3_WIPE_TOWER_DEFAULT_X_POS;
                        y = I3_WIPE_TOWER_DEFAULT_Y_POS;
                    }
                    if (x < WIPE_TOWER_MARGIN) {
                        x = WIPE_TOWER_MARGIN;
                    }
                    if (y < WIPE_TOWER_MARGIN) {
                        y = WIPE_TOWER_MARGIN;
                    }
 
                    //create the options using default if necessary
                    ConfigOptionFloats* wipe_x_option = m_print_config.option<ConfigOptionFloats>("wipe_tower_x", true);
                    ConfigOptionFloats* wipe_y_option = m_print_config.option<ConfigOptionFloats>("wipe_tower_y", true);
                    ConfigOptionFloat wt_x_opt(x);
                    ConfigOptionFloat wt_y_opt(y);
 
                    wipe_x_option->set_at(&wt_x_opt, i, 0);
                    wipe_y_option->set_at(&wt_y_opt, i, 0);
                }
            }
        }
 
        for (size_t i = 0; i < plate_count; i++)
        {
            //unlock all the plates
            Slic3r::GUI::PartPlate* cur_plate = (Slic3r::GUI::PartPlate*)partplate_list.get_plate(i);
            cur_plate->lock(false);
        }
 
        partplate_list.reload_all_objects(false, -1);
    }
    else if (need_arrange)
    {
        ArrangePolygons selected, unselected, unprintable, locked_aps;
 
        //for (Model &model : m_models)
        if (m_models.size() > 0)
        {
            Model &model = m_models[0];
            Model original_model;
            std::set<std::pair<int, int>> backup_set;
            bool finished_arrange = false, first_run = true;
            Slic3r::GUI::PartPlate* cur_plate = nullptr;
            int low_duplicate_count = 0, up_duplicate_count = duplicate_count, arrange_count = 0;
            float orig_wipe_x = 0.f, orig_wipe_y = 0.f;
 
            if (duplicate_count > 0) {
                original_model = model;
            }
 
            while(!finished_arrange)
            {
                arrange_cfg = ArrangeParams();  // reset all params
                arrange_count++;
                //step-0: duplicate model
                if (duplicate_count > 0)
                {
                    //copy model objects and instances on plate
                    if (!first_run) {
                        BOOST_LOG_TRIVIAL(info) << boost::format("restore model object and plate, new duplicate_count %1%, arrange_count=%2%")%duplicate_count%arrange_count;
                        beds = get_bed_shape(m_print_config);
                        model.clear_objects();
                        model.clear_materials();
                        model = original_model;
                        partplate_list.load_from_3mf_structure(plate_data_src);
 
                        selected.clear();
                        unselected.clear();
                        unprintable.clear();
                        locked_aps.clear();
                    }
                    else {
                        first_run = false;
                        if (plate_to_slice > 0) {
                            ConfigOptionFloats* wipe_x_option = m_print_config.option<ConfigOptionFloats>("wipe_tower_x");
                            ConfigOptionFloats* wipe_y_option = m_print_config.option<ConfigOptionFloats>("wipe_tower_y");
 
                            if (wipe_x_option && (wipe_x_option->size() > (plate_to_slice-1))) {
                                orig_wipe_x = wipe_x_option->get_at(plate_to_slice-1);
                                BOOST_LOG_TRIVIAL(info) << boost::format("%1%, plate_to_slice %2%, orig_wipe_x=%3%")%__LINE__%plate_to_slice%orig_wipe_x;
                            }
                            if (wipe_y_option && (wipe_y_option->size() > (plate_to_slice-1))) {
                                orig_wipe_y = wipe_y_option->get_at(plate_to_slice-1);
                                BOOST_LOG_TRIVIAL(info) << boost::format("%1%, plate_to_slice %2%, orig_wipe_y=%3%")%__LINE__%plate_to_slice%orig_wipe_y;
                            }
                        }
                    }
 
                    cur_plate = (Slic3r::GUI::PartPlate *)partplate_list.get_plate(plate_to_slice-1);
                    cur_plate->duplicate_all_instance(duplicate_count, need_skip, skip_maps);
                }
                else if (plate_to_slice > 0)
                {
                    cur_plate = (Slic3r::GUI::PartPlate *)partplate_list.get_plate(plate_to_slice-1);
                }
 
                if (cur_plate) {
                    get_print_sequence(cur_plate, m_print_config, arrange_cfg.is_seq_print);
                }
 
                //Step-1: prepare arrange polygons
                if ((duplicate_count == 0) && (plate_to_slice == 0))
                {
                    //global arrange
                    for (size_t oidx = 0; oidx < model.objects.size(); ++oidx)
                    {
                        ModelObject* mo = model.objects[oidx];
                        for (size_t inst_idx = 0; inst_idx < mo->instances.size(); ++inst_idx)
                        {
                            ModelInstance* minst = mo->instances[inst_idx];
                            ArrangePolygon ap = get_instance_arrange_poly(minst, m_print_config);
 
                            //preprocess by partplate list
                            //remove the locked plate's instances, neither in selected, nor in un-selected
                            bool locked = partplate_list.preprocess_arrange_polygon(oidx, inst_idx, ap, true);
                            if (!locked)
                            {
                                ap.itemid = selected.size();
                                if (minst->printable)
                                    selected.emplace_back(ap);
                                else
                                    unprintable.emplace_back(ap);
                            }
                            else
                            {
                                //skip this object due to be locked in plate
                                ap.itemid = locked_aps.size();
                                locked_aps.emplace_back(ap);
                                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": skip locked instance, obj_id %1%, instance_id %2%") % oidx % inst_idx;
                            }
                        }
                    }
 
                    if (m_print_config.has("print_sequence")) {
                        PrintSequence seq = m_print_config.option<ConfigOptionEnum<PrintSequence>>("print_sequence")->value;
                        arrange_cfg.is_seq_print = (seq == PrintSequence::ByObject);
                    }
 
                    //add the virtual object into unselect list if has
                    partplate_list.preprocess_exclude_areas(unselected, m_print_config, enable_wrapping_detect);
 
                    // Filament ids given on the command line size the tower for STL input. A project
                    // records its filament use per plate, so count there and keep its tower positions.
                    const int  plate_count  = partplate_list.get_plate_count();
                    const bool from_project = used_filament_set.empty();
                    std::vector<int> plate_filament_counts(plate_count, static_cast<int>(used_filament_set.size()));
                    if (from_project)
                        for (int plate_index = 0; plate_index < plate_count; ++plate_index)
                            plate_filament_counts[plate_index] = static_cast<int>(partplate_list.get_plate(plate_index)->get_extruders_under_cli(true, m_print_config).size());
                    // A project only gets a tower the slicer will print: the prime tower enabled, and not
                    // a by-object print unless a smooth timelapse needs it, as the per-plate arrange decides.
                    const bool project_tower_allowed = m_print_config.option<ConfigOptionBool>("enable_prime_tower", true)->value &&
                                                       (is_smooth_timelapse || !arrange_cfg.is_seq_print);
                    const auto plate_needs_wipe_tower = [from_project, project_tower_allowed, is_smooth_timelapse](int filament_count) {
                        if (!from_project)
                            return filament_count > 0;
                        return project_tower_allowed && (filament_count > 1 || (filament_count > 0 && is_smooth_timelapse));
                    };
                    const int max_filament_count = plate_count > 0 ? *std::max_element(plate_filament_counts.begin(), plate_filament_counts.end()) : 0;
 
                    if (!is_belt_printer && plate_needs_wipe_tower(max_filament_count))
                    {
                        //prepare the wipe tower
                        auto printer_structure_opt = m_print_config.option<ConfigOptionEnum<PrinterStructure>>("printer_structure");
                        // This margin only pre-adjusts the default away from the near edges;
                        // estimate_wipe_tower_polygon below computes the real clamped position.
                        float tower_brim_width = m_print_config.option<ConfigOptionFloat>("prime_tower_brim_width", true)->value;
                        if (tower_brim_width < 0.f) tower_brim_width = 8.f; // auto: object heights unknown here, 8 mm is the auto cap
                        const float tower_margin          = WIPE_TOWER_MARGIN + tower_brim_width;
                        // set the default position, the same with print config(left top)
                        float x = WIPE_TOWER_DEFAULT_X_POS;
                        float y = WIPE_TOWER_DEFAULT_Y_POS;
                        if (printer_structure_opt && printer_structure_opt->value == PrinterStructure::psI3) {
                            x = I3_WIPE_TOWER_DEFAULT_X_POS;
                            y = I3_WIPE_TOWER_DEFAULT_Y_POS;
                        }
 
                        if (x < tower_margin) {
                            x = tower_margin;
                        }
                        if (y < tower_margin) {
                            y = tower_margin;
                        }
                        ConfigOptionFloat wt_x_opt(x);
                        ConfigOptionFloat wt_y_opt(y);
 
                        //create the options using default if necessary
                        ConfigOptionFloats* wipe_x_option = m_print_config.option<ConfigOptionFloats>("wipe_tower_x", true);
                        ConfigOptionFloats* wipe_y_option = m_print_config.option<ConfigOptionFloats>("wipe_tower_y", true);
                        ConfigOptionFloat* width_option = m_print_config.option<ConfigOptionFloat>("prime_tower_width", true);
                        ConfigOptionFloat* rotation_angle_option = m_print_config.option<ConfigOptionFloat>("wipe_tower_rotation_angle", true);
                        ConfigOptionFloat* volume_option = m_print_config.option<ConfigOptionFloat>("prime_volume", true);
 
                        BOOST_LOG_TRIVIAL(info) << boost::format("prime_tower_width %1% wipe_tower_rotation_angle %2% prime_volume %3%")%width_option->value %rotation_angle_option->value %volume_option->value ;
 
 
                        for (int bedid = 0; bedid < MAX_PLATE_COUNT; bedid++) {
                            int plate_index_valid = std::min(bedid, plate_count - 1);
                            // Overflow beds may receive objects from any plate, so size them for the busiest one.
                            const int extruder_size = bedid < plate_count ? plate_filament_counts[bedid] : max_filament_count;
                            if (!plate_needs_wipe_tower(extruder_size))
                                continue;
                            if (bedid < plate_count && !from_project) {
                                wipe_x_option->set_at(&wt_x_opt, plate_index_valid, 0);
                                wipe_y_option->set_at(&wt_y_opt, plate_index_valid, 0);
                            }
 
                            Vec3d wipe_tower_size, wipe_tower_pos;
                            ArrangePolygon wipe_tower_ap = partplate_list.get_plate(plate_index_valid)->estimate_wipe_tower_polygon(m_print_config, plate_index_valid, wipe_tower_pos, wipe_tower_size, extruder_size, true);
 
                            //update the new wp position
                            if (bedid < plate_count) {
                                wt_x_opt.value = wipe_tower_pos(0);
                                wt_y_opt.value = wipe_tower_pos(1);
 
                                wipe_x_option->set_at(&wt_x_opt, plate_index_valid, 0);
                                wipe_y_option->set_at(&wt_y_opt, plate_index_valid, 0);
 
                                BOOST_LOG_TRIVIAL(info) << boost::format("%1%, after estimate_wipe_tower_polygon,  pos {%2%, %3%}, size {%4%, %5%}, plate %6%")%__LINE__ % wipe_tower_pos(0) % wipe_tower_pos(1) % wipe_tower_size(0) %wipe_tower_size(1) %bedid;
                            }
 
                            wipe_tower_ap.bed_idx = bedid;
                            unselected.emplace_back(wipe_tower_ap);
                        }
                    }
                }
                else {
                    //only arrange current plate
                    partplate_list.lock_plate(plate_to_slice - 1, false);
                    partplate_list.select_plate(plate_to_slice-1);
                    BOOST_LOG_TRIVIAL(info) << boost::format("plate %1% set to selected")%plate_to_slice;
 
                    for (size_t oidx = 0; oidx < model.objects.size(); ++oidx)
                    {
                        ModelObject* mo = model.objects[oidx];
 
                        for (size_t inst_idx = 0; inst_idx < mo->instances.size(); ++inst_idx)
                        {
                            ModelInstance*   minst = mo->instances[inst_idx];
                            bool             in_plate = cur_plate->contain_instance(oidx, inst_idx) || cur_plate->intersect_instance(oidx, inst_idx);
                            ArrangePolygon   ap = get_instance_arrange_poly(minst, m_print_config);
 
                            ArrangePolygons& cont = mo->instances[inst_idx]->printable ?
                                (in_plate ? selected : unselected) :
                                unprintable;
                            bool locked = partplate_list.preprocess_arrange_polygon_other_locked(oidx, inst_idx, ap, in_plate);
                            BOOST_LOG_TRIVIAL(info) << boost::format("name %4% in_plate %1% printable %2%, locked %3%")%in_plate %mo->instances[inst_idx]->printable %locked % ap.name ;
                            if (!locked)
                            {
                                ap.itemid = cont.size();
                                cont.emplace_back(std::move(ap));
                            }
                            else
                            {
                                //skip this object due to be not in current plate, treated as locked
                                ap.itemid = locked_aps.size();
                                locked_aps.emplace_back(std::move(ap));
                                BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format("arrange: skip locked instance, obj_id %1%, name %2%") % oidx % mo->name;
                            }
                        }
                    }
                    if ((duplicate_count > 0)&&(selected.size() == (duplicate_count + 1)))
                    {
                        duplicate_single_object = true;
                        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": found single object mode");
                    }
 
                    if (!is_belt_printer && m_print_config.has("wipe_tower_x") && (is_smooth_timelapse || !arrange_cfg.is_seq_print || (selected.size() <= 1))) {
                        float x;
                        float y;
                        if (duplicate_count > 0) {
                            auto printer_structure_opt = m_print_config.option<ConfigOptionEnum<PrinterStructure>>("printer_structure");
                            x = WIPE_TOWER_DEFAULT_X_POS;
                            y = WIPE_TOWER_DEFAULT_Y_POS;
                            if (printer_structure_opt && printer_structure_opt->value == PrinterStructure::psI3) {
                                x = I3_WIPE_TOWER_DEFAULT_X_POS;
                                y = I3_WIPE_TOWER_DEFAULT_Y_POS;
                            }
                        }
                        else {
                            //keep the original
                            x = dynamic_cast<const ConfigOptionFloats *>(m_print_config.option("wipe_tower_x"))->get_at(plate_to_slice-1);
                            y = dynamic_cast<const ConfigOptionFloats *>(m_print_config.option("wipe_tower_y"))->get_at(plate_to_slice-1);
                        }
                        float w = dynamic_cast<const ConfigOptionFloat *>(m_print_config.option("prime_tower_width"))->value;
                        float a = dynamic_cast<const ConfigOptionFloat *>(m_print_config.option("wipe_tower_rotation_angle"))->value;
                        float v = dynamic_cast<const ConfigOptionFloat *>(m_print_config.option("prime_volume"))->value;
                        unsigned int filaments_cnt = (plate_data_src.size() >= static_cast<size_t>(plate_to_slice)) ? plate_data_src[plate_to_slice-1]->slice_filaments_info.size() : 0;
                        if ((filaments_cnt == 0) || need_skip)
                        {
                            // slice filaments info invalid
                            std::vector<int> extruders = cur_plate->get_extruders_under_cli(true, m_print_config);
                            filaments_cnt = extruders.size();
                            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format("arrange: slice filaments info invalid or need_skip, get from partplate: filament_count %1%")%filaments_cnt;
                        }
 
                        if ((filaments_cnt <= 1) && !is_smooth_timelapse && (!enable_wrapping_detect || current_wrapping_exclude_area.empty()))
                        {
                            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format("arrange: not a multi-color object anymore, drop the wipe tower before arrange.");
                        }
                        else
                        {
                            float layer_height = 0.2;
                            ConfigOption* layer_height_opt = m_print_config.option("layer_height");
                            if (layer_height_opt)
                                layer_height = layer_height_opt->getFloat();
 
                            //float depth = v * (filaments_cnt - 1) / (layer_height * w);
 
                            const WipeTowerFootprint footprint = cur_plate->estimate_wipe_tower_footprint(m_print_config, filaments_cnt);
                            Vec3d wipe_tower_size(footprint.width, footprint.depth, footprint.height);
                            Vec3d plate_origin = cur_plate->get_origin();
                            int plate_width, plate_depth;
                            double plate_height;
                            partplate_list.get_plate_size(plate_width, plate_depth, plate_height);
                            float depth = wipe_tower_size(1);
                            // Brim already resolved against the height the body was sized from.
                            float margin = 15.f, wp_brim_width = float(footprint.brim_width);
                            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format("arrange wipe_tower: wp_brim_width %1%")%wp_brim_width;
                            w = wipe_tower_size(0);
 
                            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format("arrange wipe_tower: x=%1%, y=%2%, width=%3%, depth=%4%, angle=%5%, prime_volume=%6%, filaments_cnt=%7%, layer_height=%8%, plate_width=%9%, plate_depth=%10%")
                                                            %x %y %w %depth %a %v %filaments_cnt %layer_height %plate_width %plate_depth;
                            if ((y + depth + margin + wp_brim_width) > (float)plate_depth) {
                                y = (float)plate_depth - depth - margin - wp_brim_width;
                                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format("arrange wipe_tower: exceeds the border, change y to %1%, plate_depth=%2%")%y %plate_depth;
                            }
 
                            if ((x + w + margin + wp_brim_width) > (float)plate_width) {
                                x = (float)plate_width - w - margin - wp_brim_width;
                                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format("arrange wipe_tower: exceeds the border, change x to %1%, plate_width=%2%")%y %plate_width;
                            }
                            if (x < margin) {
                                x = margin;
                            }
                            if (y < margin) {
                                y = margin;
                            }
                            //update wipe_tower_x and wipe_tower_y
                            ConfigOptionFloat wt_x_opt(x);
                            ConfigOptionFloat wt_y_opt(y);
                            ConfigOptionFloats* wipe_x_option = m_print_config.option<ConfigOptionFloats>("wipe_tower_x", true);
                            ConfigOptionFloats* wipe_y_option = m_print_config.option<ConfigOptionFloats>("wipe_tower_y", true);
 
                            wipe_x_option->set_at(&wt_x_opt, plate_to_slice-1, 0);
                            wipe_y_option->set_at(&wt_y_opt, plate_to_slice-1, 0);
 
                            ArrangePolygon wipe_tower_ap;
 
                            Polygon ap({
                                {scaled(x - wp_brim_width), scaled(y - wp_brim_width)},
                                {scaled(x + w + wp_brim_width), scaled(y - wp_brim_width)},
                                {scaled(x + w + wp_brim_width), scaled(y + depth + wp_brim_width)},
                                {scaled(x - wp_brim_width), scaled(y + depth + wp_brim_width)}
                                });
                            wipe_tower_ap.bed_idx = 0;
                            wipe_tower_ap.setter = NULL; // do not move wipe tower
 
                            wipe_tower_ap.poly.contour = std::move(ap);
                            wipe_tower_ap.translation  = {scaled(0.f), scaled(0.f)};
                            wipe_tower_ap.rotation     = a;
                            wipe_tower_ap.name = "WipeTower";
                            wipe_tower_ap.is_virt_object = true;
                            wipe_tower_ap.is_wipe_tower = true;
                            ++wipe_tower_ap.priority;
                            unselected.emplace_back(std::move(wipe_tower_ap));
                        }
                    }
 
                    // add the virtual object into unselect list if has
                    partplate_list.preprocess_exclude_areas(
                        unselected, m_print_config, enable_wrapping_detect, plate_to_slice);
                }
 
 
                //Step-2:prepare the arrange params
                arrange_cfg.allow_rotations  = allow_rotations;
                arrange_cfg.allow_multi_materials_on_same_plate = allow_multicolor_oneplate;
                arrange_cfg.avoid_extrusion_cali_region         = avoid_extrusion_cali_region;
                arrange_cfg.clearance_height_to_rod             = height_to_rod;
                arrange_cfg.clearance_height_to_lid             = height_to_lid;
                arrange_cfg.clearance_radius                   = clearance_radius;
                arrange_cfg.nozzle_height                       = nozzle_height;
                arrange_cfg.align_center                        = align_center;
                arrange_cfg.printable_height                    = print_height;
                arrange_cfg.min_obj_distance = 0;
                if (arrange_cfg.is_seq_print) {
                    arrange_cfg.bed_shrink_x = BED_SHRINK_SEQ_PRINT;
                    arrange_cfg.bed_shrink_y = BED_SHRINK_SEQ_PRINT;
                }
                if (align_to_y_axis.has_value()) {
                    arrange_cfg.align_to_y_axis = *align_to_y_axis;
                } else if (auto printer_structure_opt = m_print_config.option<ConfigOptionEnum<PrinterStructure>>("printer_structure")) {
                    arrange_cfg.align_to_y_axis = (printer_structure_opt->value == PrinterStructure::psI3);
                }
 
                arrangement::update_arrange_params(arrange_cfg, &m_print_config, selected);
                arrangement::update_selected_items_inflation(selected, &m_print_config, arrange_cfg);
                arrangement::update_unselected_items_inflation(unselected, &m_print_config, arrange_cfg);
                arrangement::update_selected_items_axis_align(selected, &m_print_config, arrange_cfg);
 
                beds=get_shrink_bedpts(&m_print_config, arrange_cfg);
 
                partplate_list.preprocess_exclude_areas(
                    arrange_cfg.excluded_regions, m_print_config, enable_wrapping_detect, 1, scale_(1));
 
                {
                    BOOST_LOG_TRIVIAL(debug) << "arrange bedpts:" << beds[0].transpose() << ", " << beds[1].transpose() << ", " << beds[2].transpose() << ", " << beds[3].transpose();
                    BOOST_LOG_TRIVIAL(info)<< "Arrange full params: "<< arrange_cfg.to_json();
                    BOOST_LOG_TRIVIAL(info) << boost::format("arrange: items selected before arranging: %1%")%selected.size();
                    for (auto item : selected)
                        BOOST_LOG_TRIVIAL(trace) << item.name << ", extruder: " << item.extrude_ids.back() << ", bed: " << item.bed_idx
                                                << ", trans: " << item.translation.transpose();
                    BOOST_LOG_TRIVIAL(info) << boost::format("arrange: items unselected before arranging: %1%") % unselected.size();
                    for (auto item : unselected)
                        BOOST_LOG_TRIVIAL(trace) << item.name << ", bed: " << item.bed_idx << ", trans: " << item.translation.transpose();
                }
                arrange_cfg.progressind= [](unsigned st, std::string str = "") {
                    //boost::nowide::cout << "st=" << st << ", " << str << std::endl;
                };
 
                //Step-3:do the arrange
                BOOST_LOG_TRIVIAL(info) << boost::format("start %1% th arranging...")%arrange_count;
                arrangement::arrange(selected, unselected, beds, arrange_cfg);
                arrangement::arrange(unprintable, {}, beds, arrange_cfg);
                arranged_without_rotations |= !arrange_cfg.allow_rotations;
                BOOST_LOG_TRIVIAL(info) << boost::format("finished %1% th arranging...")%arrange_count;
 
                //Step-4:postprocess by partplate list&&apply the result
                int bed_idx_max = 0;
                if (duplicate_count == 0)
                {
                    if (plate_to_slice > 0)
                    {
                        //only for partplate case
                        partplate_list.clear(false, false, true, plate_to_slice-1);
 
                        for (ArrangePolygon& ap : selected) {
                            partplate_list.postprocess_bed_index_for_current_plate(ap);
                            if (ap.bed_idx != (plate_to_slice-1))
                            {
                                BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(":arrange failed: ap.name %1% ap.bed_idx %2%, plate index %3%")% ap.name % ap.bed_idx % (plate_to_slice-1);
                                record_exit_reson(outfile_dir, CLI_OBJECT_ARRANGE_FAILED, 0, cli_errors[CLI_OBJECT_ARRANGE_FAILED], sliced_info);
                                flush_and_exit(CLI_OBJECT_ARRANGE_FAILED);
                            }
                            bed_idx_max = std::max(ap.bed_idx, bed_idx_max);
                        }
                    }
                    else
                    {
                        //clear all the relations before apply the arrangement results
                        partplate_list.clear();
 
                        // Apply the arrange result to all selected objects
                        for (ArrangePolygon &ap : selected) {
                            //BBS: partplate postprocess
                            partplate_list.postprocess_bed_index_for_selected(ap);
 
                            bed_idx_max = std::max(ap.bed_idx, bed_idx_max);
                            BOOST_LOG_TRIVIAL(trace)<< "after arrange: name=" << ap.name << boost::format(",bed_id %1%, trans {%2%,%3%}") % ap.bed_idx % unscale<double>(ap.translation(X)) % unscale<double>(ap.translation(Y)) << "\n";
                        }
                    }
                    for (ArrangePolygon &ap : locked_aps) {
                        bed_idx_max = std::max(ap.bed_idx, bed_idx_max);
 
                        partplate_list.postprocess_arrange_polygon(ap, false);
 
                        ap.apply();
                    }
 
                    // Apply the arrange result to all selected objects
                    for (ArrangePolygon &ap : selected) {
                        //BBS: partplate postprocess
                        partplate_list.postprocess_arrange_polygon(ap, true);
 
                        ap.apply();
                    }
 
                    // Apply the arrange result to unselected objects(due to the sukodu-style column changes, the position of unselected may also be modified)
                    for (ArrangePolygon& ap : unselected)
                    {
                        if (ap.is_virt_object)
                            continue;
 
                        //BBS: partplate postprocess
                        partplate_list.postprocess_arrange_polygon(ap, false);
 
                        ap.apply();
                    }
 
                    // Move the unprintable items to the last virtual bed.
                    // Note ap.apply() moves relatively according to bed_idx, so we need to subtract the original bed_idx
                    for (ArrangePolygon& ap : unprintable)
                    {
                        ap.bed_idx = bed_idx_max + 1;
                        partplate_list.postprocess_arrange_polygon(ap, true);
 
                        ap.apply();
                        BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(":arrange m_unprintable: name: %4%, bed_id %1%, trans {%2%,%3%}") % ap.bed_idx % unscale<double>(ap.translation(X)) % unscale<double>(ap.translation(Y)) % ap.name;
                    }
 
                    //BBS: reload all objects due to arrange
                    if (plate_to_slice > 0)
                        partplate_list.rebuild_plates_after_arrangement(false, true, plate_to_slice-1);
                    else
                        partplate_list.rebuild_plates_after_arrangement();
                }
                else {
                    //only for partplate case
                    partplate_list.clear(false, false, true, plate_to_slice-1);
 
                    //BBS: adjust the bed_index, create new plates, get the max bed_index
                    bool failed_this_time = false;
                    for (ArrangePolygon& ap : selected) {
                        partplate_list.postprocess_bed_index_for_current_plate(ap);
                        if (ap.bed_idx != (plate_to_slice-1))
                        {
                            //
                            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(":arrange failed: ap.name %1% ap.bed_idx %2%, plate index %3%")% ap.name % ap.bed_idx % (plate_to_slice-1);
                            if (!duplicate_single_object)
                            {
                                BOOST_LOG_TRIVIAL(warning) << boost::format("arrange failed when duplicate multiple objects at count %1%, low_duplicate_count %2%, up_duplicate_count %3%")%duplicate_count %low_duplicate_count %up_duplicate_count;
 
                                if (duplicate_count == 1)
                                {
                                    BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(": failed even on duplicate 1 copy, just print one original model");
                                    duplicate_count = 0;
                                }
                                else
                                {
                                    if (duplicate_count == low_duplicate_count)
                                    {
                                        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(": previous success, but currently failed count %1%!!!")%duplicate_count;
                                        up_duplicate_count = duplicate_count;
                                        low_duplicate_count --;
                                        duplicate_count --;
                                    }
                                    else {
                                        up_duplicate_count = duplicate_count;
                                        duplicate_count = (up_duplicate_count + low_duplicate_count)/2;
                                    }
                                    BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(": try new count %1%, low_duplicate_count %2%, up_duplicate_count %3%")%duplicate_count %low_duplicate_count %up_duplicate_count;
                                }
                                //record_exit_reson(outfile_dir, CLI_OBJECT_ARRANGE_FAILED, 0, cli_errors[CLI_OBJECT_ARRANGE_FAILED], sliced_info);
                                //flush_and_exit(CLI_OBJECT_ARRANGE_FAILED);
                                failed_this_time = true;
                                break;
                            }
                        }
                        else {
                            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(":arrange success: ap.name %1% ap.bed_idx %2%, plate index %3%")% ap.name % ap.bed_idx % (plate_to_slice-1);
                            real_duplicate_count ++;
                        }
 
                        bed_idx_max = std::max(ap.bed_idx, bed_idx_max);
                        BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": arrange selected %4%: bed_id %1%, trans {%2%,%3%}") % ap.bed_idx % unscale<double>(ap.translation(X)) % unscale<double>(ap.translation(Y)) % ap.name;
                    }
 
                    if (failed_this_time) {
                        if (duplicate_count == 0)
                        {
                            //restore to the original
                            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": restore to the original model and plates, orig_wipe_x %1%, orig_wipe_y %2%")%orig_wipe_x %orig_wipe_y;
                            finished_arrange = true;
                            model = original_model;
                            partplate_list.load_from_3mf_structure(plate_data_src);
                            partplate_list.reset_size(current_printable_width, current_printable_depth, current_printable_height, true, true);
                            if ((orig_wipe_x > 0.f) && (orig_wipe_y > 0.f))
                            {
                                ConfigOptionFloat wt_x_opt(orig_wipe_x);
                                ConfigOptionFloat wt_y_opt(orig_wipe_y);
                                ConfigOptionFloats* wipe_x_option = m_print_config.option<ConfigOptionFloats>("wipe_tower_x", true);
                                ConfigOptionFloats* wipe_y_option = m_print_config.option<ConfigOptionFloats>("wipe_tower_y", true);
 
                                wipe_x_option->set_at(&wt_x_opt, plate_to_slice-1, 0);
                                wipe_y_option->set_at(&wt_y_opt, plate_to_slice-1, 0);
                                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": restore wipe_tower position to {%1%, %2%}")%orig_wipe_x %orig_wipe_y;
                            }
                            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": exit arrange process");
                        }
                        continue;
                    }
 
                    if (duplicate_single_object)
                    {
                        if (real_duplicate_count <= 1) {
                            BOOST_LOG_TRIVIAL(warning) << boost::format("no object can be placed under single object mode, restore to the original model and plates also, orig_wipe_x %1%, orig_wipe_y %2%")%orig_wipe_x %orig_wipe_y;
                            //record_exit_reson(outfile_dir, CLI_OBJECT_ARRANGE_FAILED, 0, cli_errors[CLI_OBJECT_ARRANGE_FAILED], sliced_info);
                            //flush_and_exit(CLI_OBJECT_ARRANGE_FAILED);
                            finished_arrange = true;
                            model = original_model;
                            partplate_list.load_from_3mf_structure(plate_data_src);
                            partplate_list.reset_size(current_printable_width, current_printable_depth, current_printable_height, true, true);
                            duplicate_count = 0;
                            if ((orig_wipe_x > 0.f) && (orig_wipe_y > 0.f))
                            {
                                ConfigOptionFloat wt_x_opt(orig_wipe_x);
                                ConfigOptionFloat wt_y_opt(orig_wipe_y);
                                ConfigOptionFloats* wipe_x_option = m_print_config.option<ConfigOptionFloats>("wipe_tower_x", true);
                                ConfigOptionFloats* wipe_y_option = m_print_config.option<ConfigOptionFloats>("wipe_tower_y", true);
 
                                wipe_x_option->set_at(&wt_x_opt, plate_to_slice-1, 0);
                                wipe_y_option->set_at(&wt_y_opt, plate_to_slice-1, 0);
                                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": restore wipe_tower position to {%1%, %2%}")%orig_wipe_x %orig_wipe_y;
                            }
                            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": exit arrange process");
                            continue;
                        }
                        duplicate_count = real_duplicate_count - 1;
                    }
                    else {
                        //multiple objects case
                        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": multiple objects mode, arrange success on count %1%, low_duplicate_count %2%, up_duplicate_count %3%")%duplicate_count %low_duplicate_count %up_duplicate_count;
                        if ((duplicate_count == up_duplicate_count) || (duplicate_count == (up_duplicate_count - 1)))
                        {
                            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": found the max arrangeable count %1%")%duplicate_count;
                        }
                        else {
                            low_duplicate_count = duplicate_count;
                            duplicate_count = (up_duplicate_count + low_duplicate_count)/2;
                            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": try new count %1%, low_duplicate_count %2%, up_duplicate_count %3%")%duplicate_count %low_duplicate_count %up_duplicate_count;
                            continue;
                        }
                    }
 
                    //BBS: adjust the bed_index, create new plates, get the max bed_index
                    for (ArrangePolygon& ap : unselected)
                    {
                        if (ap.is_virt_object)
                            continue;
 
                        bed_idx_max = std::max(ap.bed_idx, bed_idx_max);
                        BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(":arrange unselected %4%: bed_id %1%, trans {%2%,%3%}") % ap.bed_idx % unscale<double>(ap.translation(X)) % unscale<double>(ap.translation(Y)) % ap.name;
                    }
 
                    for (ArrangePolygon& ap : locked_aps)
                    {
                        bed_idx_max = std::max(ap.bed_idx, bed_idx_max);
 
                        partplate_list.postprocess_arrange_polygon(ap, false);
 
                        ap.apply();
                    }
 
                    // Apply the arrange result to all selected objects
                    for (ArrangePolygon& ap : selected) {
                        //BBS: partplate postprocess
                        partplate_list.postprocess_arrange_polygon(ap, true);
 
                        ap.apply();
                    }
 
                    // Apply the arrange result to unselected objects(due to the sukodu-style column changes, the position of unselected may also be modified)
                    for (ArrangePolygon& ap : unselected)
                    {
                        if (ap.is_virt_object)
                            continue;
 
                        //BBS: partplate postprocess
                        partplate_list.postprocess_arrange_polygon(ap, false);
 
                        ap.apply();
                    }
 
                    // Move the unprintable items to the last virtual bed.
                    // Note ap.apply() moves relatively according to bed_idx, so we need to subtract the original bed_idx
                    for (ArrangePolygon& ap : unprintable)
                    {
                        ap.bed_idx = bed_idx_max + 1;
                        partplate_list.postprocess_arrange_polygon(ap, true);
 
                        ap.apply();
                        BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(":arrange m_unprintable: name: %4%, bed_id %1%, trans {%2%,%3%}") % ap.bed_idx % unscale<double>(ap.translation(X)) % unscale<double>(ap.translation(Y)) % ap.name;
                    }
 
                    partplate_list.rebuild_plates_after_arrangement(false, true, plate_to_slice-1);
                }
                finished_arrange = true;
            }
            original_model.clear_objects();
            original_model.clear_materials();
        }
    }
 
    // All transforms have been dealt with. Now ensure that the objects are on bed.
    // (Unless the user said otherwise.)
    //BBS: current only support models on bed, 0407 sinking supported
    if (m_config.opt_bool("ensure_on_bed"))
    {
        BOOST_LOG_TRIVIAL(info) << "ensure_on_bed: need to ensure each object on beds";
        for (auto &model : m_models)
            for (auto &o : model.objects)
                o->ensure_on_bed();
    }
 
    // loop through action options
    bool export_to_3mf = false, load_slicedata = false, export_slicedata = false, export_slicedata_error = false;
    bool no_check = false;
    std::string export_3mf_file, load_slice_data_dir, export_slice_data_dir, export_stls_dir;
    std::vector<ThumbnailData*> calibration_thumbnails;
    std::vector<int> plate_object_count(partplate_list.get_plate_count(), 0);
    int max_slicing_time_per_plate = 0, max_triangle_count_per_plate = 0, sliced_plate = -1;
    std::vector<bool> plate_has_skips(partplate_list.get_plate_count(), false);
    std::vector<std::vector<size_t>> plate_skipped_objects(partplate_list.get_plate_count());
 
    global_current_time = (long long)Slic3r::Utils::get_current_time_utc();
    sliced_info.prepare_time = (size_t) (global_current_time - global_begin_time);
    global_begin_time = global_current_time;
 
    for (auto const &opt_key : m_actions) {
        if (opt_key == "help") {
            this->print_help();
        } else if (opt_key == "help_fff") {
            this->print_help(true, ptFFF);
        } else if (opt_key == "help_sla") {
            this->print_help(true, ptSLA);
        } else if (opt_key == "pipe") {
            //already processed before
        } else if (opt_key == "load_slicedata") {
            load_slicedata = true;
            load_slice_data_dir = m_config.opt_string(opt_key);
            if (export_slicedata) {
                BOOST_LOG_TRIVIAL(error) << "should not set load_slicedata and export_slicedata together." << std::endl;
                record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
                flush_and_exit(CLI_INVALID_PARAMS);
            }
            else if (duplicate_count > 0)
            {
                BOOST_LOG_TRIVIAL(error) << "should not set load_slicedata when set repetitions." << std::endl;
                record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
                flush_and_exit(CLI_INVALID_PARAMS);
            }
            else if (shrink_to_new_bed > 0)
            {
                BOOST_LOG_TRIVIAL(warning) << "use load_slicedata when shrink_to_new_bed." << std::endl;
                //record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
                //flush_and_exit(CLI_INVALID_PARAMS);
            }
        } else if (opt_key == "export_settings") {
            //FIXME check for mixing the FFF / SLA parameters.
            // or better save fff_print_config vs. sla_print_config
            //m_print_config.save(m_config.opt_string("save"));
            const std::string &settings_file = m_config.opt_string(opt_key);
            if (settings_file == "-")
                m_print_config.save_to_json(boost::nowide::cout, "project_settings", "project", SoftFever_VERSION, /*replace_invalid_utf8=*/true);
            else
                m_print_config.save_to_json(settings_file, std::string("project_settings"), std::string("project"), std::string(SoftFever_VERSION));
        } else if (opt_key == "info") {
            // --info works on unrepaired model
            for (Model &model : m_models) {
                model.add_default_instances();
                model.print_info();
            }
        } else if (opt_key == "inspect_mesh") {
            // Machine-readable alternative to --info. Registered as an action so it satisfies the
            // "needs an action" check and bypasses the GUI fallback, then exits once the JSON is out.
            for (Model &model : m_models) {
                model.add_default_instances();
                Slic3r::MeshInspect::inspect_to_json(model, m_input_files, boost::nowide::cout);
            }
            boost::nowide::cout.flush();
            // Conflicting actions were rejected before loading. Finish like the end of run().
            // flush_and_exit() is not usable here: it prints "found error ..." to stdout,
            // which would corrupt the JSON.
#if defined(__linux__) || defined(__LINUX__)
            if (g_cli_callback_mgr.is_started()) {
                PrintBase::SlicingStatus slicing_status{100, "All done, Success"};
                cli_status_callback(slicing_status);
            }
            g_cli_callback_mgr.stop();
#endif
            for (Model &m : m_models)
                m.remove_backup_path_if_exist();
            record_exit_reson(outfile_dir, CLI_SUCCESS, plate_to_slice, cli_errors[CLI_SUCCESS], sliced_info);
            boost::nowide::cerr.flush();
            return CLI_SUCCESS;
        } else if (opt_key == "inspect_paint") {
            // --inspect-paint — read the per-facet enforcer/blocker/extruder/
            // fuzzy state from the loaded model and emit a JSON summary.
            // Machine-readable alternative to opening the paint gizmos.
            for (Model &model : m_models) {
                model.add_default_instances();
                Slic3r::PaintCLI::inspect_to_json(model, m_input_files, boost::nowide::cout);
            }
            boost::nowide::cout.flush();
            // The tooltip promises "then exit"; conflicting actions were rejected before
            // loading. Finish like the end of run(). flush_and_exit() is not usable here:
            // it prints "found error ..." to stdout, which would corrupt the JSON.
#if defined(__linux__) || defined(__LINUX__)
            if (g_cli_callback_mgr.is_started()) {
                PrintBase::SlicingStatus slicing_status{100, "All done, Success"};
                cli_status_callback(slicing_status);
            }
            g_cli_callback_mgr.stop();
#endif
            for (Model &m : m_models)
                m.remove_backup_path_if_exist();
            record_exit_reson(outfile_dir, CLI_SUCCESS, plate_to_slice, cli_errors[CLI_SUCCESS], sliced_info);
            boost::nowide::cerr.flush();
            return CLI_SUCCESS;
        } else if (opt_key == "uptodate") {
            //already processed before
        } else if (opt_key == "min_save") {
            //already processed before
        } else if (opt_key == "load_defaultfila") {
            //already processed before
        } else if (opt_key == "mtcpp") {
            max_triangle_count_per_plate = m_config.option<ConfigOptionInt>("mtcpp")->value;
        } else if (opt_key == "mstpp") {
            max_slicing_time_per_plate = m_config.option<ConfigOptionInt>("mstpp")->value;
        } else if (opt_key == "export_stl") {
            for (auto &model : m_models)
                model.add_default_instances();
            if (! this->export_models(IO::STL)) {
                record_exit_reson(outfile_dir, CLI_EXPORT_STL_ERROR, 0, cli_errors[CLI_EXPORT_STL_ERROR], sliced_info);
                flush_and_exit(CLI_EXPORT_STL_ERROR);
            }
        } else if (opt_key == "export_stls") {
            export_stls_dir = m_config.opt_string(opt_key);
            for (auto &model : m_models)
                model.add_default_instances();
            if (! this->export_models(IO::STL, export_stls_dir)) {
                record_exit_reson(outfile_dir, CLI_EXPORT_STL_ERROR, 0, cli_errors[CLI_EXPORT_STL_ERROR], sliced_info);
                flush_and_exit(CLI_EXPORT_STL_ERROR);
            }
        } else if (opt_key == "export_obj") {
            for (auto &model : m_models)
                model.add_default_instances();
            if (! this->export_models(IO::OBJ)) {
                record_exit_reson(outfile_dir, CLI_EXPORT_OBJ_ERROR, 0, cli_errors[CLI_EXPORT_OBJ_ERROR], sliced_info);
                flush_and_exit(CLI_EXPORT_OBJ_ERROR);
            }
        }/* else if (opt_key == "export_amf") {
            if (! this->export_models(IO::AMF))
                return 1;
        } */else if (opt_key == "export_3mf") {
            export_to_3mf = true;
            export_3mf_file = m_config.opt_string(opt_key);
        }else if(opt_key=="no_check"){
            no_check = m_config.opt_bool(opt_key);
        }else if(opt_key=="strict"){
            //already read into sliced_info at the start of run()
        //} else if (opt_key == "export_gcode" || opt_key == "export_sla" || opt_key == "slice") {
        } else if (opt_key == "normative_check") {
            //already processed before
        } else if (opt_key == "export_slicedata") {
            export_slicedata = true;
            export_slice_data_dir = m_config.opt_string(opt_key);
            if (load_slicedata) {
                BOOST_LOG_TRIVIAL(error) << "should not set load_slicedata and export_slicedata together." << std::endl;
                record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
                flush_and_exit(CLI_INVALID_PARAMS);
            }
        } else if (opt_key == "slice") {
            //BBS: slice 0 means all plates, i means plate i;
            plate_to_slice = m_config.option<ConfigOptionInt>("slice")->value;
            sliced_plate = plate_to_slice;
            bool pre_check = (plate_to_slice == 0)?true:false;
            bool finished = false;
 
            /*if (opt_key == "export_gcode" && printer_technology == ptSLA) {
                boost::nowide::cerr << "error: cannot export G-code for an FFF configuration" << std::endl;
                record_exit_reson(outfile_dir, 1, 0, cli_errors[1], sliced_info);
                flush_and_exit(1);
            } else if (opt_key == "export_sla" && printer_technology == ptFFF) {
                boost::nowide::cerr << "error: cannot export SLA slices for a SLA configuration" << std::endl;
                record_exit_reson(outfile_dir, 1, 0, cli_errors[1], sliced_info);
                flush_and_exit(1);
            }*/
            BOOST_LOG_TRIVIAL(info) << "Need to slice for plate "<<plate_to_slice <<", total plate count "<<partplate_list.get_plate_count()<<" partplates!" << std::endl;
#if defined(__linux__) || defined(__LINUX__)
            if (g_cli_callback_mgr.is_started()) {
                PrintBase::SlicingStatus slicing_status{3, "Prepare slicing"};
                cli_status_callback(slicing_status);
            }
#endif
            // Make a copy of the model if the current action is not the last action, as the model may be
            // modified by the centering and such.
            Model model_copy;
            bool  make_copy = &opt_key != &m_actions.back();
            for (Model &model_in : m_models) {
                if (make_copy)
                    model_copy = model_in;
                Model &model = make_copy ? model_copy : model_in;
                // If all objects have defined instances, their relative positions will be
                // honored when printing (they will be only centered, unless --dont-arrange
                // is supplied); if any object has no instances, it will get a default one
                // and all instances will be rearranged (unless --dont-arrange is supplied).
                std::string outfile;
                //Print       fff_print;
                std::vector<size_t> plate_triangle_counts(partplate_list.get_plate_count(), 0);
 
                // The stored (or default) tower position may not fit the tower these plates
                // need, and no CLI placement site runs on a plain slice - mirror the GUI's
                // reload clamp and fit every plate's tower into the printable area first.
                if (!is_belt_printer && m_print_config.option<ConfigOptionBool>("enable_prime_tower", true)->value) {
                    for (int index = 0; index < partplate_list.get_plate_count(); index++) {
                        if ((plate_to_slice != 0) && (plate_to_slice != (index + 1)))
                            continue;
                        Slic3r::GUI::PartPlate *plate = partplate_list.get_plate(index);
                        // Printing by object disables the tower only with more than one instance.
                        bool is_seq_print = false;
                        get_print_sequence(plate, m_print_config, is_seq_print);
                        if (is_seq_print && plate->printable_instance_size() > 1)
                            continue;
                        // An empty estimate is a plate that prints no tower (one filament and
                        // neither smooth timelapse, wrapping detection nor a raft).
                        Vec3d                            wt_pos, wt_size;
                        Slic3r::GUI::WipeTowerRelocation relocation;
                        plate->estimate_wipe_tower_polygon(m_print_config, index, wt_pos, wt_size, 0, false, &relocation);
                        if (wt_size(0) < EPSILON || wt_size(1) < EPSILON)
                            continue;
                        if (relocation.moved)
                            BOOST_LOG_TRIVIAL(warning) << boost::format("plate %1%: the wipe tower no longer fits at its saved position {%2%, %3%} and was moved %4%")
                                % (index + 1) % m_print_config.option<ConfigOptionFloats>("wipe_tower_x", true)->get_at(index)
                                % m_print_config.option<ConfigOptionFloats>("wipe_tower_y", true)->get_at(index)
                                % (relocation.overlaps_objects ? "onto an object, as no free space is left" : "to free space");
                        ConfigOptionFloat wt_x_opt((float) wt_pos(0));
                        ConfigOptionFloat wt_y_opt((float) wt_pos(1));
                        m_print_config.option<ConfigOptionFloats>("wipe_tower_x", true)->set_at(&wt_x_opt, index, 0);
                        m_print_config.option<ConfigOptionFloats>("wipe_tower_y", true)->set_at(&wt_y_opt, index, 0);
                        BOOST_LOG_TRIVIAL(info) << boost::format("plate %1%: wipe tower clamped to {%2%, %3%}, size {%4%, %5%}")
                            % (index + 1) % wt_pos(0) % wt_pos(1) % wt_size(0) % wt_size(1);
                    }
                }
 
                while(!finished)
                {
                    //BBS: slice every partplate one by one
                    PrintBase  *print=NULL;
                    Print *print_fff = NULL;
 
                    Slic3r::GUI::GCodeResult *gcode_result = NULL;
                    int print_index;
                    for (int index = 0; index < partplate_list.get_plate_count(); index ++)
                    {
                        if ((plate_to_slice != 0) && (plate_to_slice != (index + 1))) {
                            BOOST_LOG_TRIVIAL(info) << "Skip plate " << index+1 << std::endl;
                            continue;
                        }
                        sliced_plate_info_t sliced_plate_info;
                        sliced_plate_info.plate_id = index+1;
 
                        model.curr_plate_index = index;
                        BOOST_LOG_TRIVIAL(info) << boost::format("Plate %1%: pre_check %2%, start")%(index+1)%pre_check;
                        long long start_time = 0, end_time = 0, temp_time = 0, time_using_cache = 0;
                        start_time = (long long)Slic3r::Utils::get_current_time_utc();
                        //get the current partplate
                        Slic3r::GUI::PartPlate* part_plate = partplate_list.get_plate(index);
                        part_plate->get_print(&print, &gcode_result, &print_index);
 
                        print_fff = dynamic_cast<Print *>(print);
                        /*if (outfile_config.empty())
                        {
                            outfile = "plate_" + std::to_string(index + 1) + ".gcode";
                        }
                        else
                        {
                            outfile = "plate_" + std::to_string(index + 1) + "_" + outfile_config + ".gcode";
                        }*/
 
                        //update plate's bounding box to model
#if 0
                        BoundingBoxf3   print_volume = part_plate->get_bounding_box(false);
                        print_volume.max(2) = z;
                        print_volume.min(2) = -1e10;
                        model.update_print_volume_state(print_volume);
                        BOOST_LOG_TRIVIAL(info) << boost::format("print_volume {%1%,%2%,%3%}->{%4%, %5%, %6%}") % print_volume.min(0) % print_volume.min(1)
                            % print_volume.min(2) % print_volume.max(0) % print_volume.max(1) % print_volume.max(2) << std::endl;
#else
                        BuildVolume build_volume(part_plate->get_shape(), print_height, part_plate->get_extruder_areas(), current_extruder_print_heights);
                        //model.update_print_volume_state(build_volume);
                        unsigned int count = model.update_print_volume_state(build_volume);
 
                        if (count == 0) {
                            BOOST_LOG_TRIVIAL(error) << "plate "<< index+1<< ": Nothing to be sliced, Either the print is empty or no object is fully inside the print volume before apply." << std::endl;
                            std::string no_objects_reason = cli_errors[CLI_NO_SUITABLE_OBJECTS];
                            if (arranged_without_rotations) {
                                //ORCA: result.json is only written on Linux, so also print the reason to stderr.
                                no_objects_reason = "No object is fully inside the print volume. Arrange ran without rotations."
                                                    " If an object only fits the bed when rotated, pass --allow-rotations."
                                                    " Otherwise the plate is empty or an object is larger than the printable area or height.";
                                boost::nowide::cerr << "plate " << index+1 << ": " << no_objects_reason << std::endl;
                            }
                            record_exit_reson(outfile_dir, CLI_NO_SUITABLE_OBJECTS, index+1, no_objects_reason, sliced_info);
                            flush_and_exit(CLI_NO_SUITABLE_OBJECTS);
                        }
                        else if ((plate_to_slice != 0) || pre_check) {
                            long long triangle_count = 0;
                            int printable_instances = 0;
                            int skipped_count = 0;
                            std::vector<std::set<int>> unprintable_filament_ids(new_extruder_count, std::set<int>());
                            for (ModelObject* model_object : model.objects)
                                for (ModelInstance *i : model_object->instances)
                                {
                                    i->use_loaded_id_for_label = true;
                                    if (skip_maps.find(i->loaded_id) != skip_maps.end()) {
                                        skip_maps[i->loaded_id] = true;
                                        i->printable = false;
                                        if (i->print_volume_state == ModelInstancePVS_Inside) {
                                            skipped_count++;
                                            plate_has_skips[index] = true;
                                            plate_skipped_objects[index].emplace_back(i->loaded_id);
                                            BOOST_LOG_TRIVIAL(info) << boost::format("Plate %1%: skip object %2%.")%(index+1)%i->loaded_id;
                                            //need to regenerate the thumbnail
                                            if (plate_data_src.size() > index) {
                                                if (!plate_data_src[index]->thumbnail_file.empty()) {
                                                    BOOST_LOG_TRIVIAL(info) << boost::format("Plate %1%: clear loaded thumbnail %2%.")%(index+1)%plate_data_src[index]->thumbnail_file;
                                                    plate_data_src[index]->thumbnail_file.clear();
                                                }
                                                if (!plate_data_src[index]->no_light_thumbnail_file.empty()) {
                                                    BOOST_LOG_TRIVIAL(info) << boost::format("Plate %1%: clear loaded no_light_thumbnail %2%.")%(index+1)%plate_data_src[index]->no_light_thumbnail_file;
                                                    plate_data_src[index]->no_light_thumbnail_file.clear();
                                                }
                                                if (!plate_data_src[index]->top_file.empty()) {
                                                    BOOST_LOG_TRIVIAL(info) << boost::format("Plate %1%: clear loaded top_thumbnail %2%.")%(index+1)%plate_data_src[index]->top_file;
                                                    plate_data_src[index]->top_file.clear();
                                                }
                                                if (!plate_data_src[index]->pick_file.empty()) {
                                                    BOOST_LOG_TRIVIAL(info) << boost::format("Plate %1%: clear loaded pick_thumbnail %2%.")%(index+1)%plate_data_src[index]->pick_file;
                                                    plate_data_src[index]->pick_file.clear();
                                                }
                                            }
                                        }
                                        continue;
                                    }
 
                                    if (i->print_volume_state == ModelInstancePVS_Partly_Outside)
                                    {
                                        BOOST_LOG_TRIVIAL(error) << "plate "<< index+1<< ": Found Object " << model_object->name <<" partly inside, can not be sliced." << std::endl;
                                        record_exit_reson(outfile_dir, CLI_OBJECTS_PARTLY_INSIDE, index+1, cli_errors[CLI_OBJECTS_PARTLY_INSIDE], sliced_info);
                                        flush_and_exit(CLI_OBJECTS_PARTLY_INSIDE);
                                    }
                                    else if (i->print_volume_state == ModelInstancePVS_Inside)
                                    {
                                        const Transform3d& inst_matrix = i->get_transformation().get_matrix();
 
                                        //get object filaments
                                        std::set<int> object_filaments;
                                        for (const ModelVolume *vol : model_object->volumes) {
                                            std::vector<int> filaments = vol->get_extruders();
                                            object_filaments.insert(filaments.begin(), filaments.end());
                                        }
                                        for (const ModelVolume* vol : model_object->volumes)
                                        {
                                            if (vol->is_model_part()) {
                                                size_t volume_triangle_count = vol->mesh().facets_count();
                                                triangle_count += volume_triangle_count;
                                                BOOST_LOG_TRIVIAL(debug) << boost::format("volume triangle count %1%, total %2%")%volume_triangle_count %triangle_count;
                                                if ((max_triangle_count_per_plate != 0) && (triangle_count > max_triangle_count_per_plate))
                                                {
                                                    BOOST_LOG_TRIVIAL(error) << "plate "<< index+1<< ": triangle count " << triangle_count <<" exceeds the limit:" << max_triangle_count_per_plate;
                                                    record_exit_reson(outfile_dir, CLI_TRIANGLE_COUNT_EXCEEDS_LIMIT, index+1, cli_errors[CLI_TRIANGLE_COUNT_EXCEEDS_LIMIT], sliced_info);
                                                    flush_and_exit(CLI_TRIANGLE_COUNT_EXCEEDS_LIMIT);
                                                }
 
                                                if (new_extruder_count > 1) {
                                                    BoundingBoxf3 bbox = vol->get_convex_hull().transformed_bounding_box(inst_matrix * vol->get_matrix());
                                                    std::vector<bool> inside_extruders;
                                                    BuildVolume::ObjectState state = build_volume.check_volume_bbox_state_with_extruder_areas(bbox, inside_extruders);
                                                    if (state == BuildVolume::ObjectState::Limited) {
                                                        if (object_filaments.size() == 1) {
                                                            // Only check for single-color object
                                                            for (size_t j = 0; j < inside_extruders.size(); ++j) {
                                                                if (!inside_extruders[j]) {
                                                                    std::vector<int> filaments = vol->get_extruders();
                                                                    unprintable_filament_ids[j].insert(filaments.begin(), filaments.end());
                                                                }
                                                            }
                                                        }
                                                    }
 
                                                }
                                            }
                                        }
                                    }
 
                                    if (i->print_volume_state == ModelInstancePVS_Inside)
                                        printable_instances++;
                                }
 
                            if (printable_instances == 0) {
                                BOOST_LOG_TRIVIAL(error) << "plate "<< index+1<< ": Nothing to be sliced, after skipping "<<skipped_count<<" objects."<< std::endl;
                                record_exit_reson(outfile_dir, CLI_NO_SUITABLE_OBJECTS_AFTER_SKIP, index+1, cli_errors[CLI_NO_SUITABLE_OBJECTS_AFTER_SKIP], sliced_info);
                                flush_and_exit(CLI_NO_SUITABLE_OBJECTS_AFTER_SKIP);
                            }
 
                            std::vector<int> plate_filaments = part_plate->get_extruders_under_cli(true, m_print_config);
                            std::vector<int> used_tpu_filaments;
                            for (int f_index = 0; f_index < plate_filaments.size(); f_index++) {
                                if (plate_filaments[f_index] <= filament_count) {
                                    std::string filament_type;
                                    m_print_config.get_filament_type(filament_type, plate_filaments[f_index]-1);
                                    if (filament_type == "TPU") {
                                        used_tpu_filaments.push_back(plate_filaments[f_index]);
                                    }
                                }
                            }
                            bool tpu_valid = part_plate->check_tpu_printable_status(m_print_config, used_tpu_filaments);
                            if (!tpu_valid) {
                                BOOST_LOG_TRIVIAL(error) << boost::format("plate %1% : Found 2 or more tpu filaments on plate ") % (index + 1);
                                record_exit_reson(outfile_dir, CLI_ONLY_ONE_TPU_SUPPORTED, index + 1, cli_errors[CLI_ONLY_ONE_TPU_SUPPORTED], sliced_info);
                                flush_and_exit(CLI_ONLY_ONE_TPU_SUPPORTED);
                            }
 
                            // Same type gate as the GUI's Sidebar::has_broken_mixed_filament: refuse a plate that uses a
                            // mixed slot whose components are different filament types. Missing or out-of-range
                            // components never get here, validate() already rejects them for the whole project.
                            const auto *is_mixed_opt   = m_print_config.option<ConfigOptionBools>("filament_is_mixed");
                            const auto *components_opt = m_print_config.option<ConfigOptionStrings>("filament_mixed_components");
                            if (is_mixed_opt && components_opt && has_any_mixed_filament(is_mixed_opt->values)) {
                                const auto &is_mixed   = is_mixed_opt->values;
                                const auto &components = components_opt->values;
                                const size_t num_physical = static_cast<size_t>(filament_count) - static_cast<size_t>(std::count(is_mixed.begin(), is_mixed.end(), true));
                                std::vector<std::string> physical_types(num_physical);
                                for (size_t f_index = 0; f_index < num_physical; ++f_index) {
                                    std::string displayed_type;
                                    physical_types[f_index] = m_print_config.get_filament_type(displayed_type, static_cast<int>(f_index));
                                    if (physical_types[f_index].empty())
                                        physical_types[f_index] = "PLA";
                                }
                                const std::vector<size_t> mismatched_slots = check_mixed_filament_type_consistency(is_mixed, components, physical_types);
                                // plate_filaments has mixed slots expanded to their components; the gate needs the slots.
                                const std::vector<int> plate_slots = mismatched_slots.empty() ? std::vector<int>() :
                                                                     part_plate->get_extruders_under_cli(true, m_print_config, false);
                                for (size_t slot : mismatched_slots) {
                                    if (std::find(plate_slots.begin(), plate_slots.end(), static_cast<int>(slot) + 1) == plate_slots.end())
                                        continue;
                                    BOOST_LOG_TRIVIAL(error) << boost::format("plate %1%: mixed filament %2% mixes components of different filament types")
                                                                    % (index + 1) % (slot + 1);
                                    record_exit_reson(outfile_dir, CLI_MIXED_FILAMENT_INVALID, index + 1, cli_errors[CLI_MIXED_FILAMENT_INVALID], sliced_info);
                                    flush_and_exit(CLI_MIXED_FILAMENT_INVALID);
                                }
                            }
 
                            if (new_extruder_count > 1) {
                                std::vector<std::vector<int>> unprintable_filament_vec;
                                for (const std::set<int>& filamnt_ids : unprintable_filament_ids) {
                                    unprintable_filament_vec.emplace_back(std::vector<int>(filamnt_ids.begin(), filamnt_ids.end()));
                                }
 
                                FilamentMapMode mode;
                                if (m_extra_config.option<ConfigOptionEnum<FilamentMapMode>>("filament_map_mode"))
                                    mode = m_extra_config.option<ConfigOptionEnum<FilamentMapMode>>("filament_map_mode")->value;
                                else
                                    mode = part_plate->get_real_filament_map_mode(m_print_config);
                                BOOST_LOG_TRIVIAL(info) << boost::format("%1% :filament map mode is %2% ") % __LINE__ %(int)mode;
                                if (mode < FilamentMapMode::fmmManual) {
                                    std::vector<int> conflict_filament_vector;
                                    for (int index = 0; index < new_extruder_count; index++)
                                    {
                                        if (!unprintable_filament_vec[index].empty())
                                        {
                                            std::sort(unprintable_filament_vec[index].begin(), unprintable_filament_vec[index].end());
                                            if (index == 0)
                                                conflict_filament_vector = unprintable_filament_vec[index];
                                            else
                                            {
                                                std::vector<int> result_filaments;
                                                //result_filaments.reserve(conflict_filaments.size());
                                                std::set_intersection(conflict_filament_vector.begin(), conflict_filament_vector.end(), unprintable_filament_vec[index].begin(),
                                                    unprintable_filament_vec[index].end(), std::insert_iterator<std::vector<int>>(result_filaments, result_filaments.begin()));
                                                conflict_filament_vector = result_filaments;
                                            }
                                        }
                                        else
                                        {
                                            conflict_filament_vector.clear();
                                            break;
                                        }
                                    }
                                    //check whether has filament can not map
                                    if (!conflict_filament_vector.empty())
                                    {
                                        BOOST_LOG_TRIVIAL(error) << boost::format("plate %1% : some filaments can not be mapped under auto mode for multi extruder printer ")% (index + 1);
                                        record_exit_reson(outfile_dir, CLI_FILAMENT_CAN_NOT_MAP, index + 1, cli_errors[CLI_FILAMENT_CAN_NOT_MAP], sliced_info);
                                        flush_and_exit(CLI_FILAMENT_CAN_NOT_MAP);
                                    }
                                }
                                else {
                                    std::vector<int> filament_maps;
                                    if (m_extra_config.option<ConfigOptionInts>("filament_map")) {
                                        filament_maps = m_extra_config.option<ConfigOptionInts>("filament_map")->values;
                                        int default_value = -1;
                                        bool has_invalid_value = false;
                                        for (int f_index = 0; f_index < filament_maps.size(); f_index++)
                                        {
                                            if (filament_maps[f_index] != -1)
                                            {
                                                if (default_value == -1)
                                                    default_value = filament_maps[f_index];
                                                else
                                                    continue;
                                            }
                                            else
                                                has_invalid_value = true;
 
                                            if (has_invalid_value && (default_value != -1))
                                                break;
                                        }
                                        BOOST_LOG_TRIVIAL(info) << boost::format("%1% :filament map default_value %2%, has_invalid_value %3% ") % __LINE__ %default_value %has_invalid_value;
 
                                        if (has_invalid_value)
                                        {
                                            for (int f_index = 0; f_index < filament_maps.size(); f_index++)
                                            {
                                                if (filament_maps[f_index] == -1)
                                                {
                                                    if (default_value != -1) {
                                                        filament_maps[f_index] = default_value;
                                                        BOOST_LOG_TRIVIAL(info) << boost::format("plate %1% : set filament_map of filament %2% to first value %3%.")% (index + 1) %(f_index+1) %default_value;
                                                    }
                                                    else {
                                                        filament_maps[f_index] = 1;
                                                        BOOST_LOG_TRIVIAL(info) << boost::format("plate %1% : set filament_map of filament %2% to default value 1.")% (index + 1) %(f_index+1);
                                                    }
                                                }
                                            }
                                            m_extra_config.option<ConfigOptionInts>("filament_map")->values = filament_maps;
                                        }
                                        part_plate->set_filament_maps(filament_maps);
                                    }
                                    else
                                        filament_maps = part_plate->get_real_filament_maps(m_print_config);
 
                                    // Multi-nozzle printers need the per-filament volume assignment as a grouping
                                    // input in the manual modes: synthesize it from the per-extruder flow types when
                                    // the caller did not provide one (an extruder whose nozzle stats span several
                                    // volume types keeps the per-filament choice), and require explicit maps in
                                    // nozzle-manual mode.
                                    auto max_nozzle_counts_opt = m_print_config.option<ConfigOptionIntsNullable>("extruder_max_nozzle_count");
                                    // Skip nil entries: a nullable-int nil is INT_MAX (> 1) and would otherwise falsely pass the gate.
                                    bool support_multi_nozzle =
                                        max_nozzle_counts_opt &&
                                        std::any_of(max_nozzle_counts_opt->values.begin(), max_nozzle_counts_opt->values.end(),
                                                    [](int v) { return v > 1 && v != ConfigOptionIntsNullable::nil_value(); });
                                    if (support_multi_nozzle && (mode == fmmManual || mode == fmmNozzleManual) && (plate_to_slice != 0)) {
                                        // Orca: the grouping result is reconstructed purely from the passed maps in
                                        // nozzle-manual mode, so all of them must be present (there are no separate
                                        // per-nozzle CLI parameters to rebuild them from).
                                        if (mode == FilamentMapMode::fmmNozzleManual &&
                                            (!m_extra_config.has("filament_volume_map") || !m_extra_config.has("filament_nozzle_map") ||
                                             !m_extra_config.has("filament_map"))) {
                                            BOOST_LOG_TRIVIAL(error)
                                                << boost::format("%1%, can not find filament_volume_map/filament_nozzle_map/filament_map under Nozzle Manual mode") % __LINE__;
                                            record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, index + 1, cli_errors[CLI_INVALID_PARAMS], sliced_info);
                                            flush_and_exit(CLI_INVALID_PARAMS);
                                        }
 
                                        if (mode == fmmManual) {
                                            // Build the volume map when absent: filaments on a single-volume extruder
                                            // print with that extruder's volume; a mixed-volume extruder keeps the
                                            // per-filament choice (default Standard).
                                            std::vector<NozzleVolumeType> using_nozzle_volume_type = new_nozzle_volume_type;
                                            using_nozzle_volume_type.resize(new_extruder_count, nvtStandard);
                                            if (auto extruder_nozzle_stats_opt = m_print_config.option<ConfigOptionStrings>("extruder_nozzle_stats")) {
                                                auto nozzle_stats = get_extruder_nozzle_stats(extruder_nozzle_stats_opt->values);
                                                for (int e_index = 0; e_index < new_extruder_count && e_index < (int) nozzle_stats.size(); e_index++) {
                                                    if (nozzle_stats[e_index].size() > 1) {
                                                        using_nozzle_volume_type[e_index] = nvtHybrid;
                                                        BOOST_LOG_TRIVIAL(info) << boost::format("%1% : extruder %2%, set nozzle_volume_type to hybrid ") % __LINE__ % (e_index + 1);
                                                    }
                                                }
                                            }
                                            std::vector<int> &manual_volume_maps = m_extra_config.option<ConfigOptionInts>("filament_volume_map", true)->values;
                                            // default to standard flow
                                            manual_volume_maps.resize(filament_count, (int) (nvtStandard));
                                            for (int f_index = 0; f_index < filament_count && f_index < (int) filament_maps.size(); f_index++) {
                                                int f_extruder_index = filament_maps[f_index] - 1;
                                                if (f_extruder_index >= 0 && f_extruder_index < new_extruder_count &&
                                                    using_nozzle_volume_type[f_extruder_index] != nvtHybrid) {
                                                    manual_volume_maps[f_index] = int(using_nozzle_volume_type[f_extruder_index]);
                                                    BOOST_LOG_TRIVIAL(info) << boost::format("%1% : filament %2% extruder %3%, set filament_volume_map to %4% ") % __LINE__ % (f_index + 1) % (f_extruder_index + 1) % manual_volume_maps[f_index];
                                                }
                                            }
                                        }
 
                                        if (m_extra_config.has("filament_volume_map")) {
                                            part_plate->set_filament_volume_maps(m_extra_config.option<ConfigOptionInts>("filament_volume_map")->values);
                                        }
                                        if (m_extra_config.has("filament_nozzle_map")) {
                                            part_plate->set_filament_nozzle_maps(m_extra_config.option<ConfigOptionInts>("filament_nozzle_map")->values);
                                        }
                                    }
                                    else if (!support_multi_nozzle && (mode == fmmNozzleManual)) {
                                        BOOST_LOG_TRIVIAL(error)
                                            << boost::format("%1%, Nozzle Manual mode not supported for %2%") % __LINE__ % new_printer_name;
                                        record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, index + 1, cli_errors[CLI_INVALID_PARAMS], sliced_info);
                                        flush_and_exit(CLI_INVALID_PARAMS);
                                    }
 
                                    for (int index = 0; index < filament_maps.size(); index++)
                                    {
                                        int filament_extruder = filament_maps[index];
                                        if (unprintable_filament_ids[filament_extruder - 1].find(index + 1) != unprintable_filament_ids[filament_extruder - 1].end())
                                        {
                                            BOOST_LOG_TRIVIAL(error) << boost::format("plate %1% : some filaments can not be mapped under manual mode for multi extruder printer ") % (index + 1);
                                            record_exit_reson(outfile_dir, CLI_FILAMENT_CAN_NOT_MAP, index + 1, cli_errors[CLI_FILAMENT_CAN_NOT_MAP], sliced_info);
                                            flush_and_exit(CLI_FILAMENT_CAN_NOT_MAP);
                                        }
                                    }
 
                                    for (int f_index = 0; f_index < plate_filaments.size(); f_index++) {
                                        for (int f_index = 0; f_index < plate_filaments.size(); f_index++) {
                                            if (plate_filaments[f_index] <= filament_count) {
                                                int filament_extruder = filament_maps[plate_filaments[f_index] - 1];
                                                std::string filament_type;
                                                m_print_config.get_filament_type(filament_type, plate_filaments[f_index] - 1);
                                                auto *filament_printable_status = dynamic_cast<const ConfigOptionInts *>(m_print_config.option("filament_printable"));
                                                if (filament_printable_status && (filament_printable_status->values.size() >= plate_filaments[f_index])) {
                                                    int status = filament_printable_status->values.at(plate_filaments[f_index] - 1);
                                                    if (!(status >> (filament_extruder - 1) & 1)) {
                                                        BOOST_LOG_TRIVIAL(error)
                                                            << boost::format(
                                                                   "plate %1% : filament %2% can not be printed on extruder %3%, under manual mode for multi extruder printer") %
                                                                   (index + 1) % filament_type % filament_extruder;
                                                        record_exit_reson(outfile_dir, CLI_FILAMENTS_NOT_SUPPORTED_BY_EXTRUDER, index + 1,
                                                                          cli_errors[CLI_FILAMENTS_NOT_SUPPORTED_BY_EXTRUDER], sliced_info);
                                                        flush_and_exit(CLI_FILAMENTS_NOT_SUPPORTED_BY_EXTRUDER);
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
 
                            plate_triangle_counts[index] = triangle_count;
                            plate_object_count[index] = printable_instances;
                            BOOST_LOG_TRIVIAL(info) << "plate "<< index+1<< ": load cached data success, go on.";
                        }
                        // BBS: TODO
                        //BOOST_LOG_TRIVIAL(info) << boost::format("print_volume {%1%,%2%,%3%}->{%4%, %5%, %6%}, has %7% printables") % print_volume.min(0) % print_volume.min(1)
                        //    % print_volume.min(2) % print_volume.max(0) % print_volume.max(1) % print_volume.max(2) % count << std::endl;
#endif
                        DynamicPrintConfig new_print_config = m_print_config;
                        new_print_config.apply(*part_plate->config());
                        new_print_config.apply(m_extra_config, true);
            if (m_print_config.option<ConfigOptionFloat>("layer_height"))
                            sliced_info.layer_height = m_print_config.option<ConfigOptionFloat>("layer_height")->value;
            if (m_print_config.option<ConfigOptionInt>("wall_loops"))
                            sliced_info.wall_loops = m_print_config.option<ConfigOptionInt>("wall_loops")->value;
                        if (m_print_config.option<ConfigOptionPercent>("sparse_infill_density"))
                            sliced_info.sparse_infill_density = m_print_config.option<ConfigOptionPercent>("sparse_infill_density")->value;
                        if (new_extruder_count > 1) {
                            FilamentMapMode map_mode = fmmAutoForFlush;
                            if (new_print_config.option<ConfigOptionEnum<FilamentMapMode>>("filament_map_mode"))
                                map_mode = new_print_config.option<ConfigOptionEnum<FilamentMapMode>>("filament_map_mode")->value;
 
                            if (map_mode < fmmManual) {
                                //set default params for auto map
                                std::vector<std::string> extruder_ams_count(new_extruder_count, "");
                                std::vector<std::vector<DynamicPrintConfig>> extruder_filament_info(new_extruder_count, std::vector<DynamicPrintConfig>());
                                int color_count = 0;
 
                                const ConfigOptionStrings* filament_type  = dynamic_cast<const ConfigOptionStrings *>(m_print_config.option("filament_type"));
                                std::vector<std::string> types = filament_type ? filament_type->vserialize() : std::vector<std::string>{"PLA"};
 
                                for (int e_index = 0; e_index < new_extruder_count; e_index++)
                                {
                                    extruder_ams_count[e_index] = "1#0|4#1";
                                    for (int color_index = 0; color_index < 4; color_index++)
                                    {
                                        DynamicPrintConfig temp_config;
                                        std::vector<std::string> temp_colors(1, "#FFFFFFFF");
                                        std::vector<std::string> temp_types(1, "PLA");
                                        //if (filament_color) {
                                        //    temp_colors[0] = colors[color_count % colors.size()];
                                        //}
                                        if (filament_type)
                                            temp_types[0]  = types[color_count % types.size()];
 
                                        temp_config.option<ConfigOptionStrings>("filament_colour", true)->values = temp_colors;
                                        temp_config.option<ConfigOptionStrings>("filament_type", true)->values = temp_types;
                                        temp_config.option<ConfigOptionBools>("filament_is_support",true)->values = { 0 };
                                        extruder_filament_info[e_index].push_back(std::move(temp_config));
                                        color_count++;
                                    }
                                }
                                new_print_config.option<ConfigOptionStrings>("extruder_ams_count", true)->values = extruder_ams_count;
                                print_fff->set_extruder_filament_info(extruder_filament_info);
                            }
                        }
 
                        //set filament_map
                        std::vector<int>& final_filament_maps = new_print_config.option<ConfigOptionInts>("filament_map", true)->values;
                        if (final_filament_maps.size() < filament_count)
                            final_filament_maps.resize(filament_count, 1);
                        if (new_extruder_count == 1) {
                            for (int index = 0; index < filament_count; index++)
                                final_filament_maps[index] = 1;
                        }
                        if(!new_print_config.has("nozzle_volume_type")) {
                            //set default nozzle_volume_type
                            ConfigOptionEnumsGeneric* final_nozzle_volume_type_opt = new_print_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type", true);
                            final_nozzle_volume_type_opt->values.resize(new_extruder_count, nvtStandard);
                        }
                        print->apply(model, new_print_config);
                        BOOST_LOG_TRIVIAL(info) << boost::format("set no_check to %1%:")%no_check;
                        print->set_no_check_flag(no_check);//BBS
 
                        // Set is_BBL_printer flag before validation as the validation depends on it.
                        std::string& printer_model_string = new_print_config.opt_string("printer_model", true);
                        bool is_bbl_vendor_preset = false;
 
                        if (!printer_model_string.empty()) {
                            is_bbl_vendor_preset = (printer_model_string.compare(0, 9, "Bambu Lab") == 0);
                            BOOST_LOG_TRIVIAL(info) << boost::format("printer_model_string: %1%, is_bbl_vendor_preset %2%")%printer_model_string %is_bbl_vendor_preset;
                        }
                        else {
                            if (!new_printer_name.empty())
                                is_bbl_vendor_preset = (new_printer_name.compare(0, 9, "Bambu Lab") == 0);
                            else if (!current_printer_system_name.empty())
                                is_bbl_vendor_preset = (current_printer_system_name.compare(0, 9, "Bambu Lab") == 0);
                            BOOST_LOG_TRIVIAL(info) << boost::format("new_printer_name: %1%, current_printer_system_name %2%, is_bbl_vendor_preset %3%")%new_printer_name %current_printer_system_name %is_bbl_vendor_preset;
                        }
                        (dynamic_cast<Print*>(print))->is_BBL_printer() = is_bbl_vendor_preset;
 
                        std::vector<StringObjectException> warnings;
                        print_fff->set_check_multi_filaments_compatibility(!allow_mix_temp);
                        auto err = print->validate(&warnings);
                        if (!err.string.empty()) {
                            if ((STRING_EXCEPT_LAYER_HEIGHT_EXCEEDS_LIMIT == err.type) && no_check) {
                                BOOST_LOG_TRIVIAL(warning) << "got warnings: "<< err.string << std::endl;
                            }
                            else {
                                BOOST_LOG_TRIVIAL(error) << "got error when validate: "<< err.string << std::endl;
                                boost::nowide::cerr << err.string << std::endl;
                                int validate_error;
                                switch (err.type)
                                {
                                    case STRING_EXCEPT_FILAMENT_NOT_MATCH_BED_TYPE:
                                        validate_error = CLI_FILAMENT_NOT_MATCH_BED_TYPE;
                                        break;
                                    case STRING_EXCEPT_FILAMENTS_DIFFERENT_TEMP:
                                        validate_error = CLI_FILAMENTS_DIFFERENT_TEMP;
                                        break;
                                    case STRING_EXCEPT_OBJECT_COLLISION_IN_SEQ_PRINT:
                                        validate_error = CLI_OBJECT_COLLISION_IN_SEQ_PRINT;
                                        break;
                                    case STRING_EXCEPT_OBJECT_COLLISION_IN_LAYER_PRINT:
                                        validate_error = CLI_OBJECT_COLLISION_IN_LAYER_PRINT;
                                        break;
                                    default:
                                        validate_error = CLI_VALIDATE_ERROR;
                                        break;
                                }
                                if (no_check)
                                    record_exit_reson(outfile_dir, validate_error, index+1, err.string, sliced_info);
                                else
                                    record_exit_reson(outfile_dir, validate_error, index+1, cli_errors[validate_error], sliced_info);
                                flush_and_exit(validate_error);
                            }
                        }
                        else if (!warnings.empty()) {
                            for (const auto& w : warnings)
                                BOOST_LOG_TRIVIAL(warning) << "got warnings: "<< w.string << std::endl;
                        }
 
                        if (print->empty()) {
                            BOOST_LOG_TRIVIAL(error) << "plate "<< index+1<< ": Nothing to be sliced, Either the print is empty or no object is fully inside the print volume after apply." << std::endl;
                            record_exit_reson(outfile_dir, CLI_NO_SUITABLE_OBJECTS, index+1, cli_errors[CLI_NO_SUITABLE_OBJECTS], sliced_info);
                            flush_and_exit(CLI_NO_SUITABLE_OBJECTS);
                        }
                        else {
                            if (pre_check && (partplate_list.get_plate_count() > 1)) //continue to next plate directly
                                continue;
                            try {
                                std::string outfile_final;
                                BOOST_LOG_TRIVIAL(info) << "start Print::process for partplate "<<index+1 << std::endl;
#if defined(__linux__) || defined(__LINUX__)
                                BOOST_LOG_TRIVIAL(info) << "cli callback mgr started:  "<<g_cli_callback_mgr.m_started << std::endl;
                                if (g_cli_callback_mgr.is_started()) {
                                    BOOST_LOG_TRIVIAL(info) << "set print's callback to cli_status_callback.";
                                    print->set_status_callback(cli_status_callback);
                                    g_cli_callback_mgr.set_plate_info(index+1, (plate_to_slice== 0)?partplate_list.get_plate_count():1);
                                    if (!warnings.empty()) {
                                        std::string warning_text;
                                        for (const auto& w : warnings) {
                                            if (!warning_text.empty())
                                                warning_text += "\n";
                                            warning_text += w.string;
                                        }
                                        PrintBase::SlicingStatus slicing_status{4, warning_text, 0, 0};
                                        cli_status_callback(slicing_status);
                                    }
                                    else {
                                        PrintBase::SlicingStatus slicing_status{4, "Slicing begins"};
                                        cli_status_callback(slicing_status);
                                    }
                                }
                                else {
                                    BOOST_LOG_TRIVIAL(info) << "set print's callback to default_status_callback.";
                                    print->set_status_callback(default_status_callback);
                                }
#else
                                BOOST_LOG_TRIVIAL(info) << "set print's callback to default_status_callback.";
                                print->set_status_callback(default_status_callback);
#endif
 
                                //update information for brim
                                const PrintConfig& print_config = print_fff->config();
                                Model::setExtruderParams(m_print_config, filament_count);
                                Model::setPrintSpeedTable(m_print_config, print_config);
                                if (load_slicedata) {
                                    std::string plate_dir = load_slice_data_dir+"/"+std::to_string(index+1);
                                    int ret = print->load_cached_data(plate_dir);
                                    if (ret) {
                                        BOOST_LOG_TRIVIAL(warning) << "plate "<< index+1<< ": load Slicing data error, ret=" << ret;
                                        BOOST_LOG_TRIVIAL(warning) << "plate "<< index+1<< ": switch normal slicing";
                                        print->process();
                                    }
                                    else {
                                        BOOST_LOG_TRIVIAL(info) << "plate "<< index+1<< ": load cached data success, go on.";
#if defined(__linux__) || defined(__LINUX__)
                                        if (g_cli_callback_mgr.is_started()) {
                                            PrintBase::SlicingStatus slicing_status{69, "Cache data loaded"};
                                            cli_status_callback(slicing_status);
                                        }
#endif
                                        print->process(nullptr, true);
                                        BOOST_LOG_TRIVIAL(info) << "plate "<< index+1<< ": finished print::process.";
                                    }
                                }
                                else {
                                    print->process(&time_using_cache);
                                    BOOST_LOG_TRIVIAL(info) << "print::process: first time_using_cache is " << time_using_cache << " secs.";
                                }
                                if (printer_technology == ptFFF) {
                                    // Read the engine's final grouping back onto the plate so an exported
                                    // project (--export-3mf / gcode.3mf) carries the concrete maps in its
                                    // plate settings, matching what a GUI slice persists.
                                    // Orca: deliberately gated to multi-extruder printers so single-extruder
                                    // exports keep their plate settings unchanged.
                                    if (new_extruder_count > 1) {
                                        FilamentMapMode current_map_mode = print_fff->config().filament_map_mode.value;
                                        if (is_auto_filament_map_mode(current_map_mode)) {
                                            part_plate->set_filament_maps(print_fff->get_filament_maps());
                                            part_plate->set_filament_volume_maps(print_fff->get_filament_volume_maps());
                                        }
                                        if (current_map_mode != FilamentMapMode::fmmNozzleManual) {
                                            part_plate->set_filament_nozzle_maps(print_fff->get_filament_nozzle_maps());
                                        }
                                    }
 
                                    std::string conflict_result = print_fff->get_conflict_string();
                                    if (!conflict_result.empty()) {
                                       BOOST_LOG_TRIVIAL(error) << "plate "<< index+1<< ": found slicing result conflict!"<< std::endl;
                                       record_exit_reson(outfile_dir, CLI_GCODE_PATH_CONFLICTS, index+1, cli_errors[CLI_GCODE_PATH_CONFLICTS], sliced_info);
                                       flush_and_exit(CLI_GCODE_PATH_CONFLICTS);
                                    }
 
                                    //check the warnings
                                    if (!g_slicing_warnings.empty())
                                    {
                                        for (unsigned int i = 0; i < g_slicing_warnings.size(); i++)
                                        {
                                            PrintBase::SlicingStatus& status = g_slicing_warnings[i];
                                            if ((status.warning_step != -1) && (status.message_type != PrintStateBase::SlicingDefaultNotification))
                                            {
                                                sliced_plate_info.warning_message = status.text;
 
                                                if (status.warning_level == PrintStateBase::WarningLevel::NON_CRITICAL) {
                                                    BOOST_LOG_TRIVIAL(warning) << "plate "<< index+1<< ": found NON_CRITICAL slicing warnings: "<<status.text <<std::endl;
                                                    // Always record for AI/CI consumers; under --strict, elevate to a
                                                    // non-zero exit so scripted pipelines don't ship a "warning OK" slice.
                                                    cli_record_warning(sliced_info, "slicing_warning_non_critical",
                                                                       nlohmann::json{{"plate_id", index+1}, {"text", status.text}});
                                                    if (sliced_info.strict_mode) {
                                                        sliced_info.sliced_plates.push_back(sliced_plate_info);
                                                        record_exit_reson(outfile_dir, CLI_SLICING_ERROR, index+1, cli_errors[CLI_SLICING_ERROR], sliced_info);
                                                        flush_and_exit(CLI_SLICING_ERROR);
                                                    }
                                                }
                                                else {
                                                    BOOST_LOG_TRIVIAL(warning) << boost::format("plate %1%: found slicing warnings: %2%, no_check=%3%")%(index+1) %status.text %no_check;
                                                    if (!no_check) {
                                                        //only following message will be reported under import mode
                                                        if (status.message_type == PrintStateBase::SlicingEmptyGcodeLayers
                                                            || status.message_type == PrintStateBase::SlicingGcodeOverlap)
                                                        {
                                                            sliced_info.sliced_plates.push_back(sliced_plate_info);
                                                            record_exit_reson(outfile_dir, CLI_SLICING_ERROR, index+1, cli_errors[CLI_SLICING_ERROR], sliced_info);
                                                            flush_and_exit(CLI_SLICING_ERROR);
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        g_slicing_warnings.clear();
                                    }
                                    sliced_plate_info.triangle_count = plate_triangle_counts[index];
 
                                    // The outfile is processed by a PlaceholderParser.
                                    //outfile = part_plate->get_tmp_gcode_path();
                                    if (outfile_dir.empty()) {
                                        outfile = part_plate->get_tmp_gcode_path();
                                    }
                                    else {
                                        outfile = outfile_dir + "/plate_" + std::to_string(index + 1) + ".gcode";
                                        part_plate->set_tmp_gcode_path(outfile);
                                    }
                                    BOOST_LOG_TRIVIAL(info) << "process finished, will export gcode temporarily to " << outfile << std::endl;
                                    temp_time = (long long)Slic3r::Utils::get_current_time_utc();
                                    outfile = print_fff->export_gcode(outfile, gcode_result, nullptr);
                                    time_using_cache = time_using_cache + ((long long)Slic3r::Utils::get_current_time_utc() - temp_time);
                                    BOOST_LOG_TRIVIAL(info) << "export_gcode finished: time_using_cache update to " << time_using_cache << " secs.";
                                    if (gcode_result && gcode_result->gcode_check_result.error_code) {
                                        //found gcode error
                                        if ((gcode_result->gcode_check_result.error_code & 0b11100)>0)
                                            BOOST_LOG_TRIVIAL(error) << "plate " << index + 1 << ": found gcode in unprintable area of the printers! gcode_result->gcode_check_result.error_code = "
                                                << gcode_result->gcode_check_result.error_code << std::endl;
                                        else
                                            BOOST_LOG_TRIVIAL(error) << "plate " << index + 1 << ": found gcode in unprintable area of multi extruder printers! gcode_result->gcode_check_result.error_code = "
                                                << gcode_result->gcode_check_result.error_code << std::endl;
                                        record_exit_reson(outfile_dir, CLI_GCODE_PATH_IN_UNPRINTABLE_AREA, index + 1, cli_errors[CLI_GCODE_PATH_IN_UNPRINTABLE_AREA], sliced_info);
                                        flush_and_exit(CLI_GCODE_PATH_IN_UNPRINTABLE_AREA);
                                    }
                                    // Without an output directory the G-code is a temporary file, kept only in an exported 3MF.
                                    if (export_statistics && !outfile_dir.empty()) {
                                        try {
                                            export_gcode_statistics(*gcode_result, gcode_statistics_path(outfile));
                                        } catch (const std::exception &ex) {
                                            BOOST_LOG_TRIVIAL(error) << "plate " << index + 1 << ": " << ex.what();
                                            record_exit_reson(outfile_dir, CLI_EXPORT_STATISTICS_ERROR, index + 1, cli_errors[CLI_EXPORT_STATISTICS_ERROR], sliced_info);
                                            flush_and_exit(CLI_EXPORT_STATISTICS_ERROR);
                                        }
                                    }
 
 
                                    //outfile_final = (dynamic_cast<Print*>(print))->print_statistics().finalize_output_path(outfile);
                                    //m_fff_print->export_gcode(m_temp_output_path, m_gcode_result, [this](const ThumbnailsParams& params) { return this->render_thumbnails(params); });
                                }/* else {
                                    outfile = sla_print.output_filepath(outfile);
                                    // We need to finalize the filename beforehand because the export function sets the filename inside the zip metadata
                                    outfile_final = sla_print.print_statistics().finalize_output_path(outfile);
                                    sla_archive.export_print(outfile_final, sla_print);
                                }*/
                                /*if (outfile != outfile_final) {
                                    if (Slic3r::rename_file(outfile, outfile_final)) {
                                        boost::nowide::cerr << "Renaming file " << outfile << " to " << outfile_final << " failed" << std::endl;
                                        record_exit_reson(outfile_dir, 1, index+1, cli_errors[1], sliced_info);
                                        flush_and_exit(1);
                                    }
                                    outfile = outfile_final;
                                }*/
                                // Run the post-processing scripts if defined.
                                //run_post_process_scripts(outfile, print->full_print_config());
                                BOOST_LOG_TRIVIAL(info) << "Slicing result exported to " << outfile << std::endl;
                                part_plate->update_slice_result_valid_state(true);
#if defined(__linux__) || defined(__LINUX__)
                                if (g_cli_callback_mgr.is_started()) {
                                    PrintBase::SlicingStatus slicing_status{100, "Slicing finished"};
                                    cli_status_callback(slicing_status);
                                }
#endif
                                if (export_slicedata) {
                                    BOOST_LOG_TRIVIAL(info) << "plate "<< index+1<< ":will export Slicing data to " << export_slice_data_dir;
                                    std::string plate_dir = export_slice_data_dir+"/"+std::to_string(index+1);
                                    bool with_space = (get_logging_level() >= 4)?true:false;
                                    int ret = print->export_cached_data(plate_dir, with_space);
                                    if (ret) {
                                        BOOST_LOG_TRIVIAL(error) << "plate "<< index+1<< ": export Slicing data error, ret=" << ret;
                                        export_slicedata_error = true;
                                        if (fs::exists(plate_dir))
                                            fs::remove_all(plate_dir);
                                        record_exit_reson(outfile_dir, ret, index+1, cli_errors[ret], sliced_info);
                                        flush_and_exit(ret);
                                    }
                                }
                                end_time = (long long)Slic3r::Utils::get_current_time_utc();
                                sliced_plate_info.sliced_time = end_time - start_time;
                                sliced_plate_info.sliced_time_with_cache = time_using_cache;
 
                                if (max_slicing_time_per_plate != 0) {
                                    long long time_cost = end_time - start_time;
                                    if (time_cost > max_slicing_time_per_plate) {
                                        sliced_plate_info.warning_message = (boost::format("plate %1%'s slice time %2% exceeds the limit %3%, return error.")%(index+1) %time_cost %max_slicing_time_per_plate).str();
                                        BOOST_LOG_TRIVIAL(error) << sliced_plate_info.warning_message;
                                        sliced_info.sliced_plates.push_back(sliced_plate_info);
                                        record_exit_reson(outfile_dir, CLI_SLICING_TIME_EXCEEDS_LIMIT, index+1, cli_errors[CLI_SLICING_TIME_EXCEEDS_LIMIT], sliced_info);
                                        flush_and_exit(CLI_SLICING_TIME_EXCEEDS_LIMIT);
                                    }
                                }
                                sliced_info.sliced_plates.push_back(sliced_plate_info);
                            } catch (const Slic3r::SlicingErrors &exs) {
                                const std::string message = print_fff ? print_fff->slicing_errors_message(exs) : std::string(exs.what());
                                BOOST_LOG_TRIVIAL(error) << "found slicing or export error for partplate " << index+1 << ": " << message;
                                boost::nowide::cerr << message << std::endl;
                                record_exit_reson(outfile_dir, CLI_SLICING_ERROR, index+1, message, sliced_info);
                                flush_and_exit(CLI_SLICING_ERROR);
                            } catch (const std::exception &ex) {
                                BOOST_LOG_TRIVIAL(error) << "found slicing or export error for partplate "<<index+1 << std::endl;
                                boost::nowide::cerr << ex.what() << std::endl;
                                //continue;
                                record_exit_reson(outfile_dir, CLI_SLICING_ERROR, index+1, cli_errors[CLI_SLICING_ERROR], sliced_info);
                                flush_and_exit(CLI_SLICING_ERROR);
                            }
                        }
                    }
                    if (pre_check&& (partplate_list.get_plate_count() > 1))
                        pre_check = false;
                    else
                        finished = true;
                }//end for partplate
 
#if defined(__linux__) || defined(__LINUX__)
                if (g_cli_callback_mgr.is_started()) {
                    int plate_count = (plate_to_slice== 0)?partplate_list.get_plate_count():1;
                    g_cli_callback_mgr.set_plate_info(0, plate_count);
                }
#endif
/*
                print.center = ! m_config.has("center")
                    && ! m_config.has("align_xy")
                    && ! m_config.opt_bool("dont_arrange");
                print.set_model(model);
 
                // start chronometer
                typedef std::chrono::high_resolution_clock clock_;
                typedef std::chrono::duration<double, std::ratio<1> > second_;
                std::chrono::time_point<clock_> t0{ clock_::now() };
 
                const std::string outfile = this->output_filepath(model, IO::Gcode);
                try {
                    print.export_gcode(outfile);
                } catch (std::runtime_error &e) {
                    boost::nowide::cerr << e.what() << std::endl;
                    return 1;
                }
                BOOST_LOG_TRIVIAL(info) << "G-code exported to " << outfile << std::endl;
 
                // output some statistics
                double duration { std::chrono::duration_cast<second_>(clock_::now() - t0).count() };
                BOOST_LOG_TRIVIAL(info) << std::fixed << std::setprecision(0)
                    << "Done. Process took " << (duration/60) << " minutes and "
                    << std::setprecision(3)
                    << std::fmod(duration, 60.0) << " seconds." << std::endl
                    << std::setprecision(2)
                    << "Filament required: " << print.total_used_filament() << "mm"
                    << " (" << print.total_extruded_volume()/1000 << "cm3)" << std::endl;
*/
            }
        } else {
            boost::nowide::cerr << "error: option not supported yet: " << opt_key << std::endl;
            record_exit_reson(outfile_dir, CLI_UNSUPPORTED_OPERATION, 0, cli_errors[CLI_UNSUPPORTED_OPERATION], sliced_info);
            flush_and_exit(CLI_UNSUPPORTED_OPERATION);
        }
    }
 
    global_begin_time = (long long)Slic3r::Utils::get_current_time_utc();
    if (export_to_3mf) {
        //BBS: export as bbl 3mf
        std::vector<ThumbnailData *> thumbnails, no_light_thumbnails, top_thumbnails, pick_thumbnails;
        std::vector<PlateBBoxData*> plate_bboxes;
        PlateDataPtrs plate_data_list;
        partplate_list.store_to_3mf_structure(plate_data_list, true, -1, export_statistics);
 
        if (sliced_plate == -1) {
            for (int i = 0; i < plate_data_list.size(); i++) {
                Slic3r::GUI::PartPlate *part_plate      = partplate_list.get_plate(i);
                plate_object_count[i] = part_plate->printable_instance_size();
            }
        }
        else if (sliced_plate == 0){
            //slicing all
            for (int i = 0; i < plate_data_list.size(); i++) {
                if (skip_useless_pick && (plate_object_count[i] == 1)) {
                    BOOST_LOG_TRIVIAL(info) << boost::format("only has 1 object,  set plate %1%'s is_label_object_enabled from %2% to false")%(i+1) % (plate_data_list[i]->is_label_object_enabled);
                    plate_data_list[i]->is_label_object_enabled = false;
                }
            }
        }
        else {
            if (skip_useless_pick && (plate_object_count[sliced_plate - 1] == 1)) {
                BOOST_LOG_TRIVIAL(info) << boost::format("only has 1 object,  set plate %1%'s is_label_object_enabled from %2% to false")%sliced_plate % (plate_data_list[sliced_plate - 1]->is_label_object_enabled);
                plate_data_list[sliced_plate - 1]->is_label_object_enabled = false;
            }
        }
 
        if (!outfile_dir.empty()) {
            export_3mf_file = outfile_dir + "/"+export_3mf_file;
        }
 
#if defined(__linux__) || defined(__LINUX__)
        if (g_cli_callback_mgr.is_started()) {
            PrintBase::SlicingStatus slicing_status{94, "Generate thumbnails"};
            cli_status_callback(slicing_status);
        }
#endif
 
        bool need_regenerate_thumbnail = oriented_or_arranged || regenerate_thumbnails;
        bool need_regenerate_no_light_thumbnail = oriented_or_arranged || regenerate_thumbnails;
        bool need_regenerate_top_thumbnail = oriented_or_arranged || regenerate_thumbnails;
        bool need_create_thumbnail_group = false, need_create_no_light_group = false, need_create_top_group = false;
 
        // get type and color for platedata
        const ConfigOptionStrings* filament_color = dynamic_cast<const ConfigOptionStrings *>(m_print_config.option("filament_colour"));
        auto* filament_id = dynamic_cast<const ConfigOptionStrings*>(m_print_config.option("filament_ids"));
        const ConfigOptionFloats* nozzle_diameter_option = dynamic_cast<const ConfigOptionFloats *>(m_print_config.option("nozzle_diameter"));
        std::string nozzle_diameter_str;
        if (nozzle_diameter_option)
            nozzle_diameter_str = nozzle_diameter_option->serialize();
#ifdef SLIC3R_GUI
        // A Bambu printer reads slice_info.config and knows only its own catalog ids. The GUI
        // gates the same translation on PresetBundle::is_bbl_vendor(); the CLI has no
        // PresetBundle, so reuse the printer_model prefix that already decides
        // Print::is_BBL_printer() for this same run.
        auto* printer_model_option = dynamic_cast<const ConfigOptionString*>(m_print_config.option("printer_model"));
        const bool is_bbl_printer = printer_model_option && printer_model_option->value.compare(0, 9, "Bambu Lab") == 0;
        // No wxApp on the CLI path, so there is no live agent to ask; the translator is stateless
        // over a lazily loaded map, so one instance serves every plate and filament below.
        // ORCA TODO: this assumes Bambu's is the only agent with a catalog of its own. Once another
        // agent carries one, resolve the agent from the selected printer the way
        // GUI_App::resolve_printer_agent_id does, rather than hard-coding BBLPrinterAgent here.
        const BBLPrinterAgent bbl_agent;
#endif /* SLIC3R_GUI */
 
        for (int i = 0; i < plate_data_list.size(); i++) {
            PlateData *plate_data = plate_data_list[i];
            bool skip_this_plate = ((plate_to_slice != 0) && (plate_to_slice != (i + 1)))?true:false;
 
            plate_data->skipped_objects = plate_skipped_objects[i];
            if (!printer_model_id.empty())
                plate_data->printer_model_id = printer_model_id;
            if (!nozzle_diameter_str.empty())
                plate_data->nozzle_diameters = nozzle_diameter_str;
 
            for (auto it = plate_data->slice_filaments_info.begin(); it != plate_data->slice_filaments_info.end(); it++) {
                // get_at() on an empty vector option is UB - these can be unpopulated on a from-scratch slice
                std::string display_filament_type;
                it->type  = m_print_config.get_filament_type(display_filament_type, it->id);
                it->color = (filament_color && !filament_color->values.empty()) ? filament_color->get_at(it->id) : "#FFFFFF";
                it->filament_id = (filament_id && !filament_id->values.empty()) ? filament_id->get_at(it->id) : "";
#ifdef SLIC3R_GUI
                if (is_bbl_printer)
                    it->filament_id = bbl_agent.from_orca_filament_id(it->filament_id);
#endif /* SLIC3R_GUI */
            }
 
            if (!plate_data->plate_thumbnail.is_valid()) {
                if (!oriented_or_arranged && !regenerate_thumbnails && plate_data_src.size() > i)
                    plate_data->thumbnail_file = plate_data_src[i]->thumbnail_file;
                BOOST_LOG_TRIVIAL(info) << boost::format("thumbnails stage: plate %1%'s thumbnail data is invalid, check the file %2% exist or not")%(i+1) %plate_data->thumbnail_file;
                if (plate_data->thumbnail_file.empty() || (!boost::filesystem::exists(plate_data->thumbnail_file))) {
                    BOOST_LOG_TRIVIAL(info) << boost::format("thumbnails stage: plate %1%'s thumbnail file also not there, need to regenerate")%(i+1);
                    if (!skip_this_plate) {
                        need_regenerate_thumbnail = true;
                        need_create_thumbnail_group = true;
                    }
                }
                else {
                    if (regenerate_thumbnails) {
                        BOOST_LOG_TRIVIAL(info) << boost::format("thumbnails stage: plate %1%'s thumbnail file %2% cleared, need to regenerate")%(i+1) %plate_data->thumbnail_file;
                        plate_data->thumbnail_file.clear();
                    }
                    else
                        BOOST_LOG_TRIVIAL(info) << boost::format("thumbnails stage: plate %1%'s thumbnail file exists, no need to regenerate")%(i+1);
                }
            }
            else {
                if (regenerate_thumbnails)
                    plate_data->plate_thumbnail.reset();
 
                if (!skip_this_plate) {
                    need_create_thumbnail_group = true;
                }
            }
 
            if (plate_data->no_light_thumbnail_file.empty()) {
                if (!regenerate_thumbnails && (plate_data_src.size() > i)) {
                    plate_data->no_light_thumbnail_file = plate_data_src[i]->no_light_thumbnail_file;
                }
                if (plate_data->no_light_thumbnail_file.empty() || (!boost::filesystem::exists(plate_data->no_light_thumbnail_file))) {
                    BOOST_LOG_TRIVIAL(info) << boost::format("thumbnails stage: plate %1%'s no_light_thumbnail_file %2% also not there, need to regenerate")%(i+1)%plate_data->no_light_thumbnail_file;
                    if (!skip_this_plate) {
                        need_regenerate_no_light_thumbnail = true;
                        need_create_no_light_group = true;
                    }
                }
                else {
                    if (regenerate_thumbnails) {
                        BOOST_LOG_TRIVIAL(info) << boost::format("thumbnails stage: plate %1%'s no_light_thumbnail file %2% cleared, need to regenerate")%(i+1) %plate_data->no_light_thumbnail_file;
                        plate_data->no_light_thumbnail_file.clear();
                    }
                    else
                        BOOST_LOG_TRIVIAL(info) << boost::format("thumbnails stage: plate %1%'s no_light_thumbnail file exists, no need to regenerate")%(i+1);
                }
            }
 
            if (plate_data->top_file.empty() || plate_data->pick_file.empty()) {
                if (!regenerate_thumbnails && (plate_data_src.size() > i)) {
                    plate_data->top_file = plate_data_src[i]->top_file;
                    plate_data->pick_file = plate_data_src[i]->pick_file;
                }
                if (plate_data->top_file.empty()|| plate_data->pick_file.empty()
                    || (!boost::filesystem::exists(plate_data->top_file)) || (!boost::filesystem::exists(plate_data->pick_file))) {
                    BOOST_LOG_TRIVIAL(info) << boost::format("thumbnails stage: plate %1%'s top_file %2% also not there, need to regenerate")%(i+1)%plate_data->top_file;
                    if (!skip_this_plate) {
                        need_regenerate_top_thumbnail = true;
                        need_create_top_group = true;
                    }
                }
                else {
                    if (regenerate_thumbnails) {
                        BOOST_LOG_TRIVIAL(info) << boost::format("thumbnails stage: plate %1%'s top_thumbnail file %2% cleared, need to regenerate")%(i+1) %plate_data->top_file;
                        plate_data->top_file.clear();
                        plate_data->pick_file.clear();
                    }
                    else
                        BOOST_LOG_TRIVIAL(info) << boost::format("thumbnails stage: plate %1%'s top_thumbnail file exists, no need to regenerate")%(i+1);
                }
            }
        }
 
        if (need_regenerate_thumbnail || need_regenerate_no_light_thumbnail || need_regenerate_top_thumbnail) {
            std::vector<std::string> colors;
            if (filament_color) {
                colors= filament_color->vserialize();
            }
            else
                colors.push_back("#FFFFFFFF");
 
            std::vector<ColorRGBA> colors_out(colors.size());
            unsigned char rgb_color[4] = {};
            for (const std::string& color : colors) {
                Slic3r::GUI::BitmapCache::parse_color4(color, rgb_color);
                size_t color_idx = &color - &colors.front();
                colors_out[color_idx] = ColorRGBA(float(rgb_color[0]) / 255.f, float(rgb_color[1]) / 255.f, float(rgb_color[2]) / 255.f, float(rgb_color[3]) / 255.f);
            }
 
            int glfw_major, glfw_minor, glfw_revision;
            glfwGetVersion(&glfw_major, &glfw_minor, &glfw_revision);
            BOOST_LOG_TRIVIAL(info) << boost::format("GLFW version %1%.%2%.%3%") % glfw_major % glfw_minor % glfw_revision;
 
            bool thumbnail_opengl_ready = false;
            glfwSetErrorCallback(glfw_callback);
            int ret = glfwInit();
            if (ret == GLFW_FALSE) {
                const char* error_msg;
                int code = glfwGetError(&error_msg);
                BOOST_LOG_TRIVIAL(error) << "glfwInit return error, Error code: " << code << ", Error: " << error_msg << std::endl;
            }
            else {
                BOOST_LOG_TRIVIAL(info) << "glfwInit Success."<< std::endl;
                // Request OrcaSlicer's minimum OpenGL version, independently of the GLFW library version.
                glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
                glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
                glfwWindowHint(GLFW_RED_BITS, 8);
                glfwWindowHint(GLFW_GREEN_BITS, 8);
                glfwWindowHint(GLFW_BLUE_BITS, 8);
                glfwWindowHint(GLFW_ALPHA_BITS, 8);
                glfwWindowHint(GLFW_VISIBLE, false);
                //glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
                //glfwDisable(GLFW_AUTO_POLL_EVENTS);
#ifdef __WXMAC__
                glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
                glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
#else
                glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_COMPAT_PROFILE);
#endif
 
                GLFWwindow* window = glfwCreateWindow(640, 480, "base_window", NULL, NULL);
#ifndef __WXMAC__
                if (window == NULL) {
                    // Some drivers (e.g. older Mesa) only expose compatibility profile 3.0; take whatever they offer.
                    BOOST_LOG_TRIVIAL(warning) << "Failed to create OpenGL 3.3 compatibility context, retrying with driver default" << std::endl;
                    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 1);
                    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
                    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_ANY_PROFILE);
                    window = glfwCreateWindow(640, 480, "base_window", NULL, NULL);
                }
#endif
                if (window == NULL)
                {
                    BOOST_LOG_TRIVIAL(error) << "Failed to create GLFW window; skipping thumbnail rendering for CLI export" << std::endl;
                }
                else {
                    glfwMakeContextCurrent(window);
                    thumbnail_opengl_ready = true;
                }
            }
 
            //opengl manager related logic
            if (!thumbnail_opengl_ready) {
                BOOST_LOG_TRIVIAL(error) << "OpenGL context unavailable; skip thumbnail generating" << std::endl;
                need_create_thumbnail_group = false;
                need_create_no_light_group = false;
                need_create_top_group = false;
            }
            else
            {
                GUI::OpenGLManager opengl_mgr;
                bool opengl_valid = opengl_mgr.init_gl(false);
                if (!opengl_valid) {
                    BOOST_LOG_TRIVIAL(error) << "init opengl failed! skip thumbnail generating" << std::endl;
                }
                else {
                    BOOST_LOG_TRIVIAL(info) << "gladLoadGL Success." << std::endl;
                    GLVolumeCollection glvolume_collection;
                    Model &model = m_models[0];
                    int obj_extruder_id = 1, volume_extruder_id = 1;
                    for (unsigned int obj_idx = 0; obj_idx < (unsigned int)model.objects.size(); ++ obj_idx) {
                        const ModelObject &model_object = *model.objects[obj_idx];
                        const ConfigOption* option = model_object.config.option("extruder");
                        if (option)
                            obj_extruder_id = (dynamic_cast<const ConfigOptionInt *>(option))->getInt();
                        else
                            obj_extruder_id = 1;
                        for (int volume_idx = 0; volume_idx < (int)model_object.volumes.size(); ++ volume_idx) {
                            const ModelVolume &model_volume = *model_object.volumes[volume_idx];
                            option = model_volume.config.option("extruder");
                            if (option)
                                volume_extruder_id = (dynamic_cast<const ConfigOptionInt *>(option))->getInt();
                            else
                                volume_extruder_id = obj_extruder_id;
 
                            BOOST_LOG_TRIVIAL(debug) << boost::format("volume %1%'s extruder_id %2%")%volume_idx %volume_extruder_id;
                            //if (!model_volume.is_model_part())
                            //    continue;
                            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()->geometry_id = key.geometry_id;
                                std::string color = filament_color?filament_color->get_at(volume_extruder_id - 1):"#00FF00FF";
 
                                BOOST_LOG_TRIVIAL(debug) << boost::format("volume %1%'s color %2%")%volume_idx %color;
 
                                unsigned char  rgb_color[4] = {};
                                Slic3r::GUI::BitmapCache::parse_color4(color, rgb_color);
 
                                ColorRGBA new_color;
                                new_color.r(float(rgb_color[0]) / 255.f);
                                new_color.g(float(rgb_color[1]) / 255.f);
                                new_color.b(float(rgb_color[2]) / 255.f);
                                new_color.a(float(rgb_color[3]) / 255.f);
 
                                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;
                            }
                        }
                    }
 
                    ThumbnailsParams thumbnail_params;
                    GLShaderProgram* shader = opengl_mgr.get_shader("thumbnail");
                    if (!shader) {
                        BOOST_LOG_TRIVIAL(error) << boost::format("can not get shader for rendering thumbnail");
                    }
                    else {
                        for (int i = 0; i < partplate_list.get_plate_count(); i++) {
                            Slic3r::GUI::PartPlate *part_plate      = partplate_list.get_plate(i);
                            PlateData *plate_data = plate_data_list[i];
                            if (plate_data->plate_thumbnail.is_valid()) {
                                if ((plate_to_slice != 0) && (plate_to_slice != (i + 1))) {
                                    BOOST_LOG_TRIVIAL(info) << boost::format("Line %1%: regenerate thumbnail, reset plate %2%'s thumbnail.")%__LINE__%(i+1);
                                    plate_data->plate_thumbnail.reset();
                                }
                                else {
                                    BOOST_LOG_TRIVIAL(info) << boost::format("plate %1% has a valid thumbnail, width %2%, height %3%， directly using it")%(i+1) %plate_data->plate_thumbnail.width %plate_data->plate_thumbnail.height;
                                }
                            }
                            else if (!plate_data->thumbnail_file.empty() && (boost::filesystem::exists(plate_data->thumbnail_file)))
                            {
                                if ((plate_to_slice != 0) && (plate_to_slice != (i + 1))) {
                                    BOOST_LOG_TRIVIAL(info) << boost::format("Line %1%: regenerate thumbnail, clear plate %2%'s thumbnail file path to empty.")%__LINE__%(i+1);
                                    plate_data->thumbnail_file.clear();
                                }
                                else {
                                    BOOST_LOG_TRIVIAL(info) << boost::format("plate %1% has a valid thumbnail %2% extracted from 3mf, directly using it")%(i+1) %plate_data->thumbnail_file;
                                    int dec_ret = decode_png_to_thumbnail(plate_data->thumbnail_file, plate_data->plate_thumbnail);
                                    if (!dec_ret)
                                    {
                                        BOOST_LOG_TRIVIAL(info) << boost::format("decode png to mem success.");
                                    }
                                    else {
                                        BOOST_LOG_TRIVIAL(warning) << boost::format("decode png to mem failed.");
                                    }
                                }
                            }
                            else {
                                ThumbnailData* thumbnail_data = &plate_data->plate_thumbnail;
 
                                if ((plate_to_slice != 0) && (plate_to_slice != (i + 1))) {
                                    BOOST_LOG_TRIVIAL(info) << boost::format("Line %1%: regenerate thumbnail, Skip plate %2%.")%__LINE__%(i+1);
                                }
                                else {
                                    unsigned int thumbnail_width = 512, thumbnail_height = 512;
                                    const ThumbnailsParams thumbnail_params = {{}, false, true, true, true, i};
 
                                    BOOST_LOG_TRIVIAL(info) << boost::format("plate %1%'s thumbnail, need to regenerate")%(i+1);
                                    switch (Slic3r::GUI::OpenGLManager::get_framebuffers_type())
                                    {
                                    case Slic3r::GUI::OpenGLManager::EFramebufferType::Arb:
                                            {
                                                BOOST_LOG_TRIVIAL(info) << 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) << 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) << boost::format("framebuffer_type: unknown");
                                            break;
                                    }
                                    BOOST_LOG_TRIVIAL(info) << boost::format("plate %1%'s thumbnail,finished rendering")%(i+1);
                                }
                            }
                            if (need_create_thumbnail_group) {
                                thumbnails.push_back(&plate_data->plate_thumbnail);
                                BOOST_LOG_TRIVIAL(info) << boost::format("plate %1%: add thumbnail data into group")%(i+1);
                            }
 
                            //no light thumbnail
                            if (!plate_data->no_light_thumbnail_file.empty() && (boost::filesystem::exists(plate_data->no_light_thumbnail_file)))
                            {
                                if ((plate_to_slice != 0) && (plate_to_slice != (i + 1))) {
                                    BOOST_LOG_TRIVIAL(info) << boost::format("Line %1%: regenerate thumbnail, clear plate %2%'s no_light_thumbnail_file path to empty.")%__LINE__%(i+1);
                                    plate_data->no_light_thumbnail_file.clear();
                                }
                                else
                                    BOOST_LOG_TRIVIAL(info) << boost::format("plate %1% has valid no_light_thumbnail_file extracted from 3mf, directly using it")%(i+1);
                            }
                            else{
                                ThumbnailData *no_light_thumbnail = &part_plate->no_light_thumbnail_data;
                                if ((plate_to_slice != 0) && (plate_to_slice != (i + 1))) {
                                    BOOST_LOG_TRIVIAL(info) << boost::format("Line %1%: regenerate thumbnail, Skip plate %2%.")%__LINE__%(i+1);
                                    part_plate->no_light_thumbnail_data.reset();
                                    plate_data->no_light_thumbnail_file.clear();
                                }
                                else {
                                    unsigned int thumbnail_width = 512, thumbnail_height = 512;
                                    const ThumbnailsParams thumbnail_params = { {}, false, true, false, true, i };
 
                                    BOOST_LOG_TRIVIAL(info) << boost::format("plate %1%'s no_light_thumbnail_file missed, need to regenerate")%(i+1);
                                    switch (Slic3r::GUI::OpenGLManager::get_framebuffers_type())
                                    {
                                        case Slic3r::GUI::OpenGLManager::EFramebufferType::Arb:
                                            {
                                                BOOST_LOG_TRIVIAL(info) << boost::format("framebuffer_type: ARB");
                                                Slic3r::GUI::GLCanvas3D::render_thumbnail_framebuffer(*no_light_thumbnail,
                                                   thumbnail_width, thumbnail_height, thumbnail_params,
                                                                                                  partplate_list, model.objects, glvolume_collection, colors_out, shader,
                                                                                                  Slic3r::GUI::Camera::EType::Ortho, Slic3r::GUI::Camera::ViewAngleType::Iso,
                                                                                                  false, true);
                                                break;
                                            }
                                        case Slic3r::GUI::OpenGLManager::EFramebufferType::Ext:
                                            {
                                                BOOST_LOG_TRIVIAL(info) << boost::format("framebuffer_type: EXT");
                                                Slic3r::GUI::GLCanvas3D::render_thumbnail_framebuffer_ext(*no_light_thumbnail,
                                                   thumbnail_width, thumbnail_height, thumbnail_params,
                                                                                                      partplate_list, model.objects, glvolume_collection, colors_out, shader,
                                                                                                      Slic3r::GUI::Camera::EType::Ortho, Slic3r::GUI::Camera::ViewAngleType::Iso,
                                                                                                      false, true);
                                                break;
                                            }
                                        default:
                                            BOOST_LOG_TRIVIAL(info) << boost::format("framebuffer_type: unknown");
                                            break;
                                    }
                                    plate_data->no_light_thumbnail_file = "valid_no_light";
                                    BOOST_LOG_TRIVIAL(info) << boost::format("plate %1%'s no_light thumbnail,finished rendering")%(i+1);
                                }
                            }
 
                            if (need_create_no_light_group) {
                                no_light_thumbnails.push_back(&part_plate->no_light_thumbnail_data);
                                BOOST_LOG_TRIVIAL(info) << boost::format("plate %1%: add thumbnail data for no_light into group")%(i+1);
                            }
 
                            //top thumbnails
                            /*if (part_plate->top_thumbnail_data.is_valid() && part_plate->pick_thumbnail_data.is_valid()) {
                                if ((plate_to_slice != 0) && (plate_to_slice != (i + 1))) {
                                    BOOST_LOG_TRIVIAL(info) << boost::format("Line %1%: regenerate thumbnail, reset plate %2%'s top/pick thumbnail.")%__LINE__%(i+1);
                                    part_plate->top_thumbnail_data.reset();
                                    part_plate->pick_thumbnail_data.reset();
                                    plate_data->top_file.clear();
                                    plate_data->pick_file.clear();
                                }
                                else {
                                    plate_data->top_file = "valid_top";
                                    plate_data->pick_file = "valid_pick";
                                    BOOST_LOG_TRIVIAL(info) << boost::format("plate %1% has a valid top/pick thumbnail data, directly using it")%(i+1);
                                }
                            }
                            else*/
                            if ((!plate_data->top_file.empty() && (boost::filesystem::exists(plate_data->top_file)))
                                &&(!plate_data->pick_file.empty() && (boost::filesystem::exists(plate_data->pick_file))))
                            {
                                if ((plate_to_slice != 0) && (plate_to_slice != (i + 1))) {
                                    BOOST_LOG_TRIVIAL(info) << boost::format("Line %1%: regenerate thumbnail, clear plate %2%'s top/pick thumbnail file path to empty.")%__LINE__%(i+1);
                                    plate_data->top_file.clear();
                                    plate_data->pick_file.clear();
                                }
                                else
                                    BOOST_LOG_TRIVIAL(info) << boost::format("plate %1% has valid top/pick thumbnail extracted from 3mf, directly using it")%(i+1);
                            }
                            else{
                                ThumbnailData* top_thumbnail = &part_plate->top_thumbnail_data;
                                ThumbnailData* picking_thumbnail = &part_plate->pick_thumbnail_data;
                                if ((plate_to_slice != 0) && (plate_to_slice != (i + 1))) {
                                    BOOST_LOG_TRIVIAL(info) << boost::format("Line %1%: regenerate thumbnail, Skip plate %2%.")%__LINE__%(i+1);
                                    part_plate->top_thumbnail_data.reset();
                                    part_plate->pick_thumbnail_data.reset();
                                    plate_data->top_file.clear();
                                    plate_data->pick_file.clear();
                                }
                                else {
                                    unsigned int thumbnail_width = 512, thumbnail_height = 512;
                                    const ThumbnailsParams thumbnail_params = { {}, false, true, false, true, i };
 
                                    BOOST_LOG_TRIVIAL(info) << boost::format("plate %1%'s top/pick thumbnail missed, need to regenerate, objects count %2%, skip_useless_pick %3%")%(i+1) %plate_object_count[i] %skip_useless_pick;
                                    if (skip_useless_pick && ((plate_object_count[i] <= 1) || (plate_object_count[i] > 64)))
                                    {
                                        //don't render pick and top
                                        part_plate->top_thumbnail_data.reset();
                                        part_plate->pick_thumbnail_data.reset();
                                        plate_data->top_file.clear();
                                        plate_data->pick_file.clear();
                                        BOOST_LOG_TRIVIAL(info) << boost::format("skip rendering for top&&pick");
                                    }
                                    else {
                                        switch (Slic3r::GUI::OpenGLManager::get_framebuffers_type())
                                        {
                                            case Slic3r::GUI::OpenGLManager::EFramebufferType::Arb:
                                                {
                                                    BOOST_LOG_TRIVIAL(info) << boost::format("framebuffer_type: ARB");
                                                    Slic3r::GUI::GLCanvas3D::render_thumbnail_framebuffer(*top_thumbnail,
                                                       thumbnail_width, thumbnail_height, thumbnail_params,
                                                                                                      partplate_list, model.objects, glvolume_collection, colors_out, shader,
                                                                                                      Slic3r::GUI::Camera::EType::Ortho, Slic3r::GUI::Camera::ViewAngleType::Top_Plate,
                                                                                                      false);
                                                    Slic3r::GUI::GLCanvas3D::render_thumbnail_framebuffer(*picking_thumbnail,
                                                       thumbnail_width, thumbnail_height, thumbnail_params,
                                                                                                          partplate_list, model.objects, glvolume_collection, colors_out, shader,
                                                                                                          Slic3r::GUI::Camera::EType::Ortho,
                                                                                                          Slic3r::GUI::Camera::ViewAngleType::Top_Plate, true, true);
                                                    break;
                                                }
                                            case Slic3r::GUI::OpenGLManager::EFramebufferType::Ext:
                                                {
                                                    BOOST_LOG_TRIVIAL(info) << boost::format("framebuffer_type: EXT");
                                                    Slic3r::GUI::GLCanvas3D::render_thumbnail_framebuffer_ext(*top_thumbnail,
                                                       thumbnail_width, thumbnail_height, thumbnail_params,
                                                                                                          partplate_list, model.objects, glvolume_collection, colors_out, shader,
                                                                                                          Slic3r::GUI::Camera::EType::Ortho,
                                                                                                          Slic3r::GUI::Camera::ViewAngleType::Top_Plate, false);
                                                    Slic3r::GUI::GLCanvas3D::render_thumbnail_framebuffer_ext(*picking_thumbnail,
                                                       thumbnail_width, thumbnail_height, thumbnail_params, partplate_list, model.objects,
                                                                                                              glvolume_collection, colors_out, shader,
                                                                                                              Slic3r::GUI::Camera::EType::Ortho,
                                                                                                              Slic3r::GUI::Camera::ViewAngleType::Top_Plate,
                                                                                                              true,true);
                                                    break;
                                                }
                                            default:
                                                BOOST_LOG_TRIVIAL(info) << boost::format("framebuffer_type: unknown");
                                                break;
                                        }
                                        plate_data->top_file = "valid_top";
                                        plate_data->pick_file = "valid_pick";
                                        BOOST_LOG_TRIVIAL(info) << boost::format("plate %1%'s top_thumbnail,finished rendering")%(i+1);
                                    }
                                }
                            }
 
                            if (need_create_top_group) {
                                top_thumbnails.push_back(&part_plate->top_thumbnail_data);
                                pick_thumbnails.push_back(&part_plate->pick_thumbnail_data);
                                BOOST_LOG_TRIVIAL(info) << boost::format("plate %1%: add thumbnail data for top and pick into group")%(i+1);
                            }
                        }
                    }
                }
            }
            //BBS: release glfw
            glfwTerminate();
        }
        else {
            BOOST_LOG_TRIVIAL(info) << boost::format("Line %1%: use previous thumbnails, no need to regenerate")%__LINE__;
            for (int i = 0; i < partplate_list.get_plate_count(); i++) {
                PlateData *plate_data = plate_data_list[i];
                bool skip_this_plate = ((plate_to_slice != 0) && (plate_to_slice != (i + 1)))?true:false;
                Slic3r::GUI::PartPlate *part_plate      = partplate_list.get_plate(i);
 
                if (skip_this_plate) {
                    BOOST_LOG_TRIVIAL(info) << boost::format("plate %1%'s all the thumbnails skipped, reset here")%(i+1);
                    plate_data->plate_thumbnail.reset();
                    plate_data->thumbnail_file.clear();
                    part_plate->no_light_thumbnail_data.reset();
                    plate_data->no_light_thumbnail_file.clear();
 
                    part_plate->top_thumbnail_data.reset();
                    part_plate->pick_thumbnail_data.reset();
                    plate_data->top_file.clear();
                    plate_data->pick_file.clear();
                }
                else if (!plate_data->plate_thumbnail.is_valid() && !plate_data->thumbnail_file.empty() && (boost::filesystem::exists(plate_data->thumbnail_file)))
                {
                    BOOST_LOG_TRIVIAL(info) << boost::format("no need to generate: plate %1% has a valid thumbnail %2% extracted from 3mf, convert to data")%(i+1) %plate_data->thumbnail_file;
                    int dec_ret = decode_png_to_thumbnail(plate_data->thumbnail_file, plate_data->plate_thumbnail);
                    if (!dec_ret)
                    {
                        BOOST_LOG_TRIVIAL(info) << boost::format("decode png to mem success.");
                        need_create_thumbnail_group = true;
                    }
                    else {
                        BOOST_LOG_TRIVIAL(warning) << boost::format("decode png to mem failed.");
                    }
                }
            }
 
            for (int i = 0; i < partplate_list.get_plate_count(); i++) {
                PlateData *plate_data = plate_data_list[i];
                Slic3r::GUI::PartPlate *part_plate      = partplate_list.get_plate(i);
 
                if (need_create_thumbnail_group) {
                    thumbnails.push_back(&plate_data->plate_thumbnail);
                    BOOST_LOG_TRIVIAL(info) << boost::format("plate %1%: add thumbnail data into group")%(i+1);
                }
 
                if (need_create_no_light_group) {
                    no_light_thumbnails.push_back(&part_plate->no_light_thumbnail_data);
                    BOOST_LOG_TRIVIAL(info) << boost::format("plate %1%: add thumbnail data into group")%(i+1);
                }
 
                if (need_create_top_group) {
                    top_thumbnails.push_back(&part_plate->top_thumbnail_data);
                    pick_thumbnails.push_back(&part_plate->pick_thumbnail_data);
                    BOOST_LOG_TRIVIAL(info) << boost::format("plate %1%: add thumbnail data for top and pick into group")%(i+1);
                }
            }
        }
 
        //generate first layer bboxes
        for (int i = 0; i < partplate_list.get_plate_count(); i++) {
            if ((plate_to_slice != 0) && (plate_to_slice != (i + 1))) {
                BOOST_LOG_TRIVIAL(info) << boost::format("Line %1%: generate bbox, Skip plate %2%.")%__LINE__%(i+1);
                plate_bboxes.push_back(new PlateBBoxData());
                continue;
            }
            Slic3r::GUI::PartPlate *part_plate      = partplate_list.get_plate(i);
            //render calibration thumbnail
            if (!part_plate->get_slice_result() || !part_plate->is_slice_result_valid()) {
                BOOST_LOG_TRIVIAL(info) << boost::format("plate %1% doesn't have a valid sliced result, skip it")%(i+1);
                //calibration_thumbnails.push_back(new ThumbnailData());
                plate_bboxes.push_back(new PlateBBoxData());
                continue;
            }
            PrintBase  *print_base=NULL;
            Slic3r::GUI::GCodeResult *gcode_result = NULL;
            int print_index;
            part_plate->get_print(&print_base, &gcode_result, &print_index);
 
            Print *print = dynamic_cast<Print *>(print_base);
 
             //don't render calibration picture
            /*BuildVolume build_volume(part_plate->get_shape(), print_height);
            const std::vector<BoundingBoxf3>& exclude_bounding_box = part_plate->get_exclude_areas();
            Slic3r::GUI::GCodeViewer gcode_viewer;
            gcode_viewer.init(ConfigOptionMode::comAdvanced, nullptr);
            gcode_viewer.load(*gcode_result, *print, build_volume, exclude_bounding_box, false, ConfigOptionMode::comAdvanced, false);
 
            std::vector<std::string> colors;
            if (filament_color)
                colors = filament_color->values;
            gcode_viewer.refresh(*gcode_result, colors);
 
            ThumbnailData* calibration_data = new ThumbnailData();
            const ThumbnailsParams calibration_params = { {}, false, true, true, true, i };
            //BBS fixed size
            const int cali_thumbnail_width = 2560;
            const int cali_thumbnail_height = 2560;
            gcode_viewer.render_calibration_thumbnail(*calibration_data, cali_thumbnail_width, cali_thumbnail_height,
                calibration_params, partplate_list, opengl_mgr);
            //generate_calibration_thumbnail(*calibration_data, thumbnail_width, thumbnail_height, calibration_params);
            // *plate_bboxes[index] = p->generate_first_layer_bbox();
            calibration_thumbnails.push_back(calibration_data);*/
 
            PlateBBoxData* plate_bbox = new PlateBBoxData();
            std::vector<BBoxData>& id_bboxes = plate_bbox->bbox_objs;
            BoundingBoxf bbox_all;
            PrintSequence curr_plate_seq = part_plate->get_print_seq();
            if (curr_plate_seq == PrintSequence::ByDefault) {
                auto seq_print  = m_print_config.option<ConfigOptionEnum<PrintSequence>>("print_sequence");
                if (seq_print && (seq_print->value == PrintSequence::ByObject)) {
                    BOOST_LOG_TRIVIAL(info) << boost::format("plate %1% print by object, set from global")%(i+1);
                    plate_bbox->is_seq_print = true;
                }
            }
            else if (curr_plate_seq == PrintSequence::ByObject) {
                BOOST_LOG_TRIVIAL(info) << boost::format("plate %1% print by object, set from plate self")%(i+1);
                plate_bbox->is_seq_print = true;
            }
            plate_bbox->first_extruder = print->get_tool_ordering().first_extruder();
            //bed type;
            BedType plate_bed_type = part_plate->get_bed_type();
            if (plate_bed_type == btDefault) {
                auto cur_bed_type  = m_print_config.option<ConfigOptionEnum<BedType>>("curr_bed_type");
                if (cur_bed_type) {
                    BOOST_LOG_TRIVIAL(info) << boost::format("plate %1% bed type: %2%, set from global")%(i+1) %cur_bed_type->serialize();
                    plate_bbox->bed_type = bed_type_to_gcode_string(cur_bed_type->value);
                }
            }
            else {
                BOOST_LOG_TRIVIAL(info) << boost::format("plate %1% bed type: %2%, set from plate self")%(i+1) %plate_bed_type;
                plate_bbox->bed_type       = bed_type_to_gcode_string(plate_bed_type);
            }
            // get nozzle diameter
            auto opt_nozzle_diameters = m_print_config.option<ConfigOptionFloats>("nozzle_diameter");
            if (opt_nozzle_diameters != nullptr)
                plate_bbox->nozzle_diameter = float(opt_nozzle_diameters->get_at(plate_bbox->first_extruder));
 
            auto objects = print->objects();
            auto orig = part_plate->get_origin();
            Vec2d orig2d = { orig[0], orig[1] };
 
            for (auto obj : objects)
            {
                BBoxData data;
                auto bb_scaled = obj->get_first_layer_bbox(data.area, data.layer_height, data.name);
                auto bb = unscaled(bb_scaled);
                bbox_all.merge(bb);
                data.area *= (SCALING_FACTOR * SCALING_FACTOR); // unscale area
                data.id = obj->id().id;
                data.bbox = { bb.min.x(),bb.min.y(),bb.max.x(),bb.max.y() };
                id_bboxes.emplace_back(std::move(data));
            }
            // add wipe tower bounding box
            if (print->has_wipe_tower()) {
                BBoxData data;
                auto   wt_corners = print->first_layer_wipe_tower_corners();
                // when loading gcode.3mf, wipe tower info may not be correct
                if (!wt_corners.empty()) {
                    BoundingBox bb_scaled = {wt_corners[0], wt_corners[2]};
                    auto        bb        = unscaled(bb_scaled);
                    bb.min -= orig2d;
                    bb.max -= orig2d;
                    bbox_all.merge(bb);
                    data.name = "wipe_tower";
                    data.id   = partplate_list.get_curr_plate()->get_index() + 1000;
                    data.bbox = {bb.min.x(), bb.min.y(), bb.max.x(), bb.max.y()};
                    id_bboxes.emplace_back(std::move(data));
                }
            }
            plate_bbox->bbox_all = { bbox_all.min.x(),bbox_all.min.y(),bbox_all.max.x(),bbox_all.max.y() };
 
            PlateData *plate_data = plate_data_list[i];
            for (auto it = plate_data->slice_filaments_info.begin(); it != plate_data->slice_filaments_info.end(); it++) {
                plate_bbox->filament_ids.push_back(it->id);
                plate_bbox->filament_colors.push_back(it->color);
            }
            plate_bboxes.push_back(plate_bbox);
        }
 
 
#if defined(__linux__) || defined(__LINUX__)
        if (g_cli_callback_mgr.is_started()) {
            PrintBase::SlicingStatus slicing_status{97, "Exporting 3mf"};
            cli_status_callback(slicing_status);
        }
#endif
 
        BOOST_LOG_TRIVIAL(info) << "will export 3mf to " << export_3mf_file << std::endl;
        if (!makerlab_name.empty()) {
            Model &model = m_models[0];
 
            model.mk_name = makerlab_name;
            model.mk_version = makerlab_version;
            BOOST_LOG_TRIVIAL(info) << boost::format("mk_name %1%, mk_version %2%")%makerlab_name %makerlab_version;
        }
 
        if (!metadata_name.empty()) {
            Model &model = m_models[0];
 
            model.md_value = metadata_value;
            model.md_name = metadata_name;
            for (unsigned int i = 0; i < metadata_name.size(); i++)
            {
                BOOST_LOG_TRIVIAL(info) << boost::format("index %1% metadata_name %2%, metadata_value %3%")%i %metadata_name[i] %metadata_value[i];
            }
        }
 
        if (!this->export_project(&m_models[0], export_3mf_file, plate_data_list, project_presets, thumbnails, no_light_thumbnails, top_thumbnails, pick_thumbnails,
                                calibration_thumbnails, plate_bboxes, &m_print_config, minimum_save, plate_to_slice - 1))
        {
            release_PlateData_list(plate_data_list);
            record_exit_reson(outfile_dir, CLI_EXPORT_3MF_ERROR, 0, cli_errors[CLI_EXPORT_3MF_ERROR], sliced_info);
            flush_and_exit(CLI_EXPORT_3MF_ERROR);
        }
 
        for (unsigned int i = 0; i < thumbnails.size(); i++)
            thumbnails[i]->reset();
        for (unsigned int i = 0; i < no_light_thumbnails.size(); i++)
            no_light_thumbnails[i]->reset();
        for (unsigned int i = 0; i < top_thumbnails.size(); i++)
            top_thumbnails[i]->reset();
        for (unsigned int i = 0; i < pick_thumbnails.size(); i++)
            pick_thumbnails[i]->reset();
 
        release_PlateData_list(plate_data_list);
 
        for (unsigned int i = 0; i < calibration_thumbnails.size(); i++)
            delete calibration_thumbnails[i];
 
        for (int i = 0; i < plate_bboxes.size(); i++)
            delete plate_bboxes[i];
    }
 
    if (plate_data_src.size() > 0)
    {
        release_PlateData_list(plate_data_src);
    }
 
#if defined(__linux__) || defined(__LINUX__)
    if (g_cli_callback_mgr.is_started()) {
        PrintBase::SlicingStatus slicing_status{100, "All done, Success"};
        cli_status_callback(slicing_status);
    }
 
    g_cli_callback_mgr.stop();
#endif
 
    for (Model &model : m_models) {
  model.remove_backup_path_if_exist();
    }
    //BBS: flush logs
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ", Finished" << std::endl;
    global_current_time = (long long)Slic3r::Utils::get_current_time_utc();
    sliced_info.export_time = (size_t) (global_current_time - global_begin_time);
 
    //record the duplicate here
    if (duplicate_count > 0)
    {
        record_key_values["sliced_count"] = std::to_string(duplicate_count+1);
        record_exit_reson(outfile_dir, 0, plate_to_slice, cli_errors[0], sliced_info, record_key_values);
    }
    else {
        record_exit_reson(outfile_dir, 0, plate_to_slice, cli_errors[0], sliced_info);
    }
 
    boost::nowide::cout.flush();
    boost::nowide::cerr.flush();
 
    return 0;
}

References _u8L, Slic3r::ColorRGBA::a(), Slic3r::Model::add_default_instances(), Slic3r::ModelObject::add_instance(), Slic3r::Model::add_object(), Slic3r::ModelObject::add_volume(), Slic3r::AddDefaultInstances, Slic3r::arrangement::ArrangeParams::align_center, Slic3r::arrangement::ArrangeParams::align_to_y_axis, Slic3r::arrangement::ArrangeParams::allow_multi_materials_on_same_plate, Slic3r::arrangement::ArrangeParams::allow_rotations, Slic3r::ConfigBase::apply(), Slic3r::PrintBase::apply(), Slic3r::ConfigBase::apply_only(), Slic3r::GUI::OpenGLManager::Arb, Slic3r::BBoxData::area, Slic3r::GUI::GUI_InitParams::argc, Slic3r::GUI::GUI_InitParams::argv, Slic3r::arrangement::arrange(), Slic3r::arrange_objects(), Slic3r::ModelConfig::assign_config(), Slic3r::arrangement::ArrangeParams::avoid_extrusion_cali_region, Slic3r::ColorRGBA::b(), BBL_JSON_KEY_FILAMENT_ID, BBL_JSON_KEY_FROM, BBL_JSON_KEY_INHERITS, BBL_JSON_KEY_NAME, BBL_JSON_KEY_TYPE, Slic3r::BBoxData::bbox, Slic3r::PlateBBoxData::bbox_all, Slic3r::PlateBBoxData::bbox_objs, bed3d_ax3s_default_tip_radius, Slic3r::arrangement::ArrangePolygon::bed_idx, BED_SHRINK_SEQ_PRINT, Slic3r::arrangement::ArrangeParams::bed_shrink_x, Slic3r::arrangement::ArrangeParams::bed_shrink_y, Slic3r::PlateBBoxData::bed_type, Slic3r::bed_type_to_gcode_string(), Slic3r::WipeTowerFootprint::brim_width, Slic3r::btDefault, Slic3r::ByDefault, Slic3r::ByObject, Slic3r::FlushVolCalculator::calc_flush_vol(), Slic3r::BoundingBox3Base< PointType >::center(), Slic3r::check_mixed_filament_type_consistency(), Slic3r::GUI::PartPlate::check_tpu_printable_status(), Slic3r::BuildVolume::check_volume_bbox_state_with_extruder_areas(), Slic3r::GUI::PartPlateList::clear(), Slic3r::Model::clear_materials(), Slic3r::Model::clear_objects(), Slic3r::arrangement::ArrangeParams::clearance_height_to_lid, Slic3r::arrangement::ArrangeParams::clearance_height_to_rod, Slic3r::arrangement::ArrangeParams::clearance_radius, CLI_3MF_NEW_MACHINE_NOT_SUPPORTED, CLI_CONFIG_FILE_ERROR, CLI_COPY_OBJECTS_ERROR, CLI_DATA_FILE_ERROR, CLI_ENVIRONMENT_ERROR, cli_errors, CLI_EXPORT_3MF_ERROR, CLI_EXPORT_OBJ_ERROR, CLI_EXPORT_STATISTICS_ERROR, CLI_EXPORT_STL_ERROR, CLI_FILAMENT_CAN_NOT_MAP, CLI_FILAMENT_NOT_MATCH_BED_TYPE, CLI_FILAMENTS_DIFFERENT_TEMP, CLI_FILAMENTS_NOT_SUPPORTED_BY_EXTRUDER, CLI_FILE_NOTFOUND, CLI_FILE_VERSION_NOT_SUPPORTED, CLI_FILELIST_INVALID_ORDER, CLI_GCODE_PATH_CONFLICTS, CLI_GCODE_PATH_IN_UNPRINTABLE_AREA, CLI_INVALID_PARAMS, CLI_INVALID_PRINTER_TECH, CLI_INVALID_VALUES_IN_3MF, CLI_MIXED_FILAMENT_INVALID, CLI_MODIFIED_PARAMS_TO_PRINTER, CLI_NO_SUITABLE_OBJECTS, CLI_NO_SUITABLE_OBJECTS_AFTER_SKIP, CLI_OBJECT_ARRANGE_FAILED, CLI_OBJECT_COLLISION_IN_LAYER_PRINT, CLI_OBJECT_COLLISION_IN_SEQ_PRINT, CLI_OBJECTS_PARTLY_INSIDE, CLI_ONLY_ONE_TPU_SUPPORTED, CLI_POSTPROCESS_NOT_SUPPORTED, CLI_PROCESS_NOT_COMPATIBLE, cli_record_warning(), CLI_SCALE_TO_FIT_ERROR, CLI_SLICING_ERROR, CLI_SLICING_TIME_EXCEEDS_LIMIT, CLI_SUCCESS, CLI_TRIANGLE_COUNT_EXCEEDS_LIMIT, CLI_UNSUPPORTED_OPERATION, CLI_VALIDATE_ERROR, Slic3r::ConfigOption::clone(), Slic3r::GUI::color_string(), Slic3r::GUI::PartPlate::config(), Slic3r::ModelObject::config, Slic3r::ModelVolume::config, Slic3r::Preset::config, Slic3r::Print::config(), Slic3r::ConfigError, Slic3r::ConfigOptionString, construct_assemble_list(), Slic3r::GUI::PartPlate::contain_instance(), Slic3r::ExPolygon::contour, Slic3r::PresetBundle::convert_filament_preset_name(), count, Slic3r::Model::curr_plate_index, Slic3r::CustomGCode::Custom, decode_png_to_thumbnail(), Slic3r::PresetCollection::default_preset(), Slic3r::PrinterPresetCollection::default_preset_for(), default_status_callback(), Slic3r::Geometry::deg2rad(), Slic3r::WipeTowerFootprint::depth, Slic3r::ConfigOptionFloatsTempl< NULLABLE >::deserialize(), Slic3r::DynamicConfig::diff(), _sliced_info::downward_machines, Slic3r::duplicate(), Slic3r::GUI::PartPlate::duplicate_all_instance(), Slic3r::ConfigOptionString::empty(), Slic3r::DynamicConfig::empty(), Slic3r::empty(), Slic3r::PrintBase::empty(), Slic3r::empty_options, Slic3r::Enable, Slic3r::ModelObject::ensure_on_bed(), EPSILON, Slic3r::DynamicConfig::erase(), Slic3r::GCodeCheckResult::error_code, Slic3r::escape_strings_cstyle(), Slic3r::GUI::PartPlate::estimate_wipe_tower_footprint(), Slic3r::GUI::PartPlate::estimate_wipe_tower_polygon(), Slic3r::etDirectDrive, Slic3r::_printer_plate_info::exclude_depth, Slic3r::_printer_plate_info::exclude_width, Slic3r::_printer_plate_info::exclude_x, Slic3r::_printer_plate_info::exclude_y, Slic3r::arrangement::ArrangeParams::excluded_regions, Slic3r::PrintBase::export_cached_data(), Slic3r::Print::export_gcode(), Slic3r::export_gcode_statistics(), export_models(), export_project(), _sliced_info::export_time, Slic3r::GUI::OpenGLManager::Ext, Slic3r::GUI::GUI_InitParams::extra_config, Slic3r::ModelConfig::extruder(), Slic3r::TriangleMesh::facets_count(), Slic3r::PlateBBoxData::filament_colors, Slic3r::filament_dev_options, Slic3r::PlateBBoxData::filament_ids, Slic3r::Preset::filament_options(), Slic3r::filament_options_with_variant, Slic3r::filament_type(), Slic3r::PresetBundle::filaments, Slic3r::_assemble_plate_info::filaments_count, Slic3r::FileNotFound, Slic3r::find_largest_plane(), Slic3r::find_plane_at_point(), Slic3r::find_plane_by_normal(), Slic3r::PresetCollection::find_preset2(), Slic3r::PlateBBoxData::first_extruder, Slic3r::ToolOrdering::first_extruder(), Slic3r::Print::first_layer_wipe_tower_corners(), flush_and_exit, Slic3r::fmmAutoForFlush, Slic3r::fmmManual, Slic3r::fmmNozzleManual, Slic3r::CustomGCode::Info::from_json(), Slic3r::BBLPrinterAgent::from_orca_filament_id(), Slic3r::ColorRGBA::g(), Slic3r::g_flush_volume_to_support, Slic3r::g_max_flush_volume, Slic3r::g_min_flush_volume_from_support, g_slicing_warnings, Slic3r::GCodeProcessorResult::gcode_check_result, Slic3r::gcode_statistics_path(), Slic3r::CustomGCode::Info::gcodes, Slic3r::gcodes_key_set, Slic3r::ModelConfig::get(), Slic3r::ConfigOptionBoolsTempl< NULLABLE >::get_at(), Slic3r::ConfigOptionVector< T >::get_at(), Slic3r::ConfigOptionVector< double >::get_at(), Slic3r::ConfigOptionVector< int >::get_at(), Slic3r::get_bed_shape(), Slic3r::GUI::PartPlate::get_bed_type(), Slic3r::GUI::PartPlate::get_bounding_box(), Slic3r::Print::get_conflict_string(), Slic3r::ModelVolume::get_convex_hull(), Slic3r::GUI::PartPlateList::get_curr_plate(), Slic3r::Utils::get_current_time_utc(), Slic3r::GUI::PartPlate::get_extruder_areas(), Slic3r::get_extruder_nozzle_stats(), Slic3r::get_extruder_variant_string(), Slic3r::ModelVolume::get_extruders(), Slic3r::GUI::PartPlate::get_extruders_under_cli(), Slic3r::Print::get_filament_maps(), Slic3r::Print::get_filament_nozzle_maps(), Slic3r::Print::get_filament_volume_maps(), Slic3r::get_flush_volumes_matrix(), Slic3r::GUI::OpenGLManager::get_framebuffers_type(), Slic3r::GUI::PartPlate::get_index(), Slic3r::get_instance_arrange_poly(), Slic3r::get_logging_level(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::ModelVolume::get_matrix(), Slic3r::GUI::get_min_flush_volumes(), Slic3r::GUI::PartPlate::get_objects_bounding_box(), Slic3r::ModelInstance::get_offset(), Slic3r::GUI::PartPlate::get_origin(), Slic3r::GUI::PartPlateList::get_plate(), Slic3r::GUI::PartPlateList::get_plate_count(), Slic3r::GUI::PartPlateList::get_plate_size(), Slic3r::GUI::PartPlate::get_print(), Slic3r::GUI::PartPlate::get_print_seq(), get_printer_technology(), Slic3r::GUI::PartPlate::get_real_filament_map_mode(), Slic3r::GUI::PartPlate::get_real_filament_maps(), Slic3r::GUI::OpenGLManager::get_shader(), Slic3r::GUI::PartPlate::get_shape(), Slic3r::GUI::PartPlate::get_slice_result(), Slic3r::GUI::PartPlate::get_tmp_gcode_path(), Slic3r::Print::get_tool_ordering(), Slic3r::ModelInstance::get_transformation(), Slic3r::Preset::get_type_string(), Slic3r::ConfigOption::getFloat(), GL_TRUE, glfw_callback(), Slic3r::GUI::GUI_Run(), Slic3r::ConfigOptionResolver::has(), Slic3r::has_any_mixed_filament(), Slic3r::ModelObject::has_custom_layering(), Slic3r::Print::has_wipe_tower(), Slic3r::ThumbnailData::height, Slic3r::WipeTowerFootprint::height, I3_WIPE_TOWER_DEFAULT_X_POS, I3_WIPE_TOWER_DEFAULT_Y_POS, Slic3r::BBoxData::id, Slic3r::ObjectBase::id(), Slic3r::ObjectID::id, Slic3r::GUI::OpenGLManager::init_gl(), Slic3r::GUI::GUI_InitParams::input_files, Slic3r::GUI::GUI_InitParams::input_gcode, Slic3r::MeshInspect::inspect_to_json(), Slic3r::PaintCLI::inspect_to_json(), Slic3r::ModelObject::instance_bounding_box(), Slic3r::ModelObject::instances, Slic3r::GUI::PartPlate::intersect_instance(), Slic3r::is_auto_filament_map_mode(), Slic3r::is_compatible_with_printer(), Slic3r::is_gcode_file(), Slic3r::ModelVolume::is_model_part(), Slic3r::ModelVolume::is_modifier(), Slic3r::Preset::is_project_embedded, Slic3r::ConfigOption::is_scalar(), Slic3r::arrangement::ArrangeParams::is_seq_print, Slic3r::PlateBBoxData::is_seq_print, Slic3r::GUI::PartPlate::is_slice_result_valid(), Slic3r::ThumbnailData::is_valid(), Slic3r::arrangement::ArrangePolygon::is_virt_object, Slic3r::arrangement::ArrangePolygon::is_wipe_tower, Slic3r::GUI::Camera::Iso, Slic3r::arrangement::ArrangePolygon::itemid, Slic3r::DynamicConfig::keys(), Slic3r::lay_on_face(), Slic3r::lay_on_face_planes(), Slic3r::ModelObject::layer_config_ranges, _sliced_info::layer_height, Slic3r::BBoxData::layer_height, Slic3r::layer_height(), legacy_bed_exclude_area_points(), Slic3r::BuildVolume::Limited, Slic3r::load_assemble_plate_list(), Slic3r::PrintBase::load_cached_data(), Slic3r::GUI::GUI_InitParams::load_configs, load_default_gcodes_to_config(), load_downward_settings_list_from_config(), Slic3r::Preset::load_external_config(), Slic3r::GUI::PartPlateList::load_from_3mf_structure(), Slic3r::AppConfig::load_if_exists(), load_key_values_from_json(), Slic3r::GLVolumeCollection::load_object_volume(), Slic3r::LoadAuxiliary, Slic3r::LoadConfig, Slic3r::ModelInstance::loaded_id, Slic3r::_assemble_plate_info::loaded_obj_list, Slic3r::LoadModel, Slic3r::GUI::PartPlate::lock(), Slic3r::GUI::PartPlateList::lock_plate(), m_actions, m_config, m_extra_config, m_given_option_keys, m_input_files, m_models, m_print_config, m_transforms, Slic3r::Semver::maj(), Slic3r::make_counter_clockwise(), Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, MAX_CLONEABLE_SIZE, MAX_PLATE_COUNT, Slic3r::Model::md_name, Slic3r::Model::md_value, Slic3r::BoundingBox3Base< PointType >::merge(), Slic3r::BoundingBoxBase< PointType, APointsType >::merge(), Slic3r::ModelVolume::mesh(), Slic3r::PrintBase::SlicingStatus::message_type, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, Slic3r::Semver::min(), Slic3r::arrangement::ArrangeParams::min_obj_distance, Slic3r::Model::mk_name, Slic3r::Model::mk_version, Slic3r::ModelInstancePVS_Inside, Slic3r::ModelInstancePVS_Partly_Outside, Slic3r::MeshRepairStats::modified, Slic3r::GUI::WipeTowerRelocation::moved, Slic3r::arrangement::ArrangePolygon::name, Slic3r::BBoxData::name, Slic3r::ModelObject::name, Slic3r::ModelVolume::name, Slic3r::Preset::name, Slic3r::_assemble_plate_info::need_arrange, WebView::NeedsCompositingWorkaround(), Slic3r::ConfigSubstitution::new_value, Slic3r::GUI::PartPlate::no_light_thumbnail_data, Slic3r::PlateData::no_light_thumbnail_file, Slic3r::PrintStateBase::NON_CRITICAL, Slic3r::normal(), Slic3r::normalize_filament_values_to_variants(), Slic3r::PlateBBoxData::nozzle_diameter, Slic3r::PlateData::nozzle_diameters, Slic3r::arrangement::ArrangeParams::nozzle_height, Slic3r::nozzle_height(), Slic3r::nozzle_volume_type(), Slic3r::nvtHybrid, Slic3r::nvtStandard, Slic3r::IO::OBJ, Slic3r::Model::objects, Slic3r::Print::objects(), Slic3r::offset(), Slic3r::ConfigSubstitution::old_value, Slic3r::ConfigSubstitution::opt_def, Slic3r::DynamicConfig::opt_float(), Slic3r::ConfigOptionDef::opt_key, Slic3r::DynamicConfig::opt_string(), Slic3r::ConfigBase::option(), Slic3r::ModelConfig::option(), Slic3r::orientation::orient(), Slic3r::GUI::Camera::Ortho, Slic3r::GUI::WipeTowerRelocation::overlaps_objects, Slic3r::Semver::parse(), Slic3r::GUI::BitmapCache::parse_color4(), Slic3r::per_user_temp_dir(), Slic3r::per_user_temp_id(), Slic3r::PlateData::pick_file, Slic3r::GUI::PartPlate::pick_thumbnail_data, _sliced_plate_info::plate_id, Slic3r::PlateData::plate_thumbnail, Slic3r::arrangement::ArrangePolygon::poly, Slic3r::GUI::PartPlateList::postprocess_arrange_polygon(), Slic3r::GUI::PartPlateList::postprocess_bed_index_for_current_plate(), Slic3r::GUI::PartPlateList::postprocess_bed_index_for_selected(), _sliced_info::prepare_time, Slic3r::GUI::PartPlateList::preprocess_arrange_polygon(), Slic3r::GUI::PartPlateList::preprocess_arrange_polygon_other_locked(), Slic3r::GUI::PartPlateList::preprocess_exclude_areas(), Slic3r::GUI::PartPlateList::preprocess_nonprefered_areas(), Slic3r::Preset, print_help(), Slic3r::Preset::print_options(), Slic3r::print_options_with_variant, Slic3r::ModelInstance::print_volume_state, Slic3r::ModelInstance::printable, Slic3r::_printer_plate_info::printable_depth, Slic3r::_printer_plate_info::printable_height, Slic3r::arrangement::ArrangeParams::printable_height, Slic3r::GUI::PartPlate::printable_instance_size(), Slic3r::_printer_plate_info::printable_width, Slic3r::PlateData::printer_model_id, Slic3r::_printer_plate_info::printer_name, Slic3r::Preset::printer_options(), Slic3r::printer_options_with_variant_1, Slic3r::printer_options_with_variant_2, Slic3r::printer_technology(), Slic3r::PresetBundle::printers, Slic3r::PresetBundle::prints, Slic3r::arrangement::ArrangePolygon::priority, Slic3r::PrintBase::process(), Slic3r::arrangement::ArrangeParams::progressind, Slic3r::PresetBundle::project_different_keys(), Slic3r::psI3, Slic3r::ptFFF, Slic3r::ptSLA, Slic3r::ptUnknown, Slic3r::ColorRGBA::r(), Slic3r::Model::read_from_file(), Slic3r::GUI::PartPlateList::rebuild_plates_after_arrangement(), record_exit_reson(), Slic3r::release_PlateData_list(), Slic3r::GUI::PartPlateList::reload_all_objects(), Slic3r::GUI::GLCanvas3D::render_thumbnail_framebuffer(), Slic3r::GUI::GLCanvas3D::render_thumbnail_framebuffer_ext(), Slic3r::ModelVolume::repair(), Slic3r::AppConfig::reset(), Slic3r::ThumbnailData::reset(), Slic3r::GUI::PartPlateList::reset_size(), Slic3r::ConfigOptionVector< T >::resize(), Slic3r::ConfigOptionVectorBase::resize(), Slic3r::resize_mixed_filament_metadata(), Slic3r::PresetBundle::resolve_preset_config(), Slic3r::PresetBundle::resolve_preset_config_type(), Slic3r::resources_dir(), Slic3r::arrangement::ArrangePolygon::rotation, Slic3r::save_main_thread_id(), scale_, Slic3r::scaled(), SCALING_FACTOR, Slic3r::GUI::PartPlateList::select_plate(), serialize(), Slic3r::ConfigOption::serialize(), Slic3r::ConfigOptionBoolsTempl< NULLABLE >::serialize(), Slic3r::ConfigOptionFloatsTempl< NULLABLE >::serialize(), Slic3r::ConfigBase::set(), Slic3r::ConfigOption::set(), Slic3r::ConfigOptionVector< T >::set_at(), Slic3r::ConfigOptionVector< double >::set_at(), Slic3r::ConfigOptionVectorBase::set_at(), Slic3r::Model::set_backup_path(), Slic3r::Print::set_check_multi_filaments_compatibility(), Slic3r::set_current_thread_name(), Slic3r::Print::set_extruder_filament_info(), Slic3r::set_filament_dev_options(), Slic3r::GUI::PartPlate::set_filament_maps(), Slic3r::GUI::PartPlate::set_filament_nozzle_maps(), Slic3r::GUI::PartPlate::set_filament_volume_maps(), Slic3r::set_flush_volumes_matrix(), Slic3r::DynamicConfig::set_key_value(), Slic3r::ModelConfig::set_key_value(), Slic3r::set_logging_file(), Slic3r::set_logging_level(), Slic3r::PrintBase::set_no_check_flag(), Slic3r::ModelInstance::set_offset(), Slic3r::GUI::PartPlateList::set_shapes(), Slic3r::PrintBase::set_status_callback(), Slic3r::set_temporary_dir(), Slic3r::GUI::PartPlate::set_tmp_gcode_path(), Slic3r::ConfigOptionVectorBase::set_with_restore(), Slic3r::ConfigOptionVectorBase::set_with_restore_2(), Slic3r::Model::setExtruderParams(), Slic3r::Model::setPrintSpeedTable(), Slic3r::arrangement::ArrangePolygon::setter, setup(), Slic3r::BoundingBox3Base< PointType >::size(), Slic3r::BoundingBoxBase< PointType, APointsType >::size(), Slic3r::ConfigOptionVector< T >::size(), Slic3r::ConfigOptionVector< double >::size(), Slic3r::ConfigOptionVector< unsigned char >::size(), Slic3r::ConfigOptionVectorBase::size(), Slic3r::PlateData::skipped_objects, SLIC3R_APP_FULL_NAME, Slic3r::PlateData::slice_filaments_info, _sliced_info::sliced_plates, _sliced_plate_info::sliced_time, _sliced_plate_info::sliced_time_with_cache, Slic3r::Print::slicing_errors_message(), Slic3r::PrintStateBase::SlicingDefaultNotification, Slic3r::PrintStateBase::SlicingEmptyGcodeLayers, Slic3r::PrintStateBase::SlicingGcodeOverlap, Slic3r::smsDefault, Slic3r::smsTreeOrganic, _sliced_info::sparse_infill_density, Slic3r::IO::STL, Slic3r::stNormalAuto, Slic3r::GUI::PartPlateList::store_to_3mf_structure(), _sliced_info::strict_mode, Slic3r::STRING_EXCEPT_FILAMENT_NOT_MATCH_BED_TYPE, Slic3r::STRING_EXCEPT_FILAMENTS_DIFFERENT_TEMP, Slic3r::STRING_EXCEPT_LAYER_HEIGHT_EXCEEDS_LIMIT, Slic3r::STRING_EXCEPT_OBJECT_COLLISION_IN_LAYER_PRINT, Slic3r::STRING_EXCEPT_OBJECT_COLLISION_IN_SEQ_PRINT, Slic3r::stTreeAuto, Slic3r::ConfigSubstitutionContext::substitutions, WebView::SupportsForceSharedMemory(), Slic3r::PrintBase::SlicingStatus::text, Slic3r::PlateData::thumbnail_file, Slic3r::time_cost(), Slic3r::tlSmooth, Slic3r::arrangement::ArrangeParams::to_json(), Slic3r::to_rgb(), Slic3r::Semver::to_string(), Slic3r::PlateData::top_file, Slic3r::GUI::Camera::Top_Plate, Slic3r::GUI::PartPlate::top_thumbnail_data, Slic3r::trace(), Slic3r::TriangleMesh::transformed_bounding_box(), Slic3r::BoundingBox3Base< PointType >::translate(), Slic3r::GUI::PartPlate::translate_all_instance(), Slic3r::ModelObject::translate_instances(), Slic3r::arrangement::ArrangePolygon::translation, _sliced_plate_info::triangle_count, Slic3r::Preset::type, Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, Slic3r::Preset::TYPE_PRINTER, Slic3r::unescape_strings_cstyle(), Slic3r::unscale(), Slic3r::unscaled(), Slic3r::arrangement::update_arrange_params(), Slic3r::Model::update_print_volume_state(), Slic3r::arrangement::update_selected_items_axis_align(), Slic3r::arrangement::update_selected_items_inflation(), Slic3r::GUI::PartPlate::update_slice_result_valid_state(), Slic3r::arrangement::update_unselected_items_inflation(), Slic3r::DynamicPrintConfig::update_values_from_multi_to_multi_2(), _sliced_info::upward_machines, Slic3r::ModelInstance::use_loaded_id_for_label, Slic3r::PrintBase::validate(), Slic3r::ConfigOptionSingle< T >::value, Slic3r::ConfigOptionVector< T >::values, Slic3r::ConfigOptionVector< double >::values, Slic3r::ConfigOptionVector< int >::values, Slic3r::ConfigOptionVector< unsigned char >::values, Slic3r::GLVolumeCollection::volumes, Slic3r::ModelObject::volumes, Slic3r::ConfigOptionStrings::vserialize(), _sliced_info::wall_loops, Slic3r::PrintBase::SlicingStatus::warning_level, _sliced_plate_info::warning_message, Slic3r::PrintBase::SlicingStatus::warning_step, Slic3r::GUI::warning_text, Slic3r::ThumbnailData::width, Slic3r::WipeTowerFootprint::width, WIPE_TOWER_DEFAULT_X_POS, WIPE_TOWER_DEFAULT_Y_POS, WIPE_TOWER_MARGIN, Slic3r::wipe_tower_y(), Slic3r::_printer_plate_info::wrapping_depth, Slic3r::_printer_plate_info::wrapping_width, Slic3r::_printer_plate_info::wrapping_x, Slic3r::_printer_plate_info::wrapping_y, Slic3r::wtwRectangle, Slic3r::X, Slic3r::Y, and Slic3r::Z.

Referenced by main().

Here is the caller graph for this function:

setup()

bool CLI::setup ( int argc, char ** argv )

private

{
    // Detect the operating system flavor after SLIC3R_LOGLEVEL is set.
    detect_platform();
 
#ifdef WIN32
    // Notify user that a blacklisted DLL was injected into OrcaSlicer process (for example Nahimic, see GH #5573).
    // We hope that if a DLL is being injected into a OrcaSlicer process, it happens at the very start of the application,
    // thus we shall detect them now.
    if (BlacklistedLibraryCheck::get_instance().perform_check()) {
        std::wstring text = L"Following DLLs have been injected into the OrcaSlicer process:\n\n";
        text += BlacklistedLibraryCheck::get_instance().get_blacklisted_string();
        text += L"\n\n"
                L"OrcaSlicer is known to not run correctly with these DLLs injected. "
                L"We suggest stopping or uninstalling these services if you experience "
                L"crashes or unexpected behaviour while using OrcaSlicer.\n"
                L"For example, ASUS Sonic Studio injects a Nahimic driver, which makes OrcaSlicer "
                L"to crash on a secondary monitor";
        MessageBoxW(NULL, text.c_str(), L"Warning"/*L"Incopatible library found"*/, MB_OK);
    }
#endif
 
    // See Invoking prusa-slicer from $PATH environment variable crashes #5542
    // boost::filesystem::path path_to_binary = boost::filesystem::system_complete(argv[0]);
    boost::filesystem::path path_to_binary = boost::dll::program_location();
 
    // Path from the Slic3r binary to its resources.
#ifdef __APPLE__
    // The application is packed in the .dmg archive as 'Slic3r.app/Contents/MacOS/Slic3r'
    // The resources are packed to 'Slic3r.app/Contents/Resources'
    boost::filesystem::path path_resources = boost::filesystem::canonical(path_to_binary).parent_path().parent_path() / "Resources";
#elif defined _WIN32
    // The application is packed in the .zip archive in the root,
    // The resources are packed to 'resources'
    // Path from Slic3r binary to resources:
    boost::filesystem::path path_resources = path_to_binary.parent_path() / "resources";
#elif defined SLIC3R_FHS
    // The application is packaged according to the Linux Filesystem Hierarchy Standard
    // Resources are set to the 'Architecture-independent (shared) data', typically /usr/share or /usr/local/share
    boost::filesystem::path path_resources = SLIC3R_FHS_RESOURCES;
#else
    // The application is packed in the .tar.bz archive (or in AppImage) as 'bin/slic3r',
    // The resources are packed to 'resources'
    // Path from Slic3r binary to resources:
    boost::filesystem::path path_resources = boost::filesystem::canonical(path_to_binary).parent_path().parent_path() / "resources";
    //Orca: for build systems that support multiple configurations, the binary may be in a subdirectory like "bin/Release" or "bin/Debug".
    if( !boost::filesystem::exists(path_resources)) {
        // If the resources directory does not exist, try to use the resources directory
        path_resources = boost::filesystem::canonical(path_to_binary).parent_path().parent_path().parent_path() / "resources";
    }
#endif
 
    set_resources_dir(path_resources.string());
    set_var_dir((path_resources / "images").string());
    set_local_dir((path_resources / "i18n").string());
    set_sys_shapes_dir((path_resources / "shapes").string());
    set_custom_gcodes_dir((path_resources / "custom_gcodes").string());
 
    // Parse all command line options into a DynamicConfig.
    // If any option is unsupported, print usage and abort immediately.
    t_config_option_keys opt_order;
    if (! m_config.read_cli(argc, argv, &m_input_files, &opt_order)) {
        // Separate error message reported by the CLI parser from the help.
        boost::nowide::cerr << std::endl;
        this->print_help();
        return false;
    }
 
    // Orca: resolve here, while the process is still in the directory the user invoked it from.
    // GUI_App's constructor moves the working directory to <data_dir>/log, long before the GUI
    // opens these files in post_init(), and a relative path would then resolve against that.
    for (std::string &input_file : m_input_files)
        input_file = resolve_cli_input_path(input_file);
 
    m_given_option_keys.insert(opt_order.begin(), opt_order.end());
 
    // Parse actions and transform options.
    for (auto const &opt_key : opt_order) {
        if (cli_actions_config_def.has(opt_key))
            m_actions.emplace_back(opt_key);
        else if (cli_transform_config_def.has(opt_key))
            m_transforms.emplace_back(opt_key);
    }
 
    //FIXME Validating at this stage most likely does not make sense, as the config is not fully initialized yet.
    std::map<std::string, std::string> validity = m_config.validate(true);
 
    // Initialize with defaults.
    for (const t_optiondef_map *options : { &cli_actions_config_def.options, &cli_transform_config_def.options, &cli_misc_config_def.options })
        for (const t_optiondef_map::value_type &optdef : *options)
            m_config.option(optdef.first, true);
 
    set_data_dir(m_config.opt_string("datadir"));
    if (!data_dir().empty() && !boost::filesystem::exists(data_dir())) {
        boost::nowide::cerr << "Could not create data directory: " << data_dir() << std::endl;
        return false;
    }
 
    //FIXME Validating at this stage most likely does not make sense, as the config is not fully initialized yet.
    if (!validity.empty()) {
        boost::nowide::cerr << "Params in command line error: "<< std::endl;
        for (std::map<std::string, std::string>::iterator it=validity.begin(); it!=validity.end(); ++it)
            boost::nowide::cerr << it->first <<": "<< it->second << std::endl;
        return false;
    }
 
    return true;
}

References Slic3r::cli_actions_config_def, Slic3r::cli_misc_config_def, Slic3r::cli_transform_config_def, Slic3r::data_dir(), Slic3r::detect_platform(), Slic3r::empty(), L, m_actions, m_config, m_given_option_keys, m_input_files, m_transforms, print_help(), Slic3r::resolve_cli_input_path(), Slic3r::set_custom_gcodes_dir(), Slic3r::set_data_dir(), Slic3r::set_local_dir(), Slic3r::set_resources_dir(), Slic3r::set_sys_shapes_dir(), and Slic3r::set_var_dir().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_actions

std::vector<std::string> Slic3r::CLI::m_actions

private

Referenced by run(), and setup().

m_config

DynamicPrintAndCLIConfig Slic3r::CLI::m_config

private

Referenced by has_print_action(), output_filepath(), output_filepath(), run(), and setup().

m_extra_config

DynamicPrintConfig Slic3r::CLI::m_extra_config

private

Referenced by run().

m_given_option_keys

std::set<std::string> Slic3r::CLI::m_given_option_keys

private

Referenced by run(), and setup().

m_input_files

std::vector<std::string> Slic3r::CLI::m_input_files

private

Referenced by run(), and setup().

m_models

std::vector<Model> Slic3r::CLI::m_models

private

Referenced by export_models(), and run().

m_print_config

DynamicPrintConfig Slic3r::CLI::m_print_config

private

Referenced by run().

m_transforms

std::vector<std::string> Slic3r::CLI::m_transforms

private

Referenced by run(), and setup().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/OrcaSlicer.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/OrcaSlicer.cpp