Slic3r::opt Namespace Reference

Namespaces
namespace	detail

Classes
struct	always_false
class	Bound
class	Optimizer
class	Optimizer< AlgBruteForce >
class	Optimizer< M, detail::NLoptOnly< M > >
struct	Result
struct	ScoreGradient
class	StopCriteria

Typedefs
using	AlgBruteForce = detail::AlgBurteForce
using	AlgNLoptGenetic = detail::NLoptAlgComb< NLOPT_GN_ESCH >
using	AlgNLoptSubplex = detail::NLoptAlg< NLOPT_LN_SBPLX >
using	AlgNLoptSimplex = detail::NLoptAlg< NLOPT_LN_NELDERMEAD >
using	AlgNLoptCobyla = detail::NLoptAlg< NLOPT_LN_COBYLA >
using	AlgNLoptDIRECT = detail::NLoptAlg< NLOPT_GN_DIRECT >
using	AlgNLoptORIG_DIRECT = detail::NLoptAlg< NLOPT_GN_ORIG_DIRECT >
using	AlgNLoptISRES = detail::NLoptAlg< NLOPT_GN_ISRES >
using	AlgNLoptAGS = detail::NLoptAlg< NLOPT_GN_AGS >
using	AlgNLoptMLSL_Subplx = detail::NLoptAlgComb< NLOPT_GN_MLSL_LDS, NLOPT_LN_SBPLX >
using	AlgNLoptMLSL_Cobyla = detail::NLoptAlgComb< NLOPT_GN_MLSL, NLOPT_LN_COBYLA >
using	AlgNLoptGenetic_Subplx = detail::NLoptAlgComb< NLOPT_GN_ESCH, NLOPT_LN_SBPLX >
template<class T , class O = T>
using	FloatingOnly = std::enable_if_t< std::is_floating_point< T >::value, O >
template<size_t N>
using	Input = std::array< double, N >
template<size_t N>
using	Bounds = std::array< Bound, N >

Functions
template<size_t N>
Bounds< N >	bounds (const Bound(&b)[N])
template<size_t N>
Input< N >	initvals (const double(&a)[N])
template<size_t N>
auto	score_gradient (double s, const double(&grad)[N])

Variables
template<class Alg >
constexpr bool	SupportsEqualities
template<class Alg >
constexpr bool	SupportsInequalities
template<class T , class = FloatingOnly<T>>
constexpr T	NaN = std::numeric_limits<T>::quiet_NaN()
constexpr float	NaNf = NaN<float>
constexpr double	NaNd = NaN<double>

---

Class Documentation

Slic3r::opt::Result

struct Slic3r::opt::Result

template<size_t N>
struct Slic3r::opt::Result< N >

Collaboration diagram for Slic3r::opt::Result< N >:

Class Members
array< double, N >	optimum
int	resultcode
double	score

Typedef Documentation

AlgBruteForce

using Slic3r::opt::AlgBruteForce = typedef detail::AlgBurteForce

AlgNLoptAGS

using Slic3r::opt::AlgNLoptAGS = typedef detail::NLoptAlg<NLOPT_GN_AGS>

AlgNLoptCobyla

using Slic3r::opt::AlgNLoptCobyla = typedef detail::NLoptAlg<NLOPT_LN_COBYLA>

AlgNLoptDIRECT

using Slic3r::opt::AlgNLoptDIRECT = typedef detail::NLoptAlg<NLOPT_GN_DIRECT>

AlgNLoptGenetic

using Slic3r::opt::AlgNLoptGenetic = typedef detail::NLoptAlgComb<NLOPT_GN_ESCH>

AlgNLoptGenetic_Subplx

using Slic3r::opt::AlgNLoptGenetic_Subplx = typedef detail::NLoptAlgComb<NLOPT_GN_ESCH, NLOPT_LN_SBPLX>

AlgNLoptISRES

using Slic3r::opt::AlgNLoptISRES = typedef detail::NLoptAlg<NLOPT_GN_ISRES>

AlgNLoptMLSL_Cobyla

using Slic3r::opt::AlgNLoptMLSL_Cobyla = typedef detail::NLoptAlgComb<NLOPT_GN_MLSL, NLOPT_LN_COBYLA>

AlgNLoptMLSL_Subplx

using Slic3r::opt::AlgNLoptMLSL_Subplx = typedef detail::NLoptAlgComb<NLOPT_GN_MLSL_LDS, NLOPT_LN_SBPLX>

AlgNLoptORIG_DIRECT

using Slic3r::opt::AlgNLoptORIG_DIRECT = typedef detail::NLoptAlg<NLOPT_GN_ORIG_DIRECT>

AlgNLoptSimplex

using Slic3r::opt::AlgNLoptSimplex = typedef detail::NLoptAlg<NLOPT_LN_NELDERMEAD>

AlgNLoptSubplex

using Slic3r::opt::AlgNLoptSubplex = typedef detail::NLoptAlg<NLOPT_LN_SBPLX>

Bounds

template<size_t N>

using Slic3r::opt::Bounds = typedef std::array<Bound, N>

FloatingOnly

template<class T , class O = T>

using Slic3r::opt::FloatingOnly = typedef std::enable_if_t<std::is_floating_point<T>::value, O>

Input

template<size_t N>

using Slic3r::opt::Input = typedef std::array<double, N>

Function Documentation

bounds()

template<size_t N>

Bounds< N > Slic3r::opt::bounds

(

const Bound(&)

b[N]

)

{ return detail::to_arr(b); }

References bounds(), and Slic3r::opt::detail::to_arr().

Referenced by bounds(), Slic3r::sla::find_best_misalignment_rotation(), Slic3r::sla::find_least_supports_rotation(), Slic3r::opt::detail::NLoptOpt< M, class >::optimize(), Slic3r::opt::detail::AlgBurteForce::optimize(), Slic3r::opt::Optimizer< AlgBruteForce >::optimize(), Slic3r::opt::detail::AlgBurteForce::run(), and Slic3r::opt::detail::NLoptOpt< M, class >::set_up().

Here is the call graph for this function:

Here is the caller graph for this function:

initvals()

template<size_t N>

Input< N > Slic3r::opt::initvals

(

const double(&)

a[N]

)

{ return detail::to_arr(a); }

References Slic3r::opt::detail::to_arr().

Referenced by Slic3r::sla::find_best_misalignment_rotation(), and Slic3r::sla::find_least_supports_rotation().

Here is the call graph for this function:

Here is the caller graph for this function:

score_gradient()

template<size_t N>

auto Slic3r::opt::score_gradient	(	double	s,
		const double(&)	grad[N]
	)

{
    return ScoreGradient<N>(s, detail::to_arr(grad));
}

References Slic3r::opt::detail::to_arr().

Here is the call graph for this function:

Variable Documentation

NaN

template<class T , class = FloatingOnly<T>>

constexpr T Slic3r::opt::NaN = std::numeric_limits<T>::quiet_NaN()

constexpr

NaNd

constexpr double Slic3r::opt::NaNd = NaN<double>

constexpr

NaNf

constexpr float Slic3r::opt::NaNf = NaN<float>

constexpr

SupportsEqualities

template<class Alg >

constexpr bool Slic3r::opt::SupportsEqualities

constexpr

Initial value:

=
    detail::AlgFeatures_<remove_cvref_t<Alg>>::SupportsEqualities

SupportsInequalities

template<class Alg >

constexpr bool Slic3r::opt::SupportsInequalities

constexpr

Initial value:

=
    detail::AlgFeatures_<remove_cvref_t<Alg>>::SupportsInequalities