OrcaSlicer latest
OrcaSlicer
Loading...
Searching...
No Matches
Point.hpp File Reference
#include "libslic3r.h"
#include <Eigen/Core>
#include <algorithm>
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <type_traits>
#include <iterator>
#include <ostream>
#include <utility>
#include <limits>
#include <optional>
#include <functional>
#include <vector>
#include <cmath>
#include <string>
#include <sstream>
#include <unordered_map>
#include <oneapi/tbb/scalable_allocator.h>
#include <Eigen/Geometry>
#include "LocalesUtils.hpp"
#include <boost/version.hpp>
#include <boost/polygon/polygon.hpp>
Include dependency graph for Point.hpp:

Go to the source code of this file.

Classes

class  Slic3r::Point
class  Slic3r::Point3
struct  Slic3r::PointHash
class  Slic3r::ClosestPointInRadiusLookup< ValueType, PointAccessor >
struct  Slic3r::MinMax< T >
struct  std::hash< Slic3r::Vec2ds >
struct  std::hash< std::vector< int > >
struct  boost::polygon::geometry_concept< Slic3r::Point >
struct  boost::polygon::point_traits< Slic3r::Point >
struct  boost::polygon::point_mutable_traits< Slic3r::Point >

Namespaces

namespace  Slic3r
 |/ Copyright (c) Prusa Research 2020 - 2023 Enrico Turri @enricoturri1966 |/ |/ PrusaSlicer is released under the terms of the AGPLv3 or higher |/
namespace  Slic3r::int128
namespace  std
 STL namespace.
namespace  boost
namespace  boost::polygon
namespace  cereal
 External Cereal serialization of ExPolygons.
namespace  Eigen

Typedefs

using Slic3r::Vector = Point
template<int N, int M, class T>
using Slic3r::Mat = Eigen::Matrix<T, N, M, Eigen::DontAlign, N, M>
template<int N, class T>
using Slic3r::Vec = Mat<N, 1, T>
using Slic3r::Vec2crd = Eigen::Matrix<coord_t, 2, 1, Eigen::DontAlign>
using Slic3r::Vec3crd = Eigen::Matrix<coord_t, 3, 1, Eigen::DontAlign>
using Slic3r::Vec2i32 = Eigen::Matrix<int32_t, 2, 1, Eigen::DontAlign>
using Slic3r::Vec2i64 = Eigen::Matrix<int64_t, 2, 1, Eigen::DontAlign>
using Slic3r::Vec3i32 = Eigen::Matrix<int32_t, 3, 1, Eigen::DontAlign>
using Slic3r::Vec3i64 = Eigen::Matrix<int64_t, 3, 1, Eigen::DontAlign>
using Slic3r::Vec4i32 = Eigen::Matrix<int32_t, 4, 1, Eigen::DontAlign>
using Slic3r::Vec2f = Eigen::Matrix<float, 2, 1, Eigen::DontAlign>
using Slic3r::Vec3f = Eigen::Matrix<float, 3, 1, Eigen::DontAlign>
using Slic3r::Vec4f = Eigen::Matrix<float, 4, 1, Eigen::DontAlign>
using Slic3r::Vec2d = Eigen::Matrix<double, 2, 1, Eigen::DontAlign>
using Slic3r::Vec3d = Eigen::Matrix<double, 3, 1, Eigen::DontAlign>
using Slic3r::Vec4d = Eigen::Matrix<double, 4, 1, Eigen::DontAlign>
template<typename BaseType>
using Slic3r::PointsAllocator = tbb::scalable_allocator<BaseType>
using Slic3r::Points = std::vector<Point, PointsAllocator<Point>>
using Slic3r::PointPtrs = std::vector<Point*>
using Slic3r::PointConstPtrs = std::vector<const Point*>
using Slic3r::Points3 = std::vector<Point3, PointsAllocator<Point3>>
using Slic3r::Pointfs = std::vector<Vec2d>
using Slic3r::Vec2ds = std::vector<Vec2d>
using Slic3r::Pointf3s = std::vector<Vec3d>
using Slic3r::VecOfPoints = std::vector<Points, PointsAllocator<Points>>
using Slic3r::Matrix2f = Eigen::Matrix<float, 2, 2, Eigen::DontAlign>
using Slic3r::Matrix2d = Eigen::Matrix<double, 2, 2, Eigen::DontAlign>
using Slic3r::Matrix3f = Eigen::Matrix<float, 3, 3, Eigen::DontAlign>
using Slic3r::Matrix3d = Eigen::Matrix<double, 3, 3, Eigen::DontAlign>
using Slic3r::Matrix4f = Eigen::Matrix<float, 4, 4, Eigen::DontAlign>
using Slic3r::Matrix4d = Eigen::Matrix<double, 4, 4, Eigen::DontAlign>
template<int N, class T>
using Slic3r::Transform = Eigen::Transform<float, N, Eigen::Affine, Eigen::DontAlign>
using Slic3r::Transform2f = Eigen::Transform<float, 2, Eigen::Affine, Eigen::DontAlign>
using Slic3r::Transform2d = Eigen::Transform<double, 2, Eigen::Affine, Eigen::DontAlign>
using Slic3r::Transform3f = Eigen::Transform<float, 3, Eigen::Affine, Eigen::DontAlign>
using Slic3r::Transform3d = Eigen::Transform<double, 3, Eigen::Affine, Eigen::DontAlign>

Functions

Polyline Slic3r::to_polyline (const Points &points)
Polyline3 Slic3r::to_polyline (const Points3 &points)
Points Slic3r::to_points (const Points3 &points3)
Points3 Slic3r::to_points3 (const Points &points)
template<int N, class T>
Transform< N, T > Slic3r::identity ()
bool Slic3r::operator< (const Vec2d &lhs, const Vec2d &rhs)
template<int Options>
int32_t Slic3r::cross2 (const Eigen::MatrixBase< Eigen::Matrix< int32_t, 2, 1, Options > > &v1, const Eigen::MatrixBase< Eigen::Matrix< int32_t, 2, 1, Options > > &v2)=delete
template<typename T, int Options>
T Slic3r::cross2 (const Eigen::MatrixBase< Eigen::Matrix< T, 2, 1, Options > > &v1, const Eigen::MatrixBase< Eigen::Matrix< T, 2, 1, Options > > &v2)
template<typename Derived, typename Derived2>
Derived::Scalar Slic3r::cross2 (const Eigen::MatrixBase< Derived > &v1, const Eigen::MatrixBase< Derived2 > &v2)
template<typename Derived>
Eigen::Matrix< typename Derived::Scalar, 2, 1, Eigen::DontAlign > Slic3r::perp (const Eigen::MatrixBase< Derived > &v)
template<typename Derived, typename Derived2>
double Slic3r::angle (const Eigen::MatrixBase< Derived > &v1, const Eigen::MatrixBase< Derived2 > &v2)
template<typename Derived>
Eigen::Matrix< typename Derived::Scalar, 2, 1, Eigen::DontAlign > Slic3r::to_2d (const Eigen::MatrixBase< Derived > &ptN)
template<typename Derived>
Eigen::Matrix< typename Derived::Scalar, 3, 1, Eigen::DontAlign > Slic3r::to_3d (const Eigen::MatrixBase< Derived > &pt, const typename Derived::Scalar z)
Vec2d Slic3r::unscale (coord_t x, coord_t y)
Vec2d Slic3r::unscale (const Vec2crd &pt)
Vec2d Slic3r::unscale (const Vec2d &pt)
Vec3d Slic3r::unscale (coord_t x, coord_t y, coord_t z)
Vec3d Slic3r::unscale (const Vec3crd &pt)
Vec3d Slic3r::unscale (const Vec3d &pt)
std::string Slic3r::to_string (const Vec2crd &pt)
std::string Slic3r::to_string (const Vec2d &pt)
std::string Slic3r::to_string (const Vec3crd &pt)
std::string Slic3r::to_string (const Vec3d &pt)
std::vector< Vec3f > Slic3r::transform (const std::vector< Vec3f > &points, const Transform3f &t)
Pointf3s Slic3r::transform (const Pointf3s &points, const Transform3d &t)
bool Slic3r::has_reflection (const Transform3d &transform)
 Check whether transformation matrix contains odd number of mirroring. NOTE: In code is sometime function named is_left_handed.
const Vec3d Slic3r::get_base (unsigned index, const Transform3d &transform)
 Getter on base of transformation matrix.
const Vec3d Slic3r::get_x_base (const Transform3d &transform)
const Vec3d Slic3r::get_y_base (const Transform3d &transform)
const Vec3d Slic3r::get_z_base (const Transform3d &transform)
const Vec3d Slic3r::get_base (unsigned index, const Transform3d::LinearPart &transform)
const Vec3d Slic3r::get_x_base (const Transform3d::LinearPart &transform)
const Vec3d Slic3r::get_y_base (const Transform3d::LinearPart &transform)
const Vec3d Slic3r::get_z_base (const Transform3d::LinearPart &transform)
bool Slic3r::operator< (const Point &l, const Point &r)
Point Slic3r::operator* (const Point &l, const double &r)
void Slic3r::append_points (Points &dst, const Points3 &src)
Point3 Slic3r::operator* (const Point3 &l, const double &r)
std::ostream & Slic3r::operator<< (std::ostream &os, const Point &pt)
bool Slic3r::is_approx (const Point &p1, const Point &p2, coord_t epsilon=coord_t(SCALED_EPSILON))
bool Slic3r::is_approx (const Vec2f &p1, const Vec2f &p2, float epsilon=float(EPSILON))
bool Slic3r::is_approx (const Vec2d &p1, const Vec2d &p2, double epsilon=EPSILON)
bool Slic3r::is_approx (const Vec3f &p1, const Vec3f &p2, float epsilon=float(EPSILON))
bool Slic3r::is_approx (const Vec3d &p1, const Vec3d &p2, double epsilon=EPSILON)
Point Slic3r::lerp (const Point &a, const Point &b, double t)
Point3 Slic3r::lerp (const Point3 &a, const Point3 &b, double t)
template<bool IncludeBoundary>
BoundingBox Slic3r::get_extents (const Points &pts)
template BoundingBox Slic3r::get_extents< false > (const Points &pts)
template BoundingBox Slic3r::get_extents< true > (const Points &pts)
template<bool IncludeBoundary>
BoundingBox Slic3r::get_extents (const VecOfPoints &pts)
template BoundingBox Slic3r::get_extents< false > (const VecOfPoints &pts)
template BoundingBox Slic3r::get_extents< true > (const VecOfPoints &pts)
BoundingBoxf Slic3r::get_extents (const std::vector< Vec2d > &pts)
bool Slic3r::has_duplicate_points (Points &&pts)
bool Slic3r::has_duplicate_points (const Points &pts)
bool Slic3r::has_duplicate_successive_points (const Points &pts)
bool Slic3r::has_duplicate_successive_points_closed (const Points &pts)
Points Slic3r::collect_duplicates (Points pts)
bool Slic3r::shorter_then (const Point &p0, const coord_t len)
int Slic3r::int128::orient (const Vec2crd &p1, const Vec2crd &p2, const Vec2crd &p3)
int Slic3r::int128::cross (const Vec2crd &v1, const Vec2crd &v2)
std::ostream & Slic3r::operator<< (std::ostream &stm, const Vec2d &pointf)
template<class Tout, class Tin, class = FloatingOnly<Tin>>
constexpr FloatingOnly< Tout > Slic3r::scaled (const Tin &v) noexcept
template<class Tout = coord_t, class Tin, class = FloatingOnly<Tin>>
constexpr ScaledCoordOnly< Tout > Slic3r::scaled (const Tin &v) noexcept
template<class Tout = coord_t, class Tin, int N, class = FloatingOnly<Tin>, int... EigenArgs>
Eigen::Matrix< ArithmeticOnly< Tout >, N, EigenArgs... > Slic3r::scaled (const Eigen::Matrix< Tin, N, EigenArgs... > &v)
template<class Tout = double, class Tin, class = ArithmeticOnly<Tin>, class = FloatingOnly<Tout>>
constexpr Tout Slic3r::unscaled (const Tin &v) noexcept
template<class Tout = double, class Tin, int N, class = ArithmeticOnly<Tin>, class = FloatingOnly<Tout>, int... EigenArgs>
constexpr Eigen::Matrix< Tout, N, EigenArgs... > Slic3r::unscaled (const Eigen::Matrix< Tin, N, EigenArgs... > &v) noexcept
coord_t Slic3r::align_to_grid (const coord_t coord, const coord_t spacing)
Point Slic3r::align_to_grid (Point coord, Point spacing)
coord_t Slic3r::align_to_grid (coord_t coord, coord_t spacing, coord_t base)
Point Slic3r::align_to_grid (Point coord, Point spacing, Point base)
template<typename T>
static bool Slic3r::apply (std::optional< T > &val, const MinMax< T > &limit)
template<typename T>
static bool Slic3r::apply (T &val, const MinMax< T > &limit)
template<class Archive>
void cereal::serialize (Archive &archive, Slic3r::Vec2i32 &v)
template<class Archive>
void cereal::serialize (Archive &archive, Slic3r::Vec3i32 &v)
template<class Archive>
void cereal::serialize (Archive &archive, Slic3r::Vec2i64 &v)
template<class Archive>
void cereal::serialize (Archive &archive, Slic3r::Vec3i64 &v)
template<class Archive>
void cereal::serialize (Archive &archive, Slic3r::Vec2f &v)
template<class Archive>
void cereal::serialize (Archive &archive, Slic3r::Vec3f &v)
template<class Archive>
void cereal::serialize (Archive &archive, Slic3r::Vec2d &v)
template<class Archive>
void cereal::serialize (Archive &archive, Slic3r::Vec3d &v)
template<class Archive>
void cereal::load (Archive &archive, Slic3r::Matrix2f &m)
template<class Archive>
void cereal::save (Archive &archive, Slic3r::Matrix2f &m)
template<class Archive>
void cereal::load (Archive &archive, Slic3r::Transform3d &m)
template<class Archive>
void cereal::save (Archive &archive, const Slic3r::Transform3d &m)
template<class T, int N, int M>
T * Eigen::begin (Slic3r::Mat< N, M, T > &mat)
template<class T, int N, int M>
T * Eigen::end (Slic3r::Mat< N, M, T > &mat)
template<class T, int N, int M>
const T * Eigen::begin (const Slic3r::Mat< N, M, T > &mat)
template<class T, int N, int M>
const T * Eigen::end (const Slic3r::Mat< N, M, T > &mat)

Variables

const auto & Slic3r::identity3f = identity<3, float>
const auto & Slic3r::identity3d = identity<3, double>

Class Documentation

◆ Slic3r::MinMax

struct Slic3r::MinMax
template<typename T>
struct Slic3r::MinMax< T >
Inheritance diagram for Slic3r::MinMax< T >:
Collaboration diagram for Slic3r::MinMax< T >:
Class Members
T max
T min

◆ boost::polygon::geometry_concept< Slic3r::Point >

struct boost::polygon::geometry_concept< Slic3r::Point >
Class Members
typedef point_concept type point_concept