OrcaSlicer.cpp File Reference

#include <map>
#include <vector>
#include "libslic3r/PrintBase.hpp"
#include <boost/date_time/posix_time/posix_time_duration.hpp>
#include <cerrno>
#include <utility>
#include <boost/filesystem/operations.hpp>
#include <boost/filesystem/fstream.hpp>
#include "libslic3r/LocalesUtils.hpp"
#include <fstream>
#include <exception>
#include <set>
#include "libslic3r/Color.hpp"
#include "libslic3r/TriangleSelector.hpp"
#include <algorithm>
#include "libslic3r/Format/bbs_3mf.hpp"
#include "libslic3r/Format/AssembleList.hpp"
#include <cstdlib>
#include <stdlib.h>
#include <stdexcept>
#include "libslic3r/Point.hpp"
#include "libslic3r_version.h"
#include "libslic3r/Semver.hpp"
#include "libslic3r/PrintConfig.hpp"
#include "libslic3r/BoundingBox.hpp"
#include "libslic3r/CustomGCode.hpp"
#include <memory>
#include <sstream>
#include <iomanip>
#include <iterator>
#include "libslic3r/ClipperUtils.hpp"
#include "libslic3r/GCode/WipeTowerEstimate.hpp"
#include "slic3r/GUI/Gizmos/GLGizmoBase.hpp"
#include <functional>
#include "libslic3r/Arrange.hpp"
#include "libslic3r/Polygon.hpp"
#include "libslic3r/GCode/ThumbnailData.hpp"
#include "slic3r/GUI/3DScene.hpp"
#include "slic3r/GUI/GLShader.hpp"
#include <cassert>
#include <boost/filesystem/exception.hpp>
#include <signal.h>
#include <cstdio>
#include <string>
#include <cstring>
#include <iostream>
#include <math.h>
#include <csignal>
#include <atomic>
#include <new>
#include <optional>
#include "nlohmann/json.hpp"
#include <boost/algorithm/string/predicate.hpp>
#include <boost/filesystem.hpp>
#include <boost/nowide/args.hpp>
#include <boost/nowide/cstdlib.hpp>
#include <boost/nowide/iostream.hpp>
#include <boost/nowide/fstream.hpp>
#include <boost/nowide/filesystem.hpp>
#include <boost/dll/runtime_symbol_info.hpp>
#include <boost/log/trivial.hpp>
#include "unix/fhs.hpp"
#include "libslic3r/libslic3r.h"
#include "libslic3r/Config.hpp"
#include "libslic3r/FilamentMixer.hpp"
#include "libslic3r/Preset.hpp"
#include "libslic3r/Geometry.hpp"
#include "libslic3r/GCode.hpp"
#include "libslic3r/MeshRepair.hpp"
#include "libslic3r/Model.hpp"
#include "libslic3r/ModelArrange.hpp"
#include "libslic3r/Platform.hpp"
#include "libslic3r/Print.hpp"
#include "libslic3r/SLAPrint.hpp"
#include "libslic3r/TriangleMesh.hpp"
#include "libslic3r/Format/AMF.hpp"
#include "libslic3r/Format/3mf.hpp"
#include "libslic3r/Format/STL.hpp"
#include "libslic3r/Format/OBJ.hpp"
#include "libslic3r/Format/SL1.hpp"
#include "libslic3r/Utils.hpp"
#include "libslic3r/Time.hpp"
#include "libslic3r/Thread.hpp"
#include "libslic3r/BlacklistedLibraryCheck.hpp"
#include "libslic3r/FlushVolCalc.hpp"
#include "libslic3r/LayOnFace.hpp"
#include "libslic3r/Orient.hpp"
#include "libslic3r/PNGReadWrite.hpp"
#include "libslic3r/ObjColorUtils.hpp"
#include "OrcaSlicer.hpp"
#include <wx/filename.h>
#include <wx/stdpaths.h>
#include "slic3r/Utils/MeshInspect.hpp"
#include "slic3r/Utils/PaintCLI.hpp"
#include "slic3r/GUI/PartPlate.hpp"
#include "slic3r/GUI/BitmapCache.hpp"
#include "slic3r/GUI/OpenGLManager.hpp"
#include "slic3r/GUI/GLCanvas3D.hpp"
#include "slic3r/GUI/Camera.hpp"
#include "slic3r/GUI/Plater.hpp"
#include "slic3r/GUI/GuiColor.hpp"
#include <GLFW/glfw3.h>
#include "libslic3r/AppConfig.hpp"
#include "libslic3r/BuildVolume.hpp"
#include "libslic3r/ExPolygon.hpp"
#include "libslic3r/Exception.hpp"
#include "libslic3r/GCode/GCodeProcessor.hpp"
#include "libslic3r/GCode/GCodeStatistics.hpp"
#include "libslic3r/GCode/ToolOrdering.hpp"
#include "libslic3r/ObjectID.hpp"
#include "libslic3r/PresetBundle.hpp"
#include "libslic3r/ProjectTask.hpp"
#include "slic3r/GUI/GUI_ObjectList.hpp"
#include "slic3r/GUI/I18N.hpp"
#include "slic3r/GUI/Jobs/SendJob.hpp"
#include <boost/nowide/convert.hpp>
#include <stdio.h>

Go to the source code of this file.

Classes
struct	_sliced_plate_info
struct	_sliced_info

Macros
#define	MAX_CLONEABLE_SIZE   512
#define	flush_and_exit(ret)
#define	DIR_SEPARATOR   '/'

Typedefs
typedef struct _sliced_plate_info	sliced_plate_info_t
typedef struct _sliced_info	sliced_info_t

Functions
static Pointfs	legacy_bed_exclude_area_points (const DynamicPrintConfig &config)
void	default_status_callback (const PrintBase::SlicingStatus &slicing_status)
static PrinterTechnology	get_printer_technology (const DynamicConfig &config)
static void	cli_record_warning (sliced_info_t &sliced_info, const std::string &cls, nlohmann::json details=nlohmann::json::object())
void	record_exit_reson (std::string outputdir, int code, int plate_id, std::string error_message, sliced_info_t &sliced_info, std::map< std::string, std::string > key_values=std::map< std::string, std::string >())
static int	decode_png_to_thumbnail (std::string png_file, ThumbnailData &thumbnail_data)
static void	glfw_callback (int error_code, const char *description)
static int	load_key_values_from_json (const std::string &file, std::map< std::string, std::string > &key_values)
static void	load_default_gcodes_to_config (DynamicPrintConfig &config, Preset::Type type)
void	merge_or_add_object (assemble_plate_info_t &assemble_plate_info, Model &model, int assemble_index, std::map< int, ModelObject * > &merged_objects, ModelObject *ori_object)
bool	convert_obj_cluster_colors (std::vector< Slic3r::RGBA > &input_colors, std::vector< RGBA > &all_colours, int max_filament_count, std::vector< unsigned char > &output_filament_ids)
static int	construct_assemble_list (std::vector< assemble_plate_info_t > &assemble_plate_info_list, Model &model, PlateDataPtrs &plate_list, std::vector< RGBA > &all_colours)
static void	load_downward_settings_list_from_config (std::string config_file, std::string printer_name, std::string printer_model, std::vector< std::string > &downward_settings)
void	attach_console_on_demand ()
int	main (int argc, char **argv)

