Slic3r::_BBS_3MF_Importer Class Reference

Inheritance diagram for Slic3r::_BBS_3MF_Importer:

Collaboration diagram for Slic3r::_BBS_3MF_Importer:

Classes
struct	Component
struct	Geometry
struct	CurrentObject
struct	CurrentConfig
struct	CurrentInstance
struct	Instance
struct	Metadata
struct	ObjectMetadata
struct	CutObjectInfo
struct	ObjectImporter

Public Member Functions
	_BBS_3MF_Importer ()
	~_BBS_3MF_Importer ()
bool	load_model_from_file (const std::string &filename, Model &model, PlateDataPtrs &plate_data_list, std::vector< Preset * > &project_presets, DynamicPrintConfig &config, ConfigSubstitutionContext &config_substitutions, LoadStrategy strategy, bool *is_bbl_3mf, bool *is_orca_3mf, Semver &file_version, Import3mfProgressFn proFn=nullptr, BBLProject *project=nullptr, int plate_id=0)
bool	get_thumbnail (const std::string &filename, std::string &data)
bool	load_gcode_3mf_from_stream (std::istream &data, Model &model, PlateDataPtrs &plate_data_list, DynamicPrintConfig &config, Semver &file_version)
unsigned int	version () const
void	log_errors ()

Protected Member Functions
void	add_error (const std::string &error) const
void	clear_errors ()

Private Types
typedef std::pair< std::string, int >	Id
typedef std::vector< Component >	ComponentsList
typedef std::vector< Metadata >	MetadataList
typedef std::map< Id, CurrentObject >	IdToCurrentObjectMap
typedef std::map< int, std::string >	IndexToPathMap
typedef std::map< Id, int >	IdToModelObjectMap
typedef std::vector< Instance >	InstancesList
typedef std::map< int, ObjectMetadata >	IdToMetadataMap
typedef std::map< int, CutObjectInfo >	IdToCutObjectInfoMap
typedef std::map< int, std::vector< coordf_t > >	IdToLayerHeightsProfileMap
typedef std::map< int, t_layer_config_ranges >	IdToLayerConfigRangesMap
typedef std::map< int, BrimPoints >	IdToBrimPointsMap
using	PathToEmbossShapeFileMap = std::map<std::string, std::shared_ptr<std::string>>

Private Member Functions
void	_apply_texture_displacement (ModelVolume &volume, const std::string &json_path)
void	_destroy_xml_parser ()
void	_stop_xml_parser (const std::string &msg=std::string())
bool	parse_error () const
const char *	parse_error_message () const
bool	_load_model_from_file (std::string filename, Model &model, PlateDataPtrs &plate_data_list, std::vector< Preset * > &project_presets, DynamicPrintConfig &config, ConfigSubstitutionContext &config_substitutions, Import3mfProgressFn proFn=nullptr, BBLProject *project=nullptr, int plate_id=0)
bool	_is_published_3mf () const
bool	_is_svg_shape_file (const std::string &filename) const
bool	_extract_from_archive (mz_zip_archive &archive, std::string const &path, std::function< bool(mz_zip_archive &archive, const mz_zip_archive_file_stat &stat)>, bool restore=false)
bool	_extract_xml_from_archive (mz_zip_archive &archive, std::string const &path, XML_StartElementHandler start_handler, XML_EndElementHandler end_handler)
bool	_extract_xml_from_archive (mz_zip_archive &archive, const mz_zip_archive_file_stat &stat, XML_StartElementHandler start_handler, XML_EndElementHandler end_handler)
bool	_extract_model_from_archive (mz_zip_archive &archive, const mz_zip_archive_file_stat &stat)
void	_extract_cut_information_from_archive (mz_zip_archive &archive, const mz_zip_archive_file_stat &stat, ConfigSubstitutionContext &config_substitutions)
void	_extract_layer_heights_profile_config_from_archive (mz_zip_archive &archive, const mz_zip_archive_file_stat &stat)
void	_extract_layer_config_ranges_from_archive (mz_zip_archive &archive, const mz_zip_archive_file_stat &stat, ConfigSubstitutionContext &config_substitutions)
void	_extract_sla_support_points_from_archive (mz_zip_archive &archive, const mz_zip_archive_file_stat &stat)
void	_extract_sla_drain_holes_from_archive (mz_zip_archive &archive, const mz_zip_archive_file_stat &stat)
void	_extract_brim_ear_points_from_archive (mz_zip_archive &archive, const mz_zip_archive_file_stat &stat)
void	_extract_custom_gcode_per_print_z_from_archive (mz_zip_archive &archive, const mz_zip_archive_file_stat &stat)
void	_extract_filament_sequence_from_archive (mz_zip_archive &archive, const mz_zip_archive_file_stat &stat)
void	_extract_print_config_from_archive (mz_zip_archive &archive, const mz_zip_archive_file_stat &stat, DynamicPrintConfig &config, ConfigSubstitutionContext &subs_context, const std::string &archive_filename)
void	_extract_project_config_from_archive (mz_zip_archive &archive, const mz_zip_archive_file_stat &stat, DynamicPrintConfig &config, ConfigSubstitutionContext &subs_context, Model &model)
void	_extract_project_embedded_presets_from_archive (mz_zip_archive &archive, const mz_zip_archive_file_stat &stat, std::vector< Preset * > &project_presets, Model &model, Preset::Type type, bool use_json=true)
void	_extract_auxiliary_file_from_archive (mz_zip_archive &archive, const mz_zip_archive_file_stat &stat, Model &model)
void	_extract_file_from_archive (mz_zip_archive &archive, const mz_zip_archive_file_stat &stat)
void	_extract_embossed_svg_shape_file (const std::string &filename, mz_zip_archive &archive, const mz_zip_archive_file_stat &stat)
void	_handle_start_model_xml_element (const char *name, const char **attributes)
void	_handle_end_model_xml_element (const char *name)
void	_handle_xml_characters (const XML_Char *s, int len)
void	_handle_start_config_xml_element (const char *name, const char **attributes)
void	_handle_end_config_xml_element (const char *name)
bool	_handle_start_model (const char **attributes, unsigned int num_attributes)
bool	_handle_end_model ()
bool	_handle_start_resources (const char **attributes, unsigned int num_attributes)
bool	_handle_end_resources ()
bool	_handle_start_object (const char **attributes, unsigned int num_attributes)
bool	_handle_end_object ()
bool	_handle_start_color_group (const char **attributes, unsigned int num_attributes)
bool	_handle_end_color_group ()
bool	_handle_start_color (const char **attributes, unsigned int num_attributes)
bool	_handle_end_color ()
bool	_handle_start_mesh (const char **attributes, unsigned int num_attributes)
bool	_handle_end_mesh ()
bool	_handle_start_vertices (const char **attributes, unsigned int num_attributes)
bool	_handle_end_vertices ()
bool	_handle_start_vertex (const char **attributes, unsigned int num_attributes)
bool	_handle_end_vertex ()
bool	_handle_start_triangles (const char **attributes, unsigned int num_attributes)
bool	_handle_end_triangles ()
bool	_handle_start_triangle (const char **attributes, unsigned int num_attributes)
bool	_handle_end_triangle ()
bool	_handle_start_components (const char **attributes, unsigned int num_attributes)
bool	_handle_end_components ()
bool	_handle_start_component (const char **attributes, unsigned int num_attributes)
bool	_handle_end_component ()
bool	_handle_start_build (const char **attributes, unsigned int num_attributes)
bool	_handle_end_build ()
bool	_handle_start_item (const char **attributes, unsigned int num_attributes)
bool	_handle_end_item ()
bool	_handle_start_metadata (const char **attributes, unsigned int num_attributes)
bool	_handle_end_metadata ()
bool	_handle_start_text_configuration (const char **attributes, unsigned int num_attributes)
bool	_handle_start_shape_configuration (const char **attributes, unsigned int num_attributes)
bool	_create_object_instance (std::string const &path, int object_id, const Transform3d &transform, const bool printable, unsigned int recur_counter)
void	_apply_transform (ModelInstance &instance, const Transform3d &transform)
bool	_handle_start_config (const char **attributes, unsigned int num_attributes)
bool	_handle_end_config ()
bool	_handle_start_config_object (const char **attributes, unsigned int num_attributes)
bool	_handle_end_config_object ()
bool	_handle_start_config_volume (const char **attributes, unsigned int num_attributes)
bool	_handle_start_config_volume_mesh (const char **attributes, unsigned int num_attributes)
bool	_handle_end_config_volume ()
bool	_handle_end_config_volume_mesh ()
bool	_handle_start_config_metadata (const char **attributes, unsigned int num_attributes)
bool	_handle_end_config_metadata ()
bool	_handle_start_config_filament (const char **attributes, unsigned int num_attributes)
bool	_handle_start_config_mixed_filament (const char **attributes, unsigned int num_attributes)
bool	_handle_end_config_filament ()
bool	_handle_start_config_warning (const char **attributes, unsigned int num_attributes)
bool	_handle_end_config_warning ()
bool	_handle_start_config_nozzle (const char **attributes, unsigned int num_attributes)
bool	_handle_end_config_nozzle ()
bool	_handle_start_config_plater (const char **attributes, unsigned int num_attributes)
bool	_handle_end_config_plater ()
bool	_handle_start_config_plater_instance (const char **attributes, unsigned int num_attributes)
bool	_handle_end_config_plater_instance ()
bool	_handle_start_assemble (const char **attributes, unsigned int num_attributes)
bool	_handle_end_assemble ()
bool	_handle_start_assemble_item (const char **attributes, unsigned int num_attributes)
bool	_handle_end_assemble_item ()
bool	_handle_start_text_info_item (const char **attributes, unsigned int num_attributes)
bool	_handle_end_text_info_item ()
void	_handle_start_relationships_element (const char *name, const char **attributes)
void	_handle_end_relationships_element (const char *name)
bool	_handle_start_relationship (const char **attributes, unsigned int num_attributes)
bool	_generate_current_object_list (std::vector< Component > &sub_objects, Id object_id, IdToCurrentObjectMap &current_objects)
bool	_generate_volumes_new (ModelObject &object, const std::vector< Component > &sub_objects, const ObjectMetadata::VolumeMetadataList &volumes, ConfigSubstitutionContext &config_substitutions)

Static Private Member Functions
static void XMLCALL	_handle_start_relationships_element (void *userData, const char *name, const char **attributes)
static void XMLCALL	_handle_end_relationships_element (void *userData, const char *name)
static void XMLCALL	_handle_start_model_xml_element (void *userData, const char *name, const char **attributes)
static void XMLCALL	_handle_end_model_xml_element (void *userData, const char *name)
static void XMLCALL	_handle_xml_characters (void *userData, const XML_Char *s, int len)
static void XMLCALL	_handle_start_config_xml_element (void *userData, const char *name, const char **attributes)
static void XMLCALL	_handle_end_config_xml_element (void *userData, const char *name)

Private Attributes
unsigned int	m_version
bool	m_check_version = false
bool	m_load_model = false
bool	m_load_aux = false
bool	m_load_config = false
bool	m_load_restore = false
std::string	m_backup_path
std::string	m_origin_file
boost::optional< Semver >	m_bambuslicer_generator_version
boost::optional< Semver >	m_orca_slicer_version
unsigned int	m_fdm_supports_painting_version = 0
unsigned int	m_seam_painting_version = 0
unsigned int	m_mm_painting_version = 0
std::string	m_model_id
std::string	m_contry_code
std::string	m_designer
std::string	m_designer_user_id
std::string	m_designer_cover
ModelInfo	model_info
BBLProject	project_info
std::string	m_profile_title
std::string	m_profile_cover
std::string	m_Profile_description
std::string	m_profile_user_id
std::string	m_profile_user_name
XML_Parser	m_xml_parser
bool	m_parse_error { false }
std::string	m_parse_error_message
Model *	m_model
float	m_unit_factor
CurrentObject *	m_curr_object {nullptr}
IdToCurrentObjectMap	m_current_objects
IndexToPathMap	m_index_paths
IdToModelObjectMap	m_objects
InstancesList	m_instances
CurrentConfig	m_curr_config
IdToMetadataMap	m_objects_metadata
std::set< int >	m_items_auto_drop_off
IdToCutObjectInfoMap	m_cut_object_infos
IdToLayerHeightsProfileMap	m_layer_heights_profiles
IdToLayerConfigRangesMap	m_layer_config_ranges
IdToBrimPointsMap	m_brim_ear_points
PathToEmbossShapeFileMap	m_path_to_emboss_shape_files
std::map< std::string, std::string >	m_texture_displacement_files
std::string	m_curr_metadata_name
std::string	m_curr_characters
std::string	m_name
std::string	m_sub_model_path
std::string	m_start_part_path
std::string	m_thumbnail_path
std::string	m_thumbnail_middle
std::string	m_thumbnail_small
std::vector< std::string >	m_sub_model_paths
std::vector< ObjectImporter * >	m_object_importers
std::map< int, ModelVolume * >	m_shared_meshes
bool	m_is_bbl_3mf { false }
bool	m_parsing_slice_info { false }
PlateDataMaps	m_plater_data
PlateData *	m_curr_plater
CurrentInstance	m_curr_instance
int	m_current_color_group {-1}
std::map< int, std::string >	m_group_id_to_color
boost::mutex	mutex
std::vector< std::string >	m_errors

Detailed Description

---

Class Documentation

Slic3r::_BBS_3MF_Importer::CurrentConfig

struct Slic3r::_BBS_3MF_Importer::CurrentConfig

Class Members
int	object_id {-1}
int	volume_id {-1}

Slic3r::_BBS_3MF_Importer::CurrentInstance

struct Slic3r::_BBS_3MF_Importer::CurrentInstance

Class Members
int	identify_id
int	instance_id
int	object_id

Slic3r::_BBS_3MF_Importer::ObjectMetadata

struct Slic3r::_BBS_3MF_Importer::ObjectMetadata

Collaboration diagram for Slic3r::_BBS_3MF_Importer::ObjectMetadata:

Class Members
typedef vector< VolumeMetadata >	VolumeMetadataList

Class Members
optional< bool >	auto_drop
MetadataList	metadata
VolumeMetadataList	volumes

Slic3r::_BBS_3MF_Importer::CutObjectInfo

struct Slic3r::_BBS_3MF_Importer::CutObjectInfo

Collaboration diagram for Slic3r::_BBS_3MF_Importer::CutObjectInfo:

Class Members
vector< Connector >	connectors
CutObjectBase	id

Member Typedef Documentation

ComponentsList

typedef std::vector<Component> Slic3r::_BBS_3MF_Importer::ComponentsList

private

Id

typedef std::pair<std::string, int> Slic3r::_BBS_3MF_Importer::Id

private

IdToBrimPointsMap

typedef std::map<int, BrimPoints> Slic3r::_BBS_3MF_Importer::IdToBrimPointsMap

private

IdToCurrentObjectMap

typedef std::map<Id, CurrentObject> Slic3r::_BBS_3MF_Importer::IdToCurrentObjectMap

private

IdToCutObjectInfoMap

typedef std::map<int, CutObjectInfo> Slic3r::_BBS_3MF_Importer::IdToCutObjectInfoMap

private

IdToLayerConfigRangesMap

typedef std::map<int, t_layer_config_ranges> Slic3r::_BBS_3MF_Importer::IdToLayerConfigRangesMap

private

IdToLayerHeightsProfileMap

typedef std::map<int, std::vector<coordf_t> > Slic3r::_BBS_3MF_Importer::IdToLayerHeightsProfileMap

private

IdToMetadataMap

typedef std::map<int, ObjectMetadata> Slic3r::_BBS_3MF_Importer::IdToMetadataMap

private

IdToModelObjectMap

typedef std::map<Id, int> Slic3r::_BBS_3MF_Importer::IdToModelObjectMap

private

IndexToPathMap

typedef std::map<int, std::string> Slic3r::_BBS_3MF_Importer::IndexToPathMap

private

InstancesList

typedef std::vector<Instance> Slic3r::_BBS_3MF_Importer::InstancesList

private

MetadataList

typedef std::vector<Metadata> Slic3r::_BBS_3MF_Importer::MetadataList

private

PathToEmbossShapeFileMap

using Slic3r::_BBS_3MF_Importer::PathToEmbossShapeFileMap = std::map<std::string, std::shared_ptr<std::string>>

private

Constructor & Destructor Documentation

_BBS_3MF_Importer()

Slic3r::_BBS_3MF_Importer::_BBS_3MF_Importer

(

)

        : m_version(0)
        , m_check_version(false)
        , m_xml_parser(nullptr)
        , m_model(nullptr)
        , m_unit_factor(1.0f)
        , m_curr_metadata_name("")
        , m_curr_characters("")
        , m_name("")
        , m_curr_plater(nullptr)
    {
    }

References m_check_version, m_curr_characters, m_curr_metadata_name, m_curr_plater, m_model, m_name, m_unit_factor, m_version, and m_xml_parser.

Referenced by Slic3r::_BBS_3MF_Importer::ObjectImporter::ObjectImporter(), _extract_model_from_archive(), _handle_end_config_xml_element(), _handle_end_model_xml_element(), _handle_end_relationships_element(), _handle_start_config_xml_element(), _handle_start_model_xml_element(), _handle_start_relationships_element(), and _handle_xml_characters().

Here is the caller graph for this function:

~_BBS_3MF_Importer()

Slic3r::_BBS_3MF_Importer::~_BBS_3MF_Importer

(

)

    {
        _destroy_xml_parser();
        clear_errors();
 
        if (m_curr_object) {
            delete m_curr_object;
            m_curr_object = nullptr;
        }
        m_current_objects.clear();
        m_index_paths.clear();
        m_objects.clear();
        m_instances.clear();
        m_objects_metadata.clear();
        m_items_auto_drop_off.clear();
        m_curr_metadata_name.clear();
        m_curr_characters.clear();
 
        std::map<int, PlateData*>::iterator it = m_plater_data.begin();
        while (it != m_plater_data.end())
        {
            delete it->second;
            it++;
        }
        m_plater_data.clear();
    }

References _destroy_xml_parser(), Slic3r::_BBS_3MF_Base::clear_errors(), m_curr_characters, m_curr_metadata_name, m_curr_object, m_current_objects, m_index_paths, m_instances, m_items_auto_drop_off, m_objects, m_objects_metadata, and m_plater_data.

Here is the call graph for this function:

Member Function Documentation

_apply_texture_displacement()

void Slic3r::_BBS_3MF_Importer::_apply_texture_displacement ( ModelVolume & volume, const std::string & json_path )

private

    {
        const auto json = m_texture_displacement_files.find(json_path);
        if (json == m_texture_displacement_files.end()) {
            add_error("Missing texture displacement data: " + json_path);
            return;
        }
        std::vector<TextureDisplacementLayer> layers;
        TextureDisplacementOptions            options;
        if (!texture_displacement_layers_from_json(json->second, layers, options)) {
            add_error("Malformed texture displacement data: " + json_path);
            return;
        }
        // The archive is the only source of a layer's pixels. `path` comes from the project file, so loading
        // the project must never read the file it names: that would let whoever made the project pick any
        // local (or, on Windows, network) file to read, and the next save would embed it in the archive.
        // `path` stays a label of where the texture came from; a layer the archive carries no image for
        // loads without one, its settings intact, until the user picks a texture again.
        for (TextureDisplacementLayer &layer : layers) {
            if (layer.path_in_3mf.empty())
                continue;
            const auto image = m_texture_displacement_files.find(layer.path_in_3mf);
            if (image == m_texture_displacement_files.end()) {
                add_error("Missing texture displacement image: " + layer.path_in_3mf);
                continue;
            }
            layer.image_data = std::make_shared<std::vector<unsigned char>>(image->second.begin(), image->second.end());
        }
        volume.texture_displacement_layers  = std::move(layers);
        volume.texture_displacement_options = options;
    }

References _apply_texture_displacement(), Slic3r::_BBS_3MF_Base::add_error(), m_texture_displacement_files, Slic3r::ModelVolume::texture_displacement_layers, Slic3r::texture_displacement_layers_from_json(), and Slic3r::ModelVolume::texture_displacement_options.

Referenced by _apply_texture_displacement(), and _generate_volumes_new().

Here is the call graph for this function:

Here is the caller graph for this function:

_apply_transform()

void Slic3r::_BBS_3MF_Importer::_apply_transform ( ModelInstance & instance, const Transform3d & transform )

private

    {
        // Validate the affine matrix directly. Decomposing a valid mirrored transform to
        // rotation and scale is not stable across Eigen versions and may yield a zero diagonal.
        if (!transform.matrix().allFinite() || !transform.linear().fullPivLu().isInvertible())
            return;
 
        instance.set_transformation(Slic3r::Geometry::Transformation(transform));
    }

References _apply_transform(), Slic3r::ModelInstance::set_transformation(), and Slic3r::transform().

Referenced by _apply_transform(), and _handle_end_model().

Here is the call graph for this function:

Here is the caller graph for this function:

_create_object_instance()

bool Slic3r::_BBS_3MF_Importer::_create_object_instance ( std::string const & path, int object_id, const Transform3d & transform, const bool printable, unsigned int recur_counter )

private

    {
        static const unsigned int MAX_RECURSIONS = 10;
 
        // escape from circular aliasing
        if (recur_counter > MAX_RECURSIONS) {
            add_error("Too many recursions");
            return false;
        }
 
        Id id{path, object_id};
        IdToCurrentObjectMap::iterator it = m_current_objects.find(id);
        if (it == m_current_objects.end()) {
            add_error("can not find object id " + std::to_string(object_id) + " to builditem");
            return false;
        }
 
        IdToModelObjectMap::iterator object_item = m_objects.find(id);
        if (object_item == m_objects.end()) {
            //add object
            CurrentObject& current_object = it->second;
            int object_index =  (int)m_model->objects.size();
            ModelObject* model_object = m_model->add_object();
            if (model_object == nullptr) {
                add_error("Unable to create object for builditem, id " + std::to_string(object_id));
                return false;
            }
            m_objects.insert({ id, object_index });
            current_object.model_object_idx = object_index;
            current_object.object = model_object;
 
            ModelInstance* instance = m_model->objects[object_index]->add_instance();
            if (instance == nullptr) {
                add_error("error when add object instance for id " + std::to_string(object_id));
                return false;
            }
            instance->printable = printable;
 
            m_instances.emplace_back(instance, transform);
 
            if (m_is_bbl_3mf && boost::ends_with(current_object.uuid, OBJECT_UUID_SUFFIX)) {
                std::istringstream iss(current_object.uuid);
                int backup_id;
                if (iss >> std::hex >> backup_id) {
                    m_model->set_object_backup_id(*model_object, backup_id);
                }
            }
            /*if (!current_object.geometry.empty()) {
            }
            else if (!current_object.components.empty()) {
                 // recursively process nested components
                for (const Component& component : it->second) {
                    if (!_create_object_instance(path, component.object_id, transform * component.transform, printable, recur_counter + 1))
                        return false;
                }
            }
            else {
                add_error("can not construct build items with invalid object, id " + std::to_string(object_id));
                return false;
            }*/
        }
        else {
            //add instance
            ModelInstance* instance = m_model->objects[object_item->second]->add_instance();
            if (instance == nullptr) {
                add_error("error when add object instance for id " + std::to_string(object_id));
                return false;
            }
            instance->printable = printable;
 
            m_instances.emplace_back(instance, transform);
        }
 
        /*if (it->second.size() == 1 && it->second[0].object_id == object_id) {
            // aliasing to itself
 
            IdToModelObjectMap::iterator object_item = m_objects.find(id);
            if (object_item == m_objects.end() || object_item->second == -1) {
                add_error("Found invalid object");
                return false;
            }
            else {
                ModelInstance* instance = m_model->objects[object_item->second]->add_instance();
                if (instance == nullptr) {
                    add_error("Unable to add object instance");
                    return false;
                }
                instance->printable = printable;
 
                m_instances.emplace_back(instance, transform);
            }
        }
        else {
            // recursively process nested components
            for (const Component& component : it->second) {
                if (!_create_object_instance(path, component.object_id, transform * component.transform, printable, recur_counter + 1))
                    return false;
            }
        }*/
 
        return true;
    }

References _create_object_instance(), Slic3r::_BBS_3MF_Base::add_error(), m_current_objects, m_instances, m_is_bbl_3mf, m_model, m_objects, Slic3r::_BBS_3MF_Importer::CurrentObject::model_object_idx, Slic3r::_BBS_3MF_Importer::CurrentObject::object, OBJECT_UUID_SUFFIX, Slic3r::ModelInstance::printable, Slic3r::transform(), and Slic3r::_BBS_3MF_Importer::CurrentObject::uuid.

Referenced by _create_object_instance(), and _handle_start_item().

Here is the call graph for this function:

Here is the caller graph for this function:

_destroy_xml_parser()

void Slic3r::_BBS_3MF_Importer::_destroy_xml_parser ( )

private

    {
        if (m_xml_parser != nullptr) {
            XML_ParserFree(m_xml_parser);
            m_xml_parser = nullptr;
        }
    }

References m_xml_parser.

Referenced by ~_BBS_3MF_Importer(), _extract_model_from_archive(), and _extract_xml_from_archive().

Here is the caller graph for this function:

_extract_auxiliary_file_from_archive()

void Slic3r::_BBS_3MF_Importer::_extract_auxiliary_file_from_archive ( mz_zip_archive & archive, const mz_zip_archive_file_stat & stat, Model & model )

private

    {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", stat.m_uncomp_size is %1%")%stat.m_uncomp_size;
        if (stat.m_uncomp_size > 0) {
            std::string dest_file;
            if (stat.m_is_utf8) {
                dest_file = stat.m_filename;
            } else {
                std::string extra(1024, 0);
                size_t n = mz_zip_reader_get_extra(&archive, stat.m_file_index, extra.data(), extra.size());
                dest_file = ZipUnicodePathExtraField::decode(extra.substr(0, n), stat.m_filename);
            }
            std::string temp_path = model.get_auxiliary_file_temp_path();
            //aux directory from model
            boost::filesystem::path dir = boost::filesystem::path(temp_path);
            std::size_t found = dest_file.find(AUXILIARY_DIR);
            if (found != std::string::npos)
                dest_file = dest_file.substr(found + AUXILIARY_STR_LEN);
            else
                return;
 
            if (!is_path_within_root(dest_file, dir)) {
                BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(", path traversal detected in auxiliary file: %1%, skipping") % dest_file;
                return;
            }
 
            if (dest_file.find('/') != std::string::npos) {
                boost::filesystem::path src_path = boost::filesystem::path(dest_file);
                boost::filesystem::path parent_path = src_path.parent_path();
                std::string temp_path = dir.string() + std::string("/") + parent_path.string();
                boost::filesystem::path parent_full_path =  boost::filesystem::path(temp_path);
                if (!boost::filesystem::exists(parent_full_path))
                    boost::filesystem::create_directories(parent_full_path);
            }
            dest_file = dir.string() + std::string("/") + dest_file;
            std::string dest_zip_file = encode_path(dest_file.c_str());
            mz_bool res = mz_zip_reader_extract_to_file(&archive, stat.m_file_index, dest_zip_file.c_str(), 0);
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", extract  %1% from 3mf %2%, ret %3%\n") % dest_file % stat.m_filename % res;
            if (res == 0) {
                add_error("Error while extract auxiliary file to file");
                return;
            }
        }
    }

References _extract_auxiliary_file_from_archive(), Slic3r::_BBS_3MF_Base::add_error(), AUXILIARY_DIR, AUXILIARY_STR_LEN, ZipUnicodePathExtraField::decode(), Slic3r::encode_path(), Slic3r::Model::get_auxiliary_file_temp_path(), and Slic3r::is_path_within_root().

Referenced by _extract_auxiliary_file_from_archive().

Here is the call graph for this function:

Here is the caller graph for this function:

_extract_brim_ear_points_from_archive()

void Slic3r::_BBS_3MF_Importer::_extract_brim_ear_points_from_archive ( mz_zip_archive & archive, const mz_zip_archive_file_stat & stat )

private

    {
        if (stat.m_uncomp_size > 0) {
            std::string buffer((size_t)stat.m_uncomp_size, 0);
            mz_bool res = mz_zip_reader_extract_to_mem(&archive, stat.m_file_index, (void*)buffer.data(), (size_t)stat.m_uncomp_size, 0);
            if (res == 0) {
                add_error("Error while reading brim ear points data to buffer");
                return;
            }
 
            if (buffer.back() == '\n')
                buffer.pop_back();
 
            std::vector<std::string> objects;
            boost::split(objects, buffer, boost::is_any_of("\n"), boost::token_compress_off);
 
            // Info on format versioning - see bbs_3mf.hpp
            int version = 0;
            std::string key("brim_points_format_version=");
            if (!objects.empty() && objects[0].find(key) != std::string::npos) {
                objects[0].erase(objects[0].begin(), objects[0].begin() + long(key.size())); // removes the string
                version = std::stoi(objects[0]);
                objects.erase(objects.begin()); // pop the header
            }
 
            for (const std::string& object : objects) {
                std::vector<std::string> object_data;
                boost::split(object_data, object, boost::is_any_of("|"), boost::token_compress_off);
 
                if (object_data.size() != 2) {
                    add_error("Error while reading object data");
                    continue;
                }
 
                std::vector<std::string> object_data_id;
                boost::split(object_data_id, object_data[0], boost::is_any_of("="), boost::token_compress_off);
                if (object_data_id.size() != 2) {
                    add_error("Error while reading object id");
                    continue;
                }
 
                int object_id = std::atoi(object_data_id[1].c_str());
                if (object_id == 0) {
                    add_error("Found invalid object id");
                    continue;
                }
 
                IdToBrimPointsMap::iterator object_item = m_brim_ear_points.find(object_id);
                if (object_item != m_brim_ear_points.end()) {
                    add_error("Found duplicated brim ear points");
                    continue;
                }
 
                std::vector<std::string> object_data_points;
                boost::split(object_data_points, object_data[1], boost::is_any_of(" "), boost::token_compress_off);
 
                std::vector<BrimPoint> brim_ear_points;
                if (version == 0) {
                    for (unsigned int i=0; i<object_data_points.size(); i+=4)
                    brim_ear_points.emplace_back(float(std::atof(object_data_points[i+0].c_str())),
                                                    float(std::atof(object_data_points[i+1].c_str())),
                                                    float(std::atof(object_data_points[i+2].c_str())),
                                                    float(std::atof(object_data_points[i+3].c_str())));
                }
 
                if (!brim_ear_points.empty())
                    m_brim_ear_points.insert({ object_id, brim_ear_points });
            }
        }
    }

References _extract_brim_ear_points_from_archive(), Slic3r::_BBS_3MF_Base::add_error(), m_brim_ear_points, and version().

Referenced by _extract_brim_ear_points_from_archive().

Here is the call graph for this function:

Here is the caller graph for this function:

_extract_custom_gcode_per_print_z_from_archive()

void Slic3r::_BBS_3MF_Importer::_extract_custom_gcode_per_print_z_from_archive ( mz_zip_archive & archive, const mz_zip_archive_file_stat & stat )

private

    {
        //BBS: add plate tree related logic
        if (stat.m_uncomp_size > 0) {
            std::string buffer((size_t)stat.m_uncomp_size, 0);
            mz_bool res = mz_zip_reader_extract_file_to_mem(&archive, stat.m_filename, (void*)buffer.data(), (size_t)stat.m_uncomp_size, 0);
            if (res == 0) {
                add_error("Error while reading custom Gcodes per height data to buffer");
                return;
            }
 
            std::istringstream iss(buffer); // wrap returned xml to istringstream
            pt::ptree main_tree;
            pt::read_xml(iss, main_tree);
 
            if (main_tree.front().first != "custom_gcodes_per_layer")
                return;
 
            auto extract_code = [this](int plate_id, pt::ptree code_tree) {
                for (const auto& code : code_tree) {
                    if (code.first == "mode") {
                        pt::ptree tree = code.second;
                        std::string mode = tree.get<std::string>("<xmlattr>.value");
                        m_model->plates_custom_gcodes[plate_id - 1].mode = mode == CustomGCode::SingleExtruderMode ? CustomGCode::Mode::SingleExtruder :
                            mode == CustomGCode::MultiAsSingleMode ? CustomGCode::Mode::MultiAsSingle :
                            CustomGCode::Mode::MultiExtruder;
                    }
                    if (code.first == "layer") {
                        pt::ptree tree = code.second;
                        double print_z = tree.get<double>("<xmlattr>.top_z");
                        int extruder = tree.get<int>("<xmlattr>.extruder");
                        std::string color = tree.get<std::string>("<xmlattr>.color");
 
                        CustomGCode::Type   type;
                        std::string         extra;
                        pt::ptree attr_tree = tree.find("<xmlattr>")->second;
                        if (attr_tree.find("type") == attr_tree.not_found()) {
                            // It means that data was saved in old version (2.2.0 and older) of PrusaSlicer
                            // read old data ...
                            std::string gcode = tree.get<std::string>("<xmlattr>.gcode");
                            // ... and interpret them to the new data
                            type = gcode == "M600" ? CustomGCode::ColorChange :
                                gcode == "M601" ? CustomGCode::PausePrint :
                                gcode == "tool_change" ? CustomGCode::ToolChange : CustomGCode::Custom;
                            extra = type == CustomGCode::PausePrint ? color :
                                type == CustomGCode::Custom ? gcode : "";
                        }
                        else {
                            type = static_cast<CustomGCode::Type>(tree.get<int>("<xmlattr>.type"));
                            extra = tree.get<std::string>("<xmlattr>.extra");
                        }
                        m_model->plates_custom_gcodes[plate_id - 1].gcodes.push_back(CustomGCode::Item{ print_z, type, extruder, color, extra });
                    }
                }
            };
 
            m_model->plates_custom_gcodes.clear();
 
            bool has_plate_info = false;
            for (const auto& element : main_tree.front().second) {
                if (element.first == "plate") {
                    has_plate_info = true;
 
                    int plate_id = -1;
                    pt::ptree code_tree = element.second;
                    for (const auto& code : code_tree) {
                        if (code.first == "plate_info") {
                            plate_id = code.second.get<int>("<xmlattr>.id");
                        }
 
                    }
                    if (plate_id == -1)
                        continue;
 
                    extract_code(plate_id, code_tree);
                }
            }
 
            if (!has_plate_info) {
                int plate_id = 1;
                pt::ptree code_tree = main_tree.front().second;
                extract_code(plate_id, code_tree);
            }
        }
    }

References _extract_custom_gcode_per_print_z_from_archive(), Slic3r::_BBS_3MF_Base::add_error(), Slic3r::CustomGCode::ColorChange, Slic3r::CustomGCode::Custom, m_model, Slic3r::CustomGCode::MultiAsSingle, Slic3r::CustomGCode::MultiAsSingleMode, Slic3r::CustomGCode::MultiExtruder, Slic3r::CustomGCode::PausePrint, Slic3r::CustomGCode::SingleExtruder, Slic3r::CustomGCode::SingleExtruderMode, and Slic3r::CustomGCode::ToolChange.

Referenced by _extract_custom_gcode_per_print_z_from_archive().

Here is the call graph for this function:

Here is the caller graph for this function:

_extract_cut_information_from_archive()

void Slic3r::_BBS_3MF_Importer::_extract_cut_information_from_archive ( mz_zip_archive & archive, const mz_zip_archive_file_stat & stat, ConfigSubstitutionContext & config_substitutions )

private

    {
        if (stat.m_uncomp_size > 0) {
            std::string buffer((size_t)stat.m_uncomp_size, 0);
            mz_bool res = mz_zip_reader_extract_file_to_mem(&archive, stat.m_filename, (void *) buffer.data(), (size_t) stat.m_uncomp_size, 0);
            if (res == 0) {
                add_error("Error while reading cut information data to buffer");
                return;
            }
 
            std::istringstream iss(buffer); // wrap returned xml to istringstream
            pt::ptree objects_tree;
            pt::read_xml(iss, objects_tree);
 
            for (const auto& object : objects_tree.get_child("objects")) {
                pt::ptree object_tree = object.second;
                int obj_idx = object_tree.get<int>("<xmlattr>.id", -1);
                if (obj_idx <= 0) {
                    add_error("Found invalid object id");
                    continue;
                }
 
                IdToCutObjectInfoMap::iterator object_item = m_cut_object_infos.find(obj_idx);
                if (object_item != m_cut_object_infos.end()) {
                    add_error("Found duplicated cut_object_id");
                    continue;
                }
 
                CutObjectBase cut_id;
                std::vector<CutObjectInfo::Connector>  connectors;
 
                for (const auto& obj_cut_info : object_tree) {
                    if (obj_cut_info.first == "cut_id") {
                        pt::ptree cut_id_tree = obj_cut_info.second;
                        cut_id = CutObjectBase(ObjectID( cut_id_tree.get<size_t>("<xmlattr>.id")),
                                                         cut_id_tree.get<size_t>("<xmlattr>.check_sum"),
                                                         cut_id_tree.get<size_t>("<xmlattr>.connectors_cnt"));
                    }
                    if (obj_cut_info.first == "connectors") {
                        pt::ptree cut_connectors_tree = obj_cut_info.second;
                        for (const auto& cut_connector : cut_connectors_tree) {
                            if (cut_connector.first != "connector")
                                continue;
                            pt::ptree connector_tree = cut_connector.second;
                            CutObjectInfo::Connector connector = {connector_tree.get<int>("<xmlattr>.volume_id"),
                                                                  connector_tree.get<int>("<xmlattr>.type"),
                                                                  connector_tree.get<float>("<xmlattr>.r_tolerance"),
                                                                  connector_tree.get<float>("<xmlattr>.h_tolerance")};
                            connectors.emplace_back(connector);
                        }
                    }
                }
 
                CutObjectInfo cut_info {cut_id, connectors};
                m_cut_object_infos.insert({ obj_idx, cut_info });
            }
        }
    }

References _extract_cut_information_from_archive(), Slic3r::_BBS_3MF_Base::add_error(), and m_cut_object_infos.

Referenced by _extract_cut_information_from_archive().

Here is the call graph for this function:

Here is the caller graph for this function:

_extract_embossed_svg_shape_file()

void Slic3r::_BBS_3MF_Importer::_extract_embossed_svg_shape_file ( const std::string & filename, mz_zip_archive & archive, const mz_zip_archive_file_stat & stat )

private

                                                                                                                                                    {
        assert(m_path_to_emboss_shape_files.find(filename) == m_path_to_emboss_shape_files.end());
        auto file = std::make_unique<std::string>(stat.m_uncomp_size, '\0');
        mz_bool res  = mz_zip_reader_extract_to_mem(&archive, stat.m_file_index, (void *) file->data(), stat.m_uncomp_size, 0);
        if (res == 0) {
            add_error("Error while reading svg shape for emboss");
            return;
        }
        
        // store for case svg is loaded before volume
        m_path_to_emboss_shape_files[filename] = std::move(file);
        
        // find embossed volume, for case svg is loaded after volume
        for (const ModelObject* object : m_model->objects)
        for (ModelVolume *volume : object->volumes) {
            std::optional<EmbossShape> &es = volume->emboss_shape;
            if (!es.has_value())
                continue;
            std::optional<EmbossShape::SvgFile> &svg = es->svg_file;
            if (!svg.has_value())
                continue;
            if (filename.compare(svg->path_in_3mf) == 0)
                svg->file_data = m_path_to_emboss_shape_files[filename];
        }
    }

References _extract_embossed_svg_shape_file(), Slic3r::_BBS_3MF_Base::add_error(), Slic3r::ModelVolume::emboss_shape, m_model, m_path_to_emboss_shape_files, and Slic3r::ModelObject::volumes.

Referenced by _extract_embossed_svg_shape_file().

Here is the call graph for this function:

Here is the caller graph for this function:

_extract_filament_sequence_from_archive()

void Slic3r::_BBS_3MF_Importer::_extract_filament_sequence_from_archive ( mz_zip_archive & archive, const mz_zip_archive_file_stat & stat )

private

    {
        if (stat.m_uncomp_size == 0) {
            add_error("Error while reading filament sequence data to buffer");
            return;
        }
 
        std::string buffer((size_t) stat.m_uncomp_size, 0);
        mz_bool res = mz_zip_reader_extract_file_to_mem(&archive, stat.m_filename, (void*) buffer.data(), (size_t) stat.m_uncomp_size, 0);
        if (res == 0) {
            add_error("Error while reading filament sequence data to buffer");
            return;
        }
 
        try {
            const nlohmann::json sequence_json = nlohmann::json::parse(buffer);
            for (auto& elem : m_plater_data) {
                const std::string plate_key = "plate_" + std::to_string(elem.first);
                auto plate_it = sequence_json.find(plate_key);
                if (plate_it == sequence_json.end() || !plate_it->is_object())
                    continue;
 
                auto filament_it = plate_it->find("filament_sequence");
                if (filament_it == plate_it->end())
                    filament_it = plate_it->find("sequence");
 
                auto nozzle_it = plate_it->find("nozzle_sequence");
                if (filament_it == plate_it->end() || !filament_it->is_array() || nozzle_it == plate_it->end() || !nozzle_it->is_array())
                    continue;
 
                std::vector<unsigned int> filament_sequence;
                std::vector<unsigned int> nozzle_sequence;
                std::vector<int> optimal_assignment;
                for (const auto& item : *filament_it) {
                    const unsigned int filament_id = item.get<unsigned int>();
                    filament_sequence.push_back(filament_id > 0 ? filament_id - 1 : 0);
                }
                for (const auto& item : *nozzle_it)
                    nozzle_sequence.push_back(item.get<unsigned int>());
 
                auto optimal_assignment_it = plate_it->find("optimal_assignment");
                if (optimal_assignment_it != plate_it->end() && optimal_assignment_it->is_array()) {
                    for (const auto& item : *optimal_assignment_it)
                        optimal_assignment.emplace_back(item.get<int>());
                }
 
                elem.second->filament_change_sequence = std::move(filament_sequence);
                elem.second->nozzle_change_sequence = std::move(nozzle_sequence);
                if (!optimal_assignment.empty())
                    elem.second->optimal_assignment = std::move(optimal_assignment);
            }
        } catch (const std::exception& e) {
            add_error(std::string("Error while parsing filament sequence JSON: ") + e.what());
        }
    }

References _extract_filament_sequence_from_archive(), Slic3r::_BBS_3MF_Base::add_error(), and m_plater_data.

Referenced by _extract_filament_sequence_from_archive(), and load_gcode_3mf_from_stream().

Here is the call graph for this function:

Here is the caller graph for this function:

_extract_file_from_archive()

void Slic3r::_BBS_3MF_Importer::_extract_file_from_archive ( mz_zip_archive & archive, const mz_zip_archive_file_stat & stat )

private

    {
        if (stat.m_uncomp_size > 0) {
            std::string src_file = decode_path(stat.m_filename);
 
            boost::filesystem::path backup_root(m_backup_path);
            if (!is_path_within_root(src_file, backup_root)) {
                BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(", path traversal detected in file: %1%, skipping") % src_file;
                return;
            }
 
            // BBS: use backup path
            //aux directory from model
            boost::filesystem::path dest_path = boost::filesystem::path(m_backup_path + "/" + src_file);
            std::string dest_zip_file = encode_path(dest_path.string().c_str());
            mz_bool res = mz_zip_reader_extract_to_file(&archive, stat.m_file_index, dest_zip_file.c_str(), 0);
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", extract  %1% from 3mf %2%, ret %3%\n") % dest_path % stat.m_filename % res;
            if (res == 0) {
                add_error("Error while extract file to temp directory");
                return;
            }
        }
        return;
    }

References _extract_file_from_archive(), Slic3r::_BBS_3MF_Base::add_error(), Slic3r::decode_path(), Slic3r::encode_path(), Slic3r::is_path_within_root(), and m_backup_path.

Referenced by _extract_file_from_archive().

Here is the call graph for this function:

Here is the caller graph for this function:

_extract_from_archive()

bool Slic3r::_BBS_3MF_Importer::_extract_from_archive ( mz_zip_archive & archive, std::string const & path, std::function< bool(mz_zip_archive &archive, const mz_zip_archive_file_stat &stat)> extract, bool restore = false )

private

    {
        mz_uint num_entries = mz_zip_reader_get_num_files(&archive);
        mz_zip_archive_file_stat stat;
        std::string path2 = path;
        if (path2.front() == '/') path2 = path2.substr(1);
        // try utf8 encoding
        int index = mz_zip_reader_locate_file(&archive, path2.c_str(), nullptr, 0);
        if (index < 0) {
            // try native encoding
            std::string native_path = encode_path(path2.c_str());
            index = mz_zip_reader_locate_file(&archive, native_path.c_str(), nullptr, 0);
        }
        if (index < 0) {
            // try unicode path extra
            std::string extra(1024, 0);
            for (mz_uint i = 0; i < archive.m_total_files; ++i) {
                size_t n = mz_zip_reader_get_extra(&archive, i, extra.data(), extra.size());
                if (n > 0 && path2 == ZipUnicodePathExtraField::decode(extra.substr(0, n))) {
                    index = i;
                    break;
                }
            }
        }
        if (index < 0 || !mz_zip_reader_file_stat(&archive, index, &stat)) {
            if (restore) {
                std::vector<std::string> paths = {m_backup_path + path};
                if (!m_origin_file.empty()) paths.push_back(m_origin_file);
                for (auto & path2 : paths) {
                    bool result = false;
                    if (boost::filesystem::exists(path2)) {
                        mz_zip_archive archive;
                        mz_zip_zero_struct(&archive);
                        if (open_zip_reader(&archive, path2)) {
                            result = _extract_from_archive(archive, path, extract);
                            close_zip_reader(&archive);
                        }
                    }
                    if (result) return result;
                }
            }
            char error_buf[1024];
            ::snprintf(error_buf, 1024, "File %s not found from archive", path.c_str());
            add_error(error_buf);
            return false;
        }
        try
        {
            if (!extract(archive, stat)) {
                return false;
            }
        }
        catch (const std::exception& e)
        {
            // ensure the zip archive is closed and rethrow the exception
            add_error(e.what());
            return false;
        }
        return true;
    }

References _extract_from_archive(), Slic3r::_BBS_3MF_Base::add_error(), Slic3r::close_zip_reader(), ZipUnicodePathExtraField::decode(), Slic3r::encode_path(), m_backup_path, m_origin_file, and Slic3r::open_zip_reader().

Referenced by _extract_from_archive(), _extract_xml_from_archive(), _load_model_from_file(), get_thumbnail(), and load_gcode_3mf_from_stream().

Here is the call graph for this function:

Here is the caller graph for this function:

_extract_layer_config_ranges_from_archive()

void Slic3r::_BBS_3MF_Importer::_extract_layer_config_ranges_from_archive ( mz_zip_archive & archive, const mz_zip_archive_file_stat & stat, ConfigSubstitutionContext & config_substitutions )

private

    {
        if (stat.m_uncomp_size > 0) {
            std::string buffer((size_t)stat.m_uncomp_size, 0);
            mz_bool res = mz_zip_reader_extract_file_to_mem(&archive, stat.m_filename, (void*)buffer.data(), (size_t)stat.m_uncomp_size, 0);
            if (res == 0) {
                add_error("Error while reading layer config ranges data to buffer");
                return;
            }
 
            std::istringstream iss(buffer); // wrap returned xml to istringstream
            pt::ptree objects_tree;
            pt::read_xml(iss, objects_tree);
 
            for (const auto& object : objects_tree.get_child("objects")) {
                pt::ptree object_tree = object.second;
                int obj_idx = object_tree.get<int>("<xmlattr>.id", -1);
                if (obj_idx <= 0) {
                    add_error("Found invalid object id");
                    continue;
                }
 
                IdToLayerConfigRangesMap::iterator object_item = m_layer_config_ranges.find(obj_idx);
                if (object_item != m_layer_config_ranges.end()) {
                    add_error("Found duplicated layer config range");
                    continue;
                }
 
                t_layer_config_ranges config_ranges;
 
                for (const auto& range : object_tree) {
                    if (range.first != "range")
                        continue;
                    pt::ptree range_tree = range.second;
                    double min_z = range_tree.get<double>("<xmlattr>.min_z");
                    double max_z = range_tree.get<double>("<xmlattr>.max_z");
 
                    // get Z range information
                    DynamicPrintConfig config;
 
                    for (const auto& option : range_tree) {
                        if (option.first != "option")
                            continue;
                        std::string opt_key = option.second.get<std::string>("<xmlattr>.opt_key");
                        std::string value = option.second.data();
 
                        config.set_deserialize(opt_key, value, config_substitutions);
                    }
 
                    config_ranges[{ min_z, max_z }].assign_config(std::move(config));
                }
 
                if (!config_ranges.empty())
                    m_layer_config_ranges.insert({ obj_idx, std::move(config_ranges) });
            }
        }
    }

References _extract_layer_config_ranges_from_archive(), Slic3r::_BBS_3MF_Base::add_error(), m_layer_config_ranges, and Slic3r::range().

Referenced by _extract_layer_config_ranges_from_archive().

Here is the call graph for this function:

Here is the caller graph for this function:

_extract_layer_heights_profile_config_from_archive()

void Slic3r::_BBS_3MF_Importer::_extract_layer_heights_profile_config_from_archive ( mz_zip_archive & archive, const mz_zip_archive_file_stat & stat )

private

    {
        if (stat.m_uncomp_size > 0) {
            std::string buffer((size_t)stat.m_uncomp_size, 0);
            mz_bool res = mz_zip_reader_extract_to_mem(&archive, stat.m_file_index, (void*)buffer.data(), (size_t)stat.m_uncomp_size, 0);
            if (res == 0) {
                add_error("Error while reading layer heights profile data to buffer");
                return;
            }
 
            if (buffer.back() == '\n')
                buffer.pop_back();
 
            std::vector<std::string> objects;
            boost::split(objects, buffer, boost::is_any_of("\n"), boost::token_compress_off);
 
            for (const std::string& object : objects)             {
                std::vector<std::string> object_data;
                boost::split(object_data, object, boost::is_any_of("|"), boost::token_compress_off);
                if (object_data.size() != 2) {
                    add_error("Error while reading object data");
                    continue;
                }
 
                std::vector<std::string> object_data_id;
                boost::split(object_data_id, object_data[0], boost::is_any_of("="), boost::token_compress_off);
                if (object_data_id.size() != 2) {
                    add_error("Error while reading object id");
                    continue;
                }
 
                int object_id = std::atoi(object_data_id[1].c_str());
                if (object_id == 0) {
                    add_error("Found invalid object id");
                    continue;
                }
 
                IdToLayerHeightsProfileMap::iterator object_item = m_layer_heights_profiles.find(object_id);
                if (object_item != m_layer_heights_profiles.end()) {
                    add_error("Found duplicated layer heights profile");
                    continue;
                }
 
                std::vector<std::string> object_data_profile;
                boost::split(object_data_profile, object_data[1], boost::is_any_of(";"), boost::token_compress_off);
                if (object_data_profile.size() <= 4 || object_data_profile.size() % 2 != 0) {
                    add_error("Found invalid layer heights profile");
                    continue;
                }
 
                std::vector<coordf_t> profile;
                profile.reserve(object_data_profile.size());
 
                for (const std::string& value : object_data_profile) {
                    profile.push_back((coordf_t)std::atof(value.c_str()));
                }
 
                m_layer_heights_profiles.insert({ object_id, profile });
            }
        }
    }

References _extract_layer_heights_profile_config_from_archive(), Slic3r::_BBS_3MF_Base::add_error(), and m_layer_heights_profiles.

Referenced by _extract_layer_heights_profile_config_from_archive().

Here is the call graph for this function:

Here is the caller graph for this function:

_extract_model_from_archive()

bool Slic3r::_BBS_3MF_Importer::_extract_model_from_archive ( mz_zip_archive & archive, const mz_zip_archive_file_stat & stat )

private

    {
        if (stat.m_uncomp_size == 0) {
            add_error("Found invalid size");
            return false;
        }
 
        _destroy_xml_parser();
 
        m_xml_parser = XML_ParserCreate(nullptr);
        if (m_xml_parser == nullptr) {
            add_error("Unable to create parser");
            return false;
        }
 
        XML_SetUserData(m_xml_parser, (void*)this);
        XML_SetElementHandler(m_xml_parser, _BBS_3MF_Importer::_handle_start_model_xml_element, _BBS_3MF_Importer::_handle_end_model_xml_element);
        XML_SetCharacterDataHandler(m_xml_parser, _BBS_3MF_Importer::_handle_xml_characters);
        XML_SetEntityDeclHandler(m_xml_parser, nullptr);
        XML_SetExternalEntityRefHandler(m_xml_parser, nullptr);
 
        struct CallbackData
        {
            XML_Parser& parser;
            _BBS_3MF_Importer& importer;
            const mz_zip_archive_file_stat& stat;
 
            CallbackData(XML_Parser& parser, _BBS_3MF_Importer& importer, const mz_zip_archive_file_stat& stat) : parser(parser), importer(importer), stat(stat) {}
        };
 
        CallbackData data(m_xml_parser, *this, stat);
 
        mz_bool res = 0;
 
        try
        {
            mz_file_write_func callback = [](void* pOpaque, mz_uint64 file_ofs, const void* pBuf, size_t n)->size_t {
                CallbackData* data = (CallbackData*)pOpaque;
                if (!XML_Parse(data->parser, (const char*)pBuf, (int)n, (file_ofs + n == data->stat.m_uncomp_size) ? 1 : 0) || data->importer.parse_error()) {
                    char error_buf[1024];
                    ::snprintf(error_buf, 1024, "Error (%s) while parsing '%s' at line %d", data->importer.parse_error_message(), data->stat.m_filename, (int)XML_GetCurrentLineNumber(data->parser));
                    throw Slic3r::FileIOError(error_buf);
                }
                return n;
            };
            void* opaque = &data;
            res = mz_zip_reader_extract_to_callback(&archive, stat.m_file_index, callback, opaque, 0);
        }
        catch (const version_error& e)
        {
            // rethrow the exception
            throw Slic3r::FileIOError(e.what());
        }
        catch (std::exception& e)
        {
            add_error(e.what());
            return false;
        }
 
        if (res == 0) {
            add_error("Error while extracting model data from zip archive");
            return false;
        }
 
        return true;
    }

References _BBS_3MF_Importer(), _destroy_xml_parser(), _extract_model_from_archive(), _handle_end_model_xml_element(), _handle_start_model_xml_element(), _handle_xml_characters(), Slic3r::_BBS_3MF_Base::add_error(), and m_xml_parser.

Referenced by _extract_model_from_archive(), _load_model_from_file(), and load_gcode_3mf_from_stream().

Here is the call graph for this function:

Here is the caller graph for this function:

_extract_print_config_from_archive()

void Slic3r::_BBS_3MF_Importer::_extract_print_config_from_archive ( mz_zip_archive & archive, const mz_zip_archive_file_stat & stat, DynamicPrintConfig & config, ConfigSubstitutionContext & subs_context, const std::string & archive_filename )

private

    {
        if (stat.m_uncomp_size > 0) {
            std::string buffer((size_t)stat.m_uncomp_size, 0);
            mz_bool res = mz_zip_reader_extract_file_to_mem(&archive, stat.m_filename, (void*)buffer.data(), (size_t)stat.m_uncomp_size, 0);
            if (res == 0) {
                add_error("Error while reading config data to buffer");
                return;
            }
            ConfigBase::load_from_gcode_string_legacy(config, buffer.data(), config_substitutions);
        }
    }

References _extract_print_config_from_archive(), Slic3r::_BBS_3MF_Base::add_error(), and Slic3r::ConfigBase::load_from_gcode_string_legacy().

Referenced by _extract_print_config_from_archive().

Here is the call graph for this function:

Here is the caller graph for this function:

_extract_project_config_from_archive()

void Slic3r::_BBS_3MF_Importer::_extract_project_config_from_archive ( mz_zip_archive & archive, const mz_zip_archive_file_stat & stat, DynamicPrintConfig & config, ConfigSubstitutionContext & subs_context, Model & model )

private

    {
        if (stat.m_uncomp_size > 0) {
            const std::string& temp_path = model.get_backup_path();
 
            std::string dest_file = temp_path + std::string("/") + "_temp_3.config";;
            std::string dest_zip_file = encode_path(dest_file.c_str());
            mz_bool res = mz_zip_reader_extract_to_file(&archive, stat.m_file_index, dest_zip_file.c_str(), 0);
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", extract  %1% from 3mf %2%, ret %3%\n") % dest_file % stat.m_filename % res;
            if (res == 0) {
                add_error("Error while extract project config file to file");
                return;
            }
            std::map<std::string, std::string> key_values;
            std::string reason;
            int ret = config.load_from_json(dest_file, config_substitutions, true, key_values, reason);
            if (ret) {
                add_error("Error load config from json:"+reason);
                return;
            }
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", load project config file successfully from %1%\n") %dest_file;
 
            // Heal any gradient-curve slots corrupted by the legacy "|" separator collision
            // (see FilamentMixer::sanitize_mixed_gradient_curve_array). The 3MF JSON itself
            // is safe (";" + C-style escape), but older projects saved through the buggy
            // export_selections/load_selections path may already carry single-point entries
            // that fail MakerWorld's "curve needs >= 2 points" check.
            if (auto* curve_opt = config.option<ConfigOptionStrings>("filament_mixed_gradient_curve"))
                Slic3r::sanitize_mixed_gradient_curve_array(curve_opt->values);
        }
    }

References _extract_project_config_from_archive(), Slic3r::_BBS_3MF_Base::add_error(), Slic3r::encode_path(), Slic3r::Model::get_backup_path(), Slic3r::ConfigBase::load_from_json(), Slic3r::ConfigBase::option(), and Slic3r::sanitize_mixed_gradient_curve_array().

Referenced by _extract_project_config_from_archive(), and load_gcode_3mf_from_stream().

Here is the call graph for this function:

Here is the caller graph for this function:

_extract_project_embedded_presets_from_archive()

void Slic3r::_BBS_3MF_Importer::_extract_project_embedded_presets_from_archive ( mz_zip_archive & archive, const mz_zip_archive_file_stat & stat, std::vector< Preset * > & project_presets, Model & model, Preset::Type type, bool use_json = true )

private

    {
        if (stat.m_uncomp_size > 0) {
            /*std::string src_file = decode_path(stat.m_filename);
            std::size_t found = src_file.find(METADATA_DIR);
            if (found != std::string::npos)
                src_file = src_file.substr(found + METADATA_STR_LEN);
            else
                return;*/
            std::string dest_file = m_backup_path + std::string("/") + "_temp_2.config";;
            std::string dest_zip_file = encode_path(dest_file.c_str());
            mz_bool res = mz_zip_reader_extract_to_file(&archive, stat.m_file_index, dest_zip_file.c_str(), 0);
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", extract  %1% from 3mf %2%, ret %3%\n") % dest_file % stat.m_filename % res;
            if (res == 0) {
                add_error("Error while extract auxiliary file to file");
                return;
            }
            //load presets
            DynamicPrintConfig config;
            //ConfigSubstitutions config_substitutions = config.load_from_ini(dest_file, Enable);
            std::map<std::string, std::string> key_values;
            std::string reason;
            ConfigSubstitutions config_substitutions = use_json? config.load_from_json(dest_file, Enable, key_values, reason) : config.load_from_ini(dest_file, Enable);
            if (!reason.empty()) {
                BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(", load project embedded config from  %1% failed\n") % dest_file;
                //skip this file
                return;
            }
            ConfigOptionString* print_name;
            ConfigOptionStrings* filament_names;
            std::string preset_name;
            if (type == Preset::TYPE_PRINT) {
                print_name = dynamic_cast < ConfigOptionString* > (config.option("print_settings_id"));
                if (!print_name) {
                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(", can not found print_settings_id from  %1%\n") % dest_file;
                    //skip this file
                    return;
                }
                preset_name = print_name->value;
            }
            else if (type == Preset::TYPE_FILAMENT) {
                filament_names = dynamic_cast < ConfigOptionStrings* > (config.option("filament_settings_id"));
                if (!filament_names) {
                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(", can not found filament_settings_id from  %1%\n") % dest_file;
                    //skip this file
                    return;
                }
                preset_name = filament_names->values[0];
            }
            else if (type == Preset::TYPE_PRINTER) {
                print_name = dynamic_cast < ConfigOptionString* > (config.option("printer_settings_id"));
                if (!print_name) {
                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(", can not found printer_settings_id from  %1%\n") % dest_file;
                    //skip this file
                    return;
                }
                preset_name = print_name->value;
            }
            else {
                BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(", invalid type  %1% from file %2%\n")% Preset::get_type_string(type) % dest_file;
                //skip this file
                return;
            }
 
            Preset *preset = new Preset(type, preset_name, false);
            preset->file = dest_file;
            preset->config = std::move(config);
            preset->loaded = true;
            preset->is_project_embedded = true;
            preset->is_external = true;
            preset->is_dirty = false;
 
            std::string version_str = key_values[BBL_JSON_KEY_VERSION];
            boost::optional<Semver> version = Semver::parse(version_str);
            if (version) {
                preset->version = *version;
            }
            else
                preset->version = this->m_bambuslicer_generator_version?*this->m_bambuslicer_generator_version: Semver();
            /*for (int i = 0; i < config_substitutions.size(); i++)
            {
                //ConfigSubstitution config_substitution;
                //config_substitution.opt_def   = optdef;
                //config_substitution.old_value = value;
                //config_substitution.new_value = ConfigOptionUniquePtr(opt->clone());
                preset->loading_substitutions.emplace_back(std::move(config_substitutions[i]));
            }*/
            if (!config_substitutions.empty()) {
                preset->loading_substitutions = new ConfigSubstitutions();
                *(preset->loading_substitutions) = std::move(config_substitutions);
            }
 
            project_presets.push_back(preset);
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", create one project embedded preset: %1% from %2%, type %3%\n") % preset_name % dest_file %Preset::get_type_string(type);
        }
    }

References _extract_project_embedded_presets_from_archive(), Slic3r::_BBS_3MF_Base::add_error(), BBL_JSON_KEY_VERSION, Slic3r::Preset::config, Slic3r::Enable, Slic3r::encode_path(), Slic3r::Preset::file, Slic3r::Preset::get_type_string(), Slic3r::Preset::is_dirty, Slic3r::Preset::is_external, Slic3r::Preset::is_project_embedded, Slic3r::ConfigBase::load_from_ini(), Slic3r::ConfigBase::load_from_json(), Slic3r::Preset::loaded, Slic3r::Preset::loading_substitutions, m_backup_path, Slic3r::ConfigBase::option(), Slic3r::Semver::parse(), Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, Slic3r::Preset::TYPE_PRINTER, Slic3r::ConfigOptionSingle< T >::value, Slic3r::ConfigOptionVector< T >::values, version(), and Slic3r::Preset::version.

Referenced by _extract_project_embedded_presets_from_archive().

Here is the call graph for this function:

Here is the caller graph for this function:

_extract_sla_drain_holes_from_archive()

void Slic3r::_BBS_3MF_Importer::_extract_sla_drain_holes_from_archive ( mz_zip_archive & archive, const mz_zip_archive_file_stat & stat )

private

References Slic3r::transform().

Here is the call graph for this function:

_extract_sla_support_points_from_archive()

void Slic3r::_BBS_3MF_Importer::_extract_sla_support_points_from_archive ( mz_zip_archive & archive, const mz_zip_archive_file_stat & stat )

private

_extract_xml_from_archive() [1/2]

bool Slic3r::_BBS_3MF_Importer::_extract_xml_from_archive ( mz_zip_archive & archive, const mz_zip_archive_file_stat & stat, XML_StartElementHandler start_handler, XML_EndElementHandler end_handler )

private

    {
        if (stat.m_uncomp_size == 0) {
            add_error("Found invalid size");
            return false;
        }
 
        _destroy_xml_parser();
 
        m_xml_parser = XML_ParserCreate(nullptr);
        if (m_xml_parser == nullptr) {
            add_error("Unable to create parser");
            return false;
        }
 
        XML_SetUserData(m_xml_parser, (void*)this);
        XML_SetElementHandler(m_xml_parser, start_handler, end_handler);
        XML_SetCharacterDataHandler(m_xml_parser, _BBS_3MF_Importer::_handle_xml_characters);
        XML_SetEntityDeclHandler(m_xml_parser, nullptr);
        XML_SetExternalEntityRefHandler(m_xml_parser, nullptr);
 
        // expat sizes its buffer with an int, so a larger entry cannot be parsed in one piece.
        if (stat.m_uncomp_size > static_cast<mz_uint64>(std::numeric_limits<int>::max())) {
            add_error("Found invalid size");
            return false;
        }
        const int xml_size = static_cast<int>(stat.m_uncomp_size);
 
        void* parser_buffer = XML_GetBuffer(m_xml_parser, xml_size);
        if (parser_buffer == nullptr) {
            add_error("Unable to create buffer");
            return false;
        }
 
        mz_bool res = mz_zip_reader_extract_file_to_mem(&archive, stat.m_filename, parser_buffer, static_cast<size_t>(xml_size), 0);
        if (res == 0) {
            add_error("Error while reading config data to buffer");
            return false;
        }
 
        if (!XML_ParseBuffer(m_xml_parser, xml_size, 1)) {
            char error_buf[1024];
            ::snprintf(error_buf, 1024, "Error (%s) while parsing xml file at line %d", XML_ErrorString(XML_GetErrorCode(m_xml_parser)), (int)XML_GetCurrentLineNumber(m_xml_parser));
            add_error(error_buf);
            return false;
        }
 
        return true;
    }

References _destroy_xml_parser(), _extract_xml_from_archive(), _handle_xml_characters(), Slic3r::_BBS_3MF_Base::add_error(), and m_xml_parser.

Here is the call graph for this function:

_extract_xml_from_archive() [2/2]

bool Slic3r::_BBS_3MF_Importer::_extract_xml_from_archive ( mz_zip_archive & archive, std::string const & path, XML_StartElementHandler start_handler, XML_EndElementHandler end_handler )

private

    {
        return _extract_from_archive(archive, path, [this, start_handler, end_handler](mz_zip_archive& archive, const mz_zip_archive_file_stat& stat) {
            return _extract_xml_from_archive(archive, stat, start_handler, end_handler);
        });
    }

References _extract_from_archive(), and _extract_xml_from_archive().

Referenced by _extract_xml_from_archive(), _extract_xml_from_archive(), _load_model_from_file(), get_thumbnail(), and load_gcode_3mf_from_stream().

Here is the call graph for this function:

Here is the caller graph for this function:

_generate_current_object_list()

bool Slic3r::_BBS_3MF_Importer::_generate_current_object_list ( std::vector< Component > & sub_objects, Id object_id, IdToCurrentObjectMap & current_objects )

private

    {
        // A cycle in the component graph would expand forever, and an acyclic graph can still expand
        // exponentially, so bound the number of component references queued. Checking before they are
        // queued bounds the work list itself, whatever the fan-out. A valid file over the budget is
        // rejected too, but the budget is way above the component references of any real object.
        static constexpr size_t max_components = 100000;
 
        std::list<std::pair<Component, Transform3d>> id_list;
        id_list.push_back(std::make_pair(Component(object_id, Transform3d::Identity()), Transform3d::Identity()));
 
        size_t num_components = 0;
        while (!id_list.empty())
        {
            auto current_item = id_list.front();
            Component current_id = current_item.first;
            id_list.pop_front();
            IdToCurrentObjectMap::iterator current_object = current_objects.find(current_id.object_id);
            if (current_object != current_objects.end()) {
                //found one
                if (!current_object->second.components.empty()) {
                    num_components += current_object->second.components.size();
                    if (num_components > max_components) {
                        add_error("invalid 3mf: cyclic or too many component references");
                        sub_objects.clear();
                        return false;
                    }
                    for (const Component &comp : current_object->second.components) {
                        id_list.push_back(std::pair(comp, current_item.second * comp.transform));
                    }
                }
                else if (!(current_object->second.geometry.empty())) {
                    //CurrentObject* ptr = &(current_objects[current_id]);
                    //CurrentObject* ptr2 = &(current_object->second);
                    sub_objects.push_back({ current_object->first, current_item.second});
                }
            }
        }
        return true;
    }

References _generate_current_object_list(), Slic3r::_BBS_3MF_Base::add_error(), Slic3r::_BBS_3MF_Importer::Component::object_id, and Slic3r::_BBS_3MF_Importer::Component::transform.

Referenced by _generate_current_object_list().

Here is the call graph for this function:

Here is the caller graph for this function:

_generate_volumes_new()

bool Slic3r::_BBS_3MF_Importer::_generate_volumes_new ( ModelObject & object, const std::vector< Component > & sub_objects, const ObjectMetadata::VolumeMetadataList & volumes, ConfigSubstitutionContext & config_substitutions )

private

    {
        if (!object.volumes.empty()) {
            add_error("object already built with parts");
            return false;
        }
 
        //unsigned int geo_tri_count = (unsigned int)geometry.triangles.size();
        unsigned int renamed_volumes_count = 0;
 
        for (unsigned int index = 0; index < sub_objects.size(); index++)
        {
            //find the volume metadata firstly
            Component sub_comp = sub_objects[index];
            Id object_id = sub_comp.object_id;
            IdToCurrentObjectMap::iterator current_object = m_current_objects.find(object_id);
            if (current_object == m_current_objects.end()) {
                add_error("sub_objects can not be found, id=" + std::to_string(object_id.second));
                return false;
            }
            CurrentObject* sub_object = &(current_object->second);
 
            const ObjectMetadata::VolumeMetadata* volume_data = nullptr;
            ObjectMetadata::VolumeMetadata default_volume_data(sub_object->id);
            if (index < volumes.size() && volumes[index].subobject_id == sub_object->id)
                volume_data = &volumes[index];
            else for (const ObjectMetadata::VolumeMetadata& volume_iter : volumes) {
                if (volume_iter.subobject_id == sub_object->id) {
                    volume_data = &volume_iter;
                    break;
                }
            }
 
            Transform3d volume_matrix_to_object = Transform3d::Identity();
            bool        has_transform         = false;
            int         shared_mesh_id          = object_id.second;
            if (volume_data)
            {
                int found_count = 0;
                // extract the volume transformation from the volume's metadata, if present
                for (const Metadata& metadata : volume_data->metadata) {
                    if (metadata.key == MATRIX_KEY) {
                        volume_matrix_to_object = Slic3r::Geometry::transform3d_from_string(metadata.value);
                        has_transform       = ! volume_matrix_to_object.isApprox(Transform3d::Identity(), 1e-10);
                        found_count++;
                    }
                    else if (metadata.key == MESH_SHARED_KEY){
                        //add the shared mesh logic
                        shared_mesh_id = ::atoi(metadata.value.c_str());
                        found_count++;
                        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": line %1%, shared_mesh_id %2%")%__LINE__%shared_mesh_id;
                    }
 
                    if (found_count >= 2)
                        break;
                }
            }
            else {
                //create a volume_data
                volume_data = &default_volume_data;
            }
 
            ModelVolume* volume = nullptr;
            ModelVolume *shared_volume = nullptr;
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": line %1%, subobject_id %2%, shared_mesh_id %3%")%__LINE__ %sub_object->id %shared_mesh_id;
            if (shared_mesh_id != -1) {
                std::map<int, ModelVolume*>::iterator iter = m_shared_meshes.find(shared_mesh_id);
                if (iter != m_shared_meshes.end()) {
                    shared_volume = iter->second;
                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": line %1%, found shared mesh, id %2%, mesh %3%")%__LINE__%shared_mesh_id%shared_volume;
                }
            }
            else {
                //for some cases, object point to this shared mesh already loaded, treat that one as the root
                std::map<int, ModelVolume*>::iterator iter = m_shared_meshes.find(sub_object->id);
                if (iter != m_shared_meshes.end()) {
                    shared_volume = iter->second;
                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": line %1%, already loaded copy-share mesh before, id %2%, mesh %3%")%__LINE__%sub_object->id%shared_volume;
                }
            }
 
            const size_t triangles_count = sub_object->geometry.triangles.size();
            if (triangles_count == 0) {
                add_error("found no trianges in the object " + std::to_string(sub_object->id));
                return false;
            }
            if (!shared_volume){
                // splits volume out of imported geometry
                indexed_triangle_set its;
                its.indices.assign(sub_object->geometry.triangles.begin(), sub_object->geometry.triangles.end());
                //const size_t triangles_count = its.indices.size();
                //if (triangles_count == 0) {
                //    add_error("found no trianges in the object " + std::to_string(sub_object->id));
                //    return false;
                //}
                for (const Vec3i32& face : its.indices) {
                    for (const int tri_id : face) {
                        if (tri_id < 0 || tri_id >= int(sub_object->geometry.vertices.size())) {
                            add_error("invalid vertex id in object " + std::to_string(sub_object->id));
                            return false;
                        }
                    }
                }
 
                for (const Vec3f &v : sub_object->geometry.vertices)
                    if (! v.allFinite()) {   // Qhull cannot take a NaN vertex
                        add_error("invalid (non-finite) vertex in object " + std::to_string(sub_object->id));
                        return false;
                    }
                its.vertices.assign(sub_object->geometry.vertices.begin(), sub_object->geometry.vertices.end());
 
                // BBS
                for (const std::string& prop_str : sub_object->geometry.face_properties) {
                    FaceProperty face_prop;
                    face_prop.from_string(prop_str);
                    its.properties.push_back(face_prop);
                }
 
                TriangleMesh triangle_mesh(std::move(its), volume_data->mesh_stats);
 
                // BBS: no need to multiply the instance matrix into the volume
                //if (!m_is_bbl_3mf) {
                //    // if the 3mf was not produced by BambuStudio and there is only one instance,
                //    // bake the transformation into the geometry to allow the reload from disk command
                //    // to work properly
                //    if (object.instances.size() == 1) {
                //        triangle_mesh.transform(object.instances.front()->get_transformation().get_matrix(), false);
                //        object.instances.front()->set_transformation(Slic3r::Geometry::Transformation());
                //        //FIXME do the mesh fixing?
                //    }
                //}
                if (triangle_mesh.volume() < 0)
                    triangle_mesh.flip_triangles();
 
                volume = object.add_volume(std::move(triangle_mesh));
 
                if (shared_mesh_id != -1)
                    //for some cases the shared mesh is in other plate and not loaded in cli slicing
                    //we need to use the first one in the same plate instead
                    m_shared_meshes[shared_mesh_id] = volume;
                else
                    m_shared_meshes[sub_object->id] = volume;
            }
            else {
                //create volume to use shared mesh
                volume = object.add_volume_with_shared_mesh(*shared_volume);
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": line %1%, create volume using shared_mesh %2%")%__LINE__%shared_volume;
            }
            // stores the volume matrix taken from the metadata, if present
            if (has_transform)
                volume->source.transform = Slic3r::Geometry::Transformation(volume_matrix_to_object);
 
            volume->calculate_convex_hull();
 
            //set transform from 3mf
            Slic3r::Geometry::Transformation comp_transformatino(sub_comp.transform);
            volume->set_transformation(comp_transformatino * volume->get_transformation());
            if (shared_volume) {
                const TriangleMesh& trangle_mesh = volume->mesh();
                Vec3d shift = trangle_mesh.get_init_shift();
                if (!shift.isApprox(Vec3d::Zero()))
                    volume->translate(shift);
            }
 
            // recreate custom supports, seam and mmu segmentation from previously loaded attribute
            {
                volume->supported_facets.reserve(triangles_count);
                volume->seam_facets.reserve(triangles_count);
                volume->mmu_segmentation_facets.reserve(triangles_count);
                volume->fuzzy_skin_facets.reserve(triangles_count);
                for (size_t i=0; i<triangles_count; ++i) {
                    assert(i < sub_object->geometry.custom_supports.size());
                    assert(i < sub_object->geometry.custom_seam.size());
                    assert(i < sub_object->geometry.mmu_segmentation.size());
                    assert(i < sub_object->geometry.fuzzy_skin.size());
                    if (! sub_object->geometry.custom_supports[i].empty())
                        volume->supported_facets.set_triangle_from_string(i, sub_object->geometry.custom_supports[i]);
                    if (! sub_object->geometry.custom_seam[i].empty())
                        volume->seam_facets.set_triangle_from_string(i, sub_object->geometry.custom_seam[i]);
                    if (! sub_object->geometry.mmu_segmentation[i].empty())
                        volume->mmu_segmentation_facets.set_triangle_from_string(i, sub_object->geometry.mmu_segmentation[i]);
                    if (!sub_object->geometry.fuzzy_skin[i].empty())
                        volume->fuzzy_skin_facets.set_triangle_from_string(i, sub_object->geometry.fuzzy_skin[i]);
                }
                volume->supported_facets.shrink_to_fit();
                volume->seam_facets.shrink_to_fit();
                volume->mmu_segmentation_facets.shrink_to_fit();
                volume->mmu_segmentation_facets.touch();
                volume->fuzzy_skin_facets.shrink_to_fit();
                volume->fuzzy_skin_facets.touch();
                for (int slot = 0; slot < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++slot) {
                    const std::vector<std::string> &mask = sub_object->geometry.texture_displacement[slot];
                    if (mask.empty())
                        continue; // no triangle painted on this slot
                    FacetsAnnotation &facets = volume->texture_displacement_facet(slot);
                    facets.reserve(triangles_count);
                    for (size_t i = 0; i < triangles_count && i < mask.size(); ++i)
                        if (!mask[i].empty())
                            facets.set_triangle_from_string(i, mask[i]);
                    facets.shrink_to_fit();
                    facets.touch();
                }
            }
 
            volume->set_type(volume_data->part_type);
            
            if (auto &es = volume_data->shape_configuration; es.has_value())
                volume->emboss_shape = std::move(es);            
            if (auto &tc = volume_data->text_configuration; tc.has_value())
                volume->text_configuration = std::move(tc);
 
            // Apply the seam mode after all base-type metadata, regardless of XML key order.
            ModelVolumeType precise_seam_type = ModelVolumeType::INVALID;
            // apply the remaining volume's metadata
            for (const Metadata& metadata : volume_data->metadata) {
                if (metadata.key == NAME_KEY)
                    volume->name = metadata.value;
                else if (metadata.key == TEXTURE_DISPLACEMENT_KEY)
                    _apply_texture_displacement(*volume, metadata.value);
                //else if ((metadata.key == MODIFIER_KEY) && (metadata.value == "1"))
        //  volume->set_type(ModelVolumeType::PARAMETER_MODIFIER);
        //for old format
                else if ((metadata.key == VOLUME_TYPE_KEY) || (metadata.key == PART_TYPE_KEY))
                    volume->set_type(ModelVolume::type_from_string(metadata.value));
                else if (metadata.key == PRECISE_SEAM_TYPE_KEY)
                    precise_seam_type = ModelVolume::type_from_string(metadata.value);
                else if (boost::starts_with(metadata.key, PRECISE_SEAM_CONFIG_PREFIX))
                    continue; // Restore dormant settings only after the final volume type is known.
                else if (metadata.key == SOURCE_FILE_KEY)
                    volume->source.input_file = metadata.value;
                else if (metadata.key == SOURCE_OBJECT_ID_KEY)
                    volume->source.object_idx = ::atoi(metadata.value.c_str());
                else if (metadata.key == SOURCE_VOLUME_ID_KEY)
                    volume->source.volume_idx = ::atoi(metadata.value.c_str());
                else if (metadata.key == SOURCE_OFFSET_X_KEY)
                    volume->source.mesh_offset(0) = ::atof(metadata.value.c_str());
                else if (metadata.key == SOURCE_OFFSET_Y_KEY)
                    volume->source.mesh_offset(1) = ::atof(metadata.value.c_str());
                else if (metadata.key == SOURCE_OFFSET_Z_KEY)
                    volume->source.mesh_offset(2) = ::atof(metadata.value.c_str());
                else if (metadata.key == SOURCE_IN_INCHES)
                    volume->source.is_converted_from_inches = metadata.value == "1";
                else if (metadata.key == SOURCE_IN_METERS)
                    volume->source.is_converted_from_meters = metadata.value == "1";
                else if ((metadata.key == MATRIX_KEY) || (metadata.key == MESH_SHARED_KEY))
                    continue;
                else
                    volume->config.set_deserialize(metadata.key, metadata.value, config_substitutions);
            }
 
            // Missing or unknown seam modes retain the ordinary modifier fallback.
            // Ignore seam metadata on other base types; legacy inline seam types still load above.
            if (volume->is_modifier() && is_precise_seam(precise_seam_type))
                volume->set_type(precise_seam_type);
 
            // Unknown seam modes must remain inert modifiers, even when dormant settings are present.
            if (volume->is_precise_seam()) {
                for (const Metadata& metadata : volume_data->metadata) {
                    if (boost::starts_with(metadata.key, PRECISE_SEAM_CONFIG_PREFIX)) {
                        const std::string key = metadata.key.substr(sizeof(PRECISE_SEAM_CONFIG_PREFIX) - 1);
                        if (!key.empty())
                            volume->config.set_deserialize(key, metadata.value, config_substitutions);
                    }
                }
            }
 
            // this may happen for 3mf saved by 3rd part softwares
            if (volume->name.empty()) {
                volume->name = object.name;
                if (renamed_volumes_count > 0)
                    volume->name += "_" + std::to_string(renamed_volumes_count + 1);
                ++renamed_volumes_count;
            }
        }
 
        return true;
    }

References _apply_texture_displacement(), _generate_volumes_new(), Slic3r::_BBS_3MF_Base::add_error(), Slic3r::ModelVolume::calculate_convex_hull(), Slic3r::ModelVolume::config, Slic3r::_BBS_3MF_Importer::Geometry::custom_seam, Slic3r::_BBS_3MF_Importer::Geometry::custom_supports, Slic3r::ModelVolume::emboss_shape, Slic3r::empty(), Slic3r::_BBS_3MF_Importer::Geometry::face_properties, Slic3r::TriangleMesh::flip_triangles(), Slic3r::_BBS_3MF_Importer::Geometry::fuzzy_skin, Slic3r::ModelVolume::fuzzy_skin_facets, Slic3r::_BBS_3MF_Importer::CurrentObject::geometry, Slic3r::TriangleMesh::get_init_shift(), Slic3r::ModelVolume::get_transformation(), Slic3r::_BBS_3MF_Importer::CurrentObject::id, Slic3r::ModelVolume::Source::input_file, Slic3r::INVALID, Slic3r::ModelVolume::Source::is_converted_from_inches, Slic3r::ModelVolume::Source::is_converted_from_meters, Slic3r::ModelVolume::is_modifier(), Slic3r::is_precise_seam(), Slic3r::ModelVolume::is_precise_seam(), Slic3r::_BBS_3MF_Importer::Metadata::key, m_current_objects, m_shared_meshes, MATRIX_KEY, Slic3r::ModelVolume::mesh(), Slic3r::ModelVolume::Source::mesh_offset, MESH_SHARED_KEY, Slic3r::_BBS_3MF_Importer::ObjectMetadata::VolumeMetadata::mesh_stats, Slic3r::_BBS_3MF_Importer::ObjectMetadata::VolumeMetadata::metadata, Slic3r::_BBS_3MF_Importer::Geometry::mmu_segmentation, Slic3r::ModelVolume::mmu_segmentation_facets, Slic3r::ModelVolume::name, NAME_KEY, Slic3r::_BBS_3MF_Importer::Component::object_id, Slic3r::ModelVolume::Source::object_idx, Slic3r::_BBS_3MF_Importer::ObjectMetadata::VolumeMetadata::part_type, PART_TYPE_KEY, PRECISE_SEAM_CONFIG_PREFIX, PRECISE_SEAM_TYPE_KEY, Slic3r::FacetsAnnotation::reserve(), Slic3r::ModelVolume::seam_facets, Slic3r::ModelConfig::set_deserialize(), Slic3r::ModelVolume::set_transformation(), Slic3r::FacetsAnnotation::set_triangle_from_string(), Slic3r::ModelVolume::set_type(), Slic3r::_BBS_3MF_Importer::ObjectMetadata::VolumeMetadata::shape_configuration, Slic3r::FacetsAnnotation::shrink_to_fit(), Slic3r::ModelVolume::source, SOURCE_FILE_KEY, SOURCE_IN_INCHES, SOURCE_IN_METERS, SOURCE_OBJECT_ID_KEY, SOURCE_OFFSET_X_KEY, SOURCE_OFFSET_Y_KEY, SOURCE_OFFSET_Z_KEY, SOURCE_VOLUME_ID_KEY, Slic3r::ModelVolume::supported_facets, Slic3r::_BBS_3MF_Importer::ObjectMetadata::VolumeMetadata::text_configuration, Slic3r::ModelVolume::text_configuration, Slic3r::_BBS_3MF_Importer::Geometry::texture_displacement, Slic3r::ModelVolume::texture_displacement_facet(), TEXTURE_DISPLACEMENT_KEY, Slic3r::TEXTURE_DISPLACEMENT_MAX_LAYERS, Slic3r::ObjectWithTimestamp::touch(), Slic3r::_BBS_3MF_Importer::Component::transform, Slic3r::ModelVolume::Source::transform, Slic3r::Geometry::transform3d_from_string(), Slic3r::ModelVolume::translate(), Slic3r::_BBS_3MF_Importer::Geometry::triangles, Slic3r::ModelVolume::type_from_string(), Slic3r::_BBS_3MF_Importer::Metadata::value, Slic3r::_BBS_3MF_Importer::Geometry::vertices, Slic3r::TriangleMesh::volume(), Slic3r::ModelVolume::Source::volume_idx, and VOLUME_TYPE_KEY.

Referenced by _generate_volumes_new().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_end_assemble()

bool Slic3r::_BBS_3MF_Importer::_handle_end_assemble ( )

private

    {
        //do nothing
        return true;
    }

References _handle_end_assemble().

Referenced by _handle_end_assemble(), and _handle_end_config_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_end_assemble_item()

bool Slic3r::_BBS_3MF_Importer::_handle_end_assemble_item ( )

private

    {
        return true;
    }

References _handle_end_assemble_item().

Referenced by _handle_end_assemble_item(), and _handle_end_config_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_end_build()

bool Slic3r::_BBS_3MF_Importer::_handle_end_build ( )

private

    {
        // do nothing
        return true;
    }

References _handle_end_build().

Referenced by _handle_end_build(), and _handle_end_model_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_end_color()

bool Slic3r::_BBS_3MF_Importer::_handle_end_color ( )

private

    {
        // do nothing
        return true;
    }

References _handle_end_color().

Referenced by _handle_end_color(), and _handle_end_model_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_end_color_group()

bool Slic3r::_BBS_3MF_Importer::_handle_end_color_group ( )

private

    {
        // do nothing
        return true;
    }

References _handle_end_color_group().

Referenced by _handle_end_color_group(), and _handle_end_model_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_end_component()

bool Slic3r::_BBS_3MF_Importer::_handle_end_component ( )

private

    {
        // do nothing
        return true;
    }

References _handle_end_component().

Referenced by _handle_end_component(), and _handle_end_model_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_end_components()

bool Slic3r::_BBS_3MF_Importer::_handle_end_components ( )

private

    {
        // do nothing
        return true;
    }

References _handle_end_components().

Referenced by _handle_end_components(), and _handle_end_model_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_end_config()

bool Slic3r::_BBS_3MF_Importer::_handle_end_config ( )

private

    {
        // do nothing
        return true;
    }

References _handle_end_config().

Referenced by _handle_end_config(), and _handle_end_config_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_end_config_filament()

bool Slic3r::_BBS_3MF_Importer::_handle_end_config_filament ( )

private

    {
        // do nothing
        return true;
    }

References _handle_end_config_filament().

Referenced by _handle_end_config_filament(), and _handle_end_config_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_end_config_metadata()

bool Slic3r::_BBS_3MF_Importer::_handle_end_config_metadata ( )

private

    {
        // do nothing
        return true;
    }

References _handle_end_config_metadata().

Referenced by _handle_end_config_metadata(), and _handle_end_config_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_end_config_nozzle()

bool Slic3r::_BBS_3MF_Importer::_handle_end_config_nozzle ( )

private

    {
        // do nothing
        return true;
    }

References _handle_end_config_nozzle().

Referenced by _handle_end_config_nozzle(), and _handle_end_config_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_end_config_object()

bool Slic3r::_BBS_3MF_Importer::_handle_end_config_object ( )

private

    {
        m_curr_config.object_id = -1;
        return true;
    }

References _handle_end_config_object(), and m_curr_config.

Referenced by _handle_end_config_object(), and _handle_end_config_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_end_config_plater()

bool Slic3r::_BBS_3MF_Importer::_handle_end_config_plater ( )

private

    {
        if (!m_curr_plater)
        {
            add_error("_handle_end_config_plater: don't find plate created before");
            return false;
        }
        m_plater_data.emplace(m_curr_plater->plate_index, m_curr_plater);
        m_curr_plater = nullptr;
        return true;
    }

References _handle_end_config_plater(), Slic3r::_BBS_3MF_Base::add_error(), m_curr_plater, and m_plater_data.

Referenced by _handle_end_config_plater(), and _handle_end_config_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_end_config_plater_instance()

bool Slic3r::_BBS_3MF_Importer::_handle_end_config_plater_instance ( )

private

    {
        if (!m_curr_plater)
        {
            add_error("_handle_end_config_plater_instance: don't find plate created before");
            return false;
        }
        if ((m_curr_instance.object_id == -1) || (m_curr_instance.instance_id == -1))
        {
            //add_error("invalid object id/instance id");
            //skip this instance
            m_curr_instance.object_id = m_curr_instance.instance_id = -1;
            m_curr_instance.identify_id = 0;
            return true;
        }
 
        m_curr_plater->obj_inst_map.emplace(m_curr_instance.object_id, std::make_pair(m_curr_instance.instance_id, m_curr_instance.identify_id));
        m_curr_instance.object_id = m_curr_instance.instance_id = -1;
        m_curr_instance.identify_id = 0;
        return true;
    }

References _handle_end_config_plater_instance(), Slic3r::_BBS_3MF_Base::add_error(), m_curr_instance, and m_curr_plater.

Referenced by _handle_end_config_plater_instance(), and _handle_end_config_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_end_config_volume()

bool Slic3r::_BBS_3MF_Importer::_handle_end_config_volume ( )

private

    {
        m_curr_config.volume_id = -1;
        return true;
    }

References _handle_end_config_volume(), and m_curr_config.

Referenced by _handle_end_config_volume(), and _handle_end_config_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_end_config_volume_mesh()

bool Slic3r::_BBS_3MF_Importer::_handle_end_config_volume_mesh ( )

private

    {
        // do nothing
        return true;
    }

References _handle_end_config_volume_mesh().

Referenced by _handle_end_config_volume_mesh(), and _handle_end_config_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_end_config_warning()

bool Slic3r::_BBS_3MF_Importer::_handle_end_config_warning ( )

private

    {
        // do nothing
        return true;
    }

References _handle_end_config_warning().

Referenced by _handle_end_config_warning().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_end_config_xml_element() [1/2]

void Slic3r::_BBS_3MF_Importer::_handle_end_config_xml_element ( const char * name )

private

    {
        if (m_xml_parser == nullptr)
            return;
 
        bool res = true;
 
        if (::strcmp(CONFIG_TAG, name) == 0)
            res = _handle_end_config();
        else if (::strcmp(OBJECT_TAG, name) == 0)
            res = _handle_end_config_object();
        else if (::strcmp(VOLUME_TAG, name) == 0)
            res = _handle_end_config_volume();
        else if (::strcmp(PART_TAG, name) == 0)
            res = _handle_end_config_volume();
        else if (::strcmp(MESH_STAT_TAG, name) == 0)
            res = _handle_end_config_volume_mesh();
        else if (::strcmp(METADATA_TAG, name) == 0)
            res = _handle_end_config_metadata();
        else if (::strcmp(PLATE_TAG, name) == 0)
            res = _handle_end_config_plater();
        else if (::strcmp(FILAMENT_TAG, name) == 0)
            res = _handle_end_config_filament();
        else if (::strcmp(NOZZLE_TAG, name) == 0)
            res = _handle_end_config_nozzle();
        else if (::strcmp(INSTANCE_TAG, name) == 0)
            res = _handle_end_config_plater_instance();
        else if (::strcmp(ASSEMBLE_TAG, name) == 0)
            res = _handle_end_assemble();
        else if (::strcmp(ASSEMBLE_ITEM_TAG, name) == 0)
            res = _handle_end_assemble_item();
 
        if (!res)
            _stop_xml_parser();
    }

References _handle_end_assemble(), _handle_end_assemble_item(), _handle_end_config(), _handle_end_config_filament(), _handle_end_config_metadata(), _handle_end_config_nozzle(), _handle_end_config_object(), _handle_end_config_plater(), _handle_end_config_plater_instance(), _handle_end_config_volume(), _handle_end_config_volume_mesh(), _handle_end_config_xml_element(), _stop_xml_parser(), ASSEMBLE_ITEM_TAG, ASSEMBLE_TAG, CONFIG_TAG, FILAMENT_TAG, INSTANCE_TAG, m_xml_parser, MESH_STAT_TAG, METADATA_TAG, NOZZLE_TAG, OBJECT_TAG, PART_TAG, PLATE_TAG, and VOLUME_TAG.

Referenced by _handle_end_config_xml_element(), _handle_end_config_xml_element(), and load_gcode_3mf_from_stream().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_end_config_xml_element() [2/2]

void XMLCALL Slic3r::_BBS_3MF_Importer::_handle_end_config_xml_element ( void * userData, const char * name )

staticprivate

    {
        _BBS_3MF_Importer* importer = (_BBS_3MF_Importer*)userData;
        if (importer != nullptr)
            importer->_handle_end_config_xml_element(name);
    }

References _BBS_3MF_Importer(), and _handle_end_config_xml_element().

Here is the call graph for this function:

_handle_end_item()

bool Slic3r::_BBS_3MF_Importer::_handle_end_item ( )

private

    {
        // do nothing
        return true;
    }

References _handle_end_item().

Referenced by _handle_end_item(), and _handle_end_model_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_end_mesh()

bool Slic3r::_BBS_3MF_Importer::_handle_end_mesh ( )

private

    {
        // do nothing
        return true;
    }

References _handle_end_mesh().

Referenced by _handle_end_mesh(), and _handle_end_model_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_end_metadata()

bool Slic3r::_BBS_3MF_Importer::_handle_end_metadata ( )

private

    {
        if ((m_curr_metadata_name == BBS_3MF_VERSION)||(m_curr_metadata_name == BBS_3MF_VERSION1)) {
            //m_is_bbl_3mf = true;
            m_version = (unsigned int)atoi(m_curr_characters.c_str());
            /*if (m_check_version && (m_version > VERSION_BBS_3MF_COMPATIBLE)) {
                // std::string msg = _(L("The selected 3mf file has been saved with a newer version of " + std::string(SLIC3R_APP_NAME) + " and is not compatible."));
                // throw version_error(msg.c_str());
                const std::string msg = (boost::format(_(L("The selected 3mf file has been saved with a newer version of %1% and is not compatible."))) % std::string(SLIC3R_APP_NAME)).str();
                throw version_error(msg);
            }*/
        } else if (m_curr_metadata_name == BBL_APPLICATION_TAG) {
            // Generator application of the 3MF.
            // SLIC3R_APP_KEY - SoftFever_VERSION
            if (boost::starts_with(m_curr_characters, "BambuStudio-")) {
                m_is_bbl_3mf = true;
                m_bambuslicer_generator_version = Semver::parse(m_curr_characters.substr(12));
            }
            else if (boost::starts_with(m_curr_characters, "OrcaSlicer-")) {
                m_is_bbl_3mf = true;
                m_bambuslicer_generator_version = Semver::parse(m_curr_characters.substr(11));
            }
        } else if (m_curr_metadata_name == ORCASLICER_TAG) {
            // OrcaSlicer version tag (written from OrcaSlicer 2.3.2 onwards)
            m_orca_slicer_version = Semver::parse(m_curr_characters);
            if (m_orca_slicer_version) {
                m_is_bbl_3mf = true;
            }
        //TODO: currently use version 0, no need to load&&save this string
        /*} else if (m_curr_metadata_name == BBS_FDM_SUPPORTS_PAINTING_VERSION) {
            m_fdm_supports_painting_version = (unsigned int) atoi(m_curr_characters.c_str());
            check_painting_version(m_fdm_supports_painting_version, FDM_SUPPORTS_PAINTING_VERSION,
                _(L("The selected 3MF contains FDM supports painted object using a newer version of OrcaSlicer and is not compatible.")));
        } else if (m_curr_metadata_name == BBS_SEAM_PAINTING_VERSION) {
            m_seam_painting_version = (unsigned int) atoi(m_curr_characters.c_str());
            check_painting_version(m_seam_painting_version, SEAM_PAINTING_VERSION,
                _(L("The selected 3MF contains seam painted object using a newer version of OrcaSlicer and is not compatible.")));
        } else if (m_curr_metadata_name == BBS_MM_PAINTING_VERSION) {
            m_mm_painting_version = (unsigned int) atoi(m_curr_characters.c_str());
            check_painting_version(m_mm_painting_version, MM_PAINTING_VERSION,
                _(L("The selected 3MF contains multi-material painted object using a newer version of OrcaSlicer and is not compatible.")));*/
        } else if (m_curr_metadata_name == BBL_MODEL_ID_TAG) {
            m_model_id = xml_unescape(m_curr_characters);
        } else if (m_curr_metadata_name == BBL_MODEL_NAME_TAG) {
            BOOST_LOG_TRIVIAL(trace) << "design_info, load_3mf found model name = " << m_curr_characters;
            model_info.model_name = xml_unescape(m_curr_characters);
        } else if (m_curr_metadata_name == BBL_ORIGIN_TAG) {
            BOOST_LOG_TRIVIAL(trace) << "design_info, load_3mf found model name = " << m_curr_characters;
            model_info.origin = xml_unescape(m_curr_characters);
        } else if (m_curr_metadata_name == BBL_DESIGNER_TAG) {
            BOOST_LOG_TRIVIAL(trace) << "design_info, load_3mf found designer = " << m_curr_characters;
            m_designer = xml_unescape(m_curr_characters);
        } else if (m_curr_metadata_name == BBL_DESIGNER_USER_ID_TAG) {
            BOOST_LOG_TRIVIAL(trace) << "design_info, load_3mf found designer_user_id = " << m_curr_characters;
            m_designer_user_id = xml_unescape(m_curr_characters);
        } else if (m_curr_metadata_name == BBL_DESIGNER_COVER_FILE_TAG) {
            BOOST_LOG_TRIVIAL(trace) << "design_info, load_3mf found designer_cover = " << m_curr_characters;
            model_info.cover_file = xml_unescape(m_curr_characters);
        } else if (m_curr_metadata_name == BBL_DESCRIPTION_TAG) {
            BOOST_LOG_TRIVIAL(trace) << "design_info, load_3mf found description = " << m_curr_characters;
            model_info.description = xml_unescape(m_curr_characters);
        } else if (m_curr_metadata_name == BBL_LICENSE_TAG) {
            BOOST_LOG_TRIVIAL(trace) << "design_info, load_3mf found license = " << m_curr_characters;
            model_info.license = xml_unescape(m_curr_characters);
        } else if (m_curr_metadata_name == BBL_COPYRIGHT_TAG) {
            BOOST_LOG_TRIVIAL(trace) << "design_info, load_3mf found CopyRight = " << m_curr_characters;
            model_info.copyright = xml_unescape(m_curr_characters);
        } else if (m_curr_metadata_name == BBL_COPYRIGHT_NORMATIVE_TAG) {
            BOOST_LOG_TRIVIAL(trace) << "design_info, load_3mf found Copyright = " << m_curr_characters;
            model_info.copyright = xml_unescape(m_curr_characters);
        } else if (m_curr_metadata_name == BBL_REGION_TAG) {
            BOOST_LOG_TRIVIAL(trace) << "design_info, load_3mf found region = " << m_curr_characters;
            m_contry_code = xml_unescape(m_curr_characters);
        } else if (m_curr_metadata_name == BBL_PROFILE_TITLE_TAG) {
            BOOST_LOG_TRIVIAL(trace) << "design_info, load_3mf found profile_title = " << m_curr_characters;
            m_profile_title = xml_unescape(m_curr_characters);
        } else if (m_curr_metadata_name == BBL_PROFILE_COVER_TAG) {
            BOOST_LOG_TRIVIAL(trace) << "design_info, load_3mf found profile_cover = " << m_curr_characters;
            m_profile_cover = xml_unescape(m_curr_characters);
        } else if (m_curr_metadata_name == BBL_PROFILE_DESCRIPTION_TAG) {
            BOOST_LOG_TRIVIAL(trace) << "design_info, load_3mf found profile_description = " << m_curr_characters;
            m_Profile_description = xml_unescape(m_curr_characters);
        } else if (m_curr_metadata_name == BBL_PROFILE_USER_ID_TAG) {
            BOOST_LOG_TRIVIAL(trace) << "design_info, load_3mf found profile_user_id = " << m_curr_characters;
            m_profile_user_id = xml_unescape(m_curr_characters);
        }else if (m_curr_metadata_name == BBL_PROFILE_USER_NAME_TAG) {
            BOOST_LOG_TRIVIAL(trace) << "design_info, load_3mf found profile_user_name = " << m_curr_characters;
            m_profile_user_name = xml_unescape(m_curr_characters);
        } else if (m_curr_metadata_name == BBL_CREATION_DATE_TAG) {
            ;
        } else if (m_curr_metadata_name == BBL_MODIFICATION_TAG) {
            ;
        } else {
            ;
        }
        if (!m_curr_metadata_name.empty()) {
            BOOST_LOG_TRIVIAL(info) << "load_3mf found metadata key = " << m_curr_metadata_name << ", value = " << xml_unescape(m_curr_characters);
            model_info.metadata_items[m_curr_metadata_name] = xml_unescape(m_curr_characters);
        }
 
        return true;
    }

References _handle_end_metadata(), BBL_APPLICATION_TAG, BBL_COPYRIGHT_NORMATIVE_TAG, BBL_COPYRIGHT_TAG, BBL_CREATION_DATE_TAG, BBL_DESCRIPTION_TAG, BBL_DESIGNER_COVER_FILE_TAG, BBL_DESIGNER_TAG, BBL_DESIGNER_USER_ID_TAG, BBL_LICENSE_TAG, BBL_MODEL_ID_TAG, BBL_MODEL_NAME_TAG, BBL_MODIFICATION_TAG, BBL_ORIGIN_TAG, BBL_PROFILE_COVER_TAG, BBL_PROFILE_DESCRIPTION_TAG, BBL_PROFILE_TITLE_TAG, BBL_PROFILE_USER_ID_TAG, BBL_PROFILE_USER_NAME_TAG, BBL_REGION_TAG, BBS_3MF_VERSION, BBS_3MF_VERSION1, m_bambuslicer_generator_version, m_contry_code, m_curr_characters, m_curr_metadata_name, m_designer, m_designer_user_id, m_is_bbl_3mf, m_model_id, m_orca_slicer_version, m_profile_cover, m_Profile_description, m_profile_title, m_profile_user_id, m_profile_user_name, m_version, model_info, ORCASLICER_TAG, Slic3r::Semver::parse(), Slic3r::trace(), and Slic3r::xml_unescape().

Referenced by _handle_end_metadata(), and _handle_end_model_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_end_model()

bool Slic3r::_BBS_3MF_Importer::_handle_end_model ( )

private

    {
        // BBS: Production Extension
        if (!m_sub_model_path.empty())
            return true;
 
        // deletes all non-built or non-instanced objects
        for (const IdToModelObjectMap::value_type& object : m_objects) {
            if (object.second >= int(m_model->objects.size())) {
                add_error("Unable to find object");
                return false;
            }
            ModelObject *model_object = m_model->objects[object.second];
            if (model_object != nullptr && model_object->instances.size() == 0)
                m_model->delete_object(model_object);
        }
 
        //construct the index maps
        for (const IdToCurrentObjectMap::value_type& object : m_current_objects) {
            m_index_paths.insert({ object.first.second, object.first.first});
        }
 
        if (!m_is_bbl_3mf && !_is_published_3mf()) {
            // if the 3mf was not produced by OrcaSlicer and there is only one object,
            // set the object name to match the filename
            if (m_model->objects.size() == 1)
                m_model->objects.front()->name = m_name;
        }
 
        // applies instances' matrices
        for (Instance& instance : m_instances) {
            if (instance.instance != nullptr && instance.instance->get_object() != nullptr)
                // apply the transform to the instance
                _apply_transform(*instance.instance, instance.transform);
        }
 
        return true;
    }

References _apply_transform(), _handle_end_model(), _is_published_3mf(), Slic3r::_BBS_3MF_Base::add_error(), Slic3r::ModelObject::instances, m_current_objects, m_index_paths, m_instances, m_is_bbl_3mf, m_model, m_name, m_objects, and m_sub_model_path.

Referenced by _handle_end_model(), and _handle_end_model_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_end_model_xml_element() [1/2]

void Slic3r::_BBS_3MF_Importer::_handle_end_model_xml_element ( const char * name )

private

    {
        if (m_xml_parser == nullptr)
            return;
 
        bool res = true;
 
        if (::strcmp(MODEL_TAG, name) == 0)
            res = _handle_end_model();
        else if (::strcmp(RESOURCES_TAG, name) == 0)
            res = _handle_end_resources();
        else if (::strcmp(OBJECT_TAG, name) == 0)
            res = _handle_end_object();
        else if (::strcmp(COLOR_GROUP_TAG, name) == 0)
            res = _handle_end_color_group();
        else if (::strcmp(COLOR_TAG, name) == 0)
            res = _handle_end_color();
        else if (::strcmp(MESH_TAG, name) == 0)
            res = _handle_end_mesh();
        else if (::strcmp(VERTICES_TAG, name) == 0)
            res = _handle_end_vertices();
        else if (::strcmp(VERTEX_TAG, name) == 0)
            res = _handle_end_vertex();
        else if (::strcmp(TRIANGLES_TAG, name) == 0)
            res = _handle_end_triangles();
        else if (::strcmp(TRIANGLE_TAG, name) == 0)
            res = _handle_end_triangle();
        else if (::strcmp(COMPONENTS_TAG, name) == 0)
            res = _handle_end_components();
        else if (::strcmp(COMPONENT_TAG, name) == 0)
            res = _handle_end_component();
        else if (::strcmp(BUILD_TAG, name) == 0)
            res = _handle_end_build();
        else if (::strcmp(ITEM_TAG, name) == 0)
            res = _handle_end_item();
        else if (::strcmp(METADATA_TAG, name) == 0)
            res = _handle_end_metadata();
 
        if (!res)
            _stop_xml_parser();
    }

References _handle_end_build(), _handle_end_color(), _handle_end_color_group(), _handle_end_component(), _handle_end_components(), _handle_end_item(), _handle_end_mesh(), _handle_end_metadata(), _handle_end_model(), _handle_end_model_xml_element(), _handle_end_object(), _handle_end_resources(), _handle_end_triangle(), _handle_end_triangles(), _handle_end_vertex(), _handle_end_vertices(), _stop_xml_parser(), BUILD_TAG, COLOR_GROUP_TAG, COLOR_TAG, COMPONENT_TAG, COMPONENTS_TAG, ITEM_TAG, m_xml_parser, MESH_TAG, METADATA_TAG, MODEL_TAG, OBJECT_TAG, RESOURCES_TAG, TRIANGLE_TAG, TRIANGLES_TAG, VERTEX_TAG, and VERTICES_TAG.

Referenced by _extract_model_from_archive(), _handle_end_model_xml_element(), and _handle_end_model_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_end_model_xml_element() [2/2]

void XMLCALL Slic3r::_BBS_3MF_Importer::_handle_end_model_xml_element ( void * userData, const char * name )

staticprivate

    {
        _BBS_3MF_Importer* importer = (_BBS_3MF_Importer*)userData;
        if (importer != nullptr)
            importer->_handle_end_model_xml_element(name);
    }

References _BBS_3MF_Importer(), and _handle_end_model_xml_element().

Here is the call graph for this function:

_handle_end_object()

bool Slic3r::_BBS_3MF_Importer::_handle_end_object ( )

private

    {
        if (!m_load_model) {
            delete m_curr_object;
            m_curr_object = nullptr;
            return true;
        }
        if (!m_curr_object || (m_curr_object->id == -1)) {
            add_error("Found invalid object");
            return false;
        }
        else {
            if (m_is_bbl_3mf && boost::ends_with(m_curr_object->uuid, OBJECT_UUID_SUFFIX) && m_load_restore) {
                // Adjust backup object/volume id
                std::istringstream iss(m_curr_object->uuid);
                int backup_id;
                bool need_replace = false;
                if (iss >> std::hex >> backup_id) {
                    need_replace = (m_curr_object->id != backup_id);
                    m_curr_object->id = backup_id;
                }
                if (!m_curr_object->components.empty())
                {
                    Id first_id = m_curr_object->components.front().object_id;
                    first_id.second = 0;
                    IdToCurrentObjectMap::iterator current_object = m_current_objects.lower_bound(first_id);
                    IdToCurrentObjectMap new_map;
                    for (int index = 0; index < m_curr_object->components.size(); index++)
                    {
                        Component& component = m_curr_object->components[index];
                        Id new_id = component.object_id;
                        new_id.second = (index + 1) << 16 | backup_id;
                        if (current_object != m_current_objects.end()
                                && (new_id.first.empty() || new_id.first == current_object->first.first)) {
                            current_object->second.id   = new_id.second;
                            new_map.insert({new_id, std::move(current_object->second)});
                            current_object = m_current_objects.erase(current_object);
                        }
                        else {
                            add_error("can not find object for component, id=" + std::to_string(component.object_id.second));
                            delete m_curr_object;
                            m_curr_object = nullptr;
                            return false;
                        }
                        component.object_id.second = new_id.second;
                    }
                    for (auto & obj : new_map)
                        m_current_objects.insert({obj.first, std::move(obj.second)});
                }
            }
 
            Id id = std::make_pair(m_sub_model_path, m_curr_object->id);
            if (m_current_objects.find(id) == m_current_objects.end()) {
                m_current_objects.insert({ id, std::move(*m_curr_object) });
                delete m_curr_object;
                m_curr_object = nullptr;
            }
            else {
                add_error("Found object with duplicate id");
                delete m_curr_object;
                m_curr_object = nullptr;
                return false;
            }
        }
 
        /*if (m_curr_object.object != nullptr) {
            if (m_curr_object.id != -1) {
                if (m_curr_object.geometry.empty()) {
                    // no geometry defined
                    // remove the object from the model
                    m_model->delete_object(m_curr_object.object);
 
                    if (m_curr_object.components.empty()) {
                        // no components defined -> invalid object, delete it
                        IdToModelObjectMap::iterator object_item = m_objects.find(id);
                        if (object_item != m_objects.end())
                            m_objects.erase(object_item);
 
                        IdToAliasesMap::iterator alias_item = m_objects_aliases.find(id);
                        if (alias_item != m_objects_aliases.end())
                            m_objects_aliases.erase(alias_item);
                    }
                    else
                        // adds components to aliases
                        m_objects_aliases.insert({ id, m_curr_object.components });
                }
                else {
                    // geometry defined, store it for later use
                    m_geometries.insert({ id, std::move(m_curr_object.geometry) });
 
                    // stores the object for later use
                    if (m_objects.find(id) == m_objects.end()) {
                        m_objects.insert({ id, m_curr_object.model_object_idx });
                        m_objects_aliases.insert({ id, { 1, Component(m_curr_object.id) } }); // aliases itself
                    }
                    else {
                        add_error("Found object with duplicate id");
                        return false;
                    }
                }
            }
            else {
                //sub objects
            }
        }*/
 
        return true;
    }

References _handle_end_object(), Slic3r::_BBS_3MF_Base::add_error(), m_curr_object, m_current_objects, m_is_bbl_3mf, m_load_model, m_load_restore, m_sub_model_path, Slic3r::_BBS_3MF_Importer::Component::object_id, and OBJECT_UUID_SUFFIX.

Referenced by _handle_end_model_xml_element(), and _handle_end_object().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_end_relationships_element() [1/2]

void Slic3r::_BBS_3MF_Importer::_handle_end_relationships_element ( const char * name )

private

    {
        if (m_xml_parser == nullptr)
            return;
 
        bool res = true;
 
        if (!res)
            _stop_xml_parser();
    }

References _handle_end_relationships_element(), _stop_xml_parser(), and m_xml_parser.

Here is the call graph for this function:

_handle_end_relationships_element() [2/2]

void XMLCALL Slic3r::_BBS_3MF_Importer::_handle_end_relationships_element ( void * userData, const char * name )

staticprivate

    {
        _BBS_3MF_Importer* importer = (_BBS_3MF_Importer*)userData;
        if (importer != nullptr)
            importer->_handle_end_relationships_element(name);
    }

References _BBS_3MF_Importer(), and _handle_end_relationships_element().

Referenced by _handle_end_relationships_element(), _handle_end_relationships_element(), _load_model_from_file(), get_thumbnail(), and load_gcode_3mf_from_stream().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_end_resources()

bool Slic3r::_BBS_3MF_Importer::_handle_end_resources ( )

private

    {
        // do nothing
        return true;
    }

References _handle_end_resources().

Referenced by _handle_end_model_xml_element(), and _handle_end_resources().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_end_text_info_item()

bool Slic3r::_BBS_3MF_Importer::_handle_end_text_info_item ( )

private

    {
        return true;
    }

References _handle_end_text_info_item().

Referenced by _handle_end_text_info_item().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_end_triangle()

bool Slic3r::_BBS_3MF_Importer::_handle_end_triangle ( )

private

    {
        // do nothing
        return true;
    }

References _handle_end_triangle().

Referenced by _handle_end_model_xml_element(), and _handle_end_triangle().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_end_triangles()

bool Slic3r::_BBS_3MF_Importer::_handle_end_triangles ( )

private

    {
        // do nothing
        return true;
    }

References _handle_end_triangles().

Referenced by _handle_end_model_xml_element(), and _handle_end_triangles().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_end_vertex()

bool Slic3r::_BBS_3MF_Importer::_handle_end_vertex ( )

private

    {
        // do nothing
        return true;
    }

References _handle_end_vertex().

Referenced by _handle_end_model_xml_element(), and _handle_end_vertex().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_end_vertices()

bool Slic3r::_BBS_3MF_Importer::_handle_end_vertices ( )

private

    {
        // do nothing
        return true;
    }

References _handle_end_vertices().

Referenced by _handle_end_model_xml_element(), and _handle_end_vertices().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_assemble()

bool Slic3r::_BBS_3MF_Importer::_handle_start_assemble ( const char ** attributes, unsigned int num_attributes )

private

    {
        return true;
    }

References _handle_start_assemble().

Referenced by _handle_start_assemble(), and _handle_start_config_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_assemble_item()

bool Slic3r::_BBS_3MF_Importer::_handle_start_assemble_item ( const char ** attributes, unsigned int num_attributes )

private

    {
        if (!m_load_model) return true;
 
        int object_id = bbs_get_attribute_value_int(attributes, num_attributes, OBJECT_ID_ATTR);
        int instance_id = bbs_get_attribute_value_int(attributes, num_attributes, INSTANCEID_ATTR);
 
        IndexToPathMap::iterator index_iter = m_index_paths.find(object_id);
        if (index_iter == m_index_paths.end()) {
            add_error("can not find object for assemble item, id= " + std::to_string(object_id));
            return false;
        }
        Id temp_id = std::make_pair(index_iter->second, index_iter->first);
        IdToModelObjectMap::iterator object_item = m_objects.find(temp_id);
        if (object_item == m_objects.end()) {
            add_error("can not find object for assemble item, id= " + std::to_string(object_id));
            return false;
        }
        object_id = object_item->second;
 
        Transform3d transform = bbs_get_transform_from_3mf_specs_string(bbs_get_attribute_value_string(attributes, num_attributes, TRANSFORM_ATTR));
        Vec3d ofs2ass = bbs_get_offset_from_3mf_specs_string(bbs_get_attribute_value_string(attributes, num_attributes, OFFSET_ATTR));
        if (object_id < m_model->objects.size()) {
            if (instance_id < m_model->objects[object_id]->instances.size()) {
                m_model->objects[object_id]->instances[instance_id]->set_assemble_from_transform(transform);
                m_model->objects[object_id]->instances[instance_id]->set_offset_to_assembly(ofs2ass);
            }
        }
        return true;
    }

References _handle_start_assemble_item(), Slic3r::_BBS_3MF_Base::add_error(), bbs_get_attribute_value_int(), bbs_get_attribute_value_string(), bbs_get_offset_from_3mf_specs_string(), bbs_get_transform_from_3mf_specs_string(), INSTANCEID_ATTR, m_index_paths, m_load_model, m_model, m_objects, OBJECT_ID_ATTR, OFFSET_ATTR, Slic3r::transform(), and TRANSFORM_ATTR.

Referenced by _handle_start_assemble_item(), and _handle_start_config_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_build()

bool Slic3r::_BBS_3MF_Importer::_handle_start_build ( const char ** attributes, unsigned int num_attributes )

private

    {
        // do nothing
        return true;
    }

References _handle_start_build().

Referenced by _handle_start_build(), and _handle_start_model_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_color()

bool Slic3r::_BBS_3MF_Importer::_handle_start_color ( const char ** attributes, unsigned int num_attributes )

private

    {
        std::string color = bbs_get_attribute_value_string(attributes, num_attributes, COLOR_ATTR);
        m_group_id_to_color[m_current_color_group] = color;
        return true;
    }

References _handle_start_color(), bbs_get_attribute_value_string(), COLOR_ATTR, m_current_color_group, and m_group_id_to_color.

Referenced by _handle_start_color(), and _handle_start_model_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_color_group()

bool Slic3r::_BBS_3MF_Importer::_handle_start_color_group ( const char ** attributes, unsigned int num_attributes )

private

    {
        m_current_color_group = bbs_get_attribute_value_int(attributes, num_attributes, ID_ATTR);
        return true;
    }

References _handle_start_color_group(), bbs_get_attribute_value_int(), ID_ATTR, and m_current_color_group.

Referenced by _handle_start_color_group(), and _handle_start_model_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_component()

bool Slic3r::_BBS_3MF_Importer::_handle_start_component ( const char ** attributes, unsigned int num_attributes )

private

    {
        std::string path      = xml_unescape(bbs_get_attribute_value_string(attributes, num_attributes, PPATH_ATTR));
        int         object_id = bbs_get_attribute_value_int(attributes, num_attributes, OBJECTID_ATTR);
        Transform3d transform = bbs_get_transform_from_3mf_specs_string(bbs_get_attribute_value_string(attributes, num_attributes, TRANSFORM_ATTR));
 
        /*Id id = std::make_pair(m_sub_model_path, object_id);
        IdToModelObjectMap::iterator object_item = m_objects.find(id);
        if (object_item == m_objects.end()) {
            IdToAliasesMap::iterator alias_item = m_objects_aliases.find(id);
            if (alias_item == m_objects_aliases.end()) {
                add_error("Found component with invalid object id");
                return false;
            }
        }*/
 
        if (m_curr_object) {
            Id id = std::make_pair(m_sub_model_path.empty() ? path : m_sub_model_path, object_id);
            m_curr_object->components.emplace_back(id, transform);
        }
 
        return true;
    }

References _handle_start_component(), bbs_get_attribute_value_int(), bbs_get_attribute_value_string(), bbs_get_transform_from_3mf_specs_string(), m_curr_object, m_sub_model_path, OBJECTID_ATTR, PPATH_ATTR, Slic3r::transform(), TRANSFORM_ATTR, and Slic3r::xml_unescape().

Referenced by _handle_start_component(), and _handle_start_model_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_components()

bool Slic3r::_BBS_3MF_Importer::_handle_start_components ( const char ** attributes, unsigned int num_attributes )

private

    {
        // reset current components
        if (m_curr_object)
            m_curr_object->components.clear();
        return true;
    }

References _handle_start_components(), and m_curr_object.

Referenced by _handle_start_components(), and _handle_start_model_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_config()

bool Slic3r::_BBS_3MF_Importer::_handle_start_config ( const char ** attributes, unsigned int num_attributes )

private

    {
        // do nothing
        return true;
    }

References _handle_start_config().

Referenced by _handle_start_config(), and _handle_start_config_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_config_filament()

bool Slic3r::_BBS_3MF_Importer::_handle_start_config_filament ( const char ** attributes, unsigned int num_attributes )

private

    {
        if (m_curr_plater) {
            std::string id = bbs_get_attribute_value_string(attributes, num_attributes, FILAMENT_ID_TAG);
            std::string type = bbs_get_attribute_value_string(attributes, num_attributes, FILAMENT_TYPE_TAG);
            std::string color = bbs_get_attribute_value_string(attributes, num_attributes, FILAMENT_COLOR_TAG);
            std::string used_m = bbs_get_attribute_value_string(attributes, num_attributes, FILAMENT_USED_M_TAG);
            std::string used_g = bbs_get_attribute_value_string(attributes, num_attributes, FILAMENT_USED_G_TAG);
            std::string filament_id = bbs_get_attribute_value_string(attributes, num_attributes, FILAMENT_TRAY_INFO_ID_TAG);
            std::string used_for_object = bbs_get_attribute_value_string(attributes, num_attributes, FILAMENT_USED_FOR_OBJECT);
            std::string used_for_support = bbs_get_attribute_value_string(attributes, num_attributes, FILAMENT_USED_FOR_SUPPORT);
            std::string group_id = bbs_get_attribute_value_string(attributes, num_attributes, FILAMENT_NOZZLE_GROUP_ID_TAG);
            std::string nozzle_diameter = bbs_get_attribute_value_string(attributes, num_attributes, FILAMENT_NOZZLE_DIAMETER_TAG);
            std::string volume_type = bbs_get_attribute_value_string(attributes, num_attributes, FILAMENT_NOZZLE_VOLUME_TYPE_TAG);
            FilamentInfo filament_info;
            filament_info.id = atoi(id.c_str()) - 1;
            filament_info.type = type;
            filament_info.color = color;
            filament_info.used_m = atof(used_m.c_str());
            filament_info.used_g = atof(used_g.c_str());
            filament_info.filament_id = filament_id;
            std::istringstream(used_for_object) >> std::boolalpha >> filament_info.used_for_object;
            std::istringstream(used_for_support) >> std::boolalpha >> filament_info.used_for_support;
            filament_info.group_id = parse_int_list(group_id);
            filament_info.nozzle_diameter = atof(nozzle_diameter.c_str());
            filament_info.nozzle_volume_type = volume_type;
            m_curr_plater->slice_filaments_info.push_back(filament_info);
        }
        return true;
    }

References _handle_start_config_filament(), bbs_get_attribute_value_string(), Slic3r::FilamentGroupUtils::FilamentInfo::color, FILAMENT_COLOR_TAG, FILAMENT_ID_TAG, FILAMENT_NOZZLE_DIAMETER_TAG, FILAMENT_NOZZLE_GROUP_ID_TAG, FILAMENT_NOZZLE_VOLUME_TYPE_TAG, FILAMENT_TRAY_INFO_ID_TAG, FILAMENT_TYPE_TAG, FILAMENT_USED_FOR_OBJECT, FILAMENT_USED_FOR_SUPPORT, FILAMENT_USED_G_TAG, FILAMENT_USED_M_TAG, Slic3r::group_id(), m_curr_plater, Slic3r::nozzle_diameter(), parse_int_list(), and Slic3r::FilamentGroupUtils::FilamentInfo::type.

Referenced by _handle_start_config_filament(), and _handle_start_config_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_config_metadata()

bool Slic3r::_BBS_3MF_Importer::_handle_start_config_metadata ( const char ** attributes, unsigned int num_attributes )

private

    {
        //std::string type = bbs_get_attribute_value_string(attributes, num_attributes, TYPE_ATTR);
        std::string key = bbs_get_attribute_value_string(attributes, num_attributes, KEY_ATTR);
        std::string value = bbs_get_attribute_value_string(attributes, num_attributes, VALUE_ATTR);
        if (key.empty())
            return true;
 
        auto get_vector_from_string = [](const std::string& str) -> std::vector<int> {
            std::stringstream stream(str);
            int value;
            std::vector<int>  results;
            while (stream >> value) {
                results.push_back(value);
            }
            return results;
        };
 
        auto get_vector_array_from_string = [get_vector_from_string](const std::string &str) -> std::vector<std::vector<int>> {
            std::vector<std::string> sub_strs;
            size_t pos = 0;
            size_t found = 0;
            while ((found = str.find('#', pos)) != std::string::npos) {
                std::string sub_str = str.substr(pos, found - pos);
                sub_strs.push_back(sub_str);
                pos = found + 1;
            }
 
            std::vector<std::vector<int>> results;
            for (std::string sub_str : sub_strs) {
                results.emplace_back(get_vector_from_string(sub_str));
            }
 
            return results;
        };
 
        if ((m_curr_plater == nullptr)&&!m_parsing_slice_info)
        {
            IdToMetadataMap::iterator object = m_objects_metadata.find(m_curr_config.object_id);
            if (object == m_objects_metadata.end()) {
                add_error("Cannot find object for metadata, id " + std::to_string(m_curr_config.object_id));
                return false;
            }
            if (m_curr_config.volume_id == -1)
                object->second.metadata.emplace_back(key, value);
            else {
                if (size_t(m_curr_config.volume_id) < object->second.volumes.size())
                    object->second.volumes[m_curr_config.volume_id].metadata.emplace_back(key, value);
            }
        }
        else
        {
            //plater
            if (key == PLATERID_ATTR)
            {
                m_curr_plater->plate_index = atoi(value.c_str());
            }
            else if (key == PLATER_NAME_ATTR) {
                m_curr_plater->plate_name = xml_unescape(value.c_str());
            }
            else if (key == LOCK_ATTR)
            {
                std::istringstream(value) >> std::boolalpha >> m_curr_plater->locked;
            }
            else if (key == BED_TYPE_ATTR)
            {
                BedType bed_type = BedType::btPC;
                const std::string bed_type_value = value == "SuperTack Plate" ? "Supertack Plate" : value;
                ConfigOptionEnum<BedType>::from_string(bed_type_value, bed_type);
                m_curr_plater->config.set_key_value("curr_bed_type", new ConfigOptionEnum<BedType>(bed_type));
            }
            else if (key == PRINT_SEQUENCE_ATTR)
            {
                PrintSequence print_sequence = PrintSequence::ByLayer;
                ConfigOptionEnum<PrintSequence>::from_string(value, print_sequence);
                m_curr_plater->config.set_key_value("print_sequence", new ConfigOptionEnum<PrintSequence>(print_sequence));
            }
            else if (key == FIRST_LAYER_PRINT_SEQUENCE_ATTR) {
                m_curr_plater->config.set_key_value("first_layer_print_sequence", new ConfigOptionInts(get_vector_from_string(value)));
            }
            else if (key == OTHER_LAYERS_PRINT_SEQUENCE_ATTR) {
                m_curr_plater->config.set_key_value("other_layers_print_sequence", new ConfigOptionInts(get_vector_from_string(value)));
            }
            else if (key == OTHER_LAYERS_PRINT_SEQUENCE_NUMS_ATTR) {
                m_curr_plater->config.set_key_value("other_layers_print_sequence_nums", new ConfigOptionInt(stoi(value)));
            }
            else if (key == SPIRAL_VASE_MODE) {
                bool spiral_mode = false;
                std::istringstream(value) >> std::boolalpha >> spiral_mode;
                m_curr_plater->config.set_key_value("spiral_mode", new ConfigOptionBool(spiral_mode));
            }
            else if (key == IMEX_PARALLEL_MODE_ATTR || key == IXEX_PARALLEL_MODE_ATTR_LEGACY) {
                m_curr_plater->config.set_key_value("imex_parallel_mode", new ConfigOptionString(value));
            }
            else if (key == IMEX_HEAD_FILAMENT_MAP_ATTR) {
                m_curr_plater->config.set_key_value("imex_head_filament_map", new ConfigOptionString(value));
            }
            else if (key == FILAMENT_MAP_MODE_ATTR)
            {
                FilamentMapMode map_mode = FilamentMapMode::fmmAutoForFlush;
                // handle old versions, only load manual params
                if (value != "Auto") {
                    ConfigOptionEnum<FilamentMapMode>::from_string(value, map_mode);
                    m_curr_plater->config.set_key_value("filament_map_mode", new ConfigOptionEnum<FilamentMapMode>(map_mode));
                }
            }
            else if (key == FILAMENT_MAP_ATTR) {
                if (m_curr_plater){
                    auto filament_map = get_vector_from_string(value);
                    for (size_t idx = 0; idx < filament_map.size(); ++idx) {
                        if (filament_map[idx] < 1) {
                            filament_map[idx] = 1;
                        }
                    }
                    m_curr_plater->filament_maps = filament_map;
                    m_curr_plater->config.set_key_value("filament_map", new ConfigOptionInts(filament_map));
                }
            }
            else if (key == FILAMENT_VOL_MAP_ATTR) {
                if (m_curr_plater){
                    auto filament_volume_map = get_vector_from_string(value);
                    for (size_t idx = 0; idx < filament_volume_map.size(); ++idx) {
                        // The map feeds per-filament slot resolution and grouping. Clamp any
                        // higher volume-type back to Standard(0) on load: Hybrid(2) is only an
                        // in-memory grouping seed that is never persisted, and TPU High Flow(3)
                        // is clamped with the same information loss on every load.
                        if (filament_volume_map[idx] > 1) {
                            filament_volume_map[idx] = 0;
                        }
                    }
                    m_curr_plater->config.set_key_value("filament_volume_map", new ConfigOptionInts(filament_volume_map));
                }
            }
            else if (key == GCODE_FILE_ATTR)
            {
                m_curr_plater->gcode_file = value;
            }
            else if (key == THUMBNAIL_FILE_ATTR)
            {
                m_curr_plater->thumbnail_file = value;
            }
            else if (key == NO_LIGHT_THUMBNAIL_FILE_ATTR)
            {
                m_curr_plater->no_light_thumbnail_file = value;
            }
            else if (key == TOP_FILE_ATTR)
            {
                m_curr_plater->top_file = value;
            }
            else if (key == PICK_FILE_ATTR)
            {
                m_curr_plater->pick_file = value;
            }
            //else if (key == PATTERN_FILE_ATTR)
            //{
            //    m_curr_plater->pattern_file = value;
            //}
            else if (key == PATTERN_BBOX_FILE_ATTR)
            {
                m_curr_plater->pattern_bbox_file = value;
            }
            else if (key == INSTANCEID_ATTR)
            {
                m_curr_instance.instance_id = atoi(value.c_str());
            }
            else if (key == IDENTIFYID_ATTR)
            {
                m_curr_instance.identify_id = atoi(value.c_str());
            }
            else if (key == OBJECT_ID_ATTR)
            {
                m_curr_instance.object_id = atoi(value.c_str());
                /*int obj_id = atoi(value.c_str());
                m_curr_instance.object_id = -1;
                IndexToPathMap::iterator index_iter = m_index_paths.find(obj_id);
                if (index_iter == m_index_paths.end()) {
                    BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ":" << __LINE__
                        << boost::format(", can not find object for plate's item, id=%1%, skip this object")%obj_id;
                    return true;
                }
                Id temp_id = std::make_pair(index_iter->second, index_iter->first);
                IdToModelObjectMap::iterator object_item = m_objects.find(temp_id);
                if (object_item == m_objects.end()) {
                    BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ":" << __LINE__
                        << boost::format(", can not find object for plate's item, ID <%1%, %2%>, skip this object")%index_iter->second %index_iter->first;
                    return true;
                }
                m_curr_instance.object_id = object_item->second;*/
            }
            else if (key == PLATE_IDX_ATTR)
            {
                int plate_index = atoi(value.c_str());
                std::map<int, PlateData*>::iterator it = m_plater_data.find(plate_index);
                if (it != m_plater_data.end())
                    m_curr_plater = it->second;
            }
            else if (key == SLICE_PREDICTION_ATTR)
            {
                if (m_curr_plater)
                    m_curr_plater->gcode_prediction = value;
            }
            else if (key == SLICE_WEIGHT_ATTR)
            {
                if (m_curr_plater)
                    m_curr_plater->gcode_weight = value;
            }
            else if (key == OUTSIDE_ATTR)
            {
                if (m_curr_plater)
                    std::istringstream(value) >> std::boolalpha >> m_curr_plater->toolpath_outside;
            }
            else if (key == SUPPORT_USED_ATTR)
            {
                if (m_curr_plater)
                    std::istringstream(value) >> std::boolalpha >> m_curr_plater->is_support_used;
            }
            else if (key == LABEL_OBJECT_ENABLED_ATTR)
            {
                if (m_curr_plater)
                    std::istringstream(value) >> std::boolalpha >> m_curr_plater->is_label_object_enabled;
            }
            else if (key == ENABLE_FILAMENT_DYNAMIC_MAP_ATTR)
            {
                if (m_curr_plater) {
                    bool enable_filament_dynamic_map = false;
                    std::istringstream(value) >> std::boolalpha >> enable_filament_dynamic_map;
                    m_curr_plater->config.set_key_value("enable_filament_dynamic_map", new ConfigOptionBool(enable_filament_dynamic_map));
                }
            }
            else if (key == HAS_FILAMENT_SWITCHER_ATTR)
            {
                if (m_curr_plater) {
                    bool has_filament_switcher = false;
                    std::istringstream(value) >> std::boolalpha >> has_filament_switcher;
                    m_curr_plater->config.set_key_value("has_filament_switcher", new ConfigOptionBool(has_filament_switcher));
                }
            }
            else if (key == PRINTER_MODEL_ID_ATTR)
            {
                if (m_curr_plater)
                    m_curr_plater->printer_model_id = value;
            }
            else if (key == NOZZLE_VOLUME_TYPE_ATTR)
            {
                if (m_curr_plater)
                    m_curr_plater->nozzle_volume_types = value;
            }
            else if (key == NOZZLE_DIAMETERS_ATTR)
            {
                if (m_curr_plater)
                    m_curr_plater->nozzle_diameters = value;
            }
        }
 
        return true;
    }

References _handle_start_config_metadata(), Slic3r::_BBS_3MF_Base::add_error(), bbs_get_attribute_value_string(), BED_TYPE_ATTR, Slic3r::btPC, Slic3r::ByLayer, ENABLE_FILAMENT_DYNAMIC_MAP_ATTR, Slic3r::filament_map(), FILAMENT_MAP_ATTR, FILAMENT_MAP_MODE_ATTR, FILAMENT_VOL_MAP_ATTR, FIRST_LAYER_PRINT_SEQUENCE_ATTR, Slic3r::fmmAutoForFlush, Slic3r::ConfigOptionEnum< T >::from_string(), GCODE_FILE_ATTR, HAS_FILAMENT_SWITCHER_ATTR, IDENTIFYID_ATTR, IMEX_HEAD_FILAMENT_MAP_ATTR, IMEX_PARALLEL_MODE_ATTR, INSTANCEID_ATTR, IXEX_PARALLEL_MODE_ATTR_LEGACY, KEY_ATTR, LABEL_OBJECT_ENABLED_ATTR, LOCK_ATTR, m_curr_config, m_curr_instance, m_curr_plater, m_objects_metadata, m_parsing_slice_info, m_plater_data, NO_LIGHT_THUMBNAIL_FILE_ATTR, NOZZLE_DIAMETERS_ATTR, NOZZLE_VOLUME_TYPE_ATTR, OBJECT_ID_ATTR, OTHER_LAYERS_PRINT_SEQUENCE_ATTR, OTHER_LAYERS_PRINT_SEQUENCE_NUMS_ATTR, OUTSIDE_ATTR, PATTERN_BBOX_FILE_ATTR, PICK_FILE_ATTR, PLATE_IDX_ATTR, PLATER_NAME_ATTR, PLATERID_ATTR, Slic3r::print_sequence(), PRINT_SEQUENCE_ATTR, PRINTER_MODEL_ID_ATTR, SLICE_PREDICTION_ATTR, SLICE_WEIGHT_ATTR, SPIRAL_VASE_MODE, SUPPORT_USED_ATTR, THUMBNAIL_FILE_ATTR, TOP_FILE_ATTR, VALUE_ATTR, and Slic3r::xml_unescape().

Referenced by _handle_start_config_metadata(), and _handle_start_config_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_config_mixed_filament()

bool Slic3r::_BBS_3MF_Importer::_handle_start_config_mixed_filament ( const char ** attributes, unsigned int num_attributes )

private

    {
        if (m_curr_plater) {
            std::string id         = bbs_get_attribute_value_string(attributes, num_attributes, FILAMENT_ID_TAG);
            std::string type       = bbs_get_attribute_value_string(attributes, num_attributes, FILAMENT_TYPE_TAG);
            std::string color      = bbs_get_attribute_value_string(attributes, num_attributes, FILAMENT_COLOR_TAG);
            std::string components = bbs_get_attribute_value_string(attributes, num_attributes, MIXED_FILAMENT_COMPONENTS_TAG);
            PlateMixedFilamentInfo mixed_info;
            mixed_info.id         = atoi(id.c_str());
            mixed_info.type       = type;
            mixed_info.color      = color;
            mixed_info.components = components;
            m_curr_plater->mixed_filaments_info.push_back(mixed_info);
        }
        return true;
    }

References _handle_start_config_mixed_filament(), bbs_get_attribute_value_string(), Slic3r::PlateMixedFilamentInfo::color, Slic3r::PlateMixedFilamentInfo::components, FILAMENT_COLOR_TAG, FILAMENT_ID_TAG, FILAMENT_TYPE_TAG, Slic3r::PlateMixedFilamentInfo::id, m_curr_plater, MIXED_FILAMENT_COMPONENTS_TAG, and Slic3r::PlateMixedFilamentInfo::type.

Referenced by _handle_start_config_mixed_filament(), and _handle_start_config_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_config_nozzle()

bool Slic3r::_BBS_3MF_Importer::_handle_start_config_nozzle ( const char ** attributes, unsigned int num_attributes )

private

    {
        // Read the per-plate <nozzle> tags. Older 3mf without <nozzle> tags leave nozzles_info
        // empty; load_nozzle_infos_with_compatibility then rebuilds the list from the per-filament
        // group_id / filament_map on the device side.
        if (m_curr_plater) {
            // id="0" extruder_id="1" nozzle_diameter="0.4" volume_type="Standard"
            std::string id             = bbs_get_attribute_value_string(attributes, num_attributes, "id");
            std::string extruder_id    = bbs_get_attribute_value_string(attributes, num_attributes, "extruder_id");
            std::string nozzle_diameter= bbs_get_attribute_value_string(attributes, num_attributes, "nozzle_diameter");
            std::string volume_type    = bbs_get_attribute_value_string(attributes, num_attributes, "volume_type");
 
            auto volume_type_str_to_enum = ConfigOptionEnum<NozzleVolumeType>::get_enum_values();
 
            MultiNozzleUtils::NozzleInfo nozzle_info;
            nozzle_info.group_id    = atoi(id.c_str());
            nozzle_info.extruder_id = atoi(extruder_id.c_str()) - 1;
            nozzle_info.diameter    = nozzle_diameter;
 
            if (volume_type_str_to_enum.count(volume_type))
                nozzle_info.volume_type = NozzleVolumeType(volume_type_str_to_enum.at(volume_type));
            else
                nozzle_info.volume_type = NozzleVolumeType::nvtStandard;
 
            m_curr_plater->nozzles_info.push_back(nozzle_info);
        }
        return true;
    }

References _handle_start_config_nozzle(), bbs_get_attribute_value_string(), Slic3r::MultiNozzleUtils::NozzleInfo::diameter, Slic3r::MultiNozzleUtils::NozzleInfo::extruder_id, Slic3r::ConfigOptionEnum< T >::get_enum_values(), Slic3r::MultiNozzleUtils::NozzleInfo::group_id, m_curr_plater, Slic3r::nozzle_diameter(), Slic3r::nvtStandard, and Slic3r::MultiNozzleUtils::NozzleInfo::volume_type.

Referenced by _handle_start_config_nozzle(), and _handle_start_config_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_config_object()

bool Slic3r::_BBS_3MF_Importer::_handle_start_config_object ( const char ** attributes, unsigned int num_attributes )

private

    {
        if (m_parsing_slice_info)
            return true;
        int object_id = bbs_get_attribute_value_int(attributes, num_attributes, ID_ATTR);
        IdToMetadataMap::iterator object_item = m_objects_metadata.find(object_id);
        if (object_item != m_objects_metadata.end()) {
            add_error("Duplicated object id: " + std::to_string(object_id) + " in model_settings.config");
            return false;
        }
 
        // Added because of github #3435, currently not used by PrusaSlicer
        // int instances_count_id = bbs_get_attribute_value_int(attributes, num_attributes, INSTANCESCOUNT_ATTR);
 
        ObjectMetadata metadata;
        if (bbs_get_attribute_value_charptr(attributes, num_attributes, AUTO_DROP_ATTR) != nullptr)
            metadata.auto_drop = bbs_get_attribute_value_bool(attributes, num_attributes, AUTO_DROP_ATTR);
        m_objects_metadata.insert({ object_id, std::move(metadata) });
        m_curr_config.object_id = object_id;
        return true;
    }

References _handle_start_config_object(), Slic3r::_BBS_3MF_Base::add_error(), Slic3r::_BBS_3MF_Importer::ObjectMetadata::auto_drop, AUTO_DROP_ATTR, bbs_get_attribute_value_bool(), bbs_get_attribute_value_charptr(), bbs_get_attribute_value_int(), ID_ATTR, m_curr_config, m_objects_metadata, and m_parsing_slice_info.

Referenced by _handle_start_config_object(), and _handle_start_config_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_config_plater()

bool Slic3r::_BBS_3MF_Importer::_handle_start_config_plater ( const char ** attributes, unsigned int num_attributes )

private

    {
        if (!m_parsing_slice_info) {
            m_curr_plater = new PlateData();
        }
 
        return true;
    }

References _handle_start_config_plater(), m_curr_plater, and m_parsing_slice_info.

Referenced by _handle_start_config_plater(), and _handle_start_config_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_config_plater_instance()

bool Slic3r::_BBS_3MF_Importer::_handle_start_config_plater_instance ( const char ** attributes, unsigned int num_attributes )

private

    {
        if (!m_curr_plater)
        {
            add_error("_handle_start_config_plater_instance: don't find plate created before");
            return false;
        }
 
        //do nothing
        return true;
    }

References _handle_start_config_plater_instance(), Slic3r::_BBS_3MF_Base::add_error(), and m_curr_plater.

Referenced by _handle_start_config_plater_instance(), and _handle_start_config_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_config_volume()

bool Slic3r::_BBS_3MF_Importer::_handle_start_config_volume ( const char ** attributes, unsigned int num_attributes )

private

    {
        IdToMetadataMap::iterator object = m_objects_metadata.find(m_curr_config.object_id);
        if (object == m_objects_metadata.end()) {
            add_error("can not find object for part, id " + std::to_string(m_curr_config.object_id) );
            return false;
        }
 
        m_curr_config.volume_id = (int)object->second.volumes.size();
 
        unsigned int first_triangle_id = (unsigned int)bbs_get_attribute_value_int(attributes, num_attributes, FIRST_TRIANGLE_ID_ATTR);
        unsigned int last_triangle_id = (unsigned int)bbs_get_attribute_value_int(attributes, num_attributes, LAST_TRIANGLE_ID_ATTR);
 
        //BBS: refine the part type logic
        std::string subtype_str = bbs_get_attribute_value_string(attributes, num_attributes, SUBTYPE_ATTR);
        ModelVolumeType type = ModelVolume::type_from_string(subtype_str);
 
        int subbject_id = bbs_get_attribute_value_int(attributes, num_attributes, ID_ATTR);
 
        if (last_triangle_id > 0)
            object->second.volumes.emplace_back(first_triangle_id, last_triangle_id, type);
        else
            object->second.volumes.emplace_back(subbject_id, type);
        return true;
    }

References _handle_start_config_volume(), Slic3r::_BBS_3MF_Base::add_error(), bbs_get_attribute_value_int(), bbs_get_attribute_value_string(), FIRST_TRIANGLE_ID_ATTR, ID_ATTR, LAST_TRIANGLE_ID_ATTR, m_curr_config, m_objects_metadata, SUBTYPE_ATTR, and Slic3r::ModelVolume::type_from_string().

Referenced by _handle_start_config_volume(), and _handle_start_config_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_config_volume_mesh()

bool Slic3r::_BBS_3MF_Importer::_handle_start_config_volume_mesh ( const char ** attributes, unsigned int num_attributes )

private

    {
        IdToMetadataMap::iterator object = m_objects_metadata.find(m_curr_config.object_id);
        if (object == m_objects_metadata.end()) {
            add_error("can not find object for mesh_stats, id " + std::to_string(m_curr_config.object_id) );
            return false;
        }
        if ((m_curr_config.volume_id == -1) || ((object->second.volumes.size() - 1) < m_curr_config.volume_id)) {
            add_error("can not find part for mesh_stats");
            return false;
        }
 
        ObjectMetadata::VolumeMetadata& volume = object->second.volumes[m_curr_config.volume_id];
 
        int edges_fixed         = bbs_get_attribute_value_int(attributes, num_attributes, MESH_STAT_EDGES_FIXED       );
        int degenerate_facets   = bbs_get_attribute_value_int(attributes, num_attributes, MESH_STAT_DEGENERATED_FACETS);
        int facets_removed      = bbs_get_attribute_value_int(attributes, num_attributes, MESH_STAT_FACETS_REMOVED    );
        int facets_reversed     = bbs_get_attribute_value_int(attributes, num_attributes, MESH_STAT_FACETS_RESERVED   );
        int backwards_edges     = bbs_get_attribute_value_int(attributes, num_attributes, MESH_STAT_BACKWARDS_EDGES   );
 
        volume.mesh_stats = { edges_fixed, degenerate_facets, facets_removed, facets_reversed, backwards_edges };
 
        return true;
    }

References _handle_start_config_volume_mesh(), Slic3r::_BBS_3MF_Base::add_error(), bbs_get_attribute_value_int(), m_curr_config, m_objects_metadata, MESH_STAT_BACKWARDS_EDGES, MESH_STAT_DEGENERATED_FACETS, MESH_STAT_EDGES_FIXED, MESH_STAT_FACETS_REMOVED, MESH_STAT_FACETS_RESERVED, and Slic3r::_BBS_3MF_Importer::ObjectMetadata::VolumeMetadata::mesh_stats.

Referenced by _handle_start_config_volume_mesh(), and _handle_start_config_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_config_warning()

bool Slic3r::_BBS_3MF_Importer::_handle_start_config_warning ( const char ** attributes, unsigned int num_attributes )

private

    {
        if (m_curr_plater) {
            std::string msg     = bbs_get_attribute_value_string(attributes, num_attributes, WARNING_MSG_TAG);
            std::string lvl_str = bbs_get_attribute_value_string(attributes, num_attributes, "level");
            GCodeProcessorResult::SliceWarning sw;
            sw.msg = msg;
            try {
                sw.level = atoi(lvl_str.c_str());
            }
            catch(...) {
            };
 
            m_curr_plater->warnings.push_back(sw);
        }
        return true;
    }

References _handle_start_config_warning(), bbs_get_attribute_value_string(), Slic3r::GCodeProcessorResult::SliceWarning::level, m_curr_plater, Slic3r::GCodeProcessorResult::SliceWarning::msg, and WARNING_MSG_TAG.

Referenced by _handle_start_config_warning(), and _handle_start_config_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_config_xml_element() [1/2]

void Slic3r::_BBS_3MF_Importer::_handle_start_config_xml_element ( const char * name, const char ** attributes )

private

    {
        if (m_xml_parser == nullptr)
            return;
 
        bool res = true;
        unsigned int num_attributes = (unsigned int)XML_GetSpecifiedAttributeCount(m_xml_parser);
 
        if (::strcmp(CONFIG_TAG, name) == 0)
            res = _handle_start_config(attributes, num_attributes);
        else if (::strcmp(OBJECT_TAG, name) == 0)
            res = _handle_start_config_object(attributes, num_attributes);
        else if (::strcmp(VOLUME_TAG, name) == 0)
            res = _handle_start_config_volume(attributes, num_attributes);
        else if (::strcmp(PART_TAG, name) == 0)
            res = _handle_start_config_volume(attributes, num_attributes);
        else if (::strcmp(MESH_STAT_TAG, name) == 0)
            res = _handle_start_config_volume_mesh(attributes, num_attributes);
        else if (::strcmp(METADATA_TAG, name) == 0)
            res = _handle_start_config_metadata(attributes, num_attributes);
        else if (::strcmp(SHAPE_TAG, name) == 0)
            res = _handle_start_shape_configuration(attributes, num_attributes);
        else if (::strcmp(TEXT_TAG, name) == 0)
            res = _handle_start_text_configuration(attributes, num_attributes);
        else if (::strcmp(PLATE_TAG, name) == 0)
            res = _handle_start_config_plater(attributes, num_attributes);
        else if (::strcmp(INSTANCE_TAG, name) == 0)
            res = _handle_start_config_plater_instance(attributes, num_attributes);
        else if (::strcmp(FILAMENT_TAG, name) == 0)
            res = _handle_start_config_filament(attributes, num_attributes);
        else if (::strcmp(MIXED_FILAMENT_TAG, name) == 0)
            res = _handle_start_config_mixed_filament(attributes, num_attributes);
        else if (::strcmp(SLICE_WARNING_TAG, name) == 0)
            res = _handle_start_config_warning(attributes, num_attributes);
        else if (::strcmp(NOZZLE_TAG, name) == 0)
            res = _handle_start_config_nozzle(attributes, num_attributes);
        else if (::strcmp(ASSEMBLE_TAG, name) == 0)
            res = _handle_start_assemble(attributes, num_attributes);
        else if (::strcmp(ASSEMBLE_ITEM_TAG, name) == 0)
            res = _handle_start_assemble_item(attributes, num_attributes);
        else if (::strcmp(TEXT_INFO_TAG, name) == 0)
            res = _handle_start_text_info_item(attributes, num_attributes);
 
        if (!res)
            _stop_xml_parser();
    }

References _handle_start_assemble(), _handle_start_assemble_item(), _handle_start_config(), _handle_start_config_filament(), _handle_start_config_metadata(), _handle_start_config_mixed_filament(), _handle_start_config_nozzle(), _handle_start_config_object(), _handle_start_config_plater(), _handle_start_config_plater_instance(), _handle_start_config_volume(), _handle_start_config_volume_mesh(), _handle_start_config_warning(), _handle_start_config_xml_element(), _handle_start_shape_configuration(), _handle_start_text_configuration(), _handle_start_text_info_item(), _stop_xml_parser(), ASSEMBLE_ITEM_TAG, ASSEMBLE_TAG, CONFIG_TAG, FILAMENT_TAG, INSTANCE_TAG, m_xml_parser, MESH_STAT_TAG, METADATA_TAG, MIXED_FILAMENT_TAG, NOZZLE_TAG, OBJECT_TAG, PART_TAG, PLATE_TAG, SHAPE_TAG, SLICE_WARNING_TAG, TEXT_INFO_TAG, TEXT_TAG, and VOLUME_TAG.

Referenced by _handle_start_config_xml_element(), _handle_start_config_xml_element(), and load_gcode_3mf_from_stream().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_config_xml_element() [2/2]

void XMLCALL Slic3r::_BBS_3MF_Importer::_handle_start_config_xml_element ( void * userData, const char * name, const char ** attributes )

staticprivate

    {
        _BBS_3MF_Importer* importer = (_BBS_3MF_Importer*)userData;
        if (importer != nullptr)
            importer->_handle_start_config_xml_element(name, attributes);
    }

References _BBS_3MF_Importer(), and _handle_start_config_xml_element().

Here is the call graph for this function:

_handle_start_item()

bool Slic3r::_BBS_3MF_Importer::_handle_start_item ( const char ** attributes, unsigned int num_attributes )

private

    {
        // we are ignoring the following attributes
        // thumbnail
        // partnumber
        // pid
        // pindex
        // see specifications
 
        int object_id = bbs_get_attribute_value_int(attributes, num_attributes, OBJECTID_ATTR);
        std::string path = bbs_get_attribute_value_string(attributes, num_attributes, PPATH_ATTR);
        Transform3d transform = bbs_get_transform_from_3mf_specs_string(bbs_get_attribute_value_string(attributes, num_attributes, TRANSFORM_ATTR));
        int printable = bbs_get_attribute_value_bool(attributes, num_attributes, PRINTABLE_ATTR);
        if (const char* auto_drop = bbs_get_attribute_value_charptr(attributes, num_attributes, AUTO_DROP_ATTR); auto_drop != nullptr && !::atoi(auto_drop))
            m_items_auto_drop_off.insert(object_id);
        return !m_load_model || _create_object_instance(path, object_id, transform, printable, 1);
    }

References _create_object_instance(), _handle_start_item(), AUTO_DROP_ATTR, bbs_get_attribute_value_bool(), bbs_get_attribute_value_charptr(), bbs_get_attribute_value_int(), bbs_get_attribute_value_string(), bbs_get_transform_from_3mf_specs_string(), m_items_auto_drop_off, m_load_model, OBJECTID_ATTR, PPATH_ATTR, PRINTABLE_ATTR, Slic3r::transform(), and TRANSFORM_ATTR.

Referenced by _handle_start_item(), and _handle_start_model_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_mesh()

bool Slic3r::_BBS_3MF_Importer::_handle_start_mesh ( const char ** attributes, unsigned int num_attributes )

private

    {
        // reset current geometry
        if (m_curr_object)
            m_curr_object->geometry.reset();
        return true;
    }

References _handle_start_mesh(), and m_curr_object.

Referenced by _handle_start_mesh(), and _handle_start_model_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_metadata()

bool Slic3r::_BBS_3MF_Importer::_handle_start_metadata ( const char ** attributes, unsigned int num_attributes )

private

    {
        m_curr_characters.clear();
 
        std::string name = bbs_get_attribute_value_string(attributes, num_attributes, NAME_ATTR);
        if (!name.empty()) {
            m_curr_metadata_name = name;
        }
 
        return true;
    }

References _handle_start_metadata(), bbs_get_attribute_value_string(), m_curr_characters, m_curr_metadata_name, and NAME_ATTR.

Referenced by _handle_start_metadata(), and _handle_start_model_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_model()

bool Slic3r::_BBS_3MF_Importer::_handle_start_model ( const char ** attributes, unsigned int num_attributes )

private

    {
        m_unit_factor = bbs_get_unit_factor(bbs_get_attribute_value_string(attributes, num_attributes, UNIT_ATTR));
 
        return true;
    }

References _handle_start_model(), bbs_get_attribute_value_string(), bbs_get_unit_factor(), m_unit_factor, and UNIT_ATTR.

Referenced by _handle_start_model(), and _handle_start_model_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_model_xml_element() [1/2]

void Slic3r::_BBS_3MF_Importer::_handle_start_model_xml_element ( const char * name, const char ** attributes )

private

    {
        if (m_xml_parser == nullptr)
            return;
 
        bool res = true;
        unsigned int num_attributes = (unsigned int)XML_GetSpecifiedAttributeCount(m_xml_parser);
 
        if (::strcmp(MODEL_TAG, name) == 0)
            res = _handle_start_model(attributes, num_attributes);
        else if (::strcmp(RESOURCES_TAG, name) == 0)
            res = _handle_start_resources(attributes, num_attributes);
        else if (::strcmp(OBJECT_TAG, name) == 0)
            res = _handle_start_object(attributes, num_attributes);
        else if (::strcmp(COLOR_GROUP_TAG, name) == 0)
            res = _handle_start_color_group(attributes, num_attributes);
        else if (::strcmp(COLOR_TAG, name) == 0)
            res = _handle_start_color(attributes, num_attributes);
        else if (::strcmp(MESH_TAG, name) == 0)
            res = _handle_start_mesh(attributes, num_attributes);
        else if (::strcmp(VERTICES_TAG, name) == 0)
            res = _handle_start_vertices(attributes, num_attributes);
        else if (::strcmp(VERTEX_TAG, name) == 0)
            res = _handle_start_vertex(attributes, num_attributes);
        else if (::strcmp(TRIANGLES_TAG, name) == 0)
            res = _handle_start_triangles(attributes, num_attributes);
        else if (::strcmp(TRIANGLE_TAG, name) == 0)
            res = _handle_start_triangle(attributes, num_attributes);
        else if (::strcmp(COMPONENTS_TAG, name) == 0)
            res = _handle_start_components(attributes, num_attributes);
        else if (::strcmp(COMPONENT_TAG, name) == 0)
            res = _handle_start_component(attributes, num_attributes);
        else if (::strcmp(BUILD_TAG, name) == 0)
            res = _handle_start_build(attributes, num_attributes);
        else if (::strcmp(ITEM_TAG, name) == 0)
            res = _handle_start_item(attributes, num_attributes);
        else if (::strcmp(METADATA_TAG, name) == 0)
            res = _handle_start_metadata(attributes, num_attributes);
 
        if (!res)
            _stop_xml_parser();
    }

References _handle_start_build(), _handle_start_color(), _handle_start_color_group(), _handle_start_component(), _handle_start_components(), _handle_start_item(), _handle_start_mesh(), _handle_start_metadata(), _handle_start_model(), _handle_start_model_xml_element(), _handle_start_object(), _handle_start_resources(), _handle_start_triangle(), _handle_start_triangles(), _handle_start_vertex(), _handle_start_vertices(), _stop_xml_parser(), BUILD_TAG, COLOR_GROUP_TAG, COLOR_TAG, COMPONENT_TAG, COMPONENTS_TAG, ITEM_TAG, m_xml_parser, MESH_TAG, METADATA_TAG, MODEL_TAG, OBJECT_TAG, RESOURCES_TAG, TRIANGLE_TAG, TRIANGLES_TAG, VERTEX_TAG, and VERTICES_TAG.

Referenced by _extract_model_from_archive(), _handle_start_model_xml_element(), and _handle_start_model_xml_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_model_xml_element() [2/2]

void XMLCALL Slic3r::_BBS_3MF_Importer::_handle_start_model_xml_element ( void * userData, const char * name, const char ** attributes )

staticprivate

    {
        _BBS_3MF_Importer* importer = (_BBS_3MF_Importer*)userData;
        if (importer != nullptr)
            importer->_handle_start_model_xml_element(name, attributes);
    }

References _BBS_3MF_Importer(), and _handle_start_model_xml_element().

Here is the call graph for this function:

_handle_start_object()

bool Slic3r::_BBS_3MF_Importer::_handle_start_object ( const char ** attributes, unsigned int num_attributes )

private

    {
        // reset current object data
        if (m_curr_object) {
            delete m_curr_object;
            m_curr_object = nullptr;
        }
 
        std::string object_type = bbs_get_attribute_value_string(attributes, num_attributes, TYPE_ATTR);
 
        if (bbs_is_valid_object_type(object_type)) {
            if (!m_curr_object) {
                m_curr_object = new CurrentObject();
                // create new object (it may be removed later if no instances are generated from it)
                /*m_curr_object->model_object_idx = (int)m_model->objects.size();
                m_curr_object.object = m_model->add_object();
                if (m_curr_object.object == nullptr) {
                    add_error("Unable to create object");
                    return false;
                }*/
            }
 
            m_curr_object->id = bbs_get_attribute_value_int(attributes, num_attributes, ID_ATTR);
            m_curr_object->name = bbs_get_attribute_value_string(attributes, num_attributes, NAME_ATTR);
 
            m_curr_object->uuid = bbs_get_attribute_value_string(attributes, num_attributes, PUUID_ATTR);
            if (m_curr_object->uuid.empty()) {
                m_curr_object->uuid = bbs_get_attribute_value_string(attributes, num_attributes, PUUID_LOWER_ATTR);
            }
            m_curr_object->pid = bbs_get_attribute_value_int(attributes, num_attributes, PID_ATTR);
        }
 
        return true;
    }

References _handle_start_object(), bbs_get_attribute_value_int(), bbs_get_attribute_value_string(), bbs_is_valid_object_type(), ID_ATTR, m_curr_object, NAME_ATTR, PID_ATTR, PUUID_ATTR, PUUID_LOWER_ATTR, and TYPE_ATTR.

Referenced by _handle_start_model_xml_element(), and _handle_start_object().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_relationship()

bool Slic3r::_BBS_3MF_Importer::_handle_start_relationship ( const char ** attributes, unsigned int num_attributes )

private

    {
        std::string path = bbs_get_attribute_value_string(attributes, num_attributes, TARGET_ATTR);
        std::string type = bbs_get_attribute_value_string(attributes, num_attributes, RELS_TYPE_ATTR);
        if (boost::starts_with(type, "http://schemas.microsoft.com/3dmanufacturing/") && boost::ends_with(type, "3dmodel")) {
            if (m_start_part_path.empty()) m_start_part_path = path;
            else m_sub_model_paths.push_back(path);
        } else if (boost::starts_with(type, "http://schemas.openxmlformats.org/") && boost::ends_with(type, "thumbnail")) {
            if (boost::algorithm::ends_with(path, ".png"))
                m_thumbnail_path = path;
        } else if (boost::starts_with(type, "http://schemas.bambulab.com/") && boost::ends_with(type, "cover-thumbnail-middle")) {
            m_thumbnail_middle = path;
        } else if (boost::starts_with(type, "http://schemas.bambulab.com/") && boost::ends_with(type, "cover-thumbnail-small")) {
            m_thumbnail_small = path;
        }
        return true;
    }

References _handle_start_relationship(), bbs_get_attribute_value_string(), m_start_part_path, m_sub_model_paths, m_thumbnail_middle, m_thumbnail_path, m_thumbnail_small, RELS_TYPE_ATTR, and TARGET_ATTR.

Referenced by _handle_start_relationship(), and _handle_start_relationships_element().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_relationships_element() [1/2]

void Slic3r::_BBS_3MF_Importer::_handle_start_relationships_element ( const char * name, const char ** attributes )

private

    {
        if (m_xml_parser == nullptr)
            return;
 
        bool res = true;
        unsigned int num_attributes = (unsigned int)XML_GetSpecifiedAttributeCount(m_xml_parser);
 
        if (::strcmp(RELATIONSHIP_TAG, name) == 0)
            res = _handle_start_relationship(attributes, num_attributes);
 
        m_curr_characters.clear();
        if (!res)
            _stop_xml_parser();
    }

References _handle_start_relationship(), _handle_start_relationships_element(), _stop_xml_parser(), m_curr_characters, m_xml_parser, and RELATIONSHIP_TAG.

Here is the call graph for this function:

_handle_start_relationships_element() [2/2]

void XMLCALL Slic3r::_BBS_3MF_Importer::_handle_start_relationships_element ( void * userData, const char * name, const char ** attributes )

staticprivate

    {
        _BBS_3MF_Importer* importer = (_BBS_3MF_Importer*)userData;
        if (importer != nullptr)
            importer->_handle_start_relationships_element(name, attributes);
    }

References _BBS_3MF_Importer(), and _handle_start_relationships_element().

Referenced by _handle_start_relationships_element(), _handle_start_relationships_element(), _load_model_from_file(), get_thumbnail(), and load_gcode_3mf_from_stream().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_resources()

bool Slic3r::_BBS_3MF_Importer::_handle_start_resources ( const char ** attributes, unsigned int num_attributes )

private

    {
        // do nothing
        return true;
    }

References _handle_start_resources().

Referenced by _handle_start_model_xml_element(), and _handle_start_resources().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_shape_configuration()

bool Slic3r::_BBS_3MF_Importer::_handle_start_shape_configuration ( const char ** attributes, unsigned int num_attributes )

private

    {
        IdToMetadataMap::iterator object = m_objects_metadata.find(m_curr_config.object_id);
        if (object == m_objects_metadata.end()) {
            add_error("Can not assign volume mesh to a valid object");
            return false;
        }
        auto &volumes = object->second.volumes;
        if (volumes.empty()) {
            add_error("Can not assign mesh to a valid volume");
            return false;
        }
        ObjectMetadata::VolumeMetadata &volume = volumes.back();
        volume.shape_configuration = read_emboss_shape(attributes, num_attributes);
        if (!volume.shape_configuration.has_value())
            return false;
 
        // Fill svg file content into shape_configuration
        std::optional<EmbossShape::SvgFile> &svg = volume.shape_configuration->svg_file;
        if (!svg.has_value())
            return true; // do not contain svg file
 
        const std::string &path = svg->path_in_3mf;
        if (path.empty()) 
            return true; // do not contain svg file
 
        auto it = m_path_to_emboss_shape_files.find(path);
        if (it == m_path_to_emboss_shape_files.end())
            return true; // svg file is not loaded yet
 
        svg->file_data = it->second;
        return true;
    }

References _handle_start_shape_configuration(), Slic3r::_BBS_3MF_Base::add_error(), m_curr_config, m_objects_metadata, m_path_to_emboss_shape_files, Slic3r::read_emboss_shape(), and Slic3r::_BBS_3MF_Importer::ObjectMetadata::VolumeMetadata::shape_configuration.

Referenced by _handle_start_config_xml_element(), and _handle_start_shape_configuration().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_text_configuration()

bool Slic3r::_BBS_3MF_Importer::_handle_start_text_configuration ( const char ** attributes, unsigned int num_attributes )

private

    {
        IdToMetadataMap::iterator object = m_objects_metadata.find(m_curr_config.object_id);
        if (object == m_objects_metadata.end()) {
            add_error("Can not assign volume mesh to a valid object");
            return false;
        }
        if (object->second.volumes.empty()) {
            add_error("Can not assign mesh to a valid volume");
            return false;
        }
        ObjectMetadata::VolumeMetadata& volume = object->second.volumes.back();
        volume.text_configuration = TextConfigurationSerialization::read(attributes, num_attributes);
        if (!volume.text_configuration.has_value())
            return false;
 
        // Is 3mf version with shapes?
        if (volume.shape_configuration.has_value())
            return true;
 
        // Back compatibility for 3mf version without shapes
        volume.shape_configuration = TextConfigurationSerialization::read_old(attributes, num_attributes);
        return true;
    }

References _handle_start_text_configuration(), Slic3r::_BBS_3MF_Base::add_error(), m_curr_config, m_objects_metadata, Slic3r::TextConfigurationSerialization::read(), Slic3r::TextConfigurationSerialization::read_old(), Slic3r::_BBS_3MF_Importer::ObjectMetadata::VolumeMetadata::shape_configuration, and Slic3r::_BBS_3MF_Importer::ObjectMetadata::VolumeMetadata::text_configuration.

Referenced by _handle_start_config_xml_element(), and _handle_start_text_configuration().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_text_info_item()

bool Slic3r::_BBS_3MF_Importer::_handle_start_text_info_item ( const char ** attributes, unsigned int num_attributes )

private

    {
        IdToMetadataMap::iterator object = m_objects_metadata.find(m_curr_config.object_id);
        if (object == m_objects_metadata.end()) {
            add_error("can not find object for text_info, id " + std::to_string(m_curr_config.object_id));
            return false;
        }
        if ((m_curr_config.volume_id == -1) || ((object->second.volumes.size() - 1) < m_curr_config.volume_id)) {
            add_error("can not find part for text_info");
            return false;
        }
 
        ObjectMetadata::VolumeMetadata &volume = object->second.volumes[m_curr_config.volume_id];
 
        if (volume.text_configuration.has_value()) {
            add_error("Both text_info and text_configuration found, ignore legacy text_info");
            return true;
        }
 
        // TODO: Orca: support legacy text info
        /*
        TextInfo text_info;
        text_info.m_text      = xml_unescape(bbs_get_attribute_value_string(attributes, num_attributes, TEXT_ATTR));
        text_info.m_font_name = bbs_get_attribute_value_string(attributes, num_attributes, FONT_NAME_ATTR);
 
        text_info.m_curr_font_idx = bbs_get_attribute_value_int(attributes, num_attributes, FONT_INDEX_ATTR);
 
        text_info.m_font_size = bbs_get_attribute_value_float(attributes, num_attributes, FONT_SIZE_ATTR);
        text_info.m_thickness = bbs_get_attribute_value_float(attributes, num_attributes, THICKNESS_ATTR);
        text_info.m_embeded_depth = bbs_get_attribute_value_float(attributes, num_attributes, EMBEDED_DEPTH_ATTR);
        text_info.m_rotate_angle  = bbs_get_attribute_value_float(attributes, num_attributes, ROTATE_ANGLE_ATTR);
        text_info.m_text_gap      = bbs_get_attribute_value_float(attributes, num_attributes, TEXT_GAP_ATTR);
 
        text_info.m_bold      = bbs_get_attribute_value_int(attributes, num_attributes, BOLD_ATTR);
        text_info.m_italic    = bbs_get_attribute_value_int(attributes, num_attributes, ITALIC_ATTR);
        text_info.m_is_surface_text = bbs_get_attribute_value_int(attributes, num_attributes, SURFACE_TEXT_ATTR);
        text_info.m_keep_horizontal = bbs_get_attribute_value_int(attributes, num_attributes, KEEP_HORIZONTAL_ATTR);
 
        text_info.m_rr.mesh_id = bbs_get_attribute_value_int(attributes, num_attributes, HIT_MESH_ATTR);
 
        std::string hit_pos = bbs_get_attribute_value_string(attributes, num_attributes, HIT_POSITION_ATTR);
        if (!hit_pos.empty())
            text_info.m_rr.hit = get_vec3_from_string(hit_pos);
 
        std::string hit_normal = bbs_get_attribute_value_string(attributes, num_attributes, HIT_NORMAL_ATTR);
        if (!hit_normal.empty())
            text_info.m_rr.normal = get_vec3_from_string(hit_normal);
 
        volume.text_info = text_info;*/
        return true;
    }

References _handle_start_text_info_item(), Slic3r::_BBS_3MF_Base::add_error(), m_curr_config, m_objects_metadata, and Slic3r::_BBS_3MF_Importer::ObjectMetadata::VolumeMetadata::text_configuration.

Referenced by _handle_start_config_xml_element(), and _handle_start_text_info_item().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_triangle()

bool Slic3r::_BBS_3MF_Importer::_handle_start_triangle ( const char ** attributes, unsigned int num_attributes )

private

    {
        // we are ignoring the following attributes:
        // p1
        // p2
        // p3
        // pid
        // see specifications
 
        // appends the triangle's vertices indices
        // missing values are set equal to ZERO
        if (m_curr_object) {
            m_curr_object->geometry.triangles.emplace_back(
                bbs_get_attribute_value_int(attributes, num_attributes, V1_ATTR),
                bbs_get_attribute_value_int(attributes, num_attributes, V2_ATTR),
                bbs_get_attribute_value_int(attributes, num_attributes, V3_ATTR));
 
            m_curr_object->geometry.custom_supports.push_back(bbs_get_attribute_value_string(attributes, num_attributes, CUSTOM_SUPPORTS_ATTR));
            m_curr_object->geometry.custom_seam.push_back(bbs_get_attribute_value_string(attributes, num_attributes, CUSTOM_SEAM_ATTR));
            m_curr_object->geometry.mmu_segmentation.push_back(bbs_get_attribute_value_string(attributes, num_attributes, MMU_SEGMENTATION_ATTR));
            m_curr_object->geometry.fuzzy_skin.push_back(bbs_get_attribute_value_string(attributes, num_attributes, CUSTOM_FUZZY_SKIN_ATTR));
            for (int slot = 0; slot < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++slot)
                if (const char *paint = bbs_get_attribute_value_charptr(attributes, num_attributes, TEXTURE_DISPLACEMENT_ATTRS[slot])) {
                    std::vector<std::string> &mask = m_curr_object->geometry.texture_displacement[slot];
                    mask.resize(m_curr_object->geometry.triangles.size());
                    mask.back() = paint;
                }
            // BBS
            m_curr_object->geometry.face_properties.push_back(bbs_get_attribute_value_string(attributes, num_attributes, FACE_PROPERTY_ATTR));
        }
        return true;
    }

References _handle_start_triangle(), bbs_get_attribute_value_charptr(), bbs_get_attribute_value_int(), bbs_get_attribute_value_string(), CUSTOM_FUZZY_SKIN_ATTR, CUSTOM_SEAM_ATTR, CUSTOM_SUPPORTS_ATTR, FACE_PROPERTY_ATTR, m_curr_object, MMU_SEGMENTATION_ATTR, TEXTURE_DISPLACEMENT_ATTRS, Slic3r::TEXTURE_DISPLACEMENT_MAX_LAYERS, V1_ATTR, V2_ATTR, and V3_ATTR.

Referenced by _handle_start_model_xml_element(), and _handle_start_triangle().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_triangles()

bool Slic3r::_BBS_3MF_Importer::_handle_start_triangles ( const char ** attributes, unsigned int num_attributes )

private

    {
        // reset current triangles
        if (m_curr_object)
            m_curr_object->geometry.triangles.clear();
        return true;
    }

References _handle_start_triangles(), and m_curr_object.

Referenced by _handle_start_model_xml_element(), and _handle_start_triangles().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_vertex()

bool Slic3r::_BBS_3MF_Importer::_handle_start_vertex ( const char ** attributes, unsigned int num_attributes )

private

    {
        // appends the vertex coordinates
        // missing values are set equal to ZERO
        if (m_curr_object) {
            const Vec3f v(m_unit_factor * bbs_get_attribute_value_float(attributes, num_attributes, X_ATTR),
                          m_unit_factor * bbs_get_attribute_value_float(attributes, num_attributes, Y_ATTR),
                          m_unit_factor * bbs_get_attribute_value_float(attributes, num_attributes, Z_ATTR));
            // A non-finite coordinate ("nan", "inf") used to be accepted and crashed
            // qhull in ModelVolume's convex hull while the file was still loading. Refuse the file.
            if (! v.allFinite()) {
                _stop_xml_parser("Invalid vertex coordinate: not a finite number");
                return true;   // the parser is stopped; returning false would overwrite the message
            }
            m_curr_object->geometry.vertices.emplace_back(v);
        }
        return true;
    }

References _handle_start_vertex(), _stop_xml_parser(), bbs_get_attribute_value_float(), m_curr_object, m_unit_factor, X_ATTR, Y_ATTR, and Z_ATTR.

Referenced by _handle_start_model_xml_element(), and _handle_start_vertex().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_start_vertices()

bool Slic3r::_BBS_3MF_Importer::_handle_start_vertices ( const char ** attributes, unsigned int num_attributes )

private

    {
        // reset current vertices
        if (m_curr_object)
            m_curr_object->geometry.vertices.clear();
        return true;
    }

References _handle_start_vertices(), and m_curr_object.

Referenced by _handle_start_model_xml_element(), and _handle_start_vertices().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_xml_characters() [1/2]

void Slic3r::_BBS_3MF_Importer::_handle_xml_characters ( const XML_Char * s, int len )

private

    {
        m_curr_characters.append(s, len);
    }

References _handle_xml_characters(), and m_curr_characters.

Referenced by _extract_model_from_archive(), _extract_xml_from_archive(), _handle_xml_characters(), and _handle_xml_characters().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_xml_characters() [2/2]

void XMLCALL Slic3r::_BBS_3MF_Importer::_handle_xml_characters ( void * userData, const XML_Char * s, int len )

staticprivate

    {
        _BBS_3MF_Importer* importer = (_BBS_3MF_Importer*)userData;
        if (importer != nullptr)
            importer->_handle_xml_characters(s, len);
    }

References _BBS_3MF_Importer(), and _handle_xml_characters().

Here is the call graph for this function:

_is_published_3mf()

bool Slic3r::_BBS_3MF_Importer::_is_published_3mf ( ) const

inlineprivate

                                       {
            const auto it = this->model_info.metadata_items.find(ORCA_PUBLISHED_TAG);
            return it != this->model_info.metadata_items.end() && is_published_3mf_flag(it->second);
        }

References Slic3r::is_published_3mf_flag(), Slic3r::ModelInfo::metadata_items, and Slic3r::ORCA_PUBLISHED_TAG.

Referenced by _handle_end_model().

Here is the call graph for this function:

Here is the caller graph for this function:

_is_svg_shape_file()

bool Slic3r::_BBS_3MF_Importer::_is_svg_shape_file ( const std::string & filename ) const

private

                                                                          { 
        return boost::starts_with(name, MODEL_FOLDER) && boost::ends_with(name, ".svg");
    }

References _is_svg_shape_file(), and MODEL_FOLDER.

Referenced by _is_svg_shape_file().

Here is the call graph for this function:

Here is the caller graph for this function:

_load_model_from_file()

bool Slic3r::_BBS_3MF_Importer::_load_model_from_file ( std::string filename, Model & model, PlateDataPtrs & plate_data_list, std::vector< Preset * > & project_presets, DynamicPrintConfig & config, ConfigSubstitutionContext & config_substitutions, Import3mfProgressFn proFn = nullptr, BBLProject * project = nullptr, int plate_id = 0 )

private

    {
        bool cb_cancel = false;
        //BBS progress point
        // prepare restore
        if (m_load_restore) {
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" << __LINE__ << boost::format("import 3mf IMPORT_STAGE_RESTORE\n");
            if (proFn) {
                proFn(IMPORT_STAGE_RESTORE, 0, 1, cb_cancel);
                if (cb_cancel)
                    return false;
            }
        }
 
        //BBS progress point
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" << __LINE__ << boost::format("import 3mf IMPORT_STAGE_OPEN, m_load_restore=%1%\n")%m_load_restore;
        if (proFn) {
            proFn(IMPORT_STAGE_OPEN, 0, 1, cb_cancel);
            if (cb_cancel)
                return false;
        }
 
        mz_zip_archive archive;
        mz_zip_zero_struct(&archive);
 
        struct close_lock
        {
            mz_zip_archive * archive;
            void close() {
                if (archive) {
                    close_zip_reader(archive);
                    archive = nullptr;
                }
            }
            ~close_lock() {
                close();
            }
        } lock{ &archive };
 
        if (!open_zip_reader(&archive, filename)) {
            add_error("Unable to open the file"+filename);
            return false;
        }
 
        mz_uint num_entries = mz_zip_reader_get_num_files(&archive);
 
        mz_zip_archive_file_stat stat;
 
        m_name = boost::filesystem::path(filename).stem().string();
 
        //BBS progress point
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" << __LINE__ << boost::format("import 3mf IMPORT_STAGE_READ_FILES\n");
        if (proFn) {
            proFn(IMPORT_STAGE_READ_FILES, 0, 3, cb_cancel);
            if (cb_cancel)
                return false;
        }
        // BBS: load relationships
        if (!_extract_xml_from_archive(archive, RELATIONSHIPS_FILE, _handle_start_relationships_element, _handle_end_relationships_element))
            return false;
        if (m_start_part_path.empty())
            return false;
        // BBS: load sub models (Production Extension)
        std::string sub_rels = m_start_part_path;
        sub_rels.insert(boost::find_last(sub_rels, "/").end() - sub_rels.begin(), "_rels/");
        sub_rels.append(".rels");
        if (sub_rels.front() == '/') sub_rels = sub_rels.substr(1);
 
        //check whether sub relation file is exist or not
        int sub_index = mz_zip_reader_locate_file(&archive, sub_rels.c_str(), nullptr, 0);
        if (sub_index == -1) {
            //no submodule files found, use only one 3dmodel.model
        }
        else {
            _extract_xml_from_archive(archive, sub_rels, _handle_start_relationships_element, _handle_end_relationships_element);
            int index = 0;
 
#if 0
            for (auto path : m_sub_model_paths) {
                if (proFn) {
                    proFn(IMPORT_STAGE_READ_FILES, ++index, 3 + m_sub_model_paths.size(), cb_cancel);
                    if (cb_cancel)
                        return false;
                }
                else
                    ++index;
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" << __LINE__ << boost::format(", read %1%th sub model file %2%\n")%index %path;
                m_sub_model_path = path;
                if (!_extract_from_archive(archive, path, [this] (mz_zip_archive& archive, const mz_zip_archive_file_stat& stat) {
                    return _extract_model_from_archive(archive, stat);
                }, m_load_restore)) {
                    add_error("Archive does not contain a valid model");
                    return false;
                }
                m_sub_model_path.clear();
            }
#else
            for (auto path : m_sub_model_paths) {
                ObjectImporter *object_importer = new ObjectImporter(this, filename, path);
                m_object_importers.push_back(object_importer);
            }
 
            bool object_load_result = true;
            boost::mutex mutex;
            tbb::parallel_for(
                tbb::blocked_range<size_t>(0, m_object_importers.size()),
                [this, &mutex, &object_load_result](const tbb::blocked_range<size_t>& importer_range) {
                    CNumericLocalesSetter locales_setter;
                    for (size_t object_index = importer_range.begin(); object_index < importer_range.end(); ++ object_index) {
                        bool result = m_object_importers[object_index]->extract_object_model();
                        {
                            boost::unique_lock l(mutex);
                            object_load_result &= result;
                        }
                    }
                }
            );
 
            if (!object_load_result) {
                BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", loading sub-objects error\n");
                return false;
            }
 
            //merge these objects into one
            for (auto obj_importer : m_object_importers) {
                for (const IdToCurrentObjectMap::value_type&  obj : obj_importer->object_list)
                    m_current_objects.insert({ std::move(obj.first), std::move(obj.second)});
                for (auto group_color : obj_importer->object_group_id_to_color)
                    m_group_id_to_color.insert(std::move(group_color));
 
                delete obj_importer;
            }
            m_object_importers.clear();
#endif
            // BBS: load root model
            if (proFn) {
                proFn(IMPORT_STAGE_READ_FILES, 2, 3, cb_cancel);
                if (cb_cancel)
                    return false;
            }
        }
 
        //extract model files
        if (!_extract_from_archive(archive, m_start_part_path, [this] (mz_zip_archive& archive, const mz_zip_archive_file_stat& stat) {
                    return _extract_model_from_archive(archive, stat);
            })) {
            add_error("Archive does not contain a valid model");
            return false;
        }
 
        if (!m_designer.empty()) {
            m_model->design_info = std::make_shared<ModelDesignInfo>();
            m_model->design_info->DesignerUserId = m_designer_user_id;
            m_model->design_info->Designer = m_designer;
        }
 
        m_model->profile_info = std::make_shared<ModelProfileInfo>();
        m_model->profile_info->ProfileTile = m_profile_title;
        m_model->profile_info->ProfileCover = m_profile_cover;
        m_model->profile_info->ProfileDescription = m_Profile_description;
        m_model->profile_info->ProfileUserId = m_profile_user_id;
        m_model->profile_info->ProfileUserName = m_profile_user_name;
 
 
        m_model->model_info = std::make_shared<ModelInfo>();
        m_model->model_info->load(model_info);
        if (!m_thumbnail_small.empty()) m_model->model_info->metadata_items.emplace("Thumbnail_Small", m_thumbnail_small);
        if (!m_thumbnail_middle.empty()) m_model->model_info->metadata_items.emplace("Thumbnail_Middle", m_thumbnail_middle);
 
        //got project id
        if (project) {
            project->project_model_id = m_model_id;
            project->project_country_code = m_contry_code;
        }
 
        // Orca: skip version check
        bool dont_load_config = !m_load_config;
        // if (m_bambuslicer_generator_version) {
        //     Semver app_version = *(Semver::parse(SoftFever_VERSION));
        //     Semver file_version = *m_bambuslicer_generator_version;
        //     if (file_version.maj() != app_version.maj())
        //         dont_load_config = true;
        // }
        // else {
        //     m_bambuslicer_generator_version = Semver::parse("0.0.0.0");
        //     dont_load_config = true;
        // }
 
        // we then loop again the entries to read other files stored in the archive
        for (mz_uint i = 0; i < num_entries; ++i) {
            if (mz_zip_reader_file_stat(&archive, i, &stat)) {
 
                //BBS progress point
                if (proFn) {
                    proFn(IMPORT_STAGE_EXTRACT, i, num_entries, cb_cancel);
                    if (cb_cancel)
                        return false;
                }
 
                std::string name(stat.m_filename);
                std::replace(name.begin(), name.end(), '\\', '/');
 
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" << __LINE__ << boost::format("extract %1%th file %2%, total=%3%")%(i+1)%name%num_entries;
 
                if (name.find("/../") != std::string::npos ||
                    name.find("../") == 0 ||
                    (name.length() >= 3 && name.compare(name.length() - 3, 3, "/..") == 0) ||
                    name == "..") {
                    BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(", find file path including path traversal, not valid, skip it\n");
                    continue;
                }
 
                if (boost::algorithm::iequals(name, BBS_LAYER_HEIGHTS_PROFILE_FILE)) {
                    // extract slic3r layer heights profile file
                    _extract_layer_heights_profile_config_from_archive(archive, stat);
                }
                else
                if (boost::algorithm::iequals(name, LAYER_CONFIG_RANGES_FILE)) {
                    // extract slic3r layer config ranges file
                    _extract_layer_config_ranges_from_archive(archive, stat, config_substitutions);
                }
                else if (boost::algorithm::iequals(name, BRIM_EAR_POINTS_FILE)) {
                    // extract slic3r config file
                    _extract_brim_ear_points_from_archive(archive, stat);
                }
                //BBS: disable SLA related files currently
                /*else if (boost::algorithm::iequals(name, SLA_SUPPORT_POINTS_FILE)) {
                    // extract sla support points file
                    _extract_sla_support_points_from_archive(archive, stat);
                }
                else if (boost::algorithm::iequals(name, SLA_DRAIN_HOLES_FILE)) {
                    // extract sla support points file
                    _extract_sla_drain_holes_from_archive(archive, stat);
                }*/
                //BBS: project setting file
                //if (!dont_load_config && boost::algorithm::iequals(name, BBS_PRINT_CONFIG_FILE)) {
                    // extract slic3r print config file
                //    _extract_print_config_from_archive(archive, stat, config, config_substitutions, filename);
                //} else
                if (!dont_load_config && boost::algorithm::iequals(name, BBS_PROJECT_CONFIG_FILE)) {
                    // extract slic3r print config file
                    _extract_project_config_from_archive(archive, stat, config, config_substitutions, model);
                }
                else if (boost::algorithm::iequals(name, ORCA_CAD_RECIPE_FILE)
                      || boost::algorithm::iequals(name, LEGACY_CAD_RECIPE_FILE)) {
                    // Restore the editable CAD recipe (optional; absent in non-CAD projects).
                    // The current name wins over the legacy one whichever the archive lists
                    // first, and the size the archive claims is capped before it is allocated.
                    constexpr mz_uint64 kMaxCadRecipe = mz_uint64(1) << 30;   // 1 GiB
                    const bool legacy = boost::algorithm::iequals(name, LEGACY_CAD_RECIPE_FILE);
                    if (stat.m_uncomp_size > kMaxCadRecipe) {
                        BOOST_LOG_TRIVIAL(error) << "3MF: CAD recipe of " << stat.m_uncomp_size
                                                 << " bytes exceeds the limit; not loaded";
                    } else if (stat.m_uncomp_size > 0 && !(legacy && !model.cad_recipe.empty())) {
                        std::string buf((size_t)stat.m_uncomp_size, '\0');
                        if (mz_zip_reader_extract_to_mem(&archive, stat.m_file_index, buf.data(), buf.size(), 0))
                            model.cad_recipe = std::move(buf);
                    }
                }
                else if (boost::algorithm::iequals(name, CUT_INFORMATION_FILE)) {
                    // extract object cut info
                    _extract_cut_information_from_archive(archive, stat, config_substitutions);
                }
                //BBS: project embedded presets
                else if (!dont_load_config && boost::algorithm::istarts_with(name, PROJECT_EMBEDDED_PRINT_PRESETS_FILE)) {
                    // extract slic3r layer config ranges file
                    _extract_project_embedded_presets_from_archive(archive, stat, project_presets, model, Preset::TYPE_PRINT, false);
                }
                else if (!dont_load_config && boost::algorithm::istarts_with(name, PROJECT_EMBEDDED_SLICE_PRESETS_FILE)) {
                    // extract slic3r layer config ranges file
                    _extract_project_embedded_presets_from_archive(archive, stat, project_presets, model, Preset::TYPE_PRINT);
                }
                else if (!dont_load_config && boost::algorithm::istarts_with(name, PROJECT_EMBEDDED_FILAMENT_PRESETS_FILE)) {
                    // extract slic3r layer config ranges file
                    _extract_project_embedded_presets_from_archive(archive, stat, project_presets, model, Preset::TYPE_FILAMENT);
                }
                else if (!dont_load_config && boost::algorithm::istarts_with(name, PROJECT_EMBEDDED_PRINTER_PRESETS_FILE)) {
                    // extract slic3r layer config ranges file
                    _extract_project_embedded_presets_from_archive(archive, stat, project_presets, model, Preset::TYPE_PRINTER);
                }
                else if (!dont_load_config && boost::algorithm::iequals(name, CUSTOM_GCODE_PER_PRINT_Z_FILE)) {
                    // extract slic3r layer config ranges file
                    _extract_custom_gcode_per_print_z_from_archive(archive, stat);
                }
                else if (boost::algorithm::iequals(name, BBS_MODEL_CONFIG_FILE)) {
                    // extract slic3r model config file
                    if (!_extract_xml_from_archive(archive, stat, _handle_start_config_xml_element, _handle_end_config_xml_element)) {
                        if (m_is_bbl_3mf) {
                            add_error("Archive does not contain a valid model config");
                            return false;
                        }
                    }
                }
                else if (_is_svg_shape_file(name)) {
                    _extract_embossed_svg_shape_file(name, archive, stat);
                }
                else if (boost::algorithm::istarts_with(name, TEXTURE_DISPLACEMENT_DIR)) {
                    std::string contents(stat.m_uncomp_size, '\0');
                    if (mz_zip_reader_extract_to_mem(&archive, stat.m_file_index, contents.data(), stat.m_uncomp_size, 0))
                        m_texture_displacement_files.emplace(name, std::move(contents));
                    else
                        add_error("Error while reading texture displacement data");
                }
                else if (!dont_load_config && boost::algorithm::iequals(name, SLICE_INFO_CONFIG_FILE)) {
                    m_parsing_slice_info = true;
                    //extract slice info from archive
                    _extract_xml_from_archive(archive, stat, _handle_start_config_xml_element, _handle_end_config_xml_element);
                    m_parsing_slice_info = false;
                }
                else if (!dont_load_config && boost::algorithm::iequals(name, FILAMENT_SEQUENCE_FILE)) {
                    _extract_filament_sequence_from_archive(archive, stat);
                }
                else if (boost::algorithm::istarts_with(name, AUXILIARY_DIR)) {
                    // extract auxiliary directory to temp directory, do nothing for restore
                    if (m_load_aux && !m_load_restore)
                        _extract_auxiliary_file_from_archive(archive, stat, model);
                }
                else if (!dont_load_config && boost::algorithm::istarts_with(name, METADATA_DIR) && boost::algorithm::iends_with(name, GCODE_EXTENSION)) {
                    //load gcode files
                    _extract_file_from_archive(archive, stat);
                }
                else if (!dont_load_config && boost::algorithm::istarts_with(name, METADATA_DIR) && boost::algorithm::iends_with(name, THUMBNAIL_EXTENSION)) {
                    //BBS parsing pattern thumbnail and plate thumbnails
                    _extract_file_from_archive(archive, stat);
                }
                else if (!dont_load_config && boost::algorithm::istarts_with(name, METADATA_DIR) && boost::algorithm::iends_with(name, CALIBRATION_INFO_EXTENSION)) {
                    //BBS parsing pattern config files
                    _extract_file_from_archive(archive, stat);
                }
                else {
                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" << __LINE__ << boost::format(", %1% skipped, already parsed or a directory or not supported\n")%name;
                }
            }
        }
 
        lock.close();
 
        if (!m_is_bbl_3mf && !_is_published_3mf()) {
            // if the 3mf was not produced by OrcaSlicer and there is more than one instance,
            // split the object in as many objects as instances
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" << __LINE__ << boost::format(", found 3mf from other vendor, split as instance");
            for (const IdToModelObjectMap::value_type& object : m_objects) {
                if (object.second >= int(m_model->objects.size())) {
                    add_error("3rd 3mf, invalid object, id: "+std::to_string(object.first.second));
                    return false;
                }
                ModelObject* model_object = m_model->objects[object.second];
                if (model_object->instances.size() > 1) {
                    IdToCurrentObjectMap::const_iterator current_object = m_current_objects.find(object.first);
                    if (current_object == m_current_objects.end()) {
                        add_error("3rd 3mf, can not find object, id " + std::to_string(object.first.second));
                        return false;
                    }
                    std::vector<Component> object_id_list;
                    if (!_generate_current_object_list(object_id_list, object.first, m_current_objects))
                        return false;
 
                    ObjectMetadata::VolumeMetadataList volumes;
                    ObjectMetadata::VolumeMetadataList* volumes_ptr = nullptr;
 
                    for (int k = 0; k < object_id_list.size(); k++)
                    {
                        Id object_id = object_id_list[k].object_id;
                        volumes.emplace_back(object_id.second);
                    }
 
                    // select as volumes
                    volumes_ptr = &volumes;
 
                    // for each instance after the 1st, create a new model object containing only that instance
                    // and copy into it the geometry
                    while (model_object->instances.size() > 1) {
                        ModelObject* new_model_object = m_model->add_object(*model_object);
                        new_model_object->clear_instances();
                        new_model_object->add_instance(*model_object->instances.back());
                        model_object->delete_last_instance();
                        if (!_generate_volumes_new(*new_model_object, object_id_list, *volumes_ptr, config_substitutions))
                            return false;
                    }
                }
            }
        }
 
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" << __LINE__ << boost::format(", process group colors, size %1%\n")%m_group_id_to_color.size();
        std::map<int, int> color_group_id_to_extruder_id_map;
        std::map<std::string, int> color_to_extruder_id_map;
        int extruder_id = 0;
        for (auto group_iter = m_group_id_to_color.begin(); group_iter != m_group_id_to_color.end(); ++group_iter) {
            auto color_iter = color_to_extruder_id_map.find(group_iter->second);
            if (color_iter == color_to_extruder_id_map.end()) {
                ++extruder_id;
                color_to_extruder_id_map[group_iter->second] = extruder_id;
                color_group_id_to_extruder_id_map[group_iter->first] = extruder_id;
            } else {
                color_group_id_to_extruder_id_map[group_iter->first] = color_iter->second;
            }
        }
 
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" << __LINE__ << boost::format(", begin to assemble objects, size %1%\n")%m_objects.size();
        //only load objects in plate_id
        PlateData* current_plate_data = nullptr;
        if ((plate_id > 0) && (plate_id <= m_plater_data.size())) {
            std::map<int, PlateData*>::iterator it =m_plater_data.find(plate_id);
            if (it != m_plater_data.end()) {
                current_plate_data = it->second;
            }
        }
        for (const IdToModelObjectMap::value_type& object : m_objects) {
            if (object.second >= int(m_model->objects.size())) {
                add_error("invalid object, id: "+std::to_string(object.first.second));
                return false;
            }
            if (current_plate_data) {
                std::map<int, std::pair<int, int>>::iterator it = current_plate_data->obj_inst_map.find(object.first.second);
                if (it == current_plate_data->obj_inst_map.end()) {
                    //not in current plate, skip
                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" << __LINE__ << boost::format(", could not find object %1% in plate %2%, skip it\n")%object.first.second %plate_id;
                    continue;
                }
            }
            ModelObject* model_object = m_model->objects[object.second];
            /*IdToGeometryMap::const_iterator obj_geometry = m_geometries.find(object.first);
            if (obj_geometry == m_geometries.end()) {
                add_error("Unable to find object geometry");
                return false;
            }*/
 
            // m_layer_heights_profiles are indexed by a 1 based model object index.
            IdToLayerHeightsProfileMap::iterator obj_layer_heights_profile = m_layer_heights_profiles.find(object.second + 1);
            if (obj_layer_heights_profile != m_layer_heights_profiles.end())
                model_object->layer_height_profile.set(std::move(obj_layer_heights_profile->second));
 
            // m_layer_config_ranges are indexed by a 1 based model object index.
            IdToLayerConfigRangesMap::iterator obj_layer_config_ranges = m_layer_config_ranges.find(object.second + 1);
            if (obj_layer_config_ranges != m_layer_config_ranges.end())
                model_object->layer_config_ranges = std::move(obj_layer_config_ranges->second);
 
            IdToBrimPointsMap::iterator obj_brim_points = m_brim_ear_points.find(object.second + 1);
            if (obj_brim_points != m_brim_ear_points.end())
                model_object->brim_points = std::move(obj_brim_points->second);
 
            // m_sla_support_points are indexed by a 1 based model object index.
            /*IdToSlaSupportPointsMap::iterator obj_sla_support_points = m_sla_support_points.find(object.second + 1);
            if (obj_sla_support_points != m_sla_support_points.end() && !obj_sla_support_points->second.empty()) {
                model_object->sla_support_points = std::move(obj_sla_support_points->second);
                model_object->sla_points_status = sla::PointsStatus::UserModified;
            }
 
            IdToSlaDrainHolesMap::iterator obj_drain_holes = m_sla_drain_holes.find(object.second + 1);
            if (obj_drain_holes != m_sla_drain_holes.end() && !obj_drain_holes->second.empty()) {
                model_object->sla_drain_holes = std::move(obj_drain_holes->second);
            }*/
 
            std::vector<Component> object_id_list;
            if (!_generate_current_object_list(object_id_list, object.first, m_current_objects))
                return false;
 
            ObjectMetadata::VolumeMetadataList volumes;
            ObjectMetadata::VolumeMetadataList* volumes_ptr = nullptr;
 
            // 2.4.x stored auto_drop on build items, shared by all instances of an object; any "off" wins
            const bool legacy_auto_drop = !m_items_auto_drop_off.count(object.first.second);
 
            IdToMetadataMap::iterator obj_metadata = m_objects_metadata.find(object.first.second);
            if (obj_metadata != m_objects_metadata.end()) {
                // config data has been found, this model was saved using slic3r pe
 
                model_object->auto_drop = obj_metadata->second.auto_drop.value_or(legacy_auto_drop);
 
                // apply object's name and config data
                for (const Metadata& metadata : obj_metadata->second.metadata) {
                    if (metadata.key == "name")
                        model_object->name = metadata.value;
                    //BBS: add module name
                    else if (metadata.key == "module")
                        model_object->module_name = metadata.value;
                    else
                        model_object->config.set_deserialize(metadata.key, metadata.value, config_substitutions);
                }
 
                // select object's detected volumes
                volumes_ptr = &obj_metadata->second.volumes;
            }
            else {
                // config data not found, this model was not saved using slic3r pe
                model_object->auto_drop = legacy_auto_drop;
 
                // add the entire geometry as the single volume to generate
                //volumes.emplace_back(0, (int)obj_geometry->second.triangles.size() - 1);
                for (int k = 0; k < object_id_list.size(); k++)
                {
                    Id object_id = object_id_list[k].object_id;
                    volumes.emplace_back(object_id.second);
                }
 
                IdToCurrentObjectMap::const_iterator current_object = m_current_objects.find(object.first);
                if (current_object != m_current_objects.end()) {
                    // get name
                    if (!current_object->second.name.empty())
                        model_object->name = current_object->second.name;
                    else
                        model_object->name = "Object_"+std::to_string(object.second+1);
 
                    // get color
                    auto extruder_itor = color_group_id_to_extruder_id_map.find(current_object->second.pid);
                    if (extruder_itor != color_group_id_to_extruder_id_map.end()) {
                        model_object->config.set_key_value("extruder", new ConfigOptionInt(extruder_itor->second));
                    }
                }
 
                // select as volumes
                volumes_ptr = &volumes;
            }
 
            if (!_generate_volumes_new(*model_object, object_id_list, *volumes_ptr, config_substitutions))
                return false;
 
            // Apply cut information for object if any was loaded
            // m_cut_object_ids are indexed by a 1 based model object index.
            IdToCutObjectInfoMap::iterator cut_object_info = m_cut_object_infos.find(object.second + 1);
            if (cut_object_info != m_cut_object_infos.end()) {
                model_object->cut_id = cut_object_info->second.id;
                int vol_cnt = int(model_object->volumes.size());
                for (auto connector : cut_object_info->second.connectors) {
                    if (connector.volume_id < 0 || connector.volume_id >= vol_cnt) {
                        add_error("Invalid connector is found");
                        continue;
                    }
                    model_object->volumes[connector.volume_id]->cut_info = 
                        ModelVolume::CutInfo(CutConnectorType(connector.type), connector.r_tolerance, connector.h_tolerance, true);
                }
            }
        }
 
        // If instances contain a single volume, the volume offset should be 0,0,0
        // This equals to say that instance world position and volume world position should match
        // Correct all instances/volumes for which this does not hold
        for (int obj_id = 0; obj_id < int(model.objects.size()); ++obj_id) {
            ModelObject *o = model.objects[obj_id];
            if (o->volumes.size() == 1) {
                ModelVolume *                           v                 = o->volumes.front();
                const Slic3r::Geometry::Transformation &first_inst_trafo  = o->instances.front()->get_transformation();
                const Vec3d                             world_vol_offset  = (first_inst_trafo * v->get_transformation()).get_offset();
                const Vec3d                             world_inst_offset = first_inst_trafo.get_offset();
 
                if (!world_vol_offset.isApprox(world_inst_offset)) {
                    const Slic3r::Geometry::Transformation &vol_trafo = v->get_transformation();
                    for (int inst_id = 0; inst_id < int(o->instances.size()); ++inst_id) {
                        ModelInstance *                         i          = o->instances[inst_id];
                        const Slic3r::Geometry::Transformation &inst_trafo = i->get_transformation();
                        i->set_offset((inst_trafo * vol_trafo).get_offset());
                    }
                    v->set_offset(Vec3d::Zero());
                }
            }
        }
 
        int object_idx = 0;
        for (ModelObject* o : model.objects) {
            int volume_idx = 0;
            for (ModelVolume* v : o->volumes) {
                if (v->source.input_file.empty() && v->type() == ModelVolumeType::MODEL_PART) {
                    v->source.input_file = filename;
                    if (v->source.volume_idx == -1)
                        v->source.volume_idx = volume_idx;
                    if (v->source.object_idx == -1)
                        v->source.object_idx = object_idx;
                }
                ++volume_idx;
            }
            ++object_idx;
        }
 
        const ConfigOptionStrings* filament_ids_opt = config.option<ConfigOptionStrings>("filament_settings_id");
        int max_filament_id = filament_ids_opt ? filament_ids_opt->size() : std::numeric_limits<int>::max();
        for (ModelObject* mo : m_model->objects) {
            const ConfigOptionInt* extruder_opt = dynamic_cast<const ConfigOptionInt*>(mo->config.option("extruder"));
            int extruder_id = 0;
            if (extruder_opt != nullptr)
                extruder_id = extruder_opt->getInt();
 
            if (extruder_id == 0 || extruder_id > max_filament_id)
                mo->config.set_key_value("extruder", new ConfigOptionInt(1));
 
            if (mo->volumes.size() == 1) {
                mo->volumes[0]->config.erase("extruder");
            }
            else {
                for (ModelVolume* mv : mo->volumes) {
                    const ConfigOptionInt* vol_extruder_opt = dynamic_cast<const ConfigOptionInt*>(mv->config.option("extruder"));
                    if (vol_extruder_opt == nullptr)
                        continue;
 
                    if (vol_extruder_opt->getInt() == 0)
                        mv->config.erase("extruder");
                    else if (vol_extruder_opt->getInt() > max_filament_id)
                        mv->config.set_key_value("extruder", new ConfigOptionInt(1));
                }
            }
        }
 
//        // fixes the min z of the model if negative
//        model.adjust_min_z();
 
        //BBS progress point
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" << __LINE__ << boost::format("import 3mf IMPORT_STAGE_LOADING_PLATES, m_plater_data size %1%, m_backup_path %2%\n")%m_plater_data.size() %m_backup_path;
        if (proFn) {
            proFn(IMPORT_STAGE_LOADING_PLATES, 0, 1, cb_cancel);
            if (cb_cancel)
                return false;
        }
 
        //BBS: load the plate info into plate_data_list
        std::map<int, PlateData*>::iterator it = m_plater_data.begin();
        plate_data_list.clear();
        plate_data_list.reserve(m_plater_data.size());
        for (unsigned int i = 0; i < m_plater_data.size(); i++)
        {
            PlateData* plate = new PlateData();
            plate_data_list.push_back(plate);
        }
        while (it != m_plater_data.end())
        {
            if (it->first <= 0 || static_cast<size_t>(it->first) > m_plater_data.size())
            {
                add_error("invalid plate index");
                return false;
            }
            plate_data_list[it->first-1]->locked = it->second->locked;
            plate_data_list[it->first-1]->plate_index = it->second->plate_index-1;
            plate_data_list[it->first-1]->plate_name = it->second->plate_name;
            plate_data_list[it->first-1]->obj_inst_map = it->second->obj_inst_map;
            plate_data_list[it->first-1]->gcode_file = (m_load_restore || it->second->gcode_file.empty()) ? it->second->gcode_file : m_backup_path + "/" + it->second->gcode_file;
            plate_data_list[it->first-1]->gcode_prediction = it->second->gcode_prediction;
            plate_data_list[it->first-1]->gcode_weight = it->second->gcode_weight;
            plate_data_list[it->first-1]->toolpath_outside = it->second->toolpath_outside;
            plate_data_list[it->first-1]->is_support_used = it->second->is_support_used;
            plate_data_list[it->first-1]->is_label_object_enabled = it->second->is_label_object_enabled;
            plate_data_list[it->first-1]->slice_filaments_info = it->second->slice_filaments_info;
            plate_data_list[it->first-1]->nozzles_info  = it->second->nozzles_info;
            plate_data_list[it->first-1]->skipped_objects = it->second->skipped_objects;
            plate_data_list[it->first-1]->printer_model_id = it->second->printer_model_id;
            plate_data_list[it->first-1]->nozzle_diameters = it->second->nozzle_diameters;
            plate_data_list[it->first-1]->nozzle_volume_types = it->second->nozzle_volume_types;
            plate_data_list[it->first-1]->filament_maps = it->second->filament_maps;
            plate_data_list[it->first-1]->filament_change_sequence = it->second->filament_change_sequence;
            plate_data_list[it->first-1]->nozzle_change_sequence = it->second->nozzle_change_sequence;
            plate_data_list[it->first-1]->optimal_assignment = it->second->optimal_assignment;
            plate_data_list[it->first-1]->warnings = it->second->warnings;
            plate_data_list[it->first-1]->thumbnail_file = (m_load_restore || it->second->thumbnail_file.empty()) ? it->second->thumbnail_file : m_backup_path + "/" + it->second->thumbnail_file;
            //plate_data_list[it->first-1]->pattern_file = (m_load_restore || it->second->pattern_file.empty()) ? it->second->pattern_file : m_backup_path + "/" + it->second->pattern_file;
            plate_data_list[it->first-1]->no_light_thumbnail_file = (m_load_restore || it->second->no_light_thumbnail_file.empty()) ? it->second->no_light_thumbnail_file : m_backup_path + "/" + it->second->no_light_thumbnail_file;
            plate_data_list[it->first-1]->top_file = (m_load_restore || it->second->top_file.empty()) ? it->second->top_file : m_backup_path + "/" + it->second->top_file;
            plate_data_list[it->first-1]->pick_file = (m_load_restore || it->second->pick_file.empty()) ? it->second->pick_file : m_backup_path + "/" + it->second->pick_file;
            plate_data_list[it->first-1]->pattern_bbox_file = (m_load_restore || it->second->pattern_bbox_file.empty()) ? it->second->pattern_bbox_file : m_backup_path + "/" + it->second->pattern_bbox_file;
            plate_data_list[it->first-1]->config = it->second->config;
 
            current_plate_data = plate_data_list[it->first - 1];
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" << __LINE__ << boost::format(", plate %1%, thumbnail_file=%2%, no_light_thumbnail_file=%3%")%it->first %plate_data_list[it->first-1]->thumbnail_file %plate_data_list[it->first-1]->no_light_thumbnail_file;
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" << __LINE__ << boost::format(", top_thumbnail_file=%1%, pick_thumbnail_file=%2%")%plate_data_list[it->first-1]->top_file %plate_data_list[it->first-1]->pick_file;
            it++;
 
            //update the arrange order
            std::map<int, std::pair<int, int>>::iterator map_it = current_plate_data->obj_inst_map.begin();
            while (map_it != current_plate_data->obj_inst_map.end()) {
                int obj_index, obj_id = map_it->first, inst_index = map_it->second.first;
                IndexToPathMap::iterator index_iter = m_index_paths.find(obj_id);
                if (index_iter == m_index_paths.end()) {
                    BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ":" << __LINE__
                        << boost::format(", can not find object from plate's obj_map, id=%1%, skip this object")%obj_id;
                    map_it++;
                    continue;
                }
                Id temp_id = std::make_pair(index_iter->second, index_iter->first);
                IdToModelObjectMap::iterator object_item = m_objects.find(temp_id);
                if (object_item == m_objects.end()) {
                    BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ":" << __LINE__
                        << boost::format(", can not find object from plate's obj_map, ID <%1%, %2%>, skip this object")%index_iter->second %index_iter->first;
                    map_it++;
                    continue;
                }
                obj_index = object_item->second;
 
                if (obj_index >= m_model->objects.size()) {
                    BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ":" << __LINE__ << boost::format("invalid object id %1%\n")%obj_index;
                    map_it++;
                    continue;
                }
                ModelObject* obj =  m_model->objects[obj_index];
                if (inst_index >= obj->instances.size()) {
                    BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ":" << __LINE__ << boost::format("invalid instance id %1%\n")%inst_index;
                    map_it++;
                    continue;
                }
                ModelInstance* inst =  obj->instances[inst_index];
                inst->loaded_id = map_it->second.second;
                map_it++;
            }
        }
 
        if ((plate_id > 0) && (plate_id <= m_plater_data.size())) {
            //remove the no need objects
            std::vector<size_t> delete_ids;
            for (int index = 0; index < m_model->objects.size(); index++) {
                ModelObject* obj =  m_model->objects[index];
                if (obj->volumes.size() == 0) {
                    //remove this model objects
                    delete_ids.push_back(index);
                }
            }
 
            for (int index = delete_ids.size() - 1; index >= 0; index--)
                m_model->delete_object(delete_ids[index]);
        }
 
        //BBS progress point
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" << __LINE__ << boost::format("import 3mf IMPORT_STAGE_FINISH\n");
        if (proFn) {
            proFn(IMPORT_STAGE_FINISH, 0, 1, cb_cancel);
            if (cb_cancel)
                return false;
        }
 
        return true;
    }

References _extract_from_archive(), _extract_model_from_archive(), _extract_xml_from_archive(), _handle_end_relationships_element(), _handle_start_relationships_element(), Slic3r::_BBS_3MF_Base::add_error(), Slic3r::close_zip_reader(), Slic3r::IMPORT_STAGE_OPEN, Slic3r::IMPORT_STAGE_READ_FILES, Slic3r::IMPORT_STAGE_RESTORE, m_current_objects, m_group_id_to_color, m_load_restore, m_name, m_object_importers, m_start_part_path, m_sub_model_path, m_sub_model_paths, Slic3r::_BBS_3MF_Base::mutex, Slic3r::open_zip_reader(), and RELATIONSHIPS_FILE.

Referenced by load_model_from_file().

Here is the call graph for this function:

Here is the caller graph for this function:

_stop_xml_parser()

void Slic3r::_BBS_3MF_Importer::_stop_xml_parser ( const std::string & msg = std::string() )

private

    {
        assert(! m_parse_error);
        assert(m_parse_error_message.empty());
        assert(m_xml_parser != nullptr);
        m_parse_error = true;
        m_parse_error_message = msg;
        XML_StopParser(m_xml_parser, false);
    }

References m_parse_error, m_parse_error_message, and m_xml_parser.

Referenced by _handle_end_config_xml_element(), _handle_end_model_xml_element(), _handle_end_relationships_element(), _handle_start_config_xml_element(), _handle_start_model_xml_element(), _handle_start_relationships_element(), and _handle_start_vertex().

Here is the caller graph for this function:

add_error()

void Slic3r::_BBS_3MF_Base::add_error ( const std::string & error ) const

inlineprotectedinherited

{ boost::unique_lock l(mutex); m_errors.push_back(error); }

References m_errors, and mutex.

Referenced by Slic3r::_BBS_3MF_Exporter::_add_bbox_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_brim_ear_points_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_cad_recipe_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_content_types_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_custom_gcode_per_print_z_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_cut_information_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_filament_sequence_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_layer_config_ranges_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_layer_height_profile_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_mesh_to_object_stream(), Slic3r::_BBS_3MF_Exporter::_add_model_config_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_model_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_object_to_model_stream(), Slic3r::_BBS_3MF_Exporter::_add_print_config_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_relationships_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_slice_info_config_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_thumbnail_file_to_archive(), Slic3r::_BBS_3MF_Importer::_apply_texture_displacement(), Slic3r::_BBS_3MF_Importer::_create_object_instance(), Slic3r::_BBS_3MF_Importer::_extract_auxiliary_file_from_archive(), Slic3r::_BBS_3MF_Importer::_extract_brim_ear_points_from_archive(), Slic3r::_BBS_3MF_Importer::_extract_custom_gcode_per_print_z_from_archive(), Slic3r::_BBS_3MF_Importer::_extract_cut_information_from_archive(), Slic3r::_BBS_3MF_Importer::_extract_embossed_svg_shape_file(), Slic3r::_BBS_3MF_Importer::_extract_filament_sequence_from_archive(), Slic3r::_BBS_3MF_Importer::_extract_file_from_archive(), Slic3r::_BBS_3MF_Importer::_extract_from_archive(), Slic3r::_BBS_3MF_Importer::_extract_layer_config_ranges_from_archive(), Slic3r::_BBS_3MF_Importer::_extract_layer_heights_profile_config_from_archive(), Slic3r::_BBS_3MF_Importer::_extract_model_from_archive(), Slic3r::_BBS_3MF_Importer::_extract_print_config_from_archive(), Slic3r::_BBS_3MF_Importer::_extract_project_config_from_archive(), Slic3r::_BBS_3MF_Importer::_extract_project_embedded_presets_from_archive(), Slic3r::_BBS_3MF_Importer::_extract_xml_from_archive(), Slic3r::_BBS_3MF_Importer::_generate_current_object_list(), Slic3r::_BBS_3MF_Importer::_generate_volumes_new(), Slic3r::_BBS_3MF_Importer::_handle_end_config_plater(), Slic3r::_BBS_3MF_Importer::_handle_end_config_plater_instance(), Slic3r::_BBS_3MF_Importer::_handle_end_model(), Slic3r::_BBS_3MF_Importer::_handle_end_object(), Slic3r::_BBS_3MF_Importer::_handle_start_assemble_item(), Slic3r::_BBS_3MF_Importer::_handle_start_config_metadata(), Slic3r::_BBS_3MF_Importer::_handle_start_config_object(), Slic3r::_BBS_3MF_Importer::_handle_start_config_plater_instance(), Slic3r::_BBS_3MF_Importer::_handle_start_config_volume(), Slic3r::_BBS_3MF_Importer::_handle_start_config_volume_mesh(), Slic3r::_BBS_3MF_Importer::_handle_start_shape_configuration(), Slic3r::_BBS_3MF_Importer::_handle_start_text_configuration(), Slic3r::_BBS_3MF_Importer::_handle_start_text_info_item(), Slic3r::_BBS_3MF_Importer::_load_model_from_file(), Slic3r::_BBS_3MF_Exporter::_save_model_to_file(), Slic3r::_BBS_3MF_Importer::get_thumbnail(), Slic3r::_BBS_3MF_Importer::load_gcode_3mf_from_stream(), Slic3r::_BBS_3MF_Exporter::save_model_to_file(), and Slic3r::_BBS_3MF_Exporter::save_object_mesh().

clear_errors()

void Slic3r::_BBS_3MF_Base::clear_errors ( )

inlineprotectedinherited

{ m_errors.clear(); }

References m_errors.

Referenced by Slic3r::_BBS_3MF_Importer::~_BBS_3MF_Importer(), Slic3r::_BBS_3MF_Importer::load_model_from_file(), and Slic3r::_BBS_3MF_Exporter::save_model_to_file().

Here is the caller graph for this function:

get_thumbnail()

bool Slic3r::_BBS_3MF_Importer::get_thumbnail	(	const std::string &	filename,
		std::string &	data )

    {
        mz_zip_archive archive;
        mz_zip_zero_struct(&archive);
 
        struct close_lock
        {
            mz_zip_archive *archive;
            void            close()
            {
                if (archive) {
                    close_zip_reader(archive);
                    archive = nullptr;
                }
            }
            ~close_lock() { close(); }
        } lock{&archive};
 
        if (!open_zip_reader(&archive, filename)) {
            add_error("Unable to open the file"+filename);
            return false;
        }
 
        // BBS: load relationships
        if (!_extract_xml_from_archive(archive, RELATIONSHIPS_FILE, _handle_start_relationships_element, _handle_end_relationships_element))
            return false;
        if (m_thumbnail_middle.empty()) m_thumbnail_middle = m_thumbnail_path;
        if (!m_thumbnail_middle.empty()) {
            return _extract_from_archive(archive, m_thumbnail_middle, [&data](auto &archive, auto const &stat) -> bool {
                data.resize(stat.m_uncomp_size);
                return mz_zip_reader_extract_to_mem(&archive, stat.m_file_index, data.data(), data.size(), 0);
            });
        }
        return _extract_from_archive(archive, THUMBNAIL_FILE, [&data](auto &archive, auto const &stat) -> bool {
            data.resize(stat.m_uncomp_size);
            return mz_zip_reader_extract_to_mem(&archive, stat.m_file_index, data.data(), data.size(), 0);
        });
    }

References _extract_from_archive(), _extract_xml_from_archive(), _handle_end_relationships_element(), _handle_start_relationships_element(), Slic3r::_BBS_3MF_Base::add_error(), Slic3r::close_zip_reader(), m_thumbnail_middle, m_thumbnail_path, Slic3r::open_zip_reader(), RELATIONSHIPS_FILE, and THUMBNAIL_FILE.

Referenced by Slic3r::bbs_3mf_get_thumbnail().

Here is the call graph for this function:

Here is the caller graph for this function:

load_gcode_3mf_from_stream()

bool Slic3r::_BBS_3MF_Importer::load_gcode_3mf_from_stream	(	std::istream &	data,
		Model &	model,
		PlateDataPtrs &	plate_data_list,
		DynamicPrintConfig &	config,
		Semver &	file_version )

    {
        mz_zip_archive archive;
        mz_zip_zero_struct(&archive);
        archive.m_pRead = mz_zip_read_istream;
        archive.m_pIO_opaque = &data;
 
        data.seekg(0, std::istream::end);
        mz_uint64 size = data.tellg();
        data.seekg(0, std::istream::beg);
        if (!mz_zip_reader_init(&archive, size, 0))
            return false;
 
        struct close_lock
        {
            mz_zip_archive *archive;
            void            close()
            {
                if (archive) {
                    mz_zip_reader_end(archive);
                    archive = nullptr;
                }
            }
            ~close_lock() { close(); }
        } lock{&archive};
 
        // BBS: load relationships
        if (!_extract_xml_from_archive(archive, RELATIONSHIPS_FILE, _handle_start_relationships_element, _handle_end_relationships_element))
            return false;
        if (m_start_part_path.empty())
            return false;
 
        //extract model files
        m_model = &model;
        if (!_extract_from_archive(archive, m_start_part_path, [this] (mz_zip_archive& archive, const mz_zip_archive_file_stat& stat) {
                    return _extract_model_from_archive(archive, stat);
            })) {
            add_error("Archive does not contain a valid model");
            return false;
        }
 
        if (!m_designer.empty()) {
            m_model->design_info                 = std::make_shared<ModelDesignInfo>();
            m_model->design_info->DesignerUserId = m_designer_user_id;
            m_model->design_info->Designer       = m_designer;
        }
 
        m_model->profile_info                     = std::make_shared<ModelProfileInfo>();
        m_model->profile_info->ProfileTile        = m_profile_title;
        m_model->profile_info->ProfileCover       = m_profile_cover;
        m_model->profile_info->ProfileDescription = m_Profile_description;
        m_model->profile_info->ProfileUserId      = m_profile_user_id;
        m_model->profile_info->ProfileUserName    = m_profile_user_name;
 
        m_model->model_info = std::make_shared<ModelInfo>();
        m_model->model_info->load(model_info);
 
        if (m_thumbnail_middle.empty()) m_thumbnail_middle = m_thumbnail_path;
        if (m_thumbnail_small.empty()) m_thumbnail_small = m_thumbnail_path;
        if (!m_thumbnail_small.empty() && m_thumbnail_small.front() == '/')
            m_thumbnail_small.erase(m_thumbnail_small.begin());
        if (!m_thumbnail_middle.empty() && m_thumbnail_middle.front() == '/')
            m_thumbnail_middle.erase(m_thumbnail_middle.begin());
        m_model->model_info->metadata_items.emplace("Thumbnail", m_thumbnail_middle);
        m_model->model_info->metadata_items.emplace("Poster", m_thumbnail_middle);
 
        // we then loop again the entries to read other files stored in the archive
        mz_uint num_entries = mz_zip_reader_get_num_files(&archive);
        mz_zip_archive_file_stat stat;
        for (mz_uint i = 0; i < num_entries; ++i) {
            if (mz_zip_reader_file_stat(&archive, i, &stat)) {
                std::string name(stat.m_filename);
                std::replace(name.begin(), name.end(), '\\', '/');
 
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" << __LINE__ << boost::format("extract %1%th file %2%, total=%3%\n")%(i+1)%name%num_entries;
 
                if (boost::algorithm::iequals(name, BBS_PROJECT_CONFIG_FILE)) {
                    // extract slic3r print config file
                    ConfigSubstitutionContext config_substitutions(ForwardCompatibilitySubstitutionRule::Disable);
                    _extract_project_config_from_archive(archive, stat, config, config_substitutions, model);
                }
                else if (boost::algorithm::iequals(name, BBS_MODEL_CONFIG_FILE)) {
                    // extract slic3r model config file
                    if (!_extract_xml_from_archive(archive, stat, _handle_start_config_xml_element, _handle_end_config_xml_element)) {
                        add_error("Archive does not contain a valid model config");
                        return false;
                    }
                }
                else if (boost::algorithm::iequals(name, SLICE_INFO_CONFIG_FILE)) {
                    m_parsing_slice_info = true;
                    //extract slice info from archive
                    _extract_xml_from_archive(archive, stat, _handle_start_config_xml_element, _handle_end_config_xml_element);
                    m_parsing_slice_info = false;
                }
                else if (boost::algorithm::iequals(name, FILAMENT_SEQUENCE_FILE)) {
                    _extract_filament_sequence_from_archive(archive, stat);
                }
            }
        }
 
        //BBS: load the plate info into plate_data_list
        std::map<int, PlateData*>::iterator it = m_plater_data.begin();
        plate_data_list.clear();
        plate_data_list.reserve(m_plater_data.size());
        for (unsigned int i = 0; i < m_plater_data.size(); i++)
        {
            PlateData* plate = new PlateData();
            plate_data_list.push_back(plate);
        }
        while (it != m_plater_data.end())
        {
            if (it->first <= 0 || static_cast<size_t>(it->first) > m_plater_data.size())
            {
                add_error("invalid plate index");
                return false;
            }
            PlateData * plate = plate_data_list[it->first-1];
            plate->locked = it->second->locked;
            plate->plate_index = it->second->plate_index-1;
            plate->obj_inst_map = it->second->obj_inst_map;
            plate->gcode_file = it->second->gcode_file;
            plate->gcode_prediction = it->second->gcode_prediction;
            plate->gcode_weight = it->second->gcode_weight;
            plate->toolpath_outside = it->second->toolpath_outside;
            plate->is_support_used = it->second->is_support_used;
            plate->is_label_object_enabled = it->second->is_label_object_enabled;
            plate->skipped_objects = it->second->skipped_objects;
            plate->slice_filaments_info = it->second->slice_filaments_info;
            plate->nozzles_info = it->second->nozzles_info;
            plate->printer_model_id = it->second->printer_model_id;
            plate->nozzle_diameters = it->second->nozzle_diameters;
            plate->nozzle_volume_types = it->second->nozzle_volume_types;
            plate->filament_maps = it->second->filament_maps;
            plate->filament_change_sequence = it->second->filament_change_sequence;
            plate->nozzle_change_sequence = it->second->nozzle_change_sequence;
            plate->optimal_assignment = it->second->optimal_assignment;
            plate->warnings = it->second->warnings;
            plate->thumbnail_file = it->second->thumbnail_file;
            if (plate->thumbnail_file.empty()) {
                plate->thumbnail_file = plate->gcode_file;
                boost::algorithm::replace_all(plate->thumbnail_file, ".gcode", ".png");
            }
            //plate->pattern_file = it->second->pattern_file;
            plate->no_light_thumbnail_file = it->second->no_light_thumbnail_file;
            plate->top_file = it->second->top_file;
            plate->pick_file = it->second->pick_file;
            plate->pattern_bbox_file = it->second->pattern_bbox_file;
            plate->config = it->second->config;
 
            if (!plate->thumbnail_file.empty())
                _extract_from_archive(archive, plate->thumbnail_file, [&pixels = plate_data_list[it->first - 1]->plate_thumbnail.pixels](auto &archive, auto const &stat) -> bool {
                    pixels.resize(stat.m_uncomp_size);
                    return mz_zip_reader_extract_to_mem(&archive, stat.m_file_index, pixels.data(), pixels.size(), 0);
                });
 
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" << __LINE__ << boost::format(", plate %1%, thumbnail_file=%2%, no_light_thumbnail_file=%3%")%it->first %plate->thumbnail_file %plate->no_light_thumbnail_file;
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" << __LINE__ << boost::format(", top_thumbnail_file=%1%, pick_thumbnail_file=%2%")%plate->top_file %plate->pick_file;
            it++;
        }
 
        lock.close();
 
        return true;
    }

References _extract_filament_sequence_from_archive(), _extract_from_archive(), _extract_model_from_archive(), _extract_project_config_from_archive(), _extract_xml_from_archive(), _handle_end_config_xml_element(), _handle_end_relationships_element(), _handle_start_config_xml_element(), _handle_start_relationships_element(), Slic3r::_BBS_3MF_Base::add_error(), BBS_MODEL_CONFIG_FILE, BBS_PROJECT_CONFIG_FILE, Slic3r::PlateData::config, Slic3r::Disable, Slic3r::PlateData::filament_change_sequence, Slic3r::PlateData::filament_maps, FILAMENT_SEQUENCE_FILE, Slic3r::PlateData::gcode_file, Slic3r::PlateData::gcode_prediction, Slic3r::PlateData::gcode_weight, Slic3r::PlateData::is_label_object_enabled, Slic3r::PlateData::is_support_used, Slic3r::PlateData::locked, m_designer, m_designer_user_id, m_model, m_parsing_slice_info, m_plater_data, m_profile_cover, m_Profile_description, m_profile_title, m_profile_user_id, m_profile_user_name, m_start_part_path, m_thumbnail_middle, m_thumbnail_path, m_thumbnail_small, model_info, Slic3r::mz_zip_read_istream(), Slic3r::PlateData::no_light_thumbnail_file, Slic3r::PlateData::nozzle_change_sequence, Slic3r::PlateData::nozzle_diameters, Slic3r::PlateData::nozzle_volume_types, Slic3r::PlateData::nozzles_info, Slic3r::PlateData::obj_inst_map, Slic3r::PlateData::optimal_assignment, Slic3r::PlateData::pattern_bbox_file, Slic3r::PlateData::pick_file, Slic3r::PlateData::plate_index, Slic3r::PlateData::printer_model_id, RELATIONSHIPS_FILE, Slic3r::PlateData::skipped_objects, Slic3r::PlateData::slice_filaments_info, SLICE_INFO_CONFIG_FILE, Slic3r::PlateData::thumbnail_file, Slic3r::PlateData::toolpath_outside, Slic3r::PlateData::top_file, and Slic3r::PlateData::warnings.

Referenced by Slic3r::load_gcode_3mf_from_stream().

Here is the call graph for this function:

Here is the caller graph for this function:

load_model_from_file()

bool Slic3r::_BBS_3MF_Importer::load_model_from_file	(	const std::string &	filename,
		Model &	model,
		PlateDataPtrs &	plate_data_list,
		std::vector< Preset * > &	project_presets,
		DynamicPrintConfig &	config,
		ConfigSubstitutionContext &	config_substitutions,
		LoadStrategy	strategy,
		bool *	is_bbl_3mf,
		bool *	is_orca_3mf,
		Semver &	file_version,
		Import3mfProgressFn	proFn = nullptr,
		BBLProject *	project = nullptr,
		int	plate_id = 0 )

    {
        m_version = 0;
        m_fdm_supports_painting_version = 0;
        m_seam_painting_version = 0;
        m_mm_painting_version = 0;
        m_check_version = strategy & LoadStrategy::CheckVersion;
        //BBS: auxiliary data
        m_load_model  = strategy & LoadStrategy::LoadModel;
        m_load_aux = strategy & LoadStrategy::LoadAuxiliary;
        m_load_restore = strategy & LoadStrategy::Restore;
        m_load_config = strategy & LoadStrategy::LoadConfig;
        m_model = &model;
        m_unit_factor = 1.0f;
        m_curr_object = nullptr;
        m_current_objects.clear();
        m_index_paths.clear();
        m_objects.clear();
        //m_objects_aliases.clear();
        m_instances.clear();
        //m_geometries.clear();
        m_curr_config.object_id = -1;
        m_curr_config.volume_id = -1;
        m_objects_metadata.clear();
        m_items_auto_drop_off.clear();
        m_layer_heights_profiles.clear();
        m_layer_config_ranges.clear();
        m_brim_ear_points.clear();
        //m_sla_support_points.clear();
        m_curr_metadata_name.clear();
        m_curr_characters.clear();
        //BBS: plater data init
        m_plater_data.clear();
        m_curr_instance.object_id = -1;
        m_curr_instance.instance_id = -1;
        m_curr_instance.identify_id = 0;
        clear_errors();
 
        // restore
        if (m_load_restore) {
            m_backup_path = filename.substr(0, filename.size() - 5);
            model.set_backup_path(m_backup_path);
            try {
                if (boost::filesystem::exists(model.get_backup_path() + "/origin.txt"))
                    load_string_file(model.get_backup_path() + "/origin.txt", m_origin_file);
            } catch (...) {}
            save_string_file(
                model.get_backup_path() + "/lock.txt",
                boost::lexical_cast<std::string>(get_current_pid()));
        }
        else {
            m_backup_path = model.get_backup_path();
        }
        bool result = _load_model_from_file(filename, model, plate_data_list, project_presets, config, config_substitutions, proFn, project, plate_id);
        if (is_bbl_3mf) {
            *is_bbl_3mf = m_is_bbl_3mf;
        }
        // If the OrcaSlicer tag is present, use it as file_version (ignoring the Bambu Application version).
        // Otherwise fall back to the version parsed from the Application tag.
        if (m_orca_slicer_version) {
            file_version = *m_orca_slicer_version;
            if (is_orca_3mf)
                *is_orca_3mf = true;
        } else {
            if (m_bambuslicer_generator_version)
                file_version = *m_bambuslicer_generator_version;
            if (is_orca_3mf)
                *is_orca_3mf = false;
        }
        // save for restore
        if (result && m_load_aux && !m_load_restore) {
            save_string_file(model.get_backup_path() + "/origin.txt", filename);
        }
        if (m_load_restore && !result) // not clear failed backup data for later analyze
            model.set_backup_path("detach");
        return result;
    }

References _load_model_from_file(), Slic3r::CheckVersion, Slic3r::_BBS_3MF_Base::clear_errors(), Slic3r::Model::get_backup_path(), Slic3r::get_current_pid(), Slic3r::load_string_file(), Slic3r::LoadAuxiliary, Slic3r::LoadConfig, Slic3r::LoadModel, m_backup_path, m_bambuslicer_generator_version, m_brim_ear_points, m_check_version, m_curr_characters, m_curr_config, m_curr_instance, m_curr_metadata_name, m_curr_object, m_current_objects, m_fdm_supports_painting_version, m_index_paths, m_instances, m_is_bbl_3mf, m_items_auto_drop_off, m_layer_config_ranges, m_layer_heights_profiles, m_load_aux, m_load_config, m_load_model, m_load_restore, m_mm_painting_version, m_model, m_objects, m_objects_metadata, m_orca_slicer_version, m_origin_file, m_plater_data, m_seam_painting_version, m_unit_factor, m_version, Slic3r::Restore, Slic3r::save_string_file(), and Slic3r::Model::set_backup_path().

Referenced by Slic3r::load_bbs_3mf().

Here is the call graph for this function:

Here is the caller graph for this function:

log_errors()

void Slic3r::_BBS_3MF_Base::log_errors ( )

inlineinherited

        {
            for (const std::string& error : m_errors)
                BOOST_LOG_TRIVIAL(error) << error;
        }

References m_errors.

Referenced by Slic3r::bbs_3mf_get_thumbnail(), Slic3r::load_bbs_3mf(), Slic3r::load_gcode_3mf_from_stream(), and Slic3r::store_bbs_3mf().

Here is the caller graph for this function:

parse_error()

bool Slic3r::_BBS_3MF_Importer::parse_error ( ) const

inlineprivate

{ return m_parse_error; }

References m_parse_error.

parse_error_message()

const char * Slic3r::_BBS_3MF_Importer::parse_error_message ( ) const

inlineprivate

                                                {
            return m_parse_error ?
                // The error was signalled by the user code, not the expat parser.
                (m_parse_error_message.empty() ? "Invalid 3MF format" : m_parse_error_message.c_str()) :
                // The error was signalled by the expat parser.
                XML_ErrorString(XML_GetErrorCode(m_xml_parser));
        }

References m_parse_error, m_parse_error_message, and m_xml_parser.

version()

unsigned int Slic3r::_BBS_3MF_Importer::version ( ) const

inline

{ return m_version; }

References m_version.

Referenced by _extract_brim_ear_points_from_archive(), and _extract_project_embedded_presets_from_archive().

Here is the caller graph for this function:

Member Data Documentation

m_backup_path

std::string Slic3r::_BBS_3MF_Importer::m_backup_path

private

Referenced by _extract_file_from_archive(), _extract_from_archive(), _extract_project_embedded_presets_from_archive(), and load_model_from_file().

m_bambuslicer_generator_version

boost::optional<Semver> Slic3r::_BBS_3MF_Importer::m_bambuslicer_generator_version

private

Referenced by _handle_end_metadata(), and load_model_from_file().

m_brim_ear_points

IdToBrimPointsMap Slic3r::_BBS_3MF_Importer::m_brim_ear_points

private

Referenced by _extract_brim_ear_points_from_archive(), and load_model_from_file().

m_check_version

bool Slic3r::_BBS_3MF_Importer::m_check_version = false

private

Referenced by _BBS_3MF_Importer(), and load_model_from_file().

m_contry_code

std::string Slic3r::_BBS_3MF_Importer::m_contry_code

private

Referenced by _handle_end_metadata().

m_curr_characters

std::string Slic3r::_BBS_3MF_Importer::m_curr_characters

private

Referenced by _BBS_3MF_Importer(), ~_BBS_3MF_Importer(), _handle_end_metadata(), _handle_start_metadata(), _handle_start_relationships_element(), _handle_xml_characters(), and load_model_from_file().

m_curr_config

CurrentConfig Slic3r::_BBS_3MF_Importer::m_curr_config

private

Referenced by _handle_end_config_object(), _handle_end_config_volume(), _handle_start_config_metadata(), _handle_start_config_object(), _handle_start_config_volume(), _handle_start_config_volume_mesh(), _handle_start_shape_configuration(), _handle_start_text_configuration(), _handle_start_text_info_item(), and load_model_from_file().

m_curr_instance

CurrentInstance Slic3r::_BBS_3MF_Importer::m_curr_instance

private

Referenced by _handle_end_config_plater_instance(), _handle_start_config_metadata(), and load_model_from_file().

m_curr_metadata_name

std::string Slic3r::_BBS_3MF_Importer::m_curr_metadata_name

private

Referenced by _BBS_3MF_Importer(), ~_BBS_3MF_Importer(), _handle_end_metadata(), _handle_start_metadata(), and load_model_from_file().

m_curr_object

CurrentObject* Slic3r::_BBS_3MF_Importer::m_curr_object {nullptr}

private

{nullptr};

Referenced by ~_BBS_3MF_Importer(), _handle_end_object(), _handle_start_component(), _handle_start_components(), _handle_start_mesh(), _handle_start_object(), _handle_start_triangle(), _handle_start_triangles(), _handle_start_vertex(), _handle_start_vertices(), and load_model_from_file().

m_curr_plater

PlateData* Slic3r::_BBS_3MF_Importer::m_curr_plater

private

Referenced by _BBS_3MF_Importer(), _handle_end_config_plater(), _handle_end_config_plater_instance(), _handle_start_config_filament(), _handle_start_config_metadata(), _handle_start_config_mixed_filament(), _handle_start_config_nozzle(), _handle_start_config_plater(), _handle_start_config_plater_instance(), and _handle_start_config_warning().

m_current_color_group

int Slic3r::_BBS_3MF_Importer::m_current_color_group {-1}

private

{-1};

Referenced by _handle_start_color(), and _handle_start_color_group().

m_current_objects

IdToCurrentObjectMap Slic3r::_BBS_3MF_Importer::m_current_objects

private

Referenced by ~_BBS_3MF_Importer(), _create_object_instance(), _generate_volumes_new(), _handle_end_model(), _handle_end_object(), _load_model_from_file(), and load_model_from_file().

m_cut_object_infos

IdToCutObjectInfoMap Slic3r::_BBS_3MF_Importer::m_cut_object_infos

private

Referenced by _extract_cut_information_from_archive().

m_designer

std::string Slic3r::_BBS_3MF_Importer::m_designer

private

Referenced by _handle_end_metadata(), and load_gcode_3mf_from_stream().

m_designer_cover

std::string Slic3r::_BBS_3MF_Importer::m_designer_cover

private

m_designer_user_id

std::string Slic3r::_BBS_3MF_Importer::m_designer_user_id

private

Referenced by _handle_end_metadata(), and load_gcode_3mf_from_stream().

m_errors

std::vector<std::string> Slic3r::_BBS_3MF_Base::m_errors

mutableprivateinherited

Referenced by add_error(), clear_errors(), and log_errors().

m_fdm_supports_painting_version

unsigned int Slic3r::_BBS_3MF_Importer::m_fdm_supports_painting_version = 0

private

Referenced by load_model_from_file().

m_group_id_to_color

std::map<int, std::string> Slic3r::_BBS_3MF_Importer::m_group_id_to_color

private

Referenced by _handle_start_color(), and _load_model_from_file().

m_index_paths

IndexToPathMap Slic3r::_BBS_3MF_Importer::m_index_paths

private

Referenced by ~_BBS_3MF_Importer(), _handle_end_model(), _handle_start_assemble_item(), and load_model_from_file().

m_instances

InstancesList Slic3r::_BBS_3MF_Importer::m_instances

private

Referenced by ~_BBS_3MF_Importer(), _create_object_instance(), _handle_end_model(), and load_model_from_file().

m_is_bbl_3mf

bool Slic3r::_BBS_3MF_Importer::m_is_bbl_3mf { false }

private

{ false };

Referenced by _create_object_instance(), _handle_end_metadata(), _handle_end_model(), _handle_end_object(), and load_model_from_file().

m_items_auto_drop_off

std::set<int> Slic3r::_BBS_3MF_Importer::m_items_auto_drop_off

private

Referenced by ~_BBS_3MF_Importer(), _handle_start_item(), and load_model_from_file().

m_layer_config_ranges

IdToLayerConfigRangesMap Slic3r::_BBS_3MF_Importer::m_layer_config_ranges

private

Referenced by _extract_layer_config_ranges_from_archive(), and load_model_from_file().

m_layer_heights_profiles

IdToLayerHeightsProfileMap Slic3r::_BBS_3MF_Importer::m_layer_heights_profiles

private

Referenced by _extract_layer_heights_profile_config_from_archive(), and load_model_from_file().

m_load_aux

bool Slic3r::_BBS_3MF_Importer::m_load_aux = false

private

Referenced by load_model_from_file().

m_load_config

bool Slic3r::_BBS_3MF_Importer::m_load_config = false

private

Referenced by load_model_from_file().

m_load_model

bool Slic3r::_BBS_3MF_Importer::m_load_model = false

private

Referenced by _handle_end_object(), _handle_start_assemble_item(), _handle_start_item(), and load_model_from_file().

m_load_restore

bool Slic3r::_BBS_3MF_Importer::m_load_restore = false

private

Referenced by _handle_end_object(), _load_model_from_file(), and load_model_from_file().

m_mm_painting_version

unsigned int Slic3r::_BBS_3MF_Importer::m_mm_painting_version = 0

private

Referenced by load_model_from_file().

m_model

Model* Slic3r::_BBS_3MF_Importer::m_model

private

Referenced by _BBS_3MF_Importer(), _create_object_instance(), _extract_custom_gcode_per_print_z_from_archive(), _extract_embossed_svg_shape_file(), _handle_end_model(), _handle_start_assemble_item(), load_gcode_3mf_from_stream(), and load_model_from_file().

m_model_id

std::string Slic3r::_BBS_3MF_Importer::m_model_id

private

Referenced by _handle_end_metadata().

m_name

std::string Slic3r::_BBS_3MF_Importer::m_name

private

Referenced by _BBS_3MF_Importer(), _handle_end_model(), and _load_model_from_file().

m_object_importers

std::vector<ObjectImporter*> Slic3r::_BBS_3MF_Importer::m_object_importers

private

Referenced by _load_model_from_file().

m_objects

IdToModelObjectMap Slic3r::_BBS_3MF_Importer::m_objects

private

Referenced by ~_BBS_3MF_Importer(), _create_object_instance(), _handle_end_model(), _handle_start_assemble_item(), and load_model_from_file().

m_objects_metadata

IdToMetadataMap Slic3r::_BBS_3MF_Importer::m_objects_metadata

private

Referenced by ~_BBS_3MF_Importer(), _handle_start_config_metadata(), _handle_start_config_object(), _handle_start_config_volume(), _handle_start_config_volume_mesh(), _handle_start_shape_configuration(), _handle_start_text_configuration(), _handle_start_text_info_item(), and load_model_from_file().

m_orca_slicer_version

boost::optional<Semver> Slic3r::_BBS_3MF_Importer::m_orca_slicer_version

private

Referenced by _handle_end_metadata(), and load_model_from_file().

m_origin_file

std::string Slic3r::_BBS_3MF_Importer::m_origin_file

private

Referenced by _extract_from_archive(), and load_model_from_file().

m_parse_error

bool Slic3r::_BBS_3MF_Importer::m_parse_error { false }

private

{ false };

Referenced by _stop_xml_parser(), parse_error(), and parse_error_message().

m_parse_error_message

std::string Slic3r::_BBS_3MF_Importer::m_parse_error_message

private

Referenced by _stop_xml_parser(), and parse_error_message().

m_parsing_slice_info

bool Slic3r::_BBS_3MF_Importer::m_parsing_slice_info { false }

private

{ false };

Referenced by _handle_start_config_metadata(), _handle_start_config_object(), _handle_start_config_plater(), and load_gcode_3mf_from_stream().

m_path_to_emboss_shape_files

PathToEmbossShapeFileMap Slic3r::_BBS_3MF_Importer::m_path_to_emboss_shape_files

private

Referenced by _extract_embossed_svg_shape_file(), and _handle_start_shape_configuration().

m_plater_data

PlateDataMaps Slic3r::_BBS_3MF_Importer::m_plater_data

private

Referenced by ~_BBS_3MF_Importer(), _extract_filament_sequence_from_archive(), _handle_end_config_plater(), _handle_start_config_metadata(), load_gcode_3mf_from_stream(), and load_model_from_file().

m_profile_cover

std::string Slic3r::_BBS_3MF_Importer::m_profile_cover

private

Referenced by _handle_end_metadata(), and load_gcode_3mf_from_stream().

m_Profile_description

std::string Slic3r::_BBS_3MF_Importer::m_Profile_description

private

Referenced by _handle_end_metadata(), and load_gcode_3mf_from_stream().

m_profile_title

std::string Slic3r::_BBS_3MF_Importer::m_profile_title

private

Referenced by _handle_end_metadata(), and load_gcode_3mf_from_stream().

m_profile_user_id

std::string Slic3r::_BBS_3MF_Importer::m_profile_user_id

private

Referenced by _handle_end_metadata(), and load_gcode_3mf_from_stream().

m_profile_user_name

std::string Slic3r::_BBS_3MF_Importer::m_profile_user_name

private

Referenced by _handle_end_metadata(), and load_gcode_3mf_from_stream().

m_seam_painting_version

unsigned int Slic3r::_BBS_3MF_Importer::m_seam_painting_version = 0

private

Referenced by load_model_from_file().

m_shared_meshes

std::map<int, ModelVolume*> Slic3r::_BBS_3MF_Importer::m_shared_meshes

private

Referenced by _generate_volumes_new().

m_start_part_path

std::string Slic3r::_BBS_3MF_Importer::m_start_part_path

private

Referenced by _handle_start_relationship(), _load_model_from_file(), and load_gcode_3mf_from_stream().

m_sub_model_path

std::string Slic3r::_BBS_3MF_Importer::m_sub_model_path

private

Referenced by _handle_end_model(), _handle_end_object(), _handle_start_component(), and _load_model_from_file().

m_sub_model_paths

std::vector<std::string> Slic3r::_BBS_3MF_Importer::m_sub_model_paths

private

Referenced by _handle_start_relationship(), and _load_model_from_file().

m_texture_displacement_files

std::map<std::string, std::string> Slic3r::_BBS_3MF_Importer::m_texture_displacement_files

private

Referenced by _apply_texture_displacement().

m_thumbnail_middle

std::string Slic3r::_BBS_3MF_Importer::m_thumbnail_middle

private

Referenced by _handle_start_relationship(), get_thumbnail(), and load_gcode_3mf_from_stream().

m_thumbnail_path

std::string Slic3r::_BBS_3MF_Importer::m_thumbnail_path

private

Referenced by _handle_start_relationship(), get_thumbnail(), and load_gcode_3mf_from_stream().

m_thumbnail_small

std::string Slic3r::_BBS_3MF_Importer::m_thumbnail_small

private

Referenced by _handle_start_relationship(), and load_gcode_3mf_from_stream().

m_unit_factor

float Slic3r::_BBS_3MF_Importer::m_unit_factor

private

Referenced by _BBS_3MF_Importer(), _handle_start_model(), _handle_start_vertex(), and load_model_from_file().

m_version

unsigned int Slic3r::_BBS_3MF_Importer::m_version

private

Referenced by _BBS_3MF_Importer(), _handle_end_metadata(), load_model_from_file(), and version().

m_xml_parser

XML_Parser Slic3r::_BBS_3MF_Importer::m_xml_parser

private

Referenced by _BBS_3MF_Importer(), _destroy_xml_parser(), _extract_model_from_archive(), _extract_xml_from_archive(), _handle_end_config_xml_element(), _handle_end_model_xml_element(), _handle_end_relationships_element(), _handle_start_config_xml_element(), _handle_start_model_xml_element(), _handle_start_relationships_element(), _stop_xml_parser(), and parse_error_message().

model_info

ModelInfo Slic3r::_BBS_3MF_Importer::model_info

private

Referenced by _handle_end_metadata(), and load_gcode_3mf_from_stream().

mutex

boost::mutex Slic3r::_BBS_3MF_Base::mutex

mutableprivateinherited

Referenced by Slic3r::_BBS_3MF_Exporter::_add_gcode_file_to_archive(), Slic3r::_BBS_3MF_Importer::_load_model_from_file(), and add_error().

project_info

BBLProject Slic3r::_BBS_3MF_Importer::project_info

private

---

The documentation for this class was generated from the following file:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Format/bbs_3mf.cpp