Inheritance diagram for Slic3r::TriangleCursor:

Collaboration diagram for Slic3r::TriangleCursor:

Public Member Functions
	TriangleCursor ()=delete
	TriangleCursor (const Vec3f &center_, const Vec3f &source_, float radius_world, const Transform3d &trafo_, const TriangleSelector::ClippingPlane &clipping_plane_, const std::array< const Vec3f, 3 > &vertices)
	~TriangleCursor () override=default
bool	is_mesh_point_inside (const Vec3f &point) const override
bool	is_edge_inside_cursor (const TriangleSelector::Triangle &tr, const std::vector< TriangleSelector::Vertex > &vertices) const override
bool	is_facet_visible (int facet_idx, const std::vector< Vec3f > &face_normals) const override
bool	is_pointer_in_triangle (const Vec3f &p1, const Vec3f &p2, const Vec3f &p3) const override
bool	is_pointer_in_triangle (const Triangle &tr, const std::vector< Vertex > &vertices) const
virtual int	vertices_inside (const Triangle &tr, const std::vector< Vertex > &vertices) const

Static Public Member Functions
static std::unique_ptr< Cursor >	build_cursor (const TriangleSelector &source_selector, const TriangleSelector::Triangle &tri)
static bool	check_normal (const Vec3f &facet_norm, const Vec3f &camera_dir)
static std::unique_ptr< Cursor >	cursor_factory (const Vec3f &center, const Vec3f &camera_pos, const float cursor_radius, const CursorType cursor_type, const Transform3d &trafo_matrix, const ClippingPlane &clipping_plane)
static std::unique_ptr< Cursor >	cursor_factory (float z_world, const Vec3f &camera_pos, const float height, const Transform3d &trafo_matrix, const ClippingPlane &clipping_plane)
static bool	is_facet_visible (const Cursor &cursor, int facet_idx, const std::vector< Vec3f > &face_normals)

Static Public Attributes
static constexpr float	tolerance = 0.01f

Protected Attributes
Vec3f	center
Transform3f	trafo
Vec3f	source
bool	uniform_scaling
Transform3f	trafo_normal
float	radius
float	radius_sqr
Vec3f	dir = Vec3f(0.f, 0.f, 0.f)
ClippingPlane	clipping_plane
friend	TriangleSelector

Static Private Member Functions
static float	point_to_line_dist (const Vec3f &p, const Vec3f &a, const Vec3f &b)

Private Attributes
const Barycentric	barycentric_

Static Private Attributes
static const double	facet_angle_limit = cos(Geometry::deg2rad(5.0))

Detailed Description

Constructor & Destructor Documentation

◆ TriangleCursor() [1/2]

Slic3r::TriangleCursor::TriangleCursor ( )

delete

◆ TriangleCursor() [2/2]

Slic3r::TriangleCursor::TriangleCursor	(	const Vec3f &	center_,
		const Vec3f &	source_,
		float	radius_world,
		const Transform3d &	trafo_,
		const TriangleSelector::ClippingPlane &	clipping_plane_,
		const std::array< const Vec3f, 3 > &	vertices )

inlineexplicit

        : TriangleSelector::SinglePointCursor(center_, source_, radius_world, trafo_, clipping_plane_)
        , barycentric_(vertices[0], vertices[1], vertices[2])
    {}

References Slic3r::TriangleSelector::SinglePointCursor::SinglePointCursor(), and barycentric_.

Here is the call graph for this function:

◆ ~TriangleCursor()

Slic3r::TriangleCursor::~TriangleCursor ( )

overridedefault

Member Function Documentation

◆ build_cursor()

std::unique_ptr< Cursor > Slic3r::TriangleCursor::build_cursor	(	const TriangleSelector &	source_selector,
		const TriangleSelector::Triangle &	tri )

inlinestatic

    {
        const Vec3f& pv0 = source_selector.m_vertices[tri.verts_idxs[0]].v;
        const Vec3f& pv1 = source_selector.m_vertices[tri.verts_idxs[1]].v;
        const Vec3f& pv2 = source_selector.m_vertices[tri.verts_idxs[2]].v;
 
        // Calculate the centroid of the triangle
        const Vec3f center = (pv0 + pv1 + pv2) / 3.f;
 
        // Calculate the norm of the plane
        const Vec3f& norm = source_selector.m_face_normals[tri.source_triangle];
 
        // Calculate the min distance from the centroid to every edges
        const float radius = std::max(std::min(std::min(point_to_line_dist(center, pv0, pv1), point_to_line_dist(center, pv0, pv2)),
                                      point_to_line_dist(center, pv1, pv2)), 0.1f);
 
        return std::make_unique<TriangleCursor>(center, center + norm, radius, Transform3d::Identity(), TriangleSelector::ClippingPlane(),
                                                std::array<const Vec3f, 3>{pv0, pv1, pv2});
    }

References Slic3r::TriangleSelector::SinglePointCursor::center, Slic3r::TriangleSelector::m_face_normals, Slic3r::TriangleSelector::m_vertices, point_to_line_dist(), Slic3r::TriangleSelector::Cursor::radius, Slic3r::TriangleSelector::Triangle::source_triangle, and Slic3r::TriangleSelector::Triangle::verts_idxs.

Referenced by Slic3r::TriangleSelector::remap_painting().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_normal()

bool Slic3r::TriangleCursor::check_normal	(	const Vec3f &	facet_norm,
		const Vec3f &	camera_dir )

inlinestatic

    {
        const float a = -(facet_norm.dot(camera_dir));
        return std::clamp(a, 0.f, 1.f) >= facet_angle_limit;
    }

References facet_angle_limit.

Referenced by is_facet_visible(), and Slic3r::TriangleSelector::remap_painting().

Here is the caller graph for this function:

◆ cursor_factory() [1/2]

std::unique_ptr< Cursor > Slic3r::TriangleSelector::SinglePointCursor::cursor_factory	(	const Vec3f &	center,
		const Vec3f &	camera_pos,
		const float	cursor_radius,
		const CursorType	cursor_type,
		const Transform3d &	trafo_matrix,
		const ClippingPlane &	clipping_plane )

inlinestaticinherited

        {
            assert(cursor_type == TriangleSelector::CursorType::CIRCLE || cursor_type == TriangleSelector::CursorType::SPHERE);
            if (cursor_type == TriangleSelector::CursorType::SPHERE)
                return std::make_unique<TriangleSelector::Sphere>(center, camera_pos, cursor_radius, trafo_matrix, clipping_plane);
            else
                return std::make_unique<TriangleSelector::Circle>(center, camera_pos, cursor_radius, trafo_matrix, clipping_plane);
        }

References center, Slic3r::TriangleSelector::CIRCLE, Slic3r::TriangleSelector::Cursor::clipping_plane, and Slic3r::TriangleSelector::SPHERE.

Referenced by Slic3r::GUI::GLGizmoPainterBase::gizmo_event().

Here is the caller graph for this function:

◆ cursor_factory() [2/2]

std::unique_ptr< Cursor > Slic3r::TriangleSelector::SinglePointCursor::cursor_factory	(	float	z_world,
		const Vec3f &	camera_pos,
		const float	height,
		const Transform3d &	trafo_matrix,
		const ClippingPlane &	clipping_plane )

inlinestaticinherited

        {
            return std::make_unique<TriangleSelector::HeightRange>(z_world, camera_pos, height, trafo_matrix, clipping_plane);
        }

References Slic3r::TriangleSelector::Cursor::clipping_plane.

◆ is_edge_inside_cursor()

bool Slic3r::TriangleCursor::is_edge_inside_cursor	(	const TriangleSelector::Triangle &	tr,
		const std::vector< TriangleSelector::Vertex > &	vertices ) const

inlineoverridevirtual

Implements Slic3r::TriangleSelector::Cursor.

    {
        std::array<Vec3f, 3> pts_proj; // Projected point onto the plane
        std::array<float, 3> pts_dist; // Distance to the plane, positive means above, negative means below the plane
        for (int i = 0; i < 3; ++i) {
            Vec3f p = vertices[tr.verts_idxs[i]].v;
            if (!this->uniform_scaling)
                p = this->trafo * p;
 
            const Vec3f diff = p - center;
            pts_dist[i]      = diff.dot(dir);
            pts_proj[i]      = p - pts_dist[i] * dir;
        }
 
        for (int side = 0; side < 3; ++side) {
            const int idx_a = side;
            const int idx_b = side < 2 ? side + 1 : 0;
 
            // If both ends at the same side and farther than tolerance, skip
            const float dist_a = pts_dist[idx_a];
            const float dist_b = pts_dist[idx_b];
            if ((dist_a > tolerance && dist_b > tolerance) || (dist_a < -tolerance && dist_b < -tolerance)) {
                continue;
            }
 
            // Find the projected line segment which has distance to the plane within the tolerance
            Vec3f pt_a = pts_proj[idx_a];
            Vec3f pt_b = pts_proj[idx_b];
            if (std::abs(dist_a) > tolerance) {
                pt_a = (tolerance - dist_b) / (dist_a - dist_b) * (pts_proj[idx_a] - pts_proj[idx_b]) + pts_proj[idx_b];
            }
            if (std::abs(dist_b) > tolerance) {
                pt_b = (tolerance - dist_a) / (dist_b - dist_a) * (pts_proj[idx_b] - pts_proj[idx_a]) + pts_proj[idx_a];
            }
 
            // If any projected end is inside the triangle, then is in
            if (barycentric_.is_point_inside_triangle(pt_a) ||
                barycentric_.is_point_inside_triangle(pt_b)) {
                return true;
            }
 
            // Otherwise see if the segment (pt_a, pt_b) intersects the triangle
            {
                const Vec3f uvw_a = barycentric_.calc(pt_a);
                const Vec3f uvw_b = barycentric_.calc(pt_b);
                const Vec3f uvw_0 {1.f,0.f,0.f};
                const Vec3f uvw_1 {0.f,1.f,0.f};
                const Vec3f uvw_2 {0.f,0.f,1.f};
                constexpr std::pair<int, int> proj{0, 1};
 
                if (segments_intersect_proj(uvw_a, uvw_b, uvw_0, uvw_1, proj)||
                    segments_intersect_proj(uvw_a, uvw_b, uvw_0, uvw_2, proj)||
                    segments_intersect_proj(uvw_a, uvw_b, uvw_1, uvw_2, proj)) {
                    return true;
                }
            }
        }
        return false;
    }

References barycentric_, Slic3r::TriangleSelector::SinglePointCursor::center, Slic3r::diff(), Slic3r::TriangleSelector::Cursor::dir, Slic3r::segments_intersect_proj(), tolerance, Slic3r::TriangleSelector::Cursor::trafo, Slic3r::TriangleSelector::Cursor::uniform_scaling, and Slic3r::TriangleSelector::Triangle::verts_idxs.

Here is the call graph for this function:

◆ is_facet_visible() [1/2]

bool Slic3r::TriangleCursor::is_facet_visible	(	int	facet_idx,
		const std::vector< Vec3f > &	face_normals ) const

inlineoverridevirtual

Implements Slic3r::TriangleSelector::Cursor.

    {
        const Vec3f& n = face_normals[facet_idx];
 
        return check_normal(n, this->dir);
    }

References check_normal(), and Slic3r::TriangleSelector::Cursor::dir.

Here is the call graph for this function:

◆ is_facet_visible() [2/2]

bool Slic3r::TriangleSelector::Cursor::is_facet_visible	(	const Cursor &	cursor,
		int	facet_idx,
		const std::vector< Vec3f > &	face_normals )

staticinherited

{
    assert(facet_idx < int(face_normals.size()));
    Vec3f n = face_normals[facet_idx];
    if (!cursor.uniform_scaling)
        n = cursor.trafo_normal * n;
    return n.dot(cursor.dir) < 0.f;
}

References Cursor(), dir, trafo_normal, and uniform_scaling.

Here is the call graph for this function:

◆ is_mesh_point_inside()

bool Slic3r::TriangleCursor::is_mesh_point_inside ( const Vec3f & point ) const

inlineoverridevirtual

Implements Slic3r::TriangleSelector::Cursor.

    {
        return barycentric_.is_point_inside_triangle(point);
    }

References barycentric_.

◆ is_pointer_in_triangle() [1/2]

bool Slic3r::TriangleSelector::Cursor::is_pointer_in_triangle	(	const Triangle &	tr,
		const std::vector< Vertex > &	vertices ) const

inherited

                                                                                                               {
    const Vec3f& p1 = vertices[tr.verts_idxs[0]].v;
    const Vec3f& p2 = vertices[tr.verts_idxs[1]].v;
    const Vec3f& p3 = vertices[tr.verts_idxs[2]].v;
    return this->is_pointer_in_triangle(p1, p2, p3);
}

References is_pointer_in_triangle(), and Slic3r::TriangleSelector::Triangle::verts_idxs.

Referenced by is_pointer_in_triangle().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_pointer_in_triangle() [2/2]

bool Slic3r::TriangleSelector::SinglePointCursor::is_pointer_in_triangle	(	const Vec3f &	p1,
		const Vec3f &	p2,
		const Vec3f &	p3 ) const

overridevirtualinherited

Implements Slic3r::TriangleSelector::Cursor.

{
    return is_circle_pointer_inside_triangle(p1_, p2_, p3_, center, dir, uniform_scaling, trafo);
}

References center, Slic3r::TriangleSelector::Cursor::dir, Slic3r::is_circle_pointer_inside_triangle(), Slic3r::TriangleSelector::Cursor::trafo, and Slic3r::TriangleSelector::Cursor::uniform_scaling.

Here is the call graph for this function:

◆ point_to_line_dist()

float Slic3r::TriangleCursor::point_to_line_dist	(	const Vec3f &	p,
		const Vec3f &	a,
		const Vec3f &	b )

inlinestaticprivate

    {
        const Eigen::ParametrizedLine<float, 3> line = Eigen::ParametrizedLine<float, 3>::Through(a, b);
        return line.distance(p);
    }

Referenced by build_cursor().

Here is the caller graph for this function:

◆ vertices_inside()

int Slic3r::TriangleSelector::Cursor::vertices_inside	(	const Triangle &	tr,
		const std::vector< Vertex > &	vertices ) const

virtualinherited

{
    int inside = 0;
    for (size_t i = 0; i < 3; ++i)
        if (this->is_mesh_point_inside(vertices[tr.verts_idxs[i]].v))
            ++inside;
 
    return inside;
}

References is_mesh_point_inside(), and Slic3r::TriangleSelector::Triangle::verts_idxs.

Here is the call graph for this function:

Member Data Documentation

◆ barycentric_

const Barycentric Slic3r::TriangleCursor::barycentric_

private

Referenced by TriangleCursor(), is_edge_inside_cursor(), and is_mesh_point_inside().

◆ center

Vec3f Slic3r::TriangleSelector::SinglePointCursor::center

protectedinherited

Referenced by SinglePointCursor(), Slic3r::TriangleCursor::build_cursor(), cursor_factory(), Slic3r::TriangleCursor::is_edge_inside_cursor(), Slic3r::TriangleSelector::Circle::is_edge_inside_cursor(), Slic3r::TriangleSelector::Sphere::is_edge_inside_cursor(), Slic3r::TriangleSelector::Circle::is_mesh_point_inside(), Slic3r::TriangleSelector::Sphere::is_mesh_point_inside(), and is_pointer_in_triangle().

◆ clipping_plane

ClippingPlane Slic3r::TriangleSelector::Cursor::clipping_plane

protectedinherited

Referenced by Cursor(), Slic3r::TriangleSelector::DoublePointCursor::cursor_factory(), Slic3r::TriangleSelector::SinglePointCursor::cursor_factory(), Slic3r::TriangleSelector::SinglePointCursor::cursor_factory(), Slic3r::TriangleSelector::Capsule2D::is_mesh_point_inside(), Slic3r::TriangleSelector::Capsule3D::is_mesh_point_inside(), Slic3r::TriangleSelector::Circle::is_mesh_point_inside(), and Slic3r::TriangleSelector::Sphere::is_mesh_point_inside().

◆ dir

Vec3f Slic3r::TriangleSelector::Cursor::dir = Vec3f(0.f, 0.f, 0.f)

protectedinherited

Referenced by Slic3r::TriangleSelector::DoublePointCursor::DoublePointCursor(), Slic3r::TriangleSelector::SinglePointCursor::SinglePointCursor(), Slic3r::TriangleCursor::is_edge_inside_cursor(), Slic3r::TriangleSelector::Capsule2D::is_edge_inside_cursor(), Slic3r::TriangleCursor::is_facet_visible(), is_facet_visible(), Slic3r::TriangleSelector::Capsule2D::is_mesh_point_inside(), Slic3r::TriangleSelector::Circle::is_mesh_point_inside(), Slic3r::TriangleSelector::DoublePointCursor::is_pointer_in_triangle(), and Slic3r::TriangleSelector::SinglePointCursor::is_pointer_in_triangle().

◆ facet_angle_limit

const double Slic3r::TriangleCursor::facet_angle_limit = cos(Geometry::deg2rad(5.0))

staticprivate

Referenced by check_normal().

◆ radius

float Slic3r::TriangleSelector::Cursor::radius

protectedinherited

Referenced by Cursor(), Slic3r::TriangleCursor::build_cursor(), Slic3r::TriangleSelector::Capsule2D::is_edge_inside_cursor(), Slic3r::TriangleSelector::Capsule3D::is_edge_inside_cursor(), Slic3r::TriangleSelector::Sphere::is_edge_inside_cursor(), and Slic3r::TriangleSelector::Capsule2D::is_mesh_point_inside().

◆ radius_sqr

float Slic3r::TriangleSelector::Cursor::radius_sqr

protectedinherited

Referenced by Cursor(), Slic3r::TriangleSelector::Capsule2D::is_edge_inside_cursor(), Slic3r::TriangleSelector::Circle::is_edge_inside_cursor(), Slic3r::TriangleSelector::Circle::is_mesh_point_inside(), and Slic3r::TriangleSelector::Sphere::is_mesh_point_inside().

◆ source

Vec3f Slic3r::TriangleSelector::Cursor::source

protectedinherited

Referenced by Cursor(), Slic3r::TriangleSelector::DoublePointCursor::DoublePointCursor(), and Slic3r::TriangleSelector::SinglePointCursor::SinglePointCursor().

◆ tolerance

float Slic3r::TriangleCursor::tolerance = 0.01f

staticconstexpr

Referenced by is_edge_inside_cursor(), and Slic3r::TriangleSelector::remap_painting().

◆ trafo

Transform3f Slic3r::TriangleSelector::Cursor::trafo

protectedinherited

◆ trafo_normal

Transform3f Slic3r::TriangleSelector::Cursor::trafo_normal

protectedinherited

Referenced by Cursor(), and is_facet_visible().

◆ TriangleSelector

friend Slic3r::TriangleSelector::Cursor::TriangleSelector

protectedinherited

Referenced by Slic3r::TriangleSelector::Capsule2D::Capsule2D(), and Slic3r::TriangleSelector::Capsule3D::Capsule3D().

◆ uniform_scaling

bool Slic3r::TriangleSelector::Cursor::uniform_scaling

protectedinherited

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

/home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/TriangleSelector.cpp

	OrcaSlicer latest OrcaSlicer

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Attributes

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ TriangleCursor() [1/2]

◆ TriangleCursor() [2/2]

◆ ~TriangleCursor()

Member Function Documentation

◆ build_cursor()

◆ check_normal()

◆ cursor_factory() [1/2]

◆ cursor_factory() [2/2]

◆ is_edge_inside_cursor()

◆ is_facet_visible() [1/2]

◆ is_facet_visible() [2/2]

◆ is_mesh_point_inside()

◆ is_pointer_in_triangle() [1/2]

◆ is_pointer_in_triangle() [2/2]

◆ point_to_line_dist()

◆ vertices_inside()

Member Data Documentation

◆ barycentric_

◆ center

◆ clipping_plane

◆ dir

◆ facet_angle_limit

◆ radius

◆ radius_sqr

◆ source

◆ tolerance

◆ trafo

◆ trafo_normal

◆ TriangleSelector

◆ uniform_scaling