Slic3r::_3MF_Importer Class Reference

Inheritance diagram for Slic3r::_3MF_Importer:

Collaboration diagram for Slic3r::_3MF_Importer:

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

Public Member Functions
	_3MF_Importer ()
	~_3MF_Importer ()
bool	load_model_from_file (const std::string &filename, Model &model, DynamicPrintConfig &config, ConfigSubstitutionContext &config_substitutions, bool check_version)
unsigned int	version () const
boost::optional< Semver >	prusaslicer_generator_version () const
void	log_errors ()

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

Private Types
typedef std::vector< Component >	ComponentsList
typedef std::vector< Metadata >	MetadataList
typedef std::map< int, int >	IdToModelObjectMap
typedef std::map< int, ComponentsList >	IdToAliasesMap
typedef std::vector< Instance >	InstancesList
typedef std::map< int, ObjectMetadata >	IdToMetadataMap
typedef std::map< int, Geometry >	IdToGeometryMap
typedef std::map< int, std::vector< coordf_t > >	IdToLayerHeightsProfileMap
typedef std::map< int, t_layer_config_ranges >	IdToLayerConfigRangesMap
typedef std::map< int, CutObjectInfo >	IdToCutObjectInfoMap
typedef std::map< int, std::vector< sla::SupportPoint > >	IdToSlaSupportPointsMap
typedef std::map< int, std::vector< sla::DrainHole > >	IdToSlaDrainHolesMap

Private Member Functions
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 (const std::string &filename, Model &model, DynamicPrintConfig &config, ConfigSubstitutionContext &config_substitutions)
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_custom_gcode_per_print_z_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)
bool	_extract_model_config_from_archive (mz_zip_archive &archive, const mz_zip_archive_file_stat &stat, Model &model)
void	_handle_start_model_xml_element (const char *name, const char **attributes)
void	_handle_end_model_xml_element (const char *name)
void	_handle_model_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_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	_create_object_instance (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	_generate_volumes (ModelObject &object, const Geometry &geometry, const ObjectMetadata::VolumeMetadataList &volumes, ConfigSubstitutionContext &config_substitutions)

Static Private Member Functions
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_model_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
boost::optional< Semver >	m_prusaslicer_generator_version
unsigned int	m_fdm_supports_painting_version = 0
unsigned int	m_seam_painting_version = 0
unsigned int	m_mm_painting_version = 0
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
IdToModelObjectMap	m_objects
IdToAliasesMap	m_objects_aliases
InstancesList	m_instances
IdToGeometryMap	m_geometries
CurrentConfig	m_curr_config
IdToMetadataMap	m_objects_metadata
IdToCutObjectInfoMap	m_cut_object_infos
IdToLayerHeightsProfileMap	m_layer_heights_profiles
IdToLayerConfigRangesMap	m_layer_config_ranges
IdToSlaSupportPointsMap	m_sla_support_points
IdToSlaDrainHolesMap	m_sla_drain_holes
std::string	m_curr_metadata_name
std::string	m_curr_characters
std::string	m_name
std::vector< std::string >	m_errors

Detailed Description

---

Class Documentation

Slic3r::_3MF_Importer::CurrentConfig

struct Slic3r::_3MF_Importer::CurrentConfig

Class Members
int	object_id
int	volume_id

Slic3r::_3MF_Importer::CutObjectInfo

struct Slic3r::_3MF_Importer::CutObjectInfo

Collaboration diagram for Slic3r::_3MF_Importer::CutObjectInfo:

Class Members
vector< Connector >	connectors
CutObjectBase	id

Slic3r::_3MF_Importer::ObjectMetadata

struct Slic3r::_3MF_Importer::ObjectMetadata

Collaboration diagram for Slic3r::_3MF_Importer::ObjectMetadata:

Class Members
typedef vector< VolumeMetadata >	VolumeMetadataList

Class Members
MetadataList	metadata
VolumeMetadataList	volumes

Member Typedef Documentation

ComponentsList

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

private

IdToAliasesMap

typedef std::map<int, ComponentsList> Slic3r::_3MF_Importer::IdToAliasesMap

private

IdToCutObjectInfoMap

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

private

IdToGeometryMap

typedef std::map<int, Geometry> Slic3r::_3MF_Importer::IdToGeometryMap

private

IdToLayerConfigRangesMap

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

private

IdToLayerHeightsProfileMap

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

private

IdToMetadataMap

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

private

IdToModelObjectMap

typedef std::map<int, int> Slic3r::_3MF_Importer::IdToModelObjectMap

private

IdToSlaDrainHolesMap

typedef std::map<int, std::vector<sla::DrainHole> > Slic3r::_3MF_Importer::IdToSlaDrainHolesMap

private

IdToSlaSupportPointsMap

typedef std::map<int, std::vector<sla::SupportPoint> > Slic3r::_3MF_Importer::IdToSlaSupportPointsMap

private

InstancesList

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

private

MetadataList

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

private

Constructor & Destructor Documentation

_3MF_Importer()

Slic3r::_3MF_Importer::_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("")
    {
    }

~_3MF_Importer()

Slic3r::_3MF_Importer::~_3MF_Importer

(

)

    {
        _destroy_xml_parser();
    }

References _destroy_xml_parser().

Here is the call graph for this function:

Member Function Documentation

_apply_transform()

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

private

    {
        Slic3r::Geometry::Transformation t(transform);
        // invalid scale value, return
        if (!t.get_scaling_factor().all())
            return;
 
        instance.set_transformation(t);
    }

References Slic3r::Geometry::Transformation::get_scaling_factor(), and Slic3r::ModelInstance::set_transformation().

Here is the call graph for this function:

_create_object_instance()

bool Slic3r::_3MF_Importer::_create_object_instance ( 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;
        }
 
        IdToAliasesMap::iterator it = m_objects_aliases.find(object_id);
        if (it == m_objects_aliases.end()) {
            add_error("Found item with invalid object id");
            return false;
        }
 
        if (it->second.size() == 1 && it->second[0].object_id == object_id) {
            // aliasing to itself
 
            IdToModelObjectMap::iterator object_item = m_objects.find(object_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(component.object_id, transform * component.transform, printable, recur_counter + 1))
                    return false;
            }
        }
 
        return true;
    }

References Slic3r::Model::objects, and Slic3r::ModelInstance::printable.

_destroy_xml_parser()

void Slic3r::_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 ~_3MF_Importer(), and _extract_model_from_archive().

Here is the caller graph for this function:

_extract_custom_gcode_per_print_z_from_archive()

void Slic3r::_3MF_Importer::_extract_custom_gcode_per_print_z_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 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_print_z")
                return;
            pt::ptree code_tree = main_tree.front().second;
 
            m_model->custom_gcode_per_print_z.gcodes.clear();
 
            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->custom_gcode_per_print_z.mode = mode == CustomGCode::SingleExtruderMode ? CustomGCode::Mode::SingleExtruder :
                                                             mode == CustomGCode::MultiAsSingleMode  ? CustomGCode::Mode::MultiAsSingle  :
                                                             CustomGCode::Mode::MultiExtruder;
                }
                if (code.first != "code")
                    continue;
 
                pt::ptree tree = code.second;
                double print_z          = tree.get<double>      ("<xmlattr>.print_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->custom_gcode_per_print_z.gcodes.push_back(CustomGCode::Item{print_z, type, extruder, color, extra}) ;
            }
        }
    }

References Slic3r::Model::custom_gcode_per_print_z, Slic3r::CustomGCode::Info::gcodes, Slic3r::CustomGCode::Info::mode, mz_zip_reader_extract_to_mem(), and stat.

Referenced by _load_model_from_file().

Here is the call graph for this function:

Here is the caller graph for this function:

_extract_cut_information_from_archive()

void Slic3r::_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_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 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 mz_zip_reader_extract_to_mem(), and stat.

Referenced by _load_model_from_file().

Here is the call graph for this function:

Here is the caller graph for this function:

_extract_layer_config_ranges_from_archive()

void Slic3r::_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_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 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 mz_zip_reader_extract_to_mem(), Slic3r::range(), and stat.

Referenced by _load_model_from_file().

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::_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 mz_zip_reader_extract_to_mem(), and stat.

Referenced by _load_model_from_file().

Here is the call graph for this function:

Here is the caller graph for this function:

_extract_model_config_from_archive()

bool Slic3r::_3MF_Importer::_extract_model_config_from_archive ( mz_zip_archive &  archive, const mz_zip_archive_file_stat &  stat, Model &  model  )

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, _3MF_Importer::_handle_start_config_xml_element, _3MF_Importer::_handle_end_config_xml_element);
 
        void* parser_buffer = XML_GetBuffer(m_xml_parser, (int)stat.m_uncomp_size);
        if (parser_buffer == nullptr) {
            add_error("Unable to create buffer");
            return false;
        }
 
        mz_bool res = mz_zip_reader_extract_to_mem(&archive, stat.m_file_index, parser_buffer, (size_t)stat.m_uncomp_size, 0);
        if (res == 0) {
            add_error("Error while reading config data to buffer");
            return false;
        }
 
        if (!XML_ParseBuffer(m_xml_parser, (int)stat.m_uncomp_size, 1)) {
            char error_buf[1024];
            ::sprintf(error_buf, "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 mz_zip_reader_extract_to_mem(), and stat.

Referenced by _load_model_from_file().

Here is the call graph for this function:

Here is the caller graph for this function:

_extract_model_from_archive()

bool Slic3r::_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, _3MF_Importer::_handle_start_model_xml_element, _3MF_Importer::_handle_end_model_xml_element);
        XML_SetCharacterDataHandler(m_xml_parser, _3MF_Importer::_handle_model_xml_characters);
 
        struct CallbackData
        {
            XML_Parser& parser;
            _3MF_Importer& importer;
            const mz_zip_archive_file_stat& stat;
 
            CallbackData(XML_Parser& parser, _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
        {
            res = mz_zip_reader_extract_to_callback(&archive, stat.m_file_index, [](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];
                    ::sprintf(error_buf, "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;
                }, &data, 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 _destroy_xml_parser(), _handle_end_model_xml_element(), _handle_model_xml_characters(), _handle_start_model_xml_element(), Slic3r::_3MF_Base::add_error(), m_xml_parser, mz_zip_reader_extract_to_callback(), and stat.

Referenced by _load_model_from_file().

Here is the call graph for this function:

Here is the caller graph for this function:

_extract_print_config_from_archive()

void Slic3r::_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_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 config data to buffer");
                return;
            }
            //FIXME Loading a "will be one day a legacy format" of configuration in a form of a G-code comment.
            // Each config line is prefixed with a semicolon (G-code comment), that is ugly.
 
            // Replacing the legacy function with load_from_ini_string_commented leads to issues when
            // parsing 3MFs from before PrusaSlicer 2.0.0 (which can have duplicated entries in the INI.
            // See https://github.com/prusa3d/PrusaSlicer/issues/7155. We'll revert it for now.
            //config_substitutions.substitutions = config.load_from_ini_string_commented(std::move(buffer), config_substitutions.rule);
            ConfigBase::load_from_gcode_string_legacy(config, buffer.data(), config_substitutions);
        }
    }

References mz_zip_reader_extract_to_mem(), and stat.

Referenced by _load_model_from_file().

Here is the call graph for this function:

Here is the caller graph for this function:

_extract_sla_drain_holes_from_archive()

void Slic3r::_3MF_Importer::_extract_sla_drain_holes_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 sla support 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 3mf.hpp
            int version = 0;
            std::string key("drain_holes_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;
                }
                
                IdToSlaDrainHolesMap::iterator object_item = m_sla_drain_holes.find(object_id);
                if (object_item != m_sla_drain_holes.end()) {
                    add_error("Found duplicated SLA drain holes");
                    continue;
                }
                
                std::vector<std::string> object_data_points;
                boost::split(object_data_points, object_data[1], boost::is_any_of(" "), boost::token_compress_off);
                
                sla::DrainHoles sla_drain_holes;
 
                if (version == 1) {
                    for (unsigned int i=0; i<object_data_points.size(); i+=8)
                        sla_drain_holes.emplace_back(Vec3f{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()))},
                                                     Vec3f{float(std::atof(object_data_points[i+3].c_str())),
                                                      float(std::atof(object_data_points[i+4].c_str())),
                                                      float(std::atof(object_data_points[i+5].c_str()))},
                                                      float(std::atof(object_data_points[i+6].c_str())),
                                                      float(std::atof(object_data_points[i+7].c_str())));
                }
 
                // The holes are saved elevated above the mesh and deeper (bad idea indeed).
                // This is retained for compatibility.
                // Place the hole to the mesh and make it shallower to compensate.
                // The offset is 1 mm above the mesh.
                for (sla::DrainHole& hole : sla_drain_holes) {
                    hole.pos += hole.normal.normalized();
                    hole.height -= 1.f;
                }
                
                if (!sla_drain_holes.empty())
                    m_sla_drain_holes.insert({ object_id, sla_drain_holes });
            }
        }
    }

References mz_zip_reader_extract_to_mem(), stat, and version.

Referenced by _load_model_from_file().

Here is the call graph for this function:

Here is the caller graph for this function:

_extract_sla_support_points_from_archive()

void Slic3r::_3MF_Importer::_extract_sla_support_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 sla support 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 3mf.hpp
            int version = 0;
            std::string key("support_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;
                }
 
                IdToSlaSupportPointsMap::iterator object_item = m_sla_support_points.find(object_id);
                if (object_item != m_sla_support_points.end()) {
                    add_error("Found duplicated SLA support 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<sla::SupportPoint> sla_support_points;
 
                if (version == 0) {
                    for (unsigned int i=0; i<object_data_points.size(); i+=3)
                    sla_support_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())),
                                                    0.4f,
                                                    false);
                }
                if (version == 1) {
                    for (unsigned int i=0; i<object_data_points.size(); i+=5)
                    sla_support_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())),
                          //FIXME storing boolean as 0 / 1 and importing it as float.
                                                    std::abs(std::atof(object_data_points[i+4].c_str()) - 1.) < EPSILON);
                }
 
                if (!sla_support_points.empty())
                    m_sla_support_points.insert({ object_id, sla_support_points });
            }
        }
    }

References EPSILON, mz_zip_reader_extract_to_mem(), stat, and version.

Referenced by _load_model_from_file().

Here is the call graph for this function:

Here is the caller graph for this function:

_generate_volumes()

bool Slic3r::_3MF_Importer::_generate_volumes ( ModelObject &  object, const Geometry &  geometry, const ObjectMetadata::VolumeMetadataList &  volumes, ConfigSubstitutionContext &  config_substitutions  )

private

    {
        if (!object.volumes.empty()) {
            add_error("Found invalid volumes count");
            return false;
        }
 
        unsigned int geo_tri_count = (unsigned int)geometry.triangles.size();
        unsigned int renamed_volumes_count = 0;
 
        for (const ObjectMetadata::VolumeMetadata& volume_data : volumes) {
            if (geo_tri_count <= volume_data.first_triangle_id || geo_tri_count <= volume_data.last_triangle_id || volume_data.last_triangle_id < volume_data.first_triangle_id) {
                add_error("Found invalid triangle id");
                return false;
            }
 
            Transform3d volume_matrix_to_object = Transform3d::Identity();
            bool        has_transform         = false;
            // 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);
                    break;
                }
            }
 
            // splits volume out of imported geometry
            indexed_triangle_set its;
            its.indices.assign(geometry.triangles.begin() + volume_data.first_triangle_id, geometry.triangles.begin() + volume_data.last_triangle_id + 1);
            const size_t triangles_count = its.indices.size();
            if (triangles_count == 0) {
                add_error("An empty triangle mesh found");
                return false;
            }
 
            {
                int min_id = its.indices.front()[0];
                int max_id = min_id;
                for (const Vec3i& face : its.indices) {
                    for (const int tri_id : face) {
                        if (tri_id < 0 || tri_id >= int(geometry.vertices.size())) {
                            add_error("Found invalid vertex id");
                            return false;
                        }
                        min_id = std::min(min_id, tri_id);
                        max_id = std::max(max_id, tri_id);
                    }
                }
                its.vertices.assign(geometry.vertices.begin() + min_id, geometry.vertices.begin() + max_id + 1);
 
                // rebase indices to the current vertices list
                for (Vec3i& face : its.indices)
                    for (int& tri_id : face)
                        tri_id -= min_id;
            }
 
            if (m_prusaslicer_generator_version && 
                *m_prusaslicer_generator_version >= *Semver::parse("2.4.0-alpha1") &&
                *m_prusaslicer_generator_version < *Semver::parse("2.4.0-alpha3"))
                // PrusaSlicer 2.4.0-alpha2 contained a bug, where all vertices of a single object were saved for each volume the object contained.
                // Remove the vertices, that are not referenced by any face.
                its_compactify_vertices(its, true);
 
            TriangleMesh triangle_mesh(std::move(its), volume_data.mesh_stats);
 
            if (m_version == 0) {
                // if the 3mf was not produced by PrusaSlicer 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();
 
      ModelVolume* volume = object.add_volume(std::move(triangle_mesh));
            // stores the volume matrix taken from the metadata, if present
            if (has_transform)
                volume->source.transform = Slic3r::Geometry::Transformation(volume_matrix_to_object);
 
            // 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);
            for (size_t i=0; i<triangles_count; ++i) {
                size_t index = volume_data.first_triangle_id + i;
                assert(index < geometry.custom_supports.size());
                assert(index < geometry.custom_seam.size());
                assert(index < geometry.mmu_segmentation.size());
                if (! geometry.custom_supports[index].empty())
                    volume->supported_facets.set_triangle_from_string(i, geometry.custom_supports[index]);
                if (! geometry.custom_seam[index].empty())
                    volume->seam_facets.set_triangle_from_string(i, geometry.custom_seam[index]);
                if (! geometry.mmu_segmentation[index].empty())
                    volume->mmu_segmentation_facets.set_triangle_from_string(i, geometry.mmu_segmentation[index]);
            }
            volume->supported_facets.shrink_to_fit();
            volume->seam_facets.shrink_to_fit();
            volume->mmu_segmentation_facets.shrink_to_fit();
            auto &tc = volume_data.text_configuration;
            if (tc.has_value()) {
                volume->text_configuration = std::move(tc);
 
                //const Transform3d &pre_trmat = *tc->fix_3mf_tr;
 
                //assert(tc->fix_3mf_tr.has_value());
                //volume->text_configuration->fix_3mf_tr =
                //    pre_trmat.inverse() *
                //    volume->get_transformation().get_matrix();
            }
            
            // 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 == MODIFIER_KEY) && (metadata.value == "1"))
          volume->set_type(ModelVolumeType::PARAMETER_MODIFIER);
                else if (metadata.key == VOLUME_TYPE_KEY)
                    volume->set_type(ModelVolume::type_from_string(metadata.value));
                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.x() = ::atof(metadata.value.c_str());
                else if (metadata.key == SOURCE_OFFSET_Y_KEY)
                    volume->source.mesh_offset.y() = ::atof(metadata.value.c_str());
                else if (metadata.key == SOURCE_OFFSET_Z_KEY)
                    volume->source.mesh_offset.z() = ::atof(metadata.value.c_str());
                else if (metadata.key == SOURCE_IN_INCHES_KEY)
                    volume->source.is_converted_from_inches = metadata.value == "1";
                else if (metadata.key == SOURCE_IN_METERS_KEY)
                    volume->source.is_converted_from_meters = metadata.value == "1";
                else if (metadata.key == SOURCE_IS_BUILTIN_VOLUME_KEY)
                    volume->source.is_from_builtin_objects = metadata.value == "1";
                else
                    volume->config.set_deserialize(metadata.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 Slic3r::_3MF_Importer::Geometry::custom_seam, Slic3r::_3MF_Importer::Geometry::custom_supports, Slic3r::TriangleMesh::flip_triangles(), indexed_triangle_set::indices, Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::isApprox(), Slic3r::its_compactify_vertices(), MATRIX_KEY, Slic3r::_3MF_Importer::Geometry::mmu_segmentation, MODIFIER_KEY, NAME_KEY, SOURCE_FILE_KEY, SOURCE_IN_INCHES_KEY, SOURCE_IN_METERS_KEY, SOURCE_IS_BUILTIN_VOLUME_KEY, SOURCE_OBJECT_ID_KEY, SOURCE_OFFSET_X_KEY, SOURCE_OFFSET_Y_KEY, SOURCE_OFFSET_Z_KEY, SOURCE_VOLUME_ID_KEY, Slic3r::TriangleMesh::transform(), Slic3r::Geometry::transform3d_from_string(), Slic3r::_3MF_Importer::Geometry::triangles, indexed_triangle_set::vertices, Slic3r::_3MF_Importer::Geometry::vertices, Slic3r::TriangleMesh::volume(), and VOLUME_TYPE_KEY.

Referenced by _load_model_from_file().

Here is the call graph for this function:

Here is the caller graph for this function:

_handle_end_build()

bool Slic3r::_3MF_Importer::_handle_end_build ( )

private

    {
        // do nothing
        return true;
    }

_handle_end_component()

bool Slic3r::_3MF_Importer::_handle_end_component ( )

private

    {
        // do nothing
        return true;
    }

_handle_end_components()

bool Slic3r::_3MF_Importer::_handle_end_components ( )

private

    {
        // do nothing
        return true;
    }

_handle_end_config()

bool Slic3r::_3MF_Importer::_handle_end_config ( )

private

    {
        // do nothing
        return true;
    }

_handle_end_config_metadata()

bool Slic3r::_3MF_Importer::_handle_end_config_metadata ( )

private

    {
        // do nothing
        return true;
    }

_handle_end_config_object()

bool Slic3r::_3MF_Importer::_handle_end_config_object ( )

private

    {
        // do nothing
        return true;
    }

_handle_end_config_volume()

bool Slic3r::_3MF_Importer::_handle_end_config_volume ( )

private

    {
        // do nothing
        return true;
    }

_handle_end_config_volume_mesh()

bool Slic3r::_3MF_Importer::_handle_end_config_volume_mesh ( )

private

    {
        // do nothing
        return true;
    }

_handle_end_config_xml_element() [1/2]

void Slic3r::_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(MESH_TAG, name) == 0)
            res = _handle_end_config_volume_mesh();
        else if (::strcmp(METADATA_TAG, name) == 0)
            res = _handle_end_config_metadata();
 
        if (!res)
            _stop_xml_parser();
    }

References CONFIG_TAG, MESH_TAG, METADATA_TAG, OBJECT_TAG, and VOLUME_TAG.

Referenced by _handle_end_config_xml_element().

Here is the caller graph for this function:

_handle_end_config_xml_element() [2/2]

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

staticprivate

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

References _handle_end_config_xml_element().

Here is the call graph for this function:

_handle_end_item()

bool Slic3r::_3MF_Importer::_handle_end_item ( )

private

    {
        // do nothing
        return true;
    }

_handle_end_mesh()

bool Slic3r::_3MF_Importer::_handle_end_mesh ( )

private

    {
        // do nothing
        return true;
    }

_handle_end_metadata()

bool Slic3r::_3MF_Importer::_handle_end_metadata ( )

private

    {
        if (m_curr_metadata_name == SLIC3RPE_3MF_VERSION) {
            m_version = (unsigned int)atoi(m_curr_characters.c_str());
            if (m_check_version && (m_version > VERSION_3MF_COMPATIBLE)) {
                // std::string msg = _u8L("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(_u8L("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 == "Application") {
            // Generator application of the 3MF.
            // SLIC3R_APP_KEY - SLIC3R_VERSION
            if (boost::starts_with(m_curr_characters, "PrusaSlicer-"))
                m_prusaslicer_generator_version = Semver::parse(m_curr_characters.substr(12));
        } else if (m_curr_metadata_name == SLIC3RPE_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,
                _u8L("The selected 3MF contains FDM supports painted object using a newer version of PrusaSlicer and is not compatible."));
        } else if (m_curr_metadata_name == SLIC3RPE_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,
                _u8L("The selected 3MF contains seam painted object using a newer version of PrusaSlicer and is not compatible."));
        } else if (m_curr_metadata_name == SLIC3RPE_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,
                _u8L("The selected 3MF contains multi-material painted object using a newer version of PrusaSlicer and is not compatible."));
        }
 
        return true;
    }

References _u8L, Slic3r::check_painting_version(), FDM_SUPPORTS_PAINTING_VERSION, MM_PAINTING_VERSION, SEAM_PAINTING_VERSION, SLIC3RPE_3MF_VERSION, SLIC3RPE_FDM_SUPPORTS_PAINTING_VERSION, SLIC3RPE_MM_PAINTING_VERSION, SLIC3RPE_SEAM_PAINTING_VERSION, and VERSION_3MF_COMPATIBLE.

Here is the call graph for this function:

_handle_end_model()

bool Slic3r::_3MF_Importer::_handle_end_model ( )

private

    {
        // 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);
        }
 
        if (m_version == 0) {
            // if the 3mf was not produced by PrusaSlicer 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 Slic3r::Model::delete_object(), Slic3r::ModelObject::instances, and Slic3r::Model::objects.

Here is the call graph for this function:

_handle_end_model_xml_element() [1/2]

void Slic3r::_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(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 BUILD_TAG, COMPONENT_TAG, COMPONENTS_TAG, ITEM_TAG, 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(), and _handle_end_model_xml_element().

Here is the caller graph for this function:

_handle_end_model_xml_element() [2/2]

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

staticprivate

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

References _handle_end_model_xml_element().

Here is the call graph for this function:

_handle_end_object()

bool Slic3r::_3MF_Importer::_handle_end_object ( )

private

    {
        if (m_curr_object.object != nullptr) {
            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(m_curr_object.id);
                    if (object_item != m_objects.end())
                        m_objects.erase(object_item);
 
                    IdToAliasesMap::iterator alias_item = m_objects_aliases.find(m_curr_object.id);
                    if (alias_item != m_objects_aliases.end())
                        m_objects_aliases.erase(alias_item);
                }
                else
                    // adds components to aliases
                    m_objects_aliases.insert({ m_curr_object.id, m_curr_object.components });
            }
            else {
                // geometry defined, store it for later use
                m_geometries.insert({ m_curr_object.id, std::move(m_curr_object.geometry) });
 
                // stores the object for later use
                if (m_objects.find(m_curr_object.id) == m_objects.end()) {
                    m_objects.insert({ m_curr_object.id, m_curr_object.model_object_idx });
                    m_objects_aliases.insert({ m_curr_object.id, { 1, Component(m_curr_object.id) } }); // aliases itself
                }
                else {
                    add_error("Found object with duplicate id");
                    return false;
                }
            }
        }
 
        return true;
    }

References Slic3r::_3MF_Importer::CurrentObject::components, Slic3r::Model::delete_object(), Slic3r::_3MF_Importer::Geometry::empty(), Slic3r::_3MF_Importer::CurrentObject::geometry, Slic3r::_3MF_Importer::CurrentObject::id, Slic3r::_3MF_Importer::CurrentObject::model_object_idx, and Slic3r::_3MF_Importer::CurrentObject::object.

Here is the call graph for this function:

_handle_end_resources()

bool Slic3r::_3MF_Importer::_handle_end_resources ( )

private

    {
        // do nothing
        return true;
    }

_handle_end_triangle()

bool Slic3r::_3MF_Importer::_handle_end_triangle ( )

private

    {
        // do nothing
        return true;
    }

_handle_end_triangles()

bool Slic3r::_3MF_Importer::_handle_end_triangles ( )

private

    {
        // do nothing
        return true;
    }

_handle_end_vertex()

bool Slic3r::_3MF_Importer::_handle_end_vertex ( )

private

    {
        // do nothing
        return true;
    }

_handle_end_vertices()

bool Slic3r::_3MF_Importer::_handle_end_vertices ( )

private

    {
        // do nothing
        return true;
    }

_handle_model_xml_characters() [1/2]

void Slic3r::_3MF_Importer::_handle_model_xml_characters ( const XML_Char *  s, int  len  )

private

    {
        m_curr_characters.append(s, len);
    }

Referenced by _extract_model_from_archive(), and _handle_model_xml_characters().

Here is the caller graph for this function:

_handle_model_xml_characters() [2/2]

void XMLCALL Slic3r::_3MF_Importer::_handle_model_xml_characters ( void *  userData, const XML_Char *  s, int  len  )

staticprivate

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

References _handle_model_xml_characters().

Here is the call graph for this function:

_handle_start_build()

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

private

    {
        // do nothing
        return true;
    }

_handle_start_component()

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

private

    {
        int object_id = get_attribute_value_int(attributes, num_attributes, OBJECTID_ATTR);
        Transform3d transform = get_transform_from_3mf_specs_string(get_attribute_value_string(attributes, num_attributes, TRANSFORM_ATTR));
 
        IdToModelObjectMap::iterator object_item = m_objects.find(object_id);
        if (object_item == m_objects.end()) {
            IdToAliasesMap::iterator alias_item = m_objects_aliases.find(object_id);
            if (alias_item == m_objects_aliases.end()) {
                add_error("Found component with invalid object id");
                return false;
            }
        }
 
        m_curr_object.components.emplace_back(object_id, transform);
 
        return true;
    }

References Slic3r::_3MF_Importer::CurrentObject::components, get_attribute_value_int(), get_attribute_value_string(), get_transform_from_3mf_specs_string(), OBJECTID_ATTR, and TRANSFORM_ATTR.

Here is the call graph for this function:

_handle_start_components()

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

private

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

References Slic3r::_3MF_Importer::CurrentObject::components.

_handle_start_config()

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

private

    {
        // do nothing
        return true;
    }

_handle_start_config_metadata()

bool Slic3r::_3MF_Importer::_handle_start_config_metadata ( 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("Cannot assign metadata to valid object id");
            return false;
        }
 
        std::string type = get_attribute_value_string(attributes, num_attributes, TYPE_ATTR);
        std::string key = get_attribute_value_string(attributes, num_attributes, KEY_ATTR);
        std::string value = get_attribute_value_string(attributes, num_attributes, VALUE_ATTR);
 
        if (type == OBJECT_TYPE)
            object->second.metadata.emplace_back(key, value);
        else if (type == VOLUME_TYPE) {
            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 {
            add_error("Found invalid metadata type");
            return false;
        }
 
        return true;
    }

References get_attribute_value_string(), KEY_ATTR, Slic3r::_3MF_Importer::CurrentConfig::object_id, OBJECT_TYPE, TYPE_ATTR, VALUE_ATTR, Slic3r::_3MF_Importer::CurrentConfig::volume_id, and VOLUME_TYPE.

Here is the call graph for this function:

_handle_start_config_object()

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

private

    {
        int object_id = 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("Found duplicated object id");
            return false;
        }
 
        // Added because of github #3435, currently not used by PrusaSlicer
        // int instances_count_id = get_attribute_value_int(attributes, num_attributes, INSTANCESCOUNT_ATTR);
 
        m_objects_metadata.insert({ object_id, ObjectMetadata() });
        m_curr_config.object_id = object_id;
        return true;
    }

References get_attribute_value_int(), ID_ATTR, and Slic3r::_3MF_Importer::CurrentConfig::object_id.

Here is the call graph for this function:

_handle_start_config_volume()

bool Slic3r::_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("Cannot assign volume to a valid object");
            return false;
        }
 
        m_curr_config.volume_id = (int)object->second.volumes.size();
 
        unsigned int first_triangle_id = (unsigned int)get_attribute_value_int(attributes, num_attributes, FIRST_TRIANGLE_ID_ATTR);
        unsigned int last_triangle_id = (unsigned int)get_attribute_value_int(attributes, num_attributes, LAST_TRIANGLE_ID_ATTR);
 
        object->second.volumes.emplace_back(first_triangle_id, last_triangle_id);
        return true;
    }

References FIRST_TRIANGLE_ID_ATTR, get_attribute_value_int(), LAST_TRIANGLE_ID_ATTR, Slic3r::_3MF_Importer::CurrentConfig::object_id, and Slic3r::_3MF_Importer::CurrentConfig::volume_id.

Here is the call graph for this function:

_handle_start_config_volume_mesh()

bool Slic3r::_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("Cannot assign volume mesh to a valid object");
            return false;
        }
        if (object->second.volumes.empty()) {
            add_error("Cannot assign mesh to a valid volume");
            return false;
        }
 
        ObjectMetadata::VolumeMetadata& volume = object->second.volumes.back();
 
        int edges_fixed         = get_attribute_value_int(attributes, num_attributes, MESH_STAT_EDGES_FIXED       );
        int degenerate_facets   = get_attribute_value_int(attributes, num_attributes, MESH_STAT_DEGENERATED_FACETS);
        int facets_removed      = get_attribute_value_int(attributes, num_attributes, MESH_STAT_FACETS_REMOVED    );
        int facets_reversed     = get_attribute_value_int(attributes, num_attributes, MESH_STAT_FACETS_RESERVED   );
        int backwards_edges     = 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 get_attribute_value_int(), MESH_STAT_BACKWARDS_EDGES, MESH_STAT_DEGENERATED_FACETS, MESH_STAT_EDGES_FIXED, MESH_STAT_FACETS_REMOVED, MESH_STAT_FACETS_RESERVED, and Slic3r::_3MF_Importer::CurrentConfig::object_id.

Here is the call graph for this function:

_handle_start_config_xml_element() [1/2]

void Slic3r::_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(MESH_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(TEXT_TAG, name) == 0)
            res = _handle_start_text_configuration(attributes, num_attributes);
 
        if (!res)
            _stop_xml_parser();
    }

References CONFIG_TAG, MESH_TAG, METADATA_TAG, OBJECT_TAG, TEXT_TAG, and VOLUME_TAG.

Referenced by _handle_start_config_xml_element().

Here is the caller graph for this function:

_handle_start_config_xml_element() [2/2]

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

staticprivate

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

References _handle_start_config_xml_element().

Here is the call graph for this function:

_handle_start_item()

bool Slic3r::_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 = get_attribute_value_int(attributes, num_attributes, OBJECTID_ATTR);
        Transform3d transform = get_transform_from_3mf_specs_string(get_attribute_value_string(attributes, num_attributes, TRANSFORM_ATTR));
        int printable = get_attribute_value_bool(attributes, num_attributes, PRINTABLE_ATTR);
 
        return _create_object_instance(object_id, transform, printable, 1);
    }

References get_attribute_value_bool(), get_attribute_value_int(), get_attribute_value_string(), get_transform_from_3mf_specs_string(), OBJECTID_ATTR, PRINTABLE_ATTR, and TRANSFORM_ATTR.

Here is the call graph for this function:

_handle_start_mesh()

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

private

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

References Slic3r::_3MF_Importer::CurrentObject::geometry, and Slic3r::_3MF_Importer::Geometry::reset().

Here is the call graph for this function:

_handle_start_metadata()

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

private

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

References get_attribute_value_string(), and NAME_ATTR.

Here is the call graph for this function:

_handle_start_model()

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

private

    {
        m_unit_factor = get_unit_factor(get_attribute_value_string(attributes, num_attributes, UNIT_ATTR));
        return true;
    }

References get_attribute_value_string(), get_unit_factor(), and UNIT_ATTR.

Here is the call graph for this function:

_handle_start_model_xml_element() [1/2]

void Slic3r::_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(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 BUILD_TAG, COMPONENT_TAG, COMPONENTS_TAG, ITEM_TAG, 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(), and _handle_start_model_xml_element().

Here is the caller graph for this function:

_handle_start_model_xml_element() [2/2]

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

staticprivate

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

References _handle_start_model_xml_element().

Here is the call graph for this function:

_handle_start_object()

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

private

    {
        // reset current data
        m_curr_object.reset();
 
        if (is_valid_object_type(get_attribute_value_string(attributes, num_attributes, TYPE_ATTR))) {
            // 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;
            }
 
            // set object data
            m_curr_object.object->name = get_attribute_value_string(attributes, num_attributes, NAME_ATTR);
            if (m_curr_object.object->name.empty())
                m_curr_object.object->name = m_name + "_" + std::to_string(m_model->objects.size());
 
            m_curr_object.id = get_attribute_value_int(attributes, num_attributes, ID_ATTR);
        }
 
        return true;
    }

References Slic3r::Model::add_object(), get_attribute_value_int(), get_attribute_value_string(), Slic3r::_3MF_Importer::CurrentObject::id, ID_ATTR, is_valid_object_type(), Slic3r::_3MF_Importer::CurrentObject::model_object_idx, Slic3r::ModelObject::name, NAME_ATTR, Slic3r::_3MF_Importer::CurrentObject::object, Slic3r::Model::objects, Slic3r::_3MF_Importer::CurrentObject::reset(), and TYPE_ATTR.

Here is the call graph for this function:

_handle_start_resources()

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

private

    {
        // do nothing
        return true;
    }

_handle_start_text_configuration()

bool Slic3r::_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("Cannot assign volume mesh to a valid object");
            return false;
        }
        if (object->second.volumes.empty()) {
            add_error("Cannot assign mesh to a valid volume");
            return false;
        }
        ObjectMetadata::VolumeMetadata& volume = object->second.volumes.back();
        volume.text_configuration = TextConfigurationSerialization::read(attributes, num_attributes);
        return volume.text_configuration.has_value();
    }

References Slic3r::_3MF_Importer::CurrentConfig::object_id.

_handle_start_triangle()

bool Slic3r::_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
        m_curr_object.geometry.triangles.emplace_back(
            get_attribute_value_int(attributes, num_attributes, V1_ATTR),
            get_attribute_value_int(attributes, num_attributes, V2_ATTR),
            get_attribute_value_int(attributes, num_attributes, V3_ATTR));
 
        m_curr_object.geometry.custom_supports.push_back(get_attribute_value_string(attributes, num_attributes, CUSTOM_SUPPORTS_ATTR));
        m_curr_object.geometry.custom_seam.push_back(get_attribute_value_string(attributes, num_attributes, CUSTOM_SEAM_ATTR));
        m_curr_object.geometry.mmu_segmentation.push_back(get_attribute_value_string(attributes, num_attributes, MMU_SEGMENTATION_ATTR));
        return true;
    }

References Slic3r::_3MF_Importer::Geometry::custom_seam, CUSTOM_SEAM_ATTR, Slic3r::_3MF_Importer::Geometry::custom_supports, CUSTOM_SUPPORTS_ATTR, Slic3r::_3MF_Importer::CurrentObject::geometry, get_attribute_value_int(), get_attribute_value_string(), Slic3r::_3MF_Importer::Geometry::mmu_segmentation, MMU_SEGMENTATION_ATTR, Slic3r::_3MF_Importer::Geometry::triangles, V1_ATTR, V2_ATTR, and V3_ATTR.

Here is the call graph for this function:

_handle_start_triangles()

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

private

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

References Slic3r::_3MF_Importer::CurrentObject::geometry, and Slic3r::_3MF_Importer::Geometry::triangles.

_handle_start_vertex()

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

private

    {
        // appends the vertex coordinates
        // missing values are set equal to ZERO
        m_curr_object.geometry.vertices.emplace_back(
            m_unit_factor * get_attribute_value_float(attributes, num_attributes, X_ATTR),
            m_unit_factor * get_attribute_value_float(attributes, num_attributes, Y_ATTR),
            m_unit_factor * get_attribute_value_float(attributes, num_attributes, Z_ATTR));
        return true;
    }

References Slic3r::_3MF_Importer::CurrentObject::geometry, get_attribute_value_float(), Slic3r::_3MF_Importer::Geometry::vertices, X_ATTR, Y_ATTR, and Z_ATTR.

Here is the call graph for this function:

_handle_start_vertices()

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

private

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

References Slic3r::_3MF_Importer::CurrentObject::geometry, and Slic3r::_3MF_Importer::Geometry::vertices.

_load_model_from_file()

bool Slic3r::_3MF_Importer::_load_model_from_file ( const std::string &  filename, Model &  model, DynamicPrintConfig &  config, ConfigSubstitutionContext &  config_substitutions  )

private

    {
        mz_zip_archive archive;
        mz_zip_zero_struct(&archive);
 
        if (!open_zip_reader(&archive, filename)) {
            add_error("Unable to open the file");
            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();
 
        // we first loop the entries to read from the archive the .model file only, in order to extract the version from it
        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(), '\\', '/');
 
                if (boost::algorithm::istarts_with(name, MODEL_FOLDER) && boost::algorithm::iends_with(name, MODEL_EXTENSION)) {
                    try
                    {
                        // valid model name -> extract model
                        if (!_extract_model_from_archive(archive, stat)) {
                            close_zip_reader(&archive);
                            add_error("Archive does not contain a valid model");
                            return false;
                        }
                    }
                    catch (const std::exception& e)
                    {
                        // ensure the zip archive is closed and rethrow the exception
                        close_zip_reader(&archive);
                        throw Slic3r::FileIOError(e.what());
                    }
                }
            }
        }
 
        // 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)) {
                std::string name(stat.m_filename);
                std::replace(name.begin(), name.end(), '\\', '/');
 
                if (boost::algorithm::iequals(name, 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, CUT_INFORMATION_FILE)) {
                    // extract slic3r layer config ranges file
                    _extract_cut_information_from_archive(archive, stat, config_substitutions);
                }
                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, 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);
                }
                else if (boost::algorithm::iequals(name, PRINT_CONFIG_FILE)) {
                    // extract slic3r print config file
                    _extract_print_config_from_archive(archive, stat, config, config_substitutions, filename);
                }
                else if (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, MODEL_CONFIG_FILE)) {
                    // extract slic3r model config file
                    if (!_extract_model_config_from_archive(archive, stat, model)) {
                        close_zip_reader(&archive);
                        add_error("Archive does not contain a valid model config");
                        return false;
                    }
                }
            }
        }
 
        close_zip_reader(&archive);
 
        if (m_version == 0) {
            // if the 3mf was not produced by PrusaSlicer and there is more than one instance,
            // split the object in as many objects as instances
            size_t curr_models_count = m_model->objects.size();
            size_t i = 0;
            while (i < curr_models_count) {
                ModelObject* model_object = m_model->objects[i];
                if (model_object->instances.size() > 1) {
                    // select the geometry associated with the original model object
                    const Geometry* geometry = nullptr;
                    for (const IdToModelObjectMap::value_type& object : m_objects) {
                        if (object.second == int(i)) {
                            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;
                            }
                            geometry = &obj_geometry->second;
                            break;
                        }
                    }
 
                    if (geometry == nullptr) {
                        add_error("Unable to find object geometry");
                        return false;
                    }
 
                    // use the geometry to create the volumes in the new model objects
                    ObjectMetadata::VolumeMetadataList volumes(1, { 0, (unsigned int)geometry->triangles.size() - 1 });
 
                    // 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_model_object, *geometry, volumes, config_substitutions))
                            return false;
                    }
                }
                ++i;
            }
        }
 
        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];
            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);
 
            // 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);
            }
 
            ObjectMetadata::VolumeMetadataList volumes;
            ObjectMetadata::VolumeMetadataList* volumes_ptr = nullptr;
 
            IdToMetadataMap::iterator obj_metadata = m_objects_metadata.find(object.first);
            if (obj_metadata != m_objects_metadata.end()) {
                // config data has been found, this model was saved using slic3r pe
 
                // apply object's name and config data
                for (const Metadata& metadata : obj_metadata->second.metadata) {
                    if (metadata.key == "name")
                        model_object->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
 
                // add the entire geometry as the single volume to generate
                volumes.emplace_back(0, (int)obj_geometry->second.triangles.size() - 1);
 
                // select as volumes
                volumes_ptr = &volumes;
            }
 
            if (!_generate_volumes(*model_object, obj_geometry->second, *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());
                }
            }
        }
 
        for (int obj_id = 0; obj_id < int(model.objects.size()); ++obj_id) {
            ModelObject* o = model.objects[obj_id];
            for (int vol_id = 0; vol_id < int(o->volumes.size()); ++vol_id) {
                ModelVolume* v = o->volumes[vol_id];
                if (v->source.input_file.empty())
                    v->source.input_file = filename;
                if (v->source.volume_idx == -1)
                    v->source.volume_idx = vol_id;
                if (v->source.object_idx == -1)
                    v->source.object_idx = obj_id;
            }
        }
 
//        // fixes the min z of the model if negative
//        model.adjust_min_z();
 
        return true;
    }

References _extract_custom_gcode_per_print_z_from_archive(), _extract_cut_information_from_archive(), _extract_layer_config_ranges_from_archive(), _extract_layer_heights_profile_config_from_archive(), _extract_model_config_from_archive(), _extract_model_from_archive(), _extract_print_config_from_archive(), _extract_sla_drain_holes_from_archive(), _extract_sla_support_points_from_archive(), _generate_volumes(), Slic3r::_3MF_Base::add_error(), Slic3r::ModelObject::add_instance(), Slic3r::Model::add_object(), Slic3r::ModelObject::clear_instances(), Slic3r::close_zip_reader(), Slic3r::ModelObject::config, CUSTOM_GCODE_PER_PRINT_Z_FILE, Slic3r::ModelObject::cut_id, CUT_INFORMATION_FILE, Slic3r::ModelObject::delete_last_instance(), Slic3r::Geometry::Transformation::get_offset(), Slic3r::ModelVolume::get_transformation(), Slic3r::ModelInstance::get_transformation(), Slic3r::ObjectBase::id(), Slic3r::ModelVolume::Source::input_file, Slic3r::ModelObject::instances, Slic3r::ModelObject::layer_config_ranges, LAYER_CONFIG_RANGES_FILE, Slic3r::ModelObject::layer_height_profile, LAYER_HEIGHTS_PROFILE_FILE, m_cut_object_infos, m_geometries, m_layer_config_ranges, m_layer_heights_profiles, m_model, m_name, m_objects, m_objects_metadata, m_sla_drain_holes, m_sla_support_points, m_version, MODEL_CONFIG_FILE, MODEL_EXTENSION, MODEL_FOLDER, mz_zip_reader_file_stat(), mz_zip_reader_get_num_files(), mz_zip_zero_struct(), Slic3r::ModelObject::name, Slic3r::ModelVolume::Source::object_idx, Slic3r::Model::objects, Slic3r::open_zip_reader(), PRINT_CONFIG_FILE, Slic3r::LayerHeightProfile::set(), Slic3r::ModelConfig::set_deserialize(), Slic3r::ModelVolume::set_offset(), Slic3r::ModelInstance::set_offset(), Slic3r::ModelObject::sla_drain_holes, SLA_DRAIN_HOLES_FILE, Slic3r::ModelObject::sla_points_status, Slic3r::ModelObject::sla_support_points, SLA_SUPPORT_POINTS_FILE, Slic3r::ModelVolume::source, stat, Slic3r::_3MF_Importer::Geometry::triangles, Slic3r::sla::UserModified, Slic3r::ModelVolume::Source::volume_idx, and Slic3r::ModelObject::volumes.

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::_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.

add_error()

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

inlineprotectedinherited

{ m_errors.push_back(error); }

References error, and Slic3r::_3MF_Base::m_errors.

Referenced by _extract_model_from_archive(), and _load_model_from_file().

Here is the caller graph for this function:

clear_errors()

void Slic3r::_3MF_Base::clear_errors ( )

inlineprotectedinherited

{ m_errors.clear(); }

References Slic3r::_3MF_Base::m_errors.

Referenced by load_model_from_file().

Here is the caller graph for this function:

load_model_from_file()

bool Slic3r::_3MF_Importer::load_model_from_file	(	const std::string &	filename,
		Model &	model,
		DynamicPrintConfig &	config,
		ConfigSubstitutionContext &	config_substitutions,
		bool	check_version
	)

    {
        m_version = 0;
        m_fdm_supports_painting_version = 0;
        m_seam_painting_version = 0;
        m_mm_painting_version = 0;
        m_check_version = check_version;
        m_model = &model;
        m_unit_factor = 1.0f;
        m_curr_object.reset();
        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_layer_heights_profiles.clear();
        m_layer_config_ranges.clear();
        m_sla_support_points.clear();
        m_curr_metadata_name.clear();
        m_curr_characters.clear();
        clear_errors();
 
        return _load_model_from_file(filename, model, config, config_substitutions);
    }

References _load_model_from_file(), Slic3r::_3MF_Base::clear_errors(), m_check_version, m_curr_characters, m_curr_config, m_curr_metadata_name, m_curr_object, m_fdm_supports_painting_version, m_geometries, m_instances, m_layer_config_ranges, m_layer_heights_profiles, m_mm_painting_version, m_model, m_objects, m_objects_aliases, m_objects_metadata, m_seam_painting_version, m_sla_support_points, m_unit_factor, m_version, Slic3r::_3MF_Importer::CurrentConfig::object_id, Slic3r::_3MF_Importer::CurrentObject::reset(), and Slic3r::_3MF_Importer::CurrentConfig::volume_id.

Referenced by Slic3r::load_3mf().

Here is the call graph for this function:

Here is the caller graph for this function:

log_errors()

void Slic3r::_3MF_Base::log_errors ( )

inlineinherited

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

References error, and Slic3r::_3MF_Base::m_errors.

Referenced by Slic3r::load_3mf(), and Slic3r::store_3mf().

Here is the caller graph for this function:

parse_error()

bool Slic3r::_3MF_Importer::parse_error ( ) const

inlineprivate

{ return m_parse_error; }

References m_parse_error.

parse_error_message()

const char * Slic3r::_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.

prusaslicer_generator_version()

boost::optional< Semver > Slic3r::_3MF_Importer::prusaslicer_generator_version ( ) const

inline

{ return m_prusaslicer_generator_version; }

References m_prusaslicer_generator_version.

Referenced by Slic3r::load_3mf().

Here is the caller graph for this function:

version()

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

inline

{ return m_version; }

References m_version.

Referenced by Slic3r::load_3mf().

Here is the caller graph for this function:

Member Data Documentation

m_check_version

bool Slic3r::_3MF_Importer::m_check_version

private

Referenced by load_model_from_file().

m_curr_characters

std::string Slic3r::_3MF_Importer::m_curr_characters

private

Referenced by load_model_from_file().

m_curr_config

CurrentConfig Slic3r::_3MF_Importer::m_curr_config

private

Referenced by load_model_from_file().

m_curr_metadata_name

std::string Slic3r::_3MF_Importer::m_curr_metadata_name

private

Referenced by load_model_from_file().

m_curr_object

CurrentObject Slic3r::_3MF_Importer::m_curr_object

private

Referenced by load_model_from_file().

m_cut_object_infos

IdToCutObjectInfoMap Slic3r::_3MF_Importer::m_cut_object_infos

private

Referenced by _load_model_from_file().

m_errors

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

privateinherited

Referenced by Slic3r::_3MF_Base::add_error(), Slic3r::_3MF_Base::clear_errors(), and Slic3r::_3MF_Base::log_errors().

m_fdm_supports_painting_version

unsigned int Slic3r::_3MF_Importer::m_fdm_supports_painting_version = 0

private

Referenced by load_model_from_file().

m_geometries

IdToGeometryMap Slic3r::_3MF_Importer::m_geometries

private

Referenced by _load_model_from_file(), and load_model_from_file().

m_instances

InstancesList Slic3r::_3MF_Importer::m_instances

private

Referenced by load_model_from_file().

m_layer_config_ranges

IdToLayerConfigRangesMap Slic3r::_3MF_Importer::m_layer_config_ranges

private

Referenced by _load_model_from_file(), and load_model_from_file().

m_layer_heights_profiles

IdToLayerHeightsProfileMap Slic3r::_3MF_Importer::m_layer_heights_profiles

private

Referenced by _load_model_from_file(), and load_model_from_file().

m_mm_painting_version

unsigned int Slic3r::_3MF_Importer::m_mm_painting_version = 0

private

Referenced by load_model_from_file().

m_model

Model* Slic3r::_3MF_Importer::m_model

private

Referenced by _load_model_from_file(), and load_model_from_file().

m_name

std::string Slic3r::_3MF_Importer::m_name

private

Referenced by _load_model_from_file().

m_objects

IdToModelObjectMap Slic3r::_3MF_Importer::m_objects

private

Referenced by _load_model_from_file(), and load_model_from_file().

m_objects_aliases

IdToAliasesMap Slic3r::_3MF_Importer::m_objects_aliases

private

Referenced by load_model_from_file().

m_objects_metadata

IdToMetadataMap Slic3r::_3MF_Importer::m_objects_metadata

private

Referenced by _load_model_from_file(), and load_model_from_file().

m_parse_error

bool Slic3r::_3MF_Importer::m_parse_error { false }

private

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

m_parse_error_message

std::string Slic3r::_3MF_Importer::m_parse_error_message

private

Referenced by _stop_xml_parser(), and parse_error_message().

m_prusaslicer_generator_version

boost::optional<Semver> Slic3r::_3MF_Importer::m_prusaslicer_generator_version

private

Referenced by prusaslicer_generator_version().

m_seam_painting_version

unsigned int Slic3r::_3MF_Importer::m_seam_painting_version = 0

private

Referenced by load_model_from_file().

m_sla_drain_holes

IdToSlaDrainHolesMap Slic3r::_3MF_Importer::m_sla_drain_holes

private

Referenced by _load_model_from_file().

m_sla_support_points

IdToSlaSupportPointsMap Slic3r::_3MF_Importer::m_sla_support_points

private

Referenced by _load_model_from_file(), and load_model_from_file().

m_unit_factor

float Slic3r::_3MF_Importer::m_unit_factor

private

Referenced by load_model_from_file().

m_version

unsigned int Slic3r::_3MF_Importer::m_version

private

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

m_xml_parser

XML_Parser Slic3r::_3MF_Importer::m_xml_parser

private

Referenced by _destroy_xml_parser(), _extract_model_from_archive(), _stop_xml_parser(), and parse_error_message().

---

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

• src/libslic3r/Format/3mf.cpp