#include "SLAPrint.hpp" #include "SLA/SLASupportTree.hpp" #include "SLA/SLABasePool.hpp" #include #include //#include //#include "tbb/mutex.h" #include "I18N.hpp" //! macro used to mark string used at localization, //! return same string #define L(s) Slic3r::I18N::translate(s) namespace Slic3r { using SlicedModel = SlicedSupports; using SupportTreePtr = std::unique_ptr; class SLAPrintObject::SupportData { public: sla::EigenMesh3D emesh; // index-triangle representation sla::PointSet support_points; // all the support points (manual/auto) SupportTreePtr support_tree_ptr; // the supports SlicedSupports support_slices; // sliced supports }; namespace { const std::array OBJ_STEP_LEVELS = { 0, 20, 30, 50, 70, 90 }; const std::array OBJ_STEP_LABELS = { L("Slicing model"), // slaposObjectSlice, L("Generating islands"), // slaposSupportIslands, L("Scanning model structure"), // slaposSupportPoints, L("Generating support tree"), // slaposSupportTree, L("Generating base pool"), // slaposBasePool, L("Slicing supports") // slaposSliceSupports, }; const std::array PRINT_STEP_LEVELS = { // This is after processing all the Print objects, so we start from 50% 50, // slapsRasterize 90, // slapsValidate }; const std::array PRINT_STEP_LABELS = { L("Rasterizing layers"), // slapsRasterize L("Validating"), // slapsValidate }; } void SLAPrint::clear() { tbb::mutex::scoped_lock lock(this->state_mutex()); // The following call should stop background processing if it is running. this->invalidate_all_steps(); for (SLAPrintObject *object : m_objects) delete object; m_objects.clear(); } // Transformation without rotation around Z and without a shift by X and Y. static Transform3d sla_trafo(const ModelObject &model_object) { ModelInstance &model_instance = *model_object.instances.front(); Vec3d offset = model_instance.get_offset(); Vec3d rotation = model_instance.get_rotation(); offset(0) = 0.; offset(1) = 0.; rotation(2) = 0.; return Geometry::assemble_transform(offset, rotation, model_instance.get_scaling_factor(), model_instance.get_mirror()); } // List of instances, where the ModelInstance transformation is a composite of sla_trafo and the transformation defined by SLAPrintObject::Instance. static std::vector sla_instances(const ModelObject &model_object) { std::vector instances; for (ModelInstance *model_instance : model_object.instances) if (model_instance->is_printable()) { instances.emplace_back(SLAPrintObject::Instance( model_instance->id(), Point::new_scale(model_instance->get_offset(X), model_instance->get_offset(Y)), float(model_instance->get_rotation(Z)))); } return instances; } SLAPrint::ApplyStatus SLAPrint::apply(const Model &model, const DynamicPrintConfig &config_in) { #ifdef _DEBUG check_model_ids_validity(model); #endif /* _DEBUG */ // Make a copy of the config, normalize it. DynamicPrintConfig config(config_in); config.normalize(); // Collect changes to print config. t_config_option_keys printer_diff = m_printer_config.diff(config); t_config_option_keys material_diff = m_material_config.diff(config); t_config_option_keys object_diff = m_default_object_config.diff(config); // Do not use the ApplyStatus as we will use the max function when updating apply_status. unsigned int apply_status = APPLY_STATUS_UNCHANGED; auto update_apply_status = [&apply_status](bool invalidated) { apply_status = std::max(apply_status, invalidated ? APPLY_STATUS_INVALIDATED : APPLY_STATUS_CHANGED); }; if (! (printer_diff.empty() && material_diff.empty() && object_diff.empty())) update_apply_status(false); // Grab the lock for the Print / PrintObject milestones. tbb::mutex::scoped_lock lock(this->state_mutex()); // The following call may stop the background processing. update_apply_status(this->invalidate_state_by_config_options(printer_diff)); update_apply_status(this->invalidate_state_by_config_options(material_diff)); // It is also safe to change m_config now after this->invalidate_state_by_config_options() call. m_printer_config.apply_only(config, printer_diff, true); // Handle changes to material config. m_material_config.apply_only(config, material_diff, true); // Handle changes to object config defaults m_default_object_config.apply_only(config, object_diff, true); struct ModelObjectStatus { enum Status { Unknown, Old, New, Moved, Deleted, }; ModelObjectStatus(ModelID id, Status status = Unknown) : id(id), status(status) {} ModelID id; Status status; // Search by id. bool operator<(const ModelObjectStatus &rhs) const { return id < rhs.id; } }; std::set model_object_status; // 1) Synchronize model objects. if (model.id() != m_model.id()) { // Kill everything, initialize from scratch. // Stop background processing. this->call_cancell_callback(); update_apply_status(this->invalidate_all_steps()); for (SLAPrintObject *object : m_objects) { model_object_status.emplace(object->model_object()->id(), ModelObjectStatus::Deleted); delete object; } m_objects.clear(); m_model.assign_copy(model); for (const ModelObject *model_object : m_model.objects) model_object_status.emplace(model_object->id(), ModelObjectStatus::New); } else { if (model_object_list_equal(m_model, model)) { // The object list did not change. for (const ModelObject *model_object : m_model.objects) model_object_status.emplace(model_object->id(), ModelObjectStatus::Old); } else if (model_object_list_extended(m_model, model)) { // Add new objects. Their volumes and configs will be synchronized later. update_apply_status(this->invalidate_step(slapsRasterize)); for (const ModelObject *model_object : m_model.objects) model_object_status.emplace(model_object->id(), ModelObjectStatus::Old); for (size_t i = m_model.objects.size(); i < model.objects.size(); ++ i) { model_object_status.emplace(model.objects[i]->id(), ModelObjectStatus::New); m_model.objects.emplace_back(ModelObject::new_copy(*model.objects[i])); m_model.objects.back()->set_model(&m_model); } } else { // Reorder the objects, add new objects. // First stop background processing before shuffling or deleting the PrintObjects in the object list. this->call_cancell_callback(); update_apply_status(this->invalidate_step(slapsRasterize)); // Second create a new list of objects. std::vector model_objects_old(std::move(m_model.objects)); m_model.objects.clear(); m_model.objects.reserve(model.objects.size()); auto by_id_lower = [](const ModelObject *lhs, const ModelObject *rhs){ return lhs->id() < rhs->id(); }; std::sort(model_objects_old.begin(), model_objects_old.end(), by_id_lower); for (const ModelObject *mobj : model.objects) { auto it = std::lower_bound(model_objects_old.begin(), model_objects_old.end(), mobj, by_id_lower); if (it == model_objects_old.end() || (*it)->id() != mobj->id()) { // New ModelObject added. m_model.objects.emplace_back(ModelObject::new_copy(*mobj)); m_model.objects.back()->set_model(&m_model); model_object_status.emplace(mobj->id(), ModelObjectStatus::New); } else { // Existing ModelObject re-added (possibly moved in the list). m_model.objects.emplace_back(*it); model_object_status.emplace(mobj->id(), ModelObjectStatus::Moved); } } bool deleted_any = false; for (ModelObject *&model_object : model_objects_old) { if (model_object_status.find(ModelObjectStatus(model_object->id())) == model_object_status.end()) { model_object_status.emplace(model_object->id(), ModelObjectStatus::Deleted); deleted_any = true; } else // Do not delete this ModelObject instance. model_object = nullptr; } if (deleted_any) { // Delete PrintObjects of the deleted ModelObjects. std::vector print_objects_old = std::move(m_objects); m_objects.clear(); m_objects.reserve(print_objects_old.size()); for (SLAPrintObject *print_object : print_objects_old) { auto it_status = model_object_status.find(ModelObjectStatus(print_object->model_object()->id())); assert(it_status != model_object_status.end()); if (it_status->status == ModelObjectStatus::Deleted) { update_apply_status(print_object->invalidate_all_steps()); delete print_object; } else m_objects.emplace_back(print_object); } for (ModelObject *model_object : model_objects_old) delete model_object; } } } // 2) Map print objects including their transformation matrices. struct PrintObjectStatus { enum Status { Unknown, Deleted, Reused, New }; PrintObjectStatus(SLAPrintObject *print_object, Status status = Unknown) : id(print_object->model_object()->id()), print_object(print_object), trafo(print_object->trafo()), status(status) {} PrintObjectStatus(ModelID id) : id(id), print_object(nullptr), trafo(Transform3d::Identity()), status(Unknown) {} // ID of the ModelObject & PrintObject ModelID id; // Pointer to the old PrintObject SLAPrintObject *print_object; // Trafo generated with model_object->world_matrix(true) Transform3d trafo; Status status; // Search by id. bool operator<(const PrintObjectStatus &rhs) const { return id < rhs.id; } }; std::multiset print_object_status; for (SLAPrintObject *print_object : m_objects) print_object_status.emplace(PrintObjectStatus(print_object)); // 3) Synchronize ModelObjects & PrintObjects. std::vector print_objects_new; print_objects_new.reserve(std::max(m_objects.size(), m_model.objects.size())); bool new_objects = false; for (size_t idx_model_object = 0; idx_model_object < model.objects.size(); ++ idx_model_object) { ModelObject &model_object = *m_model.objects[idx_model_object]; auto it_status = model_object_status.find(ModelObjectStatus(model_object.id())); assert(it_status != model_object_status.end()); assert(it_status->status != ModelObjectStatus::Deleted); if (it_status->status == ModelObjectStatus::New) // PrintObject instances will be added in the next loop. continue; // Update the ModelObject instance, possibly invalidate the linked PrintObjects. assert(it_status->status == ModelObjectStatus::Old || it_status->status == ModelObjectStatus::Moved); const ModelObject &model_object_new = *model.objects[idx_model_object]; auto it_print_object_status = print_object_status.lower_bound(PrintObjectStatus(model_object.id())); if (it_print_object_status != print_object_status.end() && it_print_object_status->id != model_object.id()) it_print_object_status = print_object_status.end(); // Check whether a model part volume was added or removed, their transformations or order changed. bool model_parts_differ = model_volume_list_changed(model_object, model_object_new, ModelVolume::MODEL_PART); bool sla_trafo_differs = model_object.instances.empty() != model_object_new.instances.empty() || (! model_object.instances.empty() && ! sla_trafo(model_object).isApprox(sla_trafo(model_object_new))); if (model_parts_differ || sla_trafo_differs) { // The very first step (the slicing step) is invalidated. One may freely remove all associated PrintObjects. if (it_print_object_status != print_object_status.end()) { update_apply_status(it_print_object_status->print_object->invalidate_all_steps()); const_cast(*it_print_object_status).status = PrintObjectStatus::Deleted; } // Copy content of the ModelObject including its ID, do not change the parent. model_object.assign_copy(model_object_new); } else { // Synchronize Object's config. bool object_config_changed = model_object.config != model_object_new.config; if (object_config_changed) model_object.config = model_object_new.config; if (! object_diff.empty() || object_config_changed) { SLAPrintObjectConfig new_config = m_default_object_config; normalize_and_apply_config(new_config, model_object.config); if (it_print_object_status != print_object_status.end()) { t_config_option_keys diff = it_print_object_status->print_object->config().diff(new_config); if (! diff.empty()) { update_apply_status(it_print_object_status->print_object->invalidate_state_by_config_options(diff)); it_print_object_status->print_object->config_apply_only(new_config, diff, true); } } } if (model_object.sla_support_points != model_object_new.sla_support_points) { model_object.sla_support_points = model_object_new.sla_support_points; if (it_print_object_status != print_object_status.end()) update_apply_status(it_print_object_status->print_object->invalidate_step(slaposSupportPoints)); } // Copy the ModelObject name, input_file and instances. The instances will compared against PrintObject instances in the next step. model_object.name = model_object_new.name; model_object.input_file = model_object_new.input_file; model_object.clear_instances(); model_object.instances.reserve(model_object_new.instances.size()); for (const ModelInstance *model_instance : model_object_new.instances) { model_object.instances.emplace_back(new ModelInstance(*model_instance)); model_object.instances.back()->set_model_object(&model_object); } } std::vector new_instances = sla_instances(model_object); if (it_print_object_status != print_object_status.end() && it_print_object_status->status != PrintObjectStatus::Deleted) { // The SLAPrintObject is already there. if (new_instances != it_print_object_status->print_object->instances()) { // Instances changed. it_print_object_status->print_object->set_instances(new_instances); update_apply_status(this->invalidate_step(slapsRasterize)); } print_objects_new.emplace_back(it_print_object_status->print_object); const_cast(*it_print_object_status).status = PrintObjectStatus::Reused; } else { auto print_object = new SLAPrintObject(this, &model_object); print_object->set_trafo(sla_trafo(model_object)); print_object->set_instances(new_instances); print_object->config_apply(config, true); print_objects_new.emplace_back(print_object); new_objects = true; } } if (m_objects != print_objects_new) { this->call_cancell_callback(); update_apply_status(this->invalidate_all_steps()); m_objects = print_objects_new; // Delete the PrintObjects marked as Unknown or Deleted. bool deleted_objects = false; for (auto &pos : print_object_status) if (pos.status == PrintObjectStatus::Unknown || pos.status == PrintObjectStatus::Deleted) { // update_apply_status(pos.print_object->invalidate_all_steps()); delete pos.print_object; deleted_objects = true; } update_apply_status(new_objects); } #ifdef _DEBUG check_model_ids_equal(m_model, model); #endif /* _DEBUG */ return static_cast(apply_status); } void SLAPrint::process() { using namespace sla; // 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 // shortcut to initial layer height double ilhd = m_material_config.initial_layer_height.getFloat(); auto ilh = float(ilhd); // The slicing will be performed on an imaginary 1D grid which starts from // the bottom of the bounding box created around the supported model. So // the first layer which is usually thicker will be part of the supports // not the model geometry. Exception is when the model is not in the air // (elevation is zero) and no pad creation was requested. In this case the // model geometry starts on the ground level and the initial layer is part // of it. In any case, the model and the supports have to be sliced in the // same imaginary grid (the height vector argument to TriangleMeshSlicer). // Slicing the model object. This method is oversimplified and needs to // be compared with the fff slicing algorithm for verification auto slice_model = [this, ilh, ilhd](SLAPrintObject& po) { double lh = po.m_config.layer_height.getFloat(); TriangleMesh mesh = po.transformed_mesh(); TriangleMeshSlicer slicer(&mesh); auto bb3d = mesh.bounding_box(); double elevation = po.get_elevation(); float minZ = float(bb3d.min(Z)) - float(elevation); float maxZ = float(bb3d.max(Z)) ; auto flh = float(lh); auto gnd = float(bb3d.min(Z)); std::vector heights; // The first layer (the one before the initial height) is added only // if there is no pad and no elevation value if(minZ >= gnd) heights.emplace_back(minZ); for(float h = minZ + ilh; h < maxZ; h += flh) if(h >= gnd) heights.emplace_back(h); auto& layers = po.m_model_slices; slicer.slice(heights, &layers, [this](){ throw_if_canceled(); }); }; auto support_points = [](SLAPrintObject& po) { 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(po.transformed_mesh()); po.m_supportdata->support_points = sla::to_point_set(po.transformed_support_points()); } // for(SLAPrintObject *po : pobjects) { // TODO: calculate automatic support points // po->m_supportdata->slice_cache contains the slices at this point //} }; // In this step we create the supports auto support_tree = [this](SLAPrintObject& po) { if(!po.m_supportdata) return; auto& emesh = po.m_supportdata->emesh; auto& pts = po.m_supportdata->support_points; // nowhere filled yet try { sla::SupportConfig scfg; SLAPrintObjectConfig& c = po.m_config; scfg.head_front_radius_mm = c.support_head_front_radius.getFloat(); scfg.head_back_radius_mm = c.support_head_back_radius.getFloat(); scfg.head_penetration_mm = c.support_head_penetration.getFloat(); scfg.head_width_mm = c.support_head_width.getFloat(); scfg.object_elevation_mm = c.support_object_elevation.getFloat(); scfg.tilt = c.support_critical_angle.getFloat() * PI / 180.0 ; scfg.max_bridge_length_mm = c.support_max_bridge_length.getFloat(); scfg.pillar_radius_mm = c.support_pillar_radius.getFloat(); sla::Controller ctl; ctl.statuscb = [this](unsigned st, const std::string& msg) { unsigned stinit = OBJ_STEP_LEVELS[slaposSupportTree]; double d = (OBJ_STEP_LEVELS[slaposBasePool] - stinit) / 100.0; set_status(unsigned(stinit + st*d), msg); }; ctl.stopcondition = [this](){ return canceled(); }; ctl.cancelfn = [this]() { throw_if_canceled(); }; po.m_supportdata->support_tree_ptr.reset( new SLASupportTree(pts, emesh, scfg, ctl)); } catch(sla::SLASupportsStoppedException&) { // no need to rethrow // throw_if_canceled(); } }; // This step generates the sla base pad auto base_pool = [](SLAPrintObject& po) { // this step can only go after the support tree has been created // and before the supports had been sliced. (or the slicing has to be // repeated) if(po.is_step_done(slaposSupportTree) && po.m_config.pad_enable.getBool() && po.m_supportdata && po.m_supportdata->support_tree_ptr) { double wt = po.m_config.pad_wall_thickness.getFloat(); double h = po.m_config.pad_wall_height.getFloat(); double md = po.m_config.pad_max_merge_distance.getFloat(); double er = po.m_config.pad_edge_radius.getFloat(); double lh = po.m_config.layer_height.getFloat(); double elevation = po.m_config.support_object_elevation.getFloat(); sla::PoolConfig pcfg(wt, h, md, er); sla::ExPolygons bp; double pad_h = sla::get_pad_elevation(pcfg); if(elevation < pad_h) sla::base_plate(po.transformed_mesh(), bp, float(pad_h), float(lh)); po.m_supportdata->support_tree_ptr->add_pad(bp, wt, h, md, er); } }; // Slicing the support geometries similarly to the model slicing procedure. // If the pad had been added previously (see step "base_pool" than it will // be part of the slices) auto slice_supports = [ilh](SLAPrintObject& po) { auto& sd = po.m_supportdata; 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); } }; // Rasterizing the model objects, and their supports auto rasterize = [this, ilh, ilhd]() { using Layer = sla::ExPolygons; using LayerCopies = std::vector; struct LayerRef { std::reference_wrapper lref; std::reference_wrapper copies; LayerRef(const Layer& lyr, const LayerCopies& cp) : lref(std::cref(lyr)), copies(std::cref(cp)) {} }; using LevelID = long long; using LayerRefs = std::vector; // layers according to quantized height levels std::map levels; auto sih = LevelID(scale_(ilh)); // For all print objects, go through its initial layers and place them // into the layers hash for(SLAPrintObject *o : m_objects) { auto bb = o->transformed_mesh().bounding_box(); double modelgnd = bb.min(Z); double elevation = o->get_elevation(); double lh = o->m_config.layer_height.getFloat(); double minZ = modelgnd - elevation; // scaled values: auto sminZ = LevelID(scale_(minZ)); auto smaxZ = LevelID(scale_(bb.max(Z))); auto smodelgnd = LevelID(scale_(modelgnd)); auto slh = LevelID(scale_(lh)); // It is important that the next levels math the levels in // model_slice method. Only difference is that here it works with // scaled coordinates std::vector levelids; if(sminZ >= smodelgnd) levelids.emplace_back(sminZ); for(LevelID h = sminZ + sih; h < smaxZ; h += slh) if(h >= smodelgnd) levelids.emplace_back(h); SlicedModel & oslices = o->m_model_slices; // If everything went well this code should not run at all, but // let's be robust... assert(levelids.size() == oslices.size()); if(levelids.size() < oslices.size()) { // extend the levels until... BOOST_LOG_TRIVIAL(warning) << "Height level mismatch at rasterization!\n"; LevelID lastlvl = levelids.back(); while(levelids.size() < oslices.size()) { lastlvl += slh; levelids.emplace_back(lastlvl); } } 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], o->m_instances); } if(o->m_supportdata) { // deal with the support slices if present auto& sslices = o->m_supportdata->support_slices; 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], o->m_instances); } } } if(canceled()) return; // collect all the keys std::vector keys; keys.reserve(levels.size()); for(auto& e : levels) keys.emplace_back(e.first); { // create a raster printer for the current print parameters // I don't know any better auto& ocfg = m_objects.front()->m_config; auto& matcfg = m_material_config; auto& printcfg = m_printer_config; double w = printcfg.display_width.getFloat(); double h = printcfg.display_height.getFloat(); unsigned pw = printcfg.display_pixels_x.getInt(); unsigned ph = printcfg.display_pixels_y.getInt(); double lh = ocfg.layer_height.getFloat(); double exp_t = matcfg.exposure_time.getFloat(); double iexp_t = matcfg.initial_exposure_time.getFloat(); m_printer.reset(new SLAPrinter(w, h, pw, ph, lh, exp_t, iexp_t)); } // Allocate space for all the layers SLAPrinter& printer = *m_printer; 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 = [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; // 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)); slice.rotate(cp.rotation); printer.draw_polygon(slice, level_id); } } } // Finish the layer for later saving it. 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); // Print all the layers in parallel tbb::parallel_for(0, lvlcnt, lvlfn); }; using slaposFn = std::function; using slapsFn = std::function; // This is the actual order of steps done on each PrintObject std::array objectsteps = { slaposSupportIslands, slaposSupportPoints, slaposSupportTree, slaposBasePool, slaposObjectSlice, slaposSliceSupports }; std::array pobj_program = { slice_model, [](SLAPrintObject&){}, // slaposSupportIslands now empty support_points, support_tree, base_pool, slice_supports }; std::array print_program = { rasterize, [](){} // 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 < objectsteps.size(); ++s) { auto currentstep = objectsteps[s]; // if the base pool (which means also the support tree) is done, // do a refresh when indicating progress auto flg = currentstep == slaposObjectSlice ? SlicingStatus::RELOAD_SCENE : SlicingStatus::DEFAULT; // Cancellation checking. Each step will check for cancellation // on its own and return earlier gracefully. Just after it returns // execution gets to this point and throws the canceled signal. throw_if_canceled(); if(po->m_stepmask[currentstep] && !po->is_step_done(currentstep)) { po->set_started(currentstep); unsigned st = OBJ_STEP_LEVELS[currentstep]; st = unsigned(min_objstatus + st * ostepd); set_status(st, OBJ_STEP_LABELS[currentstep], flg); pobj_program[currentstep](*po); po->set_done(currentstep); } } } std::array printsteps = { slapsRasterize, slapsValidate }; // this would disable the rasterization step // m_stepmask[slapsRasterize] = false; for(size_t s = 0; s < print_program.size(); ++s) { auto currentstep = printsteps[s]; throw_if_canceled(); if(m_stepmask[currentstep] && !is_step_done(currentstep)) { set_status(PRINT_STEP_LEVELS[currentstep], PRINT_STEP_LABELS[currentstep]); set_started(currentstep); print_program[currentstep](); set_done(currentstep); } } // If everything vent well set_status(100, L("Slicing done")); } bool SLAPrint::invalidate_state_by_config_options(const std::vector &opt_keys) { if (opt_keys.empty()) return false; // Cache the plenty of parameters, which influence the final rasterization only, // or they are only notes not influencing the rasterization step. static std::unordered_set steps_rasterize = { "exposure_time", "initial_exposure_time", "material_correction_printing", "material_correction_curing", "display_width", "display_height", "display_pixels_x", "display_pixels_y", "printer_correction" }; static std::unordered_set steps_ignore = { "bed_shape", "max_print_height", "printer_technology", }; std::vector steps; std::vector osteps; bool invalidated = false; for (const t_config_option_key &opt_key : opt_keys) { if (steps_rasterize.find(opt_key) != steps_rasterize.end()) { // These options only affect the final rasterization, or they are just notes without influence on the output, // so there is nothing to invalidate. steps.emplace_back(slapsRasterize); } else if (steps_ignore.find(opt_key) != steps_ignore.end()) { // These steps have no influence on the output. Just ignore them. } else if (opt_key == "initial_layer_height") { steps.emplace_back(slapsRasterize); osteps.emplace_back(slaposObjectSlice); } else { // All values should be covered. assert(false); } } sort_remove_duplicates(steps); for (SLAPrintStep step : steps) invalidated |= this->invalidate_step(step); sort_remove_duplicates(osteps); for (SLAPrintObjectStep ostep : osteps) for (SLAPrintObject *object : m_objects) invalidated |= object->invalidate_step(ostep); return invalidated; } SLAPrintObject::SLAPrintObject(SLAPrint *print, ModelObject *model_object): Inherited(print, model_object), m_stepmask(slaposCount, true), m_transformed_rmesh( [this](TriangleMesh& obj){ obj = m_model_object->raw_mesh(); obj.transform(m_trafo); }) { } SLAPrintObject::~SLAPrintObject() {} // Called by SLAPrint::apply_config(). // This method only accepts SLAPrintObjectConfig option keys. bool SLAPrintObject::invalidate_state_by_config_options(const std::vector &opt_keys) { if (opt_keys.empty()) return false; std::vector steps; bool invalidated = false; for (const t_config_option_key &opt_key : opt_keys) { if ( opt_key == "support_head_front_radius" || opt_key == "support_head_penetration" || opt_key == "support_head_back_radius" || opt_key == "support_head_width" || opt_key == "support_pillar_radius" || opt_key == "support_base_radius" || opt_key == "support_base_height" || opt_key == "support_critical_angle" || opt_key == "support_max_bridge_length" || opt_key == "support_object_elevation") { steps.emplace_back(slaposSupportTree); } else if ( opt_key == "pad_enable" || opt_key == "pad_wall_thickness" || opt_key == "pad_wall_height" || opt_key == "pad_max_merge_distance" || opt_key == "pad_edge_radius") { steps.emplace_back(slaposBasePool); } else { // All keys should be covered. assert(false); } } sort_remove_duplicates(steps); for (SLAPrintObjectStep step : steps) invalidated |= this->invalidate_step(step); return invalidated; } bool SLAPrintObject::invalidate_step(SLAPrintObjectStep step) { bool invalidated = Inherited::invalidate_step(step); // propagate to dependent steps if (step == slaposObjectSlice) { invalidated |= this->invalidate_all_steps(); } else if (step == slaposSupportIslands) { invalidated |= this->invalidate_steps({ slaposSupportPoints, slaposSupportTree, slaposBasePool, slaposSliceSupports }); invalidated |= m_print->invalidate_step(slapsRasterize); } else if (step == slaposSupportPoints) { invalidated |= this->invalidate_steps({ slaposSupportTree, slaposBasePool, slaposSliceSupports }); invalidated |= m_print->invalidate_step(slapsRasterize); } else if (step == slaposSupportTree) { invalidated |= this->invalidate_steps({ slaposBasePool, slaposSliceSupports }); invalidated |= m_print->invalidate_step(slapsRasterize); } else if (step == slaposBasePool) { invalidated |= this->invalidate_step(slaposSliceSupports); invalidated |= m_print->invalidate_step(slapsRasterize); } else if (step == slaposSliceSupports) { invalidated |= m_print->invalidate_step(slapsRasterize); } return invalidated; } bool SLAPrintObject::invalidate_all_steps() { return Inherited::invalidate_all_steps() | m_print->invalidate_all_steps(); } double SLAPrintObject::get_elevation() const { double ret = m_config.support_object_elevation.getFloat(); // if the pad is enabled, then half of the pad height is its base plate if(m_config.pad_enable.getBool()) { // Normally the elevation for the pad itself would be the thickness of // its walls but currently it is half of its thickness. Whatever it // will be in the future, we provide the config to the get_pad_elevation // method and we will have the correct value sla::PoolConfig pcfg; pcfg.min_wall_height_mm = m_config.pad_wall_height.getFloat(); pcfg.min_wall_thickness_mm = m_config.pad_wall_thickness.getFloat(); pcfg.edge_radius_mm = m_config.pad_edge_radius.getFloat(); pcfg.max_merge_distance_mm = m_config.pad_max_merge_distance.getFloat(); ret += sla::get_pad_elevation(pcfg); } return ret; } namespace { // dummy empty static containers for return values in some methods const std::vector EMPTY_SLICES; const TriangleMesh EMPTY_MESH; } const std::vector &SLAPrintObject::get_support_slices() const { if(!is_step_done(slaposSliceSupports) || !m_supportdata) return EMPTY_SLICES; return m_supportdata->support_slices; } const std::vector &SLAPrintObject::get_model_slices() const { if(!is_step_done(slaposObjectSlice)) return EMPTY_SLICES; return m_model_slices; } bool SLAPrintObject::has_mesh(SLAPrintObjectStep step) const { switch (step) { case slaposSupportTree: return ! this->support_mesh().empty(); case slaposBasePool: return ! this->pad_mesh().empty(); default: return false; } } TriangleMesh SLAPrintObject::get_mesh(SLAPrintObjectStep step) const { switch (step) { case slaposSupportTree: return this->support_mesh(); case slaposBasePool: return this->pad_mesh(); default: return TriangleMesh(); } } const TriangleMesh& SLAPrintObject::support_mesh() const { if(m_supportdata && m_supportdata->support_tree_ptr) return m_supportdata->support_tree_ptr->merged_mesh(); return EMPTY_MESH; } const TriangleMesh& SLAPrintObject::pad_mesh() const { if(!m_supportdata || !m_supportdata->support_tree_ptr) return EMPTY_MESH; 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. return m_transformed_rmesh.get(); } std::vector SLAPrintObject::transformed_support_points() const { assert(m_model_object != nullptr); auto& spts = m_model_object->sla_support_points; // this could be cached as well std::vector ret; ret.reserve(spts.size()); for(auto& sp : spts) ret.emplace_back( trafo() * Vec3d(sp.cast())); return ret; } } // namespace Slic3r