#ifndef slic3r_SupportMaterial_hpp_ #define slic3r_SupportMaterial_hpp_ #include "Flow.hpp" #include "PrintConfig.hpp" #include "Slicing.hpp" #include "Fill/FillBase.hpp" #include "SupportLayer.hpp" #include "SupportParameters.hpp" namespace Slic3r { class PrintObject; class PrintConfig; class PrintObjectConfig; using LayerIndex = int; inline double layer_z(const SlicingParameters& slicing_params, const size_t layer_idx) { return slicing_params.object_print_z_min + slicing_params.first_object_layer_height + layer_idx * slicing_params.layer_height; } inline SupportGeneratorLayer& layer_initialize( SupportGeneratorLayer& layer_new, const SupporLayerType layer_type, const SlicingParameters& slicing_params, const size_t layer_idx) { layer_new.layer_type = layer_type; layer_new.print_z = layer_z(slicing_params, layer_idx); layer_new.height = layer_idx == 0 ? slicing_params.first_object_layer_height : slicing_params.layer_height; layer_new.bottom_z = layer_idx == 0 ? slicing_params.object_print_z_min : layer_new.print_z - layer_new.height; return layer_new; } // Using the std::deque as an allocator. inline SupportGeneratorLayer& layer_allocate( std::deque& layer_storage, SupporLayerType layer_type, const SlicingParameters& slicing_params, size_t layer_idx) { //FIXME take raft into account. layer_storage.push_back(SupportGeneratorLayer()); return layer_initialize(layer_storage.back(), layer_type, slicing_params, layer_idx); } void export_print_z_polygons_to_svg(const char *path, SupportGeneratorLayer ** const layers, size_t n_layers); void export_print_z_polygons_and_extrusions_to_svg(const char *path, SupportGeneratorLayer ** const layers, size_t n_layers, SupportLayer& support_layer); // This class manages raft and supports for a single PrintObject. // Instantiated by Slic3r::Print::Object->_support_material() // This class is instantiated before the slicing starts as Object.pm will query // the parameters of the raft to determine the 1st layer height and thickness. class PrintObjectSupportMaterial { public: PrintObjectSupportMaterial(const PrintObject *object, const SlicingParameters &slicing_params); // Is raft enabled? bool has_raft() const { return m_slicing_params.has_raft(); } // Has any support? bool has_support() const { return m_object_config->enable_support.value || m_object_config->enforce_support_layers; } bool build_plate_only() const { return this->has_support() && m_object_config->support_on_build_plate_only.value; } // BBS bool synchronize_layers() const { return /*m_slicing_params.soluble_interface && */!m_print_config->independent_support_layer_height.value; } bool has_contact_loops() const { return m_object_config->support_interface_loop_pattern.value; } // Generate support material for the object. // New support layers will be added to the object, // with extrusion paths and islands filled in for each support layer. void generate(PrintObject &object); private: std::vector buildplate_covered(const PrintObject &object) const; // Generate top contact layers supporting overhangs. // For a soluble interface material synchronize the layer heights with the object, otherwise leave the layer height undefined. // If supports over bed surface only are requested, don't generate contact layers over an object. SupportGeneratorLayersPtr top_contact_layers(const PrintObject &object, const std::vector &buildplate_covered, SupportGeneratorLayerStorage &layer_storage) const; // Generate bottom contact layers supporting the top contact layers. // For a soluble interface material synchronize the layer heights with the object, // otherwise set the layer height to a bridging flow of a support interface nozzle. SupportGeneratorLayersPtr bottom_contact_layers_and_layer_support_areas( const PrintObject &object, const SupportGeneratorLayersPtr &top_contacts, std::vector &buildplate_covered, SupportGeneratorLayerStorage &layer_storage, std::vector &layer_support_areas) const; // Trim the top_contacts layers with the bottom_contacts layers if they overlap, so there would not be enough vertical space for both of them. void trim_top_contacts_by_bottom_contacts(const PrintObject &object, const SupportGeneratorLayersPtr &bottom_contacts, SupportGeneratorLayersPtr &top_contacts) const; // Generate raft layers and the intermediate support layers between the bottom contact and top contact surfaces. SupportGeneratorLayersPtr raft_and_intermediate_support_layers( const PrintObject &object, const SupportGeneratorLayersPtr &bottom_contacts, const SupportGeneratorLayersPtr &top_contacts, SupportGeneratorLayerStorage &layer_storage) const; // Fill in the base layers with polygons. void generate_base_layers( const PrintObject &object, const SupportGeneratorLayersPtr &bottom_contacts, const SupportGeneratorLayersPtr &top_contacts, SupportGeneratorLayersPtr &intermediate_layers, const std::vector &layer_support_areas) const; // Trim support layers by an object to leave a defined gap between // the support volume and the object. void trim_support_layers_by_object( const PrintObject &object, SupportGeneratorLayersPtr &support_layers, const coordf_t gap_extra_above, const coordf_t gap_extra_below, const coordf_t gap_xy) const; /* void generate_pillars_shape(); void clip_with_shape(); */ // Following objects are not owned by SupportMaterial class. const PrintObject *m_object; const PrintConfig *m_print_config; const PrintObjectConfig *m_object_config; // Pre-calculated parameters shared between the object slicer and the support generator, // carrying information on a raft, 1st layer height, 1st object layer height, gap between the raft and object etc. SlicingParameters m_slicing_params; // Various precomputed support parameters to be shared with external functions. SupportParameters m_support_params; }; } // namespace Slic3r #endif /* slic3r_SupportMaterial_hpp_ */