Slic3r::TextConfigurationSerialization Struct Reference

Public Member Functions
	TextConfigurationSerialization ()=delete

Static Public Member Functions
static EmbossStyle::Type	get_type (std::string_view type)
static std::string_view	get_name (EmbossStyle::Type type)
static void	to_xml (std::stringstream &stream, const TextConfiguration &tc)
static void	create_fix_and_store (std::stringstream &stream, TextConfiguration tc, const ModelVolume &volume)
static std::optional< TextConfiguration >	read (const char **attributes, unsigned int num_attributes)

Static Public Attributes
static const boost::bimap< EmbossStyle::Type, std::string_view >	type_to_name

Detailed Description

Constructor & Destructor Documentation

TextConfigurationSerialization()

Slic3r::TextConfigurationSerialization::TextConfigurationSerialization ( )

delete

Member Function Documentation

create_fix_and_store()

void Slic3r::TextConfigurationSerialization::create_fix_and_store ( std::stringstream &  stream, TextConfiguration  tc, const ModelVolume &  volume  )

static

{
    const auto& vertices = volume.mesh().its.vertices;
    assert(!vertices.empty());
    if (vertices.empty()) { 
        to_xml(stream, tc);
        return; 
    }
 
    // IMPROVE: check if volume was modified (translated, rotated OR scaled)
    // when no change do not calculate transformation only store original fix matrix
 
    // Create transformation used after load actual stored volume
    const Transform3d &actual_trmat = volume.get_transformation().get_matrix();
    Vec3d min = actual_trmat * vertices.front().cast<double>();
    Vec3d max = min;
    for (const Vec3f &v : vertices) {
        Vec3d vd = actual_trmat * v.cast<double>();
        for (size_t i = 0; i < 3; ++i) {
            if (min[i] > vd[i]) min[i] = vd[i];
            if (max[i] < vd[i]) max[i] = vd[i];
        }
    }
    Vec3d center = (max + min) / 2;
    Transform3d post_trmat = Transform3d::Identity();
    post_trmat.translate(center);
 
    Transform3d fix_trmat = actual_trmat.inverse() * post_trmat;    
    if (!tc.fix_3mf_tr.has_value()) {
        tc.fix_3mf_tr = fix_trmat;
    } else if (!fix_trmat.isApprox(Transform3d::Identity(), 1e-5)) {
        tc.fix_3mf_tr = *tc.fix_3mf_tr * fix_trmat;
    }
    to_xml(stream, tc);
}

References Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::cast(), Slic3r::TextConfiguration::fix_3mf_tr, Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::inverse(), Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::isApprox(), and Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::translate().

Here is the call graph for this function:

get_name()

static std::string_view Slic3r::TextConfigurationSerialization::get_name ( EmbossStyle::Type  type )

inlinestatic

                                                             {
            const auto& to_name = TextConfigurationSerialization::type_to_name.left;
            auto type_name = to_name.find(type);
            assert(type_name != to_name.end());
            if (type_name == to_name.end()) return "unknown type";
            return type_name->second;
        }

get_type()

static EmbossStyle::Type Slic3r::TextConfigurationSerialization::get_type ( std::string_view  type )

inlinestatic

                                                             {
            const auto& to_type = TextConfigurationSerialization::type_to_name.right;
            auto type_item = to_type.find(type);
            assert(type_item != to_type.end());
            if (type_item == to_type.end()) return EmbossStyle::Type::undefined;
            return type_item->second;        
        }

read()

std::optional< TextConfiguration > Slic3r::TextConfigurationSerialization::read ( const char **  attributes, unsigned int  num_attributes  )

static

{
    FontProp fp;
    int char_gap = get_attribute_value_int(attributes, num_attributes, CHAR_GAP_ATTR);
    if (char_gap != 0) fp.char_gap = char_gap;
    int line_gap = get_attribute_value_int(attributes, num_attributes, LINE_GAP_ATTR); 
    if (line_gap != 0) fp.line_gap = line_gap;
    float boldness = get_attribute_value_float(attributes, num_attributes, BOLDNESS_ATTR);
    if (std::fabs(boldness) > std::numeric_limits<float>::epsilon())
        fp.boldness = boldness;
    float skew = get_attribute_value_float(attributes, num_attributes, SKEW_ATTR);
    if (std::fabs(skew) > std::numeric_limits<float>::epsilon())
        fp.skew = skew;
    float distance = get_attribute_value_float(attributes, num_attributes, DISTANCE_ATTR);
    if (std::fabs(distance) > std::numeric_limits<float>::epsilon())
        fp.distance = distance;
    int use_surface = get_attribute_value_int(attributes, num_attributes, USE_SURFACE_ATTR);
    if (use_surface == 1) fp.use_surface = true;
    float angle = get_attribute_value_float(attributes, num_attributes, ANGLE_ATTR);
    if (std::fabs(angle) > std::numeric_limits<float>::epsilon())
        fp.angle = angle;
    int collection_number = get_attribute_value_int(attributes, num_attributes, COLLECTION_NUMBER_ATTR);
    if (collection_number > 0) fp.collection_number = static_cast<unsigned int>(collection_number);
 
    fp.size_in_mm = get_attribute_value_float(attributes, num_attributes, LINE_HEIGHT_ATTR);
    fp.emboss = get_attribute_value_float(attributes, num_attributes, DEPTH_ATTR);
 
    std::string family = get_attribute_value_string(attributes, num_attributes, FONT_FAMILY_ATTR);
    if (!family.empty()) fp.family = family;
    std::string face_name = get_attribute_value_string(attributes, num_attributes, FONT_FACE_NAME_ATTR);
    if (!face_name.empty()) fp.face_name = face_name;
    std::string style = get_attribute_value_string(attributes, num_attributes, FONT_STYLE_ATTR);
    if (!style.empty()) fp.style = style;
    std::string weight = get_attribute_value_string(attributes, num_attributes, FONT_WEIGHT_ATTR);
    if (!weight.empty()) fp.weight = weight;
 
    std::string style_name = get_attribute_value_string(attributes, num_attributes, STYLE_NAME_ATTR);
    std::string font_descriptor = get_attribute_value_string(attributes, num_attributes, FONT_DESCRIPTOR_ATTR);
    std::string type_str = get_attribute_value_string(attributes, num_attributes, FONT_DESCRIPTOR_TYPE_ATTR);
    EmbossStyle::Type type = TextConfigurationSerialization::get_type(type_str);
    EmbossStyle fi{ style_name, std::move(font_descriptor), type, std::move(fp) };
 
    std::string text = get_attribute_value_string(attributes, num_attributes, TEXT_DATA_ATTR);
 
    std::optional<Transform3d> fix_tr_mat;
    std::string fix_tr_mat_str = get_attribute_value_string(attributes, num_attributes, TRANSFORM_ATTR);
    if (!fix_tr_mat_str.empty()) { 
        fix_tr_mat = get_transform_from_3mf_specs_string(fix_tr_mat_str);
    }
 
    return TextConfiguration{std::move(fi), std::move(text), std::move(fix_tr_mat)};
}

References Slic3r::angle(), Slic3r::FontProp::angle, ANGLE_ATTR, Slic3r::FontProp::boldness, BOLDNESS_ATTR, Slic3r::FontProp::char_gap, CHAR_GAP_ATTR, Slic3r::FontProp::collection_number, COLLECTION_NUMBER_ATTR, DEPTH_ATTR, Slic3r::FontProp::distance, DISTANCE_ATTR, Slic3r::FontProp::emboss, Slic3r::FontProp::face_name, Slic3r::FontProp::family, FONT_DESCRIPTOR_ATTR, FONT_DESCRIPTOR_TYPE_ATTR, FONT_FACE_NAME_ATTR, FONT_FAMILY_ATTR, FONT_STYLE_ATTR, FONT_WEIGHT_ATTR, get_attribute_value_float(), get_attribute_value_int(), get_attribute_value_string(), get_transform_from_3mf_specs_string(), Slic3r::FontProp::line_gap, LINE_GAP_ATTR, LINE_HEIGHT_ATTR, Slic3r::FontProp::size_in_mm, Slic3r::FontProp::skew, SKEW_ATTR, Slic3r::FontProp::style, style, STYLE_NAME_ATTR, TEXT_DATA_ATTR, TRANSFORM_ATTR, Slic3r::FontProp::use_surface, USE_SURFACE_ATTR, and Slic3r::FontProp::weight.

Here is the call graph for this function:

to_xml()

void Slic3r::TextConfigurationSerialization::to_xml ( std::stringstream &  stream, const TextConfiguration &  tc  )

static

{
    stream << "   <" << TEXT_TAG << " ";
 
    stream << TEXT_DATA_ATTR << "=\"" << xml_escape_double_quotes_attribute_value(tc.text) << "\" ";
    // font item
    const EmbossStyle &fi = tc.style;
    stream << STYLE_NAME_ATTR <<  "=\"" << xml_escape_double_quotes_attribute_value(fi.name) << "\" ";
    stream << FONT_DESCRIPTOR_ATTR << "=\"" << xml_escape_double_quotes_attribute_value(fi.path) << "\" ";
    stream << FONT_DESCRIPTOR_TYPE_ATTR << "=\"" << TextConfigurationSerialization::get_name(fi.type) << "\" ";
 
    // font property
    const FontProp &fp = tc.style.prop;
    if (fp.char_gap.has_value())
        stream << CHAR_GAP_ATTR << "=\"" << *fp.char_gap << "\" ";
    if (fp.line_gap.has_value())
        stream << LINE_GAP_ATTR << "=\"" << *fp.line_gap << "\" ";
 
    stream << LINE_HEIGHT_ATTR << "=\"" << fp.size_in_mm << "\" ";
    stream << DEPTH_ATTR << "=\"" << fp.emboss << "\" ";
    if (fp.use_surface)
        stream << USE_SURFACE_ATTR << "=\"" << 1 << "\" ";
    if (fp.boldness.has_value())
        stream << BOLDNESS_ATTR << "=\"" << *fp.boldness << "\" ";
    if (fp.skew.has_value())
        stream << SKEW_ATTR << "=\"" << *fp.skew << "\" ";
    if (fp.distance.has_value())
        stream << DISTANCE_ATTR << "=\"" << *fp.distance << "\" ";
    if (fp.angle.has_value())
        stream << ANGLE_ATTR << "=\"" << *fp.angle << "\" ";
    if (fp.collection_number.has_value())
        stream << COLLECTION_NUMBER_ATTR << "=\"" << *fp.collection_number << "\" ";
    // font descriptor
    if (fp.family.has_value())
        stream << FONT_FAMILY_ATTR << "=\"" << *fp.family << "\" ";
    if (fp.face_name.has_value())
        stream << FONT_FACE_NAME_ATTR << "=\"" << *fp.face_name << "\" ";
    if (fp.style.has_value())
        stream << FONT_STYLE_ATTR << "=\"" << *fp.style << "\" ";
    if (fp.weight.has_value())
        stream << FONT_WEIGHT_ATTR << "=\"" << *fp.weight << "\" ";
 
    // FIX of baked transformation
    assert(tc.fix_3mf_tr.has_value());
    stream << TRANSFORM_ATTR << "=\"";
    _3MF_Exporter::add_transformation(stream, *tc.fix_3mf_tr);
    stream << "\" ";
 
    stream << "/>\n"; // end TEXT_TAG
}

References Slic3r::FontProp::angle, ANGLE_ATTR, Slic3r::FontProp::boldness, BOLDNESS_ATTR, Slic3r::FontProp::char_gap, CHAR_GAP_ATTR, Slic3r::FontProp::collection_number, COLLECTION_NUMBER_ATTR, DEPTH_ATTR, Slic3r::FontProp::distance, DISTANCE_ATTR, Slic3r::FontProp::emboss, Slic3r::FontProp::face_name, Slic3r::FontProp::family, Slic3r::TextConfiguration::fix_3mf_tr, FONT_DESCRIPTOR_ATTR, FONT_DESCRIPTOR_TYPE_ATTR, FONT_FACE_NAME_ATTR, FONT_FAMILY_ATTR, FONT_STYLE_ATTR, FONT_WEIGHT_ATTR, Slic3r::FontProp::line_gap, LINE_GAP_ATTR, LINE_HEIGHT_ATTR, Slic3r::EmbossStyle::name, Slic3r::EmbossStyle::path, Slic3r::EmbossStyle::prop, Slic3r::FontProp::size_in_mm, Slic3r::FontProp::skew, SKEW_ATTR, Slic3r::FontProp::style, Slic3r::TextConfiguration::style, STYLE_NAME_ATTR, Slic3r::TextConfiguration::text, TEXT_DATA_ATTR, TEXT_TAG, TRANSFORM_ATTR, Slic3r::EmbossStyle::type, Slic3r::FontProp::use_surface, USE_SURFACE_ATTR, Slic3r::FontProp::weight, and Slic3r::xml_escape_double_quotes_attribute_value().

Here is the call graph for this function:

Member Data Documentation

type_to_name

const TypeToName Slic3r::TextConfigurationSerialization::type_to_name

static

Initial value:

=
            boost::assign::list_of<TypeToName::relation>
    (EmbossStyle::Type::file_path, "file_name")
    (EmbossStyle::Type::wx_win_font_descr, "wxFontDescriptor_Windows")
    (EmbossStyle::Type::wx_lin_font_descr, "wxFontDescriptor_Linux")
    (EmbossStyle::Type::wx_mac_font_descr, "wxFontDescriptor_MacOsX")

---

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

• src/libslic3r/Format/3mf.cpp