3D-printing/OrcaSlicer
1
0
Fork 0
mirror of https://github.com/SoftFever/OrcaSlicer.git synced 2025-07-11 16:57:53 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Slicing object and rasterization generates output zip. Needs testing.

Browse source
This commit is contained in:
tamasmeszaros 2018-11-13 17:33:03 +01:00
parent 95419370e1
commit ffe6862626
5 changed files with 321 additions and 149 deletions
Download patch file Download diff file Expand all files Collapse all files

252
src/libslic3r/PrintExport.hpp
View file

@ -1,22 +1,21 @@
#ifndef PRINTEXPORT_HPP
#define PRINTEXPORT_HPP
#include "Print.hpp"
// For png export of the sliced model
#include <fstream>
#include <sstream>
#include <vector>
#include <boost/log/trivial.hpp>
#include "Rasterizer/Rasterizer.hpp"
#include <tbb/parallel_for.h>
#include <tbb/spin_mutex.h>//#include "tbb/mutex.h"
//#include <tbb/parallel_for.h>
//#include <tbb/spin_mutex.h>//#include "tbb/mutex.h"
namespace Slic3r {
enum class FilePrinterFormat {
PNG,
SLA_PNGZIP,
SVG
};
@ -28,7 +27,7 @@ enum class FilePrinterFormat {
* different implementations of this class template for each supported format.
*
*/
template<FilePrinterFormat format, class LayerFormat = void>
template<FilePrinterFormat format>
class FilePrinter {
public:
@ -69,15 +68,17 @@ public:
void save_layer(unsigned lyr, const std::string& path);
};
// Provokes static_assert in the right way.
template<class T = void> struct VeryFalse { static const bool value = false; };
// This has to be explicitly implemented in the gui layer or a default zlib
// based implementation is needed.
template<class Backend> class LayerWriter {
// based implementation is needed. I don't have time for that and I'm delegating
// the implementation to the gui layer where the gui toolkit can cover this.
template<class Fmt> class LayerWriter {
public:
LayerWriter(const std::string& /*zipfile_path*/) {
static_assert(VeryFalse<Backend>::value,
static_assert(VeryFalse<Fmt>::value,
"No layer writer implementation provided!");
}
@ -97,8 +98,8 @@ public:
// Implementation for PNG raster output
// Be aware that if a large number of layers are allocated, it can very well
// exhaust the available memory especially on 32 bit platform.
template<class LyrFormat> class FilePrinter<FilePrinterFormat::PNG, LyrFormat> {
template<> class FilePrinter<FilePrinterFormat::SLA_PNGZIP>
{
struct Layer {
Raster first;
std::stringstream second;
@ -115,13 +116,11 @@ template<class LyrFormat> class FilePrinter<FilePrinterFormat::PNG, LyrFormat> {
std::vector<Layer> m_layers_rst;
Raster::Resolution m_res;
Raster::PixelDim m_pxdim;
const Print *m_print = nullptr;
double m_exp_time_s = .0, m_exp_time_first_s = .0;
double m_layer_height = .0;
std::string createIniContent(const std::string& projectname) {
double layer_height = m_print?
m_print->default_object_config().layer_height.getFloat() :
0.05;
double layer_height = m_layer_height;
using std::string;
using std::to_string;
@ -154,11 +153,13 @@ template<class LyrFormat> class FilePrinter<FilePrinterFormat::PNG, LyrFormat> {
public:
inline FilePrinter(double width_mm, double height_mm,
unsigned width_px, unsigned height_px,
double layer_height,
double exp_time, double exp_time_first):
m_res(width_px, height_px),
m_pxdim(width_mm/width_px, height_mm/height_px),
m_exp_time_s(exp_time),
m_exp_time_first_s(exp_time_first)
m_exp_time_first_s(exp_time_first),
m_layer_height(layer_height)
{
}
@ -171,8 +172,6 @@ public:
inline void layers(unsigned cnt) { if(cnt > 0) m_layers_rst.resize(cnt); }
inline unsigned layers() const { return unsigned(m_layers_rst.size()); }
void print_config(const Print& printconf) { m_print = &printconf; }
inline void draw_polygon(const ExPolygon& p, unsigned lyr) {
assert(lyr < m_layers_rst.size());
m_layers_rst[lyr].first.draw(p);
@ -203,9 +202,10 @@ public:
}
}
template<class LyrFmt>
inline void save(const std::string& path) {
try {
LayerWriter<LyrFormat> writer(path);
LayerWriter<LyrFmt> writer(path);
std::string project = writer.get_name();
@ -250,145 +250,145 @@ public:
}
};
// Let's shadow this eigen interface
inline coord_t px(const Point& p) { return p(0); }
inline coord_t py(const Point& p) { return p(1); }
inline coordf_t px(const Vec2d& p) { return p(0); }
inline coordf_t py(const Vec2d& p) { return p(1); }
//// Let's shadow this eigen interface
//inline coord_t px(const Point& p) { return p(0); }
//inline coord_t py(const Point& p) { return p(1); }
//inline coordf_t px(const Vec2d& p) { return p(0); }
//inline coordf_t py(const Vec2d& p) { return p(1); }
template<FilePrinterFormat format, class LayerFormat, class...Args>
void print_to(Print& print,
std::string dirpath,
double width_mm,
double height_mm,
Args&&...args)
{
//template<FilePrinterFormat format, class LayerFormat, class...Args>
//void print_to(Print& print,
// std::string dirpath,
// double width_mm,
// double height_mm,
// Args&&...args)
//{
std::string& dir = dirpath;
// std::string& dir = dirpath;
// This map will hold the layers sorted by z coordinate. Layers on the
// same height (from different objects) will be mapped to the same key and
// rasterized to the same image.
std::map<long long, LayerPtrs> layers;
// // This map will hold the layers sorted by z coordinate. Layers on the
// // same height (from different objects) will be mapped to the same key and
// // rasterized to the same image.
// std::map<long long, LayerPtrs> layers;
auto& objects = print.objects();
// auto& objects = print.objects();
// Merge the sliced layers with the support layers
std::for_each(objects.cbegin(), objects.cend(),
[&layers](const PrintObject *o)
{
for(const auto l : o->layers()) {
auto& lyrs = layers[static_cast<long long>(scale_(l->print_z))];
lyrs.push_back(l);
}
// // Merge the sliced layers with the support layers
// std::for_each(objects.cbegin(), objects.cend(),
// [&layers](const PrintObject *o)
// {
// for(const auto l : o->layers()) {
// auto& lyrs = layers[static_cast<long long>(scale_(l->print_z))];
// lyrs.push_back(l);
// }
for(const auto l : o->support_layers()) {
auto& lyrs = layers[static_cast<long long>(scale_(l->print_z))];
lyrs.push_back(l);
}
});
// for(const auto l : o->support_layers()) {
// auto& lyrs = layers[static_cast<long long>(scale_(l->print_z))];
// lyrs.push_back(l);
// }
// });
auto print_bb = print.bounding_box();
Vec2d punsc = unscale(print_bb.size());
// auto print_bb = print.bounding_box();
// Vec2d punsc = unscale(print_bb.size());
// If the print does not fit into the print area we should cry about it.
if(px(punsc) > width_mm || py(punsc) > height_mm) {
BOOST_LOG_TRIVIAL(warning) << "Warning: Print will not fit!" << "\n"
<< "Width needed: " << px(punsc) << "\n"
<< "Height needed: " << py(punsc) << "\n";
}
// // If the print does not fit into the print area we should cry about it.
// if(px(punsc) > width_mm || py(punsc) > height_mm) {
// BOOST_LOG_TRIVIAL(warning) << "Warning: Print will not fit!" << "\n"
// << "Width needed: " << px(punsc) << "\n"
// << "Height needed: " << py(punsc) << "\n";
// }
// Offset for centering the print onto the print area
auto cx = scale_(width_mm)/2 - (px(print_bb.center()) - px(print_bb.min));
auto cy = scale_(height_mm)/2 - (py(print_bb.center()) - py(print_bb.min));
// // Offset for centering the print onto the print area
// auto cx = scale_(width_mm)/2 - (px(print_bb.center()) - px(print_bb.min));
// auto cy = scale_(height_mm)/2 - (py(print_bb.center()) - py(print_bb.min));
// Create the actual printer, forward any additional arguments to it.
FilePrinter<format, LayerFormat> printer(width_mm, height_mm,
std::forward<Args>(args)...);
// // Create the actual printer, forward any additional arguments to it.
// FilePrinter<format, LayerFormat> printer(width_mm, height_mm,
// std::forward<Args>(args)...);
printer.print_config(print);
// printer.print_config(print);
printer.layers(layers.size()); // Allocate space for all the layers
// printer.layers(layers.size()); // Allocate space for all the layers
int st_prev = 0;
const std::string jobdesc = "Rasterizing and compressing sliced layers";
tbb::spin_mutex m;
// int st_prev = 0;
// const std::string jobdesc = "Rasterizing and compressing sliced layers";
// tbb::spin_mutex m;
std::vector<long long> keys;
keys.reserve(layers.size());
for(auto& e : layers) keys.push_back(e.first);
// std::vector<long long> keys;
// keys.reserve(layers.size());
// for(auto& e : layers) keys.push_back(e.first);
print.set_status(0, jobdesc);
// print.set_status(0, jobdesc);
// Method that prints one layer
auto process_layer = [&layers, &keys, &printer, &st_prev, &m,
&jobdesc, print_bb, dir, cx, cy, &print]
(unsigned layer_id)
{
LayerPtrs lrange = layers[keys[layer_id]];
// // Method that prints one layer
// auto process_layer = [&layers, &keys, &printer, &st_prev, &m,
// &jobdesc, print_bb, dir, cx, cy, &print]
// (unsigned layer_id)
// {
// LayerPtrs lrange = layers[keys[layer_id]];
printer.begin_layer(layer_id); // Switch to the appropriate layer
// printer.begin_layer(layer_id); // Switch to the appropriate layer
for(Layer *lp : lrange) {
Layer& l = *lp;
// for(Layer *lp : lrange) {
// Layer& l = *lp;
ExPolygonCollection slices = l.slices; // Copy the layer slices
// ExPolygonCollection slices = l.slices; // Copy the layer slices
// Sort the polygons in the layer
std::stable_sort(slices.expolygons.begin(), slices.expolygons.end(),
[](const ExPolygon& a, const ExPolygon& b) {
return a.contour.contains(b.contour.first_point()) ? false :
true;
});
// // Sort the polygons in the layer
// std::stable_sort(slices.expolygons.begin(), slices.expolygons.end(),
// [](const ExPolygon& a, const ExPolygon& b) {
// return a.contour.contains(b.contour.first_point()) ? false :
// true;
// });
// Draw all the polygons in the slice to the actual layer.
for (const Point &d : l.object()->copies())
for (ExPolygon slice : slices.expolygons) {
slice.translate(px(d), py(d));
slice.translate(-px(print_bb.min) + cx,
-py(print_bb.min) + cy);
// // Draw all the polygons in the slice to the actual layer.
// for (const Point &d : l.object()->copies())
// for (ExPolygon slice : slices.expolygons) {
// slice.translate(px(d), py(d));
// slice.translate(-px(print_bb.min) + cx,
// -py(print_bb.min) + cy);
printer.draw_polygon(slice, layer_id);
}
// printer.draw_polygon(slice, layer_id);
// }
/*if(print.has_support_material() && layer_id > 0) {
BOOST_LOG_TRIVIAL(warning) << "support material for layer "
<< layer_id
<< " defined but export is "
"not yet implemented.";
// /*if(print.has_support_material() && layer_id > 0) {
// BOOST_LOG_TRIVIAL(warning) << "support material for layer "
// << layer_id
// << " defined but export is "
// "not yet implemented.";
}*/
// }*/
}
// }
printer.finish_layer(layer_id); // Finish the layer for later saving it.
// printer.finish_layer(layer_id); // Finish the layer for later saving it.
auto st = static_cast<int>(layer_id*80.0/layers.size());
m.lock();
if( st - st_prev > 10) {
print.set_status(st, jobdesc);
st_prev = st;
}
m.unlock();
// auto st = static_cast<int>(layer_id*80.0/layers.size());
// m.lock();
// if( st - st_prev > 10) {
// print.set_status(st, jobdesc);
// st_prev = st;
// }
// m.unlock();
// printer.saveLayer(layer_id, dir); We could save the layer immediately
};
// // printer.saveLayer(layer_id, dir); We could save the layer immediately
// };
// Print all the layers in parallel
tbb::parallel_for<size_t, decltype(process_layer)>(0,
layers.size(),
process_layer);
// // Print all the layers in parallel
// tbb::parallel_for<size_t, decltype(process_layer)>(0,
// layers.size(),
// process_layer);
// Sequential version (for testing)
// for(unsigned l = 0; l < layers.size(); ++l) process_layer(l);
// // Sequential version (for testing)
// // for(unsigned l = 0; l < layers.size(); ++l) process_layer(l);
// print.set_status(100, jobdesc);
//// print.set_status(100, jobdesc);
// Save the print into the file system.
print.set_status(90, "Writing layers to disk");
printer.save(dir);
print.set_status(100, "Writing layers completed");
}
// // Save the print into the file system.
// print.set_status(90, "Writing layers to disk");
// printer.save(dir);
// print.set_status(100, "Writing layers completed");
//}
}