OrcaSlicer_profile_validator.cpp File Reference

#include "nanosvg/nanosvg.h"
#include "nanosvg/nanosvgrast.h"
#include <vector>
#include <boost/filesystem/path.hpp>
#include <map>
#include "libslic3r/Point.hpp"
#include "libslic3r/libslic3r.h"
#include "libslic3r/Polygon.hpp"
#include "libslic3r/PrintConfig.hpp"
#include <utility>
#include "libslic3r/CustomGCode.hpp"
#include <iterator>
#include <boost/smart_ptr/make_shared_object.hpp>
#include <boost/smart_ptr/shared_ptr.hpp>
#include <boost/log/core/record_view.hpp>
#include <boost/log/expressions/message.hpp>
#include <cstddef>
#include <exception>
#include "libslic3r/PlaceholderParser.hpp"
#include <boost/program_options/options_description.hpp>
#include <boost/program_options/value_semantic.hpp>
#include <boost/program_options/variables_map.hpp>
#include <boost/program_options/errors.hpp>
#include "libslic3r/BoundingBox.hpp"
#include "libslic3r/GCode.hpp"
#include "libslic3r/GCode/WipeTower.hpp"
#include "libslic3r/GCode/WipeTowerEstimate.hpp"
#include "libslic3r/Geometry.hpp"
#include "libslic3r/Preset.hpp"
#include "libslic3r/Config.hpp"
#include "libslic3r/PresetBundle.hpp"
#include "libslic3r/Print.hpp"
#include "libslic3r/Model.hpp"
#include "libslic3r/TriangleMesh.hpp"
#include "libslic3r/Utils.hpp"
#include <boost/algorithm/string/predicate.hpp>
#include <boost/filesystem/operations.hpp>
#include <boost/log/trivial.hpp>
#include <boost/log/core.hpp>
#include <boost/log/expressions.hpp>
#include <boost/log/sinks/sync_frontend.hpp>
#include <boost/log/sinks/text_ostream_backend.hpp>
#include <boost/core/null_deleter.hpp>
#include <boost/make_shared.hpp>
#include <boost/program_options.hpp>
#include <algorithm>
#include <fstream>
#include <iostream>
#include <set>
#include <string>
#include "libslic3r/AppConfig.hpp"
#include "libslic3r/Format/STEP.hpp"

Go to the source code of this file.

Namespaces
namespace	anonymous_namespace{OrcaSlicer_profile_validator.cpp}

Macros
#define	NANOSVG_IMPLEMENTATION
#define	NANOSVGRAST_IMPLEMENTATION

Typedefs
using	anonymous_namespace{OrcaSlicer_profile_validator.cpp}::Templates = std::set<std::pair<std::string, std::string>>

Functions
void	generate_custom_presets (PresetBundle *preset_bundle, AppConfig &app_config)
Vec2d	anonymous_namespace{OrcaSlicer_profile_validator.cpp}::printable_area_center (const DynamicPrintConfig &cfg)
Vec2d	anonymous_namespace{OrcaSlicer_profile_validator.cpp}::place_wipe_tower (DynamicPrintConfig &cfg, const Vec2d &center)
std::string	anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_two_color_cube_and_export (DynamicPrintConfig cfg, bool is_bbl, bool by_object)
void	anonymous_namespace{OrcaSlicer_profile_validator.cpp}::select_printer_default_presets (PresetBundle &bundle)
void	anonymous_namespace{OrcaSlicer_profile_validator.cpp}::install_slice_context_log_sink ()
DynamicPrintConfig	anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_config (PresetBundle &bundle)
std::string	anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_selection (PresetBundle &bundle, const std::string &what, bool by_object, const std::string &outdir, const std::string &file_base)
Templates	anonymous_namespace{OrcaSlicer_profile_validator.cpp}::preset_templates (const DynamicPrintConfig &cfg)
int	anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_all_printers (const std::string &vendor, const std::string &outdir)
int	main (int argc, char *argv[])

Variables
static std::string	anonymous_namespace{OrcaSlicer_profile_validator.cpp}::g_slice_context

Macro Definition Documentation

NANOSVG_IMPLEMENTATION

#define NANOSVG_IMPLEMENTATION

NANOSVGRAST_IMPLEMENTATION

#define NANOSVGRAST_IMPLEMENTATION

Function Documentation

generate_custom_presets()

void generate_custom_presets	(	PresetBundle *	preset_bundle,
		AppConfig &	app_config )

{
    struct cus_preset
    {
        std::string name;
        std::string parent_name;
    };
    // create user presets
    auto createCustomPrinters = [&](Preset::Type type) {
        std::vector<cus_preset> custom_preset;
        PresetCollection*                            collection = nullptr;
        if (type == Preset::TYPE_PRINT)
            collection = &preset_bundle->prints;
        else if (type == Preset::TYPE_FILAMENT)
            collection = &preset_bundle->filaments;
        else if (type == Preset::TYPE_PRINTER)
            collection = &preset_bundle->printers;
        else
            return;
        custom_preset.reserve(collection->size());
        for (auto& parent : collection->get_presets()) {
            if (!parent.is_system)
                continue;
            auto new_name = parent.name + "_orca_test";
            if (parent.vendor)
                new_name = parent.vendor->name + "_" + new_name;
            custom_preset.push_back({new_name, parent.name});
        }
        for (auto p : custom_preset) {
            // Creating a new preset.
            auto parent = collection->find_preset(p.parent_name);
            auto vendor = collection->get_preset_with_vendor_profile(*parent);
            if (type == Preset::TYPE_FILAMENT) {
                parent->config.set_key_value("filament_start_gcode",
                                             new ConfigOptionStrings({"this_is_orca_test_filament_start_gcode_mock"}));
                parent->config.set_key_value("filament_notes", new ConfigOptionString(vendor.vendor->name));
            } else if (type == Preset::TYPE_PRINT) {
                parent->config.set_key_value("filename_format", new ConfigOptionString("this_is_orca_test_filename_format_mock"));
                parent->config.set_key_value("notes", new ConfigOptionString(vendor.vendor->name));
            } else if (type == Preset::TYPE_PRINTER) {
                parent->config.set_key_value("machine_start_gcode", new ConfigOptionString("this_is_orca_test_machine_start_gcode_mock"));
                parent->config.set_key_value("printer_notes", new ConfigOptionString(vendor.vendor->name));
            }
 
            collection->save_current_preset(p.name, false, false, parent);
 
        }
    };
    createCustomPrinters(Preset::TYPE_PRINTER);
    createCustomPrinters(Preset::TYPE_FILAMENT);
    createCustomPrinters(Preset::TYPE_PRINT);
 
    std::string       user_sub_folder  = DEFAULT_USER_FOLDER_NAME;
    const std::string dir_user_presets = data_dir() + "/" + PRESET_USER_DIR + "/" + user_sub_folder;
 
    fs::path user_folder(data_dir() + "/" + PRESET_USER_DIR);
    if (!fs::exists(user_folder))
        fs::create_directory(user_folder);
 
    fs::path folder(dir_user_presets);
    if (!fs::exists(folder))
        fs::create_directory(folder);
    std::map<std::string, std::string> need_to_delete_list; // store setting ids of preset
 
    preset_bundle->prints.save_user_presets(dir_user_presets, PRESET_PRINT_NAME, need_to_delete_list);
    preset_bundle->filaments.save_user_presets(dir_user_presets, PRESET_FILAMENT_NAME, need_to_delete_list);
    preset_bundle->printers.save_user_presets(dir_user_presets, PRESET_PRINTER_NAME, need_to_delete_list);
 
    std::cout << "Custom presets generated successfully" << std::endl;
}

References Slic3r::ConfigOptionString, Slic3r::data_dir(), DEFAULT_USER_FOLDER_NAME, Slic3r::PresetBundle::filaments, Slic3r::PresetCollection::find_preset(), Slic3r::PresetCollection::get_preset_with_vendor_profile(), Slic3r::PresetCollection::get_presets(), PRESET_FILAMENT_NAME, PRESET_PRINT_NAME, PRESET_PRINTER_NAME, PRESET_USER_DIR, Slic3r::PresetBundle::printers, Slic3r::PresetBundle::prints, Slic3r::PresetCollection::save_current_preset(), Slic3r::PresetCollection::save_user_presets(), Slic3r::PresetCollection::size(), Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, and Slic3r::Preset::TYPE_PRINTER.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char *	argv[] )

{
    po::options_description desc("Orca Profile Validator\nUsage");
    // clang-format off
    desc.add_options()("help,h", "help")
#ifdef __APPLE__
    ("path,p", po::value<std::string>()->default_value("../../../../../../../resources/profiles"), "profile folder")
#else
    ("path,p", po::value<std::string>()->default_value("../../../resources/profiles"), "profile folder")
#endif
    ("vendor,v", po::value<std::string>()->default_value(""), "Vendor name. Optional, all profiles present in the folder will be validated if not specified")
    ("generate_presets,g", po::value<bool>()->default_value(false), "Generate user presets for mock test")
    ("slice,s", po::bool_switch()->default_value(false), "Slice a two-colour cube through every printer, and through every other system process and filament preset whose templates no printer's own slice expands, so every custom g-code and filename_format shipped is expanded, names in {if} branches not taken included (catches placeholder/flow errors that static checks miss). Off unless this flag is present.")
    ("outdir,o", po::value<std::string>()->default_value(""), "With -s, also save each slice's g-code to this folder (as <vendor>__<printer>[__<preset>].gcode) for manual inspection. Optional.")
    ("check_filament_subtypes,f", po::bool_switch()->default_value(true), "Also flag printers with duplicate (ambiguous) filament subtypes. Off unless this flag is present.")
    ("log_level,l", po::value<int>()->default_value(2), "Log level. Optional, default is 2 (warning). Higher values produce more detailed logs.");
    // clang-format on
 
    po::variables_map vm;
    try {
        po::store(po::parse_command_line(argc, argv, desc), vm);
 
        if (vm.count("help")) {
            std::cout << desc << "\n";
            return 1;
        }
 
        po::notify(vm);
    } catch (const po::error& e) {
        std::cerr << "Error: " << e.what() << "\n";
        std::cerr << desc << "\n";
        return 1;
    }
 
    std::string path                 = vm["path"].as<std::string>();
    std::string vendor               = vm["vendor"].as<std::string>();
    int         log_level            = vm["log_level"].as<int>();
    bool        generate_user_preset = vm["generate_presets"].as<bool>();
    bool        slice_mode           = vm["slice"].as<bool>();
    std::string slice_outdir         = vm["outdir"].as<std::string>();
    bool        check_filament_subtypes = vm["check_filament_subtypes"].as<bool>();
 
    //  check if path is valid, and return error if not
    if (!fs::exists(path) || !fs::is_directory(path)) {
        std::cerr << "Error: " << path << " is not a valid directory\n";
        return 1;
    }
 
    // std::cout<<"path: "<<path<<std::endl;
    // std::cout<<"vendor: "<<vendor<<std::endl;
    // std::cout<<"log_level: "<<log_level<<std::endl;
 
    set_data_dir(path);
    // Orca: the profiles folder lives at <resources>/profiles, so point resources_dir() at that
    // <resources> parent. Without this, resources_dir() is empty and slice mode's HRC lookup
    // (info/nozzle_info.json) resolves to a non-existent relative path and falls back to a
    // built-in table (logging a spurious parse error and dropping the E3D entry).
    if (fs::exists(fs::path(path).parent_path() / "info"))
        set_resources_dir(fs::path(path).parent_path().string());
 
    auto user_dir = fs::path(Slic3r::data_dir()) / PRESET_USER_DIR;
    user_dir.make_preferred();
    if (!fs::exists(user_dir))
        fs::create_directory(user_dir);
 
    set_logging_level(log_level);
 
    // Slice mode expands every printer's custom g-code by actually slicing (see slice_all_printers).
    // A distinct opt-in mode so the default static checks stay fast for every profile PR.
    if (slice_mode)
        return slice_all_printers(vendor, slice_outdir);
 
    auto preset_bundle = new PresetBundle();
    // preset_bundle->setup_directories();
    preset_bundle->set_is_validation_mode(true);
    preset_bundle->set_vendor_to_validate(vendor);
 
    preset_bundle->set_default_suppressed(true);
    AppConfig app_config;
    app_config.set("preset_folder", "default");
 
    if(generate_user_preset)
        preset_bundle->remove_user_presets_directory("default");
 
    try {
        auto preset_substitutions = preset_bundle->load_presets(app_config, ForwardCompatibilitySubstitutionRule::Disable);
    } catch (const std::exception& ex) {
        BOOST_LOG_TRIVIAL(error) << ex.what();
        std::cout << "Validation failed" << std::endl;
        return 1;
    }
    // Report loaded presets
    std::cout << "Total loaded vendors: " << preset_bundle->vendors.size() << std::endl;
 
    if (generate_user_preset) {
        generate_custom_presets(preset_bundle, app_config);
        return 0;
    }
 
    if (preset_bundle->has_errors(check_filament_subtypes)) {
        std::cout << "Validation failed" << std::endl;
        return 1;
    }
 
    std::cout << "Validation completed successfully" << std::endl;
    return 0;
}

References Slic3r::data_dir(), Slic3r::Disable, generate_custom_presets(), PRESET_USER_DIR, Slic3r::AppConfig::set(), Slic3r::set_data_dir(), Slic3r::set_logging_level(), Slic3r::set_resources_dir(), and anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_all_printers().

Here is the call graph for this function: