Slic3r::opt::detail::AlgBurteForce Struct Reference

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

Collaboration diagram for Slic3r::opt::detail::AlgBurteForce:

Public Member Functions
	AlgBurteForce (const StopCriteria &cr, size_t gs)
template<int D, size_t N, class Fn, class Cmp>
bool	run (std::array< size_t, N > &idx, Result< N > &result, const Bounds< N > &bounds, Fn &&fn, Cmp &&cmp)
template<class Fn, size_t N>
Result< N >	optimize (Fn &&fn, const Input< N > &, const Bounds< N > &bounds)

Public Attributes
bool	to_min
StopCriteria	stc
size_t	gridsz

Detailed Description

Constructor & Destructor Documentation

AlgBurteForce()

Slic3r::opt::detail::AlgBurteForce::AlgBurteForce ( const StopCriteria & cr, size_t gs )

inline

: stc{cr}, gridsz{gs} {}

References gridsz, and stc.

Member Function Documentation

optimize()

template<class Fn, size_t N>

Result< N > Slic3r::opt::detail::AlgBurteForce::optimize ( Fn && fn, const Input< N > & , const Bounds< N > & bounds )

inline

    {
        std::array<size_t, N> idx = {};
        Result<N> result;
 
        if (to_min) {
            result.score = std::numeric_limits<double>::max();
            run<int(N) - 1>(idx, result, bounds, std::forward<Fn>(fn),
                            std::less<double>{});
        }
        else {
            result.score = std::numeric_limits<double>::lowest();
            run<int(N) - 1>(idx, result, bounds, std::forward<Fn>(fn),
                            std::greater<double>{});
        }
 
        return result;
    }

References Slic3r::opt::bounds(), run(), Slic3r::opt::Result< N >::score, and to_min.

Here is the call graph for this function:

run()

template<int D, size_t N, class Fn, class Cmp>

bool Slic3r::opt::detail::AlgBurteForce::run ( std::array< size_t, N > & idx, Result< N > & result, const Bounds< N > & bounds, Fn && fn, Cmp && cmp )

inline

    {
        if (stc.stop_condition()) return false;
 
        if constexpr (D < 0) { // Let's evaluate fn
            Input<N> inp;
 
            auto max_iter = stc.max_iterations();
            if (max_iter && num_iter(idx, gridsz) >= max_iter)
                return false;
 
            for (size_t d = 0; d < N; ++d) {
                const Bound &b = bounds[d];
                double step = (b.max() - b.min()) / (gridsz - 1);
                inp[d] = b.min() + idx[d] * step;
            }
 
            auto score = fn(inp);
            if (cmp(score, result.score)) { // Change current score to the new
                double absdiff = std::abs(score - result.score);
 
                result.score = score;
                result.optimum = inp;
 
                // Check if the required precision is reached.
                if (absdiff < stc.abs_score_diff() ||
                    absdiff < stc.rel_score_diff() * std::abs(score))
                    return false;
            }
 
        } else {
            for (size_t i = 0; i < gridsz; ++i) {
                idx[D] = i; // Mark the current grid position and dig down
                if (!run<D - 1>(idx, result, bounds, std::forward<Fn>(fn),
                                std::forward<Cmp>(cmp)))
                    return false;
            }
        }
 
        return true;
    }

References Slic3r::opt::bounds(), gridsz, Slic3r::opt::Bound::max(), Slic3r::opt::Bound::min(), Slic3r::opt::detail::num_iter(), Slic3r::opt::Result< N >::optimum, run(), Slic3r::opt::Result< N >::score, and stc.

Referenced by optimize(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

gridsz

size_t Slic3r::opt::detail::AlgBurteForce::gridsz

Referenced by AlgBurteForce(), and run().

stc

StopCriteria Slic3r::opt::detail::AlgBurteForce::stc

Referenced by AlgBurteForce(), and run().

to_min

bool Slic3r::opt::detail::AlgBurteForce::to_min

Referenced by optimize().

---

The documentation for this struct was generated from the following file:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Optimize/BruteforceOptimizer.hpp