#ifndef slic3r_Print_hpp_ #define slic3r_Print_hpp_ #include "PrintBase.hpp" #include "Fill/FillAdaptive.hpp" #include "Fill/FillLightning.hpp" #include "BoundingBox.hpp" #include "ExtrusionEntityCollection.hpp" #include "Flow.hpp" #include "Point.hpp" #include "Slicing.hpp" #include "TriangleMeshSlicer.hpp" #include "GCode/ToolOrdering.hpp" #include "GCode/WipeTower.hpp" #include "GCode/ThumbnailData.hpp" #include "GCode/GCodeProcessor.hpp" #include "MultiMaterialSegmentation.hpp" #include "libslic3r.h" #include #include #include #include "Calib.hpp" namespace Slic3r { class GCode; class Layer; class ModelObject; class Print; class PrintObject; class SupportLayer; // BBS class TreeSupportData; class TreeSupport; #define MARGIN_HEIGHT 1.5 #define MAX_OUTER_NOZZLE_RADIUS 4 #define TIME_USING_CACHE "time_using_cache" #define TIME_MAKE_PERIMETERS "make_perimeters_time" #define TIME_INFILL "infill_time" #define TIME_GENERATE_SUPPORT "generate_support_material_time" // BBS: move from PrintObjectSlice.cpp struct VolumeSlices { ObjectID volume_id; std::vector slices; }; struct groupedVolumeSlices { int groupId = -1; std::vector volume_ids; ExPolygons slices; }; enum SupportNecessaryType { NoNeedSupp=0, SharpTail, Cantilever, LargeOverhang, }; namespace FillAdaptive { struct Octree; struct OctreeDeleter; using OctreePtr = std::unique_ptr; }; namespace FillLightning { class Generator; struct GeneratorDeleter; using GeneratorPtr = std::unique_ptr; }; // namespace FillLightning // Print step IDs for keeping track of the print state. // The Print steps are applied in this order. enum PrintStep { psWipeTower, // Ordering of the tools on PrintObjects for a multi-material print. // psToolOrdering is a synonym to psWipeTower, as the Wipe Tower calculates and modifies the ToolOrdering, // while if printing without the Wipe Tower, the ToolOrdering is calculated as well. psToolOrdering = psWipeTower, psSkirtBrim, // Last step before G-code export, after this step is finished, the initial extrusion path preview // should be refreshed. psSlicingFinished = psSkirtBrim, psGCodeExport, psConflictCheck, psCount }; enum PrintObjectStep { posSlice, posPerimeters, posPrepareInfill, posInfill, posIroning, posSupportMaterial, // BBS posDetectOverhangsForLift, posSimplifyWall, posSimplifyInfill, posSimplifySupportPath, posCount, }; // A PrintRegion object represents a group of volumes to print // sharing the same config (including the same assigned extruder(s)) class PrintRegion { public: PrintRegion() = default; PrintRegion(const PrintRegionConfig &config); PrintRegion(const PrintRegionConfig &config, const size_t config_hash, int print_object_region_id = -1) : m_config(config), m_config_hash(config_hash), m_print_object_region_id(print_object_region_id) {} PrintRegion(PrintRegionConfig &&config); PrintRegion(PrintRegionConfig &&config, const size_t config_hash, int print_object_region_id = -1) : m_config(std::move(config)), m_config_hash(config_hash), m_print_object_region_id(print_object_region_id) {} ~PrintRegion() = default; // Methods NOT modifying the PrintRegion's state: public: const PrintRegionConfig& config() const throw() { return m_config; } size_t config_hash() const throw() { return m_config_hash; } // Identifier of this PrintRegion in the list of Print::m_print_regions. int print_region_id() const throw() { return m_print_region_id; } int print_object_region_id() const throw() { return m_print_object_region_id; } // 1-based extruder identifier for this region and role. unsigned int extruder(FlowRole role) const; Flow flow(const PrintObject &object, FlowRole role, double layer_height, bool first_layer = false) const; // Average diameter of nozzles participating on extruding this region. coordf_t nozzle_dmr_avg(const PrintConfig &print_config) const; // Average diameter of nozzles participating on extruding this region. coordf_t bridging_height_avg(const PrintConfig &print_config) const; // Collect 0-based extruder indices used to print this region's object. void collect_object_printing_extruders(const Print &print, std::vector &object_extruders) const; static void collect_object_printing_extruders(const PrintConfig &print_config, const PrintRegionConfig ®ion_config, const bool has_brim, std::vector &object_extruders); // Methods modifying the PrintRegion's state: public: void set_config(const PrintRegionConfig &config) { m_config = config; m_config_hash = m_config.hash(); } void set_config(PrintRegionConfig &&config) { m_config = std::move(config); m_config_hash = m_config.hash(); } void config_apply_only(const ConfigBase &other, const t_config_option_keys &keys, bool ignore_nonexistent = false) { m_config.apply_only(other, keys, ignore_nonexistent); m_config_hash = m_config.hash(); } private: friend Print; friend void print_region_ref_inc(PrintRegion&); friend void print_region_ref_reset(PrintRegion&); friend int print_region_ref_cnt(const PrintRegion&); PrintRegionConfig m_config; size_t m_config_hash; int m_print_region_id { -1 }; int m_print_object_region_id { -1 }; int m_ref_cnt { 0 }; }; inline bool operator==(const PrintRegion &lhs, const PrintRegion &rhs) { return lhs.config_hash() == rhs.config_hash() && lhs.config() == rhs.config(); } inline bool operator!=(const PrintRegion &lhs, const PrintRegion &rhs) { return ! (lhs == rhs); } template class ConstVectorOfPtrsAdaptor { public: // Returning a non-const pointer to const pointers to T. T * const * begin() const { return m_data->data(); } T * const * end() const { return m_data->data() + m_data->size(); } const T* front() const { return m_data->front(); } // BBS const T* back() const { return m_data->back(); } size_t size() const { return m_data->size(); } bool empty() const { return m_data->empty(); } const T* operator[](size_t i) const { return (*m_data)[i]; } const T* at(size_t i) const { return m_data->at(i); } std::vector vector() const { return std::vector(this->begin(), this->end()); } protected: ConstVectorOfPtrsAdaptor(const std::vector *data) : m_data(data) {} private: const std::vector *m_data; }; typedef std::vector LayerPtrs; typedef std::vector ConstLayerPtrs; class ConstLayerPtrsAdaptor : public ConstVectorOfPtrsAdaptor { friend PrintObject; ConstLayerPtrsAdaptor(const LayerPtrs *data) : ConstVectorOfPtrsAdaptor(data) {} }; typedef std::vector SupportLayerPtrs; typedef std::vector ConstSupportLayerPtrs; class ConstSupportLayerPtrsAdaptor : public ConstVectorOfPtrsAdaptor { friend PrintObject; ConstSupportLayerPtrsAdaptor(const SupportLayerPtrs *data) : ConstVectorOfPtrsAdaptor(data) {} }; class BoundingBoxf3; // TODO: for temporary constructor parameter // Single instance of a PrintObject. // As multiple PrintObjects may be generated for a single ModelObject (their instances differ in rotation around Z), // ModelObject's instancess will be distributed among these multiple PrintObjects. struct PrintInstance { // Parent PrintObject PrintObject *print_object; // Source ModelInstance of a ModelObject, for which this print_object was created. const ModelInstance *model_instance; // Shift of this instance's center into the world coordinates. Point shift; BoundingBoxf3 get_bounding_box(); Polygon get_convex_hull_2d(); // OrcaSlicer // // instance id size_t id; //BBS: instance_shift is too large because of multi-plate, apply without plate offset. Point shift_without_plate_offset() const; }; typedef std::vector PrintInstances; class PrintObjectRegions { public: // Bounding box of a ModelVolume transformed into the working space of a PrintObject, possibly // clipped by a layer range modifier. // Only Eigen types of Nx16 size are vectorized. This bounding box will not be vectorized. static_assert(sizeof(Eigen::AlignedBox) == 24, "Eigen::AlignedBox is not being vectorized, thus it does not need to be aligned"); using BoundingBox = Eigen::AlignedBox; struct VolumeExtents { ObjectID volume_id; BoundingBox bbox; }; struct VolumeRegion { // ID of the associated ModelVolume. const ModelVolume *model_volume { nullptr }; // Index of a parent VolumeRegion. int parent { -1 }; // Pointer to PrintObjectRegions::all_regions, null for a negative volume. PrintRegion *region { nullptr }; // Pointer to VolumeExtents::bbox. const BoundingBox *bbox { nullptr }; // To speed up merging of same regions. const VolumeRegion *prev_same_region { nullptr }; }; struct PaintedRegion { // 1-based extruder identifier. unsigned int extruder_id; // Index of a parent VolumeRegion. int parent { -1 }; // Pointer to PrintObjectRegions::all_regions. PrintRegion *region { nullptr }; }; // One slice over the PrintObject (possibly the whole PrintObject) and a list of ModelVolumes and their bounding boxes // possibly clipped by the layer_height_range. struct LayerRangeRegions { t_layer_height_range layer_height_range; // Config of the layer range, null if there is just a single range with no config override. // Config is owned by the associated ModelObject. const DynamicPrintConfig* config { nullptr }; // Volumes sorted by ModelVolume::id(). std::vector volumes; // Sorted in the order of their source ModelVolumes, thus reflecting the order of region clipping, modifier overrides etc. std::vector volume_regions; std::vector painted_regions; bool has_volume(const ObjectID id) const { auto it = lower_bound_by_predicate(this->volumes.begin(), this->volumes.end(), [id](const VolumeExtents &l) { return l.volume_id < id; }); return it != this->volumes.end() && it->volume_id == id; } }; std::vector> all_regions; std::vector layer_ranges; // Transformation of this ModelObject into one of the associated PrintObjects (all PrintObjects derived from a single modelObject differ by a Z rotation only). // This transformation is used to calculate VolumeExtents. Transform3d trafo_bboxes; std::vector cached_volume_ids; void ref_cnt_inc() { ++ m_ref_cnt; } void ref_cnt_dec() { if (-- m_ref_cnt == 0) delete this; } void clear() { all_regions.clear(); layer_ranges.clear(); cached_volume_ids.clear(); } private: friend class PrintObject; // Number of PrintObjects generated from the same ModelObject and sharing the regions. // ref_cnt could only be modified by the main thread, thus it does not need to be atomic. size_t m_ref_cnt{ 0 }; }; class PrintObject : public PrintObjectBaseWithState { private: // Prevents erroneous use by other classes. typedef PrintObjectBaseWithState Inherited; public: // Size of an object: XYZ in scaled coordinates. The size might not be quite snug in XY plane. const Vec3crd& size() const { return m_size; } const PrintObjectConfig& config() const { return m_config; } void configBrimWidth(double m) {m_config.brim_width.value = m; } ConstLayerPtrsAdaptor layers() const { return ConstLayerPtrsAdaptor(&m_layers); } ConstSupportLayerPtrsAdaptor support_layers() const { return ConstSupportLayerPtrsAdaptor(&m_support_layers); } const Transform3d& trafo() const { return m_trafo; } // Trafo with the center_offset() applied after the transformation, to center the object in XY before slicing. Transform3d trafo_centered() const { Transform3d t = this->trafo(); t.pretranslate(Vec3d(- unscale(m_center_offset.x()), - unscale(m_center_offset.y()), 0)); return t; } const PrintInstances& instances() const { return m_instances; } PrintInstances& instances() { return m_instances; } // Whoever will get a non-const pointer to PrintObject will be able to modify its layers. LayerPtrs& layers() { return m_layers; } SupportLayerPtrs& support_layers() { return m_support_layers; } template static void remove_bridges_from_contacts( const Layer* lower_layer, const Layer* current_layer, float extrusion_width, PolysType* overhang_regions, float max_bridge_length = scale_(10), bool break_bridge=false); // Bounding box is used to align the object infill patterns, and to calculate attractor for the rear seam. // The bounding box may not be quite snug. BoundingBox bounding_box() const { return BoundingBox(Point(- m_size.x() / 2, - m_size.y() / 2), Point(m_size.x() / 2, m_size.y() / 2)); } // Height is used for slicing, for sorting the objects by height for sequential printing and for checking vertical clearence in sequential print mode. // The height is snug. coord_t height() const { return m_size.z(); } double max_z() const { return m_max_z; } // Centering offset of the sliced mesh from the scaled and rotated mesh of the model. const Point& center_offset() const { return m_center_offset; } // BBS void generate_support_preview(); const std::vector& firstLayerObjSlice() const { return firstLayerObjSliceByVolume; } std::vector& firstLayerObjSliceMod() { return firstLayerObjSliceByVolume; } const std::vector& firstLayerObjGroups() const { return firstLayerObjSliceByGroups; } std::vector& firstLayerObjGroupsMod() { return firstLayerObjSliceByGroups; } bool has_brim() const { return ((this->config().brim_type != btNoBrim && this->config().brim_width.value > 0.) || this->config().brim_type == btAutoBrim) && ! this->has_raft(); } // BBS const ExtrusionEntityCollection& object_skirt() const { return m_skirt; } // This is the *total* layer count (including support layers) // this value is not supposed to be compared with Layer::id // since they have different semantics. size_t total_layer_count() const { return this->layer_count() + this->support_layer_count(); } size_t layer_count() const { return m_layers.size(); } void clear_layers(); const Layer* get_layer(int idx) const { return m_layers[idx]; } Layer* get_layer(int idx) { return m_layers[idx]; } // Get a layer exactly at print_z. const Layer* get_layer_at_printz(coordf_t print_z) const; Layer* get_layer_at_printz(coordf_t print_z); // Get a layer approximately at print_z. const Layer* get_layer_at_printz(coordf_t print_z, coordf_t epsilon) const; Layer* get_layer_at_printz(coordf_t print_z, coordf_t epsilon); int get_layer_idx_get_printz(coordf_t print_z, coordf_t epsilon); // BBS const Layer* get_layer_at_bottomz(coordf_t bottom_z, coordf_t epsilon) const; Layer* get_layer_at_bottomz(coordf_t bottom_z, coordf_t epsilon); // Get the first layer approximately bellow print_z. const Layer* get_first_layer_bellow_printz(coordf_t print_z, coordf_t epsilon) const; // print_z: top of the layer; slice_z: center of the layer. Layer* add_layer(int id, coordf_t height, coordf_t print_z, coordf_t slice_z); // BBS SupportLayer* add_tree_support_layer(int id, coordf_t height, coordf_t print_z, coordf_t slice_z); std::shared_ptr alloc_tree_support_preview_cache(); void clear_tree_support_preview_cache() { m_tree_support_preview_cache.reset(); } size_t support_layer_count() const { return m_support_layers.size(); } void clear_support_layers(); SupportLayer* get_support_layer(int idx) { return idx &layer_height_profile); // Collect the slicing parameters, to be used by variable layer thickness algorithm, // by the interactive layer height editor and by the printing process itself. // The slicing parameters are dependent on various configuration values // (layer height, first layer height, raft settings, print nozzle diameter etc). const SlicingParameters& slicing_parameters() const { return m_slicing_params; } static SlicingParameters slicing_parameters(const DynamicPrintConfig &full_config, const ModelObject &model_object, float object_max_z); size_t num_printing_regions() const throw() { return m_shared_regions->all_regions.size(); } const PrintRegion& printing_region(size_t idx) const throw() { return *m_shared_regions->all_regions[idx].get(); } //FIXME returing all possible regions before slicing, thus some of the regions may not be slicing at the end. std::vector> all_regions() const; const PrintObjectRegions* shared_regions() const throw() { return m_shared_regions; } bool has_support() const { return m_config.enable_support || m_config.enforce_support_layers > 0; } bool has_raft() const { return m_config.raft_layers > 0; } bool has_support_material() const { return this->has_support() || this->has_raft(); } // Checks if the model object is painted using the multi-material painting gizmo. bool is_mm_painted() const { return this->model_object()->is_mm_painted(); } // returns 0-based indices of extruders used to print the object (without brim, support and other helper extrusions) std::vector object_extruders() const; // Called by make_perimeters() void slice(); // Helpers to slice support enforcer / blocker meshes by the support generator. std::vector slice_support_volumes(const ModelVolumeType model_volume_type) const; std::vector slice_support_blockers() const { return this->slice_support_volumes(ModelVolumeType::SUPPORT_BLOCKER); } std::vector slice_support_enforcers() const { return this->slice_support_volumes(ModelVolumeType::SUPPORT_ENFORCER); } // Helpers to project custom facets on slices void project_and_append_custom_facets(bool seam, EnforcerBlockerType type, std::vector& expolys) const; //BBS BoundingBox get_first_layer_bbox(float& area, float& layer_height, std::string& name); void get_certain_layers(float start, float end, std::vector &out, std::vector &boundingbox_objects); std::vector get_instances_shift_without_plate_offset(); PrintObject* get_shared_object() const { return m_shared_object; } void set_shared_object(PrintObject *object); void clear_shared_object(); void copy_layers_from_shared_object(); void copy_layers_overhang_from_shared_object(); // BBS: Boundingbox of the first layer BoundingBox firstLayerObjectBrimBoundingBox; // BBS: returns 1-based indices of extruders used to print the first layer wall of objects std::vector object_first_layer_wall_extruders; bool has_variable_layer_heights = false; // OrcaSlicer size_t get_klipper_object_id() const { return m_klipper_object_id; } void set_klipper_object_id(size_t id) { m_klipper_object_id = id; } private: // to be called from Print only. friend class Print; PrintObject(Print* print, ModelObject* model_object, const Transform3d& trafo, PrintInstances&& instances); ~PrintObject(); void config_apply(const ConfigBase &other, bool ignore_nonexistent = false) { m_config.apply(other, ignore_nonexistent); } void config_apply_only(const ConfigBase &other, const t_config_option_keys &keys, bool ignore_nonexistent = false) { m_config.apply_only(other, keys, ignore_nonexistent); } PrintBase::ApplyStatus set_instances(PrintInstances &&instances); // Invalidates the step, and its depending steps in PrintObject and Print. bool invalidate_step(PrintObjectStep step); // Invalidates all PrintObject and Print steps. bool invalidate_all_steps(); // Invalidate steps based on a set of parameters changed. // It may be called for both the PrintObjectConfig and PrintRegionConfig. bool invalidate_state_by_config_options( const ConfigOptionResolver &old_config, const ConfigOptionResolver &new_config, const std::vector &opt_keys); // If ! m_slicing_params.valid, recalculate. void update_slicing_parameters(); static PrintObjectConfig object_config_from_model_object(const PrintObjectConfig &default_object_config, const ModelObject &object, size_t num_extruders); private: void make_perimeters(); void prepare_infill(); void infill(); void ironing(); void generate_support_material(); void simplify_extrusion_path(); void slice_volumes(); //BBS ExPolygons _shrink_contour_holes(double contour_delta, double hole_delta, const ExPolygons& polys) const; // BBS void detect_overhangs_for_lift(); void clear_overhangs_for_lift(); // Has any support (not counting the raft). void detect_surfaces_type(); void process_external_surfaces(); void discover_vertical_shells(); void bridge_over_infill(); void clip_fill_surfaces(); void discover_horizontal_shells(); void combine_infill(); void _generate_support_material(); std::pair prepare_adaptive_infill_data( const std::vector>& surfaces_w_bottom_z) const; FillLightning::GeneratorPtr prepare_lightning_infill_data(); // BBS SupportNecessaryType is_support_necessary(); // XYZ in scaled coordinates Vec3crd m_size; double m_max_z; PrintObjectConfig m_config; // Translation in Z + Rotation + Scaling / Mirroring. Transform3d m_trafo = Transform3d::Identity(); // Slic3r::Point objects in scaled G-code coordinates std::vector m_instances; // The mesh is being centered before thrown to Clipper, so that the Clipper's fixed coordinates require less bits. // This is the adjustment of the the Object's coordinate system towards PrintObject's coordinate system. Point m_center_offset; // Object split into layer ranges and regions with their associated configurations. // Shared among PrintObjects created for the same ModelObject. PrintObjectRegions *m_shared_regions { nullptr }; SlicingParameters m_slicing_params; LayerPtrs m_layers; SupportLayerPtrs m_support_layers; // BBS std::shared_ptr m_tree_support_preview_cache; // this is set to true when LayerRegion->slices is split in top/internal/bottom // so that next call to make_perimeters() performs a union() before computing loops bool m_typed_slices = false; std::pair m_adaptive_fill_octrees; FillLightning::GeneratorPtr m_lightning_generator; std::vector < VolumeSlices > firstLayerObjSliceByVolume; std::vector firstLayerObjSliceByGroups; // BBS: per object skirt ExtrusionEntityCollection m_skirt; PrintObject* m_shared_object{ nullptr }; // OrcaSlicer // // object id for klipper firmware only size_t m_klipper_object_id; public: //BBS: When printing multi-material objects, this settings will make slicer to clip the overlapping object parts one by the other. //(2nd part will be clipped by the 1st, 3rd part will be clipped by the 1st and 2nd etc). // This was a per-object setting and now we default enable it. static bool clip_multipart_objects; static bool infill_only_where_needed; }; struct FakeWipeTower { // generate fake extrusion Vec2f pos; float width; float height; float layer_height; float depth; float brim_width; Vec2d plate_origin; void set_fake_extrusion_data(Vec2f p, float w, float h, float lh, float d, float bd, Vec2d o) { pos = p; width = w; height = h; layer_height = lh; depth = d; brim_width = bd; plate_origin = o; } void set_pos(Vec2f p) { pos = p; } std::vector getFakeExtrusionPathsFromWipeTower() const { int d = scale_(depth); int w = scale_(width); int bd = scale_(brim_width); Point minCorner = {scale_(pos.x()), scale_(pos.y())}; Point maxCorner = {minCorner.x() + w, minCorner.y() + d}; std::vector paths; for (float h = 0.f; h < height; h += layer_height) { ExtrusionPath path(ExtrusionRole::erWipeTower, 0.0, 0.0, layer_height); path.polyline = {minCorner, {maxCorner.x(), minCorner.y()}, maxCorner, {minCorner.x(), maxCorner.y()}, minCorner}; paths.push_back({path}); if (h == 0.f) { // add brim ExtrusionPath fakeBrim(ExtrusionRole::erBrim, 0.0, 0.0, layer_height); Point wtbminCorner = {minCorner - Point{bd, bd}}; Point wtbmaxCorner = {maxCorner + Point{bd, bd}}; fakeBrim.polyline = {wtbminCorner, {wtbmaxCorner.x(), wtbminCorner.y()}, wtbmaxCorner, {wtbminCorner.x(), wtbmaxCorner.y()}, wtbminCorner}; paths.back().push_back(fakeBrim); } } return paths; } }; struct WipeTowerData { // Following section will be consumed by the GCodeGenerator. // Tool ordering of a non-sequential print has to be known to calculate the wipe tower. // Cache it here, so it does not need to be recalculated during the G-code generation. ToolOrdering &tool_ordering; // Cache of tool changes per print layer. std::unique_ptr> priming; std::vector> tool_changes; std::unique_ptr final_purge; std::vector used_filament; int number_of_toolchanges; // Depth of the wipe tower to pass to GLCanvas3D for exact bounding box: float depth; float brim_width; void clear() { priming.reset(nullptr); tool_changes.clear(); final_purge.reset(nullptr); used_filament.clear(); number_of_toolchanges = -1; depth = 0.f; brim_width = 0.f; } private: // Only allow the WipeTowerData to be instantiated internally by Print, // as this WipeTowerData shares reference to Print::m_tool_ordering. friend class Print; WipeTowerData(ToolOrdering &tool_ordering) : tool_ordering(tool_ordering) { clear(); } WipeTowerData(const WipeTowerData & /* rhs */) = delete; WipeTowerData &operator=(const WipeTowerData & /* rhs */) = delete; }; struct PrintStatistics { PrintStatistics() { clear(); } std::string estimated_normal_print_time; std::string estimated_silent_print_time; double total_used_filament; double total_extruded_volume; double total_cost; int total_toolchanges; double total_weight; double total_wipe_tower_cost; double total_wipe_tower_filament; std::map filament_stats; // Config with the filled in print statistics. DynamicConfig config() const; // Config with the statistics keys populated with placeholder strings. static DynamicConfig placeholders(); // Replace the print statistics placeholders in the path. std::string finalize_output_path(const std::string &path_in) const; void clear() { total_used_filament = 0.; total_extruded_volume = 0.; total_cost = 0.; total_toolchanges = 0; total_weight = 0.; total_wipe_tower_cost = 0.; total_wipe_tower_filament = 0.; filament_stats.clear(); } }; typedef std::vector PrintObjectPtrs; typedef std::vector ConstPrintObjectPtrs; class ConstPrintObjectPtrsAdaptor : public ConstVectorOfPtrsAdaptor { friend Print; ConstPrintObjectPtrsAdaptor(const PrintObjectPtrs *data) : ConstVectorOfPtrsAdaptor(data) {} }; typedef std::vector PrintRegionPtrs; /* typedef std::vector ConstPrintRegionPtrs; class ConstPrintRegionPtrsAdaptor : public ConstVectorOfPtrsAdaptor { friend Print; ConstPrintRegionPtrsAdaptor(const PrintRegionPtrs *data) : ConstVectorOfPtrsAdaptor(data) {} }; */ enum FilamentTempType { HighTemp=0, LowTemp, HighLowCompatible, Undefine }; // The complete print tray with possibly multiple objects. class Print : public PrintBaseWithState { private: // Prevents erroneous use by other classes. typedef PrintBaseWithState Inherited; // Bool indicates if supports of PrintObject are top-level contour. typedef std::pair PrintObjectInfo; public: Print() = default; virtual ~Print() { this->clear(); } PrinterTechnology technology() const noexcept override { return ptFFF; } // Methods, which change the state of Print / PrintObject / PrintRegion. // The following methods are synchronized with process() and export_gcode(), // so that process() and export_gcode() may be called from a background thread. // In case the following methods need to modify data processed by process() or export_gcode(), // a cancellation callback is executed to stop the background processing before the operation. void clear() override; bool empty() const override { return m_objects.empty(); } // List of existing PrintObject IDs, to remove notifications for non-existent IDs. std::vector print_object_ids() const override; ApplyStatus apply(const Model &model, DynamicPrintConfig config) override; void process(std::unordered_map* slice_time = nullptr, bool use_cache = false) override; // Exports G-code into a file name based on the path_template, returns the file path of the generated G-code file. // If preview_data is not null, the preview_data is filled in for the G-code visualization (not used by the command line Slic3r). std::string export_gcode(const std::string& path_template, GCodeProcessorResult* result, ThumbnailsGeneratorCallback thumbnail_cb = nullptr); //return 0 means successful int export_cached_data(const std::string& dir_path, bool with_space=false); int load_cached_data(const std::string& directory); // methods for handling state bool is_step_done(PrintStep step) const { return Inherited::is_step_done(step); } // Returns true if an object step is done on all objects and there's at least one object. bool is_step_done(PrintObjectStep step) const; // Returns true if the last step was finished with success. bool finished() const override { return this->is_step_done(psGCodeExport); } bool has_infinite_skirt() const; bool has_skirt() const; bool has_brim() const; //BBS bool has_auto_brim() const { return std::any_of(m_objects.begin(), m_objects.end(), [](PrintObject* object) { return object->config().brim_type == btAutoBrim; }); } // Returns an empty string if valid, otherwise returns an error message. StringObjectException validate(StringObjectException *warning = nullptr, Polygons* collison_polygons = nullptr, std::vector>* height_polygons = nullptr) const override; double skirt_first_layer_height() const; Flow brim_flow() const; Flow skirt_flow() const; std::vector object_extruders() const; std::vector support_material_extruders() const; std::vector extruders(bool conside_custom_gcode = false) const; double max_allowed_layer_height() const; bool has_support_material() const; // Make sure the background processing has no access to this model_object during this call! void auto_assign_extruders(ModelObject* model_object) const; const PrintConfig& config() const { return m_config; } const PrintObjectConfig& default_object_config() const { return m_default_object_config; } const PrintRegionConfig& default_region_config() const { return m_default_region_config; } ConstPrintObjectPtrsAdaptor objects() const { return ConstPrintObjectPtrsAdaptor(&m_objects); } PrintObject* get_object(size_t idx) { return const_cast(m_objects[idx]); } const PrintObject* get_object(size_t idx) const { return m_objects[idx]; } // PrintObject by its ObjectID, to be used to uniquely bind slicing warnings to their source PrintObjects // in the notification center. const PrintObject* get_object(ObjectID object_id) const { auto it = std::find_if(m_objects.begin(), m_objects.end(), [object_id](const PrintObject *obj) { return obj->id() == object_id; }); return (it == m_objects.end()) ? nullptr : *it; } //BBS: Function to get m_brimMap; std::map& get_brimMap() { return m_brimMap; } // How many of PrintObject::copies() over all print objects are there? // If zero, then the print is empty and the print shall not be executed. unsigned int num_object_instances() const; // For Perl bindings. PrintObjectPtrs& objects_mutable() { return m_objects; } PrintRegionPtrs& print_regions_mutable() { return m_print_regions; } std::vector layers_sorted_for_object(float start, float end, std::vector &layers_of_objects, std::vector &boundingBox_for_objects, std::vector& objects_instances_shift); const ExtrusionEntityCollection& skirt() const { return m_skirt; } // Convex hull of the 1st layer extrusions, for bed leveling and placing the initial purge line. // It encompasses the object extrusions, support extrusions, skirt, brim, wipe tower. // It does NOT encompass user extrusions generated by custom G-code, // therefore it does NOT encompass the initial purge line. // It does NOT encompass MMU/MMU2 starting (wipe) areas. const Polygon& first_layer_convex_hull() const { return m_first_layer_convex_hull; } const PrintStatistics& print_statistics() const { return m_print_statistics; } PrintStatistics& print_statistics() { return m_print_statistics; } // Wipe tower support. bool has_wipe_tower() const; const WipeTowerData& wipe_tower_data(size_t filaments_cnt = 0) const; const ToolOrdering& tool_ordering() const { return m_tool_ordering; } bool enable_timelapse_print() const; std::string output_filename(const std::string &filename_base = std::string()) const override; size_t num_print_regions() const throw() { return m_print_regions.size(); } const PrintRegion& get_print_region(size_t idx) const { return *m_print_regions[idx]; } const ToolOrdering& get_tool_ordering() const { return m_wipe_tower_data.tool_ordering; } //BBS: plate's origin related functions void set_plate_origin(Vec3d origin) { m_origin = origin; } const Vec3d get_plate_origin() const { return m_origin; } //BBS: export gcode from previous gcode file from 3mf void set_gcode_file_ready(); void set_gcode_file_invalidated(); void export_gcode_from_previous_file(const std::string& file, GCodeProcessorResult* result, ThumbnailsGeneratorCallback thumbnail_cb = nullptr); //BBS: add modify_count logic int get_modified_count() const {return m_modified_count;} //BBS: add status for whether support used bool is_support_used() const {return m_support_used;} bool is_BBL_Printer() const { return m_isBBLPrinter;} void set_BBL_Printer(const bool isBBL) { m_isBBLPrinter = isBBL;} std::string get_conflict_string() const { std::string result; if (m_conflict_result) { result = "Found gcode path conflicts between object " + m_conflict_result.value()._objName1 + " and " + m_conflict_result.value()._objName2; } return result; } //BBS static StringObjectException sequential_print_clearance_valid(const Print &print, Polygons *polygons = nullptr, std::vector>* height_polygons = nullptr); // Return 4 wipe tower corners in the world coordinates (shifted and rotated), including the wipe tower brim. std::vector first_layer_wipe_tower_corners(bool check_wipe_tower_existance=true) const; //OrcaSlicer CalibMode & calib_mode() { return m_calib_params.mode; } const CalibMode& calib_mode() const { return m_calib_params.mode; } void set_calib_params(const Calib_Params ¶ms); const Calib_Params& calib_params() const { return m_calib_params; } Vec2d translate_to_print_space(const Vec2d& point) const; // scaled point Vec2d translate_to_print_space(const Point& point) const; static FilamentTempType get_filament_temp_type(const std::string& filament_type); static int get_hrc_by_nozzle_type(const NozzleType& type); static bool check_multi_filaments_compatibility(const std::vector& filament_types); // similar to check_multi_filaments_compatibility, but the input is int, and may be negative (means unset) static bool is_filaments_compatible(const std::vector& types); // get the compatible filament type of a multi-material object // Rule: // 1. LowTemp+HighLowCompatible=LowTemp // 2. HighTemp++HighLowCompatible=HighTemp // 3. LowTemp+HighTemp+...=HighLowCompatible // Unset types are just ignored. static int get_compatible_filament_type(const std::set& types); bool is_all_objects_are_short() const { return std::all_of(this->objects().begin(), this->objects().end(), [&](PrintObject* obj) { return obj->height() < scale_(this->config().nozzle_height.value); }); } protected: // Invalidates the step, and its depending steps in Print. bool invalidate_step(PrintStep step); private: //BBS static StringObjectException check_multi_filament_valid(const Print &print); bool invalidate_state_by_config_options(const ConfigOptionResolver &new_config, const std::vector &opt_keys); void _make_skirt(); void _make_wipe_tower(); void finalize_first_layer_convex_hull(); // Islands of objects and their supports extruded at the 1st layer. Polygons first_layer_islands() const; PrintConfig m_config; PrintObjectConfig m_default_object_config; PrintRegionConfig m_default_region_config; PrintObjectPtrs m_objects; PrintRegionPtrs m_print_regions; //BBS. bool m_isBBLPrinter = false; // Ordered collections of extrusion paths to build skirt loops and brim. ExtrusionEntityCollection m_skirt; // BBS: collecting extrusion paths to build brim by objs std::map m_brimMap; std::map m_supportBrimMap; // Convex hull of the 1st layer extrusions. // It encompasses the object extrusions, support extrusions, skirt, brim, wipe tower. // It does NOT encompass user extrusions generated by custom G-code, // therefore it does NOT encompass the initial purge line. // It does NOT encompass MMU/MMU2 starting (wipe) areas. Polygon m_first_layer_convex_hull; Points m_skirt_convex_hull; // Following section will be consumed by the GCodeGenerator. ToolOrdering m_tool_ordering; WipeTowerData m_wipe_tower_data {m_tool_ordering}; // Estimated print time, filament consumed. PrintStatistics m_print_statistics; bool m_support_used {false}; //BBS: plate's origin Vec3d m_origin; //BBS: modified_count int m_modified_count {0}; //BBS ConflictResultOpt m_conflict_result; FakeWipeTower m_fake_wipe_tower; // OrcaSlicer: calibration Calib_Params m_calib_params; // To allow GCode to set the Print's GCodeExport step status. friend class GCode; // Allow PrintObject to access m_mutex and m_cancel_callback. friend class PrintObject; public: //BBS: this was a print config and now seems to be useless so we move it to here static float min_skirt_length; }; } /* slic3r_Print_hpp_ */ #endif