From d7baac59ef3f68ed767020f673aaf0680b70f915 Mon Sep 17 00:00:00 2001 From: tamasmeszaros Date: Wed, 7 Nov 2018 16:08:04 +0100 Subject: [PATCH] Comments and SLA stage definitions. --- src/slic3r/GUI/GLGizmo.cpp | 31 +++++++++++---------- src/slic3r/GUI/SLAPrint.cpp | 14 ++++++++++ src/slic3r/GUI/SLAPrint.hpp | 54 ++++++++++++++++++++++++++++++------- 3 files changed, 74 insertions(+), 25 deletions(-) diff --git a/src/slic3r/GUI/GLGizmo.cpp b/src/slic3r/GUI/GLGizmo.cpp index 3df089c73..67c504411 100644 --- a/src/slic3r/GUI/GLGizmo.cpp +++ b/src/slic3r/GUI/GLGizmo.cpp @@ -1624,28 +1624,27 @@ void GLGizmoSlaSupports::update_mesh() void GLGizmoSlaSupports::on_deactivate() { if(!m_model_object) return; - sla::Controller supportctl; - std::cout << "Generating supports:" << std::endl; +// sla::Controller supportctl; +// std::cout << "Generating supports:" << std::endl; - // TODO: somehow get the global status indicator - supportctl.statuscb = [] (unsigned st, const std::string& msg) { - std::cout << st << "% " << msg << std::endl; - }; +// // TODO: somehow get the global status indicator +// supportctl.statuscb = [] (unsigned st, const std::string& msg) { +// std::cout << st << "% " << msg << std::endl; +// }; - TriangleMesh&& m = m_model_object->raw_mesh(); - auto&& trafo = m_model_object_matrix.cast(); - m.transform(trafo); - auto emesh = sla::to_eigenmesh(m); +// TriangleMesh&& m = m_model_object->raw_mesh(); +// m.transform(m_model_object_matrix); +// auto emesh = sla::to_eigenmesh(m); - sla::SupportConfig cfg; - sla::PointSet input = sla::support_points(*m_model_object, 0 /*instance*/); +// sla::SupportConfig cfg; +// sla::PointSet input = sla::support_points(*m_model_object, 0 /*instance*/); - sla::SLASupportTree stree(input, emesh, cfg, supportctl); +// sla::SLASupportTree stree(input, emesh, cfg, supportctl); - TriangleMesh output; - stree.merged_mesh(output); +// TriangleMesh output; +// stree.merged_mesh(output); - _3DScene::reload_scene(m_parent.get_wxglcanvas(), false); +// _3DScene::reload_scene(m_parent.get_wxglcanvas(), false); } Vec3f GLGizmoSlaSupports::unproject_on_mesh(const Vec2d& mouse_pos) diff --git a/src/slic3r/GUI/SLAPrint.cpp b/src/slic3r/GUI/SLAPrint.cpp index 52957b854..c6a7a8940 100644 --- a/src/slic3r/GUI/SLAPrint.cpp +++ b/src/slic3r/GUI/SLAPrint.cpp @@ -1,7 +1,21 @@ #include "SLAPrint.hpp" +#include "GUI.hpp" namespace Slic3r { +const std::string SLAPrint::m_stage_labels[] = { + "", // IDLE, + L("Finding best rotation"), // FIND_ROTATION, + L("Scanning model structure"), // SUPPORT_POINTS, + L("Generating support tree"), // SUPPORT_TREE, + L("Generating base pool"), // BASE_POOL, + L("Slicing model"), // SLICE_MODEL, + L("Slicing supports"), // SLICE_SUPPORTS, + L("Exporting layers"), // EXPORT, + L("Prepared for printing"), // DONE, + L("SLA print preparation aborted") // ABORT, +}; + void SLAPrint::synch() { m_gcfg = m_config_reader(); // TODO: check model objects and instances diff --git a/src/slic3r/GUI/SLAPrint.hpp b/src/slic3r/GUI/SLAPrint.hpp index b1354e8d0..7878e25ba 100644 --- a/src/slic3r/GUI/SLAPrint.hpp +++ b/src/slic3r/GUI/SLAPrint.hpp @@ -15,7 +15,7 @@ class ModelInstance; class GLCanvas3D; class DynamicPrintConfig; -// Ok, this will be the driver to create background threads. Possibly +// This will be the driver to create background threads. Possibly // implemented using a BackgroundSlicingProcess or something derived from that // The methods should be thread safe, obviously... class BackgroundProcess { @@ -23,14 +23,23 @@ public: virtual ~BackgroundProcess() {} + /// schedule a task on the background virtual void schedule(std::function fn) = 0; + /// Report status change, used inside the worker thread virtual void status(unsigned st, const std::string& msg) = 0; + /// Check whether the calculation was canceled from the UI. Called by the + /// worker thread virtual bool is_canceled() = 0; + /// Setting up a callback that transfers the input parameters to the worker + /// thread. Appropriate synchronization has to be implemented here. A simple + /// condition variable and mutex pair should do the job. virtual void on_input_changed(std::function synchfn) = 0; + /// Determine the state of the background process. If something is running + /// returns true. If no job is running, returns false. virtual bool is_running() = 0; }; @@ -47,8 +56,9 @@ public: * triangle meshes or receiving the rendering canvas and drawing on that * directly. * - * TODO: This class has to be implement the Print interface (not defined yet) - * to be usable as the input to the BackgroundSlicingProcess. + * TODO: This class uses the BackgroundProcess interface to create workers and + * manage input change events. An appropriate implementation can be derived + * from BackgroundSlicingProcess which is now working only with the FDM Print. */ class SLAPrint /* : public Print */ { public: @@ -57,6 +67,7 @@ public: BLOCKING, NON_BLOCKING }; + // Global SLA printing configuration struct GlobalConfig { double width_mm; double height_mm; @@ -67,6 +78,9 @@ public: private: + // There will be a support tree for every instance of every ModelObject + // because if the object is rotated differently, the support should also be + // very different struct PrintObjectInstance { Transform3f tr; std::unique_ptr support_tree_ptr; @@ -75,11 +89,14 @@ private: using InstanceMap = std::unordered_map; + // Every ModelObject will have its PrintObject here. It will contain the + // cached index-triangle structure (emesh) and the map of the instance cache struct PrintObject { sla::EigenMesh3D emesh; InstanceMap instances; }; + // Map definition for the print objects using ObjectMap = std::unordered_map; // Input data channels: *************************************************** @@ -88,11 +105,12 @@ private: // something to read out the config profiles and return the values we need. std::function m_config_reader; + // ************************************************************************ - GlobalConfig m_gcfg; - ObjectMap m_data; - std::shared_ptr m_process; + GlobalConfig m_gcfg; // The global SLA print config instance + ObjectMap m_data; // The model data cache (PrintObject's) + std::shared_ptr m_process; // The scheduler // For now it will just stop the whole process and invalidate everything void synch(); @@ -108,11 +126,29 @@ private: } } + enum Stages { + IDLE, + FIND_ROTATION, + SUPPORT_POINTS, + SUPPORT_TREE, + BASE_POOL, + SLICE_MODEL, + SLICE_SUPPORTS, + EXPORT, + DONE, + ABORT, + NUM_STAGES + }; + + static const std::string m_stage_labels[NUM_STAGES]; + + bool run(); public: SLAPrint(const Model * model, - std::function cfgreader = [](){ return SLAPrint::GlobalConfig(); }, - std::shared_ptr scheduler = {}): + std::function cfgreader = + [](){ return SLAPrint::GlobalConfig(); }, + std::shared_ptr scheduler = {}): m_model(model), m_config_reader(cfgreader) { synch(); @@ -123,7 +159,7 @@ public: // This will start the calculation using the bool start(std::shared_ptr scheduler); - // Get the full support structure (including the supports) + // Get the full support structure (including the base pool) // This should block until the supports are not ready? bool support_mesh(TriangleMesh& output, CallType calltype = BLOCKING);