Variables
std::map< int, std::string >	cli_errors
std::vector< PrintBase::SlicingStatus >	g_slicing_warnings
const float	bed3d_ax3s_default_stem_radius = 0.5f
const float	bed3d_ax3s_default_stem_length = 25.0f
const float	bed3d_ax3s_default_tip_radius = 2.5f * bed3d_ax3s_default_stem_radius
const float	bed3d_ax3s_default_tip_length = 5.0f
static std::set< std::string >	gcodes_key_set

---

Class Documentation

_sliced_plate_info

struct _sliced_plate_info

Collaboration diagram for _sliced_plate_info:

Class Members
int	plate_id {0}
size_t	sliced_time {0}
size_t	sliced_time_with_cache {0}
size_t	triangle_count {0}
string	warning_message

_sliced_info

struct _sliced_info

Collaboration diagram for _sliced_info:

Class Members
vector< string >	downward_machines
size_t	export_time
float	layer_height {0.f}
int	plate_count {0}
int	plate_to_slice {0}
size_t	prepare_time
vector< sliced_plate_info_t >	sliced_plates
float	sparse_infill_density {0.f}
bool	strict_mode {false}
vector< string >	upward_machines
int	wall_loops {0}
json	warnings = nlohmann::json::array()

Macro Definition Documentation

DIR_SEPARATOR

#define DIR_SEPARATOR   '/'

flush_and_exit

#define flush_and_exit

(

ret

)

Value:

    { boost::nowide::cout << __FUNCTION__ << " found error, exit" << std::endl;\
    boost::nowide::cout.flush();\
    boost::nowide::cerr.flush();\
    for (Model &model : m_models) {\
       model.remove_backup_path_if_exist();\
    }\
    return(ret);}

#define flush_and_exit(ret)     { boost::nowide::cout << __FUNCTION__ << " found error, exit" << std::endl;\
    boost::nowide::cout.flush();\
    boost::nowide::cerr.flush();\
    for (Model &model : m_models) {\
       model.remove_backup_path_if_exist();\
    }\
    return(ret);}

Referenced by Slic3r::CLI::run().

MAX_CLONEABLE_SIZE

#define MAX_CLONEABLE_SIZE   512

Referenced by Slic3r::CLI::run().

Typedef Documentation

sliced_info_t

typedef struct _sliced_info sliced_info_t

sliced_plate_info_t

typedef struct _sliced_plate_info sliced_plate_info_t

Function Documentation

attach_console_on_demand()

void attach_console_on_demand

(

)

                               {
#ifdef _WIN32
    static bool console_attached = false;
 
    if (!console_attached) {
        // Try attaching to the parent console first
        if (AttachConsole(ATTACH_PARENT_PROCESS)) {
            console_attached = true;
        } else if (GetLastError() == ERROR_ACCESS_DENIED) {
            // Already has a console (maybe attached by debugger)
            console_attached = true;
        } else {
            // No parent console found, try allocating a new one
            if (AllocConsole()) {
                console_attached = true;
            }
        }
 
        if (console_attached) {
            FILE* fp = nullptr;
            // Redirect standard C streams to the console
            if (freopen_s(&fp, "CONOUT$", "w", stdout) == 0) {
                setvbuf(stdout, NULL, _IONBF, 0); // Optional: Disable buffering
            }
            if (freopen_s(&fp, "CONOUT$", "w", stderr) == 0) {
                setvbuf(stderr, NULL, _IONBF, 0); // Optional: Disable buffering
            }
            if (freopen_s(&fp, "CONIN$", "r", stdin) == 0) {
                // Input redirection successful
            }
            // Sync C++ streams with C streams after redirection
            std::ios::sync_with_stdio(true);
            // Clear potential error states from C++ streams
            std::cout.clear();
            std::cerr.clear();
            std::cin.clear();
            boost::nowide::cout.clear();
            boost::nowide::cerr.clear();
            boost::nowide::cin.clear();
        }
    }
#endif
}

Referenced by Slic3r::CLI::print_help().

Here is the caller graph for this function:

cli_record_warning()

void cli_record_warning ( sliced_info_t & sliced_info, const std::string & cls, nlohmann::json details = nlohmann::json::object() )

static

{
    details["class"] = cls;
    sliced_info.warnings.push_back(std::move(details));
}

References _sliced_info::warnings.

Referenced by Slic3r::CLI::run().

Here is the caller graph for this function:

construct_assemble_list()

int construct_assemble_list ( std::vector< assemble_plate_info_t > & assemble_plate_info_list, Model & model, PlateDataPtrs & plate_list, std::vector< RGBA > & all_colours )

static

{
    int ret = 0;
    int plate_count = assemble_plate_info_list.size();
    ConfigSubstitutionContext config_substitutions(ForwardCompatibilitySubstitutionRule::Enable);
    Model temp_model;
    const int max_filament_count = size_t(EnforcerBlockerType::ExtruderMax);
 
    plate_list.resize(plate_count);
    for (int index = 0; index < plate_count; index++)
    {
        //each plate has its dependent assemble list
        std::map<int, ModelObject*>  merged_objects;
        std::set<int> used_filaments;
        //std::map<ModelObject*, int> to_merge_objects;
 
        assemble_plate_info_t& assemble_plate_info = assemble_plate_info_list[index];
 
        int object_count = assemble_plate_info.assemble_obj_list.size();
 
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": Plate %1%, name %2%, obj count %3%, plate params count %4%") % (index + 1) %assemble_plate_info.plate_name %object_count %assemble_plate_info.plate_params.size();
        PlateData* plate_data = new PlateData();
        plate_list[index] = plate_data;
        plate_data->plate_name = assemble_plate_info.plate_name;
        plate_data->plate_index = index;
 
        if (!assemble_plate_info.plate_params.empty())
        {
            for (auto plate_iter = assemble_plate_info.plate_params.begin(); plate_iter != assemble_plate_info.plate_params.end(); plate_iter++)
            {
                plate_data->config.set_deserialize(plate_iter->first, plate_iter->second, config_substitutions);
                BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": Plate %1%, key %2%, value %3%") % (index + 1) % plate_iter->first % plate_iter->second;
            }
        }
 
        //construct the object list
        for (size_t obj_index = 0; obj_index < object_count; obj_index++)
        {
            assemble_object_info_t& assemble_object = assemble_plate_info.assemble_obj_list[obj_index];
            std::string object_name;
            std::string object_1_name;
            ModelObject* object = nullptr;
            TriangleMesh mesh;
            bool skip_filament = false;
 
            boost::filesystem::path object_path(assemble_object.path);
            if (!fs::exists(object_path)) {
                BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": directory %1% not exist in plate %2%") % assemble_object.path % (index + 1);
                return CLI_FILE_NOTFOUND;
            }
 
            const char* path_str = assemble_object.path.c_str();
            const char* last_slash = strrchr(path_str, DIR_SEPARATOR);
            object_name.assign((last_slash == nullptr) ? path_str : last_slash + 1);
 
            if (boost::algorithm::iends_with(assemble_object.path, ".stl"))
            {
                if (!mesh.ReadSTLFile(path_str, true, nullptr)) {
                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": failed to read stl file from %1%, plate index %2%, object index %3%") % assemble_object.path % (index+1) % (obj_index+1);
                    return CLI_DATA_FILE_ERROR;
                }
                if (mesh.empty()) {
                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": found no mesh data from stl file %1%, plate index %2%, object index %3%") % assemble_object.path % (index + 1) % (obj_index + 1);
                    return CLI_DATA_FILE_ERROR;
                }
                object_name.erase(object_name.end() - 4, object_name.end());
                object_1_name = object_name + "_1";
                object = temp_model.add_object(object_1_name.c_str(), path_str, std::move(mesh));
                if (!object) {
                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": add_object %1% for stl failed, plate index %2%, object index %3%") % object_1_name % (index + 1) % (obj_index + 1);
                    return CLI_DATA_FILE_ERROR;
                }
            }
            else if (boost::algorithm::iends_with(assemble_object.path, ".obj"))
            {
                std::string message;
                ObjInfo  obj_info;
                bool    result = load_obj(path_str, &mesh, obj_info, message);
                if (!result) {
                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": failed to read a valid mesh from obj file %1%, plate index %2%, object index %3%, error %4%") % assemble_object.path % (index + 1) % (obj_index + 1) % message;
                    return CLI_DATA_FILE_ERROR;
                }
                if (obj_info.lost_material_name != "") {
                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": failed to read a valid mesh from obj file %1%, plate index %2%, object index %3%, mtl lost material: %4% ,please check mtl file") %
                                                    assemble_object.path % (index + 1) % (obj_index + 1) % obj_info.lost_material_name;
                    return CLI_DATA_FILE_ERROR;
                }
                if (obj_info.face_colors.size() > 0) {
                    auto temp0         = obj_info.face_colors.size();
                    auto temp1         = mesh.facets_count();
                    bool some_face_no_color = temp0 < temp1;
                    if (some_face_no_color) {
                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< boost::format(": failed to read a valid mesh from obj file %1%, plate index %2%, object index %3%, error:some_face_no_color,please check mtl file and obj file.") %
                                                        assemble_object.path % (index + 1) % (obj_index + 1);
                        return CLI_DATA_FILE_ERROR;
                    }
                }
                object_name.erase(object_name.end() - 4, object_name.end());
                object_1_name = object_name + "_1";
                //process colors
                Model obj_temp_model;
                ModelObject* temp_object = obj_temp_model.add_object(object_1_name.c_str(), path_str, std::move(mesh));
                if (!temp_object) {
                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": add_object %1%  for obj failed, plate index %2%, object index %3%") % object_1_name % (index + 1) % (obj_index + 1);
                    return CLI_DATA_FILE_ERROR;
                }
 
                std::vector<unsigned char> output_filament_ids;
                if (obj_info.vertex_colors.size() > 0) {
                    convert_obj_cluster_colors(obj_info.vertex_colors, all_colours, max_filament_count, output_filament_ids);
                    if (output_filament_ids.size() > 0) {
                        unsigned char first_extruder_id = output_filament_ids.front();
                        result = Model::obj_import_vertex_color_deal(output_filament_ids, first_extruder_id, & obj_temp_model);
                    }
                    skip_filament = true;
                } else if (obj_info.face_colors.size() > 0 && obj_info.has_uv_png == false) { // mtl file
                    convert_obj_cluster_colors(obj_info.face_colors, all_colours, max_filament_count, output_filament_ids);
                    if (output_filament_ids.size() > 0) {
                        unsigned char first_extruder_id = output_filament_ids.front();
                        result = Model::obj_import_face_color_deal(output_filament_ids, first_extruder_id, & obj_temp_model);
                    }
                    skip_filament = true;
                }
                if (!result) {
                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": failed to convert colors for %1%, plate index %2%, object index %3%, error %4%") % assemble_object.path % (index + 1) % (obj_index + 1) % message;
                    return CLI_DATA_FILE_ERROR;
                }
                object =  temp_model.add_object(*temp_object);
                if (!object) {
                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": add_object %1% for stl failed, plate index %2%, object index %3%") % object_1_name % (index + 1) % (obj_index + 1);
                    return CLI_DATA_FILE_ERROR;
                }
                obj_temp_model.clear_objects();
                obj_temp_model.clear_materials();
            }
            else {
                BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": unsupported file %1%, plate index %2%, object index %3%") % assemble_object.path % (index + 1) % (obj_index + 1);
                return CLI_INVALID_PARAMS;
            }
 
            if (!skip_filament) {
                object->config.set_key_value("extruder", new ConfigOptionInt(assemble_object.filaments[0]));
                used_filaments.emplace(assemble_object.filaments[0]);
            }
            else {
                assemble_object.filaments[0] = 0;
                for (const ModelVolume* mv : object->volumes) {
                    std::vector<int> volume_extruders = mv->get_extruders();
                    used_filaments.insert(volume_extruders.begin(), volume_extruders.end());
                }
            }
 
            if (!assemble_object.print_params.empty())
            {
                for (auto param_iter = assemble_object.print_params.begin(); param_iter != assemble_object.print_params.end(); param_iter++)
                {
                    object->config.set_deserialize(param_iter->first, param_iter->second, config_substitutions);
                    BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, object %2% key %3%, value %4%") % (index + 1) % object_1_name % param_iter->first % param_iter->second;
                }
            }
 
            if (!assemble_object.height_ranges.empty())
            {
                for (int range_index = 0; range_index < assemble_object.height_ranges.size(); range_index++)
                {
                    height_range_info_t& range = assemble_object.height_ranges[range_index];
                    DynamicPrintConfig range_config;
                    for (auto range_config_iter = range.range_params.begin(); range_config_iter != range.range_params.end(); range_config_iter++)
                    {
                        range_config.set_deserialize(range_config_iter->first, range_config_iter->second, config_substitutions);
                        BOOST_LOG_TRIVIAL(debug) << boost::format("object %1%, height range %2% key %3%, value %4%") % object_1_name % range_index % range_config_iter->first % range_config_iter->second;
                    }
                    object->layer_config_ranges[{ range.min_z, range.max_z }].assign_config(std::move(range_config));
                }
            }
 
            if (assemble_object.pos_x.empty())
                assemble_object.pos_x.resize(1, 0.f);
            if (assemble_object.pos_y.empty())
                assemble_object.pos_y.resize(1, 0.f);
            if (assemble_object.pos_z.empty())
                assemble_object.pos_z.resize(1, 0.f);
            if (assemble_object.assemble_index.empty())
                assemble_object.assemble_index.resize(1, 0);
 
            object->translate(assemble_object.pos_x[0], assemble_object.pos_y[0], assemble_object.pos_z[0]);
            merge_or_add_object(assemble_plate_info, model, assemble_object.assemble_index[0], merged_objects, object);
 
            BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": object %1%, name %2%, pos_x %3% pos_y %4%, pos_z %5%, filament %6%, assemble_index %7%")
                %obj_index %object->name %assemble_object.pos_x[0] %assemble_object.pos_y[0] %assemble_object.pos_z[0] %assemble_object.filaments[0] %assemble_object.assemble_index[0];
 
            for (size_t copy_index = 1; copy_index < assemble_object.count; copy_index++)
            {
                int array_index = copy_index;
 
                ModelObject* copy_obj = temp_model.add_object(*object);
                copy_obj->name = object_name + "_" + std::to_string(copy_index + 1);
 
                if (copy_index >= assemble_object.pos_x.size())
                    array_index = 0;
                copy_obj->translate(assemble_object.pos_x[array_index], assemble_object.pos_y[array_index], assemble_object.pos_z[array_index]);
 
                if (copy_index < assemble_object.filaments.size())
                    array_index = copy_index;
                else
                    array_index = 0;
 
                if (!skip_filament) {
                    copy_obj->config.set_key_value("extruder", new ConfigOptionInt(assemble_object.filaments[array_index]));
                    used_filaments.emplace(assemble_object.filaments[array_index]);
                }
                else {
                    assemble_object.filaments[array_index] = 0;
                }
 
                if (copy_index < assemble_object.assemble_index.size())
                    array_index = copy_index;
                else
                    array_index = 0;
                merge_or_add_object(assemble_plate_info, model, assemble_object.assemble_index[array_index], merged_objects, copy_obj);
 
                BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": cloned object %1%, name %2%, pos_x %3% pos_y %4%, pos_z %5%")
                    %copy_index %object->name %assemble_object.pos_x[array_index] %assemble_object.pos_y[array_index] %assemble_object.pos_z[array_index];
            }
        }
 
        size_t assemble_count = merged_objects.size();
        if ((assemble_count > 0) && (assemble_plate_info.assembled_param_list.size() > 0))
        {
            for (auto& iter : merged_objects)
            {
                ModelObject* assemble_obj = iter.second;
                int assemble_index = iter.first;
 
                auto assemble_iter = assemble_plate_info.assembled_param_list.find(assemble_index);
 
                if (assemble_iter != assemble_plate_info.assembled_param_list.end())
                {
                    assembled_param_info_t& assembled_param = assemble_iter->second;
                    if (!assembled_param.print_params.empty())
                    {
                        for (auto param_iter = assembled_param.print_params.begin(); param_iter != assembled_param.print_params.end(); param_iter++)
                        {
                            assemble_obj->config.set_deserialize(param_iter->first, param_iter->second, config_substitutions);
                            BOOST_LOG_TRIVIAL(debug) << boost::format("Plate %1%, assemble object %2% key %3%, value %4%") % (index + 1) % assemble_obj->name % param_iter->first % param_iter->second;
                        }
                    }
 
                    if (!assembled_param.height_ranges.empty())
                    {
                        for (int range_index = 0; range_index < assembled_param.height_ranges.size(); range_index++)
                        {
                            height_range_info_t& range = assembled_param.height_ranges[range_index];
                            DynamicPrintConfig range_config;
                            for (auto range_config_iter = range.range_params.begin(); range_config_iter != range.range_params.end(); range_config_iter++)
                            {
                                range_config.set_deserialize(range_config_iter->first, range_config_iter->second, config_substitutions);
                                BOOST_LOG_TRIVIAL(debug) << boost::format("assenble object %1%, height range %2% key %3%, value %4%") % assemble_obj->name % range_index % range_config_iter->first % range_config_iter->second;
                            }
                            assemble_obj->layer_config_ranges[{ range.min_z, range.max_z }].assign_config(std::move(range_config));
                        }
                    }
                }
            }
        }
 
        assemble_plate_info.filaments_count = used_filaments.size();
        assemble_plate_info.assemble_obj_list.clear();
        assemble_plate_info.assemble_obj_list.shrink_to_fit();
        assemble_plate_info.plate_params.clear();
 
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": Plate %1%, used filaments %2%") % (index + 1) % assemble_plate_info.filaments_count;
    }
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": has objects need to be merged, total plates %1%, total objects %2%") % plate_count % model.objects.size();
 
    temp_model.clear_objects();
    temp_model.clear_materials();
    return ret;
}

