Slic3r::TriangleSelector::Capsule2D Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/TriangleSelector.hpp>

Inheritance diagram for Slic3r::TriangleSelector::Capsule2D:

Collaboration diagram for Slic3r::TriangleSelector::Capsule2D:

Public Member Functions
	Capsule2D ()=delete
	Capsule2D (const Vec3f &first_center_, const Vec3f &second_center_, const Vec3f &source_, float radius_world, const Transform3d &trafo_, const ClippingPlane &clipping_plane_)
	~Capsule2D () 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 &first_center, const Vec3f &second_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	first_center
Vec3f	second_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

Capsule2D() [1/2]

Slic3r::TriangleSelector::Capsule2D::Capsule2D ( )

delete

Capsule2D() [2/2]

Slic3r::TriangleSelector::Capsule2D::Capsule2D ( const Vec3f & first_center_, const Vec3f & second_center_, const Vec3f & source_, float radius_world, const Transform3d & trafo_, const ClippingPlane & clipping_plane_ )

inlineexplicit

            : TriangleSelector::DoublePointCursor(first_center_, second_center_, source_, radius_world, trafo_, clipping_plane_)
        {}

References Slic3r::TriangleSelector::DoublePointCursor::DoublePointCursor(), and Slic3r::TriangleSelector::Cursor::TriangleSelector.

Here is the call graph for this function:

~Capsule2D()

Slic3r::TriangleSelector::Capsule2D::~Capsule2D ( )

overridedefault

Member Function Documentation

cursor_factory()

std::unique_ptr< Cursor > Slic3r::TriangleSelector::DoublePointCursor::cursor_factory ( const Vec3f & first_center, const Vec3f & second_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::Capsule3D>(first_center, second_center, camera_pos, cursor_radius, trafo_matrix, clipping_plane);
            else
                return std::make_unique<TriangleSelector::Capsule2D>(first_center, second_center, camera_pos, cursor_radius, trafo_matrix, clipping_plane);
        }

References Slic3r::TriangleSelector::CIRCLE, Slic3r::TriangleSelector::Cursor::clipping_plane, first_center, second_center, 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::Capsule2D::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 centers_diff                  = this->second_center - this->first_center;
    // Vector in the direction of line |AD| of the rectangle that intersects the circle with the center in first_center.
    const Vec3f rectangle_da_dir              = centers_diff.cross(this->dir);
    // Vector pointing from first_center to the point 'A' of the rectangle.
    const Vec3f first_center_rectangle_a_diff = rectangle_da_dir.normalized() * this->radius;
    const Vec3f rectangle_a                   = this->first_center - first_center_rectangle_a_diff;
    const Vec3f rectangle_d                   = this->first_center + first_center_rectangle_a_diff;
 
    auto edge_inside_rectangle = [&self = std::as_const(*this), &centers_diff](const Vec3f &edge_a, const Vec3f &edge_b, const Vec3f &plane_origin, const Vec3f &plane_normal) -> bool {
        Vec3f intersection(-1.f, -1.f, -1.f);
        if (line_plane_intersection(edge_a, edge_b, plane_origin, plane_normal, intersection)) {
            // Now check if the intersection point is inside the rectangle. That means it is between 'first_center' and 'second_center', resp. between 'A' and 'B'.
            if (self.first_center.dot(centers_diff) <= intersection.dot(centers_diff) && intersection.dot(centers_diff) <= self.second_center.dot(centers_diff))
                return true;
        }
        return false;
    };
 
    for (int side = 0; side < 3; ++side) {
        const Vec3f &edge_a     = pts[side];
        const Vec3f &edge_b     = pts[side < 2 ? side + 1 : 0];
        const Vec3f  edge_dir   = edge_b - edge_a;
        const Vec3f  edge_dir_n = edge_dir.normalized();
 
        float t1      = (this->first_center - edge_a).dot(edge_dir_n);
        float t2      = (this->second_center - edge_a).dot(edge_dir_n);
        Vec3f vector1 = edge_a + t1 * edge_dir_n - this->first_center;
        Vec3f vector2 = edge_a + t2 * edge_dir_n - this->second_center;
 
        // Vectors vector1 and vector2 are 3D vector from centers to the intersections. What we want to
        // measure is length of its projection onto plane perpendicular to dir.
        if (float dist = vector1.squaredNorm() - std::pow(vector1.dot(this->dir), 2.f); dist < this->radius_sqr && t1 >= 0.f && t1 <= edge_dir.norm())
            return true;
 
        if (float dist = vector2.squaredNorm() - std::pow(vector2.dot(this->dir), 2.f); dist < this->radius_sqr && t2 >= 0.f && t2 <= edge_dir.norm())
            return true;
 
        // Check if the edge is passing through the rectangle between first_center and second_center.
        if (edge_inside_rectangle(edge_a, edge_b, rectangle_a, (rectangle_d - rectangle_a)) || edge_inside_rectangle(edge_a, edge_b, rectangle_d, (rectangle_a - rectangle_d)))
            return true;
    }
 
    return false;
}

References Slic3r::TriangleSelector::Cursor::dir, Slic3r::Geometry::dist(), Slic3r::dot(), Slic3r::TriangleSelector::DoublePointCursor::first_center, Slic3r::intersection(), Slic3r::line_plane_intersection(), Slic3r::TriangleSelector::Cursor::radius, Slic3r::TriangleSelector::Cursor::radius_sqr, Slic3r::TriangleSelector::DoublePointCursor::second_center, 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::TriangleSelector::Capsule2D::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_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::TriangleSelector::Capsule2D::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 first_center_diff           = this->first_center - transformed_point;
    const Vec3f first_center_diff_projected = first_center_diff - first_center_diff.dot(this->dir) * this->dir;
    if (first_center_diff_projected.squaredNorm() < this->radius_sqr)
        return is_mesh_point_not_clipped(point, clipping_plane);
 
    const Vec3f second_center_diff           = this->second_center - transformed_point;
    const Vec3f second_center_diff_projected = second_center_diff - second_center_diff.dot(this->dir) * this->dir;
    if (second_center_diff_projected.squaredNorm() < this->radius_sqr)
        return is_mesh_point_not_clipped(point, clipping_plane);
 
    const Vec3f centers_diff           = this->second_center - this->first_center;
    const Vec3f centers_diff_projected = centers_diff - centers_diff.dot(this->dir) * this->dir;
 
    // First, check if the point is laying between first_center and second_center.
    if (first_center_diff_projected.dot(centers_diff_projected) <= 0.f && second_center_diff_projected.dot(centers_diff_projected) >= 0.f) {
        // Vector in the direction of line |AD| of the rectangle that intersects the circle with the center in first_center.
        const Vec3f rectangle_da_dir              = centers_diff.cross(this->dir);
        // Vector pointing from first_center to the point 'A' of the rectangle.
        const Vec3f first_center_rectangle_a_diff = rectangle_da_dir.normalized() * this->radius;
        const Vec3f rectangle_a                   = this->first_center - first_center_rectangle_a_diff;
        const Vec3f rectangle_d                   = this->first_center + first_center_rectangle_a_diff;
        // Now check if the point is laying inside the rectangle between circles with centers in first_center and second_center.
        if ((rectangle_a - transformed_point).dot(rectangle_da_dir) <= 0.f && (rectangle_d - transformed_point).dot(rectangle_da_dir) >= 0.f)
            return is_mesh_point_not_clipped(point, clipping_plane);
    }
 
    return false;
}

References Slic3r::TriangleSelector::Cursor::clipping_plane, Slic3r::TriangleSelector::Cursor::dir, Slic3r::dot(), Slic3r::TriangleSelector::DoublePointCursor::first_center, Slic3r::is_mesh_point_not_clipped(), Slic3r::TriangleSelector::Cursor::radius, Slic3r::TriangleSelector::DoublePointCursor::second_center, Slic3r::TriangleSelector::Cursor::trafo, and Slic3r::TriangleSelector::Cursor::uniform_scaling.

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 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::DoublePointCursor::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_, first_center, dir, uniform_scaling, trafo) ||
           is_circle_pointer_inside_triangle(p1_, p2_, p3_, second_center, dir, uniform_scaling, trafo);
}

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

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;
}

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

Here is the call graph for this function:

Member Data Documentation

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().

first_center

Vec3f Slic3r::TriangleSelector::DoublePointCursor::first_center

protectedinherited

Referenced by DoublePointCursor(), cursor_factory(), Slic3r::TriangleSelector::Capsule2D::is_edge_inside_cursor(), Slic3r::TriangleSelector::Capsule3D::is_edge_inside_cursor(), Slic3r::TriangleSelector::Capsule2D::is_mesh_point_inside(), Slic3r::TriangleSelector::Capsule3D::is_mesh_point_inside(), and is_pointer_in_triangle().

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().

second_center

Vec3f Slic3r::TriangleSelector::DoublePointCursor::second_center

protectedinherited

Referenced by DoublePointCursor(), cursor_factory(), Slic3r::TriangleSelector::Capsule2D::is_edge_inside_cursor(), Slic3r::TriangleSelector::Capsule3D::is_edge_inside_cursor(), Slic3r::TriangleSelector::Capsule2D::is_mesh_point_inside(), Slic3r::TriangleSelector::Capsule3D::is_mesh_point_inside(), and is_pointer_in_triangle().

source

Vec3f Slic3r::TriangleSelector::Cursor::source

protectedinherited

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

trafo

Transform3f Slic3r::TriangleSelector::Cursor::trafo

protectedinherited

Referenced by Cursor(), Slic3r::TriangleSelector::DoublePointCursor::DoublePointCursor(), Slic3r::TriangleSelector::SinglePointCursor::SinglePointCursor(), Slic3r::TriangleCursor::is_edge_inside_cursor(), Slic3r::TriangleSelector::Capsule2D::is_edge_inside_cursor(), Slic3r::TriangleSelector::Capsule3D::is_edge_inside_cursor(), Slic3r::TriangleSelector::Circle::is_edge_inside_cursor(), Slic3r::TriangleSelector::HeightRange::is_edge_inside_cursor(), Slic3r::TriangleSelector::Sphere::is_edge_inside_cursor(), Slic3r::TriangleSelector::Capsule2D::is_mesh_point_inside(), Slic3r::TriangleSelector::Capsule3D::is_mesh_point_inside(), Slic3r::TriangleSelector::Circle::is_mesh_point_inside(), Slic3r::TriangleSelector::HeightRange::is_mesh_point_inside(), Slic3r::TriangleSelector::Sphere::is_mesh_point_inside(), Slic3r::TriangleSelector::DoublePointCursor::is_pointer_in_triangle(), and Slic3r::TriangleSelector::SinglePointCursor::is_pointer_in_triangle().

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

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

---

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

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