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_;
    }
 
 
    void SetHypothesesThreshold(double value)
    {
      if (value < 0.5)
        throw std::invalid_argument("HypothesesThreshold must not be < 0.5");
      hypothesesThreshold_ = value;
    }
 
 
    int DerivativePatchSize() const noexcept
    {
      return derivativePatchSize_;
    }
 
 
    void SetDerivativePatchSize(int value)
    {
      if (value < 3)
        throw std::invalid_argument("DerivativePatchSize must not be < 3");
      derivativePatchSize_ = value;
    }
 
 
    double IndifferentRadius() const noexcept
    {
      return indifferentRadius_;
    }
 
 
    void SetIndifferentRadius(double value)
    {
      if (value < 0.5)
        throw std::invalid_argument("IndifferentRadius must not be < 0.5");
      indifferentRadius_ = value;
    }
 
 
    int PartsToFind() const noexcept
    {
      return partsToFind_;
    }
 
 
    void SetPartsToFind(int value)
    {
      if (value < 0)
        throw std::invalid_argument("PartsToFind must not be < 0");
      partsToFind_ = value;
    }
 
 
    bool RawResultsOnly() const noexcept
    {
      return rawResultsOnly_;
    }
 
 
    void SetRawResultsOnly(bool value) noexcept
    {
      rawResultsOnly_ = value;
    }
 
 
    int ICPShrink() const noexcept
    {
      return icpShrink_;
    }
 
 
    void SetICPShrink(int value)
    {
      if (value < 1)
        throw std::invalid_argument("ICPShrink must not be < 1");
      icpShrink_ = value;
    }
 
 
    int ICPMaxIterations() const noexcept
    {
      return icpMaxIterations_;
    }
 
 
    void SetICPMaxIterations(int value)
    {
      if (value < 1)
        throw std::invalid_argument("ICPMaxIterations must not be < 1");
      icpMaxIterations_ = value;
    }
 
 
    double PrecisionThreshold() const noexcept
    {
      return precisionThreshold_;
    }
 
 
    void SetPrecisionThreshold(double value)
    {
      if (value < 0.0)
        throw std::invalid_argument("PrecisionThreshold must not be < 0.0");
      precisionThreshold_ = value;
    }
 
 
    double MinCoverage() const noexcept
    {
      return minCoverage_;
    }
 
 
    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;
    }
 
 
    double MaxOcclusion() const noexcept
    {
      return maxOcclusion_;
    }
 
 
    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;
    }
 
 
    double MaxInconsistency() const noexcept
    {
      return maxInconsistency_;
    }
 
 
    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;
    }
 
 
    double MinScore() const noexcept
    {
      return minScore_;
    }
 
 
    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;
    }
 
  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;
 
 
};
#pragma pack (pop)
 
}
 
CVB_END_INLINE_NS
 
}