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

}