Slic3r::Emboss Namespace Reference

class with only static function add ability to engraved OR raised text OR polygons onto model surface More...

Classes
struct	FontFile
	keep information from file about font (store file data itself) More...
struct	FontFileWithCache
	Add caching for shape of glyphs. More...
struct	Glyph
class	IProject3d
	Project spatial point. More...
class	IProjection
	Project 2d point into space Could be plane, sphere, cylindric, ... More...
class	OrthoProject
class	OrthoProject3d
class	ProjectScale
class	ProjectZ

Typedefs
using	Glyphs = std::map< int, Glyph >

Functions
EmbossStyles	get_font_list ()
	Collect fonts registred inside OS.
std::optional< std::wstring >	get_font_path (const std::wstring &font_face_name)
	OS dependent function to get location of font by its name descriptor.
std::unique_ptr< FontFile >	create_font_file (const char *file_path)
	Load font file into buffer.
std::unique_ptr< FontFile >	create_font_file (std::unique_ptr< std::vector< unsigned char > > data)
std::optional< Glyph >	letter2glyph (const FontFile &font, unsigned int font_index, int letter, float flatness)
	convert letter into polygons
ExPolygons	text2shapes (FontFileWithCache &font, const char *text, const FontProp &font_prop, std::function< bool()> was_canceled=nullptr)
	Convert text into polygons.
ExPolygons	heal_shape (const Polygons &shape)
	Fix duplicit points and self intersections in polygons. Also try to reduce amount of points and remove useless polygon parts.
bool	heal_shape (ExPolygons &shape, unsigned max_iteration=10)
	NOTE: call Slic3r::union_ex before this call.
bool	divide_segments_for_close_point (ExPolygons &expolygons, double distance)
	Divide line segments in place near to point (which could lead to self intersection due to preccision) Remove same neighbors Note: Possible part of heal shape.
void	apply_transformation (const FontProp &font_prop, Transform3d &transformation)
	Use data from font property to modify transformation.
void	apply_transformation (const std::optional< float > &angle, const std::optional< float > &distance, Transform3d &transformation)
bool	is_italic (const FontFile &font, unsigned int font_index)
	Read information from naming table of font file search for italic (or oblique), bold italic (or bold oblique)
std::string	create_range_text (const std::string &text, const FontFile &font, unsigned int font_index, bool *exist_unknown=nullptr)
	Create unique character set from string with filtered from text with only character from font.
double	get_shape_scale (const FontProp &fp, const FontFile &ff)
	Calculate scale for glyph shape convert from shape points to mm.
indexed_triangle_set	polygons2model (const ExPolygons &shape2d, const IProjection &projection)
	Create triangle model for text.
Vec3d	suggest_up (const Vec3d normal, double up_limit=0.9)
	Suggest wanted up vector of embossed text by emboss direction.
std::optional< float >	calc_up (const Transform3d &tr, double up_limit=0.9)
	By transformation calculate angle between suggested and actual up vector.
Transform3d	create_transformation_onto_surface (const Vec3d &position, const Vec3d &normal, double up_limit=0.9)
	Create transformation for emboss text object to lay on surface point.

Variables
static constexpr double	SHAPE_SCALE = 0.001

Detailed Description

class with only static function add ability to engraved OR raised text OR polygons onto model surface

---

Class Documentation

Slic3r::Emboss::Glyph

struct Slic3r::Emboss::Glyph

Collaboration diagram for Slic3r::Emboss::Glyph:

Class Members
int	advance_width =0
int	left_side_bearing =0
ExPolygons	shape

Typedef Documentation

Glyphs

using Slic3r::Emboss::Glyphs = typedef std::map<int, Glyph>

Function Documentation

apply_transformation() [1/2]

void Slic3r::Emboss::apply_transformation	(	const FontProp &	font_prop,
		Transform3d &	transformation
	)

Use data from font property to modify transformation.

Parameters

font_prop	Z-move as surface distance(FontProp::distance) Z-rotation as angle to Y axis(FontProp::angle)
transformation	In / Out transformation to modify by property

                                                                                       {
    apply_transformation(font_prop.angle, font_prop.distance, transformation);
}

