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

Fixes for the duplicated layer issues...

Browse source
This commit is contained in:
tamasmeszaros 2019-03-21 18:01:41 +01:00
parent 63a899b239
commit 5e646562cd
3 changed files with 58 additions and 46 deletions
Download patch file Download diff file Expand all files Collapse all files

51
src/libslic3r/SLAPrint.cpp
View file

@ -615,12 +615,19 @@ void SLAPrint::process()
using namespace sla; using namespace sla;
using ExPolygon = Slic3r::ExPolygon; using ExPolygon = Slic3r::ExPolygon;
if(m_objects.empty()) return;
// Assumption: at this point the print objects should be populated only with // Assumption: at this point the print objects should be populated only with
// the model objects we have to process and the instances are also filtered // the model objects we have to process and the instances are also filtered
// shortcut to initial layer height // shortcut to initial layer height
double ilhd = m_material_config.initial_layer_height.getFloat(); double ilhd = m_material_config.initial_layer_height.getFloat();
auto ilh = float(ilhd); auto ilh = float(ilhd);
double lhd = m_objects.front()->m_config.layer_height.getFloat();
float lh = float(lhd);
LevelID ilhs = ilhd / SCALING_FACTOR;
LevelID lhs = lhd / SCALING_FACTOR;
const size_t objcount = m_objects.size(); const size_t objcount = m_objects.size();
const unsigned min_objstatus = 0; // where the per object operations start const unsigned min_objstatus = 0; // where the per object operations start
@ -641,24 +648,26 @@ void SLAPrint::process()
// Slicing the model object. This method is oversimplified and needs to // Slicing the model object. This method is oversimplified and needs to
// be compared with the fff slicing algorithm for verification // be compared with the fff slicing algorithm for verification
auto slice_model = [this, ilh](SLAPrintObject& po) { auto slice_model = [this, ilhs, lhs, ilh, lh](SLAPrintObject& po) {
TriangleMesh mesh = po.transformed_mesh(); TriangleMesh mesh = po.transformed_mesh();
// We need to prepare the slice index... // We need to prepare the slice index...
auto&& bb3d = mesh.bounding_box(); auto&& bb3d = mesh.bounding_box();
float minZ = float(bb3d.min(Z)) - float(po.get_elevation()); double minZ = bb3d.min(Z) - po.get_elevation();
float maxZ = float(bb3d.max(Z)); double maxZ = bb3d.max(Z);
auto flh = float(po.m_config.layer_height.getFloat());
LevelID minZs = minZ / SCALING_FACTOR;
LevelID maxZs = maxZ / SCALING_FACTOR;
auto slh = [](float h) { return LevelID( double(h) / SCALING_FACTOR); }; auto slh = [](float h) { return LevelID( double(h) / SCALING_FACTOR); };
po.m_slice_index.clear(); po.m_slice_index.clear();
po.m_slice_index.reserve(size_t(maxZ - (minZ + ilh) / flh) + 1); po.m_slice_index.reserve(size_t(maxZs - (minZs + ilhs) / lhs) + 1);
po.m_slice_index.emplace_back(slh(minZ + ilh), minZ + ilh / 2.f, ilh); po.m_slice_index.emplace_back(minZs + ilhs, minZ + ilh / 2.f, ilh);
for(float h = minZ + ilh + flh; h <= maxZ; h += flh) { for(LevelID h = minZs + ilhs + lhs; h <= maxZs; h += lhs) {
po.m_slice_index.emplace_back(slh(h), h - flh / 2.f, flh); po.m_slice_index.emplace_back(h, h*SCALING_FACTOR - lh / 2.f, lh);
} }
auto slindex_it = po.search_slice_index(float(bb3d.min(Z))); auto slindex_it = po.search_slice_index(float(bb3d.min(Z)));
@ -1337,7 +1346,7 @@ void SLAPrint::fill_statistics()
for (SLAPrintObject * po : m_objects) for (SLAPrintObject * po : m_objects)
{ {
const SLAPrintObject::SliceRecord *record = nullptr; const SLAPrintObject::_SliceRecord *record = nullptr;
{ {
const SLAPrintObject::SliceIndex& index = po->get_slice_index(); const SLAPrintObject::SliceIndex& index = po->get_slice_index();
auto it = po->search_slice_index(layer.slice_level() - float(EPSILON)); auto it = po->search_slice_index(layer.slice_level() - float(EPSILON));
@ -1562,10 +1571,10 @@ const std::vector<sla::SupportPoint>& SLAPrintObject::get_support_points() const
SLAPrintObject::SliceIndex::iterator SLAPrintObject::SliceIndex::iterator
SLAPrintObject::search_slice_index(float slice_level) SLAPrintObject::search_slice_index(float slice_level)
{ {
SliceRecord query(0, slice_level, 0); _SliceRecord query(0, slice_level, 0);
auto it = std::lower_bound(m_slice_index.begin(), m_slice_index.end(), auto it = std::lower_bound(m_slice_index.begin(), m_slice_index.end(),
query, query,
[](const SliceRecord& r1, const SliceRecord& r2) [](const _SliceRecord& r1, const _SliceRecord& r2)
{ {
return r1.slice_level() < r2.slice_level(); return r1.slice_level() < r2.slice_level();
}); });
@ -1576,10 +1585,10 @@ SLAPrintObject::search_slice_index(float slice_level)
SLAPrintObject::SliceIndex::const_iterator SLAPrintObject::SliceIndex::const_iterator
SLAPrintObject::search_slice_index(float slice_level) const SLAPrintObject::search_slice_index(float slice_level) const
{ {
SliceRecord query(0, slice_level, 0); _SliceRecord query(0, slice_level, 0);
auto it = std::lower_bound(m_slice_index.cbegin(), m_slice_index.cend(), auto it = std::lower_bound(m_slice_index.cbegin(), m_slice_index.cend(),
query, query,
[](const SliceRecord& r1, const SliceRecord& r2) [](const _SliceRecord& r1, const _SliceRecord& r2)
{ {
return r1.slice_level() < r2.slice_level(); return r1.slice_level() < r2.slice_level();
}); });
@ -1588,12 +1597,12 @@ SLAPrintObject::search_slice_index(float slice_level) const
} }
SLAPrintObject::SliceIndex::iterator SLAPrintObject::SliceIndex::iterator
SLAPrintObject::search_slice_index(SLAPrintObject::SliceRecord::Key key) SLAPrintObject::search_slice_index(SLAPrintObject::_SliceRecord::Key key)
{ {
SliceRecord query(key, 0.f, 0.f); _SliceRecord query(key, 0.f, 0.f);
auto it = std::lower_bound(m_slice_index.begin(), m_slice_index.end(), auto it = std::lower_bound(m_slice_index.begin(), m_slice_index.end(),
query, query,
[](const SliceRecord& r1, const SliceRecord& r2) [](const _SliceRecord& r1, const _SliceRecord& r2)
{ {
return r1.key() < r2.key(); return r1.key() < r2.key();
}); });
@ -1605,12 +1614,12 @@ SLAPrintObject::search_slice_index(SLAPrintObject::SliceRecord::Key key)
} }
SLAPrintObject::SliceIndex::const_iterator SLAPrintObject::SliceIndex::const_iterator
SLAPrintObject::search_slice_index(SLAPrintObject::SliceRecord::Key key) const SLAPrintObject::search_slice_index(SLAPrintObject::_SliceRecord::Key key) const
{ {
SliceRecord query(key, 0.f, 0.f); _SliceRecord query(key, 0.f, 0.f);
auto it = std::lower_bound(m_slice_index.cbegin(), m_slice_index.cend(), auto it = std::lower_bound(m_slice_index.cbegin(), m_slice_index.cend(),
query, query,
[](const SliceRecord& r1, const SliceRecord& r2) [](const _SliceRecord& r1, const _SliceRecord& r2)
{ {
return r1.key() < r2.key(); return r1.key() < r2.key();
}); });
@ -1645,7 +1654,7 @@ const std::vector<ExPolygons> &SLAPrintObject::get_support_slices() const
return m_supportdata->support_slices; return m_supportdata->support_slices;
} }
const std::vector<SLAPrintObject::SliceRecord>& const std::vector<SLAPrintObject::_SliceRecord>&
SLAPrintObject::get_slice_index() const SLAPrintObject::get_slice_index() const
{ {
// assert(is_step_done(slaposIndexSlices)); // assert(is_step_done(slaposIndexSlices));
@ -1769,7 +1778,7 @@ std::string SLAPrintStatistics::finalize_output_path(const std::string &path_in)
return final_path; return final_path;
} }
SliceIterator SLAPrintObject::SliceRecord::get_slices(const SLAPrintObject &po, SliceIterator SLAPrintObject::_SliceRecord::get_slices(const SLAPrintObject &po,
SliceOrigin so) const SliceOrigin so) const
{ {

51
src/libslic3r/SLAPrint.hpp
View file

@ -107,30 +107,21 @@ public:
// This method returns the support points of this SLAPrintObject. // This method returns the support points of this SLAPrintObject.
const std::vector<sla::SupportPoint>& get_support_points() const; const std::vector<sla::SupportPoint>& get_support_points() const;
private:
// An index record referencing the slices
// (get_model_slices(), get_support_slices()) where the keys are the height
// levels of the model in scaled-clipper coordinates. The levels correspond
// to the z coordinate of the object coordinate system.
class SliceRecord { class SliceRecord {
public: public:
using Key = LevelID; using Key = LevelID;
private: private:
static const size_t NONE = size_t(-1); // this will be the max limit of size_t
size_t m_model_slices_idx = NONE;
size_t m_support_slices_idx = NONE;
LevelID m_print_z = 0; // Top of the layer LevelID m_print_z = 0; // Top of the layer
float m_slice_z = 0.f; // Exact level of the slice float m_slice_z = 0.f; // Exact level of the slice
float m_height = 0.f; // Height of the sliced layer float m_height = 0.f; // Height of the sliced layer
public: protected:
SliceRecord(Key key, float slicez, float height): SliceRecord(Key key, float slicez, float height):
m_print_z(key), m_slice_z(slicez), m_height(height) {} m_print_z(key), m_slice_z(slicez), m_height(height) {}
public:
// The key will be the integer height level of the top of the layer. // The key will be the integer height level of the top of the layer.
inline Key key() const { return m_print_z; } inline Key key() const { return m_print_z; }
@ -139,8 +130,25 @@ private:
// Returns the current layer height // Returns the current layer height
inline float layer_height() const { return m_height; } inline float layer_height() const { return m_height; }
};
// Returns the slices for eighter the model or the supports. The return private:
// An index record referencing the slices
// (get_model_slices(), get_support_slices()) where the keys are the height
// levels of the model in scaled-clipper coordinates. The levels correspond
// to the z coordinate of the object coordinate system.
class _SliceRecord: public SliceRecord {
private:
static const size_t NONE = size_t(-1); // this will be the max limit of size_t
size_t m_model_slices_idx = NONE;
size_t m_support_slices_idx = NONE;
public:
_SliceRecord(Key key, float slicez, float height):
SliceRecord(key, slicez, height) {}
// Returns the slices for either the model or the supports. The return
// value is an iterator to po.get_model_slices() or po.get_support_slices // value is an iterator to po.get_model_slices() or po.get_support_slices
// depending on the SliceOrigin parameter. // depending on the SliceOrigin parameter.
SliceIterator get_slices(const SLAPrintObject& po, SliceOrigin so) const; SliceIterator get_slices(const SLAPrintObject& po, SliceOrigin so) const;
@ -151,7 +159,7 @@ private:
}; };
// Slice index will be a plain vector sorted by the integer height levels // Slice index will be a plain vector sorted by the integer height levels
using SliceIndex = std::vector<SliceRecord>; using SliceIndex = std::vector<_SliceRecord>;
// Retrieve the slice index which is readable only after slaposIndexSlices // Retrieve the slice index which is readable only after slaposIndexSlices
// is done. // is done.
@ -163,8 +171,8 @@ private:
// Search the slice index for a particular level in integer coordinates. // Search the slice index for a particular level in integer coordinates.
// If no such layer is present, it will return m_slice_index.end() // If no such layer is present, it will return m_slice_index.end()
SliceIndex::iterator search_slice_index(SliceRecord::Key key); SliceIndex::iterator search_slice_index(_SliceRecord::Key key);
SliceIndex::const_iterator search_slice_index(SliceRecord::Key key) const; SliceIndex::const_iterator search_slice_index(_SliceRecord::Key key) const;
public: public:
@ -173,10 +181,6 @@ public:
// steps have been succesfully finished. // steps have been succesfully finished.
// ///////////////////////////////////////////////////////////////////////// // /////////////////////////////////////////////////////////////////////////
// Getting slices for either the model or the supports for a particular
// height ID.
// SliceIterator get_slices(SliceOrigin so, LevelID k) const;
// Getting slices (model or supports) for a Z coordinate range. The returned // Getting slices (model or supports) for a Z coordinate range. The returned
// iterators should include the slices for the given boundaries as well. // iterators should include the slices for the given boundaries as well.
SliceRange get_slices( SliceRange get_slices(
@ -194,9 +198,8 @@ public:
// Returns the total number of slices in the slice grid (model and supports) // Returns the total number of slices in the slice grid (model and supports)
inline size_t get_slice_count() const { return m_slice_index.size(); } inline size_t get_slice_count() const { return m_slice_index.size(); }
// One can query the Z coordinate of the slice for a given inline const SliceRecord& get_slice_record(size_t idx) const {
inline float get_slice_level(size_t idx) const { return m_slice_index[idx];
return m_slice_index[idx].slice_level();
} }
protected: protected:
@ -239,7 +242,7 @@ private:
// Exact (float) height levels mapped to the slices. Each record contains // Exact (float) height levels mapped to the slices. Each record contains
// the index to the model and the support slice vectors. // the index to the model and the support slice vectors.
std::vector<SliceRecord> m_slice_index; std::vector<_SliceRecord> m_slice_index;
std::vector<float> m_model_height_levels; std::vector<float> m_model_height_levels;

2
src/slic3r/GUI/GUI_Preview.cpp
View file

@ -778,7 +778,7 @@ void Preview::load_print_as_sla()
size_t cnt = obj->get_slice_count(); size_t cnt = obj->get_slice_count();
for (size_t i = 0; i < cnt; i++) for (size_t i = 0; i < cnt; i++)
{ {
zs.insert(shift_z + double(obj->get_slice_level(i))); zs.insert(shift_z + obj->get_slice_record(i).key() * SCALING_FACTOR);
} }
} }
} }