#include <src/libslic3r/TriangleSelector.hpp>

Inheritance diagram for Slic3r::TriangleSelector::Circle:

Collaboration diagram for Slic3r::TriangleSelector::Circle:

Public Member Functions
	Circle ()=delete

	Circle (const Vec3f &center_, const Vec3f &source_, float radius_world, const Transform3d &trafo_, const ClippingPlane &clipping_plane_)

	~Circle () override=default

bool	is_mesh_point_inside (const Vec3f &point) const override

bool	is_edge_inside_cursor (const Triangle &tr, const std::vector< 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 >	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 bool	is_facet_visible (const Cursor &cursor, int facet_idx, const std::vector< Vec3f > &face_normals)

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

Detailed Description

Constructor & Destructor Documentation

◆ Circle() [1/2]

Slic3r::TriangleSelector::Circle::Circle ( )

delete

◆ Circle() [2/2]

Slic3r::TriangleSelector::Circle::Circle	(	const Vec3f &	center_,
		const Vec3f &	source_,
		float	radius_world,
		const Transform3d &	trafo_,
		const ClippingPlane &	clipping_plane_
	)

inlineexplicit

141 : SinglePointCursor(center_, source_, radius_world, trafo_, clipping_plane_){};

Slic3r::TriangleSelector::SinglePointCursor::SinglePointCursor

SinglePointCursor()=delete

◆ ~Circle()

Slic3r::TriangleSelector::Circle::~Circle ( )

overridedefault

Member Function Documentation

◆ cursor_factory()

static 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 Slic3r::TriangleSelector::SinglePointCursor::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:

◆ is_edge_inside_cursor()

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

overridevirtual

Implements Slic3r::TriangleSelector::Cursor.

{
    std::array<Vec3f, 3> pts;
    for (int i = 0; i < 3; ++i) {
        pts[i] = vertices[tr.verts_idxs[i]].v;
        if (!this->uniform_scaling)
            pts[i] = this->trafo * pts[i];
    }
 
    const Vec3f &p = this->center;
    for (int side = 0; side < 3; ++side) {
        const Vec3f &a      = pts[side];
        const Vec3f &b      = pts[side < 2 ? side + 1 : 0];
        Vec3f        s      = (b - a).normalized();
        float        t      = (p - a).dot(s);
        Vec3f        vector = a + t * s - p;
 
        // vector is 3D vector from center to the intersection. What we want to
        // measure is length of its projection onto plane perpendicular to dir.
        float dist_sqr = vector.squaredNorm() - std::pow(vector.dot(this->dir), 2.f);
        if (dist_sqr < this->radius_sqr && t >= 0.f && t <= (b - a).norm())
            return true;
    }
    return false;
}

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

Here is the call graph for this function:

◆ is_facet_visible() [1/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 Slic3r::TriangleSelector::Cursor::dir, Slic3r::TriangleSelector::Cursor::trafo_normal, and Slic3r::TriangleSelector::Cursor::uniform_scaling.

◆ is_facet_visible() [2/2]

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

inlineoverridevirtual

Implements Slic3r::TriangleSelector::Cursor.

        {
            return TriangleSelector::Cursor::is_facet_visible(*this, facet_idx, face_normals);
        }

References Slic3r::TriangleSelector::Cursor::is_facet_visible().

Here is the call graph for this function:

◆ is_mesh_point_inside()

bool Slic3r::TriangleSelector::Circle::is_mesh_point_inside ( const Vec3f & point ) const

overridevirtual

Implements Slic3r::TriangleSelector::Cursor.

{
    const Vec3f transformed_point = uniform_scaling ? point : Vec3f(trafo * point);
    const Vec3f diff              = center - transformed_point;
 
    if ((diff - diff.dot(dir) * dir).squaredNorm() < radius_sqr)
        return is_mesh_point_not_clipped(point, clipping_plane);
 
    return false;
}

References Slic3r::diff(), and Slic3r::is_mesh_point_not_clipped().

Here is the call graph for this function:

◆ 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 Slic3r::TriangleSelector::Triangle::verts_idxs.

◆ 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 Slic3r::is_circle_pointer_inside_triangle().

Here is the call 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;
}