#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Format/bbs_3mf.hpp>

Collaboration diagram for Slic3r::PlateData:

Public Types
using	LayerFilaments = std::unordered_map<std::vector<unsigned int>, std::vector<std::pair<int, int>>, GCodeProcessorResult::FilamentSequenceHash>

Public Member Functions
	PlateData (int plate_id, std::set< std::pair< int, int > > &obj_to_inst_list, bool lock_state)
	PlateData ()
	~PlateData ()
void	parse_filament_info (GCodeProcessorResult *result)
std::string	get_gcode_prediction_str ()
std::string	get_gcode_weight_str ()

Public Attributes
int	plate_index
std::vector< std::pair< int, int > >	objects_and_instances
std::map< int, std::pair< int, int > >	obj_inst_map
std::string	printer_model_id
std::string	nozzle_diameters
std::string	nozzle_volume_types
std::string	gcode_file
std::string	gcode_file_md5
std::string	statistics
std::string	thumbnail_file
std::string	no_light_thumbnail_file
ThumbnailData	plate_thumbnail
std::string	top_file
std::string	pick_file
std::string	pattern_bbox_file
std::string	gcode_prediction
std::string	gcode_weight
std::string	first_layer_time
std::string	plate_name
std::vector< FilamentInfo >	slice_filaments_info
std::vector< PlateMixedFilamentInfo >	mixed_filaments_info
std::vector< size_t >	skipped_objects
DynamicPrintConfig	config
bool	is_support_used {false}
bool	is_sliced_valid = false
bool	toolpath_outside {false}
bool	is_label_object_enabled {false}
int	timelapse_warning_code = 0
std::vector< int >	filament_maps
LayerFilaments	layer_filaments
std::vector< unsigned int >	filament_change_sequence
std::vector< unsigned int >	nozzle_change_sequence
std::vector< int >	optimal_assignment
std::vector< MultiNozzleUtils::NozzleInfo >	nozzles_info
std::optional< MultiNozzleUtils::LayeredNozzleGroupResult >	nozzle_group_result
std::vector< int >	limit_filament_maps
std::vector< GCodeProcessorResult::SliceWarning >	warnings
bool	locked

Detailed Description

Member Typedef Documentation

◆ LayerFilaments

using Slic3r::PlateData::LayerFilaments = std::unordered_map<std::vector<unsigned int>, std::vector<std::pair<int, int>>, GCodeProcessorResult::FilamentSequenceHash>

Constructor & Destructor Documentation

◆ PlateData() [1/2]

Slic3r::PlateData::PlateData	(	int	plate_id,
		std::set< std::pair< int, int > > &	obj_to_inst_list,
		bool	lock_state )

inline

                                                                                          : plate_index(plate_id), locked(lock_state)
    {
        objects_and_instances.clear();
        for (std::set<std::pair<int, int>>::iterator it = obj_to_inst_list.begin(); it != obj_to_inst_list.end(); ++it)
            objects_and_instances.emplace_back(it->first, it->second);
    }

References locked, objects_and_instances, and plate_index.

◆ PlateData() [2/2]

Slic3r::PlateData::PlateData ( )

inline

                : plate_index(-1), locked(false)
    {
        objects_and_instances.clear();
    }

References locked, objects_and_instances, and plate_index.

◆ ~PlateData()

Slic3r::PlateData::~PlateData ( )

inline

    {
        objects_and_instances.clear();
    }

References objects_and_instances.

Member Function Documentation

◆ get_gcode_prediction_str()

std::string Slic3r::PlateData::get_gcode_prediction_str ( )

inline

                                         {
        return gcode_prediction;
    }

References gcode_prediction.

Referenced by Slic3r::_BBS_3MF_Exporter::_add_slice_info_config_file_to_archive().

Here is the caller graph for this function:

◆ get_gcode_weight_str()

std::string Slic3r::PlateData::get_gcode_weight_str ( )

inline

                                     {
        return gcode_weight;
    }

References gcode_weight.

Referenced by Slic3r::_BBS_3MF_Exporter::_add_slice_info_config_file_to_archive().

Here is the caller graph for this function:

◆ parse_filament_info()

