Slic3r::_BBS_3MF_Exporter Class Reference

Inheritance diagram for Slic3r::_BBS_3MF_Exporter:

Collaboration diagram for Slic3r::_BBS_3MF_Exporter:

Classes
struct	BuildItem
struct	ObjectData

Public Member Functions
bool	save_model_to_file (StoreParams &store_params)
bool	save_object_mesh (const std::string &temp_path, ModelObject const &object, int obj_id)
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) const
void	clear_errors ()

Private Types
typedef std::map< const ModelVolume *, int >	VolumeToObjectIDMap
typedef std::vector< BuildItem >	BuildItemsList
typedef std::map< ModelObject const *, ObjectData >	ObjectToObjectDataMap

Private Member Functions
bool	_save_model_to_file (const std::string &filename, Model &model, PlateDataPtrs &plate_data_list, std::vector< Preset * > &project_presets, const DynamicPrintConfig *config, const std::vector< ThumbnailData * > &thumbnail_data, const std::vector< ThumbnailData * > &no_light_thumbnail_data, const std::vector< ThumbnailData * > &top_thumbnail_data, const std::vector< ThumbnailData * > &pick_thumbnail_data, Export3mfProgressFn proFn, const std::vector< ThumbnailData * > &calibration_data, const std::vector< PlateBBoxData * > &id_bboxes, BBLProject *project=nullptr, int export_plate_idx=-1)
bool	_add_file_to_archive (mz_zip_archive &archive, const std::string &path_in_zip, const std::string &file_path)
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, const char *local_path, int index, bool generate_small_thumbnail=false)
bool	_add_calibration_file_to_archive (mz_zip_archive &archive, const ThumbnailData &thumbnail_data, int index)
bool	_add_bbox_file_to_archive (mz_zip_archive &archive, const PlateBBoxData &id_bboxes, int index)
bool	_add_relationships_file_to_archive (mz_zip_archive &archive, std::string const &from={}, std::vector< std::string > const &targets={}, std::vector< std::string > const &types={}, PackingTemporaryData data=PackingTemporaryData(), int export_plate_idx=-1, bool plate_thumbnail_written=false, bool plate_small_thumbnail_written=false) const
bool	_add_model_file_to_archive (const std::string &filename, mz_zip_archive &archive, const Model &model, ObjectToObjectDataMap &objects_data, Export3mfProgressFn proFn=nullptr, BBLProject *project=nullptr) const
bool	_add_object_to_model_stream (mz_zip_writer_staged_context &context, ObjectData const &object_data) const
void	_add_object_components_to_stream (std::stringstream &stream, ObjectData const &object_data) const
bool	_add_mesh_to_object_stream (std::function< bool(std::string &, bool)> const &flush, ObjectData const &object_data) const
bool	_add_build_to_model_stream (std::stringstream &stream, const BuildItemsList &build_items) const
bool	_add_layer_height_profile_file_to_archive (mz_zip_archive &archive, Model &model)
bool	_add_cad_recipe_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_brim_ear_points_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_project_config_file_to_archive (mz_zip_archive &archive, const DynamicPrintConfig &config, Model &model)
bool	_add_project_embedded_presets_to_archive (mz_zip_archive &archive, Model &model, std::vector< Preset * > project_presets)
bool	_add_model_config_file_to_archive (mz_zip_archive &archive, const Model &model, PlateDataPtrs &plate_data_list, const ObjectToObjectDataMap &objects_data, const DynamicPrintConfig &config, int export_plate_idx=-1, bool save_gcode=true, bool use_loaded_id=false)
bool	_add_cut_information_file_to_archive (mz_zip_archive &archive, Model &model)
bool	_add_slice_info_config_file_to_archive (mz_zip_archive &archive, const Model &model, PlateDataPtrs &plate_data_list, const ObjectToObjectDataMap &objects_data, const DynamicPrintConfig &config)
bool	_add_filament_sequence_file_to_archive (mz_zip_archive &archive, const PlateDataPtrs &plate_data_list)
bool	_add_gcode_file_to_archive (mz_zip_archive &archive, const Model &model, PlateDataPtrs &plate_data_list, Export3mfProgressFn proFn=nullptr)
bool	_add_custom_gcode_per_print_z_file_to_archive (mz_zip_archive &archive, Model &model, const DynamicPrintConfig *config)
bool	_add_auxiliary_dir_to_archive (mz_zip_archive &archive, const std::string &aux_dir, PackingTemporaryData &data)

Static Private Member Functions
static int	convert_instance_id_to_resource_id (const Model &model, int obj_id, int instance_id)

Private Attributes
bool	m_fullpath_sources { false }
bool	m_zip64 { true }
bool	m_production_ext { false }
bool	m_skip_static { false }
bool	m_from_backup_save { false }
bool	m_split_model { false }
bool	m_save_gcode { false }
bool	m_skip_model { false }
bool	m_skip_auxiliary { false }
bool	m_minimal_published { false }
bool	m_use_loaded_id { false }
bool	m_share_mesh { false }
std::string	m_thumbnail_middle = PRINTER_THUMBNAIL_MIDDLE_FILE
std::string	m_thumbnail_small = PRINTER_THUMBNAIL_SMALL_FILE
std::map< void const *, std::pair< ObjectData *, ModelVolume const * > >	m_shared_meshes
std::map< ModelVolume const *, std::pair< std::string, int > >	m_volume_paths
boost::mutex	mutex
std::vector< std::string >	m_errors

Detailed Description

---

Class Documentation

Slic3r::_BBS_3MF_Exporter::ObjectData

struct Slic3r::_BBS_3MF_Exporter::ObjectData

Collaboration diagram for Slic3r::_BBS_3MF_Exporter::ObjectData:

Class Members
int	backup_id
ModelObject const *	object
int	object_id = 0
bool	share_mesh = false
string	sub_path
VolumeToObjectIDMap	volumes_objectID

Member Typedef Documentation

BuildItemsList

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

private

ObjectToObjectDataMap

typedef std::map<ModelObject const *, ObjectData> Slic3r::_BBS_3MF_Exporter::ObjectToObjectDataMap

private

VolumeToObjectIDMap

typedef std::map<const ModelVolume*, int> Slic3r::_BBS_3MF_Exporter::VolumeToObjectIDMap

private

Member Function Documentation

_add_auxiliary_dir_to_archive()

bool Slic3r::_BBS_3MF_Exporter::_add_auxiliary_dir_to_archive ( mz_zip_archive & archive, const std::string & aux_dir, PackingTemporaryData & data )

private

{
    bool result = true;
 
    if (aux_dir.empty()) {
        //no accessory directories
        return result;
    }
 
    boost::filesystem::path dir = boost::filesystem::path(aux_dir);
    if (!boost::filesystem::exists(dir))
    {
        //no accessory directories
        return result;
    }
 
    static std::string const nocomp_exts[] = {".png", ".jpg", ".mp4", ".jpeg"};
    std::deque<boost::filesystem::path> directories({dir});
    int root_dir_len = dir.string().length() + 1;
    //boost file access
    while (!directories.empty()) {
        boost::system::error_code ec;
        boost::filesystem::directory_iterator iterator(directories.front(), ec);
        directories.pop_front();
        if (ec) continue;
        for (; iterator != end(iterator); iterator.increment(ec))
        {
            if (ec) break;
            auto dir_entry = *iterator;
            std::string src_file;
            std::string dst_in_3mf;
            if (boost::filesystem::is_directory(dir_entry.path(), ec))
            {
                directories.push_back(dir_entry.path());
                continue;
            }
            if (boost::filesystem::is_regular_file(dir_entry.path(), ec) && !m_skip_auxiliary)
            {
                src_file = dir_entry.path().string();
                dst_in_3mf = dir_entry.path().string();
                dst_in_3mf.replace(0, root_dir_len, AUXILIARY_DIR);
                std::replace(dst_in_3mf.begin(), dst_in_3mf.end(), '\\', '/');
                if (_3MF_COVER_FILE.compare(1, _3MF_COVER_FILE.length() - 1, dst_in_3mf) == 0) {
                    data._3mf_thumbnail = dst_in_3mf;
                } else if (!m_thumbnail_small.empty() && m_thumbnail_small.compare(1, m_thumbnail_small.length() - 1, dst_in_3mf) == 0) {
                    data._3mf_printer_thumbnail_small = dst_in_3mf;
                    if (m_thumbnail_middle == m_thumbnail_small) data._3mf_printer_thumbnail_middle = dst_in_3mf;
                } else if (!m_thumbnail_middle.empty() && m_thumbnail_middle.compare(1, m_thumbnail_middle.length() - 1, dst_in_3mf) == 0) {
                    data._3mf_printer_thumbnail_middle = dst_in_3mf;
                }
                result &= _add_file_to_archive(archive, dst_in_3mf, src_file);
            }
        }
    }
 
    return result;
}

References _3MF_COVER_FILE, Slic3r::PackingTemporaryData::_3mf_printer_thumbnail_middle, Slic3r::PackingTemporaryData::_3mf_printer_thumbnail_small, Slic3r::PackingTemporaryData::_3mf_thumbnail, _add_auxiliary_dir_to_archive(), _add_file_to_archive(), AUXILIARY_DIR, m_skip_auxiliary, m_thumbnail_middle, and m_thumbnail_small.

Referenced by _add_auxiliary_dir_to_archive(), _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_bbox_file_to_archive()

bool Slic3r::_BBS_3MF_Exporter::_add_bbox_file_to_archive ( mz_zip_archive & archive, const PlateBBoxData & id_bboxes, int index )

private

    {
        bool res = false;
        nlohmann::json j;
        id_bboxes.to_json(j);
        std::string out = j.dump();
 
        std::string json_file_name = (boost::format(PATTERN_CONFIG_FILE_FORMAT) % (index + 1)).str();
        if (!mz_zip_writer_add_mem(&archive, json_file_name.c_str(), (const void*)out.data(), out.length(), MZ_DEFAULT_COMPRESSION)) {
            add_error("Unable to add json file to archive");
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", Unable to add json file to archive\n");
            return false;
        }
 
        return true;
    }

References _add_bbox_file_to_archive(), Slic3r::_BBS_3MF_Base::add_error(), PATTERN_CONFIG_FILE_FORMAT, and Slic3r::PlateBBoxData::to_json().

Referenced by _add_bbox_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_brim_ear_points_file_to_archive()

bool Slic3r::_BBS_3MF_Exporter::_add_brim_ear_points_file_to_archive ( mz_zip_archive & archive, Model & model )

private

    {
        std::string out = "";
        char buffer[1024];
 
        unsigned int count = 0;
        for (const ModelObject* object : model.objects) {
            ++count;
            const BrimPoints& brim_points = object->brim_points;
            if (!brim_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 < brim_points.size(); ++i) {
                    sprintf(buffer, (i==0 ? "%f %f %f %f" : " %f %f %f %f"),  brim_points[i].pos(0), brim_points[i].pos(1), brim_points[i].pos(2), brim_points[i].head_front_radius);
                    out += buffer;
                }
                out += "\n";
            }
        }
 
        if (!out.empty()) {
            // Adds version header at the beginning:
            out = std::string("brim_points_format_version=") + std::to_string(brim_points_format_version) + std::string("\n") + out;
 
            if (!mz_zip_writer_add_mem(&archive, BRIM_EAR_POINTS_FILE.c_str(), (const void*)out.data(), out.length(), MZ_DEFAULT_COMPRESSION)) {
                add_error("Unable to add brim ear points file to archive");
                return false;
            }
        }
        return true;
    }

References _add_brim_ear_points_file_to_archive(), Slic3r::_BBS_3MF_Base::add_error(), BRIM_EAR_POINTS_FILE, Slic3r::brim_points_format_version, count, and Slic3r::Model::objects.

Referenced by _add_brim_ear_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_build_to_model_stream()

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

private

    {
        // This happens for empty projects
        if (build_items.size() == 0) {
            stream << " <" << BUILD_TAG << "/>\n";
            return true;
        }
 
        stream << " <" << BUILD_TAG;
        if (m_production_ext)
            stream << " " << PUUID_ATTR << "=\"" << BUILD_UUID << "\"";
        stream << ">\n";
 
        for (const BuildItem& item : build_items) {
            stream << "  <" << ITEM_TAG << " " << OBJECTID_ATTR << "=\"" << item.id;
            if (m_production_ext)
                stream << "\" " << PUUID_ATTR << "=\"" << hex_wrap<boost::uint32_t>{item.id} << BUILD_UUID_SUFFIX;
            if (!item.path.empty())
                stream << "\" " << PPATH_ATTR << "=\"" << xml_escape(item.path);
            stream << "\" " << TRANSFORM_ATTR << "=\"";
            add_transformation(stream, item.transform);
            stream << "\" " << PRINTABLE_ATTR << "=\"" << item.printable << "\"/>\n";
        }
 
        stream << " </" << BUILD_TAG << ">\n";
 
        return true;
    }

References _add_build_to_model_stream(), add_transformation(), BUILD_TAG, BUILD_UUID, BUILD_UUID_SUFFIX, ITEM_TAG, m_production_ext, OBJECTID_ATTR, PPATH_ATTR, PRINTABLE_ATTR, PUUID_ATTR, TRANSFORM_ATTR, and Slic3r::xml_escape().

Referenced by _add_build_to_model_stream().

Here is the call graph for this function:

Here is the caller graph for this function:

_add_cad_recipe_file_to_archive()

bool Slic3r::_BBS_3MF_Exporter::_add_cad_recipe_file_to_archive ( mz_zip_archive & archive, Model & model )

private

    {
        if (model.cad_recipe.empty())
            return true;
        if (!mz_zip_writer_add_mem(&archive, ORCA_CAD_RECIPE_FILE.c_str(),
                (const void*)model.cad_recipe.data(), model.cad_recipe.length(),
                MZ_DEFAULT_COMPRESSION)) {
            add_error("Unable to add CAD recipe file to archive");
            return false;
        }
        return true;
    }

References _add_cad_recipe_file_to_archive(), Slic3r::_BBS_3MF_Base::add_error(), Slic3r::Model::cad_recipe, and ORCA_CAD_RECIPE_FILE.

Referenced by _add_cad_recipe_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_calibration_file_to_archive()

bool Slic3r::_BBS_3MF_Exporter::_add_calibration_file_to_archive ( mz_zip_archive & archive, const ThumbnailData & thumbnail_data, int index )

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_COMPRESSION, 1);
        if (png_data != nullptr) {
            std::string thumbnail_name = (boost::format(PATTERN_FILE_FORMAT) % (index + 1)).str();
            res = mz_zip_writer_add_mem(&archive, thumbnail_name.c_str(), (const void*)png_data, png_size, MZ_NO_COMPRESSION);
            mz_free(png_data);
        }
 
        if (!res) {
            add_error("Unable to add thumbnail file to archive");
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", Unable to add thumbnail file to archive\n");
        }*/
 
        return res;
    }

References _add_calibration_file_to_archive().

Referenced by _add_calibration_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_content_types_file_to_archive()

bool Slic3r::_BBS_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 << " <Default Extension=\"jpg\" ContentType=\"image/jpeg\"/>\n";
        stream << " <Default Extension=\"jpeg\" ContentType=\"image/jpeg\"/>\n";
        stream << " <Default Extension=\"json\" ContentType=\"application/json\"/>\n";
        stream << " <Default Extension=\"gcode\" ContentType=\"text/x.gcode\"/>\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");
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", Unable to add content types file to archive\n");
            return false;
        }
 
        return true;
    }

References _add_content_types_file_to_archive(), Slic3r::_BBS_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::_BBS_3MF_Exporter::_add_custom_gcode_per_print_z_file_to_archive ( mz_zip_archive & archive, Model & model, const DynamicPrintConfig * config )

private

{
    //BBS: add plate tree related logic
    std::string out = "";
    bool has_custom_gcode = false;
    pt::ptree tree;
    pt::ptree& main_tree = tree.add("custom_gcodes_per_layer", "");
    for (auto custom_gcodes : model.plates_custom_gcodes) {
            has_custom_gcode = true;
            pt::ptree& plate_tree = main_tree.add("plate", "");
            pt::ptree& plate_idx_tree = plate_tree.add("plate_info", "");
            plate_idx_tree.put("<xmlattr>.id", custom_gcodes.first + 1);
 
            // store data of custom_gcode_per_print_z
            for (const CustomGCode::Item& code : custom_gcodes.second.gcodes) {
                pt::ptree& code_tree = plate_tree.add("layer", "");
                code_tree.put("<xmlattr>.top_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 = plate_tree.add("mode", "");
            // store mode of a custom_gcode_per_print_z
            mode_tree.put("<xmlattr>.value", custom_gcodes.second.mode == CustomGCode::Mode::SingleExtruder ? CustomGCode::SingleExtruderMode :
                custom_gcodes.second.mode == CustomGCode::Mode::MultiAsSingle ? CustomGCode::MultiAsSingleMode :
                CustomGCode::MultiExtruderMode);
 
    }
    if (has_custom_gcode) {
        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");
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", Unable to add custom Gcodes per print_z file to archive\n");
            return false;
        }
    }
 
    return true;
}

References _add_custom_gcode_per_print_z_file_to_archive(), Slic3r::_BBS_3MF_Base::add_error(), Slic3r::CustomGCode::Item::color, CUSTOM_GCODE_PER_PRINT_Z_FILE, Slic3r::CustomGCode::Item::extra, Slic3r::CustomGCode::Item::extruder, Slic3r::CustomGCode::MultiAsSingle, Slic3r::CustomGCode::MultiAsSingleMode, Slic3r::CustomGCode::MultiExtruderMode, Slic3r::DynamicConfig::opt_string(), Slic3r::CustomGCode::PausePrint, Slic3r::Model::plates_custom_gcodes, Slic3r::CustomGCode::Item::print_z, Slic3r::CustomGCode::SingleExtruder, Slic3r::CustomGCode::SingleExtruderMode, Slic3r::CustomGCode::Template, Slic3r::CustomGCode::ToolChange, and Slic3r::CustomGCode::Item::type.

Referenced by _add_custom_gcode_per_print_z_file_to_archive(), _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_cut_information_file_to_archive()

bool Slic3r::_BBS_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 _add_cut_information_file_to_archive(), Slic3r::_BBS_3MF_Base::add_error(), Slic3r::CutObjectBase::check_sum(), Slic3r::ModelVolume::CutInfo::connector_type, Slic3r::CutObjectBase::connectors_cnt(), Slic3r::ModelObject::cut_id, Slic3r::ModelVolume::cut_info, CUT_INFORMATION_FILE, Slic3r::ModelVolume::CutInfo::height_tolerance, Slic3r::ObjectBase::id(), Slic3r::ObjectID::id, Slic3r::ModelObject::is_cut(), Slic3r::ModelVolume::is_cut_connector(), Slic3r::Model::objects, Slic3r::ModelVolume::CutInfo::radius_tolerance, and Slic3r::ModelObject::volumes.

Referenced by _add_cut_information_file_to_archive(), _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_filament_sequence_file_to_archive()

bool Slic3r::_BBS_3MF_Exporter::_add_filament_sequence_file_to_archive ( mz_zip_archive & archive, const PlateDataPtrs & plate_data_list )

private

    {
        nlohmann::json sequence_json;
 
        for (size_t idx = 0; idx < plate_data_list.size(); ++idx) {
            const PlateData* plate_data = plate_data_list[idx];
            if (!plate_data)
                continue;
 
            std::vector<unsigned int> filament_sequence = plate_data->filament_change_sequence;
            std::transform(filament_sequence.begin(), filament_sequence.end(), filament_sequence.begin(),
                [](unsigned int filament_id) { return filament_id + 1; });
 
            const std::string plate_key = "plate_" + std::to_string(idx + 1);
            // Dynamic-map plates write the sequence under "filament_sequence"; every other plate (the
            // whole shipping fleet + H2C static mode) keeps the "sequence" key, so the saved 3mf is
            // byte-identical to the older format. The reader accepts both.
            const bool enable_dynamic_map = plate_data->nozzle_group_result && plate_data->nozzle_group_result->is_support_dynamic_nozzle_map();
            const std::string seq_key = enable_dynamic_map ? "filament_sequence" : "sequence";
            sequence_json[plate_key][seq_key] = filament_sequence;
            sequence_json[plate_key]["nozzle_sequence"] = plate_data->nozzle_change_sequence;
            sequence_json[plate_key]["optimal_assignment"] = plate_data->optimal_assignment;
        }
 
        if (sequence_json.empty())
            return true;
 
        const std::string out = sequence_json.dump();
        if (!mz_zip_writer_add_mem(&archive, FILAMENT_SEQUENCE_FILE.c_str(), out.c_str(), out.size(), MZ_DEFAULT_COMPRESSION)) {
            add_error("Unable to add filament sequence file to archive");
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__
                                     << boost::format(", store filament sequence to 3mf, length %1%, failed\n") % out.length();
            return false;
        }
 
        return true;
    }

References _add_filament_sequence_file_to_archive(), Slic3r::_BBS_3MF_Base::add_error(), Slic3r::PlateData::filament_change_sequence, FILAMENT_SEQUENCE_FILE, Slic3r::PlateData::nozzle_change_sequence, Slic3r::PlateData::nozzle_group_result, and Slic3r::PlateData::optimal_assignment.

Referenced by _add_filament_sequence_file_to_archive(), _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_file_to_archive()

bool Slic3r::_BBS_3MF_Exporter::_add_file_to_archive ( mz_zip_archive & archive, const std::string & path_in_zip, const std::string & file_path )

private

    {
        static std::string const nocomp_exts[] = {".png", ".jpg", ".mp4", ".jpeg", ".zip", ".3mf"};
        auto end = nocomp_exts + sizeof(nocomp_exts) / sizeof(nocomp_exts[0]);
        bool nocomp = std::find_if(nocomp_exts, end, [&path_in_zip](auto & ext) { return boost::algorithm::ends_with(path_in_zip, ext); }) != end;
#if WRITE_ZIP_LANGUAGE_ENCODING
        bool result = mz_zip_writer_add_file(&archive, path_in_zip.c_str(), encode_path(src_file_path.c_str()).c_str(), NULL, 0, nocomp ? MZ_NO_COMPRESSION : MZ_DEFAULT_LEVEL);
#else
        std::string native_path = encode_path(path_in_zip.c_str());
        std::string extra = ZipUnicodePathExtraField::encode(path_in_zip, native_path);
        bool result = mz_zip_writer_add_file_ex(&archive, native_path.c_str(), encode_path(src_file_path.c_str()).c_str(), NULL, 0, nocomp ? MZ_ZIP_FLAG_ASCII_FILENAME : MZ_DEFAULT_COMPRESSION,
                extra.c_str(), extra.length(), extra.c_str(), extra.length());
#endif
        if (!result) {
            add_error("Unable to add file " + src_file_path + " to archive");
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" <<__LINE__ << boost::format(", Unable to add file %1% to archive %2%\n") % src_file_path % path_in_zip;
        } else {
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format(", add file %1% to archive %2%\n") % src_file_path % path_in_zip;
        }
        return result;
    }

References _add_file_to_archive(), Slic3r::_BBS_3MF_Base::add_error(), ZipUnicodePathExtraField::encode(), and Slic3r::encode_path().

Referenced by _add_auxiliary_dir_to_archive(), _add_file_to_archive(), _add_project_config_file_to_archive(), _add_project_embedded_presets_to_archive(), and _save_model_to_file().

Here is the call graph for this function:

Here is the caller graph for this function:

_add_gcode_file_to_archive()

bool Slic3r::_BBS_3MF_Exporter::_add_gcode_file_to_archive ( mz_zip_archive & archive, const Model & model, PlateDataPtrs & plate_data_list, Export3mfProgressFn proFn = nullptr )

private

{
    bool result = true;
    bool cb_cancel = false;
 
    PlateDataPtrs plate_data_list2;
    for (unsigned int i = 0; i < (unsigned int)plate_data_list.size(); ++i)
    {
        if (proFn) {
            proFn(EXPORT_STAGE_ADD_GCODE, i, plate_data_list.size(), cb_cancel);
            if (cb_cancel)
                return false;
        }
 
        PlateData* plate_data = plate_data_list[i];
        if (!plate_data->gcode_file.empty() && plate_data->is_sliced_valid && boost::filesystem::exists(plate_data->gcode_file)) {
            plate_data_list2.push_back(plate_data);
        }
    }
 
    boost::mutex mutex;
    tbb::parallel_for(tbb::blocked_range<size_t>(0, plate_data_list2.size(), 1), [this, &plate_data_list2, &root_archive = archive, &mutex, &result](const tbb::blocked_range<size_t>& range) {
        for (int i = range.begin(); i < range.end(); ++i) {
            PlateData* plate_data = plate_data_list2[i];
            auto src_gcode_file = plate_data->gcode_file;
            std::string gcode_in_3mf = (boost::format(GCODE_FILE_FORMAT) % (plate_data->plate_index + 1)).str();
 
            plate_data->gcode_file = gcode_in_3mf;
            mz_zip_archive archive;
            mz_zip_writer_staged_context context;
            mz_zip_zero_struct(&archive);
            mz_zip_writer_init_heap(&archive, 0, 1024 * 1024);
            {
                mz_zip_writer_add_staged_open(&archive, &context, gcode_in_3mf.c_str(), m_zip64 ? (uint64_t(1) << 30) * 16 : (uint64_t(1) << 32) - 1, nullptr, nullptr, 0,
                    MZ_DEFAULT_COMPRESSION, nullptr, 0, nullptr, 0);
                boost::filesystem::path src_gcode_path(src_gcode_file);
                if (!boost::filesystem::exists(src_gcode_path)) {
                    BOOST_LOG_TRIVIAL(error) << "Gcode is missing, filename = " << src_gcode_file;
                    result = false;
                }
                boost::filesystem::ifstream ifs(src_gcode_file, std::ios::binary);
                std::string buf(64 * 1024, 0);
                while (ifs) {
                    ifs.read(buf.data(), buf.size());
                    mz_zip_writer_add_staged_data(&context, buf.data(), ifs.gcount());
                }
                mz_zip_writer_add_staged_finish(&context);
            }
            void *ppBuf; size_t pSize;
            mz_zip_writer_finalize_heap_archive(&archive, &ppBuf, &pSize);
            mz_zip_writer_end(&archive);
            mz_zip_zero_struct(&archive);
            mz_zip_reader_init_mem(&archive, ppBuf, pSize, 0);
            {
                boost::unique_lock l(mutex);
                mz_zip_writer_add_from_zip_reader(&root_archive, &archive, 0);
            }
            mz_zip_reader_end(&archive);
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format(", store  %1% to 3mf %2%\n") % src_gcode_file % gcode_in_3mf;
        }
    });
    for (const PlateData *plate_data : plate_data_list2) {
        if (plate_data->statistics.empty())
            continue;
        const std::string statistics_in_3mf = (boost::format(STATISTICS_FILE_FORMAT) % (plate_data->plate_index + 1)).str();
        if (!mz_zip_writer_add_mem(&archive, statistics_in_3mf.c_str(), plate_data->statistics.data(), plate_data->statistics.size(),
                                   MZ_DEFAULT_COMPRESSION)) {
            add_error("Unable to add statistics file to archive");
            result = false;
        }
    }
    return result;
}

References _add_gcode_file_to_archive(), Slic3r::EXPORT_STAGE_ADD_GCODE, Slic3r::PlateData::gcode_file, Slic3r::PlateData::is_sliced_valid, Slic3r::_BBS_3MF_Base::mutex, and Slic3r::range().

Referenced by _add_gcode_file_to_archive(), _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_layer_config_ranges_file_to_archive()

bool Slic3r::_BBS_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");
                BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format("Unable to add layer heights profile file to archive\n");
                return false;
            }
        }
 
        return true;
    }

References _add_layer_config_ranges_file_to_archive(), Slic3r::_BBS_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::_BBS_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) {
                snprintf(buffer, 1024, "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) {
                    snprintf(buffer, 1024, (i == 0) ? "%f" : ";%f", layer_height_profile[i]);
                    out += buffer;
                }
 
                out += "\n";
            }
        }
 
        if (!out.empty()) {
            if (!mz_zip_writer_add_mem(&archive, BBS_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");
                BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format("Unable to add layer heights profile file to archive\n");
                return false;
            }
        }
 
        return true;
    }

References _add_layer_height_profile_file_to_archive(), Slic3r::_BBS_3MF_Base::add_error(), BBS_LAYER_HEIGHTS_PROFILE_FILE, count, Slic3r::is_decimal_separator_point(), 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::_BBS_3MF_Exporter::_add_mesh_to_object_stream ( std::function< bool(std::string &, bool)> const & flush, ObjectData const & object_data ) const

private

    {
        std::string output_buffer;
 
#if 0
        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");
                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", Error during writing or compression\n");
                    return false;
                }
                output_buffer.clear();
            }
            return true;
        };
#endif
 
        /*output_buffer += "   <";
        output_buffer += MESH_TAG;
        output_buffer += ">\n    <";
        output_buffer += VERTICES_TAG;
        output_buffer += ">\n";*/
 
        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
        };
 
        auto const & object = *object_data.object;
 
        char buf[256];
        unsigned int vertices_count = 0;
        //unsigned int triangles_count = 0;
        for (unsigned int index = 0; index < object.volumes.size(); index++) {
            ModelVolume *volume = object.volumes[index];
            if (volume == nullptr)
                continue;
 
            int volume_id = object_data.volumes_objectID.find(volume)->second;
            if (m_share_mesh && volume_id == 0)
                continue;
 
      //if (!volume->mesh().stats().repaired())
      //  throw Slic3r::FileIOError("store_3mf() requires repair()");
 
            const indexed_triangle_set &its = volume->mesh().its;
            if (its.vertices.empty()) {
                add_error("Found invalid mesh");
                BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", Found invalid mesh\n");
                return false;
            }
 
            // Orca#7574: always use "model" type to follow the 3MF Core Specification:
            // https://github.com/3MFConsortium/spec_core/blob/20c079eef39e45ed223b8443dc9f34cbe32dc2c2/3MF%20Core%20Specification.md#3431-item-element
            // > Note: items MUST NOT reference objects of type "other", either directly or recursively.
            // This won't break anything because when loading the file Orca (and Bambu) simply does not care about the actual object type at all (as long as it's one of "model" & "other");
            // But PrusaSlicer requires the type to be "model".
            std::string type = "model";
 
            output_buffer += "  <";
            output_buffer += OBJECT_TAG;
            output_buffer += " id=\"";
            output_buffer += std::to_string(volume_id);
            if (m_production_ext) {
                std::stringstream stream;
                reset_stream(stream);
                stream << "\" " << PUUID_ATTR << "=\"" << hex_wrap<boost::uint32_t>{(boost::uint32_t) (index + (object_data.backup_id << 16))} << SUB_OBJECT_UUID_SUFFIX;
                //output_buffer += "\" ";
                //output_buffer += PUUID_ATTR;
                //output_buffer += "=\"";
                //output_buffer += std::to_string(hex_wrap<boost::uint32_t>{(boost::uint32_t)backup_id});
                //output_buffer += OBJECT_UUID_SUFFIX;
                output_buffer += stream.str();
            }
            output_buffer += "\" type=\"";
            output_buffer += type;
            output_buffer += "\">\n";
            output_buffer += "   <";
            output_buffer += MESH_TAG;
            output_buffer += ">\n    <";
            output_buffer += VERTICES_TAG;
            output_buffer += ">\n";
 
            vertices_count += (int)its.vertices.size();
 
            for (size_t i = 0; i < its.vertices.size(); ++i) {
                //don't save the volume's matrix into vertex data
                //add the shared mesh logic
                //Vec3f v = (matrix * its.vertices[i].cast<double>()).cast<float>();
                Vec3f v = its.vertices[i];
                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(output_buffer, false))
                    return false;
            }
        //}
 
            output_buffer += "    </";
            output_buffer += VERTICES_TAG;
            output_buffer += ">\n    <";
            output_buffer += TRIANGLES_TAG;
            output_buffer += ">\n";
 
        //for (ModelVolume* volume : object.volumes) {
        //    if (volume == nullptr)
        //        continue;
 
            //BBS: as we stored matrix seperately, not multiplied into vertex
            //we don't need to consider this left hand case specially
            //bool is_left_handed = volume->is_left_handed();
            bool is_left_handed = false;
            //VolumeToOffsetsMap::iterator volume_it = volumes_objectID.find(volume);
            //assert(volume_it != volumes_objectID.end());
 
            //const indexed_triangle_set &its = volume->mesh().its;
 
            // updates triangle offsets
            //unsigned int first_triangle_id = triangles_count;
            //triangles_count += (int)its.indices.size();
            //unsigned int 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],
                        idx[1],
                        idx[is_left_handed ? 0 : 2]);
                    *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_painting_data_string = volume->fuzzy_skin_facets.get_triangle_as_string(i);
                if (!fuzzy_skin_painting_data_string.empty()) {
                    output_buffer += " ";
                    output_buffer += CUSTOM_FUZZY_SKIN_ATTR;
                    output_buffer += "=\"";
                    output_buffer += fuzzy_skin_painting_data_string;
                    output_buffer += "\"";
                }
 
                // One attribute per texture displacement layer slot. Older readers ignore attributes they do
                // not know, so a project written here still opens in a build without the feature - it just
                // loses the paint, which is also all it could have done with it.
                for (int slot = 0; slot < TEXTURE_DISPLACEMENT_MAX_LAYERS; ++slot) {
                    const std::string texture_paint = volume->texture_displacement_facet(slot).get_triangle_as_string(i);
                    if (texture_paint.empty())
                        continue;
                    output_buffer += " ";
                    output_buffer += TEXTURE_DISPLACEMENT_ATTRS[slot];
                    output_buffer += "=\"";
                    output_buffer += texture_paint;
                    output_buffer += "\"";
                }
 
                // BBS
                if (i < its.properties.size()) {
                    std::string prop_str = its.properties[i].to_string();
                    if (!prop_str.empty()) {
                        output_buffer += " ";
                        output_buffer += FACE_PROPERTY_ATTR;
                        output_buffer += "=\"";
                        output_buffer += prop_str;
                        output_buffer += "\"";
                    }
                }
 
                output_buffer += "/>\n";
 
                if (! flush(output_buffer, false))
                    return false;
            }
            output_buffer += "    </";
            output_buffer += TRIANGLES_TAG;
            output_buffer += ">\n   </";
            output_buffer += MESH_TAG;
            output_buffer += ">\n";
            output_buffer +=  "  </";
            output_buffer += OBJECT_TAG;
            output_buffer += ">\n";
        }
 
        // Force flush.
        return flush(output_buffer, true);
    }

References _add_mesh_to_object_stream(), Slic3r::_BBS_3MF_Base::add_error(), Slic3r::_BBS_3MF_Exporter::ObjectData::backup_id, CUSTOM_FUZZY_SKIN_ATTR, CUSTOM_SEAM_ATTR, CUSTOM_SUPPORTS_ATTR, Slic3r::f(), FACE_PROPERTY_ATTR, Slic3r::ModelVolume::fuzzy_skin_facets, Slic3r::FacetsAnnotation::get_triangle_as_string(), Slic3r::is_decimal_separator_point(), Slic3r::TriangleMesh::its, m_production_ext, m_share_mesh, Slic3r::ModelVolume::mesh(), MESH_TAG, MMU_SEGMENTATION_ATTR, Slic3r::ModelVolume::mmu_segmentation_facets, Slic3r::_BBS_3MF_Exporter::ObjectData::object, OBJECT_TAG, PUUID_ATTR, Slic3r::reset_stream(), Slic3r::ModelVolume::seam_facets, SUB_OBJECT_UUID_SUFFIX, Slic3r::ModelVolume::supported_facets, TEXTURE_DISPLACEMENT_ATTRS, Slic3r::ModelVolume::texture_displacement_facet(), Slic3r::TEXTURE_DISPLACEMENT_MAX_LAYERS, TRIANGLE_TAG, TRIANGLES_TAG, VERTEX_TAG, VERTICES_TAG, and Slic3r::_BBS_3MF_Exporter::ObjectData::volumes_objectID.

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::_BBS_3MF_Exporter::_add_model_config_file_to_archive ( mz_zip_archive & archive, const Model & model, PlateDataPtrs & plate_data_list, const ObjectToObjectDataMap & objects_data, const DynamicPrintConfig & config, int export_plate_idx = -1, bool save_gcode = true, bool use_loaded_id = false )

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";
 
        if (!m_skip_model)
        for (const ObjectToObjectDataMap::value_type& obj_metadata : objects_data) {
            auto object_data = obj_metadata.second;
            const ModelObject *obj = object_data.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";
                stream << "  <" << OBJECT_TAG << " " << ID_ATTR << "=\"" << object_data.object_id
                       << "\" " << AUTO_DROP_ATTR << "=\"" << obj->auto_drop << "\">\n";
 
                // stores object's name
                if (!obj->name.empty())
                    stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"name\" " << VALUE_ATTR << "=\"" << xml_escape(obj->name) << "\"/>\n";
 
                //BBS: store object's module name
                if (!obj->module_name.empty())
                    stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"module\" " << VALUE_ATTR << "=\"" << xml_escape(obj->module_name) << "\"/>\n";
 
                // stores object's config data
                for (const std::string& key : obj->config.keys()) {
                    stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << key << "\" " << VALUE_ATTR << "=\"" << obj->config.opt_serialize(key) << "\"/>\n";
                }
 
                for (const ModelVolume* volume : obj_metadata.second.object->volumes) {
                    if (volume != nullptr) {
                        const VolumeToObjectIDMap& objectIDs = obj_metadata.second.volumes_objectID;
                        VolumeToObjectIDMap::const_iterator it = objectIDs.find(volume);
                        if (it != objectIDs.end()) {
                            // stores volume's offsets
                            stream << "    <" << PART_TAG << " ";
                            //stream << FIRST_TRIANGLE_ID_ATTR << "=\"" << it->second.first_triangle_id << "\" ";
                            //stream << LAST_TRIANGLE_ID_ATTR << "=\"" << it->second.last_triangle_id << "\" ";
                            int volume_id = it->second;
                            if (m_share_mesh && volume_id == 0)
                                volume_id = m_volume_paths.find(volume)->second.second;
                            stream << ID_ATTR << "=\"" << volume_id << "\" ";
 
                            // Older slicers must recognize the base type even when they ignore seam metadata.
                            const ModelVolumeType stored_type = volume->is_precise_seam() ? ModelVolumeType::PARAMETER_MODIFIER : volume->type();
                            stream << SUBTYPE_ATTR << "=\"" << ModelVolume::type_to_string(stored_type) << "\">\n";
                            if (volume->is_precise_seam())
                                stream << "      <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << PRECISE_SEAM_TYPE_KEY << "\" " << VALUE_ATTR << "=\"" <<
                                    ModelVolume::type_to_string(volume->type()) << "\"/>\n";
                            //stream << "    <" << PART_TAG << " " << ID_ATTR << "=\"" << it->second << "\" " << SUBTYPE_ATTR << "=\"" << ModelVolume::type_to_string(volume->type()) << "\">\n";
 
                            // stores volume's name
                            if (!volume->name.empty())
                                stream << "      <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << NAME_KEY << "\" " << VALUE_ATTR << "=\"" << xml_escape(volume->name) << "\"/>\n";
                                //stream << "      <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << NAME_KEY << "\" " << VALUE_ATTR << "=\"" << xml_escape(volume->name) << "\"/>\n";
 
                            // stores volume's modifier field (legacy, to support old slicers)
                            /*if (volume->is_modifier())
                                stream << "      <" << METADATA_TAG << " " << TYPE_ATTR << "=\"" << PART_TYPE << "\" " << KEY_ATTR << "=\"" << MODIFIER_KEY << "\" " << VALUE_ATTR << "=\"1\"/>\n";
                            // stores volume's type (overrides the modifier field above)
                            stream << "      <" << METADATA_TAG << " " << TYPE_ATTR << "=\"" << PART_TYPE << "\" " << KEY_ATTR << "=\"" << PART_TYPE_KEY << "\" " <<
                                VALUE_ATTR << "=\"" << ModelVolume::type_to_string(volume->type()) << "\"/>\n";*/
 
                            // stores volume's local matrix
                            stream << "      <" << METADATA_TAG << " " << 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
                            {
                                auto file_path =get_dealed_platform_path(volume->source.input_file);
                                std::string input_file = xml_escape(m_fullpath_sources ? volume->source.input_file : file_path.filename().string());
                                //std::string prefix = std::string("      <") + METADATA_TAG + " " + KEY_ATTR + "=\"";
                                std::string prefix = std::string("      <") + METADATA_TAG + " " + 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 << " "<< KEY_ATTR << "=\"" << stored_key << "\" " << VALUE_ATTR << "=\"" << xml_escape_double_quotes_attribute_value(value) << "\"/>\n";
                            }
 
                            if (const std::optional<EmbossShape> &es = volume->emboss_shape; es.has_value()) {
                                to_xml(stream, *es, *volume, archive, m_fullpath_sources);
                            }
 
                            add_texture_displacement(stream, *volume, archive, std::to_string(volume->id().id));
                    
                            if (const std::optional<TextConfiguration> &tc = volume->text_configuration;
                                tc.has_value())
                                TextConfigurationSerialization::to_xml(stream, *tc);
 
                            // stores mesh's statistics
                            const RepairedMeshErrors& stats = volume->mesh().stats().repaired_errors;
                            stream << "      <" << MESH_STAT_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 << "    </" << PART_TAG << ">\n";
                        }
                    }
                }
 
                stream << "  </" << OBJECT_TAG << ">\n";
            }
        }
 
        //BBS: store plate related logic
        std::vector<std::string> gcode_paths;
        for (unsigned int i = 0; i < (unsigned int)plate_data_list.size(); ++i)
        {
            PlateData* plate_data = plate_data_list[i];
            int instance_size = plate_data->objects_and_instances.size();
 
            if (plate_data != nullptr) {
                stream << "  <" << PLATE_TAG << ">\n";
                //plate index
                stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << PLATERID_ATTR << "\" " << VALUE_ATTR << "=\"" << plate_data->plate_index + 1 << "\"/>\n";
                stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << PLATER_NAME_ATTR << "\" " << VALUE_ATTR << "=\"" <<  xml_escape(plate_data->plate_name.c_str()) << "\"/>\n";
                stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << LOCK_ATTR << "\" " << VALUE_ATTR << "=\"" << std::boolalpha<< plate_data->locked<< "\"/>\n";
                ConfigOption* bed_type_opt = plate_data->config.option("curr_bed_type");
                t_config_enum_names bed_type_names = ConfigOptionEnum<BedType>::get_enum_names();
                if (bed_type_opt != nullptr && bed_type_names.size() > bed_type_opt->getInt())
                    stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << BED_TYPE_ATTR << "\" " << VALUE_ATTR << "=\"" << bed_type_names[bed_type_opt->getInt()] << "\"/>\n";
 
                ConfigOption* print_sequence_opt = plate_data->config.option("print_sequence");
                t_config_enum_names print_sequence_names = ConfigOptionEnum<PrintSequence>::get_enum_names();
                if (print_sequence_opt != nullptr && print_sequence_names.size() > print_sequence_opt->getInt())
                    stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << PRINT_SEQUENCE_ATTR << "\" " << VALUE_ATTR << "=\"" << print_sequence_names[print_sequence_opt->getInt()] << "\"/>\n";
 
                ConfigOptionInts *first_layer_print_sequence_opt = plate_data->config.option<ConfigOptionInts>("first_layer_print_sequence");
                if (first_layer_print_sequence_opt != nullptr) {
                    stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << FIRST_LAYER_PRINT_SEQUENCE_ATTR << "\" " << VALUE_ATTR << "=\"";
                    const std::vector<int>& values = first_layer_print_sequence_opt->values;
                    for (int i = 0; i < values.size(); ++i) {
                        stream << values[i];
                        if (i != (values.size() - 1))
                            stream << " ";
                    }
                    stream << "\"/>\n";
                }
 
                ConfigOptionInts *other_layers_print_sequence_opt = plate_data->config.option<ConfigOptionInts>("other_layers_print_sequence");
                if (other_layers_print_sequence_opt != nullptr) {
                    stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << OTHER_LAYERS_PRINT_SEQUENCE_ATTR << "\" " << VALUE_ATTR << "=\"";
                    const std::vector<int> &values = other_layers_print_sequence_opt->values;
                    for (int i = 0; i < values.size(); ++i) {
                        stream << values[i];
                        if (i != (values.size() - 1))
                            stream << " ";
                    }
                    stream << "\"/>\n";
                }
 
                const ConfigOptionInt *sequence_nums_opt = dynamic_cast<const ConfigOptionInt *>(plate_data->config.option("other_layers_print_sequence_nums"));
                if (sequence_nums_opt != nullptr) {
                    stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << OTHER_LAYERS_PRINT_SEQUENCE_NUMS_ATTR << "\" " << VALUE_ATTR << "=\"" << sequence_nums_opt->getInt() << "\"/>\n";
                }
 
                ConfigOption* spiral_mode_opt = plate_data->config.option("spiral_mode");
                if (spiral_mode_opt)
                    stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << SPIRAL_VASE_MODE << "\" " << VALUE_ATTR << "=\"" << spiral_mode_opt->getBool() << "\"/>\n";
 
                {
                    // Mode names are user supplied free text, so the value has to be escaped for an
                    // attribute. xml_escape_double_quotes_attribute_value() is used rather than
                    // xml_escape() because it also emits tab/CR/LF as numeric character references:
                    // XML normalizes literal whitespace in attribute values on read, which would
                    // silently rename the mode. The reader takes the value straight from expat,
                    // which resolves both entities and character references, so this round-trips.
                    auto* imex_mode_opt = plate_data->config.option<ConfigOptionString>("imex_parallel_mode");
                    if (imex_mode_opt && !imex_mode_opt->value.empty() && imex_mode_opt->value != kImexPrimaryMode)
                        stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << IMEX_PARALLEL_MODE_ATTR << "\" " << VALUE_ATTR << "=\"" << xml_escape_double_quotes_attribute_value(imex_mode_opt->value) << "\"/>\n";
                }
                {
                    auto* imex_hfm_opt = plate_data->config.option<ConfigOptionString>("imex_head_filament_map");
                    if (imex_hfm_opt && !imex_hfm_opt->value.empty())
                        stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << IMEX_HEAD_FILAMENT_MAP_ATTR << "\" " << VALUE_ATTR << "=\"" << xml_escape_double_quotes_attribute_value(imex_hfm_opt->value) << "\"/>\n";
                }
 
                //filament map related
                ConfigOption* filament_map_mode_opt = plate_data->config.option("filament_map_mode");
                t_config_enum_names filament_map_mode_names = ConfigOptionEnum<FilamentMapMode>::get_enum_names();
                if (filament_map_mode_opt != nullptr && filament_map_mode_names.size() > filament_map_mode_opt->getInt())
                    stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << FILAMENT_MAP_MODE_ATTR << "\" " << VALUE_ATTR << "=\"" << filament_map_mode_names[filament_map_mode_opt->getInt()] << "\"/>\n";
 
                ConfigOptionInts* filament_maps_opt = plate_data->config.option<ConfigOptionInts>("filament_map");
                // filament map override global settings only when group mode overrides the global settings
                if (filament_map_mode_opt !=nullptr && filament_maps_opt != nullptr) {
                    stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << FILAMENT_MAP_ATTR << "\" " << VALUE_ATTR << "=\"";
                    const std::vector<int>& values = filament_maps_opt->values;
                    for (int i = 0; i < values.size(); ++i) {
                        stream << values[i];
                        if (i != (values.size() - 1))
                            stream << " ";
                    }
                    stream << "\"/>\n";
                }
 
                ConfigOptionInts* filament_volume_maps_opt = plate_data->config.option<ConfigOptionInts>("filament_volume_map");
                if (filament_map_mode_opt != nullptr && filament_volume_maps_opt != nullptr) {
                    stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << FILAMENT_VOL_MAP_ATTR << "\" " << VALUE_ATTR << "=\"";
                    const std::vector<int>& volume_values = filament_volume_maps_opt->values;
                    for (int i = 0; i < volume_values.size(); ++i) {
                        stream << volume_values[i];
                        if (i != (volume_values.size() - 1))
                            stream << " ";
                    }
                    stream << "\"/>\n";
                }
 
                if (save_gcode)
                    stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << GCODE_FILE_ATTR << "\" " << VALUE_ATTR << "=\"" << std::boolalpha << xml_escape(plate_data->gcode_file) << "\"/>\n";
                if (!plate_data->gcode_file.empty()) {
                    gcode_paths.push_back(plate_data->gcode_file);
                }
                if (plate_data->plate_thumbnail.is_valid()) {
                    std::string thumbnail_file_in_3mf = (boost::format(THUMBNAIL_FILE_FORMAT) % (plate_data->plate_index + 1)).str();
                    stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << THUMBNAIL_FILE_ATTR << "\" " << VALUE_ATTR << "=\"" << std::boolalpha << thumbnail_file_in_3mf << "\"/>\n";
                }
                else if (!plate_data->thumbnail_file.empty() && (boost::filesystem::exists(plate_data->thumbnail_file))){
                    std::string thumbnail_file_in_3mf = (boost::format(THUMBNAIL_FILE_FORMAT) % (plate_data->plate_index + 1)).str();
                    stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << THUMBNAIL_FILE_ATTR << "\" " << VALUE_ATTR << "=\"" << std::boolalpha << thumbnail_file_in_3mf << "\"/>\n";
                }
 
                if (!plate_data->no_light_thumbnail_file.empty()){
                    std::string no_light_thumbnail_file_in_3mf = (boost::format(NO_LIGHT_THUMBNAIL_FILE_FORMAT) % (plate_data->plate_index + 1)).str();
                    stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << NO_LIGHT_THUMBNAIL_FILE_ATTR << "\" " << VALUE_ATTR << "=\"" << std::boolalpha << no_light_thumbnail_file_in_3mf << "\"/>\n";
                }
 
                if (!plate_data->top_file.empty()) {
                    std::string top_file_in_3mf = (boost::format(TOP_FILE_FORMAT) % (plate_data->plate_index + 1)).str();
                    stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << TOP_FILE_ATTR << "\" " << VALUE_ATTR << "=\"" << std::boolalpha << top_file_in_3mf << "\"/>\n";
                }
 
                if (!plate_data->pick_file.empty()) {
                    std::string pick_file_in_3mf = (boost::format(PICK_FILE_FORMAT) % (plate_data->plate_index + 1)).str();
                    stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << PICK_FILE_ATTR << "\" " << VALUE_ATTR << "=\"" << std::boolalpha << pick_file_in_3mf << "\"/>\n";
                }
 
                /*if (!plate_data->pattern_file.empty()) {
                    std::string pattern_file_in_3mf = (boost::format(PATTERN_FILE_FORMAT) % (plate_data->plate_index + 1)).str();
                    stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << PATTERN_FILE_ATTR << "\" " << VALUE_ATTR << "=\"" << std::boolalpha << pattern_file_in_3mf << "\"/>\n";
                }*/
                if (!plate_data->pattern_bbox_file.empty()) {
                    std::string pattern_bbox_file_in_3mf = (boost::format(PATTERN_CONFIG_FILE_FORMAT) % (plate_data->plate_index + 1)).str();
                    stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << PATTERN_BBOX_FILE_ATTR << "\" " << VALUE_ATTR << "=\"" << std::boolalpha << pattern_bbox_file_in_3mf << "\"/>\n";
                }
 
                if (!m_skip_model && instance_size > 0)
                {
                    for (unsigned int j = 0; j < instance_size; ++j)
                    {
                        stream << "    <" << INSTANCE_TAG << ">\n";
                        int obj_id = plate_data->objects_and_instances[j].first;
                        int inst_id = plate_data->objects_and_instances[j].second;
                        int identify_id = 0;
                        ModelObject* obj = NULL;
                        ModelInstance* inst = NULL;
                        if (obj_id >= model.objects.size()) {
                            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ":" << __LINE__ << boost::format("invalid object id %1%\n")%obj_id;
                        }
                        else
                            obj =  model.objects[obj_id];
 
                        if (obj && (inst_id >= obj->instances.size())) {
                            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ":" << __LINE__ << boost::format("invalid instance id %1%\n")%inst_id;
                        }
                        else if (obj){
                            inst =  obj->instances[inst_id];
                            if (use_loaded_id && (inst->loaded_id > 0))
                                identify_id = inst->loaded_id;
                            else
                                identify_id = inst->id().id;
                        }
                        obj_id = objects_data.find(obj)->second.object_id;
 
                        stream << "      <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << OBJECT_ID_ATTR << "\" " << VALUE_ATTR << "=\"" << obj_id << "\"/>\n";
                        stream << "      <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << INSTANCEID_ATTR << "\" " << VALUE_ATTR << "=\"" << inst_id << "\"/>\n";
                        stream << "      <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << IDENTIFYID_ATTR << "\" " << VALUE_ATTR << "=\"" << identify_id << "\"/>\n";
                        stream << "    </" << INSTANCE_TAG << ">\n";
                    }
                }
                stream << "  </" << PLATE_TAG << ">\n";
            }
        }
 
        // write model rels
        if (save_gcode)
            _add_relationships_file_to_archive(archive, BBS_MODEL_CONFIG_RELS_FILE, gcode_paths, {"http://schemas.bambulab.com/package/2021/gcode"}, Slic3r::PackingTemporaryData(), export_plate_idx);
 
        if (!m_skip_model) {
        //BBS: store assemble related info
        stream << "  <" << ASSEMBLE_TAG << ">\n";
        for (const ObjectToObjectDataMap::value_type& obj_metadata : objects_data) {
            auto object_data = obj_metadata.second;
            const ModelObject* obj = object_data.object;
            if (obj != nullptr) {
                for (int instance_idx = 0; instance_idx < obj->instances.size(); ++instance_idx) {
                    if (obj->instances[instance_idx]->is_assemble_initialized()) {
                        stream << "   <" << ASSEMBLE_ITEM_TAG << " " << OBJECT_ID_ATTR << "=\"" << object_data.object_id << "\" ";
                        stream << INSTANCEID_ATTR << "=\"" << instance_idx << "\" " << TRANSFORM_ATTR << "=\"";
                            for (unsigned c = 0; c < 4; ++c) {
                                for (unsigned r = 0; r < 3; ++r) {
                                    const Transform3d assemble_trans = obj->instances[instance_idx]->get_assemble_transformation().get_matrix();
                                    stream << assemble_trans(r, c);
                                    if (r != 2 || c != 3)
                                        stream << " ";
                                }
                            }
 
                        stream << "\" ";
 
                        stream << OFFSET_ATTR << "=\"";
                        const Vec3d ofs2ass = obj->instances[instance_idx]->get_offset_to_assembly();
                        stream << ofs2ass(0) << " " << ofs2ass(1) << " " << ofs2ass(2);
                    stream << "\" />\n";
                    }
                }
            }
        }
        stream << "  </" << ASSEMBLE_TAG << ">\n";
        }
 
        stream << "</" << CONFIG_TAG << ">\n";
 
        std::string out = stream.str();
        if (!mz_zip_writer_add_mem(&archive, BBS_MODEL_CONFIG_FILE.c_str(), (const void*)out.data(), out.length(), MZ_DEFAULT_COMPRESSION)) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format("Unable to add model config file to archive\n");
            add_error("Unable to add model config file to archive");
            return false;
        }
 
        return true;
    }

References _add_model_config_file_to_archive(), _add_relationships_file_to_archive(), Slic3r::_BBS_3MF_Base::add_error(), Slic3r::add_texture_displacement(), ASSEMBLE_ITEM_TAG, ASSEMBLE_TAG, Slic3r::ModelObject::auto_drop, AUTO_DROP_ATTR, Slic3r::RepairedMeshErrors::backwards_edges, BBS_MODEL_CONFIG_FILE, BBS_MODEL_CONFIG_RELS_FILE, BED_TYPE_ATTR, Slic3r::ModelObject::config, Slic3r::ModelVolume::config, Slic3r::PlateData::config, CONFIG_TAG, Slic3r::RepairedMeshErrors::degenerate_facets, Slic3r::RepairedMeshErrors::edges_fixed, Slic3r::ModelVolume::emboss_shape, Slic3r::RepairedMeshErrors::facets_removed, Slic3r::RepairedMeshErrors::facets_reversed, FILAMENT_MAP_ATTR, FILAMENT_MAP_MODE_ATTR, FILAMENT_VOL_MAP_ATTR, FIRST_LAYER_PRINT_SEQUENCE_ATTR, Slic3r::PlateData::gcode_file, GCODE_FILE_ATTR, Slic3r::get_dealed_platform_path(), Slic3r::ConfigOptionEnum< T >::get_enum_names(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::ModelVolume::get_matrix(), Slic3r::ConfigOption::getBool(), Slic3r::ConfigOption::getInt(), Slic3r::ConfigOptionInt::getInt(), Slic3r::ObjectBase::id(), Slic3r::ObjectID::id, ID_ATTR, IDENTIFYID_ATTR, IMEX_HEAD_FILAMENT_MAP_ATTR, IMEX_PARALLEL_MODE_ATTR, Slic3r::ModelVolume::Source::input_file, INSTANCE_TAG, INSTANCEID_ATTR, Slic3r::ModelObject::instances, Slic3r::ModelVolume::Source::is_converted_from_inches, Slic3r::ModelVolume::Source::is_converted_from_meters, Slic3r::ModelVolume::is_precise_seam(), Slic3r::ThumbnailData::is_valid(), KEY_ATTR, Slic3r::ModelConfig::keys(), Slic3r::kImexPrimaryMode, Slic3r::ModelInstance::loaded_id, LOCK_ATTR, Slic3r::PlateData::locked, m_fullpath_sources, m_share_mesh, m_skip_model, m_volume_paths, 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_STAT_TAG, METADATA_TAG, Slic3r::ModelObject::module_name, Slic3r::ModelObject::name, Slic3r::ModelVolume::name, NAME_KEY, Slic3r::PlateData::no_light_thumbnail_file, NO_LIGHT_THUMBNAIL_FILE_ATTR, NO_LIGHT_THUMBNAIL_FILE_FORMAT, Slic3r::ModelVolume::object, OBJECT_ID_ATTR, Slic3r::ModelVolume::Source::object_idx, OBJECT_TAG, Slic3r::Model::objects, Slic3r::PlateData::objects_and_instances, OFFSET_ATTR, Slic3r::ModelConfig::opt_serialize(), Slic3r::ConfigBase::option(), OTHER_LAYERS_PRINT_SEQUENCE_ATTR, OTHER_LAYERS_PRINT_SEQUENCE_NUMS_ATTR, Slic3r::PARAMETER_MODIFIER, PART_TAG, Slic3r::PlateData::pattern_bbox_file, PATTERN_BBOX_FILE_ATTR, PATTERN_CONFIG_FILE_FORMAT, Slic3r::PlateData::pick_file, PICK_FILE_ATTR, PICK_FILE_FORMAT, Slic3r::PlateData::plate_index, Slic3r::PlateData::plate_name, PLATE_TAG, Slic3r::PlateData::plate_thumbnail, PLATER_NAME_ATTR, PLATERID_ATTR, PRECISE_SEAM_CONFIG_PREFIX, PRECISE_SEAM_TYPE_KEY, PRINT_SEQUENCE_ATTR, 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, SPIRAL_VASE_MODE, Slic3r::TriangleMesh::stats(), SUBTYPE_ATTR, Slic3r::ModelVolume::text_configuration, Slic3r::PlateData::thumbnail_file, THUMBNAIL_FILE_ATTR, THUMBNAIL_FILE_FORMAT, Slic3r::TextConfigurationSerialization::to_xml(), Slic3r::to_xml(), Slic3r::PlateData::top_file, TOP_FILE_ATTR, TOP_FILE_FORMAT, Slic3r::ModelVolume::Source::transform, TRANSFORM_ATTR, Slic3r::ModelVolume::type(), Slic3r::ModelVolume::type_to_string(), VALUE_ATTR, Slic3r::ConfigOptionVector< int >::values, Slic3r::ModelVolume::Source::volume_idx, Slic3r::ModelObject::volumes, Slic3r::xml_escape(), and Slic3r::xml_escape_double_quotes_attribute_value().

Referenced by _add_model_config_file_to_archive(), _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_model_file_to_archive()

bool Slic3r::_BBS_3MF_Exporter::_add_model_file_to_archive ( const std::string & filename, mz_zip_archive & archive, const Model & model, ObjectToObjectDataMap & objects_data, Export3mfProgressFn proFn = nullptr, BBLProject * project = nullptr ) const

private

    {
        bool sub_model = !objects_data.empty();
        bool write_object = sub_model || !m_split_model;
 
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" << __LINE__ << boost::format(", filename %1%, m_split_model %2%,  sub_model %3%")%filename % m_split_model % sub_model;
 
#if WRITE_ZIP_LANGUAGE_ENCODING
        auto & zip_filename = filename;
#else
        std::string zip_filename = encode_path(filename.c_str());
        std::string extra = sub_model ? ZipUnicodePathExtraField::encode(filename, zip_filename) : "";
#endif
        mz_zip_writer_staged_context context;
        if (!mz_zip_writer_add_staged_open(&archive, &context, sub_model ? zip_filename.c_str() : 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,
#if WRITE_ZIP_LANGUAGE_ENCODING
            nullptr, nullptr, 0, MZ_DEFAULT_LEVEL, nullptr, 0, nullptr, 0)) {
#else
            nullptr, nullptr, 0, MZ_DEFAULT_COMPRESSION, extra.c_str(), extra.length(), extra.c_str(), extra.length())) {
#endif
            add_error("Unable to add model file to archive");
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", Unable to add model file to archive\n");
            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:BambuStudio=\"http://schemas.bambulab.com/package/2021\"";
            if (m_production_ext)
                stream << " xmlns:p=\"http://schemas.microsoft.com/3dmanufacturing/production/2015/06\" requiredextensions=\"p\"";
            stream << ">\n";
 
            std::string origin;
            std::string name;
            std::string user_name;
            std::string user_id;
            std::string design_cover;
            std::string license;
            std::string description;
            std::string copyright;
            std::string rating;
            std::string model_id;
            std::string region_code;
            if (model.design_info) {
                 user_name = model.design_info->Designer;
                 user_id = model.design_info->DesignerUserId;
                 BOOST_LOG_TRIVIAL(trace) << "design_info, save_3mf found designer = " << user_name;
                 BOOST_LOG_TRIVIAL(trace) << "design_info, save_3mf found designer_user_id = " << user_id;
            }
 
            if (project) {
                model_id    = project->project_model_id;
                region_code = project->project_country_code;
            }
 
            if (model.model_info) {
                design_cover = model.model_info->cover_file;
                license      = model.model_info->license;
                description  = model.model_info->description;
                copyright    = model.model_info->copyright;
                name         = model.model_info->model_name;
                origin       = model.model_info->origin;
                BOOST_LOG_TRIVIAL(trace) << "design_info, save_3mf found designer_cover = " << design_cover;
            }
            // remember to use metadata_item_map to store metadata info
            std::map<std::string, std::string> metadata_item_map;
            if (!sub_model) {
                // update metadat_items
                if (model.model_info && model.model_info.get()) {
                    metadata_item_map = model.model_info.get()->metadata_items;
                }
 
                metadata_item_map[BBL_MODEL_NAME_TAG]           = xml_escape(name);
                metadata_item_map[BBL_ORIGIN_TAG]               = xml_escape(origin);
                metadata_item_map[BBL_DESIGNER_TAG]             = xml_escape(user_name);
                metadata_item_map[BBL_DESIGNER_USER_ID_TAG]     = ""; // Orca: PRIVACY: do not store BBL user id in 3mf
                metadata_item_map[BBL_DESIGNER_COVER_FILE_TAG]  = xml_escape(design_cover);
                metadata_item_map[BBL_DESCRIPTION_TAG]          = xml_escape(description);
                metadata_item_map[BBL_COPYRIGHT_NORMATIVE_TAG]  = xml_escape(copyright);
                metadata_item_map[BBL_LICENSE_TAG]              = xml_escape(license);
 
                /* save model info */
                if (!model_id.empty()) {
                    metadata_item_map[BBL_MODEL_ID_TAG] = model_id;
                    metadata_item_map[BBL_REGION_TAG]   = region_code;
                }
 
                // Orca: PRIVACY: do not store creation & modification date in 3mf
                metadata_item_map[BBL_CREATION_DATE_TAG] = "";
                metadata_item_map[BBL_MODIFICATION_TAG]  = "";
                // Orca: Write the BambuStudio compatibility version string using SLIC3R_VERSION.
                // A minimal published 3MF writes no slicer tags at all: any tag would route old
                // receivers onto a geometry-only fallback whose baked-in popup misreports the
                // file ("old OrcaSlicer version" / "BambuStudio"), while tag-less files classify
                // as From_Other and import the geometry silently.
                if (m_minimal_published) {
                    // metadata_item_map is seeded from the input file's metadata_items above, so a
                    // project opened from a regular Orca/BBS 3MF still carries the slicer-identifying
                    // tags it came with. Erase every one of them - not just the two most common -
                    // so a published 3MF is fully tag-less: old receivers classify it as From_Other
                    // and import the geometry silently instead of showing a baked-in "old version"
                    // popup, and no version marker survives to seed a later re-save.
                    metadata_item_map.erase(BBL_APPLICATION_TAG);
                    metadata_item_map.erase(ORCASLICER_TAG);
                    metadata_item_map.erase(BBS_3MF_VERSION);
                    metadata_item_map.erase(BBS_3MF_VERSION1);
                } else {
                    metadata_item_map[BBL_APPLICATION_TAG] = (boost::format("%1%-%2%") % "BambuStudio" % SLIC3R_VERSION).str();
                }
            }
            // The Bambu 3MF version marker is part of the slicer identity: omit it for a minimal
            // published file along with the tags erased above (skipping the overwrite alone would
            // leave the value the source file seeded into metadata_item_map).
            if (!m_minimal_published)
                metadata_item_map[BBS_3MF_VERSION] = std::to_string(VERSION_BBS_3MF);
 
            if (!model.mk_name.empty()) {
                metadata_item_map[BBL_MAKERLAB_TAG] = xml_escape(model.mk_name);
                BOOST_LOG_TRIVIAL(info) << "saved mk_name " << model.mk_name;
            }
            if (!model.mk_version.empty()) {
                metadata_item_map[BBL_MAKERLAB_VERSION_TAG] = xml_escape(model.mk_version);
                BOOST_LOG_TRIVIAL(info) << "saved mk_version " << model.mk_version;
            }
            if (!model.md_name.empty()) {
                for (unsigned int i = 0; i < model.md_name.size(); i++)
                {
                    BOOST_LOG_TRIVIAL(info) << boost::format("saved metadata_name %1%, metadata_value %2%") %model.md_name[i] %model.md_value[i];
                    metadata_item_map[model.md_name[i]] = xml_escape(model.md_value[i]);
                }
            }
 
            // store metadata info
            for (auto item : metadata_item_map) {
                BOOST_LOG_TRIVIAL(info) << "bbs_3mf: save key= " << item.first << ", value = " << item.second;
                stream << " <" << METADATA_TAG << " name=\"" << item.first << "\">"
                       << xml_escape(item.second) << "</" << METADATA_TAG << ">\n";
                if (item.first == BBL_APPLICATION_TAG && !m_minimal_published) {
                    // The OrcaSlicer tag is only written for files that carry the Application
                    // tag, which a minimal published 3MF erases (see the map assignment above):
                    // the explicit !m_minimal_published guard keeps the tag-less guarantee from
                    // depending on that erase happening to run first.
                    stream << " <" << METADATA_TAG << " name=\"" << ORCASLICER_TAG << "\">"
                           << xml_escape(SoftFever_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");
                BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", Unable to add model file to archive\n");
                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;
        unsigned int object_index = 0;
 
        bool cb_cancel = false;
        std::vector<std::string> object_paths;
        // if (!m_skip_model) {
            for (ModelObject* obj : model.objects) {
                if (sub_model && obj != objects_data.begin()->second.object) continue;
 
                if (proFn) {
                    proFn(EXPORT_STAGE_ADD_MODELS, object_index++, model.objects.size(), cb_cancel);
                    if (cb_cancel)
                        return false;
                }
 
                if (obj == nullptr)
                    continue;
 
                // Index of an object in the 3MF file corresponding to the 1st instance of a ModelObject.
                ObjectToObjectDataMap::iterator object_it = objects_data.begin();
 
                if (!sub_model) {
                    // For backup, use backup id as object id
                    int backup_id = const_cast<Model&>(model).get_object_backup_id(*obj);
                    if (m_from_backup_save) object_id = backup_id;
                    object_it = objects_data.insert({obj, {obj, backup_id} }).first;
                    auto & object_data = object_it->second;
 
                    if (m_split_model) {
                        auto filename = boost::format("3D/Objects/%s_%d.model") % obj->name % backup_id;
                        object_data.sub_path = "/" + filename.str();
                        object_paths.push_back(filename.str());
                    }
 
                    auto &volumes_objectID = object_data.volumes_objectID;
                    unsigned int volume_id = object_id, volume_count = 0;
                    for (ModelVolume *volume : obj->volumes) {
                        if (volume == nullptr)
                            continue;
                        volume_count++;
                        if (m_share_mesh) {
                            auto iter = m_shared_meshes.find(volume->mesh_ptr().get());
                            if (iter != m_shared_meshes.end())
                            {
                                const ModelVolume* shared_volume = iter->second.second;
                                bool same_texture_paint = true;
                                for (int slot = 0; slot < int(TEXTURE_DISPLACEMENT_MAX_LAYERS) && same_texture_paint; ++slot)
                                    same_texture_paint = shared_volume->texture_displacement_facet(slot).equals(volume->texture_displacement_facet(slot));
                                if ((shared_volume->supported_facets.equals(volume->supported_facets))
                                    && (shared_volume->seam_facets.equals(volume->seam_facets))
                                    && (shared_volume->mmu_segmentation_facets.equals(volume->mmu_segmentation_facets))
                                    && (shared_volume->fuzzy_skin_facets.equals(volume->fuzzy_skin_facets))
                                    && same_texture_paint)
                                {
                                    auto data = iter->second.first;
                                    const_cast<_BBS_3MF_Exporter *>(this)->m_volume_paths.insert({volume, {data->sub_path, data->volumes_objectID.find(iter->second.second)->second}});
                                    volumes_objectID.insert({volume, 0});
                                    object_data.share_mesh = true;
                                    continue;
                                }
                            }
                            const_cast<_BBS_3MF_Exporter *>(this)->m_shared_meshes.insert({volume->mesh_ptr().get(), {&object_data, volume}});
                        }
                        if (m_from_backup_save)
                            volume_id = (volume_count << 16 | backup_id);
                        volumes_objectID.insert({volume, volume_id});
                        volume_id++;
                    }
 
                    if (!m_from_backup_save) object_id = volume_id;
                    object_data.object_id = object_id;
                }
 
                if (m_skip_model) continue;
 
                if (write_object) {
                    // Store geometry of all ModelVolumes contained in a single ModelObject into a single 3MF indexed triangle set object.
                    // object_it->second.volumes_objectID 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_it->second)) {
                        add_error("Unable to add object to archive");
                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", Unable to add object to archive\n");
                        return false;
                    }
                }
 
                if (sub_model) break;
 
                unsigned int count = 0;
                for (const ModelInstance* instance : obj->instances) {
                    Transform3d t = instance->get_matrix();
                    // instance_id is just a 1 indexed index in build_items.
                    //assert(m_skip_static || curr_id == build_items.size() + 1);
 
                    build_items.emplace_back("", object_it->second.object_id, t, instance->printable);
                    count++;
                }
 
                if (!m_from_backup_save) object_id++;
            }
        // }
 
        {
            std::stringstream stream;
            reset_stream(stream);
 
            if (!m_skip_model && !sub_model) {
                for (auto object : model.objects) {
                    auto &data = objects_data[object];
                    _add_object_components_to_stream(stream, data);
                }
            }
 
            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");
                BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", Unable to add build to archive\n");
                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");
                BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", Unable to add model file to archive\n");
                return false;
            }
        }
 
        if (m_skip_model || write_object) return true;
 
        // write model rels
        _add_relationships_file_to_archive(archive, MODEL_RELS_FILE, object_paths, {"http://schemas.microsoft.com/3dmanufacturing/2013/01/3dmodel"});
 
        if (!m_from_backup_save) {
            boost::mutex mutex;
            tbb::parallel_for(tbb::blocked_range<size_t>(0, objects_data.size(), 1), [this, &mutex, &model, objects = model.objects, &objects_data, &object_paths, main = &archive, project](const tbb::blocked_range<size_t>& range) {
                for (size_t i = range.begin(); i < range.end(); ++i) {
                    auto iter = objects_data.find(objects[i]);
                    ObjectToObjectDataMap objects_data2;
                    objects_data2.insert(*iter);
                    auto & object = *iter->second.object;
                    mz_zip_archive archive;
                    mz_zip_zero_struct(&archive);
                    mz_zip_writer_init_heap(&archive, 0, 1024 * 1024);
                    CNumericLocalesSetter locales_setter;
                    _add_model_file_to_archive(object_paths[i], archive, model, objects_data2, nullptr, project);
                    iter->second = objects_data2.begin()->second;
                    void *ppBuf; size_t pSize;
                    mz_zip_writer_finalize_heap_archive(&archive, &ppBuf, &pSize);
                    mz_zip_writer_end(&archive);
                    mz_zip_zero_struct(&archive);
                    mz_zip_reader_init_mem(&archive, ppBuf, pSize, 0);
                    {
                        boost::unique_lock l(mutex);
                        mz_zip_writer_add_from_zip_reader(main, &archive, 0);
                    }
                    mz_zip_reader_end(&archive);
                }
            });
        }
 
        return true;
    }

References _add_model_file_to_archive(), _add_object_to_model_stream(), Slic3r::_BBS_3MF_Base::add_error(), BBL_APPLICATION_TAG, BBL_COPYRIGHT_NORMATIVE_TAG, BBL_CREATION_DATE_TAG, BBL_DESCRIPTION_TAG, BBL_DESIGNER_COVER_FILE_TAG, BBL_DESIGNER_TAG, BBL_DESIGNER_USER_ID_TAG, BBL_LICENSE_TAG, BBL_MAKERLAB_TAG, BBL_MAKERLAB_VERSION_TAG, BBL_MODEL_ID_TAG, BBL_MODEL_NAME_TAG, BBL_MODIFICATION_TAG, BBL_ORIGIN_TAG, BBL_REGION_TAG, BBS_3MF_VERSION, BBS_3MF_VERSION1, count, Slic3r::Model::design_info, ZipUnicodePathExtraField::encode(), Slic3r::encode_path(), Slic3r::FacetsAnnotation::equals(), Slic3r::EXPORT_STAGE_ADD_MODELS, Slic3r::ModelVolume::fuzzy_skin_facets, m_from_backup_save, m_minimal_published, m_production_ext, m_share_mesh, m_shared_meshes, m_skip_model, m_split_model, m_volume_paths, m_zip64, Slic3r::Model::md_name, Slic3r::Model::md_value, Slic3r::ModelVolume::mesh_ptr(), METADATA_TAG, Slic3r::Model::mk_name, Slic3r::Model::mk_version, Slic3r::ModelVolume::mmu_segmentation_facets, MODEL_FILE, Slic3r::Model::model_info, MODEL_TAG, Slic3r::Model::objects, ORCASLICER_TAG, Slic3r::BBLProject::project_country_code, Slic3r::BBLProject::project_model_id, Slic3r::reset_stream(), RESOURCES_TAG, Slic3r::ModelVolume::seam_facets, Slic3r::ModelVolume::supported_facets, Slic3r::ModelVolume::texture_displacement_facet(), Slic3r::TEXTURE_DISPLACEMENT_MAX_LAYERS, Slic3r::trace(), VERSION_BBS_3MF, WRITE_ZIP_LANGUAGE_ENCODING, and Slic3r::xml_escape().

Referenced by _add_model_file_to_archive(), _save_model_to_file(), and save_object_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

_add_object_components_to_stream()

void Slic3r::_BBS_3MF_Exporter::_add_object_components_to_stream ( std::stringstream & stream, ObjectData const & object_data ) const

private

    {
        auto &       object = *object_data.object;
 
        stream << "  <" << OBJECT_TAG << " id=\"" << object_data.object_id;
        if (m_production_ext)
            stream << "\" " << PUUID_ATTR << "=\"" << hex_wrap<boost::uint32_t>{(boost::uint32_t)object_data.backup_id}
                    << (object_data.share_mesh ? OBJECT_UUID_SUFFIX2 : OBJECT_UUID_SUFFIX);
        stream << "\" type=\"model\">\n";
 
        stream << "   <" << COMPONENTS_TAG << ">\n";
 
        for (unsigned int index = 0; index < object.volumes.size(); index ++) {
            ModelVolume *volume    = object.volumes[index];
            unsigned int volume_id = object_data.volumes_objectID.find(volume)->second;
            auto * ppath = &object_data.sub_path;
            auto iter = m_volume_paths.find(volume);
            if (iter != m_volume_paths.end()) {
                ppath = &iter->second.first;
                volume_id = iter->second.second;
            }
            //add the transform of the volume
            if (ppath->empty())
                stream << "    <" << COMPONENT_TAG << " objectid=\"" << volume_id;
            else
                stream << "    <" << COMPONENT_TAG << " p:path=\"" << xml_escape(*ppath) << "\" objectid=\"" << volume_id; // << "\"/>\n";
            if (m_production_ext)
                stream << "\" " << PUUID_ATTR << "=\"" << hex_wrap<boost::uint32_t>{(boost::uint32_t) (index + (object_data.backup_id << 16))} << COMPONENT_UUID_SUFFIX;
            const Transform3d &transf = volume->get_matrix();
            stream << "\" " << TRANSFORM_ATTR << "=\"";
            for (unsigned c = 0; c < 4; ++c) {
                for (unsigned r = 0; r < 3; ++r) {
                    stream << transf(r, c);
                    if (r != 2 || c != 3)
                        stream << " ";
                }
            }
            stream << "\"/>\n";
        }
 
        stream << "   </" << COMPONENTS_TAG << ">\n";
 
        stream << "  </" << OBJECT_TAG << ">\n";
    }

References _add_object_components_to_stream(), Slic3r::_BBS_3MF_Exporter::ObjectData::backup_id, COMPONENT_TAG, COMPONENT_UUID_SUFFIX, COMPONENTS_TAG, Slic3r::ModelVolume::get_matrix(), m_production_ext, m_volume_paths, Slic3r::_BBS_3MF_Exporter::ObjectData::object, Slic3r::_BBS_3MF_Exporter::ObjectData::object_id, OBJECT_TAG, OBJECT_UUID_SUFFIX, OBJECT_UUID_SUFFIX2, PUUID_ATTR, Slic3r::_BBS_3MF_Exporter::ObjectData::share_mesh, Slic3r::_BBS_3MF_Exporter::ObjectData::sub_path, TRANSFORM_ATTR, Slic3r::_BBS_3MF_Exporter::ObjectData::volumes_objectID, and Slic3r::xml_escape().

Referenced by _add_object_components_to_stream().

Here is the call graph for this function:

Here is the caller graph for this function:

_add_object_to_model_stream()

bool Slic3r::_BBS_3MF_Exporter::_add_object_to_model_stream ( mz_zip_writer_staged_context & context, ObjectData const & object_data ) const

private

    {
        // backup: make _add_mesh_to_object_stream() reusable
        auto flush = [this, &context](std::string & buf, bool force = false) {
            if ((force && !buf.empty()) || buf.size() >= 65536 * 16) {
                if (!mz_zip_writer_add_staged_data(&context, buf.data(), buf.size())) {
                    add_error("Error during writing or compression");
                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", Error during writing or compression\n");
                    return false;
                }
                buf.clear();
            }
            return true;
        };
        if (!_add_mesh_to_object_stream(flush, object_data)) {
            add_error("Unable to add mesh to archive");
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", Unable to add mesh to archive\n");
            return false;
        }
 
        // Move all components to main model
        //_add_object_components_to_stream(stream, object_data);
 
        return true;
    }

References _add_mesh_to_object_stream(), _add_object_to_model_stream(), and Slic3r::_BBS_3MF_Base::add_error().

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::_BBS_3MF_Exporter::_add_print_config_file_to_archive ( mz_zip_archive & archive, const DynamicPrintConfig & config )

private

    {
        assert(is_decimal_separator_point());
        char buffer[1024];
        snprintf(buffer, 1024, "; %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, BBS_PRINT_CONFIG_FILE.c_str(), (const void*)out.data(), out.length(), MZ_DEFAULT_COMPRESSION)) {
                add_error("Unable to add print config file to archive");
                BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format("Unable to add print config file to archive\n");
                return false;
            }
        }
 
        return true;
    }

References _add_print_config_file_to_archive(), Slic3r::_BBS_3MF_Base::add_error(), BBS_PRINT_CONFIG_FILE, Slic3r::header_slic3r_generated(), Slic3r::is_decimal_separator_point(), Slic3r::DynamicConfig::keys(), and Slic3r::ConfigBase::opt_serialize().

Referenced by _add_print_config_file_to_archive(), and _add_sla_drain_holes_file_to_archive().

Here is the call graph for this function:

Here is the caller graph for this function:

_add_project_config_file_to_archive()

bool Slic3r::_BBS_3MF_Exporter::_add_project_config_file_to_archive ( mz_zip_archive & archive, const DynamicPrintConfig & config, Model & model )

private

    {
        const std::string& temp_path = model.get_backup_path();
        std::string temp_file = temp_path + std::string("/") + "_temp_1.config";
        config.save_to_json(temp_file, std::string("project_settings"), std::string("project"), std::string(SLIC3R_VERSION));
        return _add_file_to_archive(archive, BBS_PROJECT_CONFIG_FILE, temp_file);
    }

References _add_file_to_archive(), _add_project_config_file_to_archive(), BBS_PROJECT_CONFIG_FILE, Slic3r::Model::get_backup_path(), and Slic3r::ConfigBase::save_to_json().

Referenced by _add_project_config_file_to_archive(), _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_project_embedded_presets_to_archive()

bool Slic3r::_BBS_3MF_Exporter::_add_project_embedded_presets_to_archive ( mz_zip_archive & archive, Model & model, std::vector< Preset * > project_presets )

private

    {
        char buffer[1024];
        snprintf(buffer, 1024, "; %s\n\n", header_slic3r_generated().c_str());
        std::string out = buffer;
        int print_count = 0, filament_count = 0, printer_count = 0;
        const std::string& temp_path = model.get_backup_path();
 
        for (int i = 0; i < project_presets.size(); i++)
        {
            Preset* preset = project_presets[i];
 
            if (preset) {
                preset->file = temp_path + std::string("/") + "_temp_1.config";
                DynamicPrintConfig& config = preset->config;
                //config.save(preset->file);
                config.save_to_json(preset->file, preset->name, std::string("project"), preset->version.to_string());
 
                std::string dest_file;
                if (preset->type == Preset::TYPE_PRINT) {
                    dest_file = (boost::format(EMBEDDED_PRINT_FILE_FORMAT) % (print_count + 1)).str();
                    print_count++;
                }
                else if (preset->type == Preset::TYPE_FILAMENT) {
                    dest_file = (boost::format(EMBEDDED_FILAMENT_FILE_FORMAT) % (filament_count + 1)).str();
                    filament_count++;
                }
                else if (preset->type == Preset::TYPE_PRINTER) {
                    dest_file = (boost::format(EMBEDDED_PRINTER_FILE_FORMAT) % (printer_count + 1)).str();
                    printer_count++;
                }
                else
                    continue;
 
                _add_file_to_archive(archive, dest_file, preset->file);
            }
        }
 
        return true;
    }

References _add_file_to_archive(), _add_project_embedded_presets_to_archive(), Slic3r::Preset::config, EMBEDDED_FILAMENT_FILE_FORMAT, EMBEDDED_PRINT_FILE_FORMAT, EMBEDDED_PRINTER_FILE_FORMAT, Slic3r::Preset::file, Slic3r::Model::get_backup_path(), Slic3r::header_slic3r_generated(), Slic3r::Preset::name, Slic3r::ConfigBase::save_to_json(), Slic3r::Semver::to_string(), Slic3r::Preset::type, Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, Slic3r::Preset::TYPE_PRINTER, and Slic3r::Preset::version.

Referenced by _add_project_embedded_presets_to_archive(), _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_relationships_file_to_archive()

bool Slic3r::_BBS_3MF_Exporter::_add_relationships_file_to_archive ( mz_zip_archive & archive, std::string const & from = {}, std::vector< std::string > const & targets = {}, std::vector< std::string > const & types = {}, PackingTemporaryData data = PackingTemporaryData(), int export_plate_idx = -1, bool plate_thumbnail_written = false, bool plate_small_thumbnail_written = false ) const

private

    {
        std::stringstream stream;
        stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
        stream << "<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">\n";
        if (from.empty()) {
            stream << " <Relationship Target=\"/" << MODEL_FILE << "\" Id=\"rel-1\" Type=\"http://schemas.microsoft.com/3dmanufacturing/2013/01/3dmodel\"/>\n";
 
            if (export_plate_idx < 0) {
                //use cover image if have
                if (data._3mf_thumbnail.empty()) {
                    // ORCA: only reference the plate thumbnail if it was written
                    if (plate_thumbnail_written)
                        stream << " <Relationship Target=\"/Metadata/plate_1.png"
                               << "\" Id=\"rel-2\" Type=\"http://schemas.openxmlformats.org/package/2006/relationships/metadata/thumbnail\"/>\n";
                } else {
                    stream << " <Relationship Target=\"/" << xml_escape(data._3mf_thumbnail)
                           << "\" Id=\"rel-2\" Type=\"http://schemas.openxmlformats.org/package/2006/relationships/metadata/thumbnail\"/>\n";
                }
 
                if (data._3mf_printer_thumbnail_middle.empty()) {
                    if (plate_thumbnail_written)
                        stream << " <Relationship Target=\"/Metadata/plate_1.png"
                               << "\" Id=\"rel-4\" Type=\"http://schemas.bambulab.com/package/2021/cover-thumbnail-middle\"/>\n";
                } else {
                    stream << " <Relationship Target=\"/" << xml_escape(data._3mf_printer_thumbnail_middle)
                           << "\" Id=\"rel-4\" Type=\"http://schemas.bambulab.com/package/2021/cover-thumbnail-middle\"/>\n";
                }
 
                if (data._3mf_printer_thumbnail_small.empty()) {
                    if (plate_small_thumbnail_written)
                        stream << "<Relationship Target=\"/Metadata/plate_1_small.png"
                               << "\" Id=\"rel-5\" Type=\"http://schemas.bambulab.com/package/2021/cover-thumbnail-small\"/>\n";
                } else {
                    stream << " <Relationship Target=\"/" << xml_escape(data._3mf_printer_thumbnail_small)
                           << "\" Id=\"rel-5\" Type=\"http://schemas.bambulab.com/package/2021/cover-thumbnail-small\"/>\n";
                }
            }
            else if (plate_thumbnail_written) {
                //always use plate thumbnails
                std::string thumbnail_file_str = (boost::format("Metadata/plate_%1%.png") % (export_plate_idx + 1)).str();
                stream << " <Relationship Target=\"/" << xml_escape(thumbnail_file_str)
                    << "\" Id=\"rel-2\" Type=\"http://schemas.openxmlformats.org/package/2006/relationships/metadata/thumbnail\"/>\n";
 
                thumbnail_file_str = (boost::format("Metadata/plate_%1%.png") % (export_plate_idx + 1)).str();
                stream << " <Relationship Target=\"/" << xml_escape(thumbnail_file_str)
                   << "\" Id=\"rel-4\" Type=\"http://schemas.bambulab.com/package/2021/cover-thumbnail-middle\"/>\n";
 
                if (plate_small_thumbnail_written) {
                    thumbnail_file_str = (boost::format("Metadata/plate_%1%_small.png") % (export_plate_idx + 1)).str();
                    stream << " <Relationship Target=\"/" << xml_escape(thumbnail_file_str)
                       << "\" Id=\"rel-5\" Type=\"http://schemas.bambulab.com/package/2021/cover-thumbnail-small\"/>\n";
                }
            }
        }
        else if (targets.empty()) {
            return false;
        }
        else {
            int i = 0;
            for (auto & path : targets) {
                for (auto & type : types)
                    stream << " <Relationship Target=\"/" << xml_escape(path) << "\" Id=\"rel-" << std::to_string(++i) << "\" Type=\"" << type << "\"/>\n";
            }
        }
        stream << "</Relationships>";
 
        std::string out = stream.str();
 
        if (!mz_zip_writer_add_mem(&archive, from.empty() ? RELATIONSHIPS_FILE.c_str() : from.c_str(), (const void*)out.data(), out.length(), MZ_DEFAULT_COMPRESSION)) {
            add_error("Unable to add relationships file to archive");
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", Unable to add relationships file to archive\n");
            return false;
        }
 
        return true;
    }

References Slic3r::PackingTemporaryData::_3mf_printer_thumbnail_middle, Slic3r::PackingTemporaryData::_3mf_printer_thumbnail_small, Slic3r::PackingTemporaryData::_3mf_thumbnail, _add_relationships_file_to_archive(), Slic3r::_BBS_3MF_Base::add_error(), MODEL_FILE, RELATIONSHIPS_FILE, and Slic3r::xml_escape().

Referenced by _add_model_config_file_to_archive(), _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::_BBS_3MF_Exporter::_add_sla_drain_holes_file_to_archive ( mz_zip_archive & archive, Model & model )

private

References _add_auxiliary_dir_to_archive(), _add_custom_gcode_per_print_z_file_to_archive(), _add_cut_information_file_to_archive(), _add_filament_sequence_file_to_archive(), _add_gcode_file_to_archive(), _add_model_config_file_to_archive(), _add_print_config_file_to_archive(), _add_project_config_file_to_archive(), _add_project_embedded_presets_to_archive(), and _add_slice_info_config_file_to_archive().

Here is the call graph for this function:

_add_sla_support_points_file_to_archive()

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

private

_add_slice_info_config_file_to_archive()

bool Slic3r::_BBS_3MF_Exporter::_add_slice_info_config_file_to_archive ( mz_zip_archive & archive, const Model & model, PlateDataPtrs & plate_data_list, const ObjectToObjectDataMap & objects_data, const DynamicPrintConfig & config )

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 << std::setiosflags(std::ios::fixed) << std::setprecision(2);
        stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
        stream << "<" << CONFIG_TAG << ">\n";
 
        // save slice header for debug
        stream << "  <" << SLICE_HEADER_TAG << ">\n";
        stream << "    <" << SLICE_HEADER_ITEM_TAG << " " << KEY_ATTR << "=\"" << "X-BBL-Client-Type"    << "\" " << VALUE_ATTR << "=\"" << "slicer" << "\"/>\n";
        stream << "    <" << SLICE_HEADER_ITEM_TAG << " " << KEY_ATTR << "=\"" << "X-BBL-Client-Version" << "\" " << VALUE_ATTR << "=\"" << convert_to_full_version(SLIC3R_VERSION) << "\"/>\n";
        stream << "    <" << SLICE_HEADER_ITEM_TAG << " " << KEY_ATTR << "=\"" << "OrcaSlicer-Version" << "\" " << VALUE_ATTR << "=\"" << SoftFever_VERSION << "\"/>\n";
        stream << "  </" << SLICE_HEADER_TAG << ">\n";
 
        for (unsigned int i = 0; i < (unsigned int)plate_data_list.size(); ++i)
        {
            PlateData* plate_data = plate_data_list[i];
            //int instance_size = plate_data->objects_and_instances.size();
 
            if (plate_data != nullptr && plate_data->is_sliced_valid) {
                stream << "  <" << PLATE_TAG << ">\n";
                //plate index
                stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << PLATE_IDX_ATTR        << "\" " << VALUE_ATTR << "=\"" << plate_data->plate_index + 1 << "\"/>\n";
 
                int timelapse_type = int(config.opt_enum<TimelapseType>("timelapse_type"));
                for (auto it = plate_data->warnings.begin(); it != plate_data->warnings.end(); it++) {
                    if (it->msg == NOT_GENERATE_TIMELAPSE) {
                        timelapse_type = -1;
                        break;
                    }
                }
 
                std::vector<int> extruder_types      = config.option<ConfigOptionEnumsGeneric>("extruder_type")->values;
                std::vector<int> nozzle_volume_types = config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type")->values;
                auto* nozzle_volume_type_option = dynamic_cast<const ConfigOptionEnumsGeneric*>(config.option("nozzle_volume_type"));
 
                stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << EXTRUDER_TYPE_ATTR << "\" " << VALUE_ATTR << "=\"";
                add_vector(stream, extruder_types);
                stream << "\"/>\n";
 
                stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << NOZZLE_VOLUME_TYPE_ATTR << "\" " << VALUE_ATTR << "=\"";
                add_vector(stream, nozzle_volume_types);
                stream << "\"/>\n";
 
                auto* nozzle_diameter_option = dynamic_cast<const ConfigOptionFloats*>(config.option("nozzle_diameter"));
                std::string nozzle_diameters_str;
                if (nozzle_diameter_option)
                    nozzle_diameters_str = nozzle_diameter_option->serialize();
 
                // True when any extruder carries a cluster of interchangeable nozzles (max nozzle count
                // > 1). Such an extruder's per-nozzle diameters are not expressible in the per-extruder
                // nozzle_diameter config, so the saved <filament>/<nozzle> diameters must come from the
                // grouping result. For a single-nozzle-per-extruder printer the true diameter is the raw
                // config value; the grouping result rounds it to the nearest of {0.2,0.4,0.6,0.8} for its
                // internal matching key, so reading that back would rewrite a non-standard nozzle
                // (e.g. 0.5 -> 0.4). Use this flag to keep the exact config value in that case.
                auto* extruder_max_nozzle_count_option = dynamic_cast<const ConfigOptionInts*>(config.option("extruder_max_nozzle_count"));
                const bool has_multi_nozzle_extruder = extruder_max_nozzle_count_option &&
                    std::any_of(extruder_max_nozzle_count_option->values.begin(), extruder_max_nozzle_count_option->values.end(),
                                [](int v) { return v > 1; });
 
                stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << PRINTER_MODEL_ID_ATTR       << "\" " << VALUE_ATTR << "=\"" << plate_data->printer_model_id << "\"/>\n";
                stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << NOZZLE_DIAMETERS_ATTR       << "\" " << VALUE_ATTR << "=\"" << nozzle_diameters_str << "\"/>\n";
                stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << TIMELAPSE_TYPE_ATTR << "\" " << VALUE_ATTR << "=\"" << timelapse_type << "\"/>\n";
                stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << SLICE_PREDICTION_ATTR << "\" " << VALUE_ATTR << "=\"" << plate_data->get_gcode_prediction_str() << "\"/>\n";
                stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << SLICE_WEIGHT_ATTR      << "\" " << VALUE_ATTR << "=\"" <<  plate_data->get_gcode_weight_str() << "\"/>\n";
                stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << FIRST_LAYER_TIME_ATTR      << "\" " << VALUE_ATTR << "=\"" <<  plate_data->first_layer_time << "\"/>\n";
                stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << OUTSIDE_ATTR      << "\" " << VALUE_ATTR << "=\"" << std::boolalpha<< plate_data->toolpath_outside << "\"/>\n";
                stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << SUPPORT_USED_ATTR << "\" " << VALUE_ATTR << "=\"" << std::boolalpha<< plate_data->is_support_used << "\"/>\n";
                stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << LABEL_OBJECT_ENABLED_ATTR << "\" " << VALUE_ATTR << "=\"" << std::boolalpha<< plate_data->is_label_object_enabled << "\"/>\n";
                // Report the plate's dynamic-map state from the grouping result. The result is present
                // for the whole fleet (a static single-nozzle result too), so this if-branch is normally
                // taken; is_support_dynamic_nozzle_map() is false for any non-dynamic (static /
                // single-extruder) result ⇒ byte-identical to the previously hard-coded value. The else
                // is a defensive fallback for a missing result.
                if (plate_data && plate_data->nozzle_group_result)
                    stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << ENABLE_FILAMENT_DYNAMIC_MAP_ATTR << "\" " << VALUE_ATTR << "=\"" << std::boolalpha << plate_data->nozzle_group_result->is_support_dynamic_nozzle_map() << "\"/>\n";
                else
                    stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << ENABLE_FILAMENT_DYNAMIC_MAP_ATTR << "\" " << VALUE_ATTR << "=\"" << std::boolalpha << false << "\"/>\n";
                {
                    bool has_filament_switcher = config.has("has_filament_switcher") ? config.opt_bool("has_filament_switcher") : false;
                    stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << HAS_FILAMENT_SWITCHER_ATTR << "\" " << VALUE_ATTR << "=\"" << std::boolalpha << has_filament_switcher << "\"/>\n";
                }
 
                std::vector<int> filament_maps = plate_data->filament_maps;
                if (filament_maps.empty())
                    filament_maps = config.option<ConfigOptionInts>("filament_map")->values;
                stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << FILAMENT_MAP_ATTR << "\" " << VALUE_ATTR << "=\"";
                add_vector<int>(stream, filament_maps);
                stream << "\"/>\n";
 
                if (plate_data->limit_filament_maps.size() > 0) {
                    stream << "    <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << LIMIT_FILAMENT_MAP_ATTR << "\" " << VALUE_ATTR << "=\"";
                    add_vector<int>(stream, plate_data->limit_filament_maps);
                    stream << "\"/>\n";
                }
 
                // Orca: for non-BambuLab printers that label objects in the g-code (Klipper/Marlin/RRF via
                // EXCLUDE_OBJECT / M486), write the per-instance g-code object name into slice_info.config
                // (e.g. "OrcaCube_v2.drc_id_0_copy_0") so the printer can correlate objects between the 3MF
                // and the g-code. The g-code names objects per plate as
                // "<name>_id_<object index>_copy_<instance index>" (see GCode::set_object_info), which we
                // reconstruct here from the (sorted) objects_and_instances list. identify_id is unchanged.
                // BambuLab printers keep the raw object name.
                const GCodeFlavor slice_gcode_flavor    = config.opt_enum<GCodeFlavor>("gcode_flavor");
                const bool        use_gcode_object_name  = !GCodeProcessor::s_IsBBLPrinter &&
                    (slice_gcode_flavor == gcfKlipper || slice_gcode_flavor == gcfMarlinLegacy ||
                     slice_gcode_flavor == gcfMarlinFirmware || slice_gcode_flavor == gcfRepRapFirmware);
                int gcode_object_index = -1;
                int gcode_copy_index   = 0;
                int last_object_id     = -1;
 
                for (auto it = plate_data->objects_and_instances.begin(); it != plate_data->objects_and_instances.end(); it++)
                {
                        int obj_id = it->first;
                        int inst_id = it->second;
                        int identify_id = 0;
                        ModelObject* obj = NULL;
                        ModelInstance* inst = NULL;
                        if (obj_id >= model.objects.size()) {
                            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ":" << __LINE__ << boost::format("invalid object id %1%\n")%obj_id;
                            continue;
                        }
                        obj =  model.objects[obj_id];
 
                        if (obj && (inst_id >= obj->instances.size())) {
                            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ":" << __LINE__ << boost::format("invalid instance id %1%\n")%inst_id;
                            continue;
                        }
                        inst =  obj->instances[inst_id];
                        if (m_use_loaded_id && (inst->loaded_id > 0))
                            identify_id = inst->loaded_id;
                        else
                            identify_id = inst->id().id;
                        bool skipped = std::find(plate_data->skipped_objects.begin(), plate_data->skipped_objects.end(), identify_id) !=
                                       plate_data->skipped_objects.end();
 
                        // Advance the per-plate g-code object/copy index. objects_and_instances is sorted,
                        // so all instances of the same object are contiguous.
                        if (obj_id != last_object_id) {
                            ++gcode_object_index;
                            gcode_copy_index = 0;
                            last_object_id   = obj_id;
                        } else {
                            ++gcode_copy_index;
                        }
 
                        std::string object_name = obj->name;
                        if (use_gcode_object_name)
                            // Matches GCode::get_instance_name(): sanitize(sanitize(name) + "_id_<obj>_copy_<inst>").
                            object_name = sanitize_object_label(sanitize_object_label(obj->name) + "_id_" +
                                          std::to_string(gcode_object_index) + "_copy_" + std::to_string(gcode_copy_index));
 
                        stream << "    <" << OBJECT_TAG << " " << IDENTIFYID_ATTR << "=\"" << std::to_string(identify_id) << "\" " << NAME_ATTR << "=\"" << xml_escape(object_name)
                               << "\" " << SKIPPED_ATTR << "=\"" << (skipped ? "true" : "false")
                               << "\" />\n";
                }
 
                auto get_nozzle_group_id = [&filament_maps](int filament_id) {
                    if (filament_id >= 0 && filament_id < static_cast<int>(filament_maps.size()) && filament_maps[filament_id] > 0)
                        return filament_maps[filament_id] - 1;
                    return 0;
                };
                auto get_nozzle_diameter = [nozzle_diameter_option](int nozzle_group_id) {
                    if (!nozzle_diameter_option || nozzle_diameter_option->values.empty())
                        return 0.0;
                    if (nozzle_group_id >= 0 && nozzle_group_id < static_cast<int>(nozzle_diameter_option->values.size()))
                        return nozzle_diameter_option->values[nozzle_group_id];
                    return nozzle_diameter_option->values.front();
                };
                auto get_nozzle_diameter_str = [&get_nozzle_diameter](int nozzle_group_id) {
                    std::ostringstream diameter_stream;
                    diameter_stream << std::defaultfloat << get_nozzle_diameter(nozzle_group_id);
                    return diameter_stream.str();
                };
                auto get_nozzle_volume_type = [nozzle_volume_type_option](int nozzle_group_id) {
                    if (!nozzle_volume_type_option || nozzle_volume_type_option->values.empty())
                        return std::string();
                    int nozzle_volume_type = nozzle_volume_type_option->values.front();
                    if (nozzle_group_id >= 0 && nozzle_group_id < static_cast<int>(nozzle_volume_type_option->values.size()))
                        nozzle_volume_type = nozzle_volume_type_option->values[nozzle_group_id];
                    if (nozzle_volume_type < 0 || nozzle_volume_type > nvtMaxNozzleVolumeType)
                        nozzle_volume_type = nvtStandard;
                    return get_nozzle_volume_type_string(static_cast<NozzleVolumeType>(nozzle_volume_type));
                };
                std::vector<int> used_nozzle_groups;
 
                for (auto it = plate_data->slice_filaments_info.begin(); it != plate_data->slice_filaments_info.end(); it++)
                {
                    int nozzle_group_id = get_nozzle_group_id(it->id);
                    if (std::find(used_nozzle_groups.begin(), used_nozzle_groups.end(), nozzle_group_id) == used_nozzle_groups.end())
                        used_nozzle_groups.push_back(nozzle_group_id);
                    const std::string filament_nozzle_group_id = it->group_id.empty() ? std::to_string(nozzle_group_id) : join_int_list_comma(it->group_id);
                    // Single-nozzle extruders: exact config diameter; clusters keep the result's rounded
                    // value (see has_multi_nozzle_extruder).
                    const double filament_nozzle_diameter = (has_multi_nozzle_extruder && it->nozzle_diameter > 0.0)
                                                                ? it->nozzle_diameter : get_nozzle_diameter(nozzle_group_id);
                    const std::string filament_nozzle_volume_type = it->nozzle_volume_type.empty() ? get_nozzle_volume_type(nozzle_group_id) : it->nozzle_volume_type;
 
                    stream << "    <" << FILAMENT_TAG << " " << FILAMENT_ID_TAG << "=\"" << std::to_string(it->id + 1) << "\" "
                           << FILAMENT_TRAY_INFO_ID_TAG <<"=\""<< it->filament_id <<"\" "
                           << FILAMENT_TYPE_TAG << "=\"" << it->type << "\" "
                           << FILAMENT_COLOR_TAG << "=\"" << it->color << "\" "
                           << FILAMENT_USED_M_TAG << "=\"" << it->used_m << "\" "
                           << FILAMENT_USED_G_TAG << "=\"" << it->used_g << "\" "
                           << FILAMENT_NOZZLE_GROUP_ID_TAG << "=\"" << filament_nozzle_group_id << "\" "
                           << FILAMENT_NOZZLE_DIAMETER_TAG << "=\"" << filament_nozzle_diameter << "\" "
                           << FILAMENT_NOZZLE_VOLUME_TYPE_TAG << "=\"" << filament_nozzle_volume_type << "\" "
                           << FILAMENT_USED_FOR_OBJECT << "=\"" << std::boolalpha << it->used_for_object << "\" "
                           << FILAMENT_USED_FOR_SUPPORT << "=\"" << std::boolalpha << it->used_for_support << "\"/>\n";
                }
 
                // Mixed (virtual) filaments used by this plate. These are resolved to physical
                // components before g-code statistics, so they are not present in the <filament>
                // list above and are recorded separately here.
                for (auto it = plate_data->mixed_filaments_info.begin(); it != plate_data->mixed_filaments_info.end(); it++)
                {
                    stream << "    <" << MIXED_FILAMENT_TAG << " " << FILAMENT_ID_TAG << "=\"" << std::to_string(it->id) << "\" "
                           << FILAMENT_TYPE_TAG << "=\"" << it->type << "\" "
                           << FILAMENT_COLOR_TAG << "=\"" << it->color << "\" "
                           << MIXED_FILAMENT_COMPONENTS_TAG << "=\"" << it->components << "\"/>\n";
                }
 
                for (auto it = plate_data->warnings.begin(); it != plate_data->warnings.end(); it++) {
                    stream << "    <" << SLICE_WARNING_TAG << " msg=\"" << it->msg << "\" level=\"" << std::to_string(it->level) << "\" error_code =\"" << it->error_code << "\"  />\n";
                }
 
                // Emit the <nozzle> tags from the grouping result. Single-nozzle-per-extruder printers
                // override the diameter with the exact config value (see has_multi_nozzle_extruder); the
                // else is a defensive fallback for a missing result.
                if (plate_data->nozzle_group_result) {
                    auto used_nozzle_list = plate_data->nozzle_group_result->get_used_nozzles_in_extruder();
                    for (auto& used_nozzle : used_nozzle_list) {
                        if (!has_multi_nozzle_extruder && nozzle_diameter_option &&
                            used_nozzle.extruder_id >= 0 && used_nozzle.extruder_id < (int) nozzle_diameter_option->values.size()) {
                            used_nozzle.diameter = get_nozzle_diameter_str(used_nozzle.extruder_id);
                        }
                        stream << "    <" << NOZZLE_TAG << " " << used_nozzle.serialize() << "/>\n";
                    }
                } else {
                    for (int nozzle_group_id : used_nozzle_groups) {
                        stream << "    <" << NOZZLE_TAG << " "
                               << "id=\"" << nozzle_group_id << "\" "
                               << "extruder_id=\"" << nozzle_group_id + 1 << "\" "
                               << "nozzle_diameter=\"" << get_nozzle_diameter_str(nozzle_group_id) << "\" "
                               << "volume_type=\"" << get_nozzle_volume_type(nozzle_group_id) << "\"/>\n";
                    }
                }
 
                if (!plate_data->layer_filaments.empty()) {
                    stream << "    <" << LAYER_FILAMENT_LISTS_TAG << ">\n";
                    for (auto iter = plate_data->layer_filaments.begin(); iter != plate_data->layer_filaments.end(); ++iter) {
                        // key
                        std::vector<unsigned int> sequence = iter->first;
                        std::stringstream         key_stream;
                        add_vector(key_stream, sequence);
 
                        // value
                        std::vector<std::pair<int, int>> ranges = iter->second;
                        std::stringstream                value_stream;
                        for (size_t i = 0; i < ranges.size(); ++i) {
                            value_stream << ranges[i].first;
                            value_stream << " ";
                            value_stream << ranges[i].second;
                            if (i != (ranges.size() - 1)) value_stream << ",";
                        }
 
                        stream << "      <" << LAYER_FILAMENT_LIST_TAG << " filament_list=\"" << key_stream.str() << "\" layer_ranges=\"" << value_stream.str() << "\" />\n";
                    }
                    stream << "    </" << LAYER_FILAMENT_LISTS_TAG << ">\n";
                }
 
                stream << "  </" << PLATE_TAG << ">\n";
            }
        }
        stream << "</" << CONFIG_TAG << ">\n";
 
        std::string out = stream.str();
 
        if (!mz_zip_writer_add_mem(&archive, SLICE_INFO_CONFIG_FILE.c_str(), (const void*)out.data(), out.length(), MZ_DEFAULT_COMPRESSION)) {
            add_error("Unable to add model config file to archive");
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", store  slice-info to 3mf,  length %1%, failed\n") % out.length();
            return false;
        }
 
        return true;
    }

References _add_slice_info_config_file_to_archive(), Slic3r::_BBS_3MF_Base::add_error(), add_vector(), CONFIG_TAG, Slic3r::convert_to_full_version(), ENABLE_FILAMENT_DYNAMIC_MAP_ATTR, EXTRUDER_TYPE_ATTR, FILAMENT_COLOR_TAG, FILAMENT_ID_TAG, FILAMENT_MAP_ATTR, Slic3r::PlateData::filament_maps, FILAMENT_NOZZLE_DIAMETER_TAG, FILAMENT_NOZZLE_GROUP_ID_TAG, FILAMENT_NOZZLE_VOLUME_TYPE_TAG, FILAMENT_TAG, FILAMENT_TRAY_INFO_ID_TAG, FILAMENT_TYPE_TAG, FILAMENT_USED_FOR_OBJECT, FILAMENT_USED_FOR_SUPPORT, FILAMENT_USED_G_TAG, FILAMENT_USED_M_TAG, Slic3r::PlateData::first_layer_time, FIRST_LAYER_TIME_ATTR, Slic3r::gcfKlipper, Slic3r::gcfMarlinFirmware, Slic3r::gcfMarlinLegacy, Slic3r::gcfRepRapFirmware, Slic3r::PlateData::get_gcode_prediction_str(), Slic3r::PlateData::get_gcode_weight_str(), Slic3r::get_nozzle_volume_type_string(), Slic3r::ConfigOptionResolver::has(), HAS_FILAMENT_SWITCHER_ATTR, Slic3r::ObjectBase::id(), Slic3r::ObjectID::id, IDENTIFYID_ATTR, Slic3r::ModelObject::instances, Slic3r::PlateData::is_label_object_enabled, Slic3r::PlateData::is_sliced_valid, Slic3r::PlateData::is_support_used, join_int_list_comma(), KEY_ATTR, LABEL_OBJECT_ENABLED_ATTR, LAYER_FILAMENT_LIST_TAG, LAYER_FILAMENT_LISTS_TAG, Slic3r::PlateData::layer_filaments, LIMIT_FILAMENT_MAP_ATTR, Slic3r::PlateData::limit_filament_maps, Slic3r::ModelInstance::loaded_id, m_use_loaded_id, METADATA_TAG, MIXED_FILAMENT_COMPONENTS_TAG, MIXED_FILAMENT_TAG, Slic3r::PlateData::mixed_filaments_info, Slic3r::ModelObject::name, NAME_ATTR, NOT_GENERATE_TIMELAPSE, NOZZLE_DIAMETERS_ATTR, Slic3r::PlateData::nozzle_group_result, NOZZLE_TAG, Slic3r::nozzle_volume_type(), NOZZLE_VOLUME_TYPE_ATTR, Slic3r::nvtMaxNozzleVolumeType, Slic3r::nvtStandard, OBJECT_TAG, Slic3r::Model::objects, Slic3r::PlateData::objects_and_instances, Slic3r::DynamicConfig::opt_bool(), Slic3r::DynamicConfig::opt_enum(), Slic3r::ConfigBase::option(), OUTSIDE_ATTR, PLATE_IDX_ATTR, Slic3r::PlateData::plate_index, PLATE_TAG, Slic3r::PlateData::printer_model_id, PRINTER_MODEL_ID_ATTR, Slic3r::GCodeProcessor::s_IsBBLPrinter, Slic3r::sanitize_object_label(), SKIPPED_ATTR, Slic3r::PlateData::skipped_objects, Slic3r::PlateData::slice_filaments_info, SLICE_HEADER_ITEM_TAG, SLICE_HEADER_TAG, SLICE_INFO_CONFIG_FILE, SLICE_PREDICTION_ATTR, SLICE_WARNING_TAG, SLICE_WEIGHT_ATTR, SUPPORT_USED_ATTR, TIMELAPSE_TYPE_ATTR, Slic3r::PlateData::toolpath_outside, VALUE_ATTR, Slic3r::ConfigOptionVector< int >::values, Slic3r::PlateData::warnings, and Slic3r::xml_escape().

Referenced by _add_sla_drain_holes_file_to_archive(), _add_slice_info_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_thumbnail_file_to_archive()

bool Slic3r::_BBS_3MF_Exporter::_add_thumbnail_file_to_archive ( mz_zip_archive & archive, const ThumbnailData & thumbnail_data, const char * local_path, int index, bool generate_small_thumbnail = false )

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_COMPRESSION, 1);
        if (png_data != nullptr) {
            std::string thumbnail_name = (boost::format("%1%_%2%.png")%local_path % (index + 1)).str();
            res = mz_zip_writer_add_mem(&archive, thumbnail_name.c_str(), (const void*)png_data, png_size, MZ_NO_COMPRESSION);
            mz_free(png_data);
        }
 
        if (!res) {
            add_error("Unable to add thumbnail file to archive");
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", Unable to add thumbnail file to archive\n");
        }
 
        if (generate_small_thumbnail && thumbnail_data.is_valid()) {
            //generate small size of thumbnail
            std::vector<unsigned char> small_pixels;
            small_pixels.resize(PLATE_THUMBNAIL_SMALL_WIDTH * PLATE_THUMBNAIL_SMALL_HEIGHT * 4);
            /* step width and step height */
            int sw = thumbnail_data.width / PLATE_THUMBNAIL_SMALL_WIDTH;
            int sh = thumbnail_data.height / PLATE_THUMBNAIL_SMALL_HEIGHT;
            int clampped_width = sw * PLATE_THUMBNAIL_SMALL_WIDTH;
            int clampped_height = sh * PLATE_THUMBNAIL_SMALL_HEIGHT;
 
            for (int i = 0; i < clampped_height; i += sh) {
                for (int j = 0; j < clampped_width; j += sw) {
                    int r = 0, g = 0, b = 0, a = 0;
                    for (int m = 0; m < sh; m++) {
                        for (int n = 0; n < sw; n++) {
                            r += (int)thumbnail_data.pixels[4 * ((i + m) * thumbnail_data.width + j + n) + 0];
                            g += (int)thumbnail_data.pixels[4 * ((i + m) * thumbnail_data.width + j + n) + 1];
                            b += (int)thumbnail_data.pixels[4 * ((i + m) * thumbnail_data.width + j + n) + 2];
                            a += (int)thumbnail_data.pixels[4 * ((i + m) * thumbnail_data.width + j + n) + 3];
                        }
                    }
                    r = std::clamp(0, r / sw / sh, 255);
                    g = std::clamp(0, g / sw / sh, 255);
                    b = std::clamp(0, b / sw / sh, 255);
                    a = std::clamp(0, a / sw / sh, 255);
                    small_pixels[4 * (i / sw * PLATE_THUMBNAIL_SMALL_WIDTH + j / sh) + 0] = (unsigned char)r;
                    small_pixels[4 * (i / sw * PLATE_THUMBNAIL_SMALL_WIDTH + j / sh) + 1] = (unsigned char)g;
                    small_pixels[4 * (i / sw * PLATE_THUMBNAIL_SMALL_WIDTH + j / sh) + 2] = (unsigned char)b;
                    small_pixels[4 * (i / sw * PLATE_THUMBNAIL_SMALL_WIDTH + j / sh) + 3] = (unsigned char)a;
                    //memcpy((void*)&small_pixels[4*(i / sw * PLATE_THUMBNAIL_SMALL_WIDTH + j / sh)], thumbnail_data.pixels.data() + 4*(i * thumbnail_data.width + j), 4);
                }
            }
            size_t small_png_size = 0;
            void* small_png_data = tdefl_write_image_to_png_file_in_memory_ex((const void*)small_pixels.data(), PLATE_THUMBNAIL_SMALL_WIDTH, PLATE_THUMBNAIL_SMALL_HEIGHT, 4, &small_png_size, MZ_DEFAULT_COMPRESSION, 1);
            if (png_data != nullptr) {
                std::string thumbnail_name = (boost::format("%1%_%2%_small.png") % local_path % (index + 1)).str();
                res = mz_zip_writer_add_mem(&archive, thumbnail_name.c_str(), (const void*)small_png_data, small_png_size, MZ_NO_COMPRESSION);
                mz_free(small_png_data);
            }
 
            if (!res) {
                add_error("Unable to add small thumbnail file to archive");
                BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", Unable to add small thumbnail file to archive\n");
            }
        }
 
        return res;
    }

References _add_thumbnail_file_to_archive(), Slic3r::_BBS_3MF_Base::add_error(), Slic3r::ThumbnailData::height, Slic3r::ThumbnailData::is_valid(), Slic3r::ThumbnailData::pixels, PLATE_THUMBNAIL_SMALL_HEIGHT, PLATE_THUMBNAIL_SMALL_WIDTH, 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::_BBS_3MF_Exporter::_save_model_to_file ( const std::string & filename, Model & model, PlateDataPtrs & plate_data_list, std::vector< Preset * > & project_presets, const DynamicPrintConfig * config, const std::vector< ThumbnailData * > & thumbnail_data, const std::vector< ThumbnailData * > & no_light_thumbnail_data, const std::vector< ThumbnailData * > & top_thumbnail_data, const std::vector< ThumbnailData * > & pick_thumbnail_data, Export3mfProgressFn proFn, const std::vector< ThumbnailData * > & calibration_data, const std::vector< PlateBBoxData * > & id_bboxes, BBLProject * project = nullptr, int export_plate_idx = -1 )

private

    {
        PackingTemporaryData temp_data;
 
        mz_zip_archive archive;
        mz_zip_zero_struct(&archive);
 
        bool cb_cancel = false;
 
        //BBS progress point
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ <<
                boost::format(",before open zip writer, m_skip_static %1%, m_save_gcode %2%, m_use_loaded_id %3%")%m_skip_static %m_save_gcode %m_use_loaded_id;
        if (proFn) {
            proFn(EXPORT_STAGE_OPEN_3MF, 0, 1, cb_cancel);
            if (cb_cancel)
                return false;
        }
 
        if (!open_zip_writer(&archive, filename)) {
            add_error("Unable to open the file"+filename);
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", Unable to open the file\n");
            return false;
        }
 
        struct close_lock
        {
            mz_zip_archive & archive;
            std::string const * filename;
            ~close_lock() {
                close_zip_writer(&archive);
                if (filename) {
                    boost::system::error_code ec;
                    boost::filesystem::remove(*filename, ec);
                }
            }
        } lock{ archive, &filename};
 
        //BBS progress point
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format(", before add _add_content_types_file_to_archive\n");
        if (proFn) {
            proFn(EXPORT_STAGE_CONTENT_TYPES, 0, 1, cb_cancel);
            if (cb_cancel)
                return false;
        }
 
        // Adds content types file ("[Content_Types].xml";).
        // The content of this file is the same for each OrcaSlicer 3mf.
        if (!_add_content_types_file_to_archive(archive)) {
            return false;
        }
 
        //BBS progress point
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" << __LINE__ << boost::format(",before add thumbnails, count %1%") % thumbnail_data.size();
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format(",top&&pick thumbnails, count %1%")%top_thumbnail_data.size();
 
        //BBS: add thumbnail for each plate
        //ORCA: the relationships file points at plate 1's thumbnail for a whole-project export,
        //      otherwise at the exported plate's. Track whether that thumbnail was written.
        const size_t rels_plate_idx = (export_plate_idx < 0) ? 0 : static_cast<size_t>(export_plate_idx);
        bool rels_thumbnail_written = false;
        bool rels_small_thumbnail_written = false;
        if (!m_skip_static) {
            std::vector<bool> thumbnail_status(plate_data_list.size(), false);
            std::vector<bool> no_light_thumbnail_status(plate_data_list.size(), false);
            std::vector<bool> top_thumbnail_status(plate_data_list.size(), false);
            std::vector<bool> pick_thumbnail_status(plate_data_list.size(), false);
 
            if ((thumbnail_data.size() > 0)&&(thumbnail_data.size() > plate_data_list.size())) {
                BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", thumbnail_data size %1% > plate count %2%")
                    % thumbnail_data.size() %plate_data_list.size();
                return false;
            }
            if ((no_light_thumbnail_data.size() > 0) && (no_light_thumbnail_data.size() > plate_data_list.size())) {
                BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", no_light_thumbnail_data size %1% > plate count %2%") %
                    no_light_thumbnail_data.size() % plate_data_list.size();
                return false;
            }
            if ((top_thumbnail_data.size() > 0)&&(top_thumbnail_data.size() > plate_data_list.size())) {
                BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", top_thumbnail_data size %1% > plate count %2%")
                    % top_thumbnail_data.size() %plate_data_list.size();
                return false;
            }
            if ((pick_thumbnail_data.size() > 0)&&(pick_thumbnail_data.size() > plate_data_list.size())) {
                BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", pick_thumbnail_data size %1% > plate count %2%")
                    % pick_thumbnail_data.size() %plate_data_list.size();
                return false;
            }
            if (top_thumbnail_data.size() != pick_thumbnail_data.size()) {
                BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", top_thumbnail_data size %1% != pick_thumbnail_data size %2%")
                    % top_thumbnail_data.size() %pick_thumbnail_data.size();
                return false;
            }
 
            if (proFn) {
                proFn(EXPORT_STAGE_ADD_THUMBNAILS, 0, plate_data_list.size(), cb_cancel);
                if (cb_cancel)
                    return false;
            }
 
            for (unsigned int index = 0; index < thumbnail_data.size(); index++)
            {
                if (thumbnail_data[index]->is_valid())
                {
                    if (!_add_thumbnail_file_to_archive(archive, *thumbnail_data[index], "Metadata/plate", index, true)) {
                        return false;
                    }
 
                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format(",add thumbnail %1%'s data into 3mf")%(index+1);
                    thumbnail_status[index] = true;
                    if (static_cast<size_t>(index) == rels_plate_idx) {
                        //ORCA: this call also writes the _small companion
                        rels_thumbnail_written       = true;
                        rels_small_thumbnail_written = true;
                    }
                }
            }
 
            for (unsigned int index = 0; index < no_light_thumbnail_data.size(); index++) {
                if (no_light_thumbnail_data[index]->is_valid()) {
                    if (!_add_thumbnail_file_to_archive(archive, *no_light_thumbnail_data[index], "Metadata/plate_no_light", index)) {
                        return false;
                    }
 
                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" << __LINE__ << boost::format(",add no light thumbnail %1%'s data into 3mf") % (index + 1);
                    no_light_thumbnail_status[index] = true;
                }
            }
            // Adds the file Metadata/top_i.png and Metadata/pick_i.png
            for (unsigned int index = 0; index < top_thumbnail_data.size(); index++)
            {
                if (top_thumbnail_data[index]->is_valid())
                {
                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format(",add top thumbnail %1%'s data into 3mf")%(index+1);
                    if (!_add_thumbnail_file_to_archive(archive, *top_thumbnail_data[index], "Metadata/top", index)) {
                        return false;
                    }
                    top_thumbnail_status[index] = true;
                }
 
                if (pick_thumbnail_data[index]->is_valid())
                {
                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format(",add pick thumbnail %1%'s data into 3mf")%(index+1);
                    if (!_add_thumbnail_file_to_archive(archive, *pick_thumbnail_data[index], "Metadata/pick", index)) {
                        return false;
                    }
                    pick_thumbnail_status[index] = true;
                }
            }
 
            for (int i = 0; i < plate_data_list.size(); i++) {
                PlateData *plate_data = plate_data_list[i];
 
                if (!thumbnail_status[i] && !plate_data->thumbnail_file.empty() && (boost::filesystem::exists(plate_data->thumbnail_file))){
                    std::string dst_in_3mf = (boost::format("Metadata/plate_%1%.png") % (i + 1)).str();
                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format(", add thumbnail %1% from file %2%") % (i+1) %plate_data->thumbnail_file;
 
                    if (!_add_file_to_archive(archive, dst_in_3mf, plate_data->thumbnail_file)) {
                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", add thumbnail %1% from file %2% failed\n") % (i+1) %plate_data->thumbnail_file;
                        return false;
                    }
                    //ORCA: copied from file, so there is no _small companion for this plate
                    if (static_cast<size_t>(i) == rels_plate_idx)
                        rels_thumbnail_written = true;
                }
 
                if (!no_light_thumbnail_status[i] && !plate_data->no_light_thumbnail_file.empty() && (boost::filesystem::exists(plate_data->no_light_thumbnail_file))){
                    std::string dst_in_3mf = (boost::format("Metadata/plate_no_light_%1%.png") % (i + 1)).str();
                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format(", add no light thumbnail %1% from file %2%") % (i+1) %plate_data->no_light_thumbnail_file;
 
                    if (!_add_file_to_archive(archive, dst_in_3mf, plate_data->no_light_thumbnail_file)) {
                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", add no light thumbnail %1% from file %2% failed\n") % (i+1) %plate_data->no_light_thumbnail_file;
                        return false;
                    }
                }
 
                if (!top_thumbnail_status[i] && !plate_data->top_file.empty() && (boost::filesystem::exists(plate_data->top_file))){
                    std::string dst_in_3mf = (boost::format("Metadata/top_%1%.png") % (i + 1)).str();
 
                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format(", add top thumbnail %1% from file %2%") % (i+1) %plate_data->top_file;
                    if (!_add_file_to_archive(archive, dst_in_3mf, plate_data->top_file)) {
                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", add top thumbnail %1% failed") % (i+1);
                        return false;
                    }
                    top_thumbnail_status[i] = true;
                }
 
                if (!pick_thumbnail_status[i] && !plate_data->pick_file.empty() && (boost::filesystem::exists(plate_data->pick_file))){
                    std::string dst_in_3mf = (boost::format("Metadata/pick_%1%.png") % (i + 1)).str();
 
                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format(", add pick thumbnail %1% from file %2%") % (i+1) %plate_data->pick_file;
                    if (!_add_file_to_archive(archive, dst_in_3mf, plate_data->pick_file)) {
                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", add pick thumbnail %1% failed") % (i+1);
                        return false;
                    }
                    pick_thumbnail_status[i] = true;
                }
            }
            if (proFn) {
                proFn(EXPORT_STAGE_ADD_THUMBNAILS, plate_data_list.size(), plate_data_list.size(), cb_cancel);
                if (cb_cancel)
                    return false;
            }
        }
 
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format(",before add calibration thumbnails, count %1%\n")%calibration_data.size();
        //BBS add calibration thumbnail for each plate
        if (!m_skip_static && calibration_data.size() > 0) {
            // Adds the file Metadata/calibration_p[X].png.
            for (unsigned int index = 0; index < calibration_data.size(); index++)
            {
                if (proFn) {
                    proFn(EXPORT_STAGE_ADD_THUMBNAILS, index, calibration_data.size(), cb_cancel);
                    if (cb_cancel)
                        return false;
                }
 
                if (calibration_data[index]->is_valid())
                {
                    if (!_add_calibration_file_to_archive(archive, *calibration_data[index], index)) {
                        close_zip_writer(&archive);
                        return false;
                    }
                }
            }
        }
 
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format(",before add calibration boundingbox, count %1%\n")%id_bboxes.size();
        if (!m_skip_static && id_bboxes.size() > 0) {
            // Adds the file Metadata/calibration_p[X].png.
            for (unsigned int index = 0; index < id_bboxes.size(); index++)
            {
                // BBS: save bounding box to json
                if (id_bboxes[index]->is_valid()) {
                    if (!_add_bbox_file_to_archive(archive, *id_bboxes[index], index)) {
                        close_zip_writer(&archive);
                        return false;
                    }
                }
            }
        }
 
        //BBS progress point
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format(", before add models\n");
        if (proFn) {
            proFn(EXPORT_STAGE_ADD_MODELS, 0, 1, cb_cancel);
            if (cb_cancel)
                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.
        ObjectToObjectDataMap objects_data;
        //if (!m_skip_model)
        {
            if (!_add_model_file_to_archive(filename, archive, model, objects_data, proFn, project)) { 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);
                return false;
            }
 
            if (!_add_cad_recipe_file_to_archive(archive, model)) {
                close_zip_writer(&archive);
                return false;
            }
 
            // BBS progress point
            /*BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format("export 3mf EXPORT_STAGE_ADD_LAYER_RANGE\n");
            if (proFn) {
                proFn(EXPORT_STAGE_ADD_LAYER_RANGE, 0, 1, cb_cancel);
                if (cb_cancel)
                    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);
                return false;
            }
 
            if (!_add_brim_ear_points_file_to_archive(archive, model)) {
                close_zip_writer(&archive);
                return false;
            }
 
            // BBS progress point
            /*BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format("export 3mf EXPORT_STAGE_ADD_SUPPORT\n");
            if (proFn) {
                proFn(EXPORT_STAGE_ADD_SUPPORT, 0, 1, cb_cancel);
                if (cb_cancel)
                    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)) {
                return false;
            }
 
            if (!_add_sla_drain_holes_file_to_archive(archive, model)) {
                return false;
            }*/
 
            // BBS progress point
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" << __LINE__ << boost::format(", before add custom gcodes\n");
            if (proFn) {
                proFn(EXPORT_STAGE_ADD_CUSTOM_GCODE, 0, 1, cb_cancel);
                if (cb_cancel) 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)) { return false; }
 
            // BBS progress point
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" << __LINE__ << boost::format(", before add project_settings\n");
            if (proFn) {
                proFn(EXPORT_STAGE_ADD_PRINT_CONFIG, 0, 1, cb_cancel);
                if (cb_cancel) return false;
            }
 
            // Adds slic3r print config file ("Metadata/Slic3r_PE.config").
            // This file contains the content of FullPrintConfig / SLAFullPrintConfig.
            // Omitted for minimal published 3MF: OrcaSlicer versions without the publish feature
            // then fall back to importing the geometry only, and new versions read the published
            // payload from the model metadata instead.
            if (config != nullptr && !m_minimal_published) {
                // BBS: change to json format
                // if (!_add_print_config_file_to_archive(archive, *config)) {
                if (!_add_project_config_file_to_archive(archive, *config, model)) { return false; }
            }
 
            // BBS progress point
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" << __LINE__ << boost::format(", before add project embedded settings\n");
            if (proFn) {
                proFn(EXPORT_STAGE_ADD_CONFIG_FILE, 0, 1, cb_cancel);
                if (cb_cancel) return false;
            }
 
            // BBS: add project config (omitted for minimal published 3MF)
            if (!m_minimal_published && project_presets.size() > 0) {
                // BBS: add project embedded preset files
                _add_project_embedded_presets_to_archive(archive, model, project_presets);
 
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" << __LINE__ << boost::format(", finished add project embedded settings, size %1%\n")%project_presets.size();
                if (proFn) {
                    proFn(EXPORT_STAGE_ADD_PROJECT_CONFIG, 0, 1, cb_cancel);
                    if (cb_cancel) return false;
                }
            }
        }
 
        // add plate_N.gcode.md5 to file
        if (!m_skip_static && m_save_gcode) {
            for (int i = 0; i < plate_data_list.size(); i++) {
                PlateData *plate_data = plate_data_list[i];
                if (!plate_data->gcode_file.empty() && plate_data->is_sliced_valid && boost::filesystem::exists(plate_data->gcode_file)) {
                    unsigned char digest[16];
                    MD5_CTX       ctx;
                    MD5_Init(&ctx);
                    auto                        src_gcode_file = plate_data->gcode_file;
                    boost::filesystem::ifstream ifs(src_gcode_file, std::ios::binary);
                    std::string                 buf(64 * 1024, 0);
                    const std::size_t &         size      = boost::filesystem::file_size(src_gcode_file);
                    std::size_t                 left_size = size;
                    while (ifs) {
                        ifs.read(buf.data(), buf.size());
                        int read_bytes = ifs.gcount();
                        MD5_Update(&ctx, (unsigned char *) buf.data(), read_bytes);
                    }
                    MD5_Final(digest, &ctx);
                    char md5_str[33];
                    for (int j = 0; j < 16; j++) { sprintf(&md5_str[j * 2], "%02X", (unsigned int) digest[j]); }
                    plate_data->gcode_file_md5 = std::string(md5_str);
                    std::string target_file    = (boost::format("Metadata/plate_%1%.gcode.md5") % (plate_data->plate_index + 1)).str();
                    if (!mz_zip_writer_add_mem(&archive, target_file.c_str(), (const void *) plate_data->gcode_file_md5.c_str(), plate_data->gcode_file_md5.length(),
                                               MZ_DEFAULT_COMPRESSION)) {
                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__
                                                 << boost::format(", store  gcode md5 to 3mf's %1%,  length %2%, failed\n") %target_file %plate_data->gcode_file_md5.length();
                        return false;
                    }
                }
            }
        }
 
        // Adds gcode files ("Metadata/plate_1.gcode, plate_2.gcode, ...)
        // Before _add_model_config_file_to_archive, because we modify plate_data
        //if (!m_skip_static && !_add_gcode_file_to_archive(archive, model, plate_data_list, proFn)) {
        if (!m_skip_static && m_save_gcode && !_add_gcode_file_to_archive(archive, model, plate_data_list, proFn)) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", _add_gcode_file_to_archive failed\n");
            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, plate_data_list, objects_data, *config, export_plate_idx, m_save_gcode, m_use_loaded_id)) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", _add_model_config_file_to_archive failed\n");
            return false;
        }
 
        if (!_add_cut_information_file_to_archive(archive, model)) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", _add_cut_information_file_to_archive failed\n");
            return false;
        }
 
        //BBS progress point
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format(", before add sliced info to 3mf\n");
        if (proFn) {
            proFn(EXPORT_STAGE_ADD_SLICE_INFO, 0, 1, cb_cancel);
            if (cb_cancel)
                return false;
        }
 
        // Adds sliced info of plate file ("Metadata/slice_info.config")
        // This file contains all sliced info of all plates
        if (!_add_slice_info_config_file_to_archive(archive, model, plate_data_list, objects_data, *config)) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", _add_slice_info_config_file_to_archive failed\n");
            return false;
        }
 
        if (!_add_filament_sequence_file_to_archive(archive, plate_data_list)) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", _add_filament_sequence_file_to_archive failed\n");
            return false;
        }
 
        //BBS progress point
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format(", before add auxiliary dir to 3mf\n");
        if (proFn) {
            proFn(EXPORT_STAGE_ADD_AUXILIARIES, 0, 1, cb_cancel);
            if (cb_cancel)
                return false;
        }
 
        if (!m_skip_static && !_add_auxiliary_dir_to_archive(archive, model.get_auxiliary_file_temp_path(), temp_data)) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" <<__LINE__ << boost::format(", _add_auxiliary_dir_to_archive failed\n");
            return false;
        }
 
        //BBS progress point
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format(", before add relation file to 3mf\n");
        if (proFn) {
            proFn(EXPORT_STAGE_ADD_RELATIONS, 0, 1, cb_cancel);
            if (cb_cancel)
                return false;
        }
 
        // Adds relationships file ("_rels/.rels").
        // The content of this file is the same for each OrcaSlicer 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, {}, {}, {}, temp_data, export_plate_idx, rels_thumbnail_written, rels_small_thumbnail_written)) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" <<__LINE__ << boost::format(", _add_relationships_file_to_archive failed\n");
            return false;
        }
 
        if (!mz_zip_writer_finalize_archive(&archive)) {
            add_error("Unable to finalize the archive");
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", Unable to finalize the archive\n");
            return false;
        }
 
        //BBS progress point
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format(", finished exporting 3mf\n");
        if (proFn) {
            proFn(EXPORT_STAGE_FINISH, 0, 1, cb_cancel);
            if (cb_cancel)
                return false;
        }
 
        lock.filename = nullptr;
 
        return true;
    }

References _add_auxiliary_dir_to_archive(), _add_bbox_file_to_archive(), _add_brim_ear_points_file_to_archive(), _add_cad_recipe_file_to_archive(), _add_calibration_file_to_archive(), _add_content_types_file_to_archive(), _add_custom_gcode_per_print_z_file_to_archive(), _add_cut_information_file_to_archive(), _add_filament_sequence_file_to_archive(), _add_file_to_archive(), _add_gcode_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_project_config_file_to_archive(), _add_project_embedded_presets_to_archive(), _add_relationships_file_to_archive(), _add_slice_info_config_file_to_archive(), _add_thumbnail_file_to_archive(), _save_model_to_file(), Slic3r::_BBS_3MF_Base::add_error(), Slic3r::close_zip_writer(), Slic3r::EXPORT_STAGE_ADD_AUXILIARIES, Slic3r::EXPORT_STAGE_ADD_CONFIG_FILE, Slic3r::EXPORT_STAGE_ADD_CUSTOM_GCODE, Slic3r::EXPORT_STAGE_ADD_MODELS, Slic3r::EXPORT_STAGE_ADD_PRINT_CONFIG, Slic3r::EXPORT_STAGE_ADD_PROJECT_CONFIG, Slic3r::EXPORT_STAGE_ADD_RELATIONS, Slic3r::EXPORT_STAGE_ADD_SLICE_INFO, Slic3r::EXPORT_STAGE_ADD_THUMBNAILS, Slic3r::EXPORT_STAGE_CONTENT_TYPES, Slic3r::EXPORT_STAGE_FINISH, Slic3r::EXPORT_STAGE_OPEN_3MF, Slic3r::PlateData::gcode_file, Slic3r::PlateData::gcode_file_md5, Slic3r::Model::get_auxiliary_file_temp_path(), Slic3r::PlateData::is_sliced_valid, m_minimal_published, m_save_gcode, m_skip_static, m_use_loaded_id, Slic3r::PlateData::no_light_thumbnail_file, Slic3r::open_zip_writer(), Slic3r::PlateData::pick_file, Slic3r::PlateData::plate_index, Slic3r::PlateData::thumbnail_file, and Slic3r::PlateData::top_file.

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::_BBS_3MF_Base::add_error ( const std::string & error ) const

inlineprotectedinherited

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

References m_errors, and mutex.

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

add_transformation()

void Slic3r::_BBS_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 << " ";
            }
        }
    }

References add_transformation().

Referenced by _add_build_to_model_stream(), add_transformation(), and Slic3r::to_xml().

Here is the call graph for this function:

Here is the caller graph for this function:

clear_errors()

void Slic3r::_BBS_3MF_Base::clear_errors ( )

inlineprotectedinherited

{ m_errors.clear(); }

References m_errors.

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

Here is the caller graph for this function:

convert_instance_id_to_resource_id()

int Slic3r::_BBS_3MF_Exporter::convert_instance_id_to_resource_id ( const Model & model, int obj_id, int instance_id )

inlinestaticprivate

        {
            int resource_id = 1;
 
            for (int i = 0; i < obj_id; ++i)
            {
                resource_id += model.objects[i]->volumes.size() + 1;
            }
 
            resource_id += model.objects[obj_id]->volumes.size();
 
            return resource_id;
        }

References Slic3r::Model::objects.

log_errors()

void Slic3r::_BBS_3MF_Base::log_errors ( )

inlineinherited

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

References m_errors.

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

Here is the caller graph for this function:

save_model_to_file()

bool Slic3r::_BBS_3MF_Exporter::save_model_to_file

(

StoreParams &

store_params

)

    {
        clear_errors();
        m_fullpath_sources = store_params.strategy & SaveStrategy::FullPathSources;
        m_zip64 = store_params.strategy & SaveStrategy::Zip64;
        m_production_ext = store_params.strategy & SaveStrategy::ProductionExt;
 
        m_skip_static = store_params.strategy & SaveStrategy::SkipStatic;
        m_split_model = store_params.strategy & SaveStrategy::SplitModel;
        m_save_gcode = store_params.strategy & SaveStrategy::WithGcode;
        m_skip_model  = store_params.strategy & SaveStrategy::SkipModel;
        m_skip_auxiliary = store_params.strategy & SaveStrategy::SkipAuxiliary;
        m_share_mesh       = store_params.strategy & SaveStrategy::ShareMesh;
        m_from_backup_save = store_params.strategy & SaveStrategy::Backup;
        m_minimal_published = store_params.strategy & SaveStrategy::MinimalPublished;
 
        m_use_loaded_id = store_params.strategy & SaveStrategy::UseLoadedId;
 
        if (auto info = store_params.model->model_info) {
            if (auto iter = info->metadata_items.find("Thumbnail_Small"); iter != info->metadata_items.end())
                m_thumbnail_small = iter->second;
            if (auto iter = info->metadata_items.find("Thumbnail_Middle"); iter != info->metadata_items.end())
                m_thumbnail_middle = iter->second;
        }
        boost::system::error_code ec;
        std::string filename = store_params.path;
        boost::filesystem::remove(filename + ".tmp", ec);
 
        bool result = _save_model_to_file(filename + ".tmp", *store_params.model, store_params.plate_data_list, store_params.project_presets, store_params.config,
                                          store_params.thumbnail_data, store_params.no_light_thumbnail_data, store_params.top_thumbnail_data, store_params.pick_thumbnail_data,
                                          store_params.proFn,
            store_params.calibration_thumbnail_data, store_params.id_bboxes, store_params.project, store_params.export_plate_idx);
        if (result) {
            boost::filesystem::rename(filename + ".tmp", filename, ec);
            if (ec) {
                add_error("Failed to rename file: " + ec.message());
                boost::filesystem::remove(filename + ".tmp", ec);
                return false;
            }
            if (!(store_params.strategy & SaveStrategy::Silence))
                save_string_file(store_params.model->get_backup_path() + "/origin.txt", filename);
        }
        return result;
    }

References _save_model_to_file(), Slic3r::_BBS_3MF_Base::add_error(), Slic3r::Backup, Slic3r::StoreParams::calibration_thumbnail_data, Slic3r::_BBS_3MF_Base::clear_errors(), Slic3r::StoreParams::config, Slic3r::StoreParams::export_plate_idx, Slic3r::FullPathSources, Slic3r::Model::get_backup_path(), Slic3r::StoreParams::id_bboxes, m_from_backup_save, m_fullpath_sources, m_minimal_published, m_production_ext, m_save_gcode, m_share_mesh, m_skip_auxiliary, m_skip_model, m_skip_static, m_split_model, m_thumbnail_middle, m_thumbnail_small, m_use_loaded_id, m_zip64, Slic3r::MinimalPublished, Slic3r::StoreParams::model, Slic3r::Model::model_info, Slic3r::StoreParams::no_light_thumbnail_data, Slic3r::StoreParams::path, Slic3r::StoreParams::pick_thumbnail_data, Slic3r::StoreParams::plate_data_list, Slic3r::ProductionExt, Slic3r::StoreParams::proFn, Slic3r::StoreParams::project, Slic3r::StoreParams::project_presets, save_model_to_file(), Slic3r::save_string_file(), Slic3r::ShareMesh, Slic3r::Silence, Slic3r::SkipAuxiliary, Slic3r::SkipModel, Slic3r::SkipStatic, Slic3r::SplitModel, Slic3r::StoreParams::strategy, Slic3r::StoreParams::thumbnail_data, Slic3r::StoreParams::top_thumbnail_data, Slic3r::UseLoadedId, Slic3r::WithGcode, and Slic3r::Zip64.

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

Here is the call graph for this function:

Here is the caller graph for this function:

save_object_mesh()

bool Slic3r::_BBS_3MF_Exporter::save_object_mesh	(	const std::string &	temp_path,
		ModelObject const &	object,
		int	obj_id )

    {
        m_production_ext = true;
        m_from_backup_save = true;
        Model const & model = *object.get_model();
 
        mz_zip_archive archive;
        mz_zip_zero_struct(&archive);
 
        auto filename = boost::format("3D/Objects/%s_%d.model") % object.name % obj_id;
        std::string filepath = temp_path + "/" + filename.str();
        std::string filepath_tmp = filepath + ".tmp";
        boost::system::error_code ec;
        boost::filesystem::remove(filepath_tmp, ec);
        if (!open_zip_writer(&archive, filepath_tmp)) {
            add_error("Unable to open the file"+filepath_tmp);
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":" << __LINE__ << boost::format(", Unable to open the file\n");
            return false;
        }
 
        struct close_lock
        {
            mz_zip_archive & archive;
            std::string const * filename;
            void close() {
                close_zip_writer(&archive);
                filename = nullptr;
            }
            ~close_lock() {
                if (filename) {
                    close_zip_writer(&archive);
                    boost::system::error_code ec;
                    boost::filesystem::remove(*filename, ec);
                }
            }
        } lock{archive, &filepath_tmp};
 
        ObjectToObjectDataMap objects_data;
        auto & volumes_objectID = objects_data.insert({&object, {&object, obj_id}}).first->second.volumes_objectID;
        unsigned int volume_count = 0;
        for (ModelVolume *volume : object.volumes) {
            if (volume == nullptr) continue;
            volumes_objectID.insert({volume, (++volume_count << 16 | obj_id)});
        }
 
        _add_model_file_to_archive(filename.str(), archive, model, objects_data);
 
        mz_zip_writer_finalize_archive(&archive);
        lock.close();
        boost::filesystem::rename(filepath_tmp, filepath, ec);
        return true;
    }

References _add_model_file_to_archive(), Slic3r::_BBS_3MF_Base::add_error(), Slic3r::close_zip_writer(), m_from_backup_save, m_production_ext, Slic3r::open_zip_writer(), and save_object_mesh().

Referenced by Slic3r::_BBS_Backup_Manager::process_task(), and save_object_mesh().

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::_BBS_3MF_Base::m_errors

mutableprivateinherited

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

m_from_backup_save

bool Slic3r::_BBS_3MF_Exporter::m_from_backup_save { false }

private

{ false };   // the object save is from backup store

Referenced by _add_model_file_to_archive(), save_model_to_file(), and save_object_mesh().

m_fullpath_sources

bool Slic3r::_BBS_3MF_Exporter::m_fullpath_sources { false }

private

{ false };

Referenced by _add_model_config_file_to_archive(), and save_model_to_file().

m_minimal_published

bool Slic3r::_BBS_3MF_Exporter::m_minimal_published { false }

private

{ false }; // published 3MF: omit the project config, the embedded preset files and the slicer tags

Referenced by _add_model_file_to_archive(), _save_model_to_file(), and save_model_to_file().

m_production_ext

bool Slic3r::_BBS_3MF_Exporter::m_production_ext { false }

private

{ false };    // save with Production Extention

Referenced by _add_build_to_model_stream(), _add_mesh_to_object_stream(), _add_model_file_to_archive(), _add_object_components_to_stream(), save_model_to_file(), and save_object_mesh().

m_save_gcode

bool Slic3r::_BBS_3MF_Exporter::m_save_gcode { false }

private

{ false };        // whether to save gcode for normal save

Referenced by _save_model_to_file(), and save_model_to_file().

m_share_mesh

bool Slic3r::_BBS_3MF_Exporter::m_share_mesh { false }

private

{ false };        // whether to share mesh between objects

Referenced by _add_mesh_to_object_stream(), _add_model_config_file_to_archive(), _add_model_file_to_archive(), and save_model_to_file().

m_shared_meshes

std::map<void const *, std::pair<ObjectData*, ModelVolume const *> > Slic3r::_BBS_3MF_Exporter::m_shared_meshes

private

Referenced by _add_model_file_to_archive().

m_skip_auxiliary

bool Slic3r::_BBS_3MF_Exporter::m_skip_auxiliary { false }

private

{ false };    // skip normal axuiliary files

Referenced by _add_auxiliary_dir_to_archive(), and save_model_to_file().

m_skip_model

bool Slic3r::_BBS_3MF_Exporter::m_skip_model { false }

private

{ false };        // skip model when exporting .gcode.3mf

Referenced by _add_model_config_file_to_archive(), _add_model_file_to_archive(), and save_model_to_file().

m_skip_static

bool Slic3r::_BBS_3MF_Exporter::m_skip_static { false }

private

{ false };        // not save mesh and other big static contents

Referenced by _save_model_to_file(), and save_model_to_file().

m_split_model

bool Slic3r::_BBS_3MF_Exporter::m_split_model { false }

private

{ false };       // save object per file with Production Extention

Referenced by _add_model_file_to_archive(), and save_model_to_file().

m_thumbnail_middle

std::string Slic3r::_BBS_3MF_Exporter::m_thumbnail_middle = PRINTER_THUMBNAIL_MIDDLE_FILE

private

Referenced by _add_auxiliary_dir_to_archive(), and save_model_to_file().

m_thumbnail_small

std::string Slic3r::_BBS_3MF_Exporter::m_thumbnail_small = PRINTER_THUMBNAIL_SMALL_FILE

private

Referenced by _add_auxiliary_dir_to_archive(), and save_model_to_file().

m_use_loaded_id

bool Slic3r::_BBS_3MF_Exporter::m_use_loaded_id { false }

private

{ false };        // whether to use loaded id for identify_id

Referenced by _add_slice_info_config_file_to_archive(), _save_model_to_file(), and save_model_to_file().

m_volume_paths

std::map<ModelVolume const *, std::pair<std::string, int> > Slic3r::_BBS_3MF_Exporter::m_volume_paths

private

Referenced by _add_model_config_file_to_archive(), _add_model_file_to_archive(), and _add_object_components_to_stream().

m_zip64

bool Slic3r::_BBS_3MF_Exporter::m_zip64 { true }

private

{ true };

Referenced by _add_model_file_to_archive(), and save_model_to_file().

mutex

boost::mutex Slic3r::_BBS_3MF_Base::mutex

mutableprivateinherited

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

---

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

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