#include "libslic3r_version.h"
#include <deque>
#include <iterator>
#include <functional>
#include <initializer_list>
#include <limits>
#include <utility>
#include <memory>
#include <array>
#include <algorithm>
#include <ostream>
#include <iostream>
#include <math.h>
#include <queue>
#include <sstream>
#include <cstdio>
#include <stdint.h>
#include <stdarg.h>
#include <vector>
#include <cassert>
#include <cmath>
#include <type_traits>
#include <optional>
#include "Semver.hpp"

Include dependency graph for libslic3r.h:

Classes
struct	Slic3r::is_scaled_coord< I >
class	Slic3r::Range< It >

Namespaces
namespace	Slic3r
	\|/ Copyright (c) Prusa Research 2020 - 2023 Enrico Turri @enricoturri1966 \|/ \|/ PrusaSlicer is released under the terms of the AGPLv3 or higher \|/

Macros
#define	SLIC3R_APP_FULL_NAME "Orca Slicer"
#define	GCODEVIEWER_APP_NAME "OrcaSlicer G-code Viewer"
#define	GCODEVIEWER_APP_KEY "OrcaSlicerGcodeViewer"
#define	GCODEVIEWER_BUILD_ID std::string("OrcaSlicer G-code Viewer-") + std::string(SLIC3R_VERSION) + std::string("-RC")
#define	POLY_SIDE_COUNT 24
#define	SCALED_RESOLUTION (RESOLUTION / SCALING_FACTOR)
#define	SCALED_SPARSE_INFILL_RESOLUTION (SPARSE_INFILL_RESOLUTION / SCALING_FACTOR)
#define	SCALED_SUPPORT_RESOLUTION (SUPPORT_RESOLUTION / SCALING_FACTOR)
#define	SMALL_PERIMETER_LENGTH(LENGTH)
#define	scale_(val)
#define	unscale_(val)
#define	SCALED_EPSILON scale_(EPSILON)
#define	UNUSED(x)

Typedefs
using	coord_t = int64_t
using	coordf_t = double
template<class T, class Allocator = std::allocator<T>>
using	Slic3r::deque
template<class T, class O = T>
using	Slic3r::FloatingOnly = std::enable_if_t<std::is_floating_point<T>::value, O>
template<class T, class O = T>
using	Slic3r::ScaledCoordOnly = std::enable_if_t<is_scaled_coord<T>::value, O>
template<class T, class O = T>
using	Slic3r::IntegerOnly = std::enable_if_t<std::is_integral<T>::value, O>
template<class T, class O = T>
using	Slic3r::ArithmeticOnly = std::enable_if_t<std::is_arithmetic<T>::value, O>
template<class T, class O = T>
using	Slic3r::IteratorOnly
template<class T>
using	Slic3r::remove_cvref_t = std::remove_cv_t<std::remove_reference_t<T>>

Enumerations
enum	Slic3r::Axis { Slic3r::X =0 , Slic3r::Y , Slic3r::Z , Slic3r::E , Slic3r::F , Slic3r::I , Slic3r::J , Slic3r::P , Slic3r::NUM_AXES , Slic3r::UNKNOWN_AXIS = NUM_AXES , Slic3r::NUM_AXES_WITH_UNKNOWN }

Functions
template<typename T, typename Q>
T	Slic3r::unscale (Q v)
template<typename T, typename Alloc, typename Alloc2>
void	Slic3r::append (std::vector< T, Alloc > &dest, const std::vector< T, Alloc2 > &src)
template<typename T, typename Alloc>
void	Slic3r::append (std::vector< T, Alloc > &dest, std::vector< T, Alloc > &&src)
template<class T, class... Args>
void	Slic3r::clear_and_shrink (std::vector< T, Args... > &vec)
template<typename T>
void	Slic3r::append_reversed (std::vector< T > &dest, const std::vector< T > &src)
template<typename T>
void	Slic3r::append_reversed (std::vector< T > &dest, std::vector< T > &&src)
template<typename T_TO, typename T_FROM>
std::vector< T_TO >	Slic3r::cast (const std::vector< T_FROM > &src)
template<typename T>
void	Slic3r::remove_nulls (std::vector< T * > &vec)
template<typename T>
void	Slic3r::sort_remove_duplicates (std::vector< T > &vec)
template<typename T, typename... Args>
std::unique_ptr< T >	Slic3r::make_unique (Args &&... args)
template<class ForwardIt, class LowerThanKeyPredicate>
ForwardIt	Slic3r::lower_bound_by_predicate (ForwardIt first, ForwardIt last, LowerThanKeyPredicate lower_than_key)
template<class ForwardIt, class T, class Compare = std::less<>>
ForwardIt	Slic3r::binary_find (ForwardIt first, ForwardIt last, const T &value, Compare comp={})
template<class ForwardIt, class LowerThanKeyPredicate, class EqualToKeyPredicate>
ForwardIt	Slic3r::binary_find_by_predicate (ForwardIt first, ForwardIt last, LowerThanKeyPredicate lower_thank_key, EqualToKeyPredicate equal_to_key)
template<typename ContainerType, typename ValueType>
bool	Slic3r::contains (const ContainerType &c, const ValueType &v)
template<typename T>
bool	Slic3r::contains (const std::initializer_list< T > &il, const T &v)
template<typename ContainerType, typename ValueType>
bool	Slic3r::one_of (const ValueType &v, const ContainerType &c)
template<typename T>
bool	Slic3r::one_of (const T &v, const std::initializer_list< T > &il)
template<typename T>
constexpr T	Slic3r::sqr (T x)
template<typename Number>
constexpr bool	Slic3r::is_zero (Number value)
template<typename T, typename Number>
constexpr T	Slic3r::lerp (const T &a, const T &b, Number t)
template<typename Number>
constexpr bool	Slic3r::is_approx (Number value, Number test_value, Number precision=EPSILON)
template<typename Number>
constexpr bool	Slic3r::is_approx (const std::optional< Number > &value, const std::optional< Number > &test_value)
template<class T, class I, class... Args>
IntegerOnly< I, std::vector< T, Args... > >	Slic3r::reserve_vector (I capacity)
template<class Cont>
auto	Slic3r::range (Cont &&cont)
template<typename I>
IntegerOnly< I, I >	Slic3r::fast_round_up (double a)

Variables
static constexpr double	EPSILON = 1e-4
static constexpr double	SCALING_FACTOR_INTERNAL = 0.000001
static constexpr double	SCALING_FACTOR_INTERNAL_LARGE_PRINTER = 0.00001
static constexpr double	LARGE_BED_THRESHOLD = 2147
static constexpr size_t	MAXIMUM_EXTRUDER_NUMBER = 64
static constexpr size_t	MAXIMUM_AMS_SYNC_FILAMENT_NUMBER = 16
static constexpr float	MAX_LINE_WIDTH_MULTIPLIER = 5
double	SCALING_FACTOR
static constexpr double	PI = 3.141592653589793238
static constexpr double	RESOLUTION = 0.0125
static constexpr double	SPARSE_INFILL_RESOLUTION = 0.04
static constexpr double	SUPPORT_RESOLUTION = 0.0375
static constexpr double	INSET_OVERLAP_TOLERANCE = 0.4
static constexpr double	EXTERNAL_INFILL_MARGIN = 3
static constexpr double	BRIDGE_INFILL_MARGIN = 1
static constexpr double	WIPE_TOWER_MARGIN = 1.
static constexpr double	WIPE_TOWER_AUTO_MARGIN = 15.
static constexpr bool	g_config_support_sharp_tails = true
static constexpr bool	g_config_remove_small_overhangs = true
static constexpr float	g_config_tree_support_collision_resolution = 0.2
Semver	Slic3r::SEMVER { SLIC3R_VERSION }
template<class T, class = FloatingOnly<T>>
constexpr T	Slic3r::NaN = std::numeric_limits<T>::quiet_NaN()
constexpr float	Slic3r::NaNf = NaN<float>
constexpr double	Slic3r::NaNd = NaN<double>