void Slic3r::PlateData::parse_filament_info ( GCodeProcessorResult * result )

{
    if (!result) return;
 
    PrintEstimatedStatistics &ps                            = result->print_statistics;
    std::vector<float>        m_filament_diameters          = result->filament_diameters;
    std::vector<float>        m_filament_densities          = result->filament_densities;
    auto get_used_filament_from_volume = [m_filament_diameters, m_filament_densities](double volume, int extruder_id) {
        double                    koef = 0.001;
        double                    section_area = PI * sqr(0.5 * m_filament_diameters[extruder_id]);
        std::pair<double, double> ret = {section_area < EPSILON ? 0 : (koef * volume / section_area), volume * m_filament_densities[extruder_id] * 0.001};
        return ret;
    };
 
    for (auto it = ps.total_volumes_per_extruder.begin(); it != ps.total_volumes_per_extruder.end(); it++) {
        double volume                           = it->second;
        auto [used_filament_m, used_filament_g] = get_used_filament_from_volume(volume, it->first);
 
        FilamentInfo info;
        info.id = it->first;
        info.used_g = used_filament_g;
        info.used_m = used_filament_m;
 
        // Stamp each filament's logical-nozzle assignment onto the saved 3mf so the device/monitor can
        // reconstruct it. This block runs for every print: reorder_extruders_for_minimum_flush_volume
        // runs unconditionally and stores a (non-null) 1-nozzle result even for a single-extruder print,
        // so result->nozzle_group_result is non-null here for single-nozzle printers too. The stamped
        // nozzle_diameter is the grouping result's rounded matching-key value; the 3mf writer decides the
        // final saved diameter (see has_multi_nozzle_extruder). group_id and volume_type are unaffected.
        if (result && result->nozzle_group_result) {
            auto nozzles_for_filament = result->nozzle_group_result->get_nozzles_for_filament(it->first);
            if (!nozzles_for_filament.empty()) {
                info.group_id.reserve(nozzles_for_filament.size());
                std::set<double> diameters;
                std::set<NozzleVolumeType> volume_types;
                for (const auto& nozzle : nozzles_for_filament) {
                    info.group_id.emplace_back(nozzle.group_id);
                    diameters.insert(string_to_double_decimal_point(nozzle.diameter));
                    volume_types.insert(nozzle.volume_type);
                }
                std::sort(info.group_id.begin(), info.group_id.end());
                info.group_id.erase(std::unique(info.group_id.begin(), info.group_id.end()), info.group_id.end());
                if (!diameters.empty())
                    info.nozzle_diameter = *diameters.begin();
                if (volume_types.size() > 1)
                    info.nozzle_volume_type = get_nozzle_volume_type_string(nvtHybrid);
                else if (!volume_types.empty())
                    info.nozzle_volume_type = get_nozzle_volume_type_string(*volume_types.begin());
            }
        }
 
        auto model_volume_it = ps.model_volumes_per_extruder.find(it->first);
        auto support_volume_it = ps.support_volumes_per_extruder.find(it->first);
        info.used_for_object = model_volume_it != ps.model_volumes_per_extruder.end() && model_volume_it->second > EPSILON;
        info.used_for_support = support_volume_it != ps.support_volumes_per_extruder.end() && support_volume_it->second > EPSILON;
        slice_filaments_info.push_back(info);
    }
 
    // Carry the layer-aware grouping result into the plate so the 3mf writer can emit the <nozzle> tags
    // and the enable_filament_dynamic_map flag. Only a LayeredNozzleGroupResult (the slicer output) is
    // stored; a device-side StaticNozzleGroupResult loaded from a 3mf is not re-serialized here.
    auto layered_group_result = std::dynamic_pointer_cast<MultiNozzleUtils::LayeredNozzleGroupResult>(result->nozzle_group_result);
    if (layered_group_result)
        nozzle_group_result = *layered_group_result;
 
    /* only for test
    GCodeProcessorResult::SliceWarning sw;
    sw.msg = BED_TEMP_TOO_HIGH_THAN_FILAMENT;
    sw.level = 1;
    result->warnings.push_back(sw);
    */
    warnings = result->warnings;
}