Slic3r::_3MF_Exporter Class Reference

Inheritance diagram for Slic3r::_3MF_Exporter:

Collaboration diagram for Slic3r::_3MF_Exporter:

Classes
struct	BuildItem
struct	ObjectData
struct	Offsets

Public Member Functions
bool	save_model_to_file (const std::string &filename, Model &model, const DynamicPrintConfig *config, bool fullpath_sources, const ThumbnailData *thumbnail_data, bool zip64)
void	log_errors ()

Static Public Member Functions
static void	add_transformation (std::stringstream &stream, const Transform3d &tr)

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

Private Types
typedef std::map< const ModelVolume *, Offsets >	VolumeToOffsetsMap
typedef std::vector< BuildItem >	BuildItemsList
typedef std::map< int, ObjectData >	IdToObjectDataMap

Private Member Functions
bool	_save_model_to_file (const std::string &filename, Model &model, const DynamicPrintConfig *config, const ThumbnailData *thumbnail_data)
bool	_add_content_types_file_to_archive (mz_zip_archive &archive)
bool	_add_thumbnail_file_to_archive (mz_zip_archive &archive, const ThumbnailData &thumbnail_data)
bool	_add_relationships_file_to_archive (mz_zip_archive &archive)
bool	_add_model_file_to_archive (const std::string &filename, mz_zip_archive &archive, const Model &model, IdToObjectDataMap &objects_data)
bool	_add_object_to_model_stream (mz_zip_writer_staged_context &context, unsigned int &object_id, ModelObject &object, BuildItemsList &build_items, VolumeToOffsetsMap &volumes_offsets)
bool	_add_mesh_to_object_stream (mz_zip_writer_staged_context &context, ModelObject &object, VolumeToOffsetsMap &volumes_offsets)
bool	_add_build_to_model_stream (std::stringstream &stream, const BuildItemsList &build_items)
bool	_add_cut_information_file_to_archive (mz_zip_archive &archive, Model &model)
bool	_add_layer_height_profile_file_to_archive (mz_zip_archive &archive, Model &model)
bool	_add_layer_config_ranges_file_to_archive (mz_zip_archive &archive, Model &model)
bool	_add_sla_support_points_file_to_archive (mz_zip_archive &archive, Model &model)
bool	_add_sla_drain_holes_file_to_archive (mz_zip_archive &archive, Model &model)
bool	_add_print_config_file_to_archive (mz_zip_archive &archive, const DynamicPrintConfig &config)
bool	_add_model_config_file_to_archive (mz_zip_archive &archive, const Model &model, const IdToObjectDataMap &objects_data)
bool	_add_custom_gcode_per_print_z_file_to_archive (mz_zip_archive &archive, Model &model, const DynamicPrintConfig *config)

Private Attributes
bool	m_fullpath_sources { true }
bool	m_zip64 { true }
std::vector< std::string >	m_errors

Detailed Description

Member Typedef Documentation

BuildItemsList

typedef std::vector<BuildItem> Slic3r::_3MF_Exporter::BuildItemsList

private

IdToObjectDataMap

typedef std::map<int, ObjectData> Slic3r::_3MF_Exporter::IdToObjectDataMap

private

VolumeToOffsetsMap

typedef std::map<const ModelVolume*, Offsets> Slic3r::_3MF_Exporter::VolumeToOffsetsMap

private

Member Function Documentation

_add_build_to_model_stream()

bool Slic3r::_3MF_Exporter::_add_build_to_model_stream ( std::stringstream &  stream, const BuildItemsList &  build_items  )

private

    {
        // This happens for empty projects
        if (build_items.size() == 0) {
            add_error("No build item found");
            return true;
        }
 
        stream << " <" << BUILD_TAG << ">\n";
 
        for (const BuildItem& item : build_items) {
            stream << "  <" << ITEM_TAG << " " << OBJECTID_ATTR << "=\"" << item.id << "\" " << TRANSFORM_ATTR << "=\"";
            add_transformation(stream, item.transform);
            stream << "\" " << PRINTABLE_ATTR << "=\"" << item.printable << "\"/>\n";
        }
 
        stream << " </" << BUILD_TAG << ">\n";
 
        return true;
    }

References BUILD_TAG, ITEM_TAG, OBJECTID_ATTR, PRINTABLE_ATTR, and TRANSFORM_ATTR.

_add_content_types_file_to_archive()

bool Slic3r::_3MF_Exporter::_add_content_types_file_to_archive ( mz_zip_archive &  archive )

private

    {
        std::stringstream stream;
        stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
        stream << "<Types xmlns=\"http://schemas.openxmlformats.org/package/2006/content-types\">\n";
        stream << " <Default Extension=\"rels\" ContentType=\"application/vnd.openxmlformats-package.relationships+xml\"/>\n";
        stream << " <Default Extension=\"model\" ContentType=\"application/vnd.ms-package.3dmanufacturing-3dmodel+xml\"/>\n";
        stream << " <Default Extension=\"png\" ContentType=\"image/png\"/>\n";
        stream << "</Types>";
 
        std::string out = stream.str();
 
        if (!mz_zip_writer_add_mem(&archive, CONTENT_TYPES_FILE.c_str(), (const void*)out.data(), out.length(), MZ_DEFAULT_COMPRESSION)) {
            add_error("Unable to add content types file to archive");
            return false;
        }
 
        return true;
    }

References CONTENT_TYPES_FILE, MZ_DEFAULT_COMPRESSION, and mz_zip_writer_add_mem().

Here is the call graph for this function:

_add_custom_gcode_per_print_z_file_to_archive()

bool Slic3r::_3MF_Exporter::_add_custom_gcode_per_print_z_file_to_archive ( mz_zip_archive &  archive, Model &  model, const DynamicPrintConfig *  config  )

private

{
    std::string out = "";
 
    if (!model.custom_gcode_per_print_z.gcodes.empty()) {
        pt::ptree tree;
        pt::ptree& main_tree = tree.add("custom_gcodes_per_print_z", "");
 
        for (const CustomGCode::Item& code : model.custom_gcode_per_print_z.gcodes) {
            pt::ptree& code_tree = main_tree.add("code", "");
 
            // store data of custom_gcode_per_print_z
            code_tree.put("<xmlattr>.print_z"   , code.print_z  );
            code_tree.put("<xmlattr>.type"      , static_cast<int>(code.type));
            code_tree.put("<xmlattr>.extruder"  , code.extruder );
            code_tree.put("<xmlattr>.color"     , code.color    );
            code_tree.put("<xmlattr>.extra"     , code.extra    );
 
            // add gcode field data for the old version of the PrusaSlicer
            std::string gcode = code.type == CustomGCode::ColorChange ? config->opt_string("color_change_gcode")    :
                                code.type == CustomGCode::PausePrint  ? config->opt_string("pause_print_gcode")     :
                                code.type == CustomGCode::Template    ? config->opt_string("template_custom_gcode") :
                                code.type == CustomGCode::ToolChange  ? "tool_change"   : code.extra; 
            code_tree.put("<xmlattr>.gcode"     , gcode   );
        }
 
        pt::ptree& mode_tree = main_tree.add("mode", "");
        // store mode of a custom_gcode_per_print_z 
        mode_tree.put("<xmlattr>.value", model.custom_gcode_per_print_z.mode == CustomGCode::Mode::SingleExtruder ? CustomGCode::SingleExtruderMode :
                                         model.custom_gcode_per_print_z.mode == CustomGCode::Mode::MultiAsSingle ?  CustomGCode::MultiAsSingleMode :
                                         CustomGCode::MultiExtruderMode);
 
        if (!tree.empty()) {
            std::ostringstream oss;
            boost::property_tree::write_xml(oss, tree);
            out = oss.str();
 
            // Post processing("beautification") of the output string
            boost::replace_all(out, "><", ">\n<");
        }
    } 
 
    if (!out.empty()) {
        if (!mz_zip_writer_add_mem(&archive, CUSTOM_GCODE_PER_PRINT_Z_FILE.c_str(), (const void*)out.data(), out.length(), MZ_DEFAULT_COMPRESSION)) {
            add_error("Unable to add custom Gcodes per print_z file to archive");
            return false;
        }
    }
 
    return true;
}

References Slic3r::Model::custom_gcode_per_print_z, CUSTOM_GCODE_PER_PRINT_Z_FILE, Slic3r::CustomGCode::Info::gcodes, Slic3r::CustomGCode::Info::mode, MZ_DEFAULT_COMPRESSION, mz_zip_writer_add_mem(), and Slic3r::ConfigBase::opt_string().

Here is the call graph for this function:

_add_cut_information_file_to_archive()

bool Slic3r::_3MF_Exporter::_add_cut_information_file_to_archive ( mz_zip_archive &  archive, Model &  model  )

private

    {
        std::string out = "";
        pt::ptree tree;
 
        unsigned int object_cnt = 0;
        for (const ModelObject* object : model.objects) {
            object_cnt++;
            if (!object->is_cut())
                continue;
            pt::ptree& obj_tree = tree.add("objects.object", "");
 
            obj_tree.put("<xmlattr>.id", object_cnt);
 
            // Store info for cut_id
            pt::ptree& cut_id_tree = obj_tree.add("cut_id", "");
 
            // store cut_id atributes
            cut_id_tree.put("<xmlattr>.id",             object->cut_id.id().id);
            cut_id_tree.put("<xmlattr>.check_sum",      object->cut_id.check_sum());
            cut_id_tree.put("<xmlattr>.connectors_cnt", object->cut_id.connectors_cnt());
 
            int volume_idx = -1;
            for (const ModelVolume* volume : object->volumes) {
                ++volume_idx;
                if (volume->is_cut_connector()) {
                    pt::ptree& connectors_tree = obj_tree.add("connectors.connector", "");
                    connectors_tree.put("<xmlattr>.volume_id",   volume_idx);
                    connectors_tree.put("<xmlattr>.type",        int(volume->cut_info.connector_type));
                    connectors_tree.put("<xmlattr>.r_tolerance", volume->cut_info.radius_tolerance);
                    connectors_tree.put("<xmlattr>.h_tolerance", volume->cut_info.height_tolerance);
                }
            }
        }
 
        if (!tree.empty()) {
            std::ostringstream oss;
            pt::write_xml(oss, tree);
            out = oss.str();
 
            // Post processing("beautification") of the output string for a better preview
            boost::replace_all(out, "><object", ">\n <object");
            boost::replace_all(out, "><cut_id", ">\n  <cut_id");
            boost::replace_all(out, "></cut_id>", ">\n  </cut_id>");
            boost::replace_all(out, "><connectors", ">\n  <connectors");
            boost::replace_all(out, "></connectors>", ">\n  </connectors>");
            boost::replace_all(out, "><connector", ">\n   <connector");
            boost::replace_all(out, "></connector>", ">\n   </connector>");
            boost::replace_all(out, "></object>", ">\n </object>");
            // OR just 
            boost::replace_all(out, "><", ">\n<");
        }
 
        if (!out.empty()) {
            if (!mz_zip_writer_add_mem(&archive, CUT_INFORMATION_FILE.c_str(), (const void*)out.data(), out.length(), MZ_DEFAULT_COMPRESSION)) {
                add_error("Unable to add cut information file to archive");
                return false;
            }
        }
 
        return true;
    }

References CUT_INFORMATION_FILE, MZ_DEFAULT_COMPRESSION, mz_zip_writer_add_mem(), and Slic3r::Model::objects.

Here is the call graph for this function:

_add_layer_config_ranges_file_to_archive()

bool Slic3r::_3MF_Exporter::_add_layer_config_ranges_file_to_archive ( mz_zip_archive &  archive, Model &  model  )

private

    {
        std::string out = "";
        pt::ptree tree;
 
        unsigned int object_cnt = 0;
        for (const ModelObject* object : model.objects) {
            object_cnt++;
            const t_layer_config_ranges& ranges = object->layer_config_ranges;
            if (!ranges.empty())
            {
                pt::ptree& obj_tree = tree.add("objects.object","");
 
                obj_tree.put("<xmlattr>.id", object_cnt);
 
                // Store the layer config ranges.
                for (const auto& range : ranges) {
                    pt::ptree& range_tree = obj_tree.add("range", "");
 
                    // store minX and maxZ
                    range_tree.put("<xmlattr>.min_z", range.first.first);
                    range_tree.put("<xmlattr>.max_z", range.first.second);
 
                    // store range configuration
                    const ModelConfig& config = range.second;
                    for (const std::string& opt_key : config.keys()) {
                        pt::ptree& opt_tree = range_tree.add("option", config.opt_serialize(opt_key));
                        opt_tree.put("<xmlattr>.opt_key", opt_key);
                    }
                }
            }
        }
 
        if (!tree.empty()) {
            std::ostringstream oss;
            pt::write_xml(oss, tree);
            out = oss.str();
 
            // Post processing("beautification") of the output string for a better preview
            boost::replace_all(out, "><object",      ">\n <object");
            boost::replace_all(out, "><range",       ">\n  <range");
            boost::replace_all(out, "><option",      ">\n   <option");
            boost::replace_all(out, "></range>",     ">\n  </range>");
            boost::replace_all(out, "></object>",    ">\n </object>");
            // OR just 
            boost::replace_all(out, "><",            ">\n<"); 
        }
 
        if (!out.empty()) {
            if (!mz_zip_writer_add_mem(&archive, LAYER_CONFIG_RANGES_FILE.c_str(), (const void*)out.data(), out.length(), MZ_DEFAULT_COMPRESSION)) {
                add_error("Unable to add layer heights profile file to archive");
                return false;
            }
        }
 
        return true;
    }

References Slic3r::ModelConfig::keys(), LAYER_CONFIG_RANGES_FILE, MZ_DEFAULT_COMPRESSION, mz_zip_writer_add_mem(), Slic3r::Model::objects, Slic3r::ModelConfig::opt_serialize(), and Slic3r::range().

Here is the call graph for this function:

_add_layer_height_profile_file_to_archive()

bool Slic3r::_3MF_Exporter::_add_layer_height_profile_file_to_archive ( mz_zip_archive &  archive, Model &  model  )

private

    {
        assert(is_decimal_separator_point());
        std::string out = "";
        char buffer[1024];
 
        unsigned int count = 0;
        for (const ModelObject* object : model.objects) {
            ++count;
            const std::vector<double>& layer_height_profile = object->layer_height_profile.get();
            if (layer_height_profile.size() >= 4 && layer_height_profile.size() % 2 == 0) {
                sprintf(buffer, "object_id=%d|", count);
                out += buffer;
 
                // Store the layer height profile as a single semicolon separated list.
                for (size_t i = 0; i < layer_height_profile.size(); ++i) {
                    sprintf(buffer, (i == 0) ? "%f" : ";%f", layer_height_profile[i]);
                    out += buffer;
                }
                
                out += "\n";
            }
        }
 
        if (!out.empty()) {
            if (!mz_zip_writer_add_mem(&archive, LAYER_HEIGHTS_PROFILE_FILE.c_str(), (const void*)out.data(), out.length(), MZ_DEFAULT_COMPRESSION)) {
                add_error("Unable to add layer heights profile file to archive");
                return false;
            }
        }
 
        return true;
    }

References Slic3r::is_decimal_separator_point(), LAYER_HEIGHTS_PROFILE_FILE, MZ_DEFAULT_COMPRESSION, mz_zip_writer_add_mem(), and Slic3r::Model::objects.

Here is the call graph for this function:

_add_mesh_to_object_stream()

bool Slic3r::_3MF_Exporter::_add_mesh_to_object_stream ( mz_zip_writer_staged_context &  context, ModelObject &  object, VolumeToOffsetsMap &  volumes_offsets  )

private

    {
        std::string output_buffer;
        output_buffer += "   <";
        output_buffer += MESH_TAG;
        output_buffer += ">\n    <";
        output_buffer += VERTICES_TAG;
        output_buffer += ">\n";
 
        auto flush = [this, &output_buffer, &context](bool force = false) {
            if ((force && ! output_buffer.empty()) || output_buffer.size() >= 65536 * 16) {
                if (! mz_zip_writer_add_staged_data(&context, output_buffer.data(), output_buffer.size())) {
                    add_error("Error during writing or compression");
                    return false;
                }
                output_buffer.clear();
            }
            return true;
        };
 
        auto format_coordinate = [](float f, char *buf) -> char* {
            assert(is_decimal_separator_point());
#if EXPORT_3MF_USE_SPIRIT_KARMA_FP
            // Slightly faster than sprintf("%.9g"), but there is an issue with the karma floating point formatter,
            // https://github.com/boostorg/spirit/pull/586
            // where the exported string is one digit shorter than it should be to guarantee lossless round trip.
            // The code is left here for the ocasion boost guys improve.
            coordinate_type_fixed      const coordinate_fixed      = coordinate_type_fixed();
            coordinate_type_scientific const coordinate_scientific = coordinate_type_scientific();
            // Format "f" in a fixed format.
            char *ptr = buf;
            boost::spirit::karma::generate(ptr, coordinate_fixed, f);
            // Format "f" in a scientific format.
            char *ptr2 = ptr;
            boost::spirit::karma::generate(ptr2, coordinate_scientific, f);
            // Return end of the shorter string.
            auto len2 = ptr2 - ptr;
            if (ptr - buf > len2) {
                // Move the shorter scientific form to the front.
                memcpy(buf, ptr, len2);
                ptr = buf + len2;
            }
            // Return pointer to the end.
            return ptr;
#else
            // Round-trippable float, shortest possible.
            return buf + sprintf(buf, "%.9g", f);
#endif
        };
 
        char buf[256];
        unsigned int vertices_count = 0;
        for (ModelVolume* volume : object.volumes) {
            if (volume == nullptr)
                continue;
 
            volumes_offsets.insert({ volume, Offsets(vertices_count) });
 
            const indexed_triangle_set &its = volume->mesh().its;
            if (its.vertices.empty()) {
                add_error("Found invalid mesh");
                return false;
            }
 
            vertices_count += (int)its.vertices.size();
 
            const Transform3d& matrix = volume->get_matrix();
            for (const auto& vertex: its.vertices) {
                Vec3f v = (matrix * vertex.cast<double>()).cast<float>();
                char *ptr = buf;
                boost::spirit::karma::generate(ptr, boost::spirit::lit("     <") << VERTEX_TAG << " x=\"");
                ptr = format_coordinate(v.x(), ptr);
                boost::spirit::karma::generate(ptr, "\" y=\"");
                ptr = format_coordinate(v.y(), ptr);
                boost::spirit::karma::generate(ptr, "\" z=\"");
                ptr = format_coordinate(v.z(), ptr);
                boost::spirit::karma::generate(ptr, "\"/>\n");
                *ptr = '\0';
                output_buffer += buf;
                if (! flush())
                    return false;
            }
        }
 
        output_buffer += "    </";
        output_buffer += VERTICES_TAG;
        output_buffer += ">\n    <";
        output_buffer += TRIANGLES_TAG;
        output_buffer += ">\n";
 
        unsigned int triangles_count = 0;
        for (ModelVolume* volume : object.volumes) {
            if (volume == nullptr)
                continue;
 
            bool is_left_handed = volume->is_left_handed();
            VolumeToOffsetsMap::iterator volume_it = volumes_offsets.find(volume);
            assert(volume_it != volumes_offsets.end());
 
            const indexed_triangle_set &its = volume->mesh().its;
 
            // updates triangle offsets
            volume_it->second.first_triangle_id = triangles_count;
            triangles_count += (int)its.indices.size();
            volume_it->second.last_triangle_id = triangles_count - 1;
 
            for (int i = 0; i < int(its.indices.size()); ++ i) {
                {
                    const Vec3i &idx = its.indices[i];
                    char *ptr = buf;
                    boost::spirit::karma::generate(ptr, boost::spirit::lit("     <") << TRIANGLE_TAG <<
                        " v1=\"" << boost::spirit::int_ <<
                        "\" v2=\"" << boost::spirit::int_ <<
                        "\" v3=\"" << boost::spirit::int_ << "\"",
                        idx[is_left_handed ? 2 : 0] + volume_it->second.first_vertex_id,
                        idx[1] + volume_it->second.first_vertex_id,
                        idx[is_left_handed ? 0 : 2] + volume_it->second.first_vertex_id);
                    *ptr = '\0';
                    output_buffer += buf;
                }
 
                std::string custom_supports_data_string = volume->supported_facets.get_triangle_as_string(i);
                if (! custom_supports_data_string.empty()) {
                    output_buffer += " ";
                    output_buffer += CUSTOM_SUPPORTS_ATTR;
                    output_buffer += "=\"";
                    output_buffer += custom_supports_data_string;
                    output_buffer += "\"";
                }
 
                std::string custom_seam_data_string = volume->seam_facets.get_triangle_as_string(i);
                if (! custom_seam_data_string.empty()) {
                    output_buffer += " ";
                    output_buffer += CUSTOM_SEAM_ATTR;
                    output_buffer += "=\"";
                    output_buffer += custom_seam_data_string;
                    output_buffer += "\"";
                }
 
                std::string mmu_painting_data_string = volume->mmu_segmentation_facets.get_triangle_as_string(i);
                if (! mmu_painting_data_string.empty()) {
                    output_buffer += " ";
                    output_buffer += MMU_SEGMENTATION_ATTR;
                    output_buffer += "=\"";
                    output_buffer += mmu_painting_data_string;
                    output_buffer += "\"";
                }
 
                output_buffer += "/>\n";
 
                if (! flush())
                    return false;
            }
        }
 
        output_buffer += "    </";
        output_buffer += TRIANGLES_TAG;
        output_buffer += ">\n   </";
        output_buffer += MESH_TAG;
        output_buffer += ">\n";
 
        // Force flush.
        return flush(true);
    }

References CUSTOM_SEAM_ATTR, CUSTOM_SUPPORTS_ATTR, indexed_triangle_set::indices, Slic3r::is_decimal_separator_point(), MESH_TAG, MMU_SEGMENTATION_ATTR, mz_zip_writer_add_staged_data(), TRIANGLE_TAG, TRIANGLES_TAG, VERTEX_TAG, indexed_triangle_set::vertices, and VERTICES_TAG.

Here is the call graph for this function:

_add_model_config_file_to_archive()

bool Slic3r::_3MF_Exporter::_add_model_config_file_to_archive ( mz_zip_archive &  archive, const Model &  model, const IdToObjectDataMap &  objects_data  )

private

    {
        enum class MetadataType{
            object,
            volume
        };
 
        auto add_metadata = [](std::stringstream &stream, unsigned indent, MetadataType type,
            const std::string &key, const std::string &value) {
            const char *type_value;
            switch (type) {
            case MetadataType::object: type_value = OBJECT_TYPE; break;
            case MetadataType::volume: type_value = VOLUME_TYPE; break;
            };
            stream << std::string(indent, ' ') << '<' << METADATA_TAG << " " 
                << TYPE_ATTR << "=\"" << type_value << "\" " 
                << KEY_ATTR  << "=\"" << key << "\" " 
                << VALUE_ATTR << "=\"" << xml_escape_double_quotes_attribute_value(value) << "\"/>\n";
        };
 
        std::stringstream stream;
        // Store mesh transformation in full precision, as the volumes are stored transformed and they need to be transformed back
        // when loaded as accurately as possible.
    stream << std::setprecision(std::numeric_limits<double>::max_digits10);
        stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
        stream << "<" << CONFIG_TAG << ">\n";
 
        for (const IdToObjectDataMap::value_type& obj_metadata : objects_data) {
            const ModelObject* obj = obj_metadata.second.object;
            if (obj == nullptr) continue;
            // Output of instances count added because of github #3435, currently not used by PrusaSlicer
            stream << " <" << OBJECT_TAG << " " << ID_ATTR << "=\"" << obj_metadata.first << "\" " << INSTANCESCOUNT_ATTR << "=\"" << obj->instances.size() << "\">\n";
 
            // stores object's name
            if (!obj->name.empty())                    
                add_metadata(stream, 2, MetadataType::object, "name", obj->name);
            // stores object's config data
            const ModelConfigObject &config = obj->config;
            for (const std::string& key : config.keys())
                add_metadata(stream, 2, MetadataType::object, key, config.opt_serialize(key));
 
            for (const ModelVolume* volume : obj_metadata.second.object->volumes) {
                if (volume == nullptr) continue;
                const VolumeToOffsetsMap& offsets = obj_metadata.second.volumes_offsets;
                VolumeToOffsetsMap::const_iterator it = offsets.find(volume);
                if (it != offsets.end()) {
                    // stores volume's offsets
                    stream << "  <" << VOLUME_TAG << " ";
                    stream << FIRST_TRIANGLE_ID_ATTR << "=\"" << it->second.first_triangle_id << "\" ";
                    stream << LAST_TRIANGLE_ID_ATTR << "=\"" << it->second.last_triangle_id << "\">\n";
 
                    // stores volume's name
                    if (!volume->name.empty())
                        add_metadata(stream, 3, MetadataType::volume, NAME_KEY, volume->name);
 
                    // stores volume's modifier field (legacy, to support old slicers)
                    if (volume->is_modifier())
                        add_metadata(stream, 3, MetadataType::volume, MODIFIER_KEY, "1");
                    // stores volume's type (overrides the modifier field above)
                    add_metadata(stream, 3, MetadataType::volume, VOLUME_TYPE_KEY, ModelVolume::type_to_string(volume->type()));
 
                    // stores volume's local matrix
                    stream << "   <" << METADATA_TAG << " " << TYPE_ATTR << "=\"" << VOLUME_TYPE << "\" " << KEY_ATTR << "=\"" << MATRIX_KEY << "\" " << VALUE_ATTR << "=\"";
                    const Transform3d matrix = volume->get_matrix() * volume->source.transform.get_matrix();
                    for (int r = 0; r < 4; ++r) {
                        for (int c = 0; c < 4; ++c) {
                            stream << matrix(r, c);
                            if (r != 3 || c != 3)
                                stream << " ";
                        }
                    }
                    stream << "\"/>\n";
 
                    // stores volume's source data
                    {
                        std::string input_file = xml_escape(m_fullpath_sources ? volume->source.input_file : boost::filesystem::path(volume->source.input_file).filename().string());
                        std::string prefix = std::string("   <") + METADATA_TAG + " " + TYPE_ATTR + "=\"" + VOLUME_TYPE + "\" " + KEY_ATTR + "=\"";
                        if (! volume->source.input_file.empty()) {
                            stream << prefix << SOURCE_FILE_KEY      << "\" " << VALUE_ATTR << "=\"" << input_file << "\"/>\n";
                            stream << prefix << SOURCE_OBJECT_ID_KEY << "\" " << VALUE_ATTR << "=\"" << volume->source.object_idx << "\"/>\n";
                            stream << prefix << SOURCE_VOLUME_ID_KEY << "\" " << VALUE_ATTR << "=\"" << volume->source.volume_idx << "\"/>\n";
                            stream << prefix << SOURCE_OFFSET_X_KEY  << "\" " << VALUE_ATTR << "=\"" << volume->source.mesh_offset(0) << "\"/>\n";
                            stream << prefix << SOURCE_OFFSET_Y_KEY  << "\" " << VALUE_ATTR << "=\"" << volume->source.mesh_offset(1) << "\"/>\n";
                            stream << prefix << SOURCE_OFFSET_Z_KEY  << "\" " << VALUE_ATTR << "=\"" << volume->source.mesh_offset(2) << "\"/>\n";
                        }
                        assert(! volume->source.is_converted_from_inches || ! volume->source.is_converted_from_meters);
                        if (volume->source.is_converted_from_inches)
                            stream << prefix << SOURCE_IN_INCHES_KEY << "\" " << VALUE_ATTR << "=\"1\"/>\n";
                        else if (volume->source.is_converted_from_meters)
                            stream << prefix << SOURCE_IN_METERS_KEY << "\" " << VALUE_ATTR << "=\"1\"/>\n";
                        if (volume->source.is_from_builtin_objects)
                            stream << prefix << SOURCE_IS_BUILTIN_VOLUME_KEY << "\" " << VALUE_ATTR << "=\"1\"/>\n";
                    }
 
                    // stores volume's config data
                    for (const std::string& key : volume->config.keys()) {
                        stream << "   <" << METADATA_TAG << " " << TYPE_ATTR << "=\"" << VOLUME_TYPE << "\" " << KEY_ATTR << "=\"" << key << "\" " << VALUE_ATTR << "=\"" << volume->config.opt_serialize(key) << "\"/>\n";
                    }
                                                        
                    // stores volume's text data
                    const auto &tc = volume->text_configuration;
                    if (tc.has_value())
                        TextConfigurationSerialization::create_fix_and_store(stream, *tc, *volume);                    
 
                    // stores mesh's statistics
                    const RepairedMeshErrors& stats = volume->mesh().stats().repaired_errors;
                    stream << "   <" << MESH_TAG << " ";
                    stream << MESH_STAT_EDGES_FIXED        << "=\"" << stats.edges_fixed        << "\" ";
                    stream << MESH_STAT_DEGENERATED_FACETS << "=\"" << stats.degenerate_facets  << "\" ";
                    stream << MESH_STAT_FACETS_REMOVED     << "=\"" << stats.facets_removed     << "\" ";
                    stream << MESH_STAT_FACETS_RESERVED    << "=\"" << stats.facets_reversed    << "\" ";
                    stream << MESH_STAT_BACKWARDS_EDGES    << "=\"" << stats.backwards_edges    << "\"/>\n";
 
                    stream << "  </" << VOLUME_TAG << ">\n";
                }
            }
            stream << " </" << OBJECT_TAG << ">\n";
        }
 
        stream << "</" << CONFIG_TAG << ">\n";
 
        std::string out = stream.str();
 
        if (!mz_zip_writer_add_mem(&archive, MODEL_CONFIG_FILE.c_str(), (const void*)out.data(), out.length(), MZ_DEFAULT_COMPRESSION)) {
            add_error("Unable to add model config file to archive");
            return false;
        }
 
        return true;
    }

References Slic3r::RepairedMeshErrors::backwards_edges, Slic3r::ModelObject::config, CONFIG_TAG, Slic3r::RepairedMeshErrors::degenerate_facets, Slic3r::RepairedMeshErrors::edges_fixed, Slic3r::RepairedMeshErrors::facets_removed, Slic3r::RepairedMeshErrors::facets_reversed, FIRST_TRIANGLE_ID_ATTR, ID_ATTR, Slic3r::ModelObject::instances, INSTANCESCOUNT_ATTR, KEY_ATTR, Slic3r::ModelConfig::keys(), LAST_TRIANGLE_ID_ATTR, MATRIX_KEY, MESH_STAT_BACKWARDS_EDGES, MESH_STAT_DEGENERATED_FACETS, MESH_STAT_EDGES_FIXED, MESH_STAT_FACETS_REMOVED, MESH_STAT_FACETS_RESERVED, MESH_TAG, METADATA_TAG, MODEL_CONFIG_FILE, MODIFIER_KEY, MZ_DEFAULT_COMPRESSION, mz_zip_writer_add_mem(), Slic3r::ModelObject::name, NAME_KEY, OBJECT_TAG, OBJECT_TYPE, Slic3r::ModelConfig::opt_serialize(), 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, TYPE_ATTR, VALUE_ATTR, VOLUME_TAG, VOLUME_TYPE, VOLUME_TYPE_KEY, Slic3r::xml_escape(), and Slic3r::xml_escape_double_quotes_attribute_value().

Here is the call graph for this function:

_add_model_file_to_archive()

bool Slic3r::_3MF_Exporter::_add_model_file_to_archive ( const std::string &  filename, mz_zip_archive &  archive, const Model &  model, IdToObjectDataMap &  objects_data  )

private

    {
        mz_zip_writer_staged_context context;
        if (!mz_zip_writer_add_staged_open(&archive, &context, MODEL_FILE.c_str(), 
            m_zip64 ? 
                // Maximum expected and allowed 3MF file size is 16GiB.
                // This switches the ZIP file to a 64bit mode, which adds a tiny bit of overhead to file records.
                (uint64_t(1) << 30) * 16 : 
                // Maximum expected 3MF file size is 4GB-1. This is a workaround for interoperability with Windows 10 3D model fixing API, see
                // GH issue #6193.
                (uint64_t(1) << 32) - 1,
            nullptr, nullptr, 0, MZ_DEFAULT_COMPRESSION, nullptr, 0, nullptr, 0)) {
            add_error("Unable to add model file to archive");
            return false;
        }
 
        {
            std::stringstream stream;
            reset_stream(stream);
            stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
            stream << "<" << MODEL_TAG << " unit=\"millimeter\" xml:lang=\"en-US\" xmlns=\"http://schemas.microsoft.com/3dmanufacturing/core/2015/02\" xmlns:slic3rpe=\"http://schemas.slic3r.org/3mf/2017/06\">\n";
            stream << " <" << METADATA_TAG << " name=\"" << SLIC3RPE_3MF_VERSION << "\">" << VERSION_3MF << "</" << METADATA_TAG << ">\n";
 
            if (model.is_fdm_support_painted())
                stream << " <" << METADATA_TAG << " name=\"" << SLIC3RPE_FDM_SUPPORTS_PAINTING_VERSION << "\">" << FDM_SUPPORTS_PAINTING_VERSION << "</" << METADATA_TAG << ">\n";
 
            if (model.is_seam_painted())
                stream << " <" << METADATA_TAG << " name=\"" << SLIC3RPE_SEAM_PAINTING_VERSION << "\">" << SEAM_PAINTING_VERSION << "</" << METADATA_TAG << ">\n";
 
            if (model.is_mm_painted())
                stream << " <" << METADATA_TAG << " name=\"" << SLIC3RPE_MM_PAINTING_VERSION << "\">" << MM_PAINTING_VERSION << "</" << METADATA_TAG << ">\n";
 
            std::string name = xml_escape(boost::filesystem::path(filename).stem().string());
            stream << " <" << METADATA_TAG << " name=\"Title\">" << name << "</" << METADATA_TAG << ">\n";
            stream << " <" << METADATA_TAG << " name=\"Designer\">" << "</" << METADATA_TAG << ">\n";
            stream << " <" << METADATA_TAG << " name=\"Description\">" << name << "</" << METADATA_TAG << ">\n";
            stream << " <" << METADATA_TAG << " name=\"Copyright\">" << "</" << METADATA_TAG << ">\n";
            stream << " <" << METADATA_TAG << " name=\"LicenseTerms\">" << "</" << METADATA_TAG << ">\n";
            stream << " <" << METADATA_TAG << " name=\"Rating\">" << "</" << METADATA_TAG << ">\n";
            std::string date = Slic3r::Utils::utc_timestamp(Slic3r::Utils::get_current_time_utc());
            // keep only the date part of the string
            date = date.substr(0, 10);
            stream << " <" << METADATA_TAG << " name=\"CreationDate\">" << date << "</" << METADATA_TAG << ">\n";
            stream << " <" << METADATA_TAG << " name=\"ModificationDate\">" << date << "</" << METADATA_TAG << ">\n";
            stream << " <" << METADATA_TAG << " name=\"Application\">" << SLIC3R_APP_KEY << "-" << SLIC3R_VERSION << "</" << METADATA_TAG << ">\n";
            stream << " <" << RESOURCES_TAG << ">\n";
            std::string buf = stream.str();
            if (! buf.empty() && ! mz_zip_writer_add_staged_data(&context, buf.data(), buf.size())) {
                add_error("Unable to add model file to archive");
                return false;
            }
        }
 
        // Instance transformations, indexed by the 3MF object ID (which is a linear serialization of all instances of all ModelObjects).
        BuildItemsList build_items;
 
        // The object_id here is a one based identifier of the first instance of a ModelObject in the 3MF file, where
        // all the object instances of all ModelObjects are stored and indexed in a 1 based linear fashion.
        // Therefore the list of object_ids here may not be continuous.
        unsigned int object_id = 1;
        for (ModelObject* obj : model.objects) {
            if (obj == nullptr)
                continue;
 
            // Index of an object in the 3MF file corresponding to the 1st instance of a ModelObject.
            unsigned int curr_id = object_id;
            IdToObjectDataMap::iterator object_it = objects_data.insert({ curr_id, ObjectData(obj) }).first;
            // Store geometry of all ModelVolumes contained in a single ModelObject into a single 3MF indexed triangle set object.
            // object_it->second.volumes_offsets will contain the offsets of the ModelVolumes in that single indexed triangle set.
            // object_id will be increased to point to the 1st instance of the next ModelObject.
            if (!_add_object_to_model_stream(context, object_id, *obj, build_items, object_it->second.volumes_offsets)) {
                add_error("Unable to add object to archive");
                mz_zip_writer_add_staged_finish(&context);
                return false;
            }
        }
 
        {
            std::stringstream stream;
            reset_stream(stream);
            stream << " </" << RESOURCES_TAG << ">\n";
 
            // Store the transformations of all the ModelInstances of all ModelObjects, indexed in a linear fashion.
            if (!_add_build_to_model_stream(stream, build_items)) {
                add_error("Unable to add build to archive");
                mz_zip_writer_add_staged_finish(&context);
                return false;
            }
 
            stream << "</" << MODEL_TAG << ">\n";
           
            std::string buf = stream.str();
 
            if ((! buf.empty() && ! mz_zip_writer_add_staged_data(&context, buf.data(), buf.size())) ||
                ! mz_zip_writer_add_staged_finish(&context)) {
                add_error("Unable to add model file to archive");
                return false;
            }
        }
 
        return true;
    }

References FDM_SUPPORTS_PAINTING_VERSION, Slic3r::Utils::get_current_time_utc(), Slic3r::Model::is_fdm_support_painted(), Slic3r::Model::is_mm_painted(), Slic3r::Model::is_seam_painted(), METADATA_TAG, MM_PAINTING_VERSION, MODEL_FILE, MODEL_TAG, MZ_DEFAULT_COMPRESSION, mz_zip_writer_add_staged_data(), mz_zip_writer_add_staged_finish(), mz_zip_writer_add_staged_open(), Slic3r::Model::objects, Slic3r::reset_stream(), RESOURCES_TAG, SEAM_PAINTING_VERSION, SLIC3RPE_3MF_VERSION, SLIC3RPE_FDM_SUPPORTS_PAINTING_VERSION, SLIC3RPE_MM_PAINTING_VERSION, SLIC3RPE_SEAM_PAINTING_VERSION, Slic3r::Utils::utc_timestamp(), VERSION_3MF, and Slic3r::xml_escape().

Here is the call graph for this function:

_add_object_to_model_stream()

bool Slic3r::_3MF_Exporter::_add_object_to_model_stream ( mz_zip_writer_staged_context &  context, unsigned int &  object_id, ModelObject &  object, BuildItemsList &  build_items, VolumeToOffsetsMap &  volumes_offsets  )

private

    {
        std::stringstream stream;
        reset_stream(stream);
        unsigned int id = 0;
        for (const ModelInstance* instance : object.instances) {
      assert(instance != nullptr);
            if (instance == nullptr)
                continue;
 
            unsigned int instance_id = object_id + id;
            stream << "  <" << OBJECT_TAG << " id=\"" << instance_id << "\" type=\"model\">\n";
 
            if (id == 0) {
                std::string buf = stream.str();
                reset_stream(stream);
                if ((! buf.empty() && ! mz_zip_writer_add_staged_data(&context, buf.data(), buf.size())) ||
                    ! _add_mesh_to_object_stream(context, object, volumes_offsets)) {
                    add_error("Unable to add mesh to archive");
                    return false;
                }
            }
            else {
                stream << "   <" << COMPONENTS_TAG << ">\n";
                stream << "    <" << COMPONENT_TAG << " objectid=\"" << object_id << "\"/>\n";
                stream << "   </" << COMPONENTS_TAG << ">\n";
            }
 
            Transform3d t = instance->get_matrix();
            // instance_id is just a 1 indexed index in build_items.
            assert(instance_id == build_items.size() + 1);
            build_items.emplace_back(instance_id, t, instance->printable);
 
            stream << "  </" << OBJECT_TAG << ">\n";
 
            ++id;
        }
 
        object_id += id;
        std::string buf = stream.str();
        return buf.empty() || mz_zip_writer_add_staged_data(&context, buf.data(), buf.size());
    }

References COMPONENT_TAG, COMPONENTS_TAG, mz_zip_writer_add_staged_data(), OBJECT_TAG, and Slic3r::reset_stream().

Here is the call graph for this function:

_add_print_config_file_to_archive()

bool Slic3r::_3MF_Exporter::_add_print_config_file_to_archive ( mz_zip_archive &  archive, const DynamicPrintConfig &  config  )

private

    {
        assert(is_decimal_separator_point());
        char buffer[1024];
        sprintf(buffer, "; %s\n\n", header_slic3r_generated().c_str());
        std::string out = buffer;
 
        for (const std::string &key : config.keys())
            if (key != "compatible_printers")
                out += "; " + key + " = " + config.opt_serialize(key) + "\n";
 
        if (!out.empty()) {
            if (!mz_zip_writer_add_mem(&archive, PRINT_CONFIG_FILE.c_str(), (const void*)out.data(), out.length(), MZ_DEFAULT_COMPRESSION)) {
                add_error("Unable to add print config file to archive");
                return false;
            }
        }
 
        return true;
    }

References Slic3r::header_slic3r_generated(), Slic3r::is_decimal_separator_point(), Slic3r::DynamicConfig::keys(), MZ_DEFAULT_COMPRESSION, mz_zip_writer_add_mem(), Slic3r::ConfigBase::opt_serialize(), and PRINT_CONFIG_FILE.

Here is the call graph for this function:

_add_relationships_file_to_archive()

bool Slic3r::_3MF_Exporter::_add_relationships_file_to_archive ( mz_zip_archive &  archive )

private

    {
        std::stringstream stream;
        stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
        stream << "<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">\n";
        stream << " <Relationship Target=\"/" << MODEL_FILE << "\" Id=\"rel-1\" Type=\"http://schemas.microsoft.com/3dmanufacturing/2013/01/3dmodel\"/>\n";
        stream << " <Relationship Target=\"/" << THUMBNAIL_FILE << "\" Id=\"rel-2\" Type=\"http://schemas.openxmlformats.org/package/2006/relationships/metadata/thumbnail\"/>\n";
        stream << "</Relationships>";
 
        std::string out = stream.str();
 
        if (!mz_zip_writer_add_mem(&archive, RELATIONSHIPS_FILE.c_str(), (const void*)out.data(), out.length(), MZ_DEFAULT_COMPRESSION)) {
            add_error("Unable to add relationships file to archive");
            return false;
        }
 
        return true;
    }

References MODEL_FILE, MZ_DEFAULT_COMPRESSION, mz_zip_writer_add_mem(), RELATIONSHIPS_FILE, and THUMBNAIL_FILE.

Here is the call graph for this function:

_add_sla_drain_holes_file_to_archive()

bool Slic3r::_3MF_Exporter::_add_sla_drain_holes_file_to_archive ( mz_zip_archive &  archive, Model &  model  )

private

    {
        assert(is_decimal_separator_point());
        const char *const fmt = "object_id=%d|";
        std::string out;
        
        unsigned int count = 0;
        for (const ModelObject* object : model.objects) {
            ++count;
            sla::DrainHoles drain_holes = object->sla_drain_holes;
 
            // The holes were placed 1mm above the mesh in the first implementation.
            // This was a bad idea and the reference point was changed in 2.3 so
            // to be on the mesh exactly. The elevated position is still saved
            // in 3MFs for compatibility reasons.
            for (sla::DrainHole& hole : drain_holes) {
                hole.pos -= hole.normal.normalized();
                hole.height += 1.f;
            }
 
            if (!drain_holes.empty()) {
                out += string_printf(fmt, count);
                
                // Store the layer height profile as a single space separated list.
                for (size_t i = 0; i < drain_holes.size(); ++i)
                    out += string_printf((i == 0 ? "%f %f %f %f %f %f %f %f" : " %f %f %f %f %f %f %f %f"),
                                         drain_holes[i].pos(0),
                                         drain_holes[i].pos(1),
                                         drain_holes[i].pos(2),
                                         drain_holes[i].normal(0),
                                         drain_holes[i].normal(1),
                                         drain_holes[i].normal(2),
                                         drain_holes[i].radius,
                                         drain_holes[i].height);
                
                out += "\n";
            }
        }
        
        if (!out.empty()) {
            // Adds version header at the beginning:
            out = std::string("drain_holes_format_version=") + std::to_string(drain_holes_format_version) + std::string("\n") + out;
            
            if (!mz_zip_writer_add_mem(&archive, SLA_DRAIN_HOLES_FILE.c_str(), static_cast<const void*>(out.data()), out.length(), mz_uint(MZ_DEFAULT_COMPRESSION))) {
                add_error("Unable to add sla support points file to archive");
                return false;
            }
        }
        return true;
    }

References Slic3r::drain_holes_format_version, Slic3r::is_decimal_separator_point(), MZ_DEFAULT_COMPRESSION, mz_zip_writer_add_mem(), Slic3r::Model::objects, SLA_DRAIN_HOLES_FILE, and Slic3r::string_printf().

Here is the call graph for this function:

_add_sla_support_points_file_to_archive()

bool Slic3r::_3MF_Exporter::_add_sla_support_points_file_to_archive ( mz_zip_archive &  archive, Model &  model  )

private

    {
        assert(is_decimal_separator_point());
        std::string out = "";
        char buffer[1024];
 
        unsigned int count = 0;
        for (const ModelObject* object : model.objects) {
            ++count;
            const std::vector<sla::SupportPoint>& sla_support_points = object->sla_support_points;
            if (!sla_support_points.empty()) {
                sprintf(buffer, "object_id=%d|", count);
                out += buffer;
 
                // Store the layer height profile as a single space separated list.
                for (size_t i = 0; i < sla_support_points.size(); ++i) {
                    sprintf(buffer, (i==0 ? "%f %f %f %f %f" : " %f %f %f %f %f"),  sla_support_points[i].pos(0), sla_support_points[i].pos(1), sla_support_points[i].pos(2), sla_support_points[i].head_front_radius, (float)sla_support_points[i].is_new_island);
                    out += buffer;
                }
                out += "\n";
            }
        }
 
        if (!out.empty()) {
            // Adds version header at the beginning:
            out = std::string("support_points_format_version=") + std::to_string(support_points_format_version) + std::string("\n") + out;
 
            if (!mz_zip_writer_add_mem(&archive, SLA_SUPPORT_POINTS_FILE.c_str(), (const void*)out.data(), out.length(), MZ_DEFAULT_COMPRESSION)) {
                add_error("Unable to add sla support points file to archive");
                return false;
            }
        }
        return true;
    }

References Slic3r::is_decimal_separator_point(), MZ_DEFAULT_COMPRESSION, mz_zip_writer_add_mem(), Slic3r::Model::objects, SLA_SUPPORT_POINTS_FILE, and Slic3r::support_points_format_version.

Here is the call graph for this function:

_add_thumbnail_file_to_archive()

bool Slic3r::_3MF_Exporter::_add_thumbnail_file_to_archive ( mz_zip_archive &  archive, const ThumbnailData &  thumbnail_data  )

private

    {
        bool res = false;
 
        size_t png_size = 0;
        void* png_data = tdefl_write_image_to_png_file_in_memory_ex((const void*)thumbnail_data.pixels.data(), thumbnail_data.width, thumbnail_data.height, 4, &png_size, MZ_DEFAULT_LEVEL, 1);
        if (png_data != nullptr) {
            res = mz_zip_writer_add_mem(&archive, THUMBNAIL_FILE.c_str(), (const void*)png_data, png_size, MZ_DEFAULT_COMPRESSION);
            mz_free(png_data);
        }
 
        if (!res)
            add_error("Unable to add thumbnail file to archive");
 
        return res;
    }

References Slic3r::ThumbnailData::height, MZ_DEFAULT_COMPRESSION, MZ_DEFAULT_LEVEL, mz_free(), mz_zip_writer_add_mem(), Slic3r::ThumbnailData::pixels, tdefl_write_image_to_png_file_in_memory_ex(), THUMBNAIL_FILE, and Slic3r::ThumbnailData::width.

Here is the call graph for this function:

_save_model_to_file()

bool Slic3r::_3MF_Exporter::_save_model_to_file ( const std::string &  filename, Model &  model, const DynamicPrintConfig *  config, const ThumbnailData *  thumbnail_data  )

private

    {
        mz_zip_archive archive;
        mz_zip_zero_struct(&archive);
 
        if (!open_zip_writer(&archive, filename)) {
            add_error("Unable to open the file");
            return false;
        }
 
        // Adds content types file ("[Content_Types].xml";).
        // The content of this file is the same for each PrusaSlicer 3mf.
        if (!_add_content_types_file_to_archive(archive)) {
            close_zip_writer(&archive);
            boost::filesystem::remove(filename);
            return false;
        }
 
        if (thumbnail_data != nullptr && thumbnail_data->is_valid()) {
            // Adds the file Metadata/thumbnail.png.
            if (!_add_thumbnail_file_to_archive(archive, *thumbnail_data)) {
                close_zip_writer(&archive);
                boost::filesystem::remove(filename);
                return false;
            }
        }
 
        // Adds relationships file ("_rels/.rels"). 
        // The content of this file is the same for each PrusaSlicer 3mf.
        // The relationshis file contains a reference to the geometry file "3D/3dmodel.model", the name was chosen to be compatible with CURA.
        if (!_add_relationships_file_to_archive(archive)) {
            close_zip_writer(&archive);
            boost::filesystem::remove(filename);
            return false;
        }
 
        // Adds model file ("3D/3dmodel.model").
        // This is the one and only file that contains all the geometry (vertices and triangles) of all ModelVolumes.
        IdToObjectDataMap objects_data;
        if (!_add_model_file_to_archive(filename, archive, model, objects_data)) {
            close_zip_writer(&archive);
            boost::filesystem::remove(filename);
            return false;
        }
 
        // Adds file with information for object cut ("Metadata/Slic3r_PE_cut_information.txt").
        // All information for object cut of all ModelObjects are stored here, indexed by 1 based index of the ModelObject in Model.
        // The index differes from the index of an object ID of an object instance of a 3MF file!
        if (!_add_cut_information_file_to_archive(archive, model)) {
            close_zip_writer(&archive);
            boost::filesystem::remove(filename);
            return false;
        }
 
        // Adds layer height profile file ("Metadata/Slic3r_PE_layer_heights_profile.txt").
        // All layer height profiles of all ModelObjects are stored here, indexed by 1 based index of the ModelObject in Model.
        // The index differes from the index of an object ID of an object instance of a 3MF file!
        if (!_add_layer_height_profile_file_to_archive(archive, model)) {
            close_zip_writer(&archive);
            boost::filesystem::remove(filename);
            return false;
        }
 
        // Adds layer config ranges file ("Metadata/Slic3r_PE_layer_config_ranges.txt").
        // All layer height profiles of all ModelObjects are stored here, indexed by 1 based index of the ModelObject in Model.
        // The index differes from the index of an object ID of an object instance of a 3MF file!
        if (!_add_layer_config_ranges_file_to_archive(archive, model)) {
            close_zip_writer(&archive);
            boost::filesystem::remove(filename);
            return false;
        }
 
        // Adds sla support points file ("Metadata/Slic3r_PE_sla_support_points.txt").
        // All  sla support points of all ModelObjects are stored here, indexed by 1 based index of the ModelObject in Model.
        // The index differes from the index of an object ID of an object instance of a 3MF file!
        if (!_add_sla_support_points_file_to_archive(archive, model)) {
            close_zip_writer(&archive);
            boost::filesystem::remove(filename);
            return false;
        }
        
        if (!_add_sla_drain_holes_file_to_archive(archive, model)) {
            close_zip_writer(&archive);
            boost::filesystem::remove(filename);
            return false;
        }
        
 
        // Adds custom gcode per height file ("Metadata/Prusa_Slicer_custom_gcode_per_print_z.xml").
        // All custom gcode per height of whole Model are stored here
        if (!_add_custom_gcode_per_print_z_file_to_archive(archive, model, config)) {
            close_zip_writer(&archive);
            boost::filesystem::remove(filename);
            return false;
        }
 
        // Adds slic3r print config file ("Metadata/Slic3r_PE.config").
        // This file contains the content of FullPrintConfing / SLAFullPrintConfig.
        if (config != nullptr) {
            if (!_add_print_config_file_to_archive(archive, *config)) {
                close_zip_writer(&archive);
                boost::filesystem::remove(filename);
                return false;
            }
        }
 
        // Adds slic3r model config file ("Metadata/Slic3r_PE_model.config").
        // This file contains all the attributes of all ModelObjects and their ModelVolumes (names, parameter overrides).
        // As there is just a single Indexed Triangle Set data stored per ModelObject, offsets of volumes into their respective Indexed Triangle Set data
        // is stored here as well.
        if (!_add_model_config_file_to_archive(archive, model, objects_data)) {
            close_zip_writer(&archive);
            boost::filesystem::remove(filename);
            return false;
        }
 
        if (!mz_zip_writer_finalize_archive(&archive)) {
            close_zip_writer(&archive);
            boost::filesystem::remove(filename);
            add_error("Unable to finalize the archive");
            return false;
        }
 
        close_zip_writer(&archive);
 
        return true;
    }

References Slic3r::close_zip_writer(), Slic3r::ThumbnailData::is_valid(), mz_zip_writer_finalize_archive(), mz_zip_zero_struct(), and Slic3r::open_zip_writer().

Here is the call graph for this function:

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

Here is the caller graph for this function:

add_transformation()

void Slic3r::_3MF_Exporter::add_transformation ( std::stringstream &  stream, const Transform3d &  tr  )

static

    {
        for (unsigned c = 0; c < 4; ++c) {
            for (unsigned r = 0; r < 3; ++r) {
                stream << tr(r, c);
                if (r != 2 || c != 3) stream << " ";
            }
        }
    }

clear_errors()

void Slic3r::_3MF_Base::clear_errors ( )

inlineprotectedinherited

{ m_errors.clear(); }

References Slic3r::_3MF_Base::m_errors.

Referenced by Slic3r::_3MF_Importer::load_model_from_file().

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:

save_model_to_file()

bool Slic3r::_3MF_Exporter::save_model_to_file	(	const std::string &	filename,
		Model &	model,
		const DynamicPrintConfig *	config,
		bool	fullpath_sources,
		const ThumbnailData *	thumbnail_data,
		bool	zip64
	)

    {
        clear_errors();
        m_fullpath_sources = fullpath_sources;
        m_zip64 = zip64;
        return _save_model_to_file(filename, model, config, thumbnail_data);
    }

Referenced by Slic3r::store_3mf().

Here is the caller graph for this function:

Member Data Documentation

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_fullpath_sources

bool Slic3r::_3MF_Exporter::m_fullpath_sources { true }

private

m_zip64

bool Slic3r::_3MF_Exporter::m_zip64 { true }

private

---

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

• src/libslic3r/Format/3mf.cpp