mirror of
https://git.mirrors.martin98.com/https://github.com/slic3r/Slic3r.git
synced 2025-07-30 21:12:00 +08:00
418 lines
16 KiB
C++
418 lines
16 KiB
C++
#include "slic3r.hpp"
|
|
#include "Geometry.hpp"
|
|
#include "IO.hpp"
|
|
#include "SLAPrint.hpp"
|
|
#include "Print.hpp"
|
|
#include "SimplePrint.hpp"
|
|
#include "TriangleMesh.hpp"
|
|
#include "libslic3r.h"
|
|
#include <cmath>
|
|
#include <chrono>
|
|
#include <cstdio>
|
|
#include <string>
|
|
#include <cstring>
|
|
#include <iomanip>
|
|
#include <iostream>
|
|
#include <math.h>
|
|
#include <boost/filesystem.hpp>
|
|
#include <boost/nowide/args.hpp>
|
|
#include <boost/nowide/iostream.hpp>
|
|
#include <stdexcept>
|
|
|
|
#ifdef USE_WX
|
|
#include "GUI/GUI.hpp"
|
|
#endif
|
|
|
|
using namespace Slic3r;
|
|
|
|
#ifndef BUILD_TEST
|
|
int
|
|
main(int argc, char **argv) {
|
|
return CLI().run(argc, argv);
|
|
}
|
|
#endif // BUILD_TEST
|
|
|
|
int CLI::run(int argc, char **argv) {
|
|
// Convert arguments to UTF-8 (needed on Windows).
|
|
// argv then points to memory owned by a.
|
|
boost::nowide::args a(argc, argv);
|
|
|
|
// parse all command line options into a DynamicConfig
|
|
t_config_option_keys opt_order;
|
|
this->config_def.merge(cli_actions_config_def);
|
|
this->config_def.merge(cli_transform_config_def);
|
|
this->config_def.merge(cli_misc_config_def);
|
|
this->config_def.merge(print_config_def);
|
|
this->config.def = &this->config_def;
|
|
|
|
// if any option is unsupported, print usage and abort immediately
|
|
if (!this->config.read_cli(argc, argv, &this->input_files, &opt_order)) {
|
|
this->print_help();
|
|
return 1;
|
|
}
|
|
|
|
// parse actions and transform options
|
|
for (auto const &opt_key : opt_order) {
|
|
if (cli_actions_config_def.has(opt_key)) this->actions.push_back(opt_key);
|
|
if (cli_transform_config_def.has(opt_key)) this->transforms.push_back(opt_key);
|
|
}
|
|
|
|
// load config files supplied via --load
|
|
for (auto const &file : config.getStrings("load")) {
|
|
if (!boost::filesystem::exists(file)) {
|
|
if (config.getBool("ignore_nonexistent_file", false)) {
|
|
continue;
|
|
} else {
|
|
boost::nowide::cerr << "No such file: " << file << std::endl;
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
DynamicPrintConfig c;
|
|
try {
|
|
c.load(file);
|
|
} catch (std::exception &e) {
|
|
boost::nowide::cerr << "Error while reading config file: " << e.what() << std::endl;
|
|
exit(1);
|
|
}
|
|
c.normalize();
|
|
this->print_config.apply(c);
|
|
}
|
|
|
|
// apply command line options to a more specific DynamicPrintConfig which provides normalize()
|
|
// (command line options override --load files)
|
|
this->print_config.apply(config, true);
|
|
this->print_config.normalize();
|
|
|
|
// create a static (full) print config to be used in our logic
|
|
this->full_print_config.apply(this->print_config);
|
|
|
|
// validate config
|
|
try {
|
|
this->full_print_config.validate();
|
|
} catch (InvalidOptionException &e) {
|
|
boost::nowide::cerr << e.what() << std::endl;
|
|
return 1;
|
|
}
|
|
|
|
// read input file(s) if any
|
|
for (auto const &file : input_files) {
|
|
Model model;
|
|
try {
|
|
model = Model::read_from_file(file);
|
|
} catch (std::exception &e) {
|
|
boost::nowide::cerr << file << ": " << e.what() << std::endl;
|
|
exit(1);
|
|
}
|
|
|
|
if (model.objects.empty()) {
|
|
boost::nowide::cerr << "Error: file is empty: " << file << std::endl;
|
|
continue;
|
|
}
|
|
|
|
this->models.push_back(model);
|
|
}
|
|
|
|
// loop through transform options
|
|
for (auto const &opt_key : this->transforms) {
|
|
if (opt_key == "merge") {
|
|
Model m;
|
|
for (auto &model : this->models)
|
|
m.merge(model);
|
|
this->models = {m};
|
|
} else if (opt_key == "duplicate") {
|
|
const BoundingBoxf bb{ this->full_print_config.bed_shape.values };
|
|
for (auto &model : this->models) {
|
|
const bool all_objects_have_instances = std::none_of(
|
|
model.objects.begin(), model.objects.end(),
|
|
[](ModelObject* o){ return o->instances.empty(); }
|
|
);
|
|
if (all_objects_have_instances) {
|
|
// if all input objects have defined position(s) apply duplication to the whole model
|
|
model.duplicate(this->config.getInt("duplicate"), this->full_print_config.min_object_distance(), &bb);
|
|
} else {
|
|
model.add_default_instances();
|
|
model.duplicate_objects(this->config.getInt("duplicate"), this->full_print_config.min_object_distance(), &bb);
|
|
}
|
|
}
|
|
} else if (opt_key == "duplicate_grid") {
|
|
auto &ints = this->config.opt<ConfigOptionInts>("duplicate_grid")->values;
|
|
const int x = ints.size() > 0 ? ints.at(0) : 1;
|
|
const int y = ints.size() > 1 ? ints.at(1) : 1;
|
|
const double distance = this->full_print_config.duplicate_distance.value;
|
|
for (auto &model : this->models)
|
|
model.duplicate_objects_grid(x, y, (distance > 0) ? distance : 6); // TODO: this is not the right place for setting a default
|
|
} else if (opt_key == "center") {
|
|
for (auto &model : this->models) {
|
|
model.center_instances_around_point(config.opt<ConfigOptionPoint>("center")->value);
|
|
model.align_to_ground();
|
|
}
|
|
} else if (opt_key == "align_xy") {
|
|
const Pointf p{ this->config.opt<ConfigOptionPoint>("align_xy")->value };
|
|
for (auto &model : this->models) {
|
|
BoundingBoxf3 bb{ model.bounding_box() };
|
|
model.translate(-(bb.min.x - p.x), -(bb.min.y - p.y), -bb.min.z);
|
|
}
|
|
} else if (opt_key == "rotate") {
|
|
for (auto &model : this->models)
|
|
for (auto &o : model.objects)
|
|
o->rotate(Geometry::deg2rad(config.getFloat(opt_key)), Z);
|
|
} else if (opt_key == "rotate_x") {
|
|
for (auto &model : this->models)
|
|
for (auto &o : model.objects)
|
|
o->rotate(Geometry::deg2rad(config.getFloat(opt_key)), X);
|
|
} else if (opt_key == "rotate_y") {
|
|
for (auto &model : this->models)
|
|
for (auto &o : model.objects)
|
|
o->rotate(Geometry::deg2rad(config.getFloat(opt_key)), Y);
|
|
} else if (opt_key == "scale") {
|
|
for (auto &model : this->models)
|
|
for (auto &o : model.objects)
|
|
o->scale(config.get_abs_value(opt_key, 1));
|
|
} else if (opt_key == "scale_to_fit") {
|
|
const auto opt = config.opt<ConfigOptionPoint3>(opt_key);
|
|
if (!opt->is_positive_volume()) {
|
|
boost::nowide::cerr << "--scale-to-fit requires a positive volume" << std::endl;
|
|
return 1;
|
|
}
|
|
for (auto &model : this->models)
|
|
for (auto &o : model.objects)
|
|
o->scale_to_fit(opt->value);
|
|
} else if (opt_key == "cut" || opt_key == "cut_x" || opt_key == "cut_y") {
|
|
std::vector<Model> new_models;
|
|
for (auto &model : this->models) {
|
|
model.repair();
|
|
model.translate(0, 0, -model.bounding_box().min.z); // align to z = 0
|
|
|
|
Model out;
|
|
for (auto &o : model.objects) {
|
|
if (opt_key == "cut_x") {
|
|
o->cut(X, config.getFloat("cut_x"), &out);
|
|
} else if (opt_key == "cut_y") {
|
|
o->cut(Y, config.getFloat("cut_y"), &out);
|
|
} else if (opt_key == "cut") {
|
|
o->cut(Z, config.getFloat("cut"), &out);
|
|
}
|
|
}
|
|
|
|
// add each resulting object as a distinct model
|
|
Model upper, lower;
|
|
auto upper_obj = upper.add_object(*out.objects[0]);
|
|
auto lower_obj = lower.add_object(*out.objects[1]);
|
|
|
|
if (upper_obj->facets_count() > 0) new_models.push_back(upper);
|
|
if (lower_obj->facets_count() > 0) new_models.push_back(lower);
|
|
}
|
|
|
|
// TODO: copy less stuff around using pointers
|
|
this->models = new_models;
|
|
|
|
if (this->actions.empty())
|
|
this->actions.push_back("export_stl");
|
|
} else if (opt_key == "cut_grid") {
|
|
std::vector<Model> new_models;
|
|
for (auto &model : this->models) {
|
|
TriangleMesh mesh = model.mesh();
|
|
mesh.repair();
|
|
|
|
TriangleMeshPtrs meshes = mesh.cut_by_grid(config.opt<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
|
|
this->models = new_models;
|
|
|
|
if (this->actions.empty())
|
|
this->actions.push_back("export_stl");
|
|
} else if (opt_key == "split") {
|
|
for (auto &model : this->models)
|
|
model.split();
|
|
} else if (opt_key == "repair") {
|
|
for (auto &model : this->models)
|
|
model.repair();
|
|
} else {
|
|
boost::nowide::cerr << "error: option not implemented yet: " << opt_key << std::endl;
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
// loop through action options
|
|
for (auto const &opt_key : this->actions) {
|
|
if (opt_key == "help") {
|
|
this->print_help();
|
|
} else if (opt_key == "help_options") {
|
|
this->print_help(true);
|
|
} else if (opt_key == "save") {
|
|
this->print_config.save(config.getString("save"));
|
|
} else if (opt_key == "info") {
|
|
// --info works on unrepaired model
|
|
for (const Model &model : this->models)
|
|
model.print_info();
|
|
} else if (opt_key == "export_stl") {
|
|
this->export_models(IO::STL);
|
|
} else if (opt_key == "export_obj") {
|
|
this->export_models(IO::OBJ);
|
|
} else if (opt_key == "export_pov") {
|
|
this->export_models(IO::POV);
|
|
} else if (opt_key == "export_amf") {
|
|
this->export_models(IO::AMF);
|
|
} else if (opt_key == "export_3mf") {
|
|
this->export_models(IO::TMF);
|
|
} else if (opt_key == "export_sla") {
|
|
boost::nowide::cerr << "--export-sla is not implemented yet" << std::endl;
|
|
} else if (opt_key == "export_sla_svg") {
|
|
for (const Model &model : this->models) {
|
|
SLAPrint print(&model); // initialize print with model
|
|
print.config.apply(this->print_config, true); // apply configuration
|
|
print.slice(); // slice file
|
|
const std::string outfile = this->output_filepath(model, IO::SVG);
|
|
print.write_svg(outfile); // write SVG
|
|
boost::nowide::cout << "SVG file exported to " << outfile << std::endl;
|
|
}
|
|
} else if (opt_key == "export_gcode") {
|
|
for (const Model &model : this->models) {
|
|
SimplePrint print;
|
|
print.status_cb = [](int ln, const std::string& msg) {
|
|
boost::nowide::cout << msg << std::endl;
|
|
};
|
|
print.apply_config(this->print_config);
|
|
print.center = !this->config.has("center")
|
|
&& !this->config.has("align_xy")
|
|
&& !this->config.getBool("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::nowide::cout << "G-code exported to " << outfile << std::endl;
|
|
|
|
// output some statistics
|
|
double duration { std::chrono::duration_cast<second_>(clock_::now() - t0).count() };
|
|
boost::nowide::cout << 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;
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
if (actions.empty()) {
|
|
#ifdef USE_WX
|
|
GUI::App *gui = new GUI::App();
|
|
gui->autosave = this->config.getString("autosave");
|
|
gui->datadir = this->config.getString("datadir");
|
|
GUI::App::SetInstance(gui);
|
|
wxEntry(argc, argv);
|
|
#else
|
|
std::cout << "GUI support has not been built." << "\n";
|
|
#endif
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
CLI::print_help(bool include_print_options) const {
|
|
boost::nowide::cout
|
|
<< "Slic3r " << SLIC3R_VERSION << " (build commit: " << BUILD_COMMIT << ")" << std::endl
|
|
<< "https://slic3r.org/ - https://github.com/slic3r/Slic3r" << std::endl << std::endl
|
|
<< "Usage: slic3r [ ACTIONS ] [ TRANSFORM ] [ OPTIONS ] [ file.stl ... ]" << std::endl
|
|
<< std::endl
|
|
<< "Actions:" << std::endl;
|
|
cli_actions_config_def.print_cli_help(boost::nowide::cout, false);
|
|
|
|
boost::nowide::cout
|
|
<< std::endl
|
|
<< "Transform options:" << std::endl;
|
|
cli_transform_config_def.print_cli_help(boost::nowide::cout, false);
|
|
|
|
boost::nowide::cout
|
|
<< std::endl
|
|
<< "Other options:" << std::endl;
|
|
cli_misc_config_def.print_cli_help(boost::nowide::cout, false);
|
|
|
|
if (include_print_options) {
|
|
boost::nowide::cout << std::endl;
|
|
print_config_def.print_cli_help(boost::nowide::cout, true);
|
|
} else {
|
|
boost::nowide::cout
|
|
<< std::endl
|
|
<< "Run --help-options to see the full listing of print/G-code options." << std::endl;
|
|
}
|
|
}
|
|
|
|
void
|
|
CLI::export_models(IO::ExportFormat format) {
|
|
for (size_t i = 0; i < this->models.size(); ++i) {
|
|
Model &model = this->models[i];
|
|
const std::string outfile = this->output_filepath(model, format);
|
|
|
|
IO::write_model.at(format)(model, outfile);
|
|
std::cout << "File exported to " << outfile << std::endl;
|
|
}
|
|
}
|
|
|
|
std::string
|
|
CLI::output_filepath(const Model &model, IO::ExportFormat format) const {
|
|
// get the --output-filename-format option
|
|
std::string filename_format = this->print_config.getString("output_filename_format", "[input_filename_base]");
|
|
|
|
// strip the file extension and add the correct one
|
|
filename_format = filename_format.substr(0, filename_format.find_last_of("."));
|
|
filename_format += "." + IO::extensions.at(format);
|
|
|
|
// this is the same logic used in Print::output_filepath()
|
|
// TODO: factor it out to a single place?
|
|
|
|
// find the first input_file of the model
|
|
boost::filesystem::path input_file;
|
|
for (auto o : model.objects) {
|
|
if (!o->input_file.empty()) {
|
|
input_file = o->input_file;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// compute the automatic filename
|
|
PlaceholderParser pp;
|
|
pp.set("input_filename", input_file.filename().string());
|
|
pp.set("input_filename_base", input_file.stem().string());
|
|
pp.apply_config(this->config);
|
|
const std::string filename = pp.process(filename_format);
|
|
|
|
// use --output when available
|
|
std::string outfile{ this->config.getString("output") };
|
|
if (!outfile.empty()) {
|
|
// if we were supplied a directory, use it and append our automatically generated filename
|
|
const boost::filesystem::path out(outfile);
|
|
if (boost::filesystem::is_directory(out))
|
|
outfile = (out / filename).string();
|
|
} else {
|
|
outfile = (input_file.parent_path() / filename).string();
|
|
}
|
|
|
|
return outfile;
|
|
}
|