References Slic3r::FontProp::angle, apply_transformation(), and Slic3r::FontProp::distance.

Referenced by apply_transformation(), Slic3r::GUI::on_mouse_surface_drag(), and priv::start_create_volume_on_surface_job().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_transformation() [2/2]

void Slic3r::Emboss::apply_transformation	(	const std::optional< float > &	angle,
		const std::optional< float > &	distance,
		Transform3d &	transformation
	)

                                                                                                                                  {
    if (angle.has_value()) {
        double angle_z = *angle;
        transformation *= Eigen::AngleAxisd(angle_z, Vec3d::UnitZ());
    }
    if (distance.has_value()) {
        Vec3d translate = Vec3d::UnitZ() * (*distance);
        transformation.translate(translate);
    }
}

References Slic3r::angle(), and Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::translate().

Here is the call graph for this function:

calc_up()

std::optional< float > Slic3r::Emboss::calc_up	(	const Transform3d &	tr,
		double	up_limit = 0.9
	)

By transformation calculate angle between suggested and actual up vector.

Parameters

tr	Transformation of embossed volume in world
up_limit	Is compared with normal.z to suggest up direction

Returns

Rotation of suggested up-vector[in rad] in the range [-Pi, Pi], When rotation is not zero

{
    auto tr_linear = tr.linear();
    // z base of transformation ( tr * UnitZ )
    Vec3d normal = tr_linear.col(2);
    // scaled matrix has base with different size
    normal.normalize();
    Vec3d suggested = suggest_up(normal);
    assert(is_approx(suggested.squaredNorm(), 1.));
 
    Vec3d up = tr_linear.col(1); // tr * UnitY()
    up.normalize();
    
    double dot = suggested.dot(up);
    if (dot >= 1. || dot <= -1.)
        return {}; // zero angle
 
    Matrix3d m;
    m.row(0) = up;
    m.row(1) = suggested;
    m.row(2) = normal;
    double det = m.determinant();
 
    return -atan2(det, dot);
}

References Slic3r::dot(), Slic3r::is_approx(), Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::linear(), and suggest_up().

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_advanced(), Slic3r::GUI::GLGizmoEmboss::on_mouse_for_translate(), Slic3r::GUI::on_mouse_surface_drag(), Slic3r::GUI::GLGizmoEmboss::on_stop_dragging(), and Slic3r::GUI::GLGizmoEmboss::set_volume_by_selection().

Here is the call graph for this function:

Here is the caller graph for this function:

create_font_file() [1/2]

std::unique_ptr< FontFile > Slic3r::Emboss::create_font_file

(

const char *

file_path

)

Load font file into buffer.

Parameters

file_path

Location of .ttf or .ttc font file

Returns

Font object when loaded.

{
    FILE *file = std::fopen(file_path, "rb");
    if (file == nullptr) {
        assert(false);
        BOOST_LOG_TRIVIAL(error) << "Couldn't open " << file_path << " for reading.";
        return nullptr;
    }
    ScopeGuard sg([&file]() { std::fclose(file); });
 
    // find size of file
    if (fseek(file, 0L, SEEK_END) != 0) {
        assert(false);
        BOOST_LOG_TRIVIAL(error) << "Couldn't fseek file " << file_path << " for size measure.";
        return nullptr;
    }
    size_t size = ftell(file);
    if (size == 0) {
        assert(false);
        BOOST_LOG_TRIVIAL(error) << "Size of font file is zero. Can't read.";
        return nullptr;    
    }
    rewind(file);
    auto buffer = std::make_unique<std::vector<unsigned char>>(size);
    size_t count_loaded_bytes = fread((void *) &buffer->front(), 1, size, file);
    if (count_loaded_bytes != size) {
        assert(false);
        BOOST_LOG_TRIVIAL(error) << "Different loaded(from file) data size.";
        return nullptr;
    }
    return create_font_file(std::move(buffer));
}

References create_font_file(), error, and L.

Referenced by create_font_file(), Slic3r::GUI::WxFontUtils::create_font_file(), and Slic3r::GUI::Emboss::StyleManager::load_style().

Here is the call graph for this function:

Here is the caller graph for this function:

create_font_file() [2/2]

std::unique_ptr< FontFile > Slic3r::Emboss::create_font_file

(

std::unique_ptr< std::vector< unsigned char > >

data

)

{
    int collection_size = stbtt_GetNumberOfFonts(data->data());
    // at least one font must be inside collection
    if (collection_size < 1) {
        assert(false);
        // There is no font collection inside font data
        return nullptr;
    }
 
    unsigned int c_size = static_cast<unsigned int>(collection_size);
    std::vector<FontFile::Info> infos;
    infos.reserve(c_size);
    for (unsigned int i = 0; i < c_size; ++i) {
        auto font_info = priv::load_font_info(data->data(), i);
        if (!font_info.has_value()) return nullptr;
 
        const stbtt_fontinfo *info = &(*font_info);
        // load information about line gap
        int ascent, descent, linegap;
        stbtt_GetFontVMetrics(info, &ascent, &descent, &linegap);
 
        float pixels       = 1000.; // value is irelevant
        float em_pixels    = stbtt_ScaleForMappingEmToPixels(info, pixels);
        int   units_per_em = static_cast<int>(std::round(pixels / em_pixels));
 
        infos.emplace_back(FontFile::Info{ascent, descent, linegap, units_per_em});
    }
    return std::make_unique<FontFile>(std::move(data), std::move(infos));
}

References priv::load_font_info(), stbtt_GetFontVMetrics(), stbtt_GetNumberOfFonts(), and stbtt_ScaleForMappingEmToPixels().

Here is the call graph for this function:

create_range_text()

std::string Slic3r::Emboss::create_range_text	(	const std::string &	text,
		const FontFile &	font,
		unsigned int	font_index,
		bool *	exist_unknown = nullptr
	)

Create unique character set from string with filtered from text with only character from font.

Parameters

text	Source vector of glyphs
font	Font descriptor
font_index	Define font in collection
exist_unknown	True when text contain glyph unknown in font

Returns

Unique set of character from text contained in font

{
    if (!priv::is_valid(font, font_index)) return {};
            
    std::wstring ws = boost::nowide::widen(text);
 
    // need remove symbols not contained in font
    std::sort(ws.begin(), ws.end());
 
    auto font_info_opt = priv::load_font_info(font.data->data(), 0);
    if (!font_info_opt.has_value()) return {};
    const stbtt_fontinfo *font_info = &(*font_info_opt);
 
    if (exist_unknown != nullptr) *exist_unknown = false;
    int prev_unicode = -1;
    ws.erase(std::remove_if(ws.begin(), ws.end(),
        [&prev_unicode, font_info, exist_unknown](wchar_t wc) -> bool {
            int unicode = static_cast<int>(wc);
 
            // skip white spaces
            if (unicode == '\n' || 
                unicode == '\r' || 
                unicode == '\t') return true;
 
            // is duplicit?
            if (prev_unicode == unicode) return true;
            prev_unicode = unicode;
 
            // can find in font?
            bool is_unknown = !stbtt_FindGlyphIndex(font_info, unicode);
            if (is_unknown && exist_unknown != nullptr)
                *exist_unknown = true;
            return is_unknown;
        }), ws.end());
 
    return boost::nowide::narrow(ws);
}

References Slic3r::Emboss::FontFile::data, priv::is_valid(), priv::load_font_info(), boost::nowide::narrow(), and boost::nowide::widen().

Referenced by Slic3r::GUI::GLGizmoEmboss::draw_text_input().

Here is the call graph for this function:

Here is the caller graph for this function:

create_transformation_onto_surface()

Transform3d Slic3r::Emboss::create_transformation_onto_surface	(	const Vec3d &	position,
		const Vec3d &	normal,
		double	up_limit = 0.9
	)

Create transformation for emboss text object to lay on surface point.

Parameters

position	Position of surface point
normal	Normal of surface point
up_limit	Is compared with normal.z to suggest up direction

Returns

Transformation onto surface point

{
    // is normalized ?
    assert(is_approx(normal.squaredNorm(), 1.));
 
    // up and emboss direction for generated model
    Vec3d up_dir     = Vec3d::UnitY();
    Vec3d emboss_dir = Vec3d::UnitZ();
 
    // after cast from float it needs to be normalized again
    Vec3d wanted_up_dir = suggest_up(normal, up_limit);
 
    // perpendicular to emboss vector of text and normal
    Vec3d axis_view;
    double angle_view;
    if (normal == -Vec3d::UnitZ()) {
        // text_emboss_dir has opposit direction to wanted_emboss_dir
        axis_view = Vec3d::UnitY();
        angle_view = M_PI;
    } else {
        axis_view = emboss_dir.cross(normal);
        angle_view = std::acos(emboss_dir.dot(normal)); // in rad
        axis_view.normalize();
    }
 
    Eigen::AngleAxis view_rot(angle_view, axis_view);
    Vec3d wanterd_up_rotated = view_rot.matrix().inverse() * wanted_up_dir;
    wanterd_up_rotated.normalize();
    double angle_up = std::acos(up_dir.dot(wanterd_up_rotated));
 
    Vec3d text_view = up_dir.cross(wanterd_up_rotated);
    Vec3d diff_view  = emboss_dir - text_view;
    if (std::fabs(diff_view.x()) > 1. ||
        std::fabs(diff_view.y()) > 1. ||
        std::fabs(diff_view.z()) > 1.) // oposit direction
        angle_up *= -1.;
 
    Eigen::AngleAxis up_rot(angle_up, emboss_dir);
 
    Transform3d transform = Transform3d::Identity();
    transform.translate(position);
    transform.rotate(view_rot);
    transform.rotate(up_rot);
    return transform;
}

References Eigen::Transform< double, 3, Eigen::Affine, Eigen::DontAlign >::Identity(), Slic3r::is_approx(), M_PI, Eigen::RotationBase< Derived, _Dim >::matrix(), suggest_up(), and Slic3r::transform().

Referenced by priv::start_create_volume_on_surface_job().

Here is the call graph for this function:

Here is the caller graph for this function:

divide_segments_for_close_point()

bool Slic3r::Emboss::divide_segments_for_close_point	(	ExPolygons &	expolygons,
		double	distance
	)

Divide line segments in place near to point (which could lead to self intersection due to preccision) Remove same neighbors Note: Possible part of heal shape.

Parameters

expolygons	Expolygon to edit
distance	(epsilon)Euclidean distance from point to line which divide line

Returns

True when some division was made otherwise false

{
    if (expolygons.empty()) return false;
    if (distance < 0.) return false;
 
    // ExPolygons can't contain same neigbours
    priv::remove_same_neighbor(expolygons);
 
    // IMPROVE: use int(insted of double) lines and tree
    const ExPolygonsIndices ids(expolygons);
    const std::vector<Linef> lines = Slic3r::to_linesf(expolygons, ids.get_count());
    AABBTreeIndirect::Tree<2, double> tree = AABBTreeLines::build_aabb_tree_over_indexed_lines(lines);
    using Div = std::pair<Point, size_t>;
    std::vector<Div> divs;
    size_t point_index = 0;
    auto check_points = [&divs, &point_index, &lines, &tree, &distance, &ids, &expolygons](const Points &pts) {
        for (const Point &p : pts) {
            Vec2d p_d = p.cast<double>();
            std::vector<size_t> close_lines = AABBTreeLines::all_lines_in_radius(lines, tree, p_d, distance);
            for (size_t index : close_lines) {
                // skip point neighbour lines indices
                if (index == point_index) continue;
                if (&p != &pts.front()) { 
                    if (index == point_index - 1) continue;
                } else if (index == (pts.size()-1)) continue;
 
                // do not doubled side point of segment
                const ExPolygonsIndex id = ids.cvt(index);
                const ExPolygon &expoly = expolygons[id.expolygons_index];
                const Polygon &poly = id.is_contour() ? expoly.contour : expoly.holes[id.hole_index()];
                const Points &poly_pts = poly.points;
                const Point &line_a = poly_pts[id.point_index];
                const Point &line_b = (!ids.is_last_point(id)) ? poly_pts[id.point_index + 1] : poly_pts.front();
                assert(line_a == lines[index].a.cast<int>());
                assert(line_b == lines[index].b.cast<int>());
                if (p == line_a || p == line_b) continue;
 
                divs.emplace_back(p, index);
            }
            ++point_index;
        }
    };
    for (const ExPolygon &expoly : expolygons) { 
        check_points(expoly.contour.points);
        for (const Polygon &hole : expoly.holes) 
            check_points(hole.points);
    }
 
    // check if exist division
    if (divs.empty()) return false;
 
    // sort from biggest index to zero
    // to be able add points and not interupt indices
    std::sort(divs.begin(), divs.end(), 
        [](const Div &d1, const Div &d2) { return d1.second > d2.second; });
    
    auto it = divs.begin();
    // divide close line
    while (it != divs.end()) {
        // colect division of a line segmen
        size_t index = it->second;
        auto it2 = it+1;
        while (it2 != divs.end() && it2->second == index) ++it2;
 
        ExPolygonsIndex id = ids.cvt(index);
        ExPolygon &expoly = expolygons[id.expolygons_index];
        Polygon &poly = id.is_contour() ? expoly.contour : expoly.holes[id.hole_index()];
        Points &pts = poly.points;        
        size_t count = it2 - it;
 
        // add points into polygon to divide in place of near point
        if (count == 1) {
            pts.insert(pts.begin() + id.point_index + 1, it->first);
            ++it;
        } else {
            // collect points to add into polygon
            Points points;
            points.reserve(count);
            for (; it < it2; ++it) 
                points.push_back(it->first);            
 
            // need sort by line direction
            const Linef &line = lines[index];
            Vec2d        dir  = line.b - line.a;
            // select mayorit direction
            int axis  = (abs(dir.x()) > abs(dir.y())) ? 0 : 1;
            using Fnc = std::function<bool(const Point &, const Point &)>;
            Fnc fnc   = (dir[axis] < 0) ? Fnc([axis](const Point &p1, const Point &p2) { return p1[axis] > p2[axis]; }) :
                                          Fnc([axis](const Point &p1, const Point &p2) { return p1[axis] < p2[axis]; }) ;
            std::sort(points.begin(), points.end(), fnc);
 
            // use only unique points
            points.erase(std::unique(points.begin(), points.end()), points.end());
 
            // divide line by adding points into polygon
            pts.insert(pts.begin() + id.point_index + 1,
                points.begin(), points.end());
        }
        assert(it == it2);
    }
    return true;
}

References Slic3r::Linef::a, Slic3r::AABBTreeLines::all_lines_in_radius(), Slic3r::Linef::b, Slic3r::AABBTreeLines::build_aabb_tree_over_indexed_lines(), Slic3r::ExPolygon::contour, Slic3r::ExPolygonsIndices::cvt(), Slic3r::ExPolygonsIndices::get_count(), Slic3r::ExPolygon::holes, Slic3r::ExPolygonsIndices::is_last_point(), Slic3r::MultiPoint::points, priv::remove_same_neighbor(), and Slic3r::to_linesf().

Here is the call graph for this function:

get_font_list()

EmbossStyles Slic3r::Emboss::get_font_list

(

)

Collect fonts registred inside OS.

Returns

OS registred TTF font files(full path) with names

                                   { 
    // not implemented
    return {}; 
}

get_font_path()

std::optional< std::wstring > Slic3r::Emboss::get_font_path

(

const std::wstring &

font_face_name

)

OS dependent function to get location of font by its name descriptor.

Parameters

font_face_name

Unique identificator for font

Returns

File path to font when found

                                                                             {
    // not implemented
    return {};
}

get_shape_scale()

double Slic3r::Emboss::get_shape_scale	(	const FontProp &	fp,
		const FontFile &	ff
	)

Calculate scale for glyph shape convert from shape points to mm.

Parameters

fp	Property of font
ff	Font data

Returns

Conversion to mm

{
    size_t font_index  = fp.collection_number.value_or(0);
    const FontFile::Info &info = ff.infos[font_index];
    double scale  = fp.size_in_mm / (double) info.unit_per_em;
    // Shape is scaled for store point coordinate as integer
    return scale * SHAPE_SCALE;
}

References Slic3r::FontProp::collection_number, Slic3r::Emboss::FontFile::infos, scale(), SHAPE_SCALE, Slic3r::FontProp::size_in_mm, and Slic3r::Emboss::FontFile::Info::unit_per_em.

Referenced by priv::cut_surface().

Here is the call graph for this function:

Here is the caller graph for this function:

heal_shape() [1/2]

ExPolygons Slic3r::Emboss::heal_shape

(

const Polygons &

shape

)

Fix duplicit points and self intersections in polygons. Also try to reduce amount of points and remove useless polygon parts.

Parameters

precision

Define wanted precision of shape after heal

Returns

Healed shapes

{
    // When edit this code check that font 'ALIENATE.TTF' and glyph 'i' still work
    // fix of self intersections
    // http://www.angusj.com/delphi/clipper/documentation/Docs/Units/ClipperLib/Functions/SimplifyPolygon.htm
    ClipperLib::Paths paths = ClipperLib::SimplifyPolygons(ClipperUtils::PolygonsProvider(shape), ClipperLib::pftNonZero);
    const double clean_distance = 1.415; // little grater than sqrt(2)
    ClipperLib::CleanPolygons(paths, clean_distance);
    Polygons polygons = to_polygons(paths);
    polygons.erase(std::remove_if(polygons.begin(), polygons.end(), [](const Polygon &p) { return p.size() < 3; }), polygons.end());
                
    // Do not remove all duplicates but do it better way
    // Overlap all duplicit points by rectangle 3x3
    Points duplicits = collect_duplicates(to_points(polygons));
    if (!duplicits.empty()) {
        polygons.reserve(polygons.size() + duplicits.size());
        for (const Point &p : duplicits) {
            Polygon rect_3x3(priv::pts_3x3);
            rect_3x3.translate(p);
            polygons.push_back(rect_3x3);
        }
    }
 
    // TrueTypeFonts use non zero winding number
    // https://docs.microsoft.com/en-us/typography/opentype/spec/ttch01
    // https://developer.apple.com/fonts/TrueType-Reference-Manual/RM01/Chap1.html
    ExPolygons res = Slic3r::union_ex(polygons, ClipperLib::pftNonZero);        
    heal_shape(res);
    return res;
}

References ClipperLib::CleanPolygons(), Slic3r::collect_duplicates(), heal_shape(), ClipperLib::pftNonZero, priv::pts_3x3(), ClipperLib::SimplifyPolygons(), Slic3r::to_points(), Slic3r::to_polygons(), Slic3r::MultiPoint::translate(), and Slic3r::union_ex().

Referenced by priv::get_glyph(), heal_shape(), and text2shapes().

Here is the call graph for this function:

Here is the caller graph for this function:

heal_shape() [2/2]

bool Slic3r::Emboss::heal_shape	(	ExPolygons &	shape,
		unsigned	max_iteration = 10
	)

NOTE: call Slic3r::union_ex before this call.

Heal (read: Fix) issues in expolygons:

• self intersections
• duplicit points
• points close to line segments

Parameters

shape	In/Out shape to heal
max_iteration	Heal could create another issue, After healing it is checked again until shape is good or maximal count of iteration

Returns

True when shapes is good otherwise False

{
    return priv::heal_dupl_inter(shape, max_iteration);  
}

References priv::heal_dupl_inter().

Here is the call graph for this function:

is_italic()

bool Slic3r::Emboss::is_italic	(	const FontFile &	font,
		unsigned int	font_index
	)

Read information from naming table of font file search for italic (or oblique), bold italic (or bold oblique)

Parameters

font	Selector of font
font_index	Index of font in collection

Returns

True when the font description contains italic/obligue otherwise False

{
    if (font_index >= font.infos.size()) return false;
    fontinfo_opt font_info_opt = priv::load_font_info(font.data->data(), font_index);
 
    if (!font_info_opt.has_value()) return false;
    stbtt_fontinfo *info = &(*font_info_opt);
 
    // https://docs.microsoft.com/cs-cz/typography/opentype/spec/name
    // https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6name.html
    // 2 ==> Style / Subfamily name
    int name_id = 2;
    int length;
    const char* value = stbtt_GetFontNameString(info, &length,
                                               STBTT_PLATFORM_ID_MICROSOFT,
                                               STBTT_MS_EID_UNICODE_BMP,
                                               STBTT_MS_LANG_ENGLISH,                            
                                               name_id);
 
    // value is big endian utf-16 i need extract only normal chars
    std::string value_str;
    value_str.reserve(length / 2);
    for (int i = 1; i < length; i += 2)
        value_str.push_back(value[i]);
 
    // lower case
    std::transform(value_str.begin(), value_str.end(), value_str.begin(),
                   [](unsigned char c) { return std::tolower(c); });
 
    const std::vector<std::string> italics({"italic", "oblique"});
    for (const std::string &it : italics) { 
        if (value_str.find(it) != std::string::npos) { 
            return true; 
        }
    }
    return false; 
}

References Slic3r::Emboss::FontFile::data, Slic3r::Emboss::FontFile::infos, Slic3r::length(), priv::load_font_info(), stbtt_GetFontNameString(), STBTT_MS_EID_UNICODE_BMP, STBTT_MS_LANG_ENGLISH, and STBTT_PLATFORM_ID_MICROSOFT.

Referenced by Slic3r::GUI::Emboss::StyleManager::is_font_changed().

Here is the call graph for this function:

Here is the caller graph for this function:

letter2glyph()

std::optional< Glyph > Slic3r::Emboss::letter2glyph	(	const FontFile &	font,
		unsigned int	font_index,
		int	letter,
		float	flatness
	)

convert letter into polygons

Parameters

font	Define fonts
font_index	Index of font in collection
letter	One character defined by unicode codepoint
flatness	Precision of lettter outline curve in conversion to lines

Returns

inner polygon cw(outer ccw)

{
    if (!priv::is_valid(font, font_index)) return {};
    auto font_info_opt = priv::load_font_info(font.data->data(), font_index);
    if (!font_info_opt.has_value()) return {};
    return priv::get_glyph(*font_info_opt, letter, flatness);
}

References Slic3r::Emboss::FontFile::data, priv::get_glyph(), priv::is_valid(), and priv::load_font_info().

Here is the call graph for this function:

polygons2model()

indexed_triangle_set Slic3r::Emboss::polygons2model	(	const ExPolygons &	shape2d,
		const IProjection &	projection
	)

Create triangle model for text.

Parameters

shape2d	text or image
projection	Define transformation from 2d to 3d(orientation, position, scale, ...)

Returns

Projected shape into space

{
    Points points = to_points(shape2d);    
    Points duplicits = collect_duplicates(points);
    return (duplicits.empty()) ?
        priv::polygons2model_unique(shape2d, projection, points) :
        priv::polygons2model_duplicit(shape2d, projection, points, duplicits);
}

References Slic3r::collect_duplicates(), priv::polygons2model_duplicit(), priv::polygons2model_unique(), and Slic3r::to_points().

Here is the call graph for this function:

suggest_up()

Vec3d Slic3r::Emboss::suggest_up	(	const Vec3d	normal,
		double	up_limit = 0.9
	)

Suggest wanted up vector of embossed text by emboss direction.

Parameters

normal	Normalized vector of emboss direction in world
up_limit	Is compared with normal.z to suggest up direction

Returns

Wanted up vector

{
    // Normal must be 1
    assert(is_approx(normal.squaredNorm(), 1.));
 
    // wanted up direction of result
    Vec3d wanted_up_side = 
        (std::fabs(normal.z()) > up_limit)?
        Vec3d::UnitY() : Vec3d::UnitZ();
 
    // create perpendicular unit vector to surface triangle normal vector
    // lay on surface of triangle and define up vector for text
    Vec3d wanted_up_dir = normal.cross(wanted_up_side).cross(normal);
    // normal3d is NOT perpendicular to normal_up_dir
    wanted_up_dir.normalize();
 
    return wanted_up_dir;
}

References Slic3r::is_approx().

Referenced by calc_up(), create_transformation_onto_surface(), and Slic3r::GUI::on_mouse_surface_drag().

Here is the call graph for this function:

Here is the caller graph for this function:

text2shapes()

ExPolygons Slic3r::Emboss::text2shapes	(	FontFileWithCache &	font,
		const char *	text,
		const FontProp &	font_prop,
		std::function< bool()>	was_canceled = nullptr
	)

Convert text into polygons.

Parameters

font	Define fonts + cache, which could extend
text	Characters to convert
font_prop	User defined property of the font
was_canceled	Way to interupt processing

Returns

Inner polygon cw(outer ccw)

{
    assert(font_with_cache.has_value());
    fontinfo_opt font_info_opt;    
    Point    cursor(0, 0);
    ExPolygons result;
    const FontFile& font = *font_with_cache.font_file;
    unsigned int font_index = font_prop.collection_number.has_value()?
        *font_prop.collection_number : 0;
    if (!priv::is_valid(font, font_index)) return {};
    const FontFile::Info& info = font.infos[font_index];
    Glyphs& cache = *font_with_cache.cache;
    std::wstring ws = boost::nowide::widen(text);
    for (wchar_t wc: ws){
        if (wc == '\n') { 
            int line_height = info.ascent - info.descent + info.linegap;
            if (font_prop.line_gap.has_value())
                line_height += *font_prop.line_gap;
            line_height = static_cast<int>(line_height / SHAPE_SCALE);
 
            cursor.x() = 0;
            cursor.y() -= line_height;
            continue;
        } 
        if (wc == '\t') {
            // '\t' = 4*space => same as imgui
            const int count_spaces = 4;
            const Glyph* space = priv::get_glyph(int(' '), font, font_prop, cache, font_info_opt);
            if (space == nullptr) continue;
            cursor.x() += count_spaces * space->advance_width;
            continue;
        }
        if (wc == '\r') continue;
 
        int unicode = static_cast<int>(wc);
        // check cancelation only before unknown symbol - loading of symbol could be timeconsuming on slow computer and dificult fonts
        auto it = cache.find(unicode);
        if (it == cache.end() && was_canceled != nullptr && was_canceled()) return {};
        const Glyph *glyph_ptr = (it != cache.end())? &it->second :
            priv::get_glyph(unicode, font, font_prop, cache, font_info_opt);
        if (glyph_ptr == nullptr) continue;
        
        // move glyph to cursor position
        ExPolygons expolygons = glyph_ptr->shape; // copy
        for (ExPolygon &expolygon : expolygons) 
            expolygon.translate(cursor);
 
        cursor.x() += glyph_ptr->advance_width;
        expolygons_append(result, std::move(expolygons));
    }
    result = Slic3r::union_ex(result);
    heal_shape(result);
    return result;
}

References Slic3r::Emboss::Glyph::advance_width, Slic3r::Emboss::FontFile::Info::ascent, Slic3r::Emboss::FontFileWithCache::cache, Slic3r::FontProp::collection_number, Slic3r::Emboss::FontFile::Info::descent, Slic3r::expolygons_append(), Slic3r::Emboss::FontFileWithCache::font_file, priv::get_glyph(), Slic3r::Emboss::FontFileWithCache::has_value(), heal_shape(), Slic3r::Emboss::FontFile::infos, priv::is_valid(), Slic3r::FontProp::line_gap, Slic3r::Emboss::FontFile::Info::linegap, Slic3r::Emboss::Glyph::shape, SHAPE_SCALE, Slic3r::union_ex(), and boost::nowide::widen().

Referenced by Slic3r::GUI::CreateFontImageJob::process(), and Slic3r::GUI::Emboss::CreateFontStyleImagesJob::process().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

SHAPE_SCALE

constexpr double Slic3r::Emboss::SHAPE_SCALE = 0.001

staticconstexpr

Referenced by Slic3r::Emboss::ProjectZ::create_front_back(), priv::get_glyph(), get_shape_scale(), Slic3r::GUI::Emboss::CreateFontStyleImagesJob::process(), priv::remove_spikes_in_duplicates(), priv::select_patches(), text2shapes(), priv::to_point(), Slic3r::Emboss::ProjectZ::unproject(), and priv::visualize_heal().