Slic3r::Emboss Namespace Reference

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

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

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

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
HealedExPolygons	text2shapes (FontFileWithCache &font, const char *text, const FontProp &font_prop, const std::function< bool()> &was_canceled=[]() {return false;})
	Convert text into polygons.
ExPolygonsWithIds	text2vshapes (FontFileWithCache &font, const std::wstring &text, const FontProp &font_prop, const std::function< bool()> &was_canceled=[]() {return false;})
unsigned	get_count_lines (const std::wstring &ws)
	Sum of character ' '.
unsigned	get_count_lines (const std::string &text)
unsigned	get_count_lines (const ExPolygonsWithIds &shape)
HealedExPolygons	heal_polygons (const Polygons &shape, bool is_non_zero=true, unsigned max_iteration=10)
	Fix duplicit points and self intersections in polygons. Also try to reduce amount of points and remove useless polygon parts.
bool	heal_expolygons (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 std::optional< float > &angle, const std::optional< float > &distance, Transform3d &transformation)
	Use data from font property to modify 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_text_shape_scale (const FontProp &fp, const FontFile &ff)
	Calculate scale for glyph shape convert from shape points to mm.
const FontFile::Info &	get_font_info (const FontFile &font, const FontProp &prop)
	getter of font info by collection defined in prop
int	get_line_height (const FontFile &font, const FontProp &prop)
	Read from font file and properties height of line with spacing.
double	get_align_y_offset_in_mm (FontProp::VerticalAlign align, unsigned count_lines, const FontFile &ff, const FontProp &fp)
	Calculate Vertical align.
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.
PolygonPoints	sample_slice (const TextLine &slice, const BoundingBoxes &bbs, double scale)
	Sample slice polygon by bounding boxes centers slice start point has shape_center_x coor.
double	calculate_angle (int32_t distance, PolygonPoint polygon_point, const Polygon &polygon)
	Calculate angle for polygon point.
std::vector< double >	calculate_angles (int32_t distance, const PolygonPoints &polygon_points, const Polygon &polygon)

Variables
static const float	UNION_DELTA = 50.0f
static const unsigned	UNION_MAX_ITERATIN = 10
const unsigned	ENTER_UNICODE = static_cast<unsigned>('\n')

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

Slic3r::Emboss::TextLine

struct Slic3r::Emboss::TextLine

Define polygon for draw letters.

Collaboration diagram for Slic3r::Emboss::TextLine:

Class Members
Polygon	polygon
PolygonPoint	start
float	y

Typedef Documentation

Glyphs

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

TextLines

using Slic3r::Emboss::TextLines = std::vector<TextLine>

Function Documentation

apply_transformation()

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

Use data from font property to modify transformation.

Parameters

angle	Z-rotation as angle to Y axis
distance	Z-move as surface distance
transformation	In / Out transformation to modify by property

                                                                                                                                  {
    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 Slic3r::translate().

Referenced by anonymous_namespace{SurfaceDrag.cpp}::get_volume_transformation(), anonymous_namespace{EmbossJob.cpp}::CreateObjectJob::process(), and anonymous_namespace{EmbossJob.cpp}::start_create_volume_on_surface_job().

Here is the call graph for this function:

Here is the caller 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().eval();
    // 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, up_limit);
    assert(is_approx(suggested.squaredNorm(), 1.));
 
    Vec3d up = tr_linear.col(1); // tr * UnitY()
    up.normalize();    
    Matrix3d m;
    m.row(0) = up;
    m.row(1) = suggested;
    m.row(2) = normal;
    double det = m.determinant();
    double dot = suggested.dot(up);
    double res = -atan2(det, dot);
    if (is_approx(res, 0.))
        return {};
    return res;
}

References Slic3r::dot(), Slic3r::is_approx(), Slic3r::normal(), and suggest_up().

Referenced by Slic3r::GUI::calc_angle(), Slic3r::GUI::face_selected_volume_to_camera(), and anonymous_namespace{SurfaceDrag.cpp}::start_dragging().

Here is the call graph for this function:

Here is the caller graph for this function:

calculate_angle()

double Slic3r::Emboss::calculate_angle	(	int32_t	distance,
		PolygonPoint	polygon_point,
		const Polygon &	polygon )

Calculate angle for polygon point.

Parameters

distance	Distance for found normal in point
polygon_point	Select point on polygon
polygon	Polygon know neighbor of point

Returns

angle(atan2) of normal in polygon point

{
    PolygonPoint polygon_point2 = polygon_point; // copy
    point_in_distance(distance, polygon_point, polygon);
    point_in_reverse_distance(distance, polygon_point2, polygon);
 
    Point surface_dir = polygon_point2.point - polygon_point.point;
    Point norm(-surface_dir.y(), surface_dir.x());
    Vec2d norm_d = norm.cast<double>();
    //norm_d.normalize();
    return std::atan2(norm_d.y(), norm_d.x());
}

References Slic3r::PolygonPoint::point.

Referenced by calculate_angles().

Here is the caller graph for this function:

calculate_angles()

std::vector< double > Slic3r::Emboss::calculate_angles	(	int32_t	distance,
		const PolygonPoints &	polygon_points,
		const Polygon &	polygon )

{
    std::vector<double> result;
    result.reserve(polygon_points.size());
    for(const PolygonPoint& pp: polygon_points)
        result.emplace_back(calculate_angle(distance, pp, polygon));
    return result;
}

References calculate_angle().

Referenced by anonymous_namespace{EmbossJob.cpp}::create_mesh_per_glyph(), and anonymous_namespace{EmbossJob.cpp}::cut_per_glyph_surface().

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(), and L.

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

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 = 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 anonymous_namespace{Emboss.cpp}::load_font_info().

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 (!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 = 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, anonymous_namespace{Emboss.cpp}::is_valid(), and anonymous_namespace{Emboss.cpp}::load_font_info().

Referenced by anonymous_namespace{GLGizmoEmboss.cpp}::can_write(), and 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 Slic3r::is_approx(), M_PI, Slic3r::normal(), suggest_up(), and Slic3r::transform().

Referenced by anonymous_namespace{EmbossJob.cpp}::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
    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<coord_t>());
                assert(line_b == lines[index].b.cast<coord_t>());
                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, count, Slic3r::ExPolygonsIndices::cvt(), Slic3r::ExPolygonsIndices::get_count(), Slic3r::ExPolygon::holes, Slic3r::ExPolygonsIndices::is_last_point(), Slic3r::MultiPoint::points, Slic3r::remove_same_neighbor(), and Slic3r::to_linesf().

Here is the call graph for this function:

get_align_y_offset_in_mm()

double Slic3r::Emboss::get_align_y_offset_in_mm	(	FontProp::VerticalAlign	align,
		unsigned	count_lines,
		const FontFile &	ff,
		const FontProp &	fp )

Calculate Vertical align.

Parameters

align	Top | Center | Bottom
count_lines

Returns

Return align Y offset in mm

                                                                                                                                {
    float offset_in_font_point = get_align_y_offset(align, count_lines, ff, fp);
    double scale = get_text_shape_scale(fp, ff);
    return scale * offset_in_font_point;
}

References get_text_shape_scale(), and scale().

Referenced by Slic3r::GUI::TextLinesModel::init().

Here is the call graph for this function:

Here is the caller graph for this function:

get_count_lines() [1/3]

unsigned Slic3r::Emboss::get_count_lines

(

const ExPolygonsWithIds &

shape

)

                                                                {
    if (shapes.empty())
        return 0; // no glyphs
    unsigned result = 1; // one line is minimum
    for (const ExPolygonsWithId &shape_id : shapes)
        if (shape_id.id == ENTER_UNICODE)
            ++result;
    return result;
}

References ENTER_UNICODE.

get_count_lines() [2/3]

unsigned Slic3r::Emboss::get_count_lines

(

const std::string &

text

)

{
    std::wstring ws = boost::nowide::widen(text.c_str());
    return get_count_lines(ws);
}

References get_count_lines().

Here is the call graph for this function:

get_count_lines() [3/3]

unsigned Slic3r::Emboss::get_count_lines

(

const std::wstring &

ws

)

Sum of character '
'.

{
    if (ws.empty())
        return 0;
 
    unsigned count = 1;
    for (wchar_t wc : ws)
        if (wc == '\n')
            ++count;
    return count;
 
    // unsigned prev_count = 0;
    // for (wchar_t wc : ws)
    //     if (wc == '\n')
    //         ++prev_count;
    //     else
    //         break;
    //
    // unsigned post_count = 0;
    // for (wchar_t wc : boost::adaptors::reverse(ws))
    //     if (wc == '\n')
    //         ++post_count;
    //     else
    //         break;
    //return count - prev_count - post_count;
}

References count.

Referenced by anonymous_namespace{Emboss.cpp}::align_shape(), anonymous_namespace{EmbossJob.cpp}::create_line_bounds(), anonymous_namespace{EmbossJob.cpp}::create_mesh_per_glyph(), anonymous_namespace{EmbossJob.cpp}::cut_per_glyph_surface(), Slic3r::GUI::GLGizmoEmboss::draw_advanced(), Slic3r::GUI::GLGizmoEmboss::draw_text_input(), get_count_lines(), anonymous_namespace{GLGizmoEmboss.cpp}::init_text_lines(), and Slic3r::GUI::GLGizmoEmboss::process().

Here is the caller graph for this function:

get_font_info()

const FontFile::Info & Slic3r::Emboss::get_font_info	(	const FontFile &	font,
		const FontProp &	prop )

getter of font info by collection defined in prop

Parameters

font	Contain infos about all fonts(collections) in file
prop	Index of collection

Returns

Ascent, descent, line gap

{
    unsigned int font_index = prop.collection_number.value_or(0);
    assert(is_valid(font, font_index));
    return font.infos[font_index];
}

References Slic3r::FontProp::collection_number, Slic3r::Emboss::FontFile::infos, and anonymous_namespace{Emboss.cpp}::is_valid().

Referenced by Slic3r::GUI::Emboss::StyleManager::create_imgui_font(), Slic3r::GUI::GLGizmoEmboss::draw_advanced(), anonymous_namespace{Emboss.cpp}::get_align_y_offset(), Slic3r::GUI::Emboss::StyleManager::get_imgui_font_size(), get_line_height(), and get_text_shape_scale().

Here is the call graph for this function:

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

int Slic3r::Emboss::get_line_height	(	const FontFile &	font,
		const FontProp &	prop )

Read from font file and properties height of line with spacing.

Parameters

font	Infos for collections
prop	Collection index + Additional line gap

Returns

Line height with spacing in scaled font points (same as ExPolygons)

                                                                      {
    const FontFile::Info &info = get_font_info(font, prop);
    int line_height = info.ascent - info.descent + info.linegap;
    line_height += prop.line_gap.value_or(0);
    return static_cast<int>(line_height / SHAPE_SCALE);
}

References Slic3r::Emboss::FontFile::Info::ascent, Slic3r::Emboss::FontFile::Info::descent, get_font_info(), Slic3r::FontProp::line_gap, Slic3r::Emboss::FontFile::Info::linegap, and SHAPE_SCALE.

Referenced by Slic3r::GUI::TextLinesModel::calc_line_height_in_mm(), anonymous_namespace{Emboss.cpp}::get_align_y_offset(), and anonymous_namespace{Emboss.cpp}::letter2shapes().

Here is the call graph for this function:

Here is the caller graph for this function:

get_text_shape_scale()

double Slic3r::Emboss::get_text_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

{
    const FontFile::Info &info = get_font_info(ff, fp);
    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 get_font_info(), scale(), SHAPE_SCALE, Slic3r::FontProp::size_in_mm, and Slic3r::Emboss::FontFile::Info::unit_per_em.

Referenced by anonymous_namespace{GLGizmoEmboss.cpp}::TextDataBase::TextDataBase(), Slic3r::GUI::TextLinesModel::calc_line_height_in_mm(), get_align_y_offset_in_mm(), and Slic3r::text_to_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

heal_expolygons()

bool Slic3r::Emboss::heal_expolygons	(	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 ::heal_dupl_inter(shape, max_iteration);
}

Referenced by anonymous_namespace{Emboss.cpp}::union_with_delta().

Here is the caller graph for this function:

heal_polygons()

HealedExPolygons Slic3r::Emboss::heal_polygons	(	const Polygons &	shape,
		bool	is_non_zero = true,
		unsigned	max_iteration = 10 )

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

Parameters

is_non_zero	Fill type pftNonZero for overlapping otherwise
max_iteration	Look at heal_expolygon()::max_iteration

Returns

Healed shapes with flag is fully healed

References Slic3r::angle().

Referenced by anonymous_namespace{NSVGUtils.cpp}::fill_to_expolygons(), anonymous_namespace{Emboss.cpp}::get_glyph(), and anonymous_namespace{NSVGUtils.cpp}::stroke_to_expolygons().

Here is the call graph for this function:

Here is the caller 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 = 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(), and anonymous_namespace{Emboss.cpp}::load_font_info().

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 (!is_valid(font, font_index)) return {};
    auto font_info_opt = load_font_info(font.data->data(), font_index);
    if (!font_info_opt.has_value()) return {};
    return get_glyph(*font_info_opt, letter, flatness);
}

References Slic3r::Emboss::FontFile::data, anonymous_namespace{Emboss.cpp}::get_glyph(), anonymous_namespace{Emboss.cpp}::is_valid(), and anonymous_namespace{Emboss.cpp}::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()) ?
        polygons2model_unique(shape2d, projection, points) :
        polygons2model_duplicit(shape2d, projection, points, duplicits);
}

References Slic3r::collect_duplicates(), anonymous_namespace{Emboss.cpp}::polygons2model_duplicit(), anonymous_namespace{Emboss.cpp}::polygons2model_unique(), and Slic3r::to_points().

Referenced by anonymous_namespace{EmbossJob.cpp}::create_mesh_per_glyph(), and anonymous_namespace{EmbossJob.cpp}::try_create_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

sample_slice()

PolygonPoints Slic3r::Emboss::sample_slice	(	const TextLine &	slice,
		const BoundingBoxes &	bbs,
		double	scale )

Sample slice polygon by bounding boxes centers slice start point has shape_center_x coor.

Parameters

slice	Polygon and start point[Slic3r scaled millimeters]
bbs	Bounding boxes of letter on one line[in font scales]
scale	Scale for bbs (after multiply bb is in millimeters)

Returns

Sampled polygon by bounding boxes

{
    // find BB in center of line
    size_t first_right_index = 0;
    for (const BoundingBox &bb : bbs)
        if (!bb.defined) // white char do not have bb
            continue;
        else if (bb.min.x() < 0)
            ++first_right_index;
        else 
            break;
 
    PolygonPoints samples(bbs.size());
    int32_t shapes_x_cursor = 0;
 
    PolygonPoint cursor = slice.start; //copy
 
    auto create_sample = [&] //polygon_cursor, &polygon_line_index, &line_bbs, &shapes_x_cursor, &shape_scale, &em_2_polygon, &line, &offsets]
    (const BoundingBox &bb, bool is_reverse) {
        if (!bb.defined)
            return cursor;
        Point   letter_center  = bb.center();
        int32_t shape_distance = shapes_x_cursor - letter_center.x();
        shapes_x_cursor        = letter_center.x();
        double  distance_mm    = shape_distance * scale;
        int32_t distance_polygon = static_cast<int32_t>(std::round(scale_(distance_mm)));
        if (is_reverse)
            point_in_distance(distance_polygon, cursor, slice.polygon);
        else
            point_in_reverse_distance(distance_polygon, cursor, slice.polygon);
        return cursor;
    };
 
    // calc transformation for letters on the Right side from center
    bool is_reverse = true;
    for (size_t index = first_right_index; index < bbs.size(); ++index)
        samples[index] = create_sample(bbs[index], is_reverse);
 
    // calc transformation for letters on the Left side from center
    if (first_right_index < bbs.size()) {
        shapes_x_cursor = bbs[first_right_index].center().x();
        cursor          = samples[first_right_index];
    }else{
        // only left side exists
        shapes_x_cursor = 0;
        cursor = slice.start; // copy    
    }
    is_reverse = false;
    for (size_t index_plus_one = first_right_index; index_plus_one > 0; --index_plus_one) {
        size_t index = index_plus_one - 1;
        samples[index] = create_sample(bbs[index], is_reverse);
    }
    return samples;
}

References Slic3r::BoundingBoxBase< PointType, APointsType >::center(), Slic3r::BoundingBoxBase< PointType, APointsType >::defined, Slic3r::Emboss::TextLine::polygon, scale(), scale_, and Slic3r::Emboss::TextLine::start.

Referenced by anonymous_namespace{EmbossJob.cpp}::create_mesh_per_glyph(), and anonymous_namespace{EmbossJob.cpp}::cut_per_glyph_surface().

Here is the call graph for this function:

Here is the caller 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(), and Slic3r::normal().

Referenced by calc_up(), create_transformation_onto_surface(), and anonymous_namespace{SurfaceDrag.cpp}::get_volume_transformation().

Here is the call graph for this function:

Here is the caller graph for this function:

text2shapes()

HealedExPolygons Slic3r::Emboss::text2shapes	(	FontFileWithCache &	font,
		const char *	text,
		const FontProp &	font_prop,
		const std::function< bool()> &	was_canceled = []() {return false;} )

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)

{
    std::wstring text_w = boost::nowide::widen(text);
    ExPolygonsWithIds vshapes = text2vshapes(font_with_cache, text_w, font_prop, was_canceled);
 
    float delta = static_cast<float>(1. / SHAPE_SCALE);
    return ::union_with_delta(vshapes, delta, MAX_HEAL_ITERATION_OF_TEXT);
}

References MAX_HEAL_ITERATION_OF_TEXT, SHAPE_SCALE, and text2vshapes().

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

Here is the call graph for this function:

Here is the caller graph for this function:

text2vshapes()

ExPolygonsWithIds Slic3r::Emboss::text2vshapes	(	FontFileWithCache &	font,
		const std::wstring &	text,
		const FontProp &	font_prop,
		const std::function< bool()> &	was_canceled = []() {return false;} )

                                                                                                                                                                    {
    assert(font_with_cache.has_value());
    const FontFile &font = *font_with_cache.font_file;
    unsigned int font_index = font_prop.collection_number.value_or(0);
    if (!is_valid(font, font_index))
        return {};
 
    unsigned counter = 0;
    Point cursor(0, 0);
 
    fontinfo_opt font_info_cache;  
    ExPolygonsWithIds result;
    result.reserve(text.size());
    for (wchar_t letter : text) {
        if (++counter == CANCEL_CHECK) {
            counter = 0;
            if (was_canceled())
                return {};
        }
        unsigned id = static_cast<unsigned>(letter);
        result.push_back({id, letter2shapes(letter, cursor, font_with_cache, font_prop, font_info_cache)});
    }
 
    align_shape(result, text, font_prop, font);
    return result;
}

References anonymous_namespace{Emboss.cpp}::align_shape(), anonymous_namespace{Emboss.cpp}::CANCEL_CHECK, Slic3r::FontProp::collection_number, Slic3r::Emboss::FontFileWithCache::font_file, Slic3r::Emboss::FontFileWithCache::has_value(), anonymous_namespace{Emboss.cpp}::is_valid(), and anonymous_namespace{Emboss.cpp}::letter2shapes().

Referenced by anonymous_namespace{GLGizmoEmboss.cpp}::TextDataBase::create_shape(), and text2shapes().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

ENTER_UNICODE

const unsigned Slic3r::Emboss::ENTER_UNICODE = static_cast<unsigned>('\n')

Referenced by anonymous_namespace{EmbossJob.cpp}::create_line_bounds(), and get_count_lines().

UNION_DELTA

const float Slic3r::Emboss::UNION_DELTA = 50.0f

static

Referenced by anonymous_namespace{EmbossJob.cpp}::create_shape().

UNION_MAX_ITERATIN

const unsigned Slic3r::Emboss::UNION_MAX_ITERATIN = 10

static

Referenced by anonymous_namespace{EmbossJob.cpp}::create_shape().