3DPrinting/PrusaSlicer-NonPlainar
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fix for empty or broken png output.

Browse Source 
Fix for instance transformation order error and state invalidation issues with rasterization.
This commit is contained in:
tamasmeszaros 2018-11-29 18:12:40 +01:00
parent bf94751a94
commit 55d62b8295
5 changed files with 54 additions and 161 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

146
src/libslic3r/PrintExport.hpp
View File

@ -218,8 +218,10 @@ public:
std::sprintf(lyrnum, "%.5d", i);
auto zfilename = project + lyrnum + ".png";
writer.next_entry(zfilename);
writer << m_layers_rst[i].second.rdbuf();
m_layers_rst[i].second.str("");
writer << m_layers_rst[i].second.str();
// writer << m_layers_rst[i].second.rdbuf();
// we can keep the date for later calls of this method
//m_layers_rst[i].second.str("");
}
}
@ -250,146 +252,6 @@ 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); }
//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;
// // 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();
// // 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);
// }
// });
// 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";
// }
// // 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)...);
// printer.print_config(print);
// 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;
// std::vector<long long> keys;
// keys.reserve(layers.size());
// for(auto& e : layers) keys.push_back(e.first);
// 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]];
// printer.begin_layer(layer_id); // Switch to the appropriate layer
// for(Layer *lp : lrange) {
// Layer& l = *lp;
// 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;
// });
// // 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);
// }
// /*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.
// 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
// };
// // 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);
//// 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");
//}
}
#endif // PRINTEXPORT_HPP

53
src/libslic3r/SLAPrint.cpp
View File

@ -28,6 +28,7 @@ public:
sla::PointSet support_points; // all the support points (manual/auto)
SupportTreePtr support_tree_ptr; // the supports
SlicedSupports support_slices; // sliced supports
std::vector<LevelID> level_ids;
};
namespace {
@ -567,11 +568,10 @@ void SLAPrint::process()
}
};
auto& levels = m_printer_input;
// We have the layer polygon collection but we need to unite them into
// an index where the key is the height level in discrete levels (clipper)
auto index_slices = [this, ilh, ilhd, &levels](SLAPrintObject& po) {
auto index_slices = [this, ilh, ilhd](SLAPrintObject& po) {
po.m_slice_index.clear();
auto sih = LevelID(scale_(ilh));
// For all print objects, go through its initial layers and place them
@ -591,7 +591,7 @@ void SLAPrint::process()
// It is important that the next levels match the levels in
// model_slice method. Only difference is that here it works with
// scaled coordinates
std::vector<LevelID> levelids;
auto& levelids = po.m_level_ids; levelids.clear();
if(sminZ >= smodelgnd) levelids.emplace_back(sminZ);
for(LevelID h = sminZ + sih; h < smaxZ; h += slh)
if(h >= smodelgnd) levelids.emplace_back(h);
@ -615,11 +615,9 @@ void SLAPrint::process()
// shortcut for empty index into the slice vectors
static const auto EMPTY_SLICE = SLAPrintObject::SliceRecord::NONE;
for(int i = 0; i < oslices.size(); ++i) {
LevelID h = levelids[i];
auto& lyrs = levels[h]; // this initializes a new record
lyrs.emplace_back(oslices[i], po.m_instances);
float fh = float(double(h) * SCALING_FACTOR);
@ -632,13 +630,14 @@ void SLAPrint::process()
if(po.m_supportdata) { // deal with the support slices if present
auto& sslices = po.m_supportdata->support_slices;
po.m_supportdata->level_ids.clear();
po.m_supportdata->level_ids.reserve(sslices.size());
for(int i = 0; i < sslices.size(); ++i) {
int a = i == 0 ? 0 : 1;
int b = i == 0 ? 0 : i - 1;
LevelID h = sminZ + a * sih + b * slh;
auto& lyrs = levels[h];
lyrs.emplace_back(sslices[i], po.m_instances);
po.m_supportdata->level_ids.emplace_back(h);
float fh = float(double(h) * SCALING_FACTOR);
@ -649,10 +648,40 @@ void SLAPrint::process()
}
};
auto& levels = m_printer_input;
// Rasterizing the model objects, and their supports
auto rasterize = [this, ilh, ilhd, max_objstatus, &levels]() {
if(canceled()) return;
// clear the rasterizer input
m_printer_input.clear();
for(SLAPrintObject * o : m_objects) {
auto& po = *o;
SlicedModel & oslices = po.m_model_slices;
// We need to adjust the min Z level of the slices to be zero
LevelID smfirst = po.m_supportdata? po.m_supportdata->level_ids.front() : 0;
LevelID mfirst = po.m_level_ids.front();
LevelID gndlvl = -(std::min(smfirst, mfirst));
// now merge this object's support and object slices with the rest
// of the print object slices
for(int i = 0; i < oslices.size(); ++i) {
auto& lyrs = levels[gndlvl + po.m_level_ids[i]];
lyrs.emplace_back(oslices[i], po.m_instances);
}
if(!po.m_supportdata) continue;
auto& sslices = po.m_supportdata->support_slices;
for(int i = 0; i < sslices.size(); ++i) {
auto& lyrs = levels[gndlvl + po.m_supportdata->level_ids[i]];
lyrs.emplace_back(sslices[i], po.m_instances);
}
}
// collect all the keys
std::vector<long long> keys; keys.reserve(levels.size());
for(auto& e : levels) keys.emplace_back(e.first);
@ -704,8 +733,10 @@ void SLAPrint::process()
// Draw all the polygons in the slice to the actual layer.
for(auto& cp : copies) {
for(ExPolygon slice : sl) {
slice.translate(cp.shift(X), cp.shift(Y));
// The order is important here:
// apply rotation before translation...
slice.rotate(cp.rotation);
slice.translate(cp.shift(X), cp.shift(Y));
printer.draw_polygon(slice, level_id);
}
}

10
src/libslic3r/SLAPrint.hpp
View File

@ -33,6 +33,10 @@ class GLCanvas;
using _SLAPrintObjectBase =
PrintObjectBaseWithState<SLAPrint, SLAPrintObjectStep, slaposCount>;
// Layers according to quantized height levels. This will be consumed by
// the printer (rasterizer) in the SLAPrint class.
using LevelID = long long;
class SLAPrintObject : public _SLAPrintObjectBase
{
private: // Prevents erroneous use by other classes.
@ -93,7 +97,6 @@ public:
// to the z coordinate of the object coordinate system.
struct SliceRecord {
using Key = float;
// inline static float scale_back(Key h) { return float(h * SCALING_FACTOR); }
using Idx = size_t;
static const Idx NONE = Idx(-1); // this will be the max limit of size_t
@ -145,6 +148,7 @@ private:
std::vector<bool> m_stepmask;
std::vector<ExPolygons> m_model_slices;
SliceIndex m_slice_index;
std::vector<LevelID> m_level_ids;
// Caching the transformed (m_trafo) raw mesh of the object
mutable CachedObject<TriangleMesh> m_transformed_rmesh;
@ -214,10 +218,6 @@ private:
lref(std::cref(lyr)), copies(std::cref(cp)) {}
};
// Layers according to quantized height levels. This will be consumed by
// the printer (rasterizer) in the SLAPrint class.
using LevelID = long long;
// One level may contain multiple slices from multiple objects and their
// supports
using LayerRefs = std::vector<LayerRef>;

4
src/slic3r/GUI/ProgressStatusBar.cpp
View File

@ -71,14 +71,12 @@ int ProgressStatusBar::get_progress() const
void ProgressStatusBar::set_progress(int val)
{
if(!m_prog->IsShown()) show_progress(true);
if(val < 0) return;
if(val == m_prog->GetRange()) {
m_prog->SetValue(0);
show_progress(false);
}
else if(val < 0) {
m_prog->Pulse();
}
else {
m_prog->SetValue(val);
}

2
src/slic3r/GUI/ProgressStatusBar.hpp
View File

@ -35,6 +35,8 @@ public:
~ProgressStatusBar();
int get_progress() const;
// if the argument is less than 0 it shows the last state or
// pulses if no state was set before.
void set_progress(int);
int get_range() const;
void set_range(int = 100);