Slic3r::Geometry Namespace Reference

Namespaces
namespace	BicubicInternal
namespace	impl
namespace	rotcalip

Classes
class	ArrangeItem
class	ArrangeItemIndex
struct	Circle
struct	CircleSq
struct	CubicKernelWrapper
class	Lines2VDSegments
class	MedialAxis
struct	ParabolicSegment
struct	PiecewiseFittedCurve
struct	PolynomialCurve
class	Transformation
struct	TransformationSVD
class	VoronoiDiagram
class	VoronoiUtilsCgal

Typedefs
template<typename NumberType >
using	LinearKernel = CubicKernelWrapper< BicubicInternal::LinearKernel< NumberType > >
template<typename NumberType >
using	CubicCatmulRomKernel = CubicKernelWrapper< BicubicInternal::CubicCatmulRomKernel< NumberType > >
template<typename NumberType >
using	CubicBSplineKernel = CubicKernelWrapper< BicubicInternal::CubicBSplineKernel< NumberType > >
using	Circlef = Circle< Vec2f >
using	Circled = Circle< Vec2d >
using	CircleSqf = CircleSq< Vec2f >
using	CircleSqd = CircleSq< Vec2d >
using	ParabolicTangentToSegmentOrientation = impl::ParabolicTangentToSegmentOrientationPredicateFiltered
using	ParabolicTangentToParabolicTangentOrientation = impl::ParabolicTangentToParabolicTangentOrientationPredicateFiltered
using	CGAL_Point = impl::K::Point_2

Enumerations
enum	Orientation { ORIENTATION_CCW = 1 , ORIENTATION_CW = -1 , ORIENTATION_COLINEAR = 0 }

Functions
bool	directions_parallel (double angle1, double angle2, double max_diff)
bool	directions_perpendicular (double angle1, double angle2, double max_diff)
template<class T >
bool	contains (const std::vector< T > &vector, const Point &point)
template bool	contains (const ExPolygons &vector, const Point &point)
void	simplify_polygons (const Polygons &polygons, double tolerance, Polygons *retval)
double	linint (double value, double oldmin, double oldmax, double newmin, double newmax)
bool	arrange (size_t total_parts, const Vec2d &part_size, coordf_t dist, const BoundingBoxf *bb, Pointfs &positions)
template<typename T >
T	dist (const boost::polygon::point_data< T > &p1, const boost::polygon::point_data< T > &p2)
template<typename segment_type , typename point_type >
point_type	project_point_to_segment (segment_type &seg, point_type &px)
void	assemble_transform (Transform3d &transform, const Vec3d &translation, const Vec3d &rotation, const Vec3d &scale, const Vec3d &mirror)
Transform3d	assemble_transform (const Vec3d &translation, const Vec3d &rotation, const Vec3d &scale, const Vec3d &mirror)
void	assemble_transform (Transform3d &transform, const Transform3d &translation, const Transform3d &rotation, const Transform3d &scale, const Transform3d &mirror)
Transform3d	assemble_transform (const Transform3d &translation, const Transform3d &rotation, const Transform3d &scale, const Transform3d &mirror)
void	translation_transform (Transform3d &transform, const Vec3d &translation)
Transform3d	translation_transform (const Vec3d &translation)
void	rotation_transform (Transform3d &transform, const Vec3d &rotation)
Transform3d	rotation_transform (const Vec3d &rotation)
void	scale_transform (Transform3d &transform, double scale)
void	scale_transform (Transform3d &transform, const Vec3d &scale)
Transform3d	scale_transform (double scale)
Transform3d	scale_transform (const Vec3d &scale)
Vec3d	extract_rotation (const Eigen::Matrix< double, 3, 3, Eigen::DontAlign > &rotation_matrix)
Vec3d	extract_rotation (const Transform3d &transform)
static Transform3d	extract_rotation_matrix (const Transform3d &trafo)
static Transform3d	extract_scale (const Transform3d &trafo)
static std::pair< Transform3d, Transform3d >	extract_rotation_scale (const Transform3d &trafo)
static bool	contains_skew (const Transform3d &trafo)
Transform3d	transform3d_from_string (const std::string &transform_str)
Eigen::Quaterniond	rotation_xyz_diff (const Vec3d &rot_xyz_from, const Vec3d &rot_xyz_to)
double	rotation_diff_z (const Transform3d &trafo_from, const Transform3d &trafo_to)
bool	trafos_differ_in_rotation_by_z_and_mirroring_by_xy_only (const Transform3d &t1, const Transform3d &t2)
static Orientation	orient (const Point &a, const Point &b, const Point &c)
static bool	is_ccw (const Polygon &poly)
bool	ray_ray_intersection (const Vec2d &p1, const Vec2d &v1, const Vec2d &p2, const Vec2d &v2, Vec2d &res)
bool	segment_segment_intersection (const Vec2d &p1, const Vec2d &v1, const Vec2d &p2, const Vec2d &v2, Vec2d &res)
bool	segments_intersect (const Slic3r::Point &ip1, const Slic3r::Point &ip2, const Slic3r::Point &jp1, const Slic3r::Point &jp2)
template<typename T >
T	foot_pt (const T &line_pt, const T &line_dir, const T &pt)
Vec2d	foot_pt (const Line &iline, const Point &ipt)
template<typename T >
auto	ray_point_distance_squared (const T &ray_pt, const T &ray_dir, const T &pt)
template<typename T >
auto	ray_point_distance (const T &ray_pt, const T &ray_dir, const T &pt)
double	ray_point_distance_squared (const Line &iline, const Point &ipt)
double	ray_point_distance (const Line &iline, const Point &ipt)
template<typename T >
bool	liang_barsky_line_clipping_interval (const Eigen::Matrix< T, 2, 1, Eigen::DontAlign > &x0, const Eigen::Matrix< T, 2, 1, Eigen::DontAlign > &v, const BoundingBoxBase< Eigen::Matrix< T, 2, 1, Eigen::DontAlign > > &bbox, std::pair< double, double > &out_interval)
template<typename T >
bool	liang_barsky_line_clipping (Eigen::Matrix< T, 2, 1, Eigen::DontAlign > &x0, Eigen::Matrix< T, 2, 1, Eigen::DontAlign > &x1, const BoundingBoxBase< Eigen::Matrix< T, 2, 1, Eigen::DontAlign > > &bbox)
template<typename T >
bool	liang_barsky_line_clipping (const Eigen::Matrix< T, 2, 1, Eigen::DontAlign > &x0src, const Eigen::Matrix< T, 2, 1, Eigen::DontAlign > &x1src, const BoundingBoxBase< Eigen::Matrix< T, 2, 1, Eigen::DontAlign > > &bbox, Eigen::Matrix< T, 2, 1, Eigen::DontAlign > &x0clip, Eigen::Matrix< T, 2, 1, Eigen::DontAlign > &x1clip)
template<typename T >
T	rad2deg (T angle)
template<typename T >
constexpr T	deg2rad (const T angle)
template<typename T >
T	angle_to_0_2PI (T angle)
bool	is_rotation_ninety_degrees (double a)
bool	is_rotation_ninety_degrees (const Vec3d &rotation)
bool	trafos_differ_in_rotation_by_z_and_mirroring_by_xy_only (const Transformation &t1, const Transformation &t2)
template<class Tout = double, class Tin >
std::pair< Tout, Tout >	dir_to_spheric (const Vec< 3, Tin > &n, Tout norm=1.)
template<class T = double>
Vec< 3, T >	spheric_to_dir (double polar, double azimuth)
template<class T = double, class Pair >
Vec< 3, T >	spheric_to_dir (const Pair &v)
template<typename KernelWrapper >
static KernelWrapper::FloatType	cubic_interpolate (const Eigen::ArrayBase< typename KernelWrapper::FloatType > &F, const typename KernelWrapper::FloatType pt)
template<typename Kernel , typename Derived >
static float	bicubic_interpolate (const Eigen::MatrixBase< Derived > &F, const Eigen::Matrix< typename Kernel::FloatType, 2, 1, Eigen::DontAlign > &pt)
Point	circle_center_taubin_newton (const Vec2ds::const_iterator &input_begin, const Vec2ds::const_iterator &input_end, size_t cycles)
	Adapted from work in "Circular and Linear Regression: Fitting circles and lines by least squares", pg 126 Returns a point corresponding to the center of a circle for which all of the points from input_begin to input_end lie on.
Circled	circle_taubin_newton (const Vec2ds &input, size_t cycles)
Circled	circle_ransac (const Vec2ds &input, size_t iterations, double *min_error)
template<typename Vector >
Vector	circle_center (const Vector &a, const Vector &bsrc, const Vector &csrc, typename Vector::Scalar epsilon)
Point	circle_center_taubin_newton (const Points &input, size_t cycles=20)
Vec2d	circle_center_taubin_newton (const Vec2ds &input, size_t cycles=20)
template<typename Vector , typename Points >
CircleSq< Vector >	smallest_enclosing_circle2_welzl (const Points &points, const typename Vector::Scalar epsilon)
template<typename Vector , typename Points >
Circle< Vector >	smallest_enclosing_circle_welzl (const Points &points, const typename Vector::Scalar epsilon)
Circled	smallest_enclosing_circle_welzl (const Points &points)
template<typename T >
int	ray_circle_intersections_r2_lv2_c (T r2, T a, T b, T lv2, T c, std::pair< Eigen::Matrix< T, 2, 1, Eigen::DontAlign >, Eigen::Matrix< T, 2, 1, Eigen::DontAlign > > &out)
template<typename T >
int	ray_circle_intersections (T r, T a, T b, T c, std::pair< Eigen::Matrix< T, 2, 1, Eigen::DontAlign >, Eigen::Matrix< T, 2, 1, Eigen::DontAlign > > &out)
Polygon	convex_hull (Points pts)
Pointf3s	convex_hull (Pointf3s points)
Polygon	convex_hull (const Polygons &polygons)
Polygon	convex_hull (const ExPolygons &expolygons)
Polygon	convex_hulll (const Polylines &polylines)
bool	convex_polygons_intersect (const Polygon &A, const Polygon &B)
std::pair< std::vector< Vec2d >, std::vector< Vec2d > >	decompose_convex_polygon_top_bottom (const std::vector< Vec2d > &src)
bool	inside_convex_polygon (const std::pair< std::vector< Vec2d >, std::vector< Vec2d > > &top_bottom_decomposition, const Vec2d &pt)
template<int Dimension, typename NumberType >
PolynomialCurve< Dimension, NumberType >	fit_polynomial (const std::vector< Vec< Dimension, NumberType > > &observations, const std::vector< NumberType > &observation_points, const std::vector< NumberType > &weights, size_t order)
template<typename Kernel , int Dimension, typename NumberType >
PiecewiseFittedCurve< Dimension, NumberType, Kernel >	fit_curve (const std::vector< Vec< Dimension, NumberType > > &observations, const std::vector< NumberType > &observation_points, const std::vector< NumberType > &weights, size_t segments_count, size_t endpoints_level_of_freedom)
template<int Dimension, typename NumberType >
PiecewiseFittedCurve< Dimension, NumberType, LinearKernel< NumberType > >	fit_linear_spline (const std::vector< Vec< Dimension, NumberType > > &observations, std::vector< NumberType > observation_points, std::vector< NumberType > weights, size_t segments_count, size_t endpoints_level_of_freedom=0)
template<int Dimension, typename NumberType >
PiecewiseFittedCurve< Dimension, NumberType, CubicBSplineKernel< NumberType > >	fit_cubic_bspline (const std::vector< Vec< Dimension, NumberType > > &observations, std::vector< NumberType > observation_points, std::vector< NumberType > weights, size_t segments_count, size_t endpoints_level_of_freedom=0)
template<int Dimension, typename NumberType >
PiecewiseFittedCurve< Dimension, NumberType, CubicCatmulRomKernel< NumberType > >	fit_catmul_rom_spline (const std::vector< Vec< Dimension, NumberType > > &observations, std::vector< NumberType > observation_points, std::vector< NumberType > weights, size_t segments_count, size_t endpoints_level_of_freedom=0)
template<typename VD , typename SEGMENTS >
const VD::point_type	retrieve_cell_point (const typename VD::cell_type &cell, const SEGMENTS &segments)
template<typename VD , typename SEGMENTS >
std::pair< typename VD::coord_type, typename VD::coord_type >	measure_edge_thickness (const VD &vd, const typename VD::edge_type &edge, const SEGMENTS &segments)
static CGAL_Point	to_cgal_point (const VD::vertex_type *pt)
static CGAL_Point	to_cgal_point (const Point &pt)
static CGAL_Point	to_cgal_point (const Vec2d &pt)
static Linef	make_linef (const VD::edge_type &edge)
static bool	is_equal (const VD::vertex_type &first, const VD::vertex_type &second)
static ParabolicSegment	get_parabolic_segment (const VD::edge_type &edge, const std::vector< VoronoiUtils::Segment > &segments)
static CGAL::Orientation	orientation_of_two_edges (const VD::edge_type &edge_a, const VD::edge_type &edge_b, const std::vector< VoronoiUtils::Segment > &segments)
static bool	check_if_three_edges_are_ccw (const VD::edge_type &first, const VD::edge_type &second, const VD::edge_type &third, const std::vector< VoronoiUtils::Segment > &segments)

---

Class Documentation

Slic3r::Geometry::ArrangeItem

class Slic3r::Geometry::ArrangeItem

Collaboration diagram for Slic3r::Geometry::ArrangeItem:

Class Members
coordf_t	dist
size_t	index_x
size_t	index_y
Vec2d	pos = Vec2d::Zero()

Slic3r::Geometry::ParabolicSegment

struct Slic3r::Geometry::ParabolicSegment

Collaboration diagram for Slic3r::Geometry::ParabolicSegment:

Class Members
const Line	directrix
const Point	focus
const Orientation	is_focus_on_left
const Linef	segment

Typedef Documentation

CGAL_Point

using Slic3r::Geometry::CGAL_Point = typedef impl::K::Point_2

Circled

using Slic3r::Geometry::Circled = typedef Circle<Vec2d>

Circlef

using Slic3r::Geometry::Circlef = typedef Circle<Vec2f>

CircleSqd

using Slic3r::Geometry::CircleSqd = typedef CircleSq<Vec2d>

CircleSqf

using Slic3r::Geometry::CircleSqf = typedef CircleSq<Vec2f>

CubicBSplineKernel

template<typename NumberType >

using Slic3r::Geometry::CubicBSplineKernel = typedef CubicKernelWrapper<BicubicInternal::CubicBSplineKernel<NumberType> >

CubicCatmulRomKernel

template<typename NumberType >

using Slic3r::Geometry::CubicCatmulRomKernel = typedef CubicKernelWrapper<BicubicInternal::CubicCatmulRomKernel<NumberType> >

LinearKernel

template<typename NumberType >

using Slic3r::Geometry::LinearKernel = typedef CubicKernelWrapper<BicubicInternal::LinearKernel<NumberType> >

ParabolicTangentToParabolicTangentOrientation

using Slic3r::Geometry::ParabolicTangentToParabolicTangentOrientation = typedef impl::ParabolicTangentToParabolicTangentOrientationPredicateFiltered

ParabolicTangentToSegmentOrientation

using Slic3r::Geometry::ParabolicTangentToSegmentOrientation = typedef impl::ParabolicTangentToSegmentOrientationPredicateFiltered

Enumeration Type Documentation

Orientation

enum Slic3r::Geometry::Orientation

Enumerator
ORIENTATION_CCW
ORIENTATION_CW
ORIENTATION_COLINEAR

{
    ORIENTATION_CCW = 1,
    ORIENTATION_CW = -1,
    ORIENTATION_COLINEAR = 0
};

Function Documentation

angle_to_0_2PI()

template<typename T >

T Slic3r::Geometry::angle_to_0_2PI

(

T

angle

)

{
    static const T TWO_PI = T(2) * T(PI);
    while (angle < T(0))
    {
        angle += TWO_PI;
    }
    while (TWO_PI < angle)
    {
        angle -= TWO_PI;
    }
 
    return angle;
}

References Slic3r::angle(), and PI.

Referenced by Slic3r::Geometry::Transformation::set_rotation().

Here is the call graph for this function:

Here is the caller graph for this function:

arrange()

bool Slic3r::Geometry::arrange	(	size_t	total_parts,
		const Vec2d &	part_size,
		coordf_t	dist,
		const BoundingBoxf *	bb,
		Pointfs &	positions
	)

{
    positions.clear();
 
    Vec2d part = part_size;
 
    // use actual part size (the largest) plus separation distance (half on each side) in spacing algorithm
    part(0) += dist;
    part(1) += dist;
    
    Vec2d area(Vec2d::Zero());
    if (bb != NULL && bb->defined) {
        area = bb->size();
    } else {
        // bogus area size, large enough not to trigger the error below
        area(0) = part(0) * total_parts;
        area(1) = part(1) * total_parts;
    }
    
    // this is how many cells we have available into which to put parts
    size_t cellw = floor((area(0) + dist) / part(0));
    size_t cellh = floor((area(1) + dist) / part(1));
    if (total_parts > (cellw * cellh))
        return false;
    
    // total space used by cells
    Vec2d cells(cellw * part(0), cellh * part(1));
    
    // bounding box of total space used by cells
    BoundingBoxf cells_bb;
    cells_bb.merge(Vec2d(0,0)); // min
    cells_bb.merge(cells);  // max
    
    // center bounding box to area
    cells_bb.translate(
        (area(0) - cells(0)) / 2,
        (area(1) - cells(1)) / 2
    );
    
    // list of cells, sorted by distance from center
    std::vector<ArrangeItemIndex> cellsorder;
    
    // work out distance for all cells, sort into list
    for (size_t i = 0; i <= cellw-1; ++i) {
        for (size_t j = 0; j <= cellh-1; ++j) {
            coordf_t cx = linint(i + 0.5, 0, cellw, cells_bb.min(0), cells_bb.max(0));
            coordf_t cy = linint(j + 0.5, 0, cellh, cells_bb.min(1), cells_bb.max(1));
            
            coordf_t xd = fabs((area(0) / 2) - cx);
            coordf_t yd = fabs((area(1) / 2) - cy);
            
            ArrangeItem c;
            c.pos(0) = cx;
            c.pos(1) = cy;
            c.index_x = i;
            c.index_y = j;
            c.dist = xd * xd + yd * yd - fabs((cellw / 2) - (i + 0.5));
            
            // binary insertion sort
            {
                coordf_t index = c.dist;
                size_t low = 0;
                size_t high = cellsorder.size();
                while (low < high) {
                    size_t mid = (low + ((high - low) / 2)) | 0;
                    coordf_t midval = cellsorder[mid].index;
                    
                    if (midval < index) {
                        low = mid + 1;
                    } else if (midval > index) {
                        high = mid;
                    } else {
                        cellsorder.insert(cellsorder.begin() + mid, ArrangeItemIndex(index, c));
                        goto ENDSORT;
                    }
                }
                cellsorder.insert(cellsorder.begin() + low, ArrangeItemIndex(index, c));
            }
            ENDSORT: ;
        }
    }
    
    // the extents of cells actually used by objects
    coordf_t lx = 0;
    coordf_t ty = 0;
    coordf_t rx = 0;
    coordf_t by = 0;
 
    // now find cells actually used by objects, map out the extents so we can position correctly
    for (size_t i = 1; i <= total_parts; ++i) {
        ArrangeItemIndex c = cellsorder[i - 1];
        coordf_t cx = c.item.index_x;
        coordf_t cy = c.item.index_y;
        if (i == 1) {
            lx = rx = cx;
            ty = by = cy;
        } else {
            if (cx > rx) rx = cx;
            if (cx < lx) lx = cx;
            if (cy > by) by = cy;
            if (cy < ty) ty = cy;
        }
    }
    // now we actually place objects into cells, positioned such that the left and bottom borders are at 0
    for (size_t i = 1; i <= total_parts; ++i) {
        ArrangeItemIndex c = cellsorder.front();
        cellsorder.erase(cellsorder.begin());
        coordf_t cx = c.item.index_x - lx;
        coordf_t cy = c.item.index_y - ty;
        
        positions.push_back(Vec2d(cx * part(0), cy * part(1)));
    }
    
    if (bb != NULL && bb->defined) {
        for (Pointfs::iterator p = positions.begin(); p != positions.end(); ++p) {
            p->x() += bb->min(0);
            p->y() += bb->min(1);
        }
    }
    
    return true;
}

References Slic3r::area(), Slic3r::BoundingBoxBase< PointType, APointsType >::defined, dist(), floor(), linint(), Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::merge(), Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::BoundingBoxBase< PointType, APointsType >::size(), and Slic3r::BoundingBoxBase< PointType, APointsType >::translate().

Here is the call graph for this function:

assemble_transform() [1/4]

Transform3d Slic3r::Geometry::assemble_transform	(	const Transform3d &	translation,
		const Transform3d &	rotation,
		const Transform3d &	scale,
		const Transform3d &	mirror
	)

{
    Transform3d transform;
    assemble_transform(transform, translation, rotation, scale, mirror);
    return transform;
}

References assemble_transform(), scale(), and Slic3r::transform().

Here is the call graph for this function:

assemble_transform() [2/4]

Transform3d Slic3r::Geometry::assemble_transform	(	const Vec3d &	translation,
		const Vec3d &	rotation,
		const Vec3d &	scale,
		const Vec3d &	mirror
	)

{
    Transform3d transform;
    assemble_transform(transform, translation, rotation, scale, mirror);
    return transform;
}

References assemble_transform(), scale(), and Slic3r::transform().

Here is the call graph for this function:

assemble_transform() [3/4]

void Slic3r::Geometry::assemble_transform	(	Transform3d &	transform,
		const Transform3d &	translation,
		const Transform3d &	rotation,
		const Transform3d &	scale,
		const Transform3d &	mirror
	)

{
    transform = translation * rotation * scale * mirror;
}

References scale(), and Slic3r::transform().

Here is the call graph for this function:

assemble_transform() [4/4]

void Slic3r::Geometry::assemble_transform	(	Transform3d &	transform,
		const Vec3d &	translation,
		const Vec3d &	rotation,
		const Vec3d &	scale,
		const Vec3d &	mirror
	)

{
    transform = Transform3d::Identity();
    transform.translate(translation);
    transform.rotate(Eigen::AngleAxisd(rotation(2), Vec3d::UnitZ()) * Eigen::AngleAxisd(rotation(1), Vec3d::UnitY()) * Eigen::AngleAxisd(rotation(0), Vec3d::UnitX()));
    transform.scale(scale.cwiseProduct(mirror));
}

References Eigen::Transform< double, 3, Eigen::Affine, Eigen::DontAlign >::Identity(), scale(), Slic3r::Linef3::scale(), and Slic3r::transform().

Referenced by assemble_transform(), assemble_transform(), and Slic3r::GUI::GLGizmoSlaSupports::update_point_raycasters_for_picking_transform().

Here is the call graph for this function:

Here is the caller graph for this function:

bicubic_interpolate()

template<typename Kernel , typename Derived >

static float Slic3r::Geometry::bicubic_interpolate ( const Eigen::MatrixBase< Derived > &  F, const Eigen::Matrix< typename Kernel::FloatType, 2, 1, Eigen::DontAlign > &  pt  )

static

                                                                               {
    typedef typename Kernel::FloatType T;
    const int w = F.cols();
    const int h = F.rows();
    const int ix = (int) floor(pt[0]);
    const int iy = (int) floor(pt[1]);
    const T s = pt[0] - T( ix);
    const T t = pt[1] - T( iy);
 
    if (ix > 1 && ix + 2 < w && iy > 1 && iy + 2 < h) {
        // Inside the fully interpolated region.
        return Kernel::interpolate(
                Kernel::interpolate(F(ix - 1, iy - 1), F(ix, iy - 1), F(ix + 1, iy - 1), F(ix + 2, iy - 1), s),
                Kernel::interpolate(F(ix - 1, iy), F(ix, iy), F(ix + 1, iy), F(ix + 2, iy), s),
                Kernel::interpolate(F(ix - 1, iy + 1), F(ix, iy + 1), F(ix + 1, iy + 1), F(ix + 2, iy + 1), s),
                Kernel::interpolate(F(ix - 1, iy + 2), F(ix, iy + 2), F(ix + 1, iy + 2), F(ix + 2, iy + 2), s), t);
    }
    // Transition region. Extend with a constant function.
    auto f = [&F, w, h](int x, int y) {
        return F(BicubicInternal::clamp(x, 0, w - 1), BicubicInternal::clamp(y, 0, h - 1));
    };
    return Kernel::interpolate(
            Kernel::interpolate(f(ix - 1, iy - 1), f(ix, iy - 1), f(ix + 1, iy - 1), f(ix + 2, iy - 1), s),
            Kernel::interpolate(f(ix - 1, iy), f(ix, iy), f(ix + 1, iy), f(ix + 2, iy), s),
            Kernel::interpolate(f(ix - 1, iy + 1), f(ix, iy + 1), f(ix + 1, iy + 1), f(ix + 2, iy + 1), s),
            Kernel::interpolate(f(ix - 1, iy + 2), f(ix, iy + 2), f(ix + 1, iy + 2), f(ix + 2, iy + 2), s), t);
}

References Slic3r::Geometry::BicubicInternal::clamp(), Slic3r::f(), Slic3r::F, and floor().

Here is the call graph for this function:

check_if_three_edges_are_ccw()

static bool Slic3r::Geometry::check_if_three_edges_are_ccw ( const VD::edge_type &  first, const VD::edge_type &  second, const VD::edge_type &  third, const std::vector< VoronoiUtils::Segment > &  segments  )

static

{
    assert(is_equal(*first.vertex0(), *second.vertex0()) && is_equal(*second.vertex0(), *third.vertex0()));
 
    CGAL::Orientation orientation = orientation_of_two_edges(first, second, segments);
    if (orientation == CGAL::Orientation::COLLINEAR) {
        // The first two edges are collinear, so the third edge must be on the right side on the first of them.
        return orientation_of_two_edges(first, third, segments) == CGAL::Orientation::RIGHT_TURN;
    } else if (orientation == CGAL::Orientation::LEFT_TURN) {
        // CCW oriented angle between vectors (common_pt, pt1) and (common_pt, pt2) is bellow PI.
        // So we need to check if test_pt isn't between them.
        CGAL::Orientation orientation1 = orientation_of_two_edges(first, third, segments);
        CGAL::Orientation orientation2 = orientation_of_two_edges(second, third, segments);
        return (orientation1 != CGAL::Orientation::LEFT_TURN || orientation2 != CGAL::Orientation::RIGHT_TURN);
    } else {
        assert(orientation == CGAL::Orientation::RIGHT_TURN);
        // CCW oriented angle between vectors (common_pt, pt1) and (common_pt, pt2) is upper PI.
        // So we need to check if test_pt is between them.
        CGAL::Orientation orientation1 = orientation_of_two_edges(first, third, segments);
        CGAL::Orientation orientation2 = orientation_of_two_edges(second, third, segments);
        return (orientation1 == CGAL::Orientation::RIGHT_TURN || orientation2 == CGAL::Orientation::LEFT_TURN);
    }
}

References is_equal(), and orientation_of_two_edges().

Referenced by Slic3r::Geometry::VoronoiUtilsCgal::is_voronoi_diagram_planar_angle().

Here is the call graph for this function:

Here is the caller graph for this function:

circle_center()

template<typename Vector >

Vector Slic3r::Geometry::circle_center	(	const Vector &	a,
		const Vector &	bsrc,
		const Vector &	csrc,
		typename Vector::Scalar	epsilon
	)

{
    using Scalar = typename Vector::Scalar;
    Vector b  = bsrc - a;
    Vector c  = csrc - a;
  Scalar lb = b.squaredNorm();
  Scalar lc = c.squaredNorm();
    if (Scalar d = b.x() * c.y() - b.y() * c.x(); std::abs(d) < epsilon) {
      // The three points are collinear. Take the center of the two points
      // furthest away from each other.
      Scalar lbc = (csrc - bsrc).squaredNorm();
    return Scalar(0.5) * (
      lb > lc && lb > lbc ? a + bsrc :
      lc > lb && lc > lbc ? a + csrc : bsrc + csrc);
    } else {
        Vector v = lc * b - lb * c;
        return a + Vector(- v.y(), v.x()) / (2 * d);
    }
}

Referenced by Slic3r::Geometry::CircleSq< Vector >::CircleSq(), and circle_ransac().

Here is the caller graph for this function:

circle_center_taubin_newton() [1/3]

Point Slic3r::Geometry::circle_center_taubin_newton ( const Points &  input, size_t  cycles = 20  )

inline

{ return circle_center_taubin_newton(input.cbegin(), input.cend(), cycles); }

References circle_center_taubin_newton(), and input().

Here is the call graph for this function:

circle_center_taubin_newton() [2/3]

Vec2d Slic3r::Geometry::circle_center_taubin_newton ( const Vec2ds &  input, size_t  cycles = 20  )

inline

{ return circle_center_taubin_newton(input.cbegin(), input.cend(), cycles); }

References circle_center_taubin_newton(), and input().

Here is the call graph for this function:

circle_center_taubin_newton() [3/3]

Point Slic3r::Geometry::circle_center_taubin_newton	(	const Points::const_iterator &	input_begin,
		const Points::const_iterator &	input_end,
		size_t	cycles
	)

Adapted from work in "Circular and Linear Regression: Fitting circles and lines by least squares", pg 126 Returns a point corresponding to the center of a circle for which all of the points from input_begin to input_end lie on.

Find the center of the circle corresponding to the vector of Pointfs as an arc.

Find the center of the circle corresponding to the vector of Points as an arc.

{
    Vec2ds tmp;
    tmp.reserve(std::distance(input_begin, input_end));
    std::transform(input_begin, input_end, std::back_inserter(tmp), [] (const Point& in) { return unscale(in); } );
    Vec2d center = circle_center_taubin_newton(tmp.cbegin(), tmp.end(), cycles);
  return Point::new_scale(center.x(), center.y());
}

References circle_center_taubin_newton(), and Slic3r::unscale().

Referenced by circle_center_taubin_newton(), circle_center_taubin_newton(), circle_center_taubin_newton(), and circle_taubin_newton().

Here is the call graph for this function:

Here is the caller graph for this function:

circle_ransac()

Circled Slic3r::Geometry::circle_ransac	(	const Vec2ds &	input,
		size_t	iterations,
		double *	min_error
	)

{
    if (input.size() < 3)
        return Circled::make_invalid();
 
    std::mt19937 rng;
    std::vector<Vec2d> samples;
    Circled circle_best = Circled::make_invalid();
    double  err_min = std::numeric_limits<double>::max();
    for (size_t iter = 0; iter < iterations; ++ iter) {
        samples.clear();
        std::sample(input.begin(), input.end(), std::back_inserter(samples), 3, rng);
        Circled c;
        c.center = Geometry::circle_center(samples[0], samples[1], samples[2], EPSILON);
        c.radius = std::accumulate(input.begin(), input.end(), 0., [&c](double acc, const Vec2d& pt) { return (pt - c.center).norm() + acc; });
        c.radius /= double(input.size());
        double err = 0;
        for (const Vec2d &pt : input)
            err = std::max(err, std::abs((pt - c.center).norm() - c.radius));
        if (err < err_min) {
            err_min = err;
            circle_best = c;
        }
    }
    if (min_error)
        *min_error = err_min;
    return circle_best;
}

References circle_center(), EPSILON, input(), and Slic3r::Geometry::Circle< Vector >::make_invalid().

Referenced by Slic3r::BuildVolume::BuildVolume(), and Slic3r::Measure::get_center_and_radius().

Here is the call graph for this function:

Here is the caller graph for this function:

circle_taubin_newton()

Circled Slic3r::Geometry::circle_taubin_newton	(	const Vec2ds &	input,
		size_t	cycles
	)

{
    Circled out;
    if (input.size() < 3) {
        out = Circled::make_invalid();
    } else {
        out.center = circle_center_taubin_newton(input, cycles);
        out.radius = std::accumulate(input.begin(), input.end(), 0., [&out](double acc, const Vec2d& pt) { return (pt - out.center).norm() + acc; });
        out.radius /= double(input.size());
    }
    return out;
}

References Slic3r::Geometry::Circle< Vector >::center, circle_center_taubin_newton(), input(), Slic3r::Geometry::Circle< Vector >::make_invalid(), and Slic3r::Geometry::Circle< Vector >::radius.

Here is the call graph for this function:

contains() [1/2]

template bool Slic3r::Geometry::contains	(	const ExPolygons &	vector,
		const Point &	point
	)

contains() [2/2]

template<class T >

bool Slic3r::Geometry::contains	(	const std::vector< T > &	vector,
		const Point &	point
	)

{
    for (typename std::vector<T>::const_iterator it = vector.begin(); it != vector.end(); ++it) {
        if (it->contains(point)) return true;
    }
    return false;
}

Referenced by Slic3r::GUI::GCodeViewer::refresh_render_paths().

Here is the caller graph for this function:

contains_skew()

static bool Slic3r::Geometry::contains_skew ( const Transform3d &  trafo )

static

{
    Matrix3d rotation;
    Matrix3d scale;
    trafo.computeRotationScaling(&rotation, &scale);
 
    if (scale.isDiagonal())
      return false;
    
    if (scale.determinant() >= 0.0)
      return true;
 
    // the matrix contains mirror
    const Matrix3d ratio = scale.cwiseQuotient(trafo.matrix().block<3,3>(0,0));
 
    auto check_skew = [&ratio](int i, int j, bool& skew) {
      if (!std::isnan(ratio(i, j)) && !std::isnan(ratio(j, i)))
        skew |= std::abs(ratio(i, j) * ratio(j, i) - 1.0) > EPSILON;
    };
 
    bool has_skew = false;
    check_skew(0, 1, has_skew);
    check_skew(0, 2, has_skew);
    check_skew(1, 2, has_skew);
    return has_skew;
}

References Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::computeRotationScaling(), EPSILON, Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::matrix(), and scale().

Referenced by Slic3r::Geometry::Transformation::has_skew().

Here is the call graph for this function:

Here is the caller graph for this function:

convex_hull() [1/4]

Polygon Slic3r::Geometry::convex_hull

(

const ExPolygons &

expolygons

)

{
    Points pp;
    size_t sz = 0;
    for (const auto &expoly : expolygons)
        sz += expoly.contour.size();
    pp.reserve(sz);
    for (const auto &expoly : expolygons)
        pp.insert(pp.end(), expoly.contour.points.begin(), expoly.contour.points.end());
    return convex_hull(pp);
}

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

Here is the call graph for this function:

convex_hull() [2/4]

Polygon Slic3r::Geometry::convex_hull

(

const Polygons &

polygons

)

{
    Points pp;
    for (Polygons::const_iterator p = polygons.begin(); p != polygons.end(); ++p) {
        pp.insert(pp.end(), p->points.begin(), p->points.end());
    }
    return convex_hull(std::move(pp));
}

References convex_hull().

Here is the call graph for this function:

convex_hull() [3/4]

Pointf3s Slic3r::Geometry::convex_hull

(

Pointf3s

points

)

{
    assert(points.size() >= 3);
    // sort input points
    std::sort(points.begin(), points.end(), [](const Vec3d &a, const Vec3d &b){ return a.x() < b.x() || (a.x() == b.x() && a.y() < b.y()); });
 
    int n = points.size(), k = 0;
    Pointf3s hull;
 
    if (n >= 3)
    {
        hull.resize(2 * n);
 
        // Build lower hull
        for (int i = 0; i < n; ++i)
        {
            Point p = Point::new_scale(points[i](0), points[i](1));
            while (k >= 2)
            {
                Point k1 = Point::new_scale(hull[k - 1](0), hull[k - 1](1));
                Point k2 = Point::new_scale(hull[k - 2](0), hull[k - 2](1));
 
                if (Geometry::orient(p, k2, k1) != Geometry::ORIENTATION_CCW)
                    --k;
                else
                    break;
            }
 
            hull[k++] = points[i];
        }
 
        // Build upper hull
        for (int i = n - 2, t = k + 1; i >= 0; --i)
        {
            Point p = Point::new_scale(points[i](0), points[i](1));
            while (k >= t)
            {
                Point k1 = Point::new_scale(hull[k - 1](0), hull[k - 1](1));
                Point k2 = Point::new_scale(hull[k - 2](0), hull[k - 2](1));
 
                if (Geometry::orient(p, k2, k1) != Geometry::ORIENTATION_CCW)
                    --k;
                else
                    break;
            }
 
            hull[k++] = points[i];
        }
 
        hull.resize(k);
 
        assert(hull.front() == hull.back());
        hull.pop_back();
    }
 
    return hull;
}

References orient(), and ORIENTATION_CCW.

Here is the call graph for this function:

convex_hull() [4/4]

Polygon Slic3r::Geometry::convex_hull

(

Points

pts

)

{
    std::sort(pts.begin(), pts.end(), [](const Point& a, const Point& b) { return a.x() < b.x() || (a.x() == b.x() && a.y() < b.y()); });
    pts.erase(std::unique(pts.begin(), pts.end(), [](const Point& a, const Point& b) { return a.x() == b.x() && a.y() == b.y(); }), pts.end());
 
    Polygon hull;
    int n = (int)pts.size();
    if (n >= 3) {
        int k = 0;
        hull.points.resize(2 * n);
        // Build lower hull
        for (int i = 0; i < n; ++ i) {
            while (k >= 2 && Geometry::orient(pts[i], hull[k-2], hull[k-1]) != Geometry::ORIENTATION_CCW)
                -- k;
            hull[k ++] = pts[i];
        }
        // Build upper hull
        for (int i = n-2, t = k+1; i >= 0; i--) {
            while (k >= t && Geometry::orient(pts[i], hull[k-2], hull[k-1]) != Geometry::ORIENTATION_CCW)
                -- k;
            hull[k ++] = pts[i];
        }
        hull.points.resize(k);
        assert(hull.points.front() == hull.points.back());
        hull.points.pop_back();
    }
    return hull;
}

References orient(), ORIENTATION_CCW, Slic3r::MultiPoint::points, and Slic3r::MultiPoint::size().

Referenced by Slic3r::BuildVolume::BuildVolume(), Slic3r::Print::_make_skirt(), Slic3r::TriangleMesh::convex_hull(), convex_hull(), convex_hull(), convex_hulll(), Slic3r::GUI::CameraUtils::create_hull2d(), Slic3r::Print::finalize_first_layer_convex_hull(), Slic3r::generate_extra_perimeters_over_overhangs(), Slic3r::get_arrange_poly(), Slic3r::its_convex_hull_2d_above(), Slic3r::GUI::update_arrangepoly_slaprint(), Slic3r::GUI::GLGizmoFlatten::update_planes(), and Slic3r::GUI::GLCanvas3D::update_sequential_clearance().

Here is the call graph for this function:

Here is the caller graph for this function:

convex_hulll()

Polygon Slic3r::Geometry::convex_hulll

(

const Polylines &

polylines

)

{
    Points pp;
    size_t sz = 0;
    for (const auto &polyline : polylines)
        sz += polyline.points.size();
    pp.reserve(sz);
    for (const auto &polyline : polylines)
        pp.insert(pp.end(), polyline.points.begin(), polyline.points.end());
    return convex_hull(pp);
}

References convex_hull(), and Slic3r::MultiPoint::points.

Here is the call graph for this function:

convex_polygons_intersect()

bool Slic3r::Geometry::convex_polygons_intersect	(	const Polygon &	A,
		const Polygon &	B
	)

{
    using namespace rotcalip;
 
    // Establish starting antipodals as extremes in XY plane. Use the
    // easily obtainable bounding boxes to check if A and B is disjoint
    // and return false if the are.
    struct BB
    {
        size_t         xmin = 0, xmax = 0, ymin = 0, ymax = 0;
        const Polygon &P;
        static bool cmpy(const Point &l, const Point &u)
        {
            return l.y() < u.y() || (l.y() == u.y() && l.x() < u.x());
        }
 
        BB(const Polygon &poly): P{poly}
        {
            for (size_t i = 0; i < P.size(); ++i) {
                if (P[i] < P[xmin]) xmin = i;
                if (P[xmax] < P[i]) xmax = i;
                if (cmpy(P[i], P[ymin])) ymin = i;
                if (cmpy(P[ymax], P[i])) ymax = i;
            }
        }
    };
 
    BB bA{A}, bB{B};
    BoundingBox bbA{{A[bA.xmin].x(), A[bA.ymin].y()}, {A[bA.xmax].x(), A[bA.ymax].y()}};
    BoundingBox bbB{{B[bB.xmin].x(), B[bB.ymin].y()}, {B[bB.xmax].x(), B[bB.ymax].y()}};
 
//    if (!bbA.overlap(bbB))
//        return false;
 
    // Establish starting antipodals as extreme vertex pairs in X or Y direction
    // which reside on different polygons. If no such pair is found, the two
    // polygons are certainly not disjoint.
    Idx imin{bA.xmin, A}, imax{bB.xmax, B};
    if (B[bB.xmin] < imin.pt())  imin = Idx{bB.xmin, B};
    if (imax.pt()  < A[bA.xmax]) imax = Idx{bA.xmax, A};
    if (&imin.poly() == &imax.poly()) {
        imin = Idx{bA.ymin, A};
        imax = Idx{bB.ymax, B};
        if (B[bB.ymin] < imin.pt())  imin = Idx{bB.ymin, B};
        if (imax.pt()  < A[bA.ymax]) imax = Idx{bA.ymax, A};
    }
 
    if (&imin.poly() == &imax.poly())
        return true;
 
    bool found_divisor = false;
    visit_antipodals<AntipodalVisitMode::EdgesOnly>(
        imin, imax,
        [&imin, &imax, &found_divisor](size_t ia, size_t ib, const Point &dir) {
            //        std::cout << "A" << ia << " B" << ib << " dir " <<
            //        dir.x() << " " << dir.y() << std::endl;
            const Polygon &A = imin.poly(), &B = imax.poly();
 
            Point ref_a = A[(ia + 2) % A.size()], ref_b = B[(ib + 2) % B.size()];
 
            bool is_left_a = dotperp( dir, ref_a - A[ia]) > 0;
            bool is_left_b = dotperp(-dir, ref_b - B[ib]) > 0;
 
            // If both reference points are on the left (or right) of their
            // respective support lines and the opposite support line is to
            // the right (or left), the divisor line is found. We only test
            // the reference point, as by definition, if that is on one side,
            // all the other points must be on the same side of a support
            // line. If the support lines are collinear, the polygons must be
            // on the same side of their respective support lines.
 
            auto d = dotperp(dir, B[ib] - A[ia]);
            if (d == 0) {
                // The caliper lines are collinear, not just parallel
                found_divisor = (is_left_a && is_left_b) || (!is_left_a && !is_left_b);
            } else if (d > 0) { // B is to the left of (A, A+1)
                found_divisor = !is_left_a && !is_left_b;
            } else { // B is to the right of (A, A+1)
                found_divisor = is_left_a && is_left_b;
            }
 
            return !found_divisor;
        });
 
    // Intersects if the divisor was not found
    return !found_divisor;
}

References Slic3r::MultiPoint::size().

Here is the call graph for this function:

cubic_interpolate()

template<typename KernelWrapper >

static KernelWrapper::FloatType Slic3r::Geometry::cubic_interpolate ( const Eigen::ArrayBase< typename KernelWrapper::FloatType > &  F, const typename KernelWrapper::FloatType  pt  )

static

                                                  {
    typedef typename KernelWrapper::FloatType T;
    const int w = int(F.size());
    const int ix = (int) floor(pt);
    const T s = pt - T( ix);
 
    if (ix > 1 && ix + 2 < w) {
        // Inside the fully interpolated region.
        return KernelWrapper::interpolate(F[ix - 1], F[ix], F[ix + 1], F[ix + 2], s);
    }
    // Transition region. Extend with a constant function.
    auto f = [&F, w](T x) {
        return F[BicubicInternal::clamp(x, 0, w - 1)];
    };
    return KernelWrapper::interpolate(f(ix - 1), f(ix), f(ix + 1), f(ix + 2), s);
}

References Slic3r::Geometry::BicubicInternal::clamp(), Slic3r::f(), Slic3r::F, and floor().

Here is the call graph for this function:

decompose_convex_polygon_top_bottom()

std::pair< std::vector< Vec2d >, std::vector< Vec2d > > Slic3r::Geometry::decompose_convex_polygon_top_bottom

(

const std::vector< Vec2d > &

src

)

{
    std::pair<std::vector<Vec2d>, std::vector<Vec2d>> out;
    std::vector<Vec2d> &bottom = out.first;
    std::vector<Vec2d> &top    = out.second;
 
    // Find the minimum point.
    auto left_bottom  = std::min_element(src.begin(), src.end(), [](const auto &l, const auto &r) { return l.x() < r.x() || (l.x() == r.x() && l.y() < r.y()); });
    auto right_top    = std::max_element(src.begin(), src.end(), [](const auto &l, const auto &r) { return l.x() < r.x() || (l.x() == r.x() && l.y() < r.y()); });
    if (left_bottom != src.end() && left_bottom != right_top) {
        // Produce the bottom and bottom chains.
        if (left_bottom < right_top) {
            bottom.assign(left_bottom, right_top + 1);
            size_t cnt = (src.end() - right_top) + (left_bottom + 1 - src.begin());
            top.reserve(cnt);
            top.assign(right_top, src.end());
            top.insert(top.end(), src.begin(), left_bottom + 1);
        } else {
            size_t cnt = (src.end() - left_bottom) + (right_top + 1 - src.begin());
            bottom.reserve(cnt);
            bottom.assign(left_bottom, src.end());
            bottom.insert(bottom.end(), src.begin(), right_top + 1);
            top.assign(right_top, left_bottom + 1);
        }
        // Remove strictly vertical segments at the end.
        if (bottom.size() > 1) {
            auto it = bottom.end();
            for (-- it; it != bottom.begin() && (it - 1)->x() == bottom.back().x(); -- it) ;
            bottom.erase(it + 1, bottom.end());
        }
        if (top.size() > 1) {
            auto it = top.end();
            for (-- it; it != top.begin() && (it - 1)->x() == top.back().x(); -- it) ;
            top.erase(it + 1, top.end());
        }
        std::reverse(top.begin(), top.end());
    }
 
    if (top.size() < 2 || bottom.size() < 2) {
        // invalid
        top.clear();
        bottom.clear();
    }
    return out;
}

Referenced by Slic3r::BuildVolume::BuildVolume().

Here is the caller graph for this function:

deg2rad()

template<typename T >

constexpr T Slic3r::Geometry::deg2rad ( const T  angle )

constexpr

{ return T(PI) * angle / T(180.0); }

References Slic3r::angle(), and PI.

Referenced by Slic3r::FFFSupport::SupportParameters::SupportParameters(), Slic3r::WipeTower::finish_layer(), Slic3r::Print::first_layer_wipe_tower_corners(), Slic3r::Arachne::WallToolPaths::generate(), Slic3r::WipeTower::get_wipe_tower_cone_base(), Slic3r::get_wipe_tower_extrusions_extents(), Slic3r::FakeWipeTower::getFakeExtrusionPathsFromWipeTower(), Slic3r::group_fills(), Slic3r::GUI::Bed_2D::repaint(), Slic3r::GUI::Camera::rotate_on_sphere(), Slic3r::CLI::run(), Slic3r::TriangleSelector::seed_fill_select_triangles(), Slic3r::TriangleSelector::select_patch(), Slic3r::GUI::Camera::set_default_orientation(), Slic3r::GLVolumeCollection::set_default_slope_normal_z(), and Slic3r::GUI::GLCanvas3D::Slope::set_normal_angle().

Here is the call graph for this function:

Here is the caller graph for this function:

dir_to_spheric()

template<class Tout = double, class Tin >

std::pair< Tout, Tout > Slic3r::Geometry::dir_to_spheric	(	const Vec< 3, Tin > &	n,
		Tout	norm = 1.
	)

{
    Tout z       = n.z();
    Tout r       = norm;
    Tout polar   = std::acos(z / r);
    Tout azimuth = std::atan2(n(1), n(0));
    return {polar, azimuth};
}

References dir_to_spheric().

Referenced by dir_to_spheric().

Here is the call graph for this function:

Here is the caller graph for this function:

directions_parallel()

bool Slic3r::Geometry::directions_parallel	(	double	angle1,
		double	angle2,
		double	max_diff
	)

{
    double diff = fabs(angle1 - angle2);
    max_diff += EPSILON;
    return diff < max_diff || fabs(diff - PI) < max_diff;
}

References Slic3r::diff(), EPSILON, and PI.

Referenced by Slic3r::BridgeDetector::bridge_direction_candidates(), Slic3r::Line::parallel_to(), and Slic3r::BridgeDetector::unsupported_edges().

Here is the call graph for this function:

Here is the caller graph for this function:

directions_perpendicular()

bool Slic3r::Geometry::directions_perpendicular	(	double	angle1,
		double	angle2,
		double	max_diff
	)

{
    double diff = fabs(angle1 - angle2);
    max_diff += EPSILON;
    return fabs(diff - 0.5 * PI) < max_diff || fabs(diff - 1.5 * PI) < max_diff;
}

References Slic3r::diff(), EPSILON, and PI.

Referenced by Slic3r::Line::perpendicular_to().

Here is the call graph for this function:

Here is the caller graph for this function:

dist()

template<typename T >

T Slic3r::Geometry::dist	(	const boost::polygon::point_data< T > &	p1,
		const boost::polygon::point_data< T > &	p2
	)

{
  T dx = p2(0) - p1(0);
  T dy = p2(1) - p1(1);
  return sqrt(dx*dx+dy*dy);
}

References sqrt().

Referenced by arrange(), Slic3r::GUI::get_arrange_params(), measure_edge_thickness(), Slic3r::GUI::CommonGizmosDataObjects::ObjectClipper::set_position_by_ratio(), and Slic3r::GUI::GLGizmoCut3D::update_clipper().

Here is the call graph for this function:

Here is the caller graph for this function:

extract_rotation() [1/2]

Vec3d Slic3r::Geometry::extract_rotation

(

const Eigen::Matrix< double, 3, 3, Eigen::DontAlign > &

rotation_matrix

)

{
    // The extracted "rotation" is a triplet of numbers such that Geometry::rotation_transform
    // returns the original transform. Because of the chosen order of rotations, the triplet
    // is not equivalent to Euler angles in the usual sense.
    Vec3d angles = rotation_matrix.eulerAngles(2,1,0);
    std::swap(angles(0), angles(2));
    return angles;
}

Referenced by extract_rotation(), Slic3r::Geometry::Transformation::get_rotation(), and Slic3r::Geometry::Transformation::set_rotation().

Here is the caller graph for this function:

extract_rotation() [2/2]

Vec3d Slic3r::Geometry::extract_rotation

(

const Transform3d &

transform

)

{
    // use only the non-translational part of the transform
    Eigen::Matrix<double, 3, 3, Eigen::DontAlign> m = transform.matrix().block(0, 0, 3, 3);
    // remove scale
    m.col(0).normalize();
    m.col(1).normalize();
    m.col(2).normalize();
    return extract_rotation(m);
}

References extract_rotation(), and Slic3r::transform().

Here is the call graph for this function:

extract_rotation_matrix()

static Transform3d Slic3r::Geometry::extract_rotation_matrix ( const Transform3d &  trafo )

static

{
    Matrix3d rotation;
    Matrix3d scale;
    trafo.computeRotationScaling(&rotation, &scale);
    return Transform3d(rotation);
}

References Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::computeRotationScaling(), and scale().

Referenced by Slic3r::Geometry::Transformation::get_rotation(), Slic3r::Geometry::Transformation::get_rotation_matrix(), and Slic3r::Geometry::Transformation::set_scaling_factor().

Here is the call graph for this function:

Here is the caller graph for this function:

extract_rotation_scale()

static std::pair< Transform3d, Transform3d > Slic3r::Geometry::extract_rotation_scale ( const Transform3d &  trafo )

static

{
    Matrix3d rotation;
    Matrix3d scale;
    trafo.computeRotationScaling(&rotation, &scale);
    return { Transform3d(rotation), Transform3d(scale) };
}

References Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::computeRotationScaling(), and scale().

Referenced by Slic3r::Geometry::Transformation::set_mirror(), Slic3r::Geometry::Transformation::set_mirror(), Slic3r::Geometry::Transformation::set_rotation(), and Slic3r::Geometry::Transformation::set_scaling_factor().

Here is the call graph for this function:

Here is the caller graph for this function:

extract_scale()

static Transform3d Slic3r::Geometry::extract_scale ( const Transform3d &  trafo )

static

{
    Matrix3d rotation;
    Matrix3d scale;
    trafo.computeRotationScaling(&rotation, &scale);
    return Transform3d(scale);
}

References Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::computeRotationScaling(), and scale().

Referenced by Slic3r::Geometry::Transformation::get_mirror(), Slic3r::Geometry::Transformation::get_mirror_matrix(), Slic3r::Geometry::Transformation::get_scaling_factor(), Slic3r::Geometry::Transformation::get_scaling_factor_matrix(), and Slic3r::Geometry::Transformation::set_rotation().

Here is the call graph for this function:

Here is the caller graph for this function:

fit_catmul_rom_spline()

template<int Dimension, typename NumberType >

PiecewiseFittedCurve< Dimension, NumberType, CubicCatmulRomKernel< NumberType > > Slic3r::Geometry::fit_catmul_rom_spline	(	const std::vector< Vec< Dimension, NumberType > > &	observations,
		std::vector< NumberType >	observation_points,
		std::vector< NumberType >	weights,
		size_t	segments_count,
		size_t	endpoints_level_of_freedom = 0
	)

                                               {
    return fit_curve<CubicCatmulRomKernel<NumberType>>(observations, observation_points, weights, segments_count,
            endpoints_level_of_freedom);
}

fit_cubic_bspline()

template<int Dimension, typename NumberType >

PiecewiseFittedCurve< Dimension, NumberType, CubicBSplineKernel< NumberType > > Slic3r::Geometry::fit_cubic_bspline	(	const std::vector< Vec< Dimension, NumberType > > &	observations,
		std::vector< NumberType >	observation_points,
		std::vector< NumberType >	weights,
		size_t	segments_count,
		size_t	endpoints_level_of_freedom = 0
	)

                                               {
    return fit_curve<CubicBSplineKernel<NumberType>>(observations, observation_points, weights, segments_count,
            endpoints_level_of_freedom);
}

fit_curve()

template<typename Kernel , int Dimension, typename NumberType >

PiecewiseFittedCurve< Dimension, NumberType, Kernel > Slic3r::Geometry::fit_curve	(	const std::vector< Vec< Dimension, NumberType > > &	observations,
		const std::vector< NumberType > &	observation_points,
		const std::vector< NumberType > &	weights,
		size_t	segments_count,
		size_t	endpoints_level_of_freedom
	)

                                           {
 
    // check to make sure inputs are correct
    assert(segments_count > 0);
    assert(observations.size() > 0);
    assert(observation_points.size() == observations.size());
    assert(observation_points.size() == weights.size());
    assert(segments_count <= observations.size());
 
    //prepare sqrt of weights, which will then be applied to both matrix T and observed data: https://en.wikipedia.org/wiki/Weighted_least_squares
    std::vector<NumberType> sqrt_weights(weights.size());
    for (size_t index = 0; index < weights.size(); ++index) {
        assert(weights[index] > 0);
        sqrt_weights[index] = sqrt(weights[index]);
    }
 
    // prepare result and compute metadata
    PiecewiseFittedCurve<Dimension, NumberType, Kernel> result { };
 
    NumberType valid_length = observation_points.back() - observation_points.front();
    NumberType segment_size = valid_length / NumberType(segments_count);
    result.start = observation_points.front();
    result.segment_size = segment_size;
    result.endpoints_level_of_freedom = endpoints_level_of_freedom;
 
    // prepare observed data
    // Eigen defaults to column major memory layout.
    Eigen::MatrixXf data_points(Dimension, observations.size());
    for (size_t index = 0; index < observations.size(); ++index) {
        data_points.col(index) = observations[index] * sqrt_weights[index];
    }
    // parameters count is always increased by one to make the parametric space of the curve symmetric.
    // without this fix, the end of the curve is less flexible than the beginning
    size_t parameters_count = segments_count + 1 + 2 * endpoints_level_of_freedom;
    //Create weight matrix T for each point and each segment;
    Eigen::MatrixXf T(observation_points.size(), parameters_count);
    T.setZero();
    //Fill the weight matrix
    for (size_t i = 0; i < observation_points.size(); ++i) {
        NumberType observation_point = observation_points[i];
        //find corresponding segment index; expects kernels to be centered
        int middle_right_segment_index = floor((observation_point - result.start) / result.segment_size);
        //find index of first segment that is affected by the point i; this can be deduced from kernel_span
        int start_segment_idx = middle_right_segment_index - int(Kernel::kernel_span / 2) + 1;
        for (int segment_index = start_segment_idx; segment_index < int(start_segment_idx + Kernel::kernel_span);
                segment_index++) {
            NumberType segment_start = result.start + segment_index * result.segment_size;
            NumberType normalized_segment_distance = (segment_start - observation_point) / result.segment_size;
 
            int parameter_index = segment_index + endpoints_level_of_freedom;
            parameter_index = std::clamp(parameter_index, 0, int(parameters_count) - 1);
            T(i, parameter_index) += Kernel::kernel(normalized_segment_distance) * sqrt_weights[i];
        }
    }
 
#ifdef LSQR_DEBUG
    std::cout << "weight matrix: " << std::endl;
    for (int obs = 0; obs < observation_points.size(); ++obs) {
        std::cout << std::endl;
        for (int segment = 0; segment < parameters_count; ++segment) {
            std::cout << T(obs, segment) << "  ";
        }
    }
    std::cout << std::endl;
#endif
 
    // Solve for linear least square fit
    result.coefficients.resize(Dimension, parameters_count);
    const auto QR = T.fullPivHouseholderQr();
    for (size_t dim = 0; dim < Dimension; ++dim) {
        result.coefficients.row(dim) = QR.solve(data_points.row(dim).transpose());
    }
 
    return result;
}

References floor(), segment(), and sqrt().

Here is the call graph for this function:

fit_linear_spline()

template<int Dimension, typename NumberType >

PiecewiseFittedCurve< Dimension, NumberType, LinearKernel< NumberType > > Slic3r::Geometry::fit_linear_spline	(	const std::vector< Vec< Dimension, NumberType > > &	observations,
		std::vector< NumberType >	observation_points,
		std::vector< NumberType >	weights,
		size_t	segments_count,
		size_t	endpoints_level_of_freedom = 0
	)

                                               {
    return fit_curve<LinearKernel<NumberType>>(observations, observation_points, weights, segments_count,
            endpoints_level_of_freedom);
}

fit_polynomial()

template<int Dimension, typename NumberType >

PolynomialCurve< Dimension, NumberType > Slic3r::Geometry::fit_polynomial	(	const std::vector< Vec< Dimension, NumberType > > &	observations,
		const std::vector< NumberType > &	observation_points,
		const std::vector< NumberType > &	weights,
		size_t	order
	)

                                                            {
    // check to make sure inputs are correct
    size_t cols = order + 1;
    assert(observation_points.size() >= cols);
    assert(observation_points.size() == weights.size());
    assert(observations.size() == weights.size());
 
    Eigen::MatrixXf data_points(Dimension, observations.size());
    Eigen::MatrixXf T(observations.size(), cols);
    for (size_t i = 0; i < weights.size(); ++i) {
        auto squared_weight = sqrt(weights[i]);
        data_points.col(i) = observations[i] * squared_weight;
        // Populate the matrix
        auto x = squared_weight;
        auto c = observation_points[i];
        for (size_t j = 0; j < cols; ++j, x *= c)
            T(i, j) = x;
    }
 
    const auto QR = T.householderQr();
    Eigen::MatrixXf coefficients(Dimension, cols);
    // Solve for linear least square fit
    for (size_t dim = 0; dim < Dimension; ++dim) {
        coefficients.row(dim) = QR.solve(data_points.row(dim).transpose());
    }
 
    return {std::move(coefficients)};
}

References sqrt().

Here is the call graph for this function:

foot_pt() [1/2]

Vec2d Slic3r::Geometry::foot_pt ( const Line &  iline, const Point &  ipt  )

inline

{
    return foot_pt<Vec2d>(iline.a.cast<double>(), (iline.b - iline.a).cast<double>(), ipt.cast<double>());
}

References Slic3r::Line::a, and Slic3r::Line::b.

foot_pt() [2/2]

template<typename T >

T Slic3r::Geometry::foot_pt ( const T &  line_pt, const T &  line_dir, const T &  pt  )

inline

{
    T      v   = pt - line_pt;
    auto   l2  = line_dir.squaredNorm();
    auto   t   = (l2 == 0) ? 0 : v.dot(line_dir) / l2;
    return line_pt + line_dir * t;
}

References Slic3r::l2().

Referenced by Slic3r::Voronoi::detail::line_point_equal_distance_points(), Slic3r::Voronoi::detail::point_segment_dr_dl_thresholds(), Slic3r::Voronoi::detail::point_segment_skeleton_thresholds(), ray_point_distance(), ray_point_distance(), ray_point_distance_squared(), and ray_point_distance_squared().

Here is the call graph for this function:

Here is the caller graph for this function:

get_parabolic_segment()

static ParabolicSegment Slic3r::Geometry::get_parabolic_segment ( const VD::edge_type &  edge, const std::vector< VoronoiUtils::Segment > &  segments  )

inlinestatic

{
    assert(edge.is_curved());
 
    const VD::cell_type *left_cell  = edge.cell();
    const VD::cell_type *right_cell = edge.twin()->cell();
 
    const Point                  focus_pt   = VoronoiUtils::getSourcePoint(*(left_cell->contains_point() ? left_cell : right_cell), segments);
    const VoronoiUtils::Segment &directrix  = VoronoiUtils::getSourceSegment(*(left_cell->contains_point() ? right_cell : left_cell), segments);
    CGAL::Orientation            focus_side = CGAL::opposite(CGAL::orientation(to_cgal_point(edge.vertex0()), to_cgal_point(edge.vertex1()), to_cgal_point(focus_pt)));
 
    assert(focus_side == CGAL::Orientation::LEFT_TURN || focus_side == CGAL::Orientation::RIGHT_TURN);
    return {focus_pt, Line(directrix.from(), directrix.to()), make_linef(edge), focus_side};
}

References Slic3r::Arachne::PolygonsSegmentIndex::from(), Slic3r::Arachne::VoronoiUtils::getSourcePoint(), Slic3r::Arachne::VoronoiUtils::getSourceSegment(), make_linef(), Slic3r::Arachne::PolygonsSegmentIndex::to(), and to_cgal_point().

Referenced by orientation_of_two_edges().

Here is the call graph for this function:

Here is the caller graph for this function:

inside_convex_polygon()

bool Slic3r::Geometry::inside_convex_polygon	(	const std::pair< std::vector< Vec2d >, std::vector< Vec2d > > &	top_bottom_decomposition,
		const Vec2d &	pt
	)

{
    auto it_bottom = std::lower_bound(top_bottom_decomposition.first.begin(),  top_bottom_decomposition.first.end(),  pt, [](const auto &l, const auto &r){ return l.x() < r.x(); });
    auto it_top    = std::lower_bound(top_bottom_decomposition.second.begin(), top_bottom_decomposition.second.end(), pt, [](const auto &l, const auto &r){ return l.x() < r.x(); });
    if (it_bottom == top_bottom_decomposition.first.end()) {
        // Above max x.
        assert(it_top == top_bottom_decomposition.second.end());
        return false;
    }
    if (it_bottom == top_bottom_decomposition.first.begin()) {
        // Below or at min x.
        if (pt.x() < it_bottom->x()) {
            // Below min x.
            assert(pt.x() < it_top->x());
            return false;
        }
        // At min x.
        assert(pt.x() == it_bottom->x());
        assert(pt.x() == it_top->x());
        assert(it_bottom->y() <= pt.y() && pt.y() <= it_top->y());
        return pt.y() >= it_bottom->y() && pt.y() <= it_top->y();
    }
 
    // Trapezoid or a triangle.
    assert(it_bottom != top_bottom_decomposition.first .begin() && it_bottom != top_bottom_decomposition.first .end());
    assert(it_top    != top_bottom_decomposition.second.begin() && it_top    != top_bottom_decomposition.second.end());
    assert(pt.x() <= it_bottom->x());
    assert(pt.x() <= it_top->x());
    auto it_top_prev    = it_top - 1;
    auto it_bottom_prev = it_bottom - 1;
    assert(pt.x() >= it_top_prev->x());
    assert(pt.x() >= it_bottom_prev->x());
    double det = cross2(*it_bottom - *it_bottom_prev, pt - *it_bottom_prev);
    if (det < 0)
        return false;
    det = cross2(*it_top - *it_top_prev, pt - *it_top_prev);
    return det <= 0;
}

References Slic3r::cross2().

Referenced by Slic3r::BuildVolume::all_paths_inside_vertices_and_normals_interleaved(), and Slic3r::BuildVolume::object_state().

Here is the call graph for this function:

Here is the caller graph for this function:

is_ccw()

static bool Slic3r::Geometry::is_ccw ( const Polygon &  poly )

inlinestatic

{
    // The polygon shall be at least a triangle.
    assert(poly.points.size() >= 3);
    if (poly.points.size() < 3)
        return true;
 
    // 1) Find the lowest lexicographical point.
    unsigned int imin = 0;
    for (unsigned int i = 1; i < poly.points.size(); ++ i) {
        const Point &pmin = poly.points[imin];
        const Point &p    = poly.points[i];
        if (p(0) < pmin(0) || (p(0) == pmin(0) && p(1) < pmin(1)))
            imin = i;
    }
 
    // 2) Detect the orientation of the corner imin.
    size_t iPrev = ((imin == 0) ? poly.points.size() : imin) - 1;
    size_t iNext = ((imin + 1 == poly.points.size()) ? 0 : imin + 1);
    Orientation o = orient(poly.points[iPrev], poly.points[imin], poly.points[iNext]);
    // The lowest bottom point must not be collinear if the polygon does not contain duplicate points
    // or overlapping segments.
    assert(o != ORIENTATION_COLINEAR);
    return o == ORIENTATION_CCW;
}

References orient(), ORIENTATION_CCW, ORIENTATION_COLINEAR, and Slic3r::MultiPoint::points.

Referenced by Slic3r::ExPolygonWithOffset::ExPolygonWithOffset().

Here is the call graph for this function:

Here is the caller graph for this function:

is_equal()

static bool Slic3r::Geometry::is_equal ( const VD::vertex_type &  first, const VD::vertex_type &  second  )

inlinestatic

{ return first.x() == second.x() && first.y() == second.y(); }

Referenced by check_if_three_edges_are_ccw(), and orientation_of_two_edges().

Here is the caller graph for this function:

is_rotation_ninety_degrees() [1/2]

bool Slic3r::Geometry::is_rotation_ninety_degrees ( const Vec3d &  rotation )

inline

{
    return is_rotation_ninety_degrees(rotation.x()) && is_rotation_ninety_degrees(rotation.y()) && is_rotation_ninety_degrees(rotation.z());
}

References is_rotation_ninety_degrees().

Here is the call graph for this function:

is_rotation_ninety_degrees() [2/2]

bool Slic3r::Geometry::is_rotation_ninety_degrees ( double  a )

inline

{
    a = fmod(std::abs(a), 0.5 * PI);
    if (a > 0.25 * PI)
        a = 0.5 * PI - a;
    return a < 0.001;
}

References PI.

Referenced by Slic3r::GUI::Selection::bake_transform_if_needed(), and is_rotation_ninety_degrees().

Here is the caller graph for this function:

liang_barsky_line_clipping() [1/2]

template<typename T >

bool Slic3r::Geometry::liang_barsky_line_clipping	(	const Eigen::Matrix< T, 2, 1, Eigen::DontAlign > &	x0src,
		const Eigen::Matrix< T, 2, 1, Eigen::DontAlign > &	x1src,
		const BoundingBoxBase< Eigen::Matrix< T, 2, 1, Eigen::DontAlign > > &	bbox,
		Eigen::Matrix< T, 2, 1, Eigen::DontAlign > &	x0clip,
		Eigen::Matrix< T, 2, 1, Eigen::DontAlign > &	x1clip
	)

{
  x0clip = x0src;
  x1clip = x1src;
  return liang_barsky_line_clipping(x0clip, x1clip, bbox);
}

References liang_barsky_line_clipping().

Here is the call graph for this function:

liang_barsky_line_clipping() [2/2]

template<typename T >

bool Slic3r::Geometry::liang_barsky_line_clipping ( Eigen::Matrix< T, 2, 1, Eigen::DontAlign > &  x0, Eigen::Matrix< T, 2, 1, Eigen::DontAlign > &  x1, const BoundingBoxBase< Eigen::Matrix< T, 2, 1, Eigen::DontAlign > > &  bbox  )

inline

{
    Eigen::Matrix<T, 2, 1, Eigen::DontAlign> v = x1 - x0;
    std::pair<double, double> interval;
    if (liang_barsky_line_clipping_interval(x0, v, bbox, interval)) {
        // Clipped successfully.
        x1  = x0 + interval.second * v;
        x0 += interval.first * v;
        return true;
    }
    return false;
}

References liang_barsky_line_clipping_interval().

Referenced by liang_barsky_line_clipping(), and Slic3r::Voronoi::offset().

Here is the call graph for this function:

Here is the caller graph for this function:

liang_barsky_line_clipping_interval()

template<typename T >

bool Slic3r::Geometry::liang_barsky_line_clipping_interval ( const Eigen::Matrix< T, 2, 1, Eigen::DontAlign > &  x0, const Eigen::Matrix< T, 2, 1, Eigen::DontAlign > &  v, const BoundingBoxBase< Eigen::Matrix< T, 2, 1, Eigen::DontAlign > > &  bbox, std::pair< double, double > &  out_interval  )

inline

{
    double t0 = 0.0;
    double t1 = 1.0;
    // Traverse through left, right, bottom, top edges.
    auto clip_side = [&t0, &t1](double p, double q) -> bool {
        if (p == 0) {
            if (q < 0)
                // Line parallel to the bounding box edge is fully outside of the bounding box.
                return false;
            // else don't clip
        } else {
            double r = q / p;
            if (p < 0) {
                if (r > t1)
                    // Fully clipped.
                    return false;
                if (r > t0)
                    // Partially clipped.
                    t0 = r;
            } else {
                assert(p > 0);
                if (r < t0)
                    // Fully clipped.
                    return false;
                if (r < t1)
                    // Partially clipped.
                    t1 = r;
            }
        }
        return true;
    };
 
    if (clip_side(- v.x(), - bbox.min.x() + x0.x()) &&
        clip_side(  v.x(),   bbox.max.x() - x0.x()) &&
        clip_side(- v.y(), - bbox.min.y() + x0.y()) &&
        clip_side(  v.y(),   bbox.max.y() - x0.y())) {
        out_interval.first = t0;
        out_interval.second = t1;
        return true;
    }
    return false;
}

Referenced by liang_barsky_line_clipping(), and Slic3r::line_rounded_thick_segment_collision().

Here is the caller graph for this function:

linint()

double Slic3r::Geometry::linint	(	double	value,
		double	oldmin,
		double	oldmax,
		double	newmin,
		double	newmax
	)

{
    return (value - oldmin) * (newmax - newmin) / (oldmax - oldmin) + newmin;
}

Referenced by arrange().

Here is the caller graph for this function:

make_linef()

static Linef Slic3r::Geometry::make_linef ( const VD::edge_type &  edge )

inlinestatic

{
    const VD::vertex_type *v0 = edge.vertex0();
    const VD::vertex_type *v1 = edge.vertex1();
    return {Vec2d(v0->x(), v0->y()), Vec2d(v1->x(), v1->y())};
}

Referenced by get_parabolic_segment().

Here is the caller graph for this function:

measure_edge_thickness()

template<typename VD , typename SEGMENTS >

std::pair< typename VD::coord_type, typename VD::coord_type > Slic3r::Geometry::measure_edge_thickness ( const VD &  vd, const typename VD::edge_type &  edge, const SEGMENTS &  segments  )

inline

{
    typedef typename VD::coord_type T;
    const typename VD::point_type  pa(edge.vertex0()->x(), edge.vertex0()->y());
    const typename VD::point_type  pb(edge.vertex1()->x(), edge.vertex1()->y());
    const typename VD::cell_type  &cell1 = *edge.cell();
    const typename VD::cell_type  &cell2 = *edge.twin()->cell();
    if (cell1.contains_segment()) {
        if (cell2.contains_segment()) {
            // Both cells contain a linear segment, the left / right cells are symmetric.
            // Project pa, pb to the left segment.
            const typename VD::segment_type segment1 = segments[cell1.source_index()];
            const typename VD::point_type p1a = project_point_to_segment(segment1, pa);
            const typename VD::point_type p1b = project_point_to_segment(segment1, pb);
            return std::pair<T, T>(T(2.)*dist(pa, p1a), T(2.)*dist(pb, p1b));
        } else {
            // 1st cell contains a linear segment, 2nd cell contains a point.
            // The medial axis between the cells is a parabolic arc.
            // Project pa, pb to the left segment.
            const typename  VD::point_type p2 = retrieve_cell_point<VD>(cell2, segments);
            return std::pair<T, T>(T(2.)*dist(pa, p2), T(2.)*dist(pb, p2));
        }
    } else if (cell2.contains_segment()) {
        // 1st cell contains a point, 2nd cell contains a linear segment.
        // The medial axis between the cells is a parabolic arc.
        const typename VD::point_type p1 = retrieve_cell_point<VD>(cell1, segments);
        return std::pair<T, T>(T(2.)*dist(pa, p1), T(2.)*dist(pb, p1));
    } else {
        // Both cells contain a point. The left / right regions are triangular and symmetric.
        const typename VD::point_type p1 = retrieve_cell_point<VD>(cell1, segments);
        return std::pair<T, T>(T(2.)*dist(pa, p1), T(2.)*dist(pb, p1));
    }
}

References dist(), and project_point_to_segment().

Here is the call graph for this function:

orient()

static Orientation Slic3r::Geometry::orient ( const Point &  a, const Point &  b, const Point &  c  )

inlinestatic

{
    static_assert(sizeof(coord_t) * 2 == sizeof(int64_t), "orient works with 32 bit coordinates");
    int64_t u = int64_t(b.x()) * int64_t(c.y()) - int64_t(b.y()) * int64_t(c.x());
    int64_t v = int64_t(a.x()) * int64_t(c.y()) - int64_t(a.y()) * int64_t(c.x());
    int64_t w = int64_t(a.x()) * int64_t(b.y()) - int64_t(a.y()) * int64_t(b.x());
    int64_t d = u - v + w;
    return (d > 0) ? ORIENTATION_CCW : ((d == 0) ? ORIENTATION_COLINEAR : ORIENTATION_CW);
}

References ORIENTATION_CCW, ORIENTATION_COLINEAR, and ORIENTATION_CW.

Referenced by convex_hull(), convex_hull(), and is_ccw().

Here is the caller graph for this function:

orientation_of_two_edges()

static CGAL::Orientation Slic3r::Geometry::orientation_of_two_edges ( const VD::edge_type &  edge_a, const VD::edge_type &  edge_b, const std::vector< VoronoiUtils::Segment > &  segments  )

inlinestatic

                                                                                                                                                             {
    assert(is_equal(*edge_a.vertex0(), *edge_b.vertex0()));
    CGAL::Orientation orientation;
    if (edge_a.is_linear() && edge_b.is_linear()) {
        orientation = CGAL::orientation(to_cgal_point(edge_a.vertex0()), to_cgal_point(edge_a.vertex1()), to_cgal_point(edge_b.vertex1()));
    } else if (edge_a.is_curved() && edge_b.is_curved()) {
        const ParabolicSegment parabolic_a = get_parabolic_segment(edge_a, segments);
        const ParabolicSegment parabolic_b = get_parabolic_segment(edge_b, segments);
        orientation = ParabolicTangentToParabolicTangentOrientation{}(to_cgal_point(parabolic_a.segment.a),
                                                                      to_cgal_point(parabolic_a.focus),
                                                                      to_cgal_point(parabolic_a.directrix.a),
                                                                      to_cgal_point(parabolic_a.directrix.b),
                                                                      parabolic_a.is_focus_on_left,
                                                                      to_cgal_point(parabolic_b.focus),
                                                                      to_cgal_point(parabolic_b.directrix.a),
                                                                      to_cgal_point(parabolic_b.directrix.b),
                                                                      parabolic_b.is_focus_on_left);
        return orientation;
    } else {
        assert(edge_a.is_curved() != edge_b.is_curved());
 
        const VD::edge_type   &linear_edge    = edge_a.is_curved() ? edge_b : edge_a;
        const VD::edge_type   &parabolic_edge = edge_a.is_curved() ? edge_a : edge_b;
        const ParabolicSegment parabolic      = get_parabolic_segment(parabolic_edge, segments);
        orientation = ParabolicTangentToSegmentOrientation{}(to_cgal_point(parabolic.segment.a), to_cgal_point(linear_edge.vertex1()),
                                                             to_cgal_point(parabolic.focus),
                                                             to_cgal_point(parabolic.directrix.a),
                                                             to_cgal_point(parabolic.directrix.b),
                                                             parabolic.is_focus_on_left);
 
        if (edge_b.is_curved())
            orientation = CGAL::opposite(orientation);
    }
 
    return orientation;
}

References Slic3r::Line::a, Slic3r::Linef::a, Slic3r::Line::b, Slic3r::Geometry::ParabolicSegment::directrix, Slic3r::Geometry::ParabolicSegment::focus, get_parabolic_segment(), is_equal(), Slic3r::Geometry::ParabolicSegment::is_focus_on_left, Slic3r::Geometry::ParabolicSegment::segment, and to_cgal_point().

Referenced by check_if_three_edges_are_ccw().

Here is the call graph for this function:

Here is the caller graph for this function:

project_point_to_segment()

template<typename segment_type , typename point_type >

point_type Slic3r::Geometry::project_point_to_segment ( segment_type &  seg, point_type &  px  )

inline

{
    typedef typename point_type::coordinate_type T;
    const point_type &p0 = low(seg);
    const point_type &p1 = high(seg);
    const point_type  dir(p1(0)-p0(0), p1(1)-p0(1));
    const point_type  dproj(px(0)-p0(0), px(1)-p0(1));
    const T           t = (dir(0)*dproj(0) + dir(1)*dproj(1)) / (dir(0)*dir(0) + dir(1)*dir(1));
    assert(t >= T(-1e-6) && t <= T(1. + 1e-6));
    return point_type(p0(0) + t*dir(0), p0(1) + t*dir(1));
}

Referenced by measure_edge_thickness().

Here is the caller graph for this function:

rad2deg()

template<typename T >

T Slic3r::Geometry::rad2deg

(

T

angle

)

{ return T(180.0) * angle / T(PI); }

References Slic3r::angle(), and PI.

Referenced by Slic3r::BridgeDetector::detect_angle(), Slic3r::GUI::Camera::get_fov(), Slic3r::GUI::GLGizmoCut3D::get_tooltip(), Slic3r::GUI::GLGizmoRotate::get_tooltip(), Slic3r::GUI::GLGizmoMeasure::on_render_input_window(), Slic3r::GUI::Plater::priv::on_wipetower_rotated(), Slic3r::GUI::GLGizmoMeasure::render_dimensioning(), Slic3r::TriangleMesh::rotate(), Slic3r::GUI::Camera::rotate_on_sphere(), and Slic3r::GUI::Camera::update_zenit().

Here is the call graph for this function:

Here is the caller graph for this function:

ray_circle_intersections()

template<typename T >

int Slic3r::Geometry::ray_circle_intersections	(	T	r,
		T	a,
		T	b,
		T	c,
		std::pair< Eigen::Matrix< T, 2, 1, Eigen::DontAlign >, Eigen::Matrix< T, 2, 1, Eigen::DontAlign > > &	out
	)

{
    T lv2 = a * a + b * b;
    if (lv2 < T(SCALED_EPSILON * SCALED_EPSILON)) {
        //FIXME what is the correct epsilon?
        // What if the line touches the circle?
        return false;
    }
    return ray_circle_intersections_r2_lv2_c2(r * r, a, b, a * a + b * b, c, out);
}

References SCALED_EPSILON.

ray_circle_intersections_r2_lv2_c()

template<typename T >

int Slic3r::Geometry::ray_circle_intersections_r2_lv2_c	(	T	r2,
		T	a,
		T	b,
		T	lv2,
		T	c,
		std::pair< Eigen::Matrix< T, 2, 1, Eigen::DontAlign >, Eigen::Matrix< T, 2, 1, Eigen::DontAlign > > &	out
	)

{
    T x0 = - a * c;
    T y0 = - b * c;
    T d2 = r2 * lv2 - c * c;
    if (d2 < T(0))
        return 0;
    T d = sqrt(d2);
    out.first.x() = (x0 + b * d) / lv2;
    out.first.y() = (y0 - a * d) / lv2;
    out.second.x() = (x0 - b * d) / lv2;
    out.second.y() = (y0 + a * d) / lv2;
    return d == T(0) ? 1 : 2;
}

References sqrt().

Referenced by Slic3r::line_rounded_thick_segment_collision().

Here is the call graph for this function:

Here is the caller graph for this function:

ray_point_distance() [1/2]

double Slic3r::Geometry::ray_point_distance ( const Line &  iline, const Point &  ipt  )

inline

{
    return (foot_pt(iline, ipt) - ipt.cast<double>()).norm();
}

References foot_pt().

Here is the call graph for this function:

ray_point_distance() [2/2]

template<typename T >

auto Slic3r::Geometry::ray_point_distance ( const T &  ray_pt, const T &  ray_dir, const T &  pt  )

inline

{
    return (foot_pt(ray_pt, ray_dir, pt) - pt).norm();
}

References foot_pt().

Here is the call graph for this function:

ray_point_distance_squared() [1/2]

double Slic3r::Geometry::ray_point_distance_squared ( const Line &  iline, const Point &  ipt  )

inline

{
    return (foot_pt(iline, ipt) - ipt.cast<double>()).squaredNorm();
}

References foot_pt().

Here is the call graph for this function:

ray_point_distance_squared() [2/2]

template<typename T >

auto Slic3r::Geometry::ray_point_distance_squared ( const T &  ray_pt, const T &  ray_dir, const T &  pt  )

inline

{
    return (foot_pt(ray_pt, ray_dir, pt) - pt).squaredNorm();
}

References foot_pt().

Here is the call graph for this function:

ray_ray_intersection()

bool Slic3r::Geometry::ray_ray_intersection ( const Vec2d &  p1, const Vec2d &  v1, const Vec2d &  p2, const Vec2d &  v2, Vec2d &  res  )

inline

{
    double denom = v1(0) * v2(1) - v2(0) * v1(1);
    if (std::abs(denom) < EPSILON)
        return false;
    double t = (v2(0) * (p1(1) - p2(1)) - v2(1) * (p1(0) - p2(0))) / denom;
    res(0) = p1(0) + t * v1(0);
    res(1) = p1(1) + t * v1(1);
    return true;
}

References EPSILON.

retrieve_cell_point()

template<typename VD , typename SEGMENTS >

const VD::point_type Slic3r::Geometry::retrieve_cell_point ( const typename VD::cell_type &  cell, const SEGMENTS &  segments  )

inline

{
    assert(cell.source_category() == boost::polygon::SOURCE_CATEGORY_SEGMENT_START_POINT || cell.source_category() == boost::polygon::SOURCE_CATEGORY_SEGMENT_END_POINT);
    return (cell.source_category() == boost::polygon::SOURCE_CATEGORY_SEGMENT_START_POINT) ? low(segments[cell.source_index()]) : high(segments[cell.source_index()]);
}

rotation_diff_z()

double Slic3r::Geometry::rotation_diff_z	(	const Transform3d &	trafo_from,
		const Transform3d &	trafo_to
	)

{
    auto  m  = trafo_to.linear() * trafo_from.linear().inverse();
    assert(std::abs(m.determinant() - 1) < EPSILON);
    Vec3d vx = m * Vec3d(1., 0., 0);
    // Verify that the linear part of rotation from trafo_from to trafo_to rotates around Z and is unity.
    assert(std::abs(std::hypot(vx.x(), vx.y()) - 1.) < 1e-5);
    assert(std::abs(vx.z()) < 1e-5);
    return atan2(vx.y(), vx.x());
}

References EPSILON, and Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::linear().

Referenced by Slic3r::PrintObject::PrintObject(), Slic3r::Print::sequential_print_horizontal_clearance_valid(), Slic3r::sla_instances(), and Slic3r::GUI::GLCanvas3D::update_sequential_clearance().

Here is the call graph for this function:

Here is the caller graph for this function:

rotation_transform() [1/2]

Transform3d Slic3r::Geometry::rotation_transform

(

const Vec3d &

rotation

)

{
    Transform3d transform;
    rotation_transform(transform, rotation);
    return transform;
}

References rotation_transform(), and Slic3r::transform().

Here is the call graph for this function:

rotation_transform() [2/2]

void Slic3r::Geometry::rotation_transform	(	Transform3d &	transform,
		const Vec3d &	rotation
	)

{
    transform = Transform3d::Identity();
    transform.rotate(Eigen::AngleAxisd(rotation.z(), Vec3d::UnitZ()) * Eigen::AngleAxisd(rotation.y(), Vec3d::UnitY()) * Eigen::AngleAxisd(rotation.x(), Vec3d::UnitX()));
}

References Eigen::Transform< double, 3, Eigen::Affine, Eigen::DontAlign >::Identity(), and Slic3r::transform().

Referenced by Slic3r::GUI::GLCanvas3D::_render_sla_slices(), Slic3r::GUI::GLGizmoCut3D::dragging_grabber_xy(), Slic3r::GUI::GLGizmoCut3D::flip_cut_plane(), Slic3r::GUI::GLGizmoRotate::local_transform(), Slic3r::GUI::CoordAxes::render(), Slic3r::GUI::GLGizmoBase::Grabber::render(), Slic3r::GUI::GLGizmoCut3D::render_cut_plane_grabbers(), Slic3r::GUI::GLGizmoSlaSupports::render_points(), Slic3r::GUI::GLGizmoCut3D::render_rotation_snapping(), Slic3r::GUI::Selection::render_sidebar_position_hints(), Slic3r::GUI::Selection::render_sidebar_rotation_hints(), Slic3r::GUI::Selection::render_sidebar_scale_hints(), Slic3r::GUI::Selection::rotate(), rotation_transform(), Slic3r::Geometry::Transformation::set_rotation(), Slic3r::Geometry::Transformation::set_rotation(), Slic3r::GUI::GCodeViewer::SequentialView::Marker::set_world_position(), Slic3r::GUI::GLGizmoCut3D::update_raycasters_for_picking_transform(), and Slic3r::GUI::GLCanvas3D::update_sequential_clearance().

Here is the call graph for this function:

Here is the caller graph for this function:

rotation_xyz_diff()

Eigen::Quaterniond Slic3r::Geometry::rotation_xyz_diff	(	const Vec3d &	rot_xyz_from,
		const Vec3d &	rot_xyz_to
	)

{
    return
        // From the current coordinate system to world.
        Eigen::AngleAxisd(rot_xyz_to.z(), Vec3d::UnitZ()) * Eigen::AngleAxisd(rot_xyz_to.y(), Vec3d::UnitY()) * Eigen::AngleAxisd(rot_xyz_to.x(), Vec3d::UnitX()) *
        // From world to the initial coordinate system.
        Eigen::AngleAxisd(-rot_xyz_from.x(), Vec3d::UnitX()) * Eigen::AngleAxisd(-rot_xyz_from.y(), Vec3d::UnitY()) * Eigen::AngleAxisd(-rot_xyz_from.z(), Vec3d::UnitZ());
}

Referenced by Slic3r::GUI::is_rotation_xy_synchronized().

Here is the caller graph for this function:

scale_transform() [1/4]

Transform3d Slic3r::Geometry::scale_transform

(

const Vec3d &

scale

)

{
    Transform3d transform;
    scale_transform(transform, scale);
    return transform;
}

References scale(), scale_transform(), and Slic3r::transform().

Here is the call graph for this function:

scale_transform() [2/4]

Transform3d Slic3r::Geometry::scale_transform

(

double

scale

)

{
    return scale_transform(scale * Vec3d::Ones());
}

References scale(), and scale_transform().

Here is the call graph for this function:

scale_transform() [3/4]

void Slic3r::Geometry::scale_transform	(	Transform3d &	transform,
		const Vec3d &	scale
	)

{
    transform = Transform3d::Identity();
    transform.scale(scale);
}

References Eigen::Transform< double, 3, Eigen::Affine, Eigen::DontAlign >::Identity(), scale(), Slic3r::Linef3::scale(), and Slic3r::transform().

Here is the call graph for this function:

scale_transform() [4/4]

void Slic3r::Geometry::scale_transform	(	Transform3d &	transform,
		double	scale
	)

{
    return scale_transform(transform, scale * Vec3d::Ones());
}

References scale(), scale_transform(), and Slic3r::transform().

Referenced by Slic3r::GUI::GLCanvas3D::_render_sla_slices(), Slic3r::GUI::GLGizmoCut3D::is_conflict_for_connector(), Slic3r::GUI::GCodeViewer::load_toolpaths(), Slic3r::GUI::GLGizmoMeasure::on_render(), Slic3r::GUI::GCodeViewer::COG::render(), Slic3r::GUI::GLGizmoBase::Grabber::render(), Slic3r::GUI::GLGizmoCut3D::render_connectors(), Slic3r::GUI::GLGizmoPainterBase::render_cursor_circle(), Slic3r::GUI::GLGizmoPainterBase::render_cursor_sphere(), Slic3r::GUI::GLGizmoCut3D::render_cut_plane_grabbers(), Slic3r::GUI::GLGizmoMeasure::render_dimensioning(), Slic3r::GUI::GLGizmoCut3D::render_grabber_connection(), Slic3r::GUI::GLGizmoHollow::render_points(), Slic3r::GUI::GLGizmoSlaSupports::render_points(), Slic3r::Geometry::Transformation::reset_skew(), Slic3r::GUI::Selection::scale_and_translate(), scale_transform(), scale_transform(), scale_transform(), Slic3r::Geometry::Transformation::set_scaling_factor(), Slic3r::GUI::GLGizmoHollow::update_hole_raycasters_for_picking_transform(), Slic3r::GUI::GLGizmoFlatten::update_planes(), Slic3r::GUI::GLGizmoSlaSupports::update_point_raycasters_for_picking_transform(), and Slic3r::GUI::GLGizmoCut3D::update_raycasters_for_picking_transform().

Here is the call graph for this function:

Here is the caller graph for this function:

segment_segment_intersection()

bool Slic3r::Geometry::segment_segment_intersection ( const Vec2d &  p1, const Vec2d &  v1, const Vec2d &  p2, const Vec2d &  v2, Vec2d &  res  )

inline

{
    double denom = v1(0) * v2(1) - v2(0) * v1(1);
    if (std::abs(denom) < EPSILON)
        // Lines are collinear.
        return false;
    double s12_x = p1(0) - p2(0);
    double s12_y = p1(1) - p2(1);
    double s_numer = v1(0) * s12_y - v1(1) * s12_x;
    bool   denom_is_positive = false;
    if (denom < 0.) {
        denom_is_positive = true;
        denom   = - denom;
        s_numer = - s_numer;
    }
    if (s_numer < 0.)
        // Intersection outside of the 1st segment.
        return false;
    double t_numer = v2(0) * s12_y - v2(1) * s12_x;
    if (! denom_is_positive)
        t_numer = - t_numer;
    if (t_numer < 0. || s_numer > denom || t_numer > denom)
        // Intersection outside of the 1st or 2nd segment.
        return false;
    // Intersection inside both of the segments.
    double t = t_numer / denom;
    res(0) = p1(0) + t * v1(0);
    res(1) = p1(1) + t * v1(1);
    return true;
}

References EPSILON.

segments_intersect()

bool Slic3r::Geometry::segments_intersect ( const Slic3r::Point &  ip1, const Slic3r::Point &  ip2, const Slic3r::Point &  jp1, const Slic3r::Point &  jp2  )

inline

{    
    assert(ip1 != ip2);
    assert(jp1 != jp2);
 
    auto segments_could_intersect = [](
        const Slic3r::Point &ip1, const Slic3r::Point &ip2,
        const Slic3r::Point &jp1, const Slic3r::Point &jp2) -> std::pair<int, int>
    {
        Vec2i64 iv   = (ip2 - ip1).cast<int64_t>();
        Vec2i64 vij1 = (jp1 - ip1).cast<int64_t>();
        Vec2i64 vij2 = (jp2 - ip1).cast<int64_t>();
        int64_t tij1 = cross2(iv, vij1);
        int64_t tij2 = cross2(iv, vij2);
        return std::make_pair(
            // signum
            (tij1 > 0) ? 1 : ((tij1 < 0) ? -1 : 0),
            (tij2 > 0) ? 1 : ((tij2 < 0) ? -1 : 0));
    };
 
    std::pair<int, int> sign1 = segments_could_intersect(ip1, ip2, jp1, jp2);
    std::pair<int, int> sign2 = segments_could_intersect(jp1, jp2, ip1, ip2);
    int                 test1 = sign1.first * sign1.second;
    int                 test2 = sign2.first * sign2.second;
    if (test1 <= 0 && test2 <= 0) {
        // The segments possibly intersect. They may also be collinear, but not intersect.
        if (test1 != 0 || test2 != 0)
            // Certainly not collinear, then the segments intersect.
            return true;
        // If the first segment is collinear with the other, the other is collinear with the first segment.
        assert((sign1.first == 0 && sign1.second == 0) == (sign2.first == 0 && sign2.second == 0));
        if (sign1.first == 0 && sign1.second == 0) {
            // The segments are certainly collinear. Now verify whether they overlap.
            Slic3r::Point vi = ip2 - ip1;
            // Project both on the longer coordinate of vi.
            int axis = std::abs(vi.x()) > std::abs(vi.y()) ? 0 : 1;
            coord_t i = ip1(axis);
            coord_t j = ip2(axis);
            coord_t k = jp1(axis);
            coord_t l = jp2(axis);
            if (i > j)
                std::swap(i, j);
            if (k > l)
                std::swap(k, l);
            return (k >= i && k <= j) || (i >= k && i <= l);
        }
    }
    return false;
}

References Slic3r::cross2().

Referenced by Slic3r::EdgeGrid::Grid::has_intersecting_edges(), Slic3r::EdgeGrid::Grid::intersecting_edges(), and Slic3r::FirstIntersectionVisitor::operator()().

Here is the call graph for this function:

Here is the caller graph for this function:

simplify_polygons()

void Slic3r::Geometry::simplify_polygons	(	const Polygons &	polygons,
		double	tolerance,
		Polygons *	retval
	)

{
    Polygons simplified_raw;
    for (const Polygon &source_polygon : polygons) {
        Points simplified = MultiPoint::douglas_peucker(to_polyline(source_polygon).points, tolerance);
        if (simplified.size() > 3) {
            simplified.pop_back();
            simplified_raw.push_back(Polygon{ std::move(simplified) });
        }
    }
    *retval = Slic3r::simplify_polygons(simplified_raw);
}

References Slic3r::MultiPoint::douglas_peucker(), Slic3r::simplify_polygons(), and Slic3r::to_polyline().

Referenced by Slic3r::Print::_make_skirt().

Here is the call graph for this function:

Here is the caller graph for this function:

smallest_enclosing_circle2_welzl()

template<typename Vector , typename Points >

CircleSq< Vector > Slic3r::Geometry::smallest_enclosing_circle2_welzl	(	const Points &	points,
		const typename Vector::Scalar	epsilon
	)

{
    using Scalar = typename Vector::Scalar;
    CircleSq<Vector> circle;
 
    if (! points.empty()) {
      const auto &p0 = points[0].template cast<Scalar>();
      if (points.size() == 1) {
        circle.center = p0;
        circle.radius2 = epsilon * epsilon;
      } else {
        circle = CircleSq<Vector>(p0, points[1].template cast<Scalar>()).inflated(epsilon);
        for (size_t i = 2; i < points.size(); ++ i)
            if (const Vector &p = points[i].template cast<Scalar>(); ! circle.contains(p)) {
                // p is the first point on the smallest circle enclosing points[0..i]
                circle = CircleSq<Vector>(p0, p).inflated(epsilon);
                for (size_t j = 1; j < i; ++ j)
                    if (const Vector &q = points[j].template cast<Scalar>(); ! circle.contains(q)) {
                        // q is the second point on the smallest circle enclosing points[0..i]
                        circle = CircleSq<Vector>(p, q).inflated(epsilon);
                        for (size_t k = 0; k < j; ++ k)
                            if (const Vector &r = points[k].template cast<Scalar>(); ! circle.contains(r))
                                    circle = CircleSq<Vector>(p, q, r, epsilon).inflated(epsilon);
                    }
            }
    }
  }
 
    return circle;
}

References Slic3r::Geometry::CircleSq< Vector >::center, Slic3r::Geometry::CircleSq< Vector >::contains(), Slic3r::Geometry::CircleSq< Vector >::inflated(), and Slic3r::Geometry::CircleSq< Vector >::radius2.

Here is the call graph for this function:

smallest_enclosing_circle_welzl() [1/2]

Circled Slic3r::Geometry::smallest_enclosing_circle_welzl ( const Points &  points )

inline

{
    return smallest_enclosing_circle_welzl<Vec2d, Points>(points, SCALED_EPSILON);
}

References SCALED_EPSILON.

smallest_enclosing_circle_welzl() [2/2]

template<typename Vector , typename Points >

Circle< Vector > Slic3r::Geometry::smallest_enclosing_circle_welzl	(	const Points &	points,
		const typename Vector::Scalar	epsilon
	)

{
    return Circle<Vector>(smallest_enclosing_circle2_welzl<Vector, Points>(points, epsilon));
}

Referenced by Slic3r::BuildVolume::BuildVolume(), and Slic3r::GUI::Selection::scale_to_fit_print_volume().

Here is the caller graph for this function:

spheric_to_dir() [1/2]

template<class T = double, class Pair >

Vec< 3, T > Slic3r::Geometry::spheric_to_dir

(

const Pair &

v

)

{
    double plr = std::get<0>(v), azm = std::get<1>(v);
    return spheric_to_dir<T>(plr, azm);
}

References spheric_to_dir().

Here is the call graph for this function:

spheric_to_dir() [2/2]

template<class T = double>

Vec< 3, T > Slic3r::Geometry::spheric_to_dir	(	double	polar,
		double	azimuth
	)

{
    return {T(std::cos(azimuth) * std::sin(polar)),
            T(std::sin(azimuth) * std::sin(polar)), T(std::cos(polar))};
}

References spheric_to_dir().

Referenced by spheric_to_dir(), and spheric_to_dir().

Here is the call graph for this function:

Here is the caller graph for this function:

to_cgal_point() [1/3]

static CGAL_Point Slic3r::Geometry::to_cgal_point ( const Point &  pt )

inlinestatic

{ return {pt.x(), pt.y()}; }

to_cgal_point() [2/3]

static CGAL_Point Slic3r::Geometry::to_cgal_point ( const VD::vertex_type *  pt )

inlinestatic

{ return {pt->x(), pt->y()}; }

Referenced by get_parabolic_segment(), Slic3r::Geometry::VoronoiUtilsCgal::is_voronoi_diagram_planar_intersection(), and orientation_of_two_edges().

Here is the caller graph for this function:

to_cgal_point() [3/3]

static CGAL_Point Slic3r::Geometry::to_cgal_point ( const Vec2d &  pt )

inlinestatic

{ return {pt.x(), pt.y()}; }

trafos_differ_in_rotation_by_z_and_mirroring_by_xy_only() [1/2]

bool Slic3r::Geometry::trafos_differ_in_rotation_by_z_and_mirroring_by_xy_only	(	const Transform3d &	t1,
		const Transform3d &	t2
	)

{
    if (std::abs(t1.translation().z() - t2.translation().z()) > EPSILON)
        // One of the object is higher than the other above the build plate (or below the build plate).
        return false;
    Matrix3d m1 = t1.matrix().block<3, 3>(0, 0);
    Matrix3d m2 = t2.matrix().block<3, 3>(0, 0);
    Matrix3d m = m2.inverse() * m1;
    Vec3d    z = m.block<3, 1>(0, 2);
    if (std::abs(z.x()) > EPSILON || std::abs(z.y()) > EPSILON || std::abs(z.z() - 1.) > EPSILON)
        // Z direction or length changed.
        return false;
    // Z still points in the same direction and it has the same length.
    Vec3d    x = m.block<3, 1>(0, 0);
    Vec3d    y = m.block<3, 1>(0, 1);
    if (std::abs(x.z()) > EPSILON || std::abs(y.z()) > EPSILON)
        return false;
    double   lx2 = x.squaredNorm();
    double   ly2 = y.squaredNorm();
    if (lx2 - 1. > EPSILON * EPSILON || ly2 - 1. > EPSILON * EPSILON)
        return false;
    // Verify whether the vectors x, y are still perpendicular.
    double   d   = x.dot(y);
    return std::abs(d * d) < EPSILON * lx2 * ly2;
}

References EPSILON, Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::matrix(), and Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::translation().

Referenced by trafos_differ_in_rotation_by_z_and_mirroring_by_xy_only().

Here is the call graph for this function:

Here is the caller graph for this function:

trafos_differ_in_rotation_by_z_and_mirroring_by_xy_only() [2/2]

bool Slic3r::Geometry::trafos_differ_in_rotation_by_z_and_mirroring_by_xy_only ( const Transformation &  t1, const Transformation &  t2  )

inline

    { return trafos_differ_in_rotation_by_z_and_mirroring_by_xy_only(t1.get_matrix(), t2.get_matrix()); }

References Slic3r::Geometry::Transformation::get_matrix(), and trafos_differ_in_rotation_by_z_and_mirroring_by_xy_only().

Here is the call graph for this function:

transform3d_from_string()

Transform3d Slic3r::Geometry::transform3d_from_string

(

const std::string &

transform_str

)

{
    assert(is_decimal_separator_point()); // for atof
    Transform3d transform = Transform3d::Identity();
 
    if (!transform_str.empty()) {
        std::vector<std::string> mat_elements_str;
        boost::split(mat_elements_str, transform_str, boost::is_any_of(" "), boost::token_compress_on);
 
        const unsigned int size = (unsigned int)mat_elements_str.size();
        if (size == 16) {
            unsigned int i = 0;
            for (unsigned int r = 0; r < 4; ++r) {
                for (unsigned int c = 0; c < 4; ++c) {
                    transform(r, c) = ::atof(mat_elements_str[i++].c_str());
                }
            }
        }
    }
 
    return transform;
}

References Eigen::Transform< double, 3, Eigen::Affine, Eigen::DontAlign >::Identity(), Slic3r::is_decimal_separator_point(), and Slic3r::transform().

Referenced by Slic3r::_3MF_Importer::_generate_volumes(), and Slic3r::AMFParserContext::endElement().

Here is the call graph for this function:

Here is the caller graph for this function:

translation_transform() [1/2]

Transform3d Slic3r::Geometry::translation_transform

(

const Vec3d &

translation

)

{
    Transform3d transform;
    translation_transform(transform, translation);
    return transform;
}

References Slic3r::transform(), and translation_transform().

Here is the call graph for this function:

translation_transform() [2/2]

void Slic3r::Geometry::translation_transform	(	Transform3d &	transform,
		const Vec3d &	translation
	)

{
    transform = Transform3d::Identity();
    transform.translate(translation);
}

References Eigen::Transform< double, 3, Eigen::Affine, Eigen::DontAlign >::Identity(), and Slic3r::transform().

Referenced by Slic3r::GUI::GLGizmoCut3D::PartSelection::PartSelection(), Slic3r::GUI::GLCanvas3D::_render_sla_slices(), Slic3r::GUI::GLGizmoCut3D::dragging_grabber_z(), Slic3r::GUI::GLGizmoCut3D::get_cut_matrix(), Slic3r::Geometry::Transformation::get_offset_matrix(), Slic3r::GUI::init_torus_data(), Slic3r::GUI::GLGizmoCut3D::is_conflict_for_connector(), Slic3r::GUI::GLGizmoCut3D::is_outside_of_cut_contour(), Slic3r::GUI::GCodeViewer::load_toolpaths(), Slic3r::GUI::GLGizmoMove3D::local_transform(), Slic3r::GUI::GLGizmoFlatten::on_register_raycasters_for_picking(), Slic3r::GUI::GLGizmoFlatten::on_render(), Slic3r::GUI::GLGizmoMeasure::on_render(), Slic3r::GUI::Plater::priv::reload_from_disk(), Slic3r::GLVolume::SinkingContours::render(), Slic3r::GUI::GCodeViewer::COG::render(), Slic3r::GUI::CoordAxes::render(), Slic3r::GUI::GLGizmoCut3D::PartSelection::render(), Slic3r::GUI::GLGizmoBase::Grabber::render(), Slic3r::GUI::GLGizmoCut3D::render_connectors(), Slic3r::GUI::GLGizmoPainterBase::render_cursor_circle(), Slic3r::GUI::GLGizmoPainterBase::render_cursor_sphere(), Slic3r::GUI::GLGizmoCut3D::render_cut_plane(), Slic3r::GUI::GLGizmoCut3D::render_cut_plane_grabbers(), Slic3r::GUI::GLGizmoMeasure::render_dimensioning(), Slic3r::GUI::Bed3D::render_model(), Slic3r::GUI::GLGizmoHollow::render_points(), Slic3r::GUI::GLGizmoSlaSupports::render_points(), Slic3r::GUI::GLGizmoCut3D::render_rotation_snapping(), Slic3r::GUI::Selection::render_sidebar_hints(), Slic3r::GUI::Selection::render_sidebar_scale_hints(), Slic3r::GUI::Selection::rotate(), Slic3r::GUI::GLGizmoCut3D::rotate_vec3d_around_plane_center(), Slic3r::CLI::run(), Slic3r::GUI::Selection::scale_and_translate(), Slic3r::GUI::GCodeViewer::SequentialView::Marker::set_world_position(), Slic3r::GUI::GLGizmoCut3D::PartSelection::toggle_selection(), Slic3r::GUI::Selection::transform_instance_relative(), Slic3r::GUI::Selection::transform_volume_relative(), Slic3r::GUI::GLGizmoCut3D::transformed_bounding_box(), Slic3r::GUI::Selection::translate(), Slic3r::GUI::Selection::translate(), translation_transform(), Slic3r::GUI::GLGizmoHollow::update_hole_raycasters_for_picking_transform(), Slic3r::GUI::GLGizmoMeasure::update_if_needed(), Slic3r::GUI::GLGizmoSlaSupports::update_point_raycasters_for_picking_transform(), Slic3r::GUI::GLGizmoCut3D::update_raycasters_for_picking_transform(), and Slic3r::GUI::GLCanvas3D::update_sequential_clearance().

Here is the call graph for this function:

Here is the caller graph for this function: