anonymous_namespace{TextLines.cpp} Namespace Reference

Functions
indexed_triangle_set	its_create_torus (const Slic3r::Polygon &polygon, float radius, size_t steps=20)
TextLines	select_closest_contour (const std::vector< Polygons > &line_contours)
Eigen::AngleAxis< double >	get_rotation ()
indexed_triangle_set	create_its (const TextLines &lines, float radius)
GLModel::Geometry	create_geometry (const TextLines &lines, float radius, bool is_mirrored)

Function Documentation

create_geometry()

GLModel::Geometry anonymous_namespace{TextLines.cpp}::create_geometry	(	const TextLines &	lines,
		float	radius,
		bool	is_mirrored )

{
    indexed_triangle_set its = create_its(lines, radius);
 
    GLModel::Geometry geometry;
    geometry.format = {GLModel::Geometry::EPrimitiveType::Triangles, GUI::GLModel::Geometry::EVertexLayout::P3};
    ColorRGBA color(.7f, .7f, .7f, .7f); // Transparent Gray
    geometry.color = color;
 
    geometry.reserve_vertices(its.vertices.size());
    for (Vec3f vertex : its.vertices)
        geometry.add_vertex(vertex);
 
    geometry.reserve_indices(its.indices.size() * 3);
 
    if (is_mirrored) {
        // change order of indices
        for (Vec3i32 t : its.indices)
            geometry.add_triangle(t[0], t[2], t[1]);
    } else {
        for (Vec3i32 t : its.indices)
            geometry.add_triangle(t[0], t[1], t[2]);
    }
    return geometry;    
}

References Slic3r::GUI::GLModel::Geometry::add_triangle(), Slic3r::GUI::GLModel::Geometry::add_vertex(), Slic3r::GUI::GLModel::Geometry::color, create_its(), Slic3r::GUI::GLModel::Geometry::format, Slic3r::GUI::GLModel::Geometry::P3, Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), and Slic3r::GUI::GLModel::Geometry::Triangles.

Here is the call graph for this function:

create_its()

indexed_triangle_set anonymous_namespace{TextLines.cpp}::create_its	(	const TextLines &	lines,
		float	radius )

{
    indexed_triangle_set its;
    // create model from polygons
    for (const TextLine &line : lines) {
        const Slic3r::Polygon &polygon = line.polygon;
        if (polygon.empty()) continue;
        indexed_triangle_set line_its = its_create_torus(polygon, radius);
        auto transl = Eigen::Translation3d(0., line.y, 0.);
        Transform3d tr = transl * get_rotation();
        its_transform(line_its, tr);
        its_merge(its, line_its);
    }
    return its;
}

References Slic3r::MultiPoint::empty(), get_rotation(), its_create_torus(), and Slic3r::its_merge().

Referenced by create_geometry().

Here is the call graph for this function:

Here is the caller graph for this function:

get_rotation()

Eigen::AngleAxis< double > anonymous_namespace{TextLines.cpp}::get_rotation ( )

inline

{ return Eigen::AngleAxis(-M_PI_2, Vec3d::UnitX()); }

Referenced by create_its().

Here is the caller graph for this function:

its_create_torus()

indexed_triangle_set anonymous_namespace{TextLines.cpp}::its_create_torus	(	const Slic3r::Polygon &	polygon,
		float	radius,
		size_t	steps = 20 )

{
    assert(!polygon.empty());
    if (polygon.empty())
        return {};
 
    size_t count = polygon.size();
    if (count < 3)
        return {};
 
    // convert and scale to float
    std::vector<Vec2f> points_d;
    points_d.reserve(count);
    for (const Point &point : polygon.points)
        points_d.push_back(unscale(point).cast<float>());
 
    // pre calculate normalized line directions
    auto calc_line_norm = [](const Vec2f &f, const Vec2f &s) -> Vec2f { return  (s - f).normalized(); };    
    std::vector<Vec2f> line_norm(points_d.size());
    for (size_t i = 0; i < count - 1; ++i)
        line_norm[i] = calc_line_norm(points_d[i], points_d[i + 1]);
    line_norm.back() = calc_line_norm(points_d.back(), points_d.front());
        
    // precalculate sinus and cosinus
    double angle_step = 2 * M_PI / steps;
    std::vector<std::pair<double, float>> sin_cos;
    sin_cos.reserve(steps);
    for (size_t s = 0; s < steps; ++s) {
        double angle = s * angle_step;
        sin_cos.emplace_back(
            radius * std::sin(angle), 
            static_cast<float>(radius * std::cos(angle))
        );
    }
    
    indexed_triangle_set sphere = its_make_sphere(radius, 2 * PI / steps);
 
    // create torus model along polygon path
    indexed_triangle_set model;
    model.vertices.reserve(2 * steps * count + sphere.vertices.size()*count);
    model.indices.reserve(2 * steps * count + sphere.indices.size()*count);
 
    const Vec2f *prev_prev_point_d = &points_d[count-2]; // one before back
    const Vec2f *prev_point_d = &points_d.back();
 
    auto calc_angle = [](const Vec2f &d0, const Vec2f &d1) {
        double dot = d0.dot(d1);
        double det = d0.x() * d1.y() - d0.y() * d1.x(); // Determinant
        return std::atan2(det, dot);                    // atan2(y, x) or atan2(sin, cos)
    };
 
    // opposit previos direction of line - for calculate angle
    Vec2f opposit_prev_dir = (*prev_prev_point_d) - (*prev_point_d);
    for (size_t i = 0; i < count; ++i) {
 
        const Vec2f & point_d = points_d[i];
        // line segment direction
        Vec2f dir = point_d - (*prev_point_d);
 
        double angle = calc_angle(opposit_prev_dir, dir);
        double allowed_preccission = 1e-6;
        if (angle >= (PI - allowed_preccission) || 
            angle <= (-PI + allowed_preccission))
            continue; // it is almost line
 
        // perpendicular direction to line
        Vec2d p_dir(dir.y(), -dir.x());
        p_dir.normalize(); // Should done with double preccission
        // p_dir is tube unit side vector
        // tube unit top vector is z direction
 
        // Tube
        int prev_index = model.vertices.size() + 2 * sin_cos.size() - 2;
        for (const auto &[s, c] : sin_cos) {
            Vec2f side = (s * p_dir).cast<float>();
            Vec2f xy0  = side + (*prev_point_d);
            Vec2f xy1 = side + point_d;
            model.vertices.emplace_back(xy0.x(), xy0.y(), c); // pointing of prev index
            model.vertices.emplace_back(xy1.x(), xy1.y(), c);
 
            // create triangle indices
            int f0 = prev_index;
            int s0 = f0 + 1;
            int f1 = model.vertices.size() - 2;
            int s1 = f1 + 1;
            prev_index = f1;
            model.indices.emplace_back(s0, f0, s1);
            model.indices.emplace_back(f1, s1, f0);
        }
 
        prev_prev_point_d = prev_point_d;
        prev_point_d = &point_d;
        opposit_prev_dir = -dir;
    }
 
    // sphere on each point
    for (Vec2f& p: points_d){
        indexed_triangle_set sphere_copy = sphere;
        its_translate(sphere_copy, Vec3f(p.x(), p.y(), 0.f));
        its_merge(model, sphere_copy);
    }
 
    return model;
}

References Slic3r::angle(), Slic3r::GUI::calc_angle(), Slic3r::cast(), count, Slic3r::dot(), Slic3r::MultiPoint::empty(), Slic3r::f(), Slic3r::its_make_sphere(), Slic3r::its_merge(), M_PI, PI, Slic3r::MultiPoint::points, Slic3r::MultiPoint::size(), and Slic3r::unscale().

Referenced by create_its().

Here is the call graph for this function:

Here is the caller graph for this function:

select_closest_contour()

TextLines anonymous_namespace{TextLines.cpp}::select_closest_contour

(

const std::vector< Polygons > &

line_contours

)

                                                                           {
    TextLines result;
    result.reserve(line_contours.size());
    Vec2d zero(0., 0.);
    for (const Polygons &polygons : line_contours){
        if (polygons.empty()) {
            result.emplace_back();
            continue;
        }
        // Improve: use int values and polygons only
        // Slic3r::Polygons polygons = union_(polygons);
        // std::vector<Slic3r::Line> lines = to_lines(polygons);
        // AABBTreeIndirect::Tree<2, Point> tree;
        // size_t line_idx;
        // Point hit_point;
        // Point::Scalar distance = AABBTreeLines::squared_distance_to_indexed_lines(lines, tree, point, line_idx, hit_point);
 
        ExPolygons expolygons = union_ex(polygons);
        std::vector<Linef> linesf = to_linesf(expolygons);
        AABBTreeIndirect::Tree2d tree = AABBTreeLines::build_aabb_tree_over_indexed_lines(linesf);
 
        size_t line_idx = 0;
        Vec2d  hit_point;
        // double distance = 
        AABBTreeLines::squared_distance_to_indexed_lines(linesf, tree, zero, line_idx, hit_point);
 
        // conversion between index of point and expolygon
        ExPolygonsIndices cvt(expolygons);
        ExPolygonsIndex index = cvt.cvt(static_cast<uint32_t>(line_idx));
 
        const Slic3r::Polygon& polygon = index.is_contour() ?
            expolygons[index.expolygons_index].contour :
            expolygons[index.expolygons_index].holes[index.hole_index()];
 
        Point hit_point_int = hit_point.cast<Point::coord_type>();
        TextLine tl{polygon, PolygonPoint{index.point_index, hit_point_int}};
        result.emplace_back(tl);
    }
    return result;
}

References Slic3r::AABBTreeLines::build_aabb_tree_over_indexed_lines(), Slic3r::ExPolygonsIndices::cvt(), Slic3r::ExPolygonsIndex::expolygons_index, Slic3r::ExPolygonsIndex::hole_index(), Slic3r::ExPolygonsIndex::is_contour(), Slic3r::ExPolygonsIndex::point_index, Slic3r::AABBTreeLines::squared_distance_to_indexed_lines(), Slic3r::to_linesf(), and Slic3r::union_ex().

Here is the call graph for this function: