teach_parameters.hpp

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


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

      TeachParameters() = default;


      double HeightSensitivity() const noexcept
      {
        return heightSensitivity_;
      }
      double HeightSensitivity() const noexcept {…}


      void SetHeightSensitivity(double value)
      {
        if (value < 0.0)
          throw std::invalid_argument("HeightSensitivity must not be < 0.0");
        heightSensitivity_ = value;
      }
      void SetHeightSensitivity(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) {…}


      int LocalDistributionSize() const noexcept
      {
        return localDistributionSize_;
      }
      int LocalDistributionSize() const noexcept {…}


      void SetLocalDistributionSize(int value)
      {
        if (value < 0)
          throw std::invalid_argument("LocalDistributionSize must not be < 0");
        localDistributionSize_ = value;
      }
      void SetLocalDistributionSize(int value) {…}


      int NumGradientFeatures() const noexcept
      {
        return numGradientFeatures_;
      }
      int NumGradientFeatures() const noexcept {…}


      void SetNumGradientFeatures(int value)
      {
        if (value < 0)
          throw std::invalid_argument("NumGradientFeatures must not be < 0");
        numGradientFeatures_ = value;
      }
      void SetNumGradientFeatures(int value) {…}


      int NumNormalFeatures() const noexcept
      {
        return numNormalFeatures_;
      }
      int NumNormalFeatures() const noexcept {…}


      void SetNumNormalFeatures(int value)
      {
        if (value < 0)
          throw std::invalid_argument("NumNormalFeatures must not be < 0");
        numNormalFeatures_ = value;
      }
      void SetNumNormalFeatures(int value) {…}


      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) {…}


      double DistanceKernelSize() const noexcept
      {
        return distanceKernelSize_;
      }
      double DistanceKernelSize() const noexcept {…}


      void SetDistanceKernelSize(double value)
      {
        if (value < 1.0)
          throw std::invalid_argument("DistanceKernelSize must not be < 1.0");
        distanceKernelSize_ = value;
      }
      void SetDistanceKernelSize(double value) {…}
 
    private:
      double heightSensitivity_  = 1.0;
      int derivativePatchSize_   = 3;
      int localDistributionSize_ = 8;
      int numGradientFeatures_   = 100;
      int numNormalFeatures_     = 100;
      int icpShrink_             = 4;
      double distanceKernelSize_ = 2.0;
    };
    class TeachParameters final {…};
#pragma pack(pop)
 
  }  // namespace Dnc
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb