wip: reorganizing things to support accurate pad creation. Also more accurate progress indication.

src/libslic3r/PrintBase.hpp

@@ -192,7 +192,7 @@ public:
     // Calls a registered callback to update the status, or print out the default message.
     void                    set_status(int percent, const std::string &message) { 
         if (m_status_callback) m_status_callback(percent, message);
-        else printf("%d => %s\n", percent, message.c_str());
+        /*else */printf("%d => %s\n", percent, message.c_str());
     }
 
     typedef std::function<void()>  cancel_callback_type;

src/libslic3r/SLA/SLASupportTree.cpp

@@ -9,6 +9,7 @@
 #include "SLASpatIndex.hpp"
 #include "SLABasePool.hpp"
 #include <libnest2d/tools/benchmark.h>
+#include "ClipperUtils.hpp"
 
 #include "Model.hpp"
 
@@ -510,14 +511,16 @@ struct Pad {
     Pad() {}
 
     Pad(const TriangleMesh& object_support_mesh,
+        const ExPolygons& baseplate,
         double ground_level,
         const PoolConfig& cfg) : zlevel(ground_level)
     {
         ExPolygons basep;
         base_plate(object_support_mesh, basep);
+        for(auto& bp : baseplate) basep.emplace_back(bp);
+        union_ex(basep);
         create_base_pool(basep, tmesh, cfg);
         tmesh.translate(0, 0, float(zlevel));
-        std::cout << "pad ground level " << zlevel << std::endl;
     }
 };
 
@@ -563,6 +566,10 @@ EigenMesh3D to_eigenmesh(const TriangleMesh& tmesh) {
     const stl_file& stl = tmesh.stl;
 
     EigenMesh3D outmesh;
+
+    auto&& bb = tmesh.bounding_box();
+    outmesh.ground_level += bb.min(Z);
+
     auto& V = outmesh.V;
     auto& F = outmesh.F;
 
@@ -586,28 +593,7 @@ EigenMesh3D to_eigenmesh(const TriangleMesh& tmesh) {
 }
 
 EigenMesh3D to_eigenmesh(const ModelObject& modelobj) {
-    auto&& rmesh = modelobj.raw_mesh();
+    return to_eigenmesh(modelobj.raw_mesh());
-
-    // we need to transform the raw mesh...
-    // currently all the instances share the same x and y rotation and scaling
-    // so we have to extract those from e.g. the first instance and apply to the
-    // raw mesh. This is also true for the support points.
-    // BUT: when the support structure is spawned for each instance than it has
-    // to omit the X, Y rotation and scaling as those have been already applied
-    // or apply an inverse transformation on the support structure after it
-    // has been created.
-
-//    auto rot = modelobj.instances.front()->get_rotation();
-//    auto scaling = modelobj.instances.front()->get_scaling_factor();
-
-//    rmesh.rotate(float(rot(X)), Axis::X);
-//    rmesh.rotate(float(rot(Y)), Axis::Y);
-//    rmesh.scale(scaling);
-
-    auto&& ret = to_eigenmesh(rmesh);
-    auto&& bb = rmesh.bounding_box();
-    ret.ground_level = bb.min(Z);
-    return ret;
 }
 
 EigenMesh3D to_eigenmesh(const Model& model) {
@@ -767,8 +753,9 @@ public:
     }
 
     const Pad& create_pad(const TriangleMesh& object_supports,
+                          const ExPolygons& baseplate,
                           const PoolConfig& cfg) {
-        m_pad = Pad(object_supports, ground_level, cfg);
+        m_pad = Pad(object_supports, baseplate, ground_level, cfg);
         return m_pad;
     }
 
@@ -1014,7 +1001,6 @@ bool SLASupportTree::generate(const PointSet &points,
     using Result = SLASupportTree::Impl;
 
     Result& result = *m_impl;
-    result.ground_level = mesh.ground_level;
 
     enum Steps {
         BEGIN,
@@ -1283,7 +1269,7 @@ bool SLASupportTree::generate(const PointSet &points,
         const double hbr = cfg.head_back_radius_mm;
         const double pradius = cfg.pillar_radius_mm;
         const double maxbridgelen = cfg.max_bridge_length_mm;
-        const double gndlvl = emesh.ground_level - cfg.object_elevation_mm;
+        const double gndlvl = emesh.ground_level;
 
         ClusterEl cl_centroids;
         cl_centroids.reserve(gnd_clusters.size());
@@ -1759,7 +1745,8 @@ SlicedSupports SLASupportTree::slice(float layerh, float init_layerh) const
     return ret;
 }
 
-const TriangleMesh &SLASupportTree::add_pad(double min_wall_thickness_mm,
+const TriangleMesh &SLASupportTree::add_pad(const SliceLayer& baseplate,
+                                            double min_wall_thickness_mm,
                                             double min_wall_height_mm,
                                             double max_merge_distance_mm,
                                             double edge_radius_mm) const
@@ -1771,7 +1758,7 @@ const TriangleMesh &SLASupportTree::add_pad(double min_wall_thickness_mm,
 //    pcfg.min_wall_height_mm    = min_wall_height_mm;
 //    pcfg.max_merge_distance_mm = max_merge_distance_mm;
 //    pcfg.edge_radius_mm        = edge_radius_mm;
-    return m_impl->create_pad(mm, pcfg).tmesh;
+    return m_impl->create_pad(mm, baseplate, pcfg).tmesh;
 }
 
 const TriangleMesh &SLASupportTree::get_pad() const
@@ -1791,6 +1778,7 @@ SLASupportTree::SLASupportTree(const PointSet &points,
                                const SupportConfig &cfg,
                                const Controller &ctl): m_impl(new Impl())
 {
+    m_impl->ground_level = emesh.ground_level - cfg.object_elevation_mm;
     generate(points, emesh, cfg, ctl);
 }
 

src/libslic3r/SLA/SLASupportTree.hpp

@@ -160,7 +160,8 @@ public:
     SlicedSupports slice(float layerh, float init_layerh = -1.0) const;
 
     /// Adding the "pad" (base pool) under the supports
-    const TriangleMesh& add_pad(double min_wall_thickness_mm,
+    const TriangleMesh& add_pad(const SliceLayer& baseplate,
+                                double min_wall_thickness_mm,
                                 double min_wall_height_mm,
                                 double max_merge_distance_mm,
                                 double edge_radius_mm) const;

src/libslic3r/SLAPrint.cpp

@@ -1,5 +1,6 @@
 #include "SLAPrint.hpp"
 #include "SLA/SLASupportTree.hpp"
+#include "SLA/SLABasePool.hpp"
 
 #include <tbb/parallel_for.h>
 //#include <tbb/spin_mutex.h>//#include "tbb/mutex.h"
@@ -27,12 +28,12 @@ namespace {
 
 const std::array<unsigned, slaposCount>     OBJ_STEP_LEVELS =
 {
+    0,
     20,
     30,
     50,
     70,
-    80,
+    90
-    100
 };
 
 const std::array<std::string, slaposCount> OBJ_STEP_LABELS =
@@ -47,8 +48,9 @@ const std::array<std::string, slaposCount> OBJ_STEP_LABELS =
 
 const std::array<unsigned, slapsCount> PRINT_STEP_LEVELS =
 {
+    // This is after processing all the Print objects, so we start from 50%
     50,     // slapsRasterize
-    100,    // slapsValidate
+    90,     // slapsValidate
 };
 
 const std::array<std::string, slapsCount> PRINT_STEP_LABELS =
@@ -118,8 +120,6 @@ void SLAPrint::process()
 {
     using namespace sla;
 
-    std::cout << "SLA Processing triggered" << std::endl;
-
     // 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
 
@@ -131,9 +131,7 @@ void SLAPrint::process()
     auto slice_model = [ilh](SLAPrintObject& po) {
         auto lh = float(po.m_config.layer_height.getFloat());
 
-        ModelObject *o = po.m_model_object;
+        TriangleMesh mesh = po.transformed_mesh();
-
-        TriangleMesh&& mesh = o->raw_mesh();
         TriangleMeshSlicer slicer(&mesh);
         auto bb3d = mesh.bounding_box();
 
@@ -150,11 +148,10 @@ void SLAPrint::process()
         ModelObject& mo = *po.m_model_object;
         if(!mo.sla_support_points.empty()) {
             po.m_supportdata.reset(new SLAPrintObject::SupportData());
-            po.m_supportdata->emesh = sla::to_eigenmesh(mo);
+            po.m_supportdata->emesh = sla::to_eigenmesh(po.transformed_mesh());
-            po.m_supportdata->support_points = sla::support_points(mo);
 
-            std::cout << "support points copied "
+            // TODO: transform support points appropriately
-                      << po.m_supportdata->support_points.rows() << std::endl;
+            po.m_supportdata->support_points = sla::support_points(mo);
         }
 
         // for(SLAPrintObject *po : pobjects) {
@@ -195,17 +192,19 @@ void SLAPrint::process()
         // and before the supports had been sliced. (or the slicing has to be
         // repeated)
 
-//        if(po.is_step_done(slaposSupportTree) &&
+        if(po.is_step_done(slaposSupportTree) &&
-//           po.m_supportdata &&
+           po.m_supportdata &&
-//           po.m_supportdata->support_tree_ptr)
+           po.m_supportdata->support_tree_ptr)
-//        {
+        {
-//            double wt = po.m_config.pad_wall_thickness.getFloat();
+            double wt = po.m_config.pad_wall_thickness.getFloat();
-//            double h =  po.m_config.pad_wall_height.getFloat();
+            double h =  po.m_config.pad_wall_height.getFloat();
-//            double md = po.m_config.pad_max_merge_distance.getFloat();
+            double md = po.m_config.pad_max_merge_distance.getFloat();
-//            double er = po.m_config.pad_edge_radius.getFloat();
+            double er = po.m_config.pad_edge_radius.getFloat();
 
-//            po.m_supportdata->support_tree_ptr->add_pad(wt, h, md, er);
+            sla::ExPolygons bp;
-//        }
+            sla::base_plate(po.transformed_mesh(), bp);
+            po.m_supportdata->support_tree_ptr->add_pad(bp, wt, h, md, er);
+        }
     };
 
     // Slicing the support geometries similarly to the model slicing procedure.
@@ -216,13 +215,12 @@ void SLAPrint::process()
         if(sd && sd->support_tree_ptr) {
             auto lh = float(po.m_config.layer_height.getFloat());
             sd->support_slices = sd->support_tree_ptr->slice(lh, ilh);
-            std::cout << "support slice count " << sd->support_slices.size() << std::endl;
         }
     };
 
     // Rasterizing the model objects, and their supports
     auto rasterize = [this, ilh]() {
-        using Layer = ExPolygons;
+        using Layer = sla::ExPolygons;
         using LayerCopies = std::vector<SLAPrintObject::Instance>;
         struct LayerRef {
             std::reference_wrapper<const Layer> lref;
@@ -240,7 +238,7 @@ void SLAPrint::process()
         // into the layers hash
         for(SLAPrintObject *o : m_objects) {
             double lh = o->m_config.layer_height.getFloat();
-            std::vector<ExPolygons> & oslices = o->m_model_slices;
+            SlicedModel & oslices = o->m_model_slices;
             for(int i = 0; i < oslices.size(); ++i) {
                 double h = ilh + i * lh;
                 long long lyridx = static_cast<long long>(scale_(h));
@@ -248,11 +246,8 @@ void SLAPrint::process()
                 lyrs.emplace_back(oslices[i], o->m_instances);
             }
 
-            std::cout << "model slice count at rasterization: " << oslices.size() << std::endl;
-
             if(o->m_supportdata) { // deal with the support slices if present
                 auto& sslices = o->m_supportdata->support_slices;
-                std::cout << "support slice count at rasterization: " << o->m_supportdata->support_slices.size() << std::endl;
 
                 for(int i = 0; i < sslices.size(); ++i) {
                     double h = ilh + i * lh;
@@ -263,12 +258,12 @@ void SLAPrint::process()
             }
         }
 
+        if(canceled()) return;
+
         // collect all the keys
         std::vector<long long> keys; keys.reserve(levels.size());
         for(auto& e : levels) keys.emplace_back(e.first);
 
-        std::cout << "levels count at rasterization " << levels.size() << std::endl;
-
         { // create a raster printer for the current print parameters
             // I don't know any better
             auto& ocfg = m_objects.front()->m_config;
@@ -291,14 +286,21 @@ void SLAPrint::process()
         auto lvlcnt = unsigned(levels.size());
         printer.layers(lvlcnt);
 
+        // TODO exclusive progress indication for this step would be good
+        // as it is the longest of all. It would require synchronization
+        // in the parallel processing.
+
         // procedure to process one height level. This will run in parallel
-        auto lvlfn = [&keys, &levels, &printer](unsigned level_id) {
+        auto lvlfn = [this, &keys, &levels, &printer](unsigned level_id) {
+            if(canceled()) return;
+
             LayerRefs& lrange = levels[keys[level_id]];
 
             // Switch to the appropriate layer in the printer
             printer.begin_layer(level_id);
 
             for(auto& lyrref : lrange) { // for all layers in the current level
+                if(canceled()) break;
                 const Layer& sl = lyrref.lref;   // get the layer reference
                 const LayerCopies& copies = lyrref.copies;
 
@@ -316,6 +318,9 @@ void SLAPrint::process()
             printer.finish_layer(level_id);
         };
 
+        // last minute escape
+        if(canceled()) return;
+
         // Sequential version (for testing)
         // for(unsigned l = 0; l < lvlcnt; ++l) process_level(l);
 
@@ -351,6 +356,11 @@ void SLAPrint::process()
         [](){}  // validate
     };
 
+    const unsigned min_objstatus = 0;
+    const unsigned max_objstatus = PRINT_STEP_LEVELS[slapsRasterize];
+    const size_t objcount = m_objects.size();
+    const double ostepd = (max_objstatus - min_objstatus) / (objcount * 100.0);
+
     for(SLAPrintObject * po : m_objects) {
         for(size_t s = 0; s < pobj_program.size(); ++s) {
             auto currentstep = objectsteps[s];
@@ -361,8 +371,9 @@ void SLAPrint::process()
             throw_if_canceled();
 
             if(po->m_stepmask[s] && !po->is_step_done(currentstep)) {
-                set_status(OBJ_STEP_LEVELS[currentstep],
+                unsigned st = OBJ_STEP_LEVELS[currentstep];
-                           OBJ_STEP_LABELS[currentstep]);
+                st = unsigned(min_objstatus + st * ostepd);
+                set_status(st, OBJ_STEP_LABELS[currentstep]);
 
                 po->set_started(currentstep);
                 pobj_program[s](*po);
@@ -375,7 +386,7 @@ void SLAPrint::process()
         slapsRasterize, slapsValidate
     };
 
-    // TODO: enable rasterizing
+    // this would disable the rasterization step
     // m_stepmask[slapsRasterize] = false;
 
     for(size_t s = 0; s < print_program.size(); ++s) {
@@ -402,7 +413,6 @@ SLAPrintObject::SLAPrintObject(SLAPrint *print, ModelObject *model_object):
     m_model_object(model_object),
     m_stepmask(slaposCount, true)
 {
-
 }
 
 SLAPrintObject::~SLAPrintObject() {}
@@ -414,22 +424,33 @@ TriangleMesh SLAPrintObject::support_mesh() const
     if(m_supportdata && m_supportdata->support_tree_ptr)
         m_supportdata->support_tree_ptr->merged_mesh(trm);
 
+    // TODO: is this necessary?
     trm.repair();
 
-    std::cout << "support mesh united and returned" << std::endl;
     return trm;
-//    return make_cube(10., 10., 10.);
 }
 
 TriangleMesh SLAPrintObject::pad_mesh() const
 {
-    if(!m_supportdata || !m_supportdata->support_tree_ptr) {
+    if(!m_supportdata || !m_supportdata->support_tree_ptr) return {};
-        std::cout << "Empty pad mesh returned.." << std::endl;
-        return TriangleMesh();
-    }
 
-    // FIXME: pad mesh is empty here for some reason.
     return m_supportdata->support_tree_ptr->get_pad();
 }
 
+const TriangleMesh &SLAPrintObject::transformed_mesh() const {
+    // we need to transform the raw mesh...
+    // currently all the instances share the same x and y rotation and scaling
+    // so we have to extract those from e.g. the first instance and apply to the
+    // raw mesh. This is also true for the support points.
+    // BUT: when the support structure is spawned for each instance than it has
+    // to omit the X, Y rotation and scaling as those have been already applied
+    // or apply an inverse transformation on the support structure after it
+    // has been created.
+
+    if(m_trmesh_valid) return m_transformed_rmesh;
+    m_transformed_rmesh = m_model_object->raw_mesh();
+    m_transformed_rmesh.transform(m_trafo);
+    m_trmesh_valid = true;
+}
+
 } // namespace Slic3r

src/libslic3r/SLAPrint.hpp

@@ -57,6 +57,9 @@ public:
     // Support mesh is only valid if this->is_step_done(slaposPad) is true.
     TriangleMesh            pad_mesh() const;
 
+    // This will return the transformed mesh which is cached
+    const TriangleMesh&     transformed_mesh() const;
+
     // I refuse to grantee copying (Tamas)
     SLAPrintObject(const SLAPrintObject&) = delete;
     SLAPrintObject& operator=(const SLAPrintObject&) = delete;
@@ -71,7 +74,7 @@ protected:
     void                    config_apply(const ConfigBase &other, bool ignore_nonexistent = false) { this->m_config.apply(other, ignore_nonexistent); }
     void                    config_apply_only(const ConfigBase &other, const t_config_option_keys &keys, bool ignore_nonexistent = false) 
     	{ this->m_config.apply_only(other, keys, ignore_nonexistent); }
-    void                    set_trafo(const Transform3d& trafo) { m_trafo = trafo; }
+    void                    set_trafo(const Transform3d& trafo) { m_trafo = trafo; m_trmesh_valid = false; }
 
     bool                    set_instances(const std::vector<Instance> &instances);
     // Invalidates the step, and its depending steps in SLAPrintObject and SLAPrint.
@@ -90,6 +93,10 @@ private:
     std::vector<bool>                       m_stepmask;
     std::vector<ExPolygons>                 m_model_slices;
 
+    // Caching the transformed (m_trafo) raw mesh of the object
+    mutable TriangleMesh                    m_transformed_rmesh;
+    mutable bool                            m_trmesh_valid = false;
+
     class SupportData;
     std::unique_ptr<SupportData> m_supportdata;
 };