References Slic3r::Model::add_object(), Slic3r::_assemble_object_info::assemble_index, Slic3r::_assemble_plate_info::assemble_obj_list, Slic3r::_assemble_plate_info::assembled_param_list, Slic3r::Model::clear_materials(), Slic3r::Model::clear_objects(), CLI_DATA_FILE_ERROR, CLI_FILE_NOTFOUND, CLI_INVALID_PARAMS, Slic3r::ModelObject::config, Slic3r::PlateData::config, convert_obj_cluster_colors(), Slic3r::_assemble_object_info::count, DIR_SEPARATOR, Slic3r::TriangleMesh::empty(), Slic3r::Enable, Slic3r::ExtruderMax, Slic3r::ObjInfo::face_colors, Slic3r::TriangleMesh::facets_count(), Slic3r::_assemble_object_info::filaments, Slic3r::_assemble_plate_info::filaments_count, Slic3r::ModelVolume::get_extruders(), Slic3r::ObjInfo::has_uv_png, Slic3r::_assemble_object_info::height_ranges, Slic3r::_assembled_param_info::height_ranges, Slic3r::ModelObject::layer_config_ranges, Slic3r::load_obj(), Slic3r::ObjInfo::lost_material_name, merge_or_add_object(), Slic3r::ModelObject::name, Slic3r::Model::obj_import_face_color_deal(), Slic3r::Model::obj_import_vertex_color_deal(), Slic3r::Model::objects, Slic3r::_assemble_object_info::path, Slic3r::PlateData::plate_index, Slic3r::_assemble_plate_info::plate_name, Slic3r::PlateData::plate_name, Slic3r::_assemble_plate_info::plate_params, Slic3r::_assemble_object_info::pos_x, Slic3r::_assemble_object_info::pos_y, Slic3r::_assemble_object_info::pos_z, Slic3r::_assemble_object_info::print_params, Slic3r::_assembled_param_info::print_params, Slic3r::range(), Slic3r::TriangleMesh::ReadSTLFile(), Slic3r::ConfigBase::set_deserialize(), Slic3r::ModelConfig::set_deserialize(), Slic3r::ModelConfig::set_key_value(), Slic3r::ModelObject::translate(), Slic3r::ObjInfo::vertex_colors, and Slic3r::ModelObject::volumes.

Referenced by Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

convert_obj_cluster_colors()

bool convert_obj_cluster_colors	(	std::vector< Slic3r::RGBA > &	input_colors,
		std::vector< RGBA > &	all_colours,
		int	max_filament_count,
		std::vector< unsigned char > &	output_filament_ids )

{
    using namespace Slic3r::GUI;
 
    BOOST_LOG_TRIVIAL(info) << boost::format("%1%:%2%, got original input obj colors %3%")%__FUNCTION__ %__LINE__ %input_colors.size();
    if (input_colors.size() > 0) {
        std::vector<Slic3r::RGBA> cluster_colors;
        std::vector<int>          cluster_labels;
        char                      cluster_number = -1;
 
        obj_color_deal_algo(input_colors, cluster_colors, cluster_labels, cluster_number, (int)EnforcerBlockerType::ExtruderMax);
        std::vector<int> cluster_color_maps;
 
        BOOST_LOG_TRIVIAL(info) << boost::format("%1%:%2%, after obj_color_deal_algo, cluster_colors size %3%, all_colours size %4%, max_filament_count=%5%")%__FUNCTION__ %__LINE__%cluster_colors.size() %all_colours.size() %max_filament_count;
 
        cluster_color_maps.resize(cluster_colors.size(), 1);
 
        int init_size = all_colours.size();
 
        for (size_t i = 0; i < cluster_colors.size(); i++) {
            if ((init_size + i + 1) <= max_filament_count) {
                all_colours.push_back(cluster_colors[i]);
                cluster_color_maps[i] = all_colours.size();
                BOOST_LOG_TRIVIAL(info) << boost::format("%1%:%2%, cluster color index %3% RGBA {%4%,%5%,%6%,%7%} directly inserted, id %8%")
                    %__FUNCTION__ %__LINE__%(i+1) %cluster_colors[i][0] %cluster_colors[i][1] %cluster_colors[i][2] %cluster_colors[i][3] %cluster_color_maps[i] ;
            }
            else {
                std::vector<ColorDistValue> color_dists;
                color_dists.resize(max_filament_count);
                for (size_t j = 0; j < max_filament_count; j++) {
                    color_dists[j].distance = calc_color_distance(cluster_colors[i], all_colours[j]);
                    color_dists[j].id       = j + 1;
                }
                std::sort(color_dists.begin(), color_dists.end(), [](ColorDistValue &a, ColorDistValue &b) { return a.distance < b.distance; });
                cluster_color_maps[i] = color_dists[0].id;
                BOOST_LOG_TRIVIAL(info) << boost::format("%1%:%2%, cluster color index %3% RGBA {%4%,%5%,%6%,%7%} directly inserted, id %8%")
                    %__FUNCTION__ %__LINE__%(i+1) %cluster_colors[i][0] %cluster_colors[i][1] %cluster_colors[i][2] %cluster_colors[i][3] %cluster_color_maps[i] ;
            }
        }
 
        //3.generate filament_ids
        auto input_colors_size = input_colors.size();
        output_filament_ids.resize(input_colors_size);
        for (size_t i = 0; i < input_colors_size; i++) {
            int label = cluster_labels[i];
            output_filament_ids[i] = cluster_color_maps[label];
        }
 
        BOOST_LOG_TRIVIAL(info) << boost::format("%1%:%2%, all_colours size changes to %3%")%__FUNCTION__ %__LINE__%all_colours.size();
 
        return true;
    }
 
    return false;
}

References Slic3r::GUI::calc_color_distance(), Slic3r::ExtruderMax, and obj_color_deal_algo().

Referenced by construct_assemble_list().

Here is the call graph for this function:

Here is the caller graph for this function:

decode_png_to_thumbnail()

int decode_png_to_thumbnail ( std::string png_file, ThumbnailData & thumbnail_data )

static

{
    if (!boost::filesystem::exists(png_file))
    {
        BOOST_LOG_TRIVIAL(error) << boost::format("can not find file %1%")%png_file;
        return -1;
    }
 
    const std::size_t &size  = boost::filesystem::file_size(png_file);
    std::string png_buffer(size, '\0');
    png_buffer.reserve(size);
 
    boost::filesystem::ifstream ifs(png_file, std::ios::binary);
    ifs.read(png_buffer.data(), png_buffer.size());
    ifs.close();
 
    Slic3r::png::ImageColorscale img;
    Slic3r::png::ReadBuf rb{png_buffer.data(), png_buffer.size()};
    BOOST_LOG_TRIVIAL(info) << boost::format("read png file %1%, size %2%")%png_file %size;
 
    if ( !Slic3r::png::decode_colored_png(rb, img))
    {
        BOOST_LOG_TRIVIAL(error) << boost::format("decode png file %1% failed")%png_file;
        return -2;
    }
 
    thumbnail_data.width = img.cols;
    thumbnail_data.height = img.rows;
    thumbnail_data.pixels = std::move(img.buf);
 
    return 0;
}

References Slic3r::png::Image< PxT >::buf, Slic3r::png::Image< PxT >::cols, Slic3r::png::decode_colored_png(), Slic3r::ThumbnailData::height, Slic3r::ThumbnailData::pixels, Slic3r::png::Image< PxT >::rows, and Slic3r::ThumbnailData::width.

Referenced by Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

default_status_callback()

void default_status_callback

(

const PrintBase::SlicingStatus &

slicing_status

)

{
    if (slicing_status.warning_step != -1) {
        g_slicing_warnings.push_back(slicing_status);
    }
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": percent=%1%, warning_step=%2%, message=%3%, message_type=%4%")%slicing_status.percent %slicing_status.warning_step %slicing_status.text %(int)(slicing_status.message_type);
 
    return;
}

References g_slicing_warnings, Slic3r::PrintBase::SlicingStatus::message_type, Slic3r::PrintBase::SlicingStatus::percent, Slic3r::PrintBase::SlicingStatus::text, and Slic3r::PrintBase::SlicingStatus::warning_step.

Referenced by Slic3r::CLI::run().

Here is the caller graph for this function:

get_printer_technology()

PrinterTechnology get_printer_technology ( const DynamicConfig & config )

static

{
    const ConfigOptionEnum<PrinterTechnology> *opt = config.option<ConfigOptionEnum<PrinterTechnology>>("printer_technology");
    return (opt == nullptr) ? ptUnknown : opt->value;
}

References Slic3r::ConfigBase::option(), and Slic3r::ptUnknown.

Referenced by Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

glfw_callback()

void glfw_callback ( int error_code, const char * description )

static

{
    BOOST_LOG_TRIVIAL(error) << "error_code " <<error_code <<", description: " <<description<< std::endl;
}

Referenced by Slic3r::CLI::run().

Here is the caller graph for this function:

legacy_bed_exclude_area_points()

Pointfs legacy_bed_exclude_area_points ( const DynamicPrintConfig & config )

static

{
    const ConfigOptionPoints *option = config.option<ConfigOptionPoints>("bed_exclude_area");
    return option != nullptr ? option->values : Pointfs{};
}

References Slic3r::ConfigBase::option(), and Slic3r::ConfigOptionVector< T >::values.

Referenced by Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

load_default_gcodes_to_config()

void load_default_gcodes_to_config ( DynamicPrintConfig & config, Preset::Type type )

static

{
    if (config.size() == 0) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__<< ", empty config, return directly";
        return;
    }
    //add those empty gcodes by default
    if (type == Preset::TYPE_PRINTER)
    {
        std::string change_filament_gcode = config.option<ConfigOptionString>("change_filament_gcode", true)->value;
        BOOST_LOG_TRIVIAL(trace) << __FUNCTION__<< ", change_filament_gcode: "<< change_filament_gcode;
 
        ConfigOptionString* layer_change_gcode_opt = config.option<ConfigOptionString>("layer_change_gcode", true);
        BOOST_LOG_TRIVIAL(trace) << __FUNCTION__<< ", layer_change_gcode: "<<layer_change_gcode_opt->value;
 
        ConfigOptionString* machine_end_gcode_opt = config.option<ConfigOptionString>("machine_end_gcode", true);
        BOOST_LOG_TRIVIAL(trace) << __FUNCTION__<< ", machine_end_gcode: "<<machine_end_gcode_opt->value;
 
        ConfigOptionString* machine_pause_gcode_opt = config.option<ConfigOptionString>("machine_pause_gcode", true);
        BOOST_LOG_TRIVIAL(trace) << __FUNCTION__<< ", machine_pause_gcode: "<<machine_pause_gcode_opt->value;
 
        ConfigOptionString* machine_start_gcode_opt = config.option<ConfigOptionString>("machine_start_gcode", true);
        BOOST_LOG_TRIVIAL(trace) << __FUNCTION__<< ", machine_start_gcode: "<<machine_start_gcode_opt->value;
 
        ConfigOptionString* template_custom_gcode_opt = config.option<ConfigOptionString>("template_custom_gcode", true);
        BOOST_LOG_TRIVIAL(trace) << __FUNCTION__<< ", template_custom_gcode: "<<template_custom_gcode_opt->value;
 
        ConfigOptionString* printing_by_object_gcode_opt = config.option<ConfigOptionString>("printing_by_object_gcode", true);
        BOOST_LOG_TRIVIAL(trace) << __FUNCTION__<< ", printing_by_object_gcode: "<<printing_by_object_gcode_opt->value;
 
        ConfigOptionString* before_layer_change_gcode_opt = config.option<ConfigOptionString>("before_layer_change_gcode", true);
        BOOST_LOG_TRIVIAL(trace) << __FUNCTION__<< ", before_layer_change_gcode: "<<before_layer_change_gcode_opt->value;
 
        ConfigOptionString* timeplase_gcode_opt = config.option<ConfigOptionString>("time_lapse_gcode", true);
        BOOST_LOG_TRIVIAL(trace) << __FUNCTION__<< ", time_lapse_gcode: "<<timeplase_gcode_opt->value;
 
        ConfigOptionString *wrapping_detection_gcode_opt = config.option<ConfigOptionString>("wrapping_detection_gcode", true);
        BOOST_LOG_TRIVIAL(trace) << __FUNCTION__ << ", wrapping_detection_gcode: " << wrapping_detection_gcode_opt->value;
    }
    else if (type == Preset::TYPE_FILAMENT)
    {
        std::vector<std::string>& filament_start_gcodes = config.option<ConfigOptionStrings>("filament_start_gcode", true)->values;
        if (filament_start_gcodes.empty()) {
            filament_start_gcodes.resize(1, std::string());
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__<< ", set filament_start_gcodes to empty";
        }
        else {
            BOOST_LOG_TRIVIAL(trace) << __FUNCTION__<< ", filament_start_gcodes: "<<filament_start_gcodes[0];
        }
 
        std::vector<std::string>& filament_end_gcodes = config.option<ConfigOptionStrings>("filament_end_gcode", true)->values;
        if (filament_end_gcodes.empty()) {
            filament_end_gcodes.resize(1, std::string());
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__<< ", set filament_end_gcode to empty";
        }
        else {
            BOOST_LOG_TRIVIAL(trace) << __FUNCTION__<< ", filament_end_gcode: "<<filament_end_gcodes[0];
        }
    }
}

References Slic3r::change_filament_gcode(), Slic3r::ConfigBase::option(), Slic3r::DynamicConfig::size(), Slic3r::trace(), Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINTER, and Slic3r::ConfigOptionSingle< T >::value.

Referenced by Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

load_downward_settings_list_from_config()

void load_downward_settings_list_from_config ( std::string config_file, std::string printer_name, std::string printer_model, std::vector< std::string > & downward_settings )

static

{
    std::map<std::string, std::string> printer_params;
 
    boost::filesystem::path directory_path(config_file);
 
    BOOST_LOG_TRIVIAL(info) << boost::format("%1%, will parse file %2% for printer mode %3%, printer name %4%")%__FUNCTION__ % config_file %printer_model %printer_name;
    if (!fs::exists(directory_path)) {
        BOOST_LOG_TRIVIAL(warning) << boost::format("file %1% not exist.")%config_file;
    }
    else {
        try {
            json root_json;
            boost::nowide::ifstream ifs(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("downward_check")) {
                        json downward_check_json = printer_model_json["downward_check"];
                        if (downward_check_json.contains(printer_name)) {
                            downward_settings = downward_check_json[printer_name].get<std::vector<std::string>>();
                            BOOST_LOG_TRIVIAL(info) << boost::format("got %1% downward settings of %2% in %3%")%downward_settings.size() %printer_name %config_file;
                        }
                        else {
                            BOOST_LOG_TRIVIAL(info) << boost::format("can not find  %1% in downward_check of %2% in %3%")%printer_name %printer_model %config_file;
                        }
                    }
                    else {
                        BOOST_LOG_TRIVIAL(info) << boost::format("can not find downward_check for %1% in %2%")%printer_model%config_file;
                    }
                }
                else {
                    BOOST_LOG_TRIVIAL(info) << boost::format("can not find printer_model %1% in %2%")%printer_model%config_file;
                }
            }
            else {
                BOOST_LOG_TRIVIAL(warning) << boost::format("can not find key printer in %1%")%config_file;
            }
        }
        catch (std::exception &err) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< ": parse file "<<config_file<<" got a generic exception, reason = " << err.what();
        }
    }
}

Referenced by Slic3r::CLI::run().

Here is the caller graph for this function:

load_key_values_from_json()

int load_key_values_from_json ( const std::string & file, std::map< std::string, std::string > & key_values )

static

{
    json j;
    CNumericLocalesSetter locales_setter;
 
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__<< ": begin to parse "<<file;
    try {
        boost::nowide::ifstream ifs(file);
        ifs >> j;
        ifs.close();
 
        //parse the json elements
        for (auto it = j.begin(); it != j.end(); it++) {
            if (boost::iequals(it.key(),BBL_JSON_KEY_MODEL_ID)) {
                key_values.emplace(BBL_JSON_KEY_MODEL_ID, it.value());
            }
            else if (boost::iequals(it.key(), BBL_JSON_KEY_NAME)) {
                key_values.emplace(BBL_JSON_KEY_NAME, it.value());
            }
        }
    }
    catch (const std::ifstream::failure &err)  {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< ": parse "<<file<<" got a ifstream error, reason = " << err.what();
        return -1;
    }
    catch(nlohmann::detail::parse_error &err) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< ": parse "<<file<<" got a nlohmann::detail::parse_error, reason = " << err.what();
        return -2;
    }
    catch(std::exception &err) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< ": parse "<<file<<" got a generic exception, reason = " << err.what();
        return -3;
    }
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__<< ": finished parse, key_values size "<<key_values.size();
    return 0;
}

References BBL_JSON_KEY_MODEL_ID, and BBL_JSON_KEY_NAME.

Referenced by Slic3r::CLI::run().

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char **	argv )

{
#ifndef _WIN32
    // Ignore SIGPIPE so a write to a closed socket (e.g. a dropped printer
    // network connection) returns EPIPE to the caller instead of terminating
    // the whole process. Without this, losing the printer link kills
    // OrcaSlicer with SIGPIPE (exit 141) and produces no crash report.
    std::signal(SIGPIPE, SIG_IGN);
#endif
    return CLI().run(argc, argv);
}

References Slic3r::CLI::run().

Here is the call graph for this function:

merge_or_add_object()

void merge_or_add_object	(	assemble_plate_info_t &	assemble_plate_info,
		Model &	model,
		int	assemble_index,
		std::map< int, ModelObject * > &	merged_objects,
		ModelObject *	ori_object )

{
    if (assemble_index > 0) {
        auto iter = merged_objects.find(assemble_index);
        ModelObject* new_object = nullptr;
        if (iter == merged_objects.end()) {
            //create the object to merge
            new_object = model.add_object();
            new_object->name = "assemble_" + std::to_string(assemble_index);
            merged_objects[assemble_index] = new_object;
            assemble_plate_info.loaded_obj_list.emplace_back(new_object);
            new_object->config.assign_config(ori_object->config.get());
        }
        else
            new_object = iter->second;
 
        for (auto volume : ori_object->volumes) {
            ModelVolume* new_volume = new_object->add_volume(*volume);
            // set extruder id
            new_volume->config.set_key_value("extruder", new ConfigOptionInt(ori_object->config.extruder()));
        }
        BOOST_LOG_TRIVIAL(debug) << boost::format("assemble_index %1%, name %2%, merged to new model %3%") % assemble_index % ori_object->name % new_object->name;
    }
    else {
        ModelObject* new_object = model.add_object(*ori_object);
        assemble_plate_info.loaded_obj_list.emplace_back(new_object);
        BOOST_LOG_TRIVIAL(debug) << boost::format("assemble_index %1%, name %2%, no need to merge, copy to new model") % assemble_index % ori_object->name;
    }
}

References Slic3r::Model::add_object(), Slic3r::ModelObject::add_volume(), Slic3r::ModelConfig::assign_config(), Slic3r::ModelObject::config, Slic3r::ModelVolume::config, Slic3r::ModelConfig::extruder(), Slic3r::ModelConfig::get(), Slic3r::_assemble_plate_info::loaded_obj_list, Slic3r::ModelObject::name, Slic3r::ModelConfig::set_key_value(), and Slic3r::ModelObject::volumes.

Referenced by construct_assemble_list().

Here is the call graph for this function:

Here is the caller graph for this function:

record_exit_reson()

void record_exit_reson	(	std::string	outputdir,
		int	code,
		int	plate_id,
		std::string	error_message,
		sliced_info_t &	sliced_info,
		std::map< std::string, std::string >	key_values = std::map<std::string, std::string>() )

{
#if defined(__linux__) || defined(__LINUX__)
    std::string result_file;
 
    if (!outputdir.empty())
        result_file = outputdir + "/result.json";
    else
        result_file = "result.json";
 
    try {
        json j;
        //record the headers
        if (sliced_info.downward_machines.size() > 0)
            j["downward_compatible_machine"] = sliced_info.downward_machines;
        if (sliced_info.upward_machines.size() > 0)
            j["upward_compatible_machine"] = sliced_info.upward_machines;
        j["plate_index"] = plate_id;
        j["return_code"] = code;
        j["error_string"] = error_message;
        j["prepare_time"] = sliced_info.prepare_time;
        j["export_time"] = sliced_info.export_time;
    j["layer_height"] = sliced_info.layer_height;
    j["wall_loops"] = sliced_info.wall_loops;
        j["sparse_infill_density"] = sliced_info.sparse_infill_density;
        for (size_t index = 0; index < sliced_info.sliced_plates.size(); index++)
        {
            json plate_json;
            plate_json["id"] = sliced_info.sliced_plates[index].plate_id;
            plate_json["sliced_time"] = sliced_info.sliced_plates[index].sliced_time;
            plate_json["sliced_time_with_cache"] = sliced_info.sliced_plates[index].sliced_time_with_cache;
            plate_json["triangle_count"] = sliced_info.sliced_plates[index].triangle_count;
            plate_json["warning_message"] = sliced_info.sliced_plates[index].warning_message;
            j["sliced_plates"].push_back(plate_json);
        }
        for (auto& iter: key_values)
            j[iter.first] = iter.second;
 
        j["warnings"]    = sliced_info.warnings;
        j["strict_mode"] = sliced_info.strict_mode;
 
        boost::nowide::ofstream c;
        c.open(result_file, std::ios::out | std::ios::trunc);
        c << j.dump(1, '\t') << std::endl;
        c.close();
 
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format(", saved config to %1%\n")%result_file;
    }
    catch (...) {}
#endif
}

References _sliced_info::downward_machines, _sliced_info::export_time, _sliced_info::layer_height, _sliced_info::prepare_time, _sliced_info::sliced_plates, _sliced_info::sparse_infill_density, _sliced_info::strict_mode, _sliced_info::upward_machines, _sliced_info::wall_loops, and _sliced_info::warnings.

Referenced by Slic3r::CLI::run().

Here is the caller graph for this function:

Variable Documentation

bed3d_ax3s_default_stem_length

const float bed3d_ax3s_default_stem_length = 25.0f

bed3d_ax3s_default_stem_radius

const float bed3d_ax3s_default_stem_radius = 0.5f

bed3d_ax3s_default_tip_length

const float bed3d_ax3s_default_tip_length = 5.0f

bed3d_ax3s_default_tip_radius

const float bed3d_ax3s_default_tip_radius = 2.5f * bed3d_ax3s_default_stem_radius

Referenced by Slic3r::CLI::run().

cli_errors

std::map<int, std::string> cli_errors

                                    {
    {CLI_SUCCESS, "Success."},
    {CLI_ENVIRONMENT_ERROR, "Failed setting up server environment."},
    {CLI_INVALID_PARAMS, "Invalid parameters to the slicer."},
    {CLI_FILE_NOTFOUND, "The input files to the slicer are not found."},
    {CLI_FILELIST_INVALID_ORDER, "File list order to the slicer is invalid. Please make sure the 3mf in the first place."},
    {CLI_CONFIG_FILE_ERROR, "The input preset file is invalid and can not be parsed."},
    {CLI_DATA_FILE_ERROR, "The input model file to the slicer can not be parsed."},
    {CLI_INVALID_PRINTER_TECH, "Unsupported printer technology (not FDM)."},
    {CLI_UNSUPPORTED_OPERATION, "Unsupported CLI instruction."},
    {CLI_COPY_OBJECTS_ERROR, "Failed copying objects."},
    {CLI_SCALE_TO_FIT_ERROR, "Failed scaling an object to fit the plate."},
    {CLI_EXPORT_STL_ERROR, "Failed exporting STL files."},
    {CLI_EXPORT_OBJ_ERROR, "Failed exporting OBJ files."},
    {CLI_EXPORT_3MF_ERROR, "Failed exporting 3mf files."},
    {CLI_OUT_OF_MEMORY, "Out of memory during slicing. Please upload a model with lower geometry resolution and try again."},
    {CLI_3MF_NOT_SUPPORT_MACHINE_CHANGE, "The selected printer is not supported."},
    {CLI_3MF_NEW_MACHINE_NOT_SUPPORTED, "The selected printer is not compatible with the 3mf."},
    {CLI_PROCESS_NOT_COMPATIBLE, "The selected printer is not compatible with the process preset in the 3mf."},
    {CLI_INVALID_VALUES_IN_3MF, "Invalid parameter value(s) included in the 3mf file."},
    {CLI_POSTPROCESS_NOT_SUPPORTED, "post_process is not supported under CLI."},
    {CLI_PRINTABLE_SIZE_REDUCED, "The selected printer's bed size is smaller than the bed size used in the print profile."},
    {CLI_OBJECT_ARRANGE_FAILED, "An error occurred when auto-arranging object(s)."},
    {CLI_OBJECT_ORIENT_FAILED, "An error occurred when auto-orienting object(s)."},
    {CLI_MODIFIED_PARAMS_TO_PRINTER, "Found modified parameter in printer preset in the 3mf file, which should not be changed."},
        {CLI_FILE_VERSION_NOT_SUPPORTED, "Unsupported 3MF version. Please make sure the 3MF file was created with the official version of Bambu Studio, not a beta version."},
    {CLI_EXPORT_STATISTICS_ERROR, "Failed exporting the G-code statistics."},
    {CLI_NO_SUITABLE_OBJECTS, "The plate has nothing to slice: it is empty, or no object on it is both printable and fully inside the print volume."},
    {CLI_VALIDATE_ERROR, "There are some incorrect slicing parameters in the 3mf. Please verify the slicing of all plates in Orca Slicer before uploading."},
    {CLI_OBJECTS_PARTLY_INSIDE, "Some objects are located over the boundary of the heated bed."},
    {CLI_EXPORT_CACHE_DIRECTORY_CREATE_FAILED, "Failed creating directory when exporting cache data."},
    {CLI_EXPORT_CACHE_WRITE_FAILED, "Failed exporting cache data."},
    {CLI_IMPORT_CACHE_NOT_FOUND, "Cache data not found."},
    {CLI_IMPORT_CACHE_DATA_CAN_NOT_USE, "Cache data can not be parsed."},
    {CLI_IMPORT_CACHE_LOAD_FAILED, "Failed importing cache data."},
    {CLI_SLICING_TIME_EXCEEDS_LIMIT, "Slicing time of a certain plate exceeds the limit. Please simplify the model or use a larger slicing layer height."},
    {CLI_TRIANGLE_COUNT_EXCEEDS_LIMIT, "Triangle count of single plate exceeds the limit. Please simplify the model and try to upload again."},
    {CLI_NO_SUITABLE_OBJECTS_AFTER_SKIP, "No printable objects to slice after skipping."},
    {CLI_FILAMENT_NOT_MATCH_BED_TYPE, "Filaments are not compatible with the plate type. Please verify the slicing of all plates in Orca Slicer before uploading."},
    {CLI_FILAMENTS_DIFFERENT_TEMP, "The temperature difference of the filaments used is too large. Please verify the slicing of all plates in Orca Slicer before uploading."},
    {CLI_OBJECT_COLLISION_IN_SEQ_PRINT, "Object conflicts were detected when using print-by-object mode. Please verify the slicing of all plates in Orca Slicer before uploading."},
    {CLI_OBJECT_COLLISION_IN_LAYER_PRINT, "Object conflicts were detected. Please verify the slicing of all plates in Orca Slicer before uploading."},
    {CLI_SPIRAL_MODE_INVALID_PARAMS, "Some slicing parameters cannot work with Spiral Vase mode. Please solve the issue in Orca Slicer before uploading."},
    {CLI_FILAMENT_CAN_NOT_MAP, "Some filaments cannot be mapped to correct extruders for multi-extruder Printer."},
    {CLI_ONLY_ONE_TPU_SUPPORTED, "Not support printing 2 or more TPU filaments."},
    {CLI_FILAMENTS_NOT_SUPPORTED_BY_EXTRUDER, "Some filaments cannot be printed on the extruder mapped to."},
    {CLI_MIXED_FILAMENT_INVALID, "A mixed filament is invalid: its components are different filament types, or it has no filament of its own."},
    {CLI_SLICING_ERROR, "Failed slicing the model. Please verify the slicing of all plates on Orca Slicer before uploading."},
    {CLI_GCODE_PATH_CONFLICTS, " G-code conflicts detected after slicing. Please make sure the 3mf file can be successfully sliced in the latest Orca Slicer. If the file slices normally in Orca Slicer, try moving the wipe tower further from other models, as we use more conservative parameters for it during upload."},
    {CLI_GCODE_PATH_IN_UNPRINTABLE_AREA, "Found G-code in unprintable area of multi-extruder printers after slicing. Please make sure the 3mf file can be successfully sliced in the latest Orca Slicer."}
};

Referenced by Slic3r::CLI::run().

g_slicing_warnings

std::vector<PrintBase::SlicingStatus> g_slicing_warnings

Referenced by default_status_callback(), and Slic3r::CLI::run().

gcodes_key_set

std::set<std::string> gcodes_key_set

static

Initial value:

=  {"filament_end_gcode", "filament_start_gcode", "change_filament_gcode", "layer_change_gcode", "machine_end_gcode", "machine_pause_gcode", "machine_start_gcode",
            "template_custom_gcode", "printing_by_object_gcode", "before_layer_change_gcode", "time_lapse_gcode", "wrapping_detection_gcode"}

                                           {"filament_end_gcode", "filament_start_gcode", "change_filament_gcode", "layer_change_gcode", "machine_end_gcode", "machine_pause_gcode", "machine_start_gcode",
            "template_custom_gcode", "printing_by_object_gcode", "before_layer_change_gcode", "time_lapse_gcode", "wrapping_detection_gcode"};