anonymous_namespace{Emboss.cpp} Namespace Reference

Classes
struct	SpikeDesc
struct	Duplicate

Typedefs
using	Polygon = Slic3r::Polygon
using	Duplicates = std::vector<Duplicate>
using	Coord2 = double
using	P2 = Eigen::Matrix<Coord2, 2, 1, Eigen::DontAlign>

Functions
bool	is_valid (const FontFile &font, unsigned int index)
fontinfo_opt	load_font_info (const unsigned char *data, unsigned int index=0)
std::optional< Glyph >	get_glyph (const stbtt_fontinfo &font_info, int unicode_letter, float flatness)
const Glyph *	get_glyph (int unicode, const FontFile &font, const FontProp &font_prop, Glyphs &cache, fontinfo_opt &font_info_opt)
Point	to_point (const stbtt__point &point)
void	remove_bad (Polygons &polygons)
void	remove_bad (ExPolygons &expolygons)
ExPolygon	create_bounding_rect (const ExPolygons &shape)
bool	heal_dupl_inter (ExPolygons &shape, unsigned max_iteration)
const Points	pts_2x2 ({Point(0, 0), Point(1, 0), Point(1, 1), Point(0, 1)})
const Points	pts_3x3 ({Point(-1, -1), Point(1, -1), Point(1, 1), Point(-1, 1)})
bool	remove_when_spike (Polygon &polygon, size_t index, const SpikeDesc &spike_desc)
void	remove_spikes_in_duplicates (ExPolygons &expolygons, const Points &duplicates)
Points	get_unique_intersections (const Slic3r::IntersectionsLines &intersections)
Polygons	get_holes_with_points (const Polygons &holes, const Points &points)
bool	fill_trouble_holes (const Polygons &holes, const Points &duplicates, const Points &intersections, ExPolygons &shape)
	Fill holes which create duplicits or intersections When healing hole creates trouble in shape again try to heal by an union instead of diff_ex.
Duplicates	collect_duplicit_indices (const ExPolygons &expoly)
Points	get_points (const Duplicates &duplicate_indices)
ExPolygons	letter2shapes (wchar_t letter, Point &cursor, FontFileWithCache &font_with_cache, const FontProp &font_prop, fontinfo_opt &font_info_cache)
HealedExPolygons	union_with_delta (const ExPolygonsWithIds &shapes, float delta, unsigned max_heal_iteration)
void	align_shape (ExPolygonsWithIds &shapes, const std::wstring &text, const FontProp &prop, const FontFile &font)
	Align shape against pivot.
void	add_quad (uint32_t i1, uint32_t i2, indexed_triangle_set &result, uint32_t count_point)
indexed_triangle_set	polygons2model_unique (const ExPolygons &shape2d, const IProjection &projection, const Points &points)
indexed_triangle_set	polygons2model_duplicit (const ExPolygons &shape2d, const IProjection &projection, const Points &points, const Points &duplicits)
bool	point_in_distance (const Coord2 &distance_sq, PolygonPoint &polygon_point, const size_t &i, const Slic3r::Polygon &polygon, bool is_first, bool is_reverse=false)
void	point_in_distance (int32_t distance, PolygonPoint &p, const Slic3r::Polygon &polygon)
void	point_in_reverse_distance (int32_t distance, PolygonPoint &p, const Slic3r::Polygon &polygon)
float	get_align_y_offset (FontProp::VerticalAlign align, unsigned count_lines, const FontFile &ff, const FontProp &fp)
int32_t	get_align_x_offset (FontProp::HorizontalAlign align, const BoundingBox &shape_bb, const BoundingBox &line_bb)

Variables
const int	CANCEL_CHECK = 10

---

Class Documentation

anonymous_namespace{Emboss.cpp}::Duplicate

struct anonymous_namespace{Emboss.cpp}::Duplicate

Collaboration diagram for anonymous_namespace{Emboss.cpp}::Duplicate:

Class Members
vector< uint32_t >	indices
Point	point

Typedef Documentation

Coord2

using anonymous_namespace{Emboss.cpp}::Coord2 = double

Duplicates

using anonymous_namespace{Emboss.cpp}::Duplicates = std::vector<Duplicate>

P2

using anonymous_namespace{Emboss.cpp}::P2 = Eigen::Matrix<Coord2, 2, 1, Eigen::DontAlign>

Polygon

using anonymous_namespace{Emboss.cpp}::Polygon = Slic3r::Polygon

Function Documentation

add_quad()

void anonymous_namespace{Emboss.cpp}::add_quad	(	uint32_t	i1,
		uint32_t	i2,
		indexed_triangle_set &	result,
		uint32_t	count_point )

{
    // bottom indices
    uint32_t i1_ = i1 + count_point;
    uint32_t i2_ = i2 + count_point;
    result.indices.emplace_back(i2, i2_, i1);
    result.indices.emplace_back(i1_, i1, i2_);
};

Referenced by polygons2model_duplicit(), and polygons2model_unique().

Here is the caller graph for this function:

align_shape()

void anonymous_namespace{Emboss.cpp}::align_shape	(	ExPolygonsWithIds &	shapes,
		const std::wstring &	text,
		const FontProp &	prop,
		const FontFile &	font )

Align shape against pivot.

Parameters

shapes	Shapes to align Prerequisities: shapes are aligned left top
text	To detect end of lines - to be able horizontal center the line
prop	Containe Horizontal and vertical alignment
font	Needed for scale and font size

{
    // Shapes have to match letters in text
    assert(shapes.size() == text.length());
 
    unsigned count_lines = get_count_lines(text);
    int y_offset = get_align_y_offset(prop.align.second, count_lines, font, prop);
 
    // Speed up for left aligned text
    if (prop.align.first == FontProp::HorizontalAlign::left){
        // already horizontaly aligned
        for (ExPolygonsWithId& shape : shapes)
            for (ExPolygon &s : shape.expoly)
                s.translate(Point(0, y_offset));
        return;
    }
 
    BoundingBox shape_bb;
    for (const ExPolygonsWithId& shape: shapes)
        shape_bb.merge(get_extents(shape.expoly));
 
    auto get_line_bb = [&](size_t j) {
        BoundingBox line_bb;
        for (; j < text.length() && text[j] != '\n'; ++j)
            line_bb.merge(get_extents(shapes[j].expoly));
        return line_bb;
    };
 
    // Align x line by line
    Point offset(
        get_align_x_offset(prop.align.first, shape_bb, get_line_bb(0)), 
        y_offset);
    for (size_t i = 0; i < shapes.size(); ++i) {
        wchar_t letter = text[i];
        if (letter == '\n'){
            offset.x() = get_align_x_offset(prop.align.first, shape_bb, get_line_bb(i + 1));
            continue;
        }
        ExPolygons &shape = shapes[i].expoly;
        for (ExPolygon &s : shape)
            s.translate(offset);
    }
}

References Slic3r::FontProp::align, align_shape(), get_align_x_offset(), get_align_y_offset(), Slic3r::Emboss::get_count_lines(), Slic3r::get_extents(), Slic3r::FontProp::left, Slic3r::BoundingBoxBase< PointType, APointsType >::merge(), Slic3r::offset(), and Slic3r::ExPolygon::translate().

Referenced by align_shape(), and Slic3r::Emboss::text2vshapes().

Here is the call graph for this function:

Here is the caller graph for this function:

collect_duplicit_indices()

Duplicates anonymous_namespace{Emboss.cpp}::collect_duplicit_indices

(

const ExPolygons &

expoly

)

{
    Points pts = to_points(expoly);
 
    // initialize original index locations
    std::vector<uint32_t> idx(pts.size());
    std::iota(idx.begin(), idx.end(), 0);
    std::sort(idx.begin(), idx.end(), 
        [&pts](uint32_t i1, uint32_t i2) { return pts[i1] < pts[i2]; });
 
    Duplicates result;
    const Point *prev = &pts[idx.front()];
    for (size_t i = 1; i < idx.size(); ++i) {
        uint32_t index = idx[i];
        const Point *act = &pts[index];
        if (*prev == *act) {
            // duplicit point
            if (!result.empty() && result.back().point == *act) {
                // more than 2 points with same coordinate
                result.back().indices.push_back(index);
            } else {
                uint32_t prev_index = idx[i-1];
                result.push_back({*act, {prev_index, index}});
            }
            continue;
        }
        prev = act;
    }
    return result;
}

References Slic3r::to_points().

Referenced by heal_dupl_inter().

Here is the call graph for this function:

Here is the caller graph for this function:

create_bounding_rect()

ExPolygon anonymous_namespace{Emboss.cpp}::create_bounding_rect

(

const ExPolygons &

shape

)

                                                        {
    BoundingBox bb   = get_extents(shape);
    Point       size = bb.size();
    if (size.x() < 10)
        bb.max.x() += 10;
    if (size.y() < 10)
        bb.max.y() += 10;
 
    Polygon rect({// CCW
        bb.min,
        {bb.max.x(), bb.min.y()},
        bb.max,
        {bb.min.x(), bb.max.y()}});
 
    Point   offset = bb.size() * 0.1;
    Polygon hole({// CW
        bb.min + offset,
        {bb.min.x() + offset.x(), bb.max.y() - offset.y()},
        bb.max - offset,
        {bb.max.x() - offset.x(), bb.min.y() + offset.y()}});
 
    return ExPolygon(rect, hole);
}

References Slic3r::get_extents(), Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::offset(), and Slic3r::BoundingBoxBase< PointType, APointsType >::size().

Referenced by heal_dupl_inter().

Here is the call graph for this function:

Here is the caller graph for this function:

fill_trouble_holes()

bool anonymous_namespace{Emboss.cpp}::fill_trouble_holes	(	const Polygons &	holes,
		const Points &	duplicates,
		const Points &	intersections,
		ExPolygons &	shape )

Fill holes which create duplicits or intersections When healing hole creates trouble in shape again try to heal by an union instead of diff_ex.

Parameters

holes	Holes which was substracted from shape previous
duplicates	Current duplicates in shape
intersections	Current intersections in shape
shape	Partialy healed shape[could be modified]

Returns

True when modify shape otherwise False

{
    if (holes.empty())
        return false;
    if (duplicates.empty() && intersections.empty())
        return false;
 
    Polygons fill = get_holes_with_points(holes, duplicates);
    append(fill, get_holes_with_points(holes, intersections));
    if (fill.empty())
        return false;
 
    shape = union_ex(shape, fill);
    return true;
}

References Slic3r::append(), get_holes_with_points(), Slic3r::holes(), and Slic3r::union_ex().

Referenced by heal_dupl_inter().

Here is the call graph for this function:

Here is the caller graph for this function:

get_align_x_offset()

int32_t anonymous_namespace{Emboss.cpp}::get_align_x_offset	(	FontProp::HorizontalAlign	align,
		const BoundingBox &	shape_bb,
		const BoundingBox &	line_bb )

{
    switch (align) {
    case FontProp::HorizontalAlign::right: return -shape_bb.max.x() + (shape_bb.size().x() - line_bb.size().x());
    case FontProp::HorizontalAlign::center: return -shape_bb.center().x() + (shape_bb.size().x() - line_bb.size().x()) / 2;
    case FontProp::HorizontalAlign::left: // no change
    default: break;
    }
    return 0;
}

References Slic3r::BoundingBoxBase< PointType, APointsType >::center(), Slic3r::FontProp::center, get_align_x_offset(), Slic3r::FontProp::left, Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::FontProp::right, and Slic3r::BoundingBoxBase< PointType, APointsType >::size().

Referenced by align_shape(), and get_align_x_offset().

Here is the call graph for this function:

Here is the caller graph for this function:

get_align_y_offset()

float anonymous_namespace{Emboss.cpp}::get_align_y_offset	(	FontProp::VerticalAlign	align,
		unsigned	count_lines,
		const FontFile &	ff,
		const FontProp &	fp )

{
    assert(count_lines != 0);
    int line_height = get_line_height(ff, fp);
    int ascent = get_font_info(ff, fp).ascent / SHAPE_SCALE;
    float line_center = static_cast<float>(std::round(ascent * ASCENT_CENTER));
 
    // direction of Y in 2d is from top to bottom
    // zero is on base line of first line
    switch (align) {
    case FontProp::VerticalAlign::bottom: return line_height * (count_lines - 1);
    case FontProp::VerticalAlign::top: return -ascent;
    case FontProp::VerticalAlign::center: 
    default: 
        return -line_center + line_height * (count_lines - 1) / 2.;
    }
}

References Slic3r::Emboss::FontFile::Info::ascent, ASCENT_CENTER, Slic3r::FontProp::bottom, Slic3r::FontProp::center, get_align_y_offset(), Slic3r::Emboss::get_font_info(), Slic3r::Emboss::get_line_height(), SHAPE_SCALE, and Slic3r::FontProp::top.

Referenced by align_shape(), and get_align_y_offset().

Here is the call graph for this function:

Here is the caller graph for this function:

get_glyph() [1/2]

std::optional< Glyph > anonymous_namespace{Emboss.cpp}::get_glyph	(	const stbtt_fontinfo &	font_info,
		int	unicode_letter,
		float	flatness )

{
    int glyph_index = stbtt_FindGlyphIndex(&font_info, unicode_letter);
    if (glyph_index == 0) {
        //wchar_t wchar = static_cast<wchar_t>(unicode_letter); 
        //<< "Character unicode letter ("
        //<< "decimal value = " << std::dec << unicode_letter << ", "
        //<< "hexadecimal value = U+" << std::hex << unicode_letter << std::dec << ", "
        //<< "wchar value = " << wchar
        //<< ") is NOT defined inside of the font. \n";
        return {};
    }
 
    Glyph glyph;
    stbtt_GetGlyphHMetrics(&font_info, glyph_index, &glyph.advance_width, &glyph.left_side_bearing);
 
    stbtt_vertex *vertices;
    int num_verts = stbtt_GetGlyphShape(&font_info, glyph_index, &vertices);
    if (num_verts <= 0) return glyph; // no shape
    ScopeGuard sg1([&vertices]() { free(vertices); });
 
    int *contour_lengths = NULL;
    int  num_countour_int = 0;
    stbtt__point *points = stbtt_FlattenCurves(vertices, num_verts,
        flatness, &contour_lengths, &num_countour_int, font_info.userdata);
    if (!points) return glyph; // no valid flattening
    ScopeGuard sg2([&contour_lengths, &points]() {
        free(contour_lengths); 
        free(points); 
    });
 
    size_t   num_contour = static_cast<size_t>(num_countour_int);
    Polygons glyph_polygons;
    glyph_polygons.reserve(num_contour);
    size_t pi = 0; // point index
    for (size_t ci = 0; ci < num_contour; ++ci) {
        int length = contour_lengths[ci];
        // check minimal length for triangle
        if (length < 4) {
            // weird font
            pi+=length;
            continue;
        }
        // last point is first point
        --length;
        Points pts;
        pts.reserve(length);
        for (int i = 0; i < length; ++i) 
            pts.emplace_back(to_point(points[pi++]));
        
        // last point is first point --> closed contour
        assert(pts.front() == to_point(points[pi]));
        ++pi;
 
        // change outer cw to ccw and inner ccw to cw order
        std::reverse(pts.begin(), pts.end());
        glyph_polygons.emplace_back(pts);
    }
    if (!glyph_polygons.empty()) {
        unsigned max_iteration = 10;
        // 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
        bool is_non_zero = true;
        glyph.shape = Emboss::heal_polygons(glyph_polygons, is_non_zero, max_iteration);
    }
    return glyph;
}

References Slic3r::Emboss::Glyph::advance_width, Slic3r::Emboss::heal_polygons(), Slic3r::Emboss::Glyph::left_side_bearing, Slic3r::length(), Slic3r::Emboss::Glyph::shape, and to_point().

Referenced by get_glyph(), Slic3r::Emboss::letter2glyph(), and letter2shapes().

Here is the call graph for this function:

Here is the caller graph for this function:

get_glyph() [2/2]

const Glyph * anonymous_namespace{Emboss.cpp}::get_glyph	(	int	unicode,
		const FontFile &	font,
		const FontProp &	font_prop,
		Glyphs &	cache,
		fontinfo_opt &	font_info_opt )

{
    // TODO: Use resolution by printer configuration, or add it into FontProp
    const float RESOLUTION = 0.0125f; // [in mm]
    auto glyph_item = cache.find(unicode);
    if (glyph_item != cache.end()) return &glyph_item->second;
 
    unsigned int font_index = font_prop.collection_number.value_or(0);
    if (!is_valid(font, font_index)) return nullptr;
 
    if (!font_info_opt.has_value()) {
        
        font_info_opt  = load_font_info(font.data->data(), font_index);
        // can load font info?
        if (!font_info_opt.has_value()) return nullptr;
    }
 
    float flatness = font.infos[font_index].ascent * RESOLUTION / font_prop.size_in_mm;
 
    // Fix for very small flatness because it create huge amount of points from curve
    if (flatness < RESOLUTION) flatness = RESOLUTION;
 
    std::optional<Glyph> glyph_opt = get_glyph(*font_info_opt, unicode, flatness);
 
    // IMPROVE: multiple loadig glyph without data
    // has definition inside of font?
    if (!glyph_opt.has_value()) return nullptr;
 
    Glyph &glyph = *glyph_opt;
    if (font_prop.char_gap.has_value()) 
        glyph.advance_width += *font_prop.char_gap;
 
    // scale glyph size
    glyph.advance_width = static_cast<int>(glyph.advance_width / SHAPE_SCALE);
    glyph.left_side_bearing = static_cast<int>(glyph.left_side_bearing / SHAPE_SCALE);
 
    if (!glyph.shape.empty()) {
        if (font_prop.boldness.has_value()) {
            float delta = static_cast<float>(*font_prop.boldness / SHAPE_SCALE / font_prop.size_in_mm);
            glyph.shape = Slic3r::union_ex(offset_ex(glyph.shape, delta));
        }
        if (font_prop.skew.has_value()) {
            double ratio = *font_prop.skew;
            auto skew = [&ratio](Polygon &polygon) {
                for (Slic3r::Point &p : polygon.points)
                    p.x() += static_cast<Point::coord_type>(std::round(p.y() * ratio));
            };
            for (ExPolygon &expolygon : glyph.shape) {
                skew(expolygon.contour);
                for (Polygon &hole : expolygon.holes) skew(hole);
            }
        }
    }
    auto [it, success] = cache.try_emplace(unicode, std::move(glyph));
    assert(success);
    return &it->second;
}

References Slic3r::Emboss::Glyph::advance_width, Slic3r::FontProp::boldness, Slic3r::FontProp::char_gap, Slic3r::FontProp::collection_number, Slic3r::ExPolygon::contour, Slic3r::Emboss::FontFile::data, get_glyph(), Slic3r::ExPolygon::holes, Slic3r::Emboss::FontFile::infos, is_valid(), Slic3r::Emboss::Glyph::left_side_bearing, load_font_info(), Slic3r::offset_ex(), Slic3r::MultiPoint::points, RESOLUTION, Slic3r::Emboss::Glyph::shape, SHAPE_SCALE, Slic3r::FontProp::size_in_mm, Slic3r::FontProp::skew, and Slic3r::union_ex().

Here is the call graph for this function:

get_holes_with_points()

Polygons anonymous_namespace{Emboss.cpp}::get_holes_with_points	(	const Polygons &	holes,
		const Points &	points )

{
    Polygons result;
    for (const Slic3r::Polygon &hole : holes)
        for (const Point &p : points)
            for (const Point &h : hole)
                if (p == h) {
                    result.push_back(hole);
                    break;
                }
    return result;
}

References Slic3r::holes().

Referenced by fill_trouble_holes().

Here is the call graph for this function:

Here is the caller graph for this function:

get_points()

Points anonymous_namespace{Emboss.cpp}::get_points

(

const Duplicates &

duplicate_indices

)

{
    Points result;
    if (duplicate_indices.empty())
        return result;
 
    // convert intersections into Points
    result.reserve(duplicate_indices.size());
    std::transform(duplicate_indices.begin(), duplicate_indices.end(), std::back_inserter(result), 
        [](const Duplicate &d) { return d.point; });
    return result;
}

Referenced by heal_dupl_inter().

Here is the caller graph for this function:

get_unique_intersections()

Points anonymous_namespace{Emboss.cpp}::get_unique_intersections

(

const Slic3r::IntersectionsLines &

intersections

)

{
    Points result;
    if (intersections.empty())
        return result;
 
    // convert intersections into Points
    result.reserve(intersections.size());
    std::transform(intersections.begin(), intersections.end(), std::back_inserter(result),
        [](const Slic3r::IntersectionLines &i) { return Point(
            std::floor(i.intersection.x()), 
            std::floor(i.intersection.y())); 
        });
    // intersections should be unique poits
    std::sort(result.begin(), result.end());
    auto it = std::unique(result.begin(), result.end());
    result.erase(it, result.end());
    return result;
}

Referenced by heal_dupl_inter().

Here is the caller graph for this function:

heal_dupl_inter()

bool anonymous_namespace{Emboss.cpp}::heal_dupl_inter	(	ExPolygons &	shape,
		unsigned	max_iteration )

{    
    if (shape.empty()) return true;
    remove_same_neighbor(shape);
 
    // create loop permanent memory
    Polygons holes;
    while (--max_iteration) {        
        Duplicates duplicate_indices = collect_duplicit_indices(shape);
        //Points duplicates = collect_duplicates(to_points(shape));
        IntersectionsLines intersections = get_intersections(shape);
                
        // Check whether shape is already healed
        if (intersections.empty() && duplicate_indices.empty())
            return true;
 
        Points duplicate_points = get_points(duplicate_indices);
        Points intersection_points = get_unique_intersections(intersections);
 
        if (fill_trouble_holes(holes, duplicate_points, intersection_points, shape)) {
            holes.clear(); 
            continue;
        } 
 
        holes.clear();
        holes.reserve(intersections.size() + duplicate_points.size());
 
        remove_spikes_in_duplicates(shape, duplicate_points);
 
        // Fix self intersection in result by subtracting hole 2x2
        for (const Point &p : intersection_points) {
            Polygon hole(pts_2x2);
            hole.translate(p);
            holes.push_back(hole);
        }
 
        // Fix duplicit points by hole 3x3 around duplicit point
        for (const Point &p : duplicate_points) {
            Polygon hole(pts_3x3);
            hole.translate(p);
            holes.push_back(hole);
        }
 
        shape = Slic3r::diff_ex(shape, holes, ApplySafetyOffset::No);
        // ApplySafetyOffset::Yes is incompatible with function fill_trouble_holes
    }
 
    // Create partialy healed output
    Duplicates duplicates = collect_duplicit_indices(shape);
    IntersectionsLines intersections = get_intersections(shape);
    if (duplicates.empty() && intersections.empty()){
        // healed in the last loop
        return true;
    }
    
    #ifdef VISUALIZE_HEAL
    visualize_heal(visualize_heal_svg_filepath, shape);
    #endif // VISUALIZE_HEAL
 
    assert(false); // Can not heal this shape
    // investigate how to heal better way
 
    ExPolygonsIndices ei(shape);
    std::vector<bool> is_healed(shape.size(), {true});
    for (const Duplicate &duplicate : duplicates){
        for (uint32_t i : duplicate.indices)
            is_healed[ei.cvt(i).expolygons_index] = false;
    }
    for (const IntersectionLines &intersection : intersections) {
        is_healed[ei.cvt(intersection.line_index1).expolygons_index] = false;
        is_healed[ei.cvt(intersection.line_index2).expolygons_index] = false;
    }
 
    for (size_t shape_index = 0; shape_index < shape.size(); shape_index++) {
        if (!is_healed[shape_index]) {
            // exchange non healed expoly with bb rect
            ExPolygon &expoly = shape[shape_index];
            expoly = create_bounding_rect({expoly});
        }
    }
    return false;
}

References collect_duplicit_indices(), create_bounding_rect(), Slic3r::ExPolygonsIndices::cvt(), Slic3r::diff_ex(), Slic3r::duplicate(), fill_trouble_holes(), Slic3r::get_intersections(), get_points(), get_unique_intersections(), Slic3r::holes(), Slic3r::intersection(), Slic3r::No, pts_2x2(), pts_3x3(), Slic3r::remove_same_neighbor(), remove_spikes_in_duplicates(), and Slic3r::MultiPoint::translate().

Here is the call graph for this function:

is_valid()

bool anonymous_namespace{Emboss.cpp}::is_valid	(	const FontFile &	font,
		unsigned int	index )

                                                        {
    if (font.data == nullptr) return false;
    if (font.data->empty()) return false;
    if (index >= font.infos.size()) return false;
    return true;
}

References Slic3r::Emboss::FontFile::data, and Slic3r::Emboss::FontFile::infos.

Referenced by Slic3r::Emboss::create_range_text(), Slic3r::Emboss::get_font_info(), get_glyph(), Slic3r::Emboss::letter2glyph(), and Slic3r::Emboss::text2vshapes().

Here is the caller graph for this function:

letter2shapes()

ExPolygons anonymous_namespace{Emboss.cpp}::letter2shapes	(	wchar_t	letter,
		Point &	cursor,
		FontFileWithCache &	font_with_cache,
		const FontProp &	font_prop,
		fontinfo_opt &	font_info_cache )

{
    assert(font_with_cache.has_value());
    if (!font_with_cache.has_value())
        return {};
 
    Glyphs &cache = *font_with_cache.cache;
    const FontFile &font  = *font_with_cache.font_file;
 
    if (letter == '\n') {
        cursor.x() = 0;
        // 2d shape has opposit direction of y
        cursor.y() -= get_line_height(font, font_prop);
        return {};
    }
    if (letter == '\t') {
        // '\t' = 4*space => same as imgui
        const int count_spaces = 4;
        const Glyph *space = get_glyph(int(' '), font, font_prop, cache, font_info_cache);
        if (space == nullptr)
            return {};
        cursor.x() += count_spaces * space->advance_width;
        return {};
    }
    if (letter == '\r')
        return {};
 
    int unicode = static_cast<int>(letter);
    auto it = cache.find(unicode);
 
    // Create glyph from font file and cache it
    const Glyph *glyph_ptr = (it != cache.end()) ? &it->second : get_glyph(unicode, font, font_prop, cache, font_info_cache);
    if (glyph_ptr == nullptr)
        return {};
 
    // move glyph to cursor position
    ExPolygons expolygons = glyph_ptr->shape; // copy
    for (ExPolygon &expolygon : expolygons)
        expolygon.translate(cursor);
 
    cursor.x() += glyph_ptr->advance_width;
    return expolygons;
}

References Slic3r::Emboss::Glyph::advance_width, Slic3r::Emboss::FontFileWithCache::cache, Slic3r::Emboss::FontFileWithCache::font_file, get_glyph(), Slic3r::Emboss::get_line_height(), Slic3r::Emboss::FontFileWithCache::has_value(), and Slic3r::Emboss::Glyph::shape.

Referenced by Slic3r::Emboss::text2vshapes().

Here is the call graph for this function:

Here is the caller graph for this function:

load_font_info()

fontinfo_opt anonymous_namespace{Emboss.cpp}::load_font_info	(	const unsigned char *	data,
		unsigned int	index = 0 )

{
    int font_offset = stbtt_GetFontOffsetForIndex(data, index);
    if (font_offset < 0) {
        assert(false);
        // "Font index(" << index << ") doesn't exist.";
        return {};        
    }
    stbtt_fontinfo font_info;
    if (stbtt_InitFont(&font_info, data, font_offset) == 0) {
        // Can't initialize font.
        assert(false);
        return {};
    }
    return font_info;
}

Referenced by Slic3r::Emboss::create_font_file(), Slic3r::Emboss::create_range_text(), get_glyph(), Slic3r::Emboss::is_italic(), and Slic3r::Emboss::letter2glyph().

Here is the caller graph for this function:

point_in_distance() [1/2]

bool anonymous_namespace{Emboss.cpp}::point_in_distance	(	const Coord2 &	distance_sq,
		PolygonPoint &	polygon_point,
		const size_t &	i,
		const Slic3r::Polygon &	polygon,
		bool	is_first,
		bool	is_reverse = false )

{
    size_t s  = polygon.size();
    size_t ii = (i + polygon_point.index) % s;
 
    // second point of line
    const Point &p = polygon[ii];
    Point p_d = p - polygon_point.point;
 
    P2 p_d2 = p_d.cast<Coord2>();
    Coord2 p_distance_sq = p_d2.squaredNorm();
    if (p_distance_sq < distance_sq)
        return false;
 
    // found line
    if (is_first) {
        // on same line
        // center also lay on line
        // new point is distance moved from point by direction
        polygon_point.point += p_d * sqrt(distance_sq / p_distance_sq);
        return true;
    }
 
    // line cross circle
 
    // start point of line
    size_t ii2          = (is_reverse) ? (ii + 1) % s : (ii + s - 1) % s;
    polygon_point.index = (is_reverse) ? ii : ii2;
    const Point &p2 = polygon[ii2];
 
    Point line_dir  = p2 - p;
    P2    line_dir2 = line_dir.cast<Coord2>();
 
    Coord2 a = line_dir2.dot(line_dir2);
    Coord2 b = 2 * p_d2.dot(line_dir2);
    Coord2 c = p_d2.dot(p_d2) - distance_sq;
 
    double discriminant = b * b - 4 * a * c;
    if (discriminant < 0) {
        assert(false);
        // no intersection
        polygon_point.point = p;
        return true;
    }
 
    // ray didn't totally miss sphere,
    // so there is a solution to
    // the equation.
    discriminant = sqrt(discriminant);
 
    // either solution may be on or off the ray so need to test both
    // t1 is always the smaller value, because BOTH discriminant and
    // a are nonnegative.
    double t1 = (-b - discriminant) / (2 * a);
    double t2 = (-b + discriminant) / (2 * a);
 
    double t = std::min(t1, t2);
    if (t < 0. || t > 1.) {
        // Bad intersection
        assert(false);
        polygon_point.point = p;
        return true;
    }
 
    polygon_point.point = p + (t * line_dir2).cast<Point::coord_type>();
    return true;
}

References Slic3r::cast(), Slic3r::PolygonPoint::index, Slic3r::PolygonPoint::point, point_in_distance(), and Slic3r::MultiPoint::size().

Referenced by point_in_distance(), point_in_distance(), and point_in_reverse_distance().

Here is the call graph for this function:

Here is the caller graph for this function:

point_in_distance() [2/2]

void anonymous_namespace{Emboss.cpp}::point_in_distance	(	int32_t	distance,
		PolygonPoint &	p,
		const Slic3r::Polygon &	polygon )

{
    Coord2 distance_sq = static_cast<Coord2>(distance) * distance;
    bool is_first = true;
    for (size_t i = 1; i < polygon.size(); ++i) {
        if (point_in_distance(distance_sq, p, i, polygon, is_first))
            return;
        is_first = false;
    }
    // There is not point on polygon with this distance
}

References point_in_distance(), and Slic3r::MultiPoint::size().

Here is the call graph for this function:

point_in_reverse_distance()

void anonymous_namespace{Emboss.cpp}::point_in_reverse_distance	(	int32_t	distance,
		PolygonPoint &	p,
		const Slic3r::Polygon &	polygon )

{
    Coord2 distance_sq = static_cast<Coord2>(distance) * distance;
    bool is_first = true;
    bool is_reverse = true;
    for (size_t i = polygon.size(); i > 0; --i) {
        if (point_in_distance(distance_sq, p, i, polygon, is_first, is_reverse))
            return;
        is_first = false;
    }
    // There is not point on polygon with this distance
}

References point_in_distance(), point_in_reverse_distance(), and Slic3r::MultiPoint::size().

Referenced by point_in_reverse_distance().

Here is the call graph for this function:

Here is the caller graph for this function:

polygons2model_duplicit()

indexed_triangle_set anonymous_namespace{Emboss.cpp}::polygons2model_duplicit	(	const ExPolygons &	shape2d,
		const IProjection &	projection,
		const Points &	points,
		const Points &	duplicits )

{
    // CW order of triangle indices
    std::vector<uint32_t> changes = Triangulation::create_changes(points, duplicits);
    std::vector<Vec3i32> shape_triangles = Triangulation::triangulate(shape2d, points, changes);
    uint32_t count_point = *std::max_element(changes.begin(), changes.end()) + 1;
 
    indexed_triangle_set result;
    result.vertices.reserve(2 * count_point);
    std::vector<Vec3f> &front_points = result.vertices;
    std::vector<Vec3f>  back_points;
    back_points.reserve(count_point);
 
    uint32_t max_index = std::numeric_limits<uint32_t>::max();
    for (uint32_t i = 0; i < changes.size(); ++i) { 
        uint32_t index = changes[i];
        if (max_index != std::numeric_limits<uint32_t>::max() &&
            index <= max_index) continue; // duplicit point
        assert(index == max_index + 1);
        assert(front_points.size() == index);
        assert(back_points.size() == index);
        max_index = index;
        const Point &p = points[i];
        auto p2 = projection.create_front_back(p);
        front_points.push_back(p2.first.cast<float>());
        back_points.push_back(p2.second.cast<float>());
    }
    assert(max_index+1 == count_point);    
    
    // insert back points, front are already in
    result.vertices.insert(result.vertices.end(),
                           std::make_move_iterator(back_points.begin()),
                           std::make_move_iterator(back_points.end()));
 
    result.indices.reserve(shape_triangles.size() * 2 + points.size() * 2);
    // top triangles - change to CCW
    for (const Vec3i32 &t : shape_triangles)
        result.indices.emplace_back(t.x(), t.z(), t.y());
    // bottom triangles - use CW
    for (const Vec3i32 &t : shape_triangles)
        result.indices.emplace_back(t.x() + count_point, t.y() + count_point,
                                    t.z() + count_point);
 
    // quads around - zig zag by triangles
    size_t polygon_offset = 0;
    auto add_quads = [&polygon_offset, &result, count_point, &changes]
    (const Polygon &polygon) {
        uint32_t polygon_points = polygon.points.size();
        // previous index
        uint32_t prev = changes[polygon_offset + polygon_points - 1];
        for (uint32_t p = 0; p < polygon_points; ++p) {
            uint32_t index = changes[polygon_offset + p];
            if (prev == index) continue;
            add_quad(prev, index, result, count_point);
            prev = index;
        }
        polygon_offset += polygon_points;
    };
 
    for (const ExPolygon &expolygon : shape2d) {
        add_quads(expolygon.contour);
        for (const Polygon &hole : expolygon.holes) add_quads(hole);
    }
    return result;
}

References add_quad(), Slic3r::Triangulation::create_changes(), Slic3r::Emboss::IProjection::create_front_back(), and Slic3r::Triangulation::triangulate().

Referenced by Slic3r::Emboss::polygons2model().

Here is the call graph for this function:

Here is the caller graph for this function:

polygons2model_unique()

indexed_triangle_set anonymous_namespace{Emboss.cpp}::polygons2model_unique	(	const ExPolygons &	shape2d,
		const IProjection &	projection,
		const Points &	points )

{
    // CW order of triangle indices
    std::vector<Vec3i32> shape_triangles=Triangulation::triangulate(shape2d, points);
    uint32_t           count_point     = points.size();
 
    indexed_triangle_set result;
    result.vertices.reserve(2 * count_point);
    std::vector<Vec3f> &front_points = result.vertices; // alias
    std::vector<Vec3f>  back_points;
    back_points.reserve(count_point);
 
    for (const Point &p : points) {
        auto p2 = projection.create_front_back(p);
        front_points.push_back(p2.first.cast<float>());
        back_points.push_back(p2.second.cast<float>());
    }    
    
    // insert back points, front are already in
    result.vertices.insert(result.vertices.end(),
                           std::make_move_iterator(back_points.begin()),
                           std::make_move_iterator(back_points.end()));
    result.indices.reserve(shape_triangles.size() * 2 + points.size() * 2);
    // top triangles - change to CCW
    for (const Vec3i32 &t : shape_triangles)
        result.indices.emplace_back(t.x(), t.z(), t.y());
    // bottom triangles - use CW
    for (const Vec3i32 &t : shape_triangles)
        result.indices.emplace_back(t.x() + count_point, 
                                    t.y() + count_point,
                                    t.z() + count_point);
 
    // quads around - zig zag by triangles
    size_t polygon_offset = 0;
    auto add_quads = [&polygon_offset,&result, &count_point]
    (const Polygon& polygon) {
        uint32_t polygon_points = polygon.points.size();
        // previous index
        uint32_t prev = polygon_offset + polygon_points - 1;
        for (uint32_t p = 0; p < polygon_points; ++p) { 
            uint32_t index = polygon_offset + p;
            add_quad(prev, index, result, count_point);
            prev = index;
        }
        polygon_offset += polygon_points;
    };
 
    for (const ExPolygon &expolygon : shape2d) {
        add_quads(expolygon.contour);
        for (const Polygon &hole : expolygon.holes) add_quads(hole);
    }   
 
    return result;
}

References add_quad(), Slic3r::Emboss::IProjection::create_front_back(), and Slic3r::Triangulation::triangulate().

Referenced by Slic3r::Emboss::polygons2model().

Here is the call graph for this function:

Here is the caller graph for this function:

pts_2x2()

const Points anonymous_namespace{Emboss.cpp}::pts_2x2

(

{Point(0, 0), Point(1, 0), Point(1, 1), Point(0, 1)}

)

Referenced by heal_dupl_inter().

Here is the caller graph for this function:

pts_3x3()

const Points anonymous_namespace{Emboss.cpp}::pts_3x3

(

{Point(-1, -1), Point(1, -1), Point(1, 1), Point(-1, 1)}

)

Referenced by heal_dupl_inter().

Here is the caller graph for this function:

remove_bad() [1/2]

void anonymous_namespace{Emboss.cpp}::remove_bad

(

ExPolygons &

expolygons

)

                                        {
    expolygons.erase(
        std::remove_if(expolygons.begin(), expolygons.end(), 
            [](const ExPolygon &p) { return p.contour.size() < 3; }),
        expolygons.end());
 
    for (ExPolygon &expolygon : expolygons)
         remove_bad(expolygon.holes);
}

References remove_bad().

Here is the call graph for this function:

remove_bad() [2/2]

void anonymous_namespace{Emboss.cpp}::remove_bad

(

Polygons &

polygons

)

                                    {
    polygons.erase(
        std::remove_if(polygons.begin(), polygons.end(), 
            [](const Polygon &p) { return p.size() < 3; }), 
        polygons.end());
}

Referenced by remove_bad(), and remove_spikes_in_duplicates().

Here is the caller graph for this function:

remove_spikes_in_duplicates()

void anonymous_namespace{Emboss.cpp}::remove_spikes_in_duplicates	(	ExPolygons &	expolygons,
		const Points &	duplicates )

                                                                                   { 
    if (duplicates.empty())
        return;
    auto check = [](Slic3r::Polygon &polygon, const Point &d) -> bool {
        double spike_bevel = 1 / SHAPE_SCALE;
        double spike_length = 5.;
        const static SpikeDesc sd(spike_bevel, spike_length);
        Points& pts = polygon.points;
        bool exist_remove = false;
        for (size_t i = 0; i < pts.size(); i++) {
            if (pts[i] != d)
                continue;
            exist_remove |= remove_when_spike(polygon, i, sd);
        }
        return exist_remove && pts.size() < 3;
    };
 
    bool exist_remove = false;
    for (ExPolygon &expolygon : expolygons) {
        BoundingBox bb(to_points(expolygon.contour));
        for (const Point &d : duplicates) {
            if (!bb.contains(d))
                continue;
            exist_remove |= check(expolygon.contour, d);
            for (Polygon &hole : expolygon.holes)
                exist_remove |= check(hole, d);
        }
    }
 
    if (exist_remove)
        remove_bad(expolygons);
}

References Slic3r::BoundingBoxBase< PointType, APointsType >::contains(), Slic3r::MultiPoint::points, remove_bad(), remove_when_spike(), SHAPE_SCALE, and Slic3r::to_points().

Referenced by heal_dupl_inter().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_when_spike()

bool anonymous_namespace{Emboss.cpp}::remove_when_spike	(	Slic3r::Polygon &	polygon,
		size_t	index,
		const SpikeDesc &	spike_desc )

                                                                                          {
 
    std::optional<Point> add;
    bool do_erase = false;
    Points &pts = polygon.points;
    {
        size_t  pts_size = pts.size();
        if (pts_size < 3)
            return false;
 
        const Point &a = (index == 0) ? pts.back() : pts[index - 1];
        const Point &b = pts[index];
        const Point &c = (index == (pts_size - 1)) ? pts.front() : pts[index + 1];
 
        // calc sides
        Vec2d ba = (a - b).cast<double>();
        Vec2d bc = (c - b).cast<double>();
 
        double dot_product = ba.dot(bc);
 
        // sqrt together after multiplication save one sqrt
        double ba_size_sq = ba.squaredNorm();
        double bc_size_sq = bc.squaredNorm();
        double norm       = sqrt(ba_size_sq * bc_size_sq);
        double cos_angle  = dot_product / norm;
 
        // small angle are around 1 --> cos(0) = 1
        if (cos_angle < spike_desc.cos_angle)
            return false; // not a spike
 
        // has to be in range <-1, 1>
        // Due to preccission of floating point number could be sligtly out of range
        if (cos_angle > 1.)
            cos_angle = 1.;
        // if (cos_angle < -1.)
        //     cos_angle = -1.;
 
        // Current Spike angle
        double angle          = acos(cos_angle);
        double wanted_size    = spike_desc.half_bevel / cos(angle / 2.);
        double wanted_size_sq = wanted_size * wanted_size;
 
        bool is_ba_short = ba_size_sq < wanted_size_sq;
        bool is_bc_short = bc_size_sq < wanted_size_sq;
 
        auto a_side = [&b, &ba, &ba_size_sq, &wanted_size]() -> Point {
            Vec2d ba_norm = ba / sqrt(ba_size_sq);
            return b + (wanted_size * ba_norm).cast<coord_t>();
        };
        auto c_side = [&b, &bc, &bc_size_sq, &wanted_size]() -> Point {
            Vec2d bc_norm = bc / sqrt(bc_size_sq);
            return b + (wanted_size * bc_norm).cast<coord_t>();
        };
 
        if (is_ba_short && is_bc_short) {
            // remove short spike
            do_erase = true;
        } else if (is_ba_short) {
            // move point B on C-side
            pts[index] = c_side();
        } else if (is_bc_short) {
            // move point B on A-side
            pts[index] = a_side();
        } else {
            // move point B on C-side and add point on A-side(left - before)
            pts[index] = c_side();
            add = a_side();
            if (*add == pts[index]) {
                // should be very rare, when SpikeDesc has small base
                // will be fixed by remove B point
                add.reset();
                do_erase = true;
            }
        }
    }
    if (do_erase) {
        pts.erase(pts.begin() + index);
        return true;
    }
    if (add.has_value())
        pts.insert(pts.begin() + index, *add);
    return false;
}

References Slic3r::angle(), Slic3r::cast(), anonymous_namespace{Emboss.cpp}::SpikeDesc::cos_angle, anonymous_namespace{Emboss.cpp}::SpikeDesc::half_bevel, and Slic3r::MultiPoint::points.

Referenced by remove_spikes_in_duplicates().

Here is the call graph for this function:

Here is the caller graph for this function:

to_point()

Point anonymous_namespace{Emboss.cpp}::to_point

(

const stbtt__point &

point

)

                                          {
    return Point(static_cast<int>(std::round(point.x / SHAPE_SCALE)),
                 static_cast<int>(std::round(point.y / SHAPE_SCALE)));
}

References SHAPE_SCALE.

Referenced by get_glyph().

Here is the caller graph for this function:

union_with_delta()

HealedExPolygons anonymous_namespace{Emboss.cpp}::union_with_delta	(	const ExPolygonsWithIds &	shapes,
		float	delta,
		unsigned	max_heal_iteration )

{
    // unify to one expolygons
    ExPolygons expolygons;
    for (const ExPolygonsWithId &shape : shapes) {
        if (shape.expoly.empty())
            continue;
        expolygons_append(expolygons, offset_ex(shape.expoly, delta));
    }
    ExPolygons result = union_ex(expolygons);
    result            = offset_ex(result, -delta);
    bool is_healed    = heal_expolygons(result, max_heal_iteration);
    return {result, is_healed};
}

References Slic3r::expolygons_append(), Slic3r::Emboss::heal_expolygons(), Slic3r::offset_ex(), and Slic3r::union_ex().

Referenced by Slic3r::union_with_delta().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

CANCEL_CHECK

const int anonymous_namespace{Emboss.cpp}::CANCEL_CHECK = 10

Referenced by Slic3r::Emboss::text2vshapes().