search_parameters.hpp

#pragma once
 
#include "dnc.hpp"
 
#include "../value_range.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  namespace Dnc
  {


#pragma pack(push, 4)
    class SearchParameters final
    {
    public:

      SearchParameters() = default;


      double HypothesesThreshold() const noexcept
      {
        return hypothesesThreshold_;
      }
      double HypothesesThreshold() const noexcept {…}


      void SetHypothesesThreshold(double value)
      {
        if (value < 0.5)
          throw std::invalid_argument("HypothesesThreshold must not be < 0.5");
        hypothesesThreshold_ = value;
      }
      void SetHypothesesThreshold(double value) {…}


      int DerivativePatchSize() const noexcept
      {
        return derivativePatchSize_;
      }
      int DerivativePatchSize() const noexcept {…}


      void SetDerivativePatchSize(int value)
      {
        if (value < 3)
          throw std::invalid_argument("DerivativePatchSize must not be < 3");
        derivativePatchSize_ = value;
      }
      void SetDerivativePatchSize(int value) {…}


      double IndifferentRadius() const noexcept
      {
        return indifferentRadius_;
      }
      double IndifferentRadius() const noexcept {…}


      void SetIndifferentRadius(double value)
      {
        if (value < 0.5)
          throw std::invalid_argument("IndifferentRadius must not be < 0.5");
        indifferentRadius_ = value;
      }
      void SetIndifferentRadius(double value) {…}


      int PartsToFind() const noexcept
      {
        return partsToFind_;
      }
      int PartsToFind() const noexcept {…}


      void SetPartsToFind(int value)
      {
        if (value < 0)
          throw std::invalid_argument("PartsToFind must not be < 0");
        partsToFind_ = value;
      }
      void SetPartsToFind(int value) {…}


      bool RawResultsOnly() const noexcept
      {
        return rawResultsOnly_;
      }
      bool RawResultsOnly() const noexcept {…}


      void SetRawResultsOnly(bool value) noexcept
      {
        rawResultsOnly_ = value;
      }
      void SetRawResultsOnly(bool value) noexcept {…}


      int ICPShrink() const noexcept
      {
        return icpShrink_;
      }
      int ICPShrink() const noexcept {…}


      void SetICPShrink(int value)
      {
        if (value < 1)
          throw std::invalid_argument("ICPShrink must not be < 1");
        icpShrink_ = value;
      }
      void SetICPShrink(int value) {…}


      int ICPMaxIterations() const noexcept
      {
        return icpMaxIterations_;
      }
      int ICPMaxIterations() const noexcept {…}


      void SetICPMaxIterations(int value)
      {
        if (value < 1)
          throw std::invalid_argument("ICPMaxIterations must not be < 1");
        icpMaxIterations_ = value;
      }
      void SetICPMaxIterations(int value) {…}


      double PrecisionThreshold() const noexcept
      {
        return precisionThreshold_;
      }
      double PrecisionThreshold() const noexcept {…}


      void SetPrecisionThreshold(double value)
      {
        if (value < 0.0)
          throw std::invalid_argument("PrecisionThreshold must not be < 0.0");
        precisionThreshold_ = value;
      }
      void SetPrecisionThreshold(double value) {…}


      double MinCoverage() const noexcept
      {
        return minCoverage_;
      }
      double MinCoverage() const noexcept {…}


      void SetMinCoverage(double value)
      {
        if (!IsInRange(value, ValueRange<double>(0.0, 1.0)))
          throw std::invalid_argument("MinCoverage must be in range 0..1");
        minCoverage_ = value;
      }
      void SetMinCoverage(double value) {…}


      double MaxOcclusion() const noexcept
      {
        return maxOcclusion_;
      }
      double MaxOcclusion() const noexcept {…}


      void SetMaxOcclusion(double value)
      {
        if (!IsInRange(value, ValueRange<double>(0.0, 1.0)))
          throw std::invalid_argument("MaxOcclusion must be in range 0..1");
        maxOcclusion_ = value;
      }
      void SetMaxOcclusion(double value) {…}


      double MaxInconsistency() const noexcept
      {
        return maxInconsistency_;
      }
      double MaxInconsistency() const noexcept {…}


      void SetMaxInconsistency(double value)
      {
        if (!IsInRange(value, ValueRange<double>(0.0, 1.0)))
          throw std::invalid_argument("MaxInconsistency must be in range 0..1");
        maxInconsistency_ = value;
      }
      void SetMaxInconsistency(double value) {…}


      double MinScore() const noexcept
      {
        return minScore_;
      }
      double MinScore() const noexcept {…}


      void SetMinScore(double value)
      {
        if (!IsInRange(value, ValueRange<double>(0.0, 1.0)))
          throw std::invalid_argument("MinScore must be in range 0..1");
        minScore_ = value;
      }
      void SetMinScore(double value) {…}
 
    private:
      template <class T>
      bool IsInRange(T value, ValueRange<T> range)
      {
        return value <= range.Max() && value >= range.Min();
      }
 
      double hypothesesThreshold_ = 0.7;
      int derivativePatchSize_    = 5;
      double indifferentRadius_   = 0.6;
      int partsToFind_            = 0;
      bool rawResultsOnly_        = false;
      int icpShrink_              = 4;
      int icpMaxIterations_       = 10;
      double precisionThreshold_  = 2.0;
      double minCoverage_         = 0.7;
      double maxOcclusion_        = 0.2;
      double maxInconsistency_    = 0.2;
      double minScore_            = 0.7;
    };
    class SearchParameters final {…};
#pragma pack(pop)
 
  }  // namespace Dnc
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb