Slic3r::_3MF_Exporter Class Reference

Inheritance diagram for Slic3r::_3MF_Exporter:

Collaboration diagram for Slic3r::_3MF_Exporter:

Classes
struct	BuildItem
struct	Offsets
struct	ObjectData

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 ()

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_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 << "=\"";
            for (unsigned c = 0; c < 4; ++c) {
                for (unsigned r = 0; r < 3; ++r) {
                    stream << item.transform(r, c);
                    if (r != 2 || c != 3)
                        stream << " ";
                }
            }
            stream << "\" " << PRINTABLE_ATTR << "=\"" << item.printable << "\"/>\n";
        }
 
        stream << " </" << BUILD_TAG << ">\n";
 
        return true;
    }

References _add_build_to_model_stream(), Slic3r::_3MF_Base::add_error(), BUILD_TAG, ITEM_TAG, OBJECTID_ATTR, PRINTABLE_ATTR, and TRANSFORM_ATTR.

Referenced by _add_build_to_model_stream(), and _add_model_file_to_archive().

Here is the call graph for this function:

Here is the caller graph for this function:

_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 _add_content_types_file_to_archive(), Slic3r::_3MF_Base::add_error(), and CONTENT_TYPES_FILE.

Referenced by _add_content_types_file_to_archive(), and _save_model_to_file().

Here is the call graph for this function:

Here is the caller 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

{
    return true;
    //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    );
 
    //        //BBS
    //        std::string gcode = //code.type == CustomGCode::ColorChange ? config->opt_string("color_change_gcode")    :
    //                            code.type == CustomGCode::PausePrint  ? config->opt_string("machine_pause_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 _add_custom_gcode_per_print_z_file_to_archive().

Referenced by _add_custom_gcode_per_print_z_file_to_archive(), and _save_model_to_file().

Here is the call graph for this function:

Here is the caller 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 _add_layer_config_ranges_file_to_archive(), Slic3r::_3MF_Base::add_error(), Slic3r::ModelConfig::keys(), LAYER_CONFIG_RANGES_FILE, Slic3r::Model::objects, Slic3r::ModelConfig::opt_serialize(), and Slic3r::range().

Referenced by _add_layer_config_ranges_file_to_archive(), and _save_model_to_file().

Here is the call graph for this function:

Here is the caller 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 _add_layer_height_profile_file_to_archive(), Slic3r::_3MF_Base::add_error(), count, Slic3r::is_decimal_separator_point(), LAYER_HEIGHTS_PROFILE_FILE, and Slic3r::Model::objects.

Referenced by _add_layer_height_profile_file_to_archive(), and _save_model_to_file().

Here is the call graph for this function:

Here is the caller 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 (size_t i = 0; i < its.vertices.size(); ++i) {
                Vec3f v = (matrix * its.vertices[i].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 Vec3i32 &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 += "\"";
                }
 
                std::string fuzzy_skin_data_string = volume->fuzzy_skin_facets.get_triangle_as_string(i);
                if (!fuzzy_skin_data_string.empty()) {
                    output_buffer += " ";
                    output_buffer += FUZZY_SKIN_ATTR;
                    output_buffer += "=\"";
                    output_buffer += fuzzy_skin_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 _add_mesh_to_object_stream(), Slic3r::_3MF_Base::add_error(), Slic3r::cast(), CUSTOM_SEAM_ATTR, CUSTOM_SUPPORTS_ATTR, Slic3r::f(), FUZZY_SKIN_ATTR, Slic3r::is_decimal_separator_point(), MESH_TAG, MMU_SEGMENTATION_ATTR, TRIANGLE_TAG, TRIANGLES_TAG, VERTEX_TAG, and VERTICES_TAG.

Referenced by _add_mesh_to_object_stream(), and _add_object_to_model_stream().

Here is the call graph for this function:

Here is the caller 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

    {
        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) {
                // 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())
                    stream << "  <" << METADATA_TAG << " " << TYPE_ATTR << "=\"" << OBJECT_TYPE << "\" " << KEY_ATTR << "=\"name\" " << VALUE_ATTR << "=\"" << xml_escape(obj->name) << "\"/>\n";
 
                // stores object's config data
                for (const std::string& key : obj->config.keys()) {
                    stream << "  <" << METADATA_TAG << " " << TYPE_ATTR << "=\"" << OBJECT_TYPE << "\" " << KEY_ATTR << "=\"" << key << "\" " << VALUE_ATTR << "=\"" << obj->config.opt_serialize(key) << "\"/>\n";
                }
 
                for (const ModelVolume* volume : obj_metadata.second.object->volumes) {
                    if (volume != nullptr) {
                        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())
                                stream << "   <" << METADATA_TAG << " " << TYPE_ATTR << "=\"" << VOLUME_TYPE << "\" " << KEY_ATTR << "=\"" << NAME_KEY << "\" " << VALUE_ATTR << "=\"" << xml_escape(volume->name) << "\"/>\n";
 
                            // stores volume's modifier field (legacy, to support old slicers)
                            // Readers with only the legacy flag still see helper geometry as a modifier.
                            if (volume->is_modifier() || volume->is_precise_seam())
                                stream << "   <" << METADATA_TAG << " " << TYPE_ATTR << "=\"" << VOLUME_TYPE << "\" " << KEY_ATTR << "=\"" << MODIFIER_KEY << "\" " << VALUE_ATTR << "=\"1\"/>\n";
                            // This Prusa-format reader uses ParameterModifier, not Bambu's modifier_part.
                            // The base type overrides the legacy flag, so it must also be backward-compatible.
                            // Use the same spelling for ordinary modifiers, including a downgraded seam helper.
                            const bool store_as_modifier = volume->is_modifier() || volume->is_precise_seam();
                            stream << "   <" << METADATA_TAG << " " << TYPE_ATTR << "=\"" << VOLUME_TYPE << "\" " << KEY_ATTR << "=\"" << VOLUME_TYPE_KEY << "\" " <<
                                VALUE_ATTR << "=\"" << (store_as_modifier ? "ParameterModifier" : ModelVolume::type_to_string(volume->type())) << "\"/>\n";
                            if (volume->is_precise_seam())
                                stream << "   <" << METADATA_TAG << " " << TYPE_ATTR << "=\"" << VOLUME_TYPE << "\" " << KEY_ATTR << "=\"" << PRECISE_SEAM_TYPE_KEY << "\" " <<
                                    VALUE_ATTR << "=\"" << ModelVolume::type_to_string(volume->type()) << "\"/>\n";
 
                            // stores volume's local matrix
                            stream << "   <" << METADATA_TAG << " " << TYPE_ATTR << "=\"" << VOLUME_TYPE << "\" " << KEY_ATTR << "=\"" << MATRIX_KEY << "\" " << VALUE_ATTR << "=\"";
                            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 << "\" " << VALUE_ATTR << "=\"1\"/>\n";
                                else if (volume->source.is_converted_from_meters)
                                    stream << prefix << SOURCE_IN_METERS << "\" " << VALUE_ATTR << "=\"1\"/>\n";
                            }
 
                            // stores volume's config data
                            for (const std::string& key : volume->config.keys()) {
                                // Seam settings are inactive but must survive changing the helper back into a part/modifier.
                                const bool dormant = volume->is_precise_seam();
                                const std::string stored_key = dormant ? PRECISE_SEAM_CONFIG_PREFIX + key : key;
                                const std::string value = volume->config.opt_serialize(key);
                                // Config serialization is C-style, not XML: escape active settings too, including tabs.
                                stream << "   <" << METADATA_TAG << " " << TYPE_ATTR << "=\"" << VOLUME_TYPE << "\" " << KEY_ATTR << "=\"" << stored_key << "\" " << VALUE_ATTR << "=\"" << xml_escape_double_quotes_attribute_value(value) << "\"/>\n";
                            }
 
                            // 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 _add_model_config_file_to_archive(), Slic3r::_3MF_Base::add_error(), Slic3r::RepairedMeshErrors::backwards_edges, Slic3r::ModelObject::config, Slic3r::ModelVolume::config, CONFIG_TAG, Slic3r::RepairedMeshErrors::degenerate_facets, Slic3r::RepairedMeshErrors::edges_fixed, Slic3r::RepairedMeshErrors::facets_removed, Slic3r::RepairedMeshErrors::facets_reversed, FIRST_TRIANGLE_ID_ATTR, Slic3r::Geometry::Transformation::get_matrix(), Slic3r::ModelVolume::get_matrix(), ID_ATTR, Slic3r::ModelVolume::Source::input_file, Slic3r::ModelObject::instances, INSTANCESCOUNT_ATTR, Slic3r::ModelVolume::Source::is_converted_from_inches, Slic3r::ModelVolume::Source::is_converted_from_meters, Slic3r::ModelVolume::is_modifier(), Slic3r::ModelVolume::is_precise_seam(), KEY_ATTR, Slic3r::ModelConfig::keys(), LAST_TRIANGLE_ID_ATTR, m_fullpath_sources, MATRIX_KEY, Slic3r::ModelVolume::mesh(), Slic3r::ModelVolume::Source::mesh_offset, 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, Slic3r::ModelObject::name, Slic3r::ModelVolume::name, NAME_KEY, Slic3r::ModelVolume::object, Slic3r::ModelVolume::Source::object_idx, OBJECT_TAG, OBJECT_TYPE, Slic3r::ModelConfig::opt_serialize(), PRECISE_SEAM_CONFIG_PREFIX, PRECISE_SEAM_TYPE_KEY, Slic3r::TriangleMeshStats::repaired_errors, Slic3r::ModelVolume::source, SOURCE_FILE_KEY, SOURCE_IN_INCHES, SOURCE_IN_METERS, SOURCE_OBJECT_ID_KEY, SOURCE_OFFSET_X_KEY, SOURCE_OFFSET_Y_KEY, SOURCE_OFFSET_Z_KEY, SOURCE_VOLUME_ID_KEY, Slic3r::TriangleMesh::stats(), Slic3r::ModelVolume::Source::transform, Slic3r::ModelVolume::type(), TYPE_ATTR, Slic3r::ModelVolume::type_to_string(), VALUE_ATTR, Slic3r::ModelVolume::Source::volume_idx, VOLUME_TAG, VOLUME_TYPE, VOLUME_TYPE_KEY, Slic3r::ModelObject::volumes, Slic3r::xml_escape(), and Slic3r::xml_escape_double_quotes_attribute_value().

Referenced by _add_model_config_file_to_archive(), and _save_model_to_file().

Here is the call graph for this function:

Here is the caller 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";
            // Orca: PRIVACY: do not store creation & modification date in 3mf
            stream << " <" << METADATA_TAG << " name=\"CreationDate\">" << "</" << METADATA_TAG << ">\n";
            stream << " <" << METADATA_TAG << " name=\"ModificationDate\">" << "</" << 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 _add_build_to_model_stream(), _add_model_file_to_archive(), _add_object_to_model_stream(), Slic3r::_3MF_Base::add_error(), FDM_SUPPORTS_PAINTING_VERSION, Slic3r::Model::is_fdm_support_painted(), Slic3r::Model::is_mm_painted(), Slic3r::Model::is_seam_painted(), m_zip64, METADATA_TAG, MM_PAINTING_VERSION, MODEL_FILE, MODEL_TAG, 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, VERSION_3MF, and Slic3r::xml_escape().

Referenced by _add_model_file_to_archive(), and _save_model_to_file().

Here is the call graph for this function:

Here is the caller 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 _add_mesh_to_object_stream(), _add_object_to_model_stream(), Slic3r::_3MF_Base::add_error(), COMPONENT_TAG, COMPONENTS_TAG, OBJECT_TAG, and Slic3r::reset_stream().

Referenced by _add_model_file_to_archive(), and _add_object_to_model_stream().

Here is the call graph for this function:

Here is the caller 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 _add_print_config_file_to_archive(), Slic3r::_3MF_Base::add_error(), Slic3r::header_slic3r_generated(), Slic3r::is_decimal_separator_point(), Slic3r::DynamicConfig::keys(), Slic3r::ConfigBase::opt_serialize(), and PRINT_CONFIG_FILE.

Referenced by _add_print_config_file_to_archive(), and _save_model_to_file().

Here is the call graph for this function:

Here is the caller 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 _add_relationships_file_to_archive(), Slic3r::_3MF_Base::add_error(), MODEL_FILE, RELATIONSHIPS_FILE, and THUMBNAIL_FILE.

Referenced by _add_relationships_file_to_archive(), and _save_model_to_file().

Here is the call graph for this function:

Here is the caller 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 _add_sla_drain_holes_file_to_archive(), Slic3r::_3MF_Base::add_error(), count, Slic3r::drain_holes_format_version, Slic3r::is_decimal_separator_point(), Slic3r::normal(), Slic3r::Model::objects, SLA_DRAIN_HOLES_FILE, and Slic3r::string_printf().

Referenced by _add_sla_drain_holes_file_to_archive(), and _save_model_to_file().

Here is the call graph for this function:

Here is the caller 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 _add_sla_support_points_file_to_archive(), Slic3r::_3MF_Base::add_error(), count, Slic3r::is_decimal_separator_point(), Slic3r::Model::objects, SLA_SUPPORT_POINTS_FILE, and Slic3r::support_points_format_version.

Referenced by _add_sla_support_points_file_to_archive(), and _save_model_to_file().

Here is the call graph for this function:

Here is the caller 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 _add_thumbnail_file_to_archive(), Slic3r::_3MF_Base::add_error(), Slic3r::ThumbnailData::height, Slic3r::ThumbnailData::pixels, THUMBNAIL_FILE, and Slic3r::ThumbnailData::width.

Referenced by _add_thumbnail_file_to_archive(), and _save_model_to_file().

Here is the call graph for this function:

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, 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 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 FullPrintConfig / 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 _add_content_types_file_to_archive(), _add_custom_gcode_per_print_z_file_to_archive(), _add_layer_config_ranges_file_to_archive(), _add_layer_height_profile_file_to_archive(), _add_model_config_file_to_archive(), _add_model_file_to_archive(), _add_print_config_file_to_archive(), _add_relationships_file_to_archive(), _add_sla_drain_holes_file_to_archive(), _add_sla_support_points_file_to_archive(), _add_thumbnail_file_to_archive(), _save_model_to_file(), Slic3r::_3MF_Base::add_error(), Slic3r::close_zip_writer(), Slic3r::ThumbnailData::is_valid(), and Slic3r::open_zip_writer().

Referenced by _save_model_to_file(), and save_model_to_file().

Here is the call graph for this function:

Here is the caller graph for this function:

add_error()

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

inlineprotectedinherited

{ m_errors.push_back(error); }

References m_errors.

Referenced by Slic3r::_3MF_Exporter::_add_build_to_model_stream(), Slic3r::_3MF_Exporter::_add_content_types_file_to_archive(), Slic3r::_3MF_Exporter::_add_layer_config_ranges_file_to_archive(), Slic3r::_3MF_Exporter::_add_layer_height_profile_file_to_archive(), Slic3r::_3MF_Exporter::_add_mesh_to_object_stream(), Slic3r::_3MF_Exporter::_add_model_config_file_to_archive(), Slic3r::_3MF_Exporter::_add_model_file_to_archive(), Slic3r::_3MF_Exporter::_add_object_to_model_stream(), Slic3r::_3MF_Exporter::_add_print_config_file_to_archive(), Slic3r::_3MF_Exporter::_add_relationships_file_to_archive(), Slic3r::_3MF_Exporter::_add_sla_drain_holes_file_to_archive(), Slic3r::_3MF_Exporter::_add_sla_support_points_file_to_archive(), Slic3r::_3MF_Exporter::_add_thumbnail_file_to_archive(), Slic3r::_3MF_Importer::_create_object_instance(), Slic3r::_3MF_Importer::_extract_layer_config_ranges_from_archive(), Slic3r::_3MF_Importer::_extract_layer_heights_profile_config_from_archive(), Slic3r::_3MF_Importer::_extract_model_config_from_archive(), Slic3r::_3MF_Importer::_extract_model_from_archive(), Slic3r::_3MF_Importer::_extract_print_config_from_archive(), Slic3r::_3MF_Importer::_extract_sla_drain_holes_from_archive(), Slic3r::_3MF_Importer::_extract_sla_support_points_from_archive(), Slic3r::_3MF_Importer::_generate_volumes(), Slic3r::_3MF_Importer::_handle_end_model(), Slic3r::_3MF_Importer::_handle_end_object(), Slic3r::_3MF_Importer::_handle_start_component(), Slic3r::_3MF_Importer::_handle_start_config_metadata(), Slic3r::_3MF_Importer::_handle_start_config_object(), Slic3r::_3MF_Importer::_handle_start_config_volume(), Slic3r::_3MF_Importer::_handle_start_config_volume_mesh(), Slic3r::_3MF_Importer::_handle_start_object(), Slic3r::_3MF_Importer::_load_model_from_file(), and Slic3r::_3MF_Exporter::_save_model_to_file().

Here is the caller graph for this function:

clear_errors()

void Slic3r::_3MF_Base::clear_errors ( )

inlineprotectedinherited

{ m_errors.clear(); }

References m_errors.

Referenced by Slic3r::_3MF_Importer::load_model_from_file(), and Slic3r::_3MF_Exporter::save_model_to_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 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);
    }

References _save_model_to_file(), Slic3r::_3MF_Base::clear_errors(), m_fullpath_sources, m_zip64, and save_model_to_file().

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

Here is the call graph for this function:

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 add_error(), clear_errors(), and log_errors().

m_fullpath_sources

bool Slic3r::_3MF_Exporter::m_fullpath_sources { true }

private

{ true };

Referenced by _add_model_config_file_to_archive(), and save_model_to_file().

m_zip64

bool Slic3r::_3MF_Exporter::m_zip64 { true }

private

{ true };

Referenced by _add_model_file_to_archive(), and save_model_to_file().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Format/3mf.cpp