tolerance.h

浏览该文件的文档.

#pragma once
#include <Eigen/Core>
#include <cmath>
#include <limits>
#include <vector>
 
namespace vde::foundation {
 
class Tolerance {
public:
    Tolerance(double absolute = 1e-6, double relative = 1e-8,
              double angular = 1e-8, double snapping = 1e-4)
        : absolute_(absolute), relative_(relative),
          angular_(angular), snapping_(snapping) {}
 
    // ── 判定 ──
 
    bool points_equal(const Eigen::MatrixXd& a, const Eigen::MatrixXd& b) const {
        return (a - b).norm() < absolute_;
    }
 
    template <typename T>
    bool is_zero(T value) const {
        return std::abs(value) < absolute_;
    }
 
    template <typename T>
    bool equals(T a, T b) const {
        return std::abs(a - b) < absolute_ + relative_ * std::max(std::abs(a), std::abs(b));
    }
 
    double absolute() const { return absolute_; }
    double relative() const { return relative_; }
    double angular()  const { return angular_; }
    double snapping() const { return snapping_; }
 
    // ── 分层容差：继承并收紧 ──
 
    Tolerance tighten(double factor = 0.1) const {
        return Tolerance(absolute_ * factor, relative_ * factor, angular_ * factor, snapping_ * factor);
    }
 
    Tolerance relax(double factor = 10.0) const {
        return Tolerance(absolute_ * factor, relative_ * factor, angular_ * factor, snapping_ * factor);
    }
 
    static Tolerance min(const Tolerance& a, const Tolerance& b) {
        return Tolerance(std::min(a.absolute_, b.absolute_),
                        std::min(a.relative_, b.relative_),
                        std::min(a.angular_, b.angular_),
                        std::min(a.snapping_, b.snapping_));
    }
 
    // ── 全局实例 ──
 
    static Tolerance& global() { return global_; }
 
    static void set_global(const Tolerance& tol) { global_ = tol; }
 
    // ── 默认建模容差等级 ──
 
    static constexpr double Modeling()  { return 1e-6; }
    static constexpr double Fitting()   { return 1e-3; }
    static constexpr double Intersection() { return 1e-8; }
    static constexpr double Snapping()  { return 1e-4; }
 
private:
    double absolute_;
    double relative_;
    double angular_;
    double snapping_;
    static Tolerance global_;
};
 
class ToleranceScope {
public:
    explicit ToleranceScope(const Tolerance& tol) : previous_(Tolerance::global()) {
        Tolerance::set_global(tol);
    }
 
    ~ToleranceScope() { Tolerance::set_global(previous_); }
 
private:
    Tolerance previous_;
};
 
}  // namespace vde::foundation