Slic3r::AMFParserContext Struct Reference

Collaboration diagram for Slic3r::AMFParserContext:

Classes
struct	Instance
struct	Object

Public Types

enum

AMFNodeType {   NODE_TYPE_INVALID = 0 , NODE_TYPE_UNKNOWN , NODE_TYPE_AMF , NODE_TYPE_MATERIAL ,   NODE_TYPE_OBJECT , NODE_TYPE_MESH , NODE_TYPE_VERTICES , NODE_TYPE_VERTEX ,   NODE_TYPE_COORDINATES , NODE_TYPE_COORDINATE_X , NODE_TYPE_COORDINATE_Y , NODE_TYPE_COORDINATE_Z ,   NODE_TYPE_VOLUME , NODE_TYPE_TRIANGLE , NODE_TYPE_VERTEX1 , NODE_TYPE_VERTEX2 ,   NODE_TYPE_VERTEX3 , NODE_TYPE_CONSTELLATION , NODE_TYPE_INSTANCE , NODE_TYPE_DELTAX ,   NODE_TYPE_DELTAY , NODE_TYPE_DELTAZ , NODE_TYPE_RX , NODE_TYPE_RY ,   NODE_TYPE_RZ , NODE_TYPE_SCALE , NODE_TYPE_SCALEX , NODE_TYPE_SCALEY ,   NODE_TYPE_SCALEZ , NODE_TYPE_MIRRORX , NODE_TYPE_MIRRORY , NODE_TYPE_MIRRORZ ,   NODE_TYPE_PRINTABLE , NODE_TYPE_METADATA }

Public Member Functions
	AMFParserContext (XML_Parser parser, DynamicPrintConfig *config, ConfigSubstitutionContext *config_substitutions, Model *model)
void	stop (const std::string &msg=std::string())
bool	error () const
const char *	error_message () const
void	startElement (const char *name, const char **atts)
void	endElement (const char *name)
void	endDocument ()
void	characters (const XML_Char *s, int len)

Static Public Member Functions
static void XMLCALL	startElement (void *userData, const char *name, const char **atts)
static void XMLCALL	endElement (void *userData, const char *name)
static void XMLCALL	characters (void *userData, const XML_Char *s, int len)
static const char *	get_attribute (const char **atts, const char *id)

Public Attributes
XML_Parser	m_parser
bool	m_error { false }
std::string	m_error_message
Model &	m_model
std::vector< AMFNodeType >	m_path
ModelObject *	m_object { nullptr }
std::map< std::string, Object >	m_object_instances_map
std::vector< Vec3f >	m_object_vertices
ModelVolume *	m_volume { nullptr }
std::vector< Vec3i32 >	m_volume_facets
Transform3d	m_volume_transform
ModelMaterial *	m_material { nullptr }
Instance *	m_instance { nullptr }
std::string	m_value [5]
DynamicPrintConfig *	m_config { nullptr }
ConfigSubstitutionContext *	m_config_substitutions { nullptr }
bool	m_use_inches { false }

Private Member Functions
AMFParserContext &	operator= (AMFParserContext &)

Detailed Description

Member Enumeration Documentation

AMFNodeType

enum Slic3r::AMFParserContext::AMFNodeType

Enumerator
NODE_TYPE_INVALID
NODE_TYPE_UNKNOWN
NODE_TYPE_AMF
NODE_TYPE_MATERIAL
NODE_TYPE_OBJECT
NODE_TYPE_MESH
NODE_TYPE_VERTICES
NODE_TYPE_VERTEX
NODE_TYPE_COORDINATES
NODE_TYPE_COORDINATE_X
NODE_TYPE_COORDINATE_Y
NODE_TYPE_COORDINATE_Z
NODE_TYPE_VOLUME
NODE_TYPE_TRIANGLE
NODE_TYPE_VERTEX1
NODE_TYPE_VERTEX2
NODE_TYPE_VERTEX3
NODE_TYPE_CONSTELLATION
NODE_TYPE_INSTANCE
NODE_TYPE_DELTAX
NODE_TYPE_DELTAY
NODE_TYPE_DELTAZ
NODE_TYPE_RX
NODE_TYPE_RY
NODE_TYPE_RZ
NODE_TYPE_SCALE
NODE_TYPE_SCALEX
NODE_TYPE_SCALEY
NODE_TYPE_SCALEZ
NODE_TYPE_MIRRORX
NODE_TYPE_MIRRORY
NODE_TYPE_MIRRORZ
NODE_TYPE_PRINTABLE
NODE_TYPE_METADATA

                     {
        NODE_TYPE_INVALID = 0,
        NODE_TYPE_UNKNOWN,
        NODE_TYPE_AMF,                  // amf
                                        // amf/metadata
        NODE_TYPE_MATERIAL,             // amf/material
                                        // amf/material/metadata
        NODE_TYPE_OBJECT,               // amf/object
                                        // amf/object/metadata
       // NODE_TYPE_LAYER_CONFIG,         // amf/object/layer_config_ranges
        //NODE_TYPE_RANGE,                // amf/object/layer_config_ranges/range
                                        // amf/object/layer_config_ranges/range/metadata
        NODE_TYPE_MESH,                 // amf/object/mesh
        NODE_TYPE_VERTICES,             // amf/object/mesh/vertices
        NODE_TYPE_VERTEX,               // amf/object/mesh/vertices/vertex
        NODE_TYPE_COORDINATES,          // amf/object/mesh/vertices/vertex/coordinates
        NODE_TYPE_COORDINATE_X,         // amf/object/mesh/vertices/vertex/coordinates/x
        NODE_TYPE_COORDINATE_Y,         // amf/object/mesh/vertices/vertex/coordinates/y
        NODE_TYPE_COORDINATE_Z,         // amf/object/mesh/vertices/vertex/coordinates/z
        NODE_TYPE_VOLUME,               // amf/object/mesh/volume
                                        // amf/object/mesh/volume/metadata
        NODE_TYPE_TRIANGLE,             // amf/object/mesh/volume/triangle
        NODE_TYPE_VERTEX1,              // amf/object/mesh/volume/triangle/v1
        NODE_TYPE_VERTEX2,              // amf/object/mesh/volume/triangle/v2
        NODE_TYPE_VERTEX3,              // amf/object/mesh/volume/triangle/v3
        NODE_TYPE_CONSTELLATION,        // amf/constellation
        NODE_TYPE_INSTANCE,             // amf/constellation/instance
        NODE_TYPE_DELTAX,               // amf/constellation/instance/deltax
        NODE_TYPE_DELTAY,               // amf/constellation/instance/deltay
        NODE_TYPE_DELTAZ,               // amf/constellation/instance/deltaz
        NODE_TYPE_RX,                   // amf/constellation/instance/rx
        NODE_TYPE_RY,                   // amf/constellation/instance/ry
        NODE_TYPE_RZ,                   // amf/constellation/instance/rz
        NODE_TYPE_SCALE,                // amf/constellation/instance/scale
        NODE_TYPE_SCALEX,               // amf/constellation/instance/scalex
        NODE_TYPE_SCALEY,               // amf/constellation/instance/scaley
        NODE_TYPE_SCALEZ,               // amf/constellation/instance/scalez
        NODE_TYPE_MIRRORX,              // amf/constellation/instance/mirrorx
        NODE_TYPE_MIRRORY,              // amf/constellation/instance/mirrory
        NODE_TYPE_MIRRORZ,              // amf/constellation/instance/mirrorz
        NODE_TYPE_PRINTABLE,            // amf/constellation/instance/mirrorz
        //NODE_TYPE_CUSTOM_GCODE,         // amf/custom_code_per_height
        //NODE_TYPE_GCODE_PER_HEIGHT,     // amf/custom_code_per_height/code
        //NODE_TYPE_CUSTOM_GCODE_MODE,    // amf/custom_code_per_height/mode
        NODE_TYPE_METADATA,             // anywhere under amf/*/metadata
    };

Constructor & Destructor Documentation

AMFParserContext()

Slic3r::AMFParserContext::AMFParserContext ( XML_Parser parser, DynamicPrintConfig * config, ConfigSubstitutionContext * config_substitutions, Model * model )

inline

                                                                                                                                   :
        m_parser(parser),
        m_model(*model),
        m_config(config),
        m_config_substitutions(config_substitutions)
    {
        m_path.reserve(12);
    }

References m_config, m_config_substitutions, m_model, m_parser, and m_path.

Referenced by characters(), endElement(), operator=(), and startElement().

Here is the caller graph for this function:

Member Function Documentation

characters() [1/2]

void Slic3r::AMFParserContext::characters	(	const XML_Char *	s,
		int	len )

{
    if (m_path.back() == NODE_TYPE_METADATA) {
        m_value[1].append(s, len);
    }
    else
    {
        switch (m_path.size()) {
        case 4:
            if (m_path.back() == NODE_TYPE_DELTAX ||
                m_path.back() == NODE_TYPE_DELTAY ||
                m_path.back() == NODE_TYPE_DELTAZ ||
                m_path.back() == NODE_TYPE_RX ||
                m_path.back() == NODE_TYPE_RY ||
                m_path.back() == NODE_TYPE_RZ ||
                m_path.back() == NODE_TYPE_SCALEX ||
                m_path.back() == NODE_TYPE_SCALEY ||
                m_path.back() == NODE_TYPE_SCALEZ ||
                m_path.back() == NODE_TYPE_SCALE ||
                m_path.back() == NODE_TYPE_MIRRORX ||
                m_path.back() == NODE_TYPE_MIRRORY ||
                m_path.back() == NODE_TYPE_MIRRORZ ||
                m_path.back() == NODE_TYPE_PRINTABLE)
                m_value[0].append(s, len);
            break;
        case 6:
            switch (m_path.back()) {
                case NODE_TYPE_VERTEX1: m_value[0].append(s, len); break;
                case NODE_TYPE_VERTEX2: m_value[1].append(s, len); break;
                case NODE_TYPE_VERTEX3: m_value[2].append(s, len); break;
                default: break;
            }
        case 7:
            switch (m_path.back()) {
                case NODE_TYPE_COORDINATE_X: m_value[0].append(s, len); break;
                case NODE_TYPE_COORDINATE_Y: m_value[1].append(s, len); break;
                case NODE_TYPE_COORDINATE_Z: m_value[2].append(s, len); break;
                default: break;
            }
        default:
            break;
        }
    }
}

References m_path, m_value, NODE_TYPE_COORDINATE_X, NODE_TYPE_COORDINATE_Y, NODE_TYPE_COORDINATE_Z, NODE_TYPE_DELTAX, NODE_TYPE_DELTAY, NODE_TYPE_DELTAZ, NODE_TYPE_METADATA, NODE_TYPE_MIRRORX, NODE_TYPE_MIRRORY, NODE_TYPE_MIRRORZ, NODE_TYPE_PRINTABLE, NODE_TYPE_RX, NODE_TYPE_RY, NODE_TYPE_RZ, NODE_TYPE_SCALE, NODE_TYPE_SCALEX, NODE_TYPE_SCALEY, NODE_TYPE_SCALEZ, NODE_TYPE_VERTEX1, NODE_TYPE_VERTEX2, and NODE_TYPE_VERTEX3.

Referenced by characters(), Slic3r::extract_model_from_archive(), and Slic3r::load_amf_file().

Here is the caller graph for this function:

characters() [2/2]

void XMLCALL Slic3r::AMFParserContext::characters ( void * userData, const XML_Char * s, int len )

inlinestatic

    {
        AMFParserContext *ctx = (AMFParserContext*)userData;
        ctx->characters(s, len);
    }

References AMFParserContext(), and characters().

Here is the call graph for this function:

endDocument()

void Slic3r::AMFParserContext::endDocument

(

)

{
    for (const auto &object : m_object_instances_map) {
        if (object.second.idx == -1) {
            BOOST_LOG_TRIVIAL(error) << "Undefined object " << object.first.c_str() << " referenced in constellation";
            continue;
        }
        int index = 0;
        for (const Instance &instance : object.second.instances) {
            ModelObject *model_object = m_model.objects[object.second.idx];
            index++;
            if (index > 1) {
                ModelObject *new_model_object = m_model.add_object(*model_object);
                new_model_object->clear_instances();
                model_object = new_model_object;
            }
 
            if (instance.anything_set()) {
                ModelInstance *mi = model_object->add_instance();
                mi->set_offset(Vec3d(instance.deltax_set ? (double) instance.deltax : 0.0, instance.deltay_set ? (double) instance.deltay : 0.0,
                                     instance.deltaz_set ? (double) instance.deltaz : 0.0));
                mi->set_rotation(Vec3d(instance.rx_set ? (double) instance.rx : 0.0, instance.ry_set ? (double) instance.ry : 0.0, instance.rz_set ? (double) instance.rz : 0.0));
                mi->set_scaling_factor(Vec3d(instance.scalex_set ? (double) instance.scalex : 1.0, instance.scaley_set ? (double) instance.scaley : 1.0,
                                             instance.scalez_set ? (double) instance.scalez : 1.0));
                mi->set_mirror(Vec3d(instance.mirrorx_set ? (double) instance.mirrorx : 1.0, instance.mirrory_set ? (double) instance.mirrory : 1.0,
                                     instance.mirrorz_set ? (double) instance.mirrorz : 1.0));
                mi->printable = instance.printable;
            }
        }
    }
}

References Slic3r::ModelObject::add_instance(), Slic3r::ModelObject::clear_instances(), error(), m_model, m_object_instances_map, Slic3r::ModelInstance::printable, Slic3r::ModelInstance::set_mirror(), Slic3r::ModelInstance::set_offset(), Slic3r::ModelInstance::set_rotation(), and Slic3r::ModelInstance::set_scaling_factor().

Referenced by Slic3r::load_amf_file().

Here is the call graph for this function:

Here is the caller graph for this function:

endElement() [1/2]

void Slic3r::AMFParserContext::endElement

(

const char *

name

)

{
    assert(is_decimal_separator_point());
    switch (m_path.back()) {
 
    // Constellation transformation:
    case NODE_TYPE_DELTAX:
        assert(m_instance);
        m_instance->deltax = float(atof(m_value[0].c_str()));
        m_instance->deltax_set = true;
        m_value[0].clear();
        break;
    case NODE_TYPE_DELTAY:
        assert(m_instance);
        m_instance->deltay = float(atof(m_value[0].c_str()));
        m_instance->deltay_set = true;
        m_value[0].clear();
        break;
    case NODE_TYPE_DELTAZ:
        assert(m_instance);
        m_instance->deltaz = float(atof(m_value[0].c_str()));
        m_instance->deltaz_set = true;
        m_value[0].clear();
        break;
    case NODE_TYPE_RX:
        assert(m_instance);
        m_instance->rx = float(atof(m_value[0].c_str()));
        m_instance->rx_set = true;
        m_value[0].clear();
        break;
    case NODE_TYPE_RY:
        assert(m_instance);
        m_instance->ry = float(atof(m_value[0].c_str()));
        m_instance->ry_set = true;
        m_value[0].clear();
        break;
    case NODE_TYPE_RZ:
        assert(m_instance);
        m_instance->rz = float(atof(m_value[0].c_str()));
        m_instance->rz_set = true;
        m_value[0].clear();
        break;
    case NODE_TYPE_SCALE:
        assert(m_instance);
        m_instance->scalex = float(atof(m_value[0].c_str()));
        m_instance->scalex_set = true;
        m_instance->scaley = float(atof(m_value[0].c_str()));
        m_instance->scaley_set = true;
        m_instance->scalez = float(atof(m_value[0].c_str()));
        m_instance->scalez_set = true;
        m_value[0].clear();
        break;
    case NODE_TYPE_SCALEX:
        assert(m_instance);
        m_instance->scalex = float(atof(m_value[0].c_str()));
        m_instance->scalex_set = true;
        m_value[0].clear();
        break;
    case NODE_TYPE_SCALEY:
        assert(m_instance);
        m_instance->scaley = float(atof(m_value[0].c_str()));
        m_instance->scaley_set = true;
        m_value[0].clear();
        break;
    case NODE_TYPE_SCALEZ:
        assert(m_instance);
        m_instance->scalez = float(atof(m_value[0].c_str()));
        m_instance->scalez_set = true;
        m_value[0].clear();
        break;
    case NODE_TYPE_MIRRORX:
        assert(m_instance);
        m_instance->mirrorx = float(atof(m_value[0].c_str()));
        m_instance->mirrorx_set = true;
        m_value[0].clear();
        break;
    case NODE_TYPE_MIRRORY:
        assert(m_instance);
        m_instance->mirrory = float(atof(m_value[0].c_str()));
        m_instance->mirrory_set = true;
        m_value[0].clear();
        break;
    case NODE_TYPE_MIRRORZ:
        assert(m_instance);
        m_instance->mirrorz = float(atof(m_value[0].c_str()));
        m_instance->mirrorz_set = true;
        m_value[0].clear();
        break;
    case NODE_TYPE_PRINTABLE:
        assert(m_instance);
        m_instance->printable = bool(atoi(m_value[0].c_str()));
        m_value[0].clear();
        break;
 
    // Object vertices:
    case NODE_TYPE_VERTEX:
        assert(m_object);
        // Parse the vertex data
        m_object_vertices.emplace_back(float(atof(m_value[0].c_str())), float(atof(m_value[1].c_str())), float(atof(m_value[2].c_str())));
        m_value[0].clear();
        m_value[1].clear();
        m_value[2].clear();
        break;
 
    // Faces of the current volume:
    case NODE_TYPE_TRIANGLE:
        assert(m_object && m_volume);
        m_volume_facets.emplace_back(atoi(m_value[0].c_str()), atoi(m_value[1].c_str()), atoi(m_value[2].c_str()));
        m_value[0].clear();
        m_value[1].clear();
        m_value[2].clear();
        break;
 
    // Closing the current volume. Create an STL from m_volume_facets pointing to m_object_vertices.
    case NODE_TYPE_VOLUME:
    {
    assert(m_object && m_volume);
        if (m_volume_facets.empty()) {
            this->stop("Found an empty triangle mesh");
            return;
        }
 
        {
            // Verify validity of face indices, find the vertex span.
            int min_id = m_volume_facets.front()[0];
            int max_id = min_id;
            for (const Vec3i32& face : m_volume_facets) {
                for (const int tri_id : face) {
                    if (tri_id < 0 || tri_id >= int(m_object_vertices.size())) {
                        this->stop("Found a malformed triangle mesh");
                        return;
                    }
                    min_id = std::min(min_id, tri_id);
                    max_id = std::max(max_id, tri_id);
                }
            }
 
            // rebase indices to the current vertices list
            for (Vec3i32 &face : m_volume_facets)
                face -= Vec3i32(min_id, min_id, min_id);
 
            indexed_triangle_set its { std::move(m_volume_facets), { m_object_vertices.begin() + min_id, m_object_vertices.begin() + max_id + 1 } };
            its_compactify_vertices(its);
            if (its_volume(its) < 0)
                its_flip_triangles(its);
            m_volume->set_mesh(std::move(its));
        }
 
        // stores the volume matrix taken from the metadata, if present
        if (bool has_transform = !m_volume_transform.isApprox(Transform3d::Identity(), 1e-10); has_transform)
            m_volume->source.transform = Slic3r::Geometry::Transformation(m_volume_transform);
 
        if (m_volume->source.input_file.empty() && (m_volume->type() == ModelVolumeType::MODEL_PART)) {
            m_volume->source.object_idx = (int)m_model.objects.size() - 1;
            m_volume->source.volume_idx = (int)m_model.objects.back()->volumes.size() - 1;
            m_volume->center_geometry_after_creation();
        } else
            // pass false if the mesh offset has been already taken from the data
            m_volume->center_geometry_after_creation(m_volume->source.input_file.empty());
 
        m_volume->calculate_convex_hull();
        m_volume_facets.clear();
        m_volume = nullptr;
        break;
    }
 
    case NODE_TYPE_OBJECT:
        assert(m_object);
        m_object_vertices.clear();
        m_object = nullptr;
        break;
 
    case NODE_TYPE_MATERIAL:
        assert(m_material);
        m_material = nullptr;
        break;
 
    case NODE_TYPE_INSTANCE:
        assert(m_instance);
        m_instance = nullptr;
        break;
 
    /*case NODE_TYPE_GCODE_PER_HEIGHT: {
        double print_z          = double(atof(m_value[0].c_str()));
        int extruder            = atoi(m_value[1].c_str());
        const std::string& color= m_value[2];
        CustomGCode::Type type  = static_cast<CustomGCode::Type>(atoi(m_value[3].c_str()));
        const std::string& extra= m_value[4];
 
        m_model.custom_gcode_per_print_z.gcodes.push_back(CustomGCode::Item{print_z, type, extruder, color, extra});
 
        for (std::string& val: m_value)
            val.clear();
        break;
        }
 
    case NODE_TYPE_CUSTOM_GCODE_MODE: {
        const std::string& mode = m_value[0];
 
        m_model.custom_gcode_per_print_z.mode = mode == CustomGCode::SingleExtruderMode ? CustomGCode::Mode::SingleExtruder :
                                                mode == CustomGCode::MultiAsSingleMode  ? CustomGCode::Mode::MultiAsSingle  :
                                                                                          CustomGCode::Mode::MultiExtruder;
        for (std::string& val: m_value)
            val.clear();
        break;
        }
        */
    case NODE_TYPE_METADATA:
        /*if ((m_config != nullptr) && strncmp(m_value[0].c_str(), SLIC3R_CONFIG_TYPE, strlen(SLIC3R_CONFIG_TYPE)) == 0) {
            //FIXME Loading a "will be one day a legacy format" of configuration in a form of a G-code comment.
            // Each config line is prefixed with a semicolon (G-code comment), that is ugly.
 
            // Replacing the legacy function with load_from_ini_string_commented leads to issues when
            // parsing 3MFs from before PrusaSlicer 2.0.0 (which can have duplicated entries in the INI.
            // See https://github.com/prusa3d/PrusaSlicer/issues/7155. We'll revert it for now.
            //m_config_substitutions->substitutions = m_config->load_from_ini_string_commented(std::move(m_value[1].c_str()), m_config_substitutions->rule);
            ConfigBase::load_from_gcode_string_legacy(*m_config, std::move(m_value[1].c_str()), *m_config_substitutions);
        }
        else if (strncmp(m_value[0].c_str(), "slic3r.", 7) == 0) {
            const char *opt_key = m_value[0].c_str() + 7;
            if (print_config_def.options.find(opt_key) != print_config_def.options.end()) {
                ModelConfig *config = nullptr;
                if (m_path.size() == 3) {
                    if (m_path[1] == NODE_TYPE_MATERIAL && m_material)
                        config = &m_material->config;
                    else if (m_path[1] == NODE_TYPE_OBJECT && m_object)
                        config = &m_object->config;
                }
                else if (m_path.size() == 5 && m_path[3] == NODE_TYPE_VOLUME && m_volume)
                    config = &m_volume->config;
                else if (m_path.size() == 5 && m_path[3] == NODE_TYPE_RANGE && m_object && !m_object->layer_config_ranges.empty()) {
                    auto it  = --m_object->layer_config_ranges.end();
                    config = &it->second;
                }
                if (config)
                    config->set_deserialize(opt_key, m_value[1], *m_config_substitutions);
            } else if (m_path.size() == 3 && m_path[1] == NODE_TYPE_OBJECT && m_object && strcmp(opt_key, "layer_height_profile") == 0) {
                // Parse object's layer height profile, a semicolon separated list of floats.
                char *p = m_value[1].data();
                std::vector<coordf_t> data;
                for (;;) {
                    char *end = strchr(p, ';');
                    if (end != nullptr)
                      *end = 0;
                    data.emplace_back(float(atof(p)));
          if (end == nullptr)
            break;
          p = end + 1;
                }
                m_object->layer_height_profile.set(std::move(data));
            }
            else if (m_path.size() == 3 && m_path[1] == NODE_TYPE_OBJECT && m_object && strcmp(opt_key, "sla_support_points") == 0) {
                // Parse object's layer height profile, a semicolon separated list of floats.
                unsigned char coord_idx = 0;
                Eigen::Matrix<float, 5, 1, Eigen::DontAlign> point(Eigen::Matrix<float, 5, 1, Eigen::DontAlign>::Zero());
                char *p = m_value[1].data();
                for (;;) {
                    char *end = strchr(p, ';');
                    if (end != nullptr)
                      *end = 0;
 
                    point(coord_idx) = float(atof(p));
                    if (++coord_idx == 5) {
                        m_object->sla_support_points.push_back(sla::SupportPoint(point));
                        coord_idx = 0;
                    }
          if (end == nullptr)
            break;
          p = end + 1;
                }
                m_object->sla_points_status = sla::PointsStatus::UserModified;
            }
            else if (m_path.size() == 5 && m_path[1] == NODE_TYPE_OBJECT && m_path[3] == NODE_TYPE_RANGE &&
                     m_object && strcmp(opt_key, "layer_height_range") == 0) {
                // Parse object's layer_height_range, a semicolon separated doubles.
                char* p = m_value[1].data();
                char* end = strchr(p, ';');
                *end = 0;
 
                const t_layer_height_range range = {double(atof(p)), double(atof(end + 1))};
                m_object->layer_config_ranges[range];
            }
            else if (m_path.size() == 5 && m_path[3] == NODE_TYPE_VOLUME && m_volume) {
                if (strcmp(opt_key, "modifier") == 0) {
                    // Is this volume a modifier volume?
                    // "modifier" flag comes first in the XML file, so it may be later overwritten by the "type" flag.
          m_volume->set_type((atoi(m_value[1].c_str()) == 1) ? ModelVolumeType::PARAMETER_MODIFIER : ModelVolumeType::MODEL_PART);
                } else if (strcmp(opt_key, "volume_type") == 0) {
                    m_volume->set_type(ModelVolume::type_from_string(m_value[1]));
                }
                else if (strcmp(opt_key, "matrix") == 0) {
                    m_volume_transform = Slic3r::Geometry::transform3d_from_string(m_value[1]);
                }
                else if (strcmp(opt_key, "source_file") == 0) {
                    m_volume->source.input_file = m_value[1];
                }
                else if (strcmp(opt_key, "source_object_id") == 0) {
                    m_volume->source.object_idx = ::atoi(m_value[1].c_str());
                }
                else if (strcmp(opt_key, "source_volume_id") == 0) {
                    m_volume->source.volume_idx = ::atoi(m_value[1].c_str());
                }
                else if (strcmp(opt_key, "source_offset_x") == 0) {
                    m_volume->source.mesh_offset(0) = ::atof(m_value[1].c_str());
                }
                else if (strcmp(opt_key, "source_offset_y") == 0) {
                    m_volume->source.mesh_offset(1) = ::atof(m_value[1].c_str());
                }
                else if (strcmp(opt_key, "source_offset_z") == 0) {
                    m_volume->source.mesh_offset(2) = ::atof(m_value[1].c_str());
                }
                else if (strcmp(opt_key, "source_in_inches") == 0) {
                    m_volume->source.is_converted_from_inches = m_value[1] == "1";
                }
                else if (strcmp(opt_key, "source_in_meters") == 0) {
                    m_volume->source.is_converted_from_meters = m_value[1] == "1";
                }
            }
        }
        else */if (m_path.size() == 3) {
            if (m_path[1] == NODE_TYPE_MATERIAL) {
                if (m_material)
                    m_material->attributes[m_value[0]] = m_value[1];
            } else if (m_path[1] == NODE_TYPE_OBJECT) {
                if (m_object && m_value[0] == "name")
                    m_object->name = std::move(m_value[1]);
            }
        } else if (m_path.size() == 5 && m_path[3] == NODE_TYPE_VOLUME) {
            if (m_volume && m_value[0] == "name")
                m_volume->name = std::move(m_value[1]);
        }
        /*else if (strncmp(m_value[0].c_str(), SLIC3RPE_AMF_VERSION, strlen(SLIC3RPE_AMF_VERSION)) == 0) {
            m_version = (unsigned int)atoi(m_value[1].c_str());
        }*/
 
        m_value[0].clear();
        m_value[1].clear();
        break;
    default:
        break;
    }
    m_path.pop_back();
}

References Slic3r::is_decimal_separator_point(), Slic3r::its_compactify_vertices(), Slic3r::its_flip_triangles(), Slic3r::its_volume(), m_instance, m_material, m_model, m_object, m_object_vertices, m_path, m_value, m_volume, m_volume_facets, m_volume_transform, Slic3r::MODEL_PART, NODE_TYPE_DELTAX, NODE_TYPE_DELTAY, NODE_TYPE_DELTAZ, NODE_TYPE_INSTANCE, NODE_TYPE_MATERIAL, NODE_TYPE_METADATA, NODE_TYPE_MIRRORX, NODE_TYPE_MIRRORY, NODE_TYPE_MIRRORZ, NODE_TYPE_OBJECT, NODE_TYPE_PRINTABLE, NODE_TYPE_RX, NODE_TYPE_RY, NODE_TYPE_RZ, NODE_TYPE_SCALE, NODE_TYPE_SCALEX, NODE_TYPE_SCALEY, NODE_TYPE_SCALEZ, NODE_TYPE_TRIANGLE, NODE_TYPE_VERTEX, NODE_TYPE_VOLUME, and stop().

Referenced by endElement(), Slic3r::extract_model_from_archive(), and Slic3r::load_amf_file().

Here is the call graph for this function:

Here is the caller graph for this function:

endElement() [2/2]

void XMLCALL Slic3r::AMFParserContext::endElement ( void * userData, const char * name )

inlinestatic

    {
        AMFParserContext *ctx = (AMFParserContext*)userData;
        ctx->endElement(name);
    }

References AMFParserContext(), and endElement().

Here is the call graph for this function:

error()

bool Slic3r::AMFParserContext::error ( ) const

inline

{ return m_error; }

References m_error.

Referenced by endDocument(), and Slic3r::load_amf_file().

Here is the caller graph for this function:

error_message()

const char * Slic3r::AMFParserContext::error_message ( ) const

inline

                                      {
        return m_error ?
            // The error was signalled by the user code, not the expat parser.
            (m_error_message.empty() ? "Parse AMF file failed" : m_error_message.c_str()) :
            // The error was signalled by the expat parser.
            XML_ErrorString(XML_GetErrorCode(m_parser));
    }

References m_error, m_error_message, and m_parser.

Referenced by Slic3r::load_amf_file().

Here is the caller graph for this function:

get_attribute()

const char * Slic3r::AMFParserContext::get_attribute ( const char ** atts, const char * id )

inlinestatic

                                                                        {
        if (atts == nullptr)
            return nullptr;
        while (*atts != nullptr) {
            if (strcmp(*(atts ++), id) == 0)
                return *atts;
            ++ atts;
        }
        return nullptr;
    }

Referenced by startElement().

Here is the caller graph for this function:

operator=()

AMFParserContext & Slic3r::AMFParserContext::operator= ( AMFParserContext & )

private

References AMFParserContext().

Here is the call graph for this function:

startElement() [1/2]

void Slic3r::AMFParserContext::startElement	(	const char *	name,
		const char **	atts )

{
    AMFNodeType node_type_new = NODE_TYPE_UNKNOWN;
    switch (m_path.size()) {
    case 0: {
        // An AMF file must start with an <amf> tag.
        node_type_new = NODE_TYPE_AMF;
        if (strcmp(name, "amf") != 0) this->stop();
        // BBS: add units logic
        const char *units = get_attribute(atts, "unit");
        if (units && (strcmp(units, "inch") == 0)) { m_use_inches = true; }
        break;
    }
    case 1:
        if (strcmp(name, "metadata") == 0) {
            const char *type = get_attribute(atts, "type");
            if (type != nullptr) {
                m_value[0] = type;
                node_type_new = NODE_TYPE_METADATA;
            }
        } else if (strcmp(name, "material") == 0) {
            const char *material_id = get_attribute(atts, "id");
            m_material = m_model.add_material((material_id == nullptr) ? "_" : material_id);
            node_type_new = NODE_TYPE_MATERIAL;
        } else if (strcmp(name, "object") == 0) {
            const char *object_id = get_attribute(atts, "id");
            if (object_id == nullptr)
                this->stop();
            else {
        assert(m_object_vertices.empty());
                m_object = m_model.add_object();
                m_object_instances_map[object_id].idx = int(m_model.objects.size())-1;
                node_type_new = NODE_TYPE_OBJECT;
            }
        } else if (strcmp(name, "constellation") == 0) {
            node_type_new = NODE_TYPE_CONSTELLATION;
        }/*else if (strcmp(name, "custom_gcodes_per_height") == 0) {
            node_type_new = NODE_TYPE_CUSTOM_GCODE;
        }*/
        break;
    case 2:
        if (strcmp(name, "metadata") == 0) {
            if (m_path[1] == NODE_TYPE_MATERIAL || m_path[1] == NODE_TYPE_OBJECT) {
                const char *type = get_attribute(atts, "type");
                if (type == nullptr)
                    this->stop();
                else {
                    m_value[0] = type;
                    node_type_new = NODE_TYPE_METADATA;
                }
            }
        }/* else if (strcmp(name, "layer_config_ranges") == 0 && m_path[1] == NODE_TYPE_OBJECT)
                node_type_new = NODE_TYPE_LAYER_CONFIG;*/
        else if (strcmp(name, "mesh") == 0) {
            if (m_path[1] == NODE_TYPE_OBJECT)
                node_type_new = NODE_TYPE_MESH;
        } else if (strcmp(name, "instance") == 0) {
            if (m_path[1] == NODE_TYPE_CONSTELLATION) {
                const char *object_id = get_attribute(atts, "objectid");
                if (object_id == nullptr)
                    this->stop();
                else {
                    m_object_instances_map[object_id].instances.push_back(AMFParserContext::Instance());
                    m_instance = &m_object_instances_map[object_id].instances.back();
                    node_type_new = NODE_TYPE_INSTANCE;
                }
            }
            else
                this->stop();
        }
        /*else if (m_path[1] == NODE_TYPE_CUSTOM_GCODE) {
            if (strcmp(name, "code") == 0) {
                node_type_new = NODE_TYPE_GCODE_PER_HEIGHT;
                m_value[0] = get_attribute(atts, "print_z");
                m_value[1] = get_attribute(atts, "extruder");
                m_value[2] = get_attribute(atts, "color");
                if (get_attribute(atts, "type"))
                {
                    m_value[3] = get_attribute(atts, "type");
                    m_value[4] = get_attribute(atts, "extra");
                }
                else
                {
                    // It means that data was saved in old version (2.2.0 and older) of PrusaSlicer
                    // read old data ...
                    std::string gcode = get_attribute(atts, "gcode");
                    // ... and interpret them to the new data
                    CustomGCode::Type type= gcode == "M600" ? CustomGCode::ColorChange :
                                            gcode == "M601" ? CustomGCode::PausePrint :
                                            gcode == "tool_change" ? CustomGCode::ToolChange : CustomGCode::Custom;
                    m_value[3] = std::to_string(static_cast<int>(type));
                    m_value[4] = type == CustomGCode::PausePrint ? m_value[2] :
                                 type == CustomGCode::Custom ? gcode : "";
                }
            }
            else if (strcmp(name, "mode") == 0) {
                node_type_new = NODE_TYPE_CUSTOM_GCODE_MODE;
                m_value[0] = get_attribute(atts, "value");
            }
        }*/
        break;
    case 3:
        if (m_path[2] == NODE_TYPE_MESH) {
      assert(m_object);
            if (strcmp(name, "vertices") == 0)
                node_type_new = NODE_TYPE_VERTICES;
      else if (strcmp(name, "volume") == 0) {
        assert(! m_volume);
                m_volume = m_object->add_volume(TriangleMesh());
                m_volume_transform = Transform3d::Identity();
                node_type_new = NODE_TYPE_VOLUME;
      }
        }
        else if (m_path[2] == NODE_TYPE_INSTANCE) {
            assert(m_instance);
            if (strcmp(name, "deltax") == 0)
                node_type_new = NODE_TYPE_DELTAX;
            else if (strcmp(name, "deltay") == 0)
                node_type_new = NODE_TYPE_DELTAY;
            else if (strcmp(name, "deltaz") == 0)
                node_type_new = NODE_TYPE_DELTAZ;
            else if (strcmp(name, "rx") == 0)
                node_type_new = NODE_TYPE_RX;
            else if (strcmp(name, "ry") == 0)
                node_type_new = NODE_TYPE_RY;
            else if (strcmp(name, "rz") == 0)
                node_type_new = NODE_TYPE_RZ;
            else if (strcmp(name, "scalex") == 0)
                node_type_new = NODE_TYPE_SCALEX;
            else if (strcmp(name, "scaley") == 0)
                node_type_new = NODE_TYPE_SCALEY;
            else if (strcmp(name, "scalez") == 0)
                node_type_new = NODE_TYPE_SCALEZ;
            else if (strcmp(name, "scale") == 0)
                node_type_new = NODE_TYPE_SCALE;
            else if (strcmp(name, "mirrorx") == 0)
                node_type_new = NODE_TYPE_MIRRORX;
            else if (strcmp(name, "mirrory") == 0)
                node_type_new = NODE_TYPE_MIRRORY;
            else if (strcmp(name, "mirrorz") == 0)
                node_type_new = NODE_TYPE_MIRRORZ;
            else if (strcmp(name, "printable") == 0)
                node_type_new = NODE_TYPE_PRINTABLE;
        }
        /*else if (m_path[2] == NODE_TYPE_LAYER_CONFIG && strcmp(name, "range") == 0) {
            assert(m_object);
            node_type_new = NODE_TYPE_RANGE;
        }*/
        break;
    case 4:
        if (m_path[3] == NODE_TYPE_VERTICES) {
            if (strcmp(name, "vertex") == 0)
                node_type_new = NODE_TYPE_VERTEX;
        } else if (m_path[3] == NODE_TYPE_VOLUME) {
            if (strcmp(name, "metadata") == 0) {
                const char *type = get_attribute(atts, "type");
                if (type == nullptr)
                    this->stop();
                else {
                    m_value[0] = type;
                    node_type_new = NODE_TYPE_METADATA;
                }
            } else if (strcmp(name, "triangle") == 0)
                node_type_new = NODE_TYPE_TRIANGLE;
        }
        /*else if (m_path[3] == NODE_TYPE_RANGE && strcmp(name, "metadata") == 0) {
            m_value[0] = get_attribute(atts, "type");
            node_type_new = NODE_TYPE_METADATA;
        }*/
        break;
    case 5:
        if (strcmp(name, "coordinates") == 0) {
            if (m_path[4] == NODE_TYPE_VERTEX) {
                node_type_new = NODE_TYPE_COORDINATES;
            } else
                this->stop();
        } else if (name[0] == 'v' && name[1] >= '1' && name[1] <= '3' && name[2] == 0) {
            if (m_path[4] == NODE_TYPE_TRIANGLE) {
                node_type_new = AMFNodeType(NODE_TYPE_VERTEX1 + name[1] - '1');
            } else
                this->stop();
        }
        break;
    case 6:
        if ((name[0] == 'x' || name[0] == 'y' || name[0] == 'z') && name[1] == 0) {
            if (m_path[5] == NODE_TYPE_COORDINATES)
                node_type_new = AMFNodeType(NODE_TYPE_COORDINATE_X + name[0] - 'x');
            else
                this->stop();
        }
        break;
    default:
        break;
    }
 
    m_path.push_back(node_type_new);
}

References get_attribute(), m_instance, m_material, m_model, m_object, m_object_instances_map, m_object_vertices, m_path, m_use_inches, m_value, m_volume, m_volume_transform, NODE_TYPE_AMF, NODE_TYPE_CONSTELLATION, NODE_TYPE_COORDINATE_X, NODE_TYPE_COORDINATES, NODE_TYPE_DELTAX, NODE_TYPE_DELTAY, NODE_TYPE_DELTAZ, NODE_TYPE_INSTANCE, NODE_TYPE_MATERIAL, NODE_TYPE_MESH, NODE_TYPE_METADATA, NODE_TYPE_MIRRORX, NODE_TYPE_MIRRORY, NODE_TYPE_MIRRORZ, NODE_TYPE_OBJECT, NODE_TYPE_PRINTABLE, NODE_TYPE_RX, NODE_TYPE_RY, NODE_TYPE_RZ, NODE_TYPE_SCALE, NODE_TYPE_SCALEX, NODE_TYPE_SCALEY, NODE_TYPE_SCALEZ, NODE_TYPE_TRIANGLE, NODE_TYPE_UNKNOWN, NODE_TYPE_VERTEX, NODE_TYPE_VERTEX1, NODE_TYPE_VERTICES, NODE_TYPE_VOLUME, and stop().

Referenced by Slic3r::extract_model_from_archive(), Slic3r::load_amf_file(), and startElement().

Here is the call graph for this function:

Here is the caller graph for this function:

startElement() [2/2]

void XMLCALL Slic3r::AMFParserContext::startElement ( void * userData, const char * name, const char ** atts )

inlinestatic

    {
        AMFParserContext *ctx = (AMFParserContext*)userData;
        ctx->startElement(name, atts);
    }

References AMFParserContext(), and startElement().

Here is the call graph for this function:

stop()

void Slic3r::AMFParserContext::stop ( const std::string & msg = std::string() )

inline

    {
        assert(! m_error);
        assert(m_error_message.empty());
        m_error = true;
        m_error_message = msg;
        XML_StopParser(m_parser, 0);
    }

References m_error, m_error_message, and m_parser.

Referenced by endElement(), and startElement().

Here is the caller graph for this function:

Member Data Documentation

m_config

DynamicPrintConfig* Slic3r::AMFParserContext::m_config { nullptr }

{ nullptr };

Referenced by AMFParserContext().

m_config_substitutions

ConfigSubstitutionContext* Slic3r::AMFParserContext::m_config_substitutions { nullptr }

{ nullptr };

Referenced by AMFParserContext().

m_error

bool Slic3r::AMFParserContext::m_error { false }

{ false };

Referenced by error(), error_message(), and stop().

m_error_message

std::string Slic3r::AMFParserContext::m_error_message

Referenced by error_message(), and stop().

m_instance

Instance* Slic3r::AMFParserContext::m_instance { nullptr }

{ nullptr };

Referenced by endElement(), and startElement().

m_material

ModelMaterial* Slic3r::AMFParserContext::m_material { nullptr }

{ nullptr };

Referenced by endElement(), and startElement().

m_model

Model& Slic3r::AMFParserContext::m_model

Referenced by AMFParserContext(), endDocument(), endElement(), and startElement().

m_object

ModelObject* Slic3r::AMFParserContext::m_object { nullptr }

{ nullptr };

Referenced by endElement(), and startElement().

m_object_instances_map

std::map<std::string, Object> Slic3r::AMFParserContext::m_object_instances_map

Referenced by endDocument(), and startElement().

m_object_vertices

std::vector<Vec3f> Slic3r::AMFParserContext::m_object_vertices

Referenced by endElement(), and startElement().

m_parser

XML_Parser Slic3r::AMFParserContext::m_parser

Referenced by AMFParserContext(), error_message(), and stop().

m_path

std::vector<AMFNodeType> Slic3r::AMFParserContext::m_path

Referenced by AMFParserContext(), characters(), endElement(), and startElement().

m_use_inches

bool Slic3r::AMFParserContext::m_use_inches { false }

{ false };

Referenced by Slic3r::load_amf_file(), and startElement().

m_value

std::string Slic3r::AMFParserContext::m_value[5]

Referenced by characters(), endElement(), and startElement().

m_volume

ModelVolume* Slic3r::AMFParserContext::m_volume { nullptr }

{ nullptr };

Referenced by endElement(), and startElement().

m_volume_facets

std::vector<Vec3i32> Slic3r::AMFParserContext::m_volume_facets

Referenced by endElement().

m_volume_transform

Transform3d Slic3r::AMFParserContext::m_volume_transform

Referenced by endElement(), and startElement().

---

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

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