barcode_grading.hpp

#pragma once
 
#include "../../_cexports/c_barcode.h"
#include "grader_config_base.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  namespace Barcode
  {
 
 
    class BarcodeGrading : public GraderConfigBase
    {
    public:
 
 
      void SetGradeDecode(bool decode)
      {
        SetDirty();
        decode_ = decode;
      };
 
 
      bool GradeDecode() const
      {
        return decode_;
      };
 
 
      void SetGradeReflectanceMin(bool reflectanceMin)
      {
        SetDirty();
        reflectanceMin_ = reflectanceMin;
      };
 
 
      bool GradeReflectanceMin() const
      {
        return reflectanceMin_;
      };
 
 
 
      void SetGradeEdgeContrastMin(bool edgeContrastMin)
      {
        SetDirty();
        edgeContrastMin_ = edgeContrastMin;
      };
 
 
      bool GradeEdgeContrastMin() const
      {
        return edgeContrastMin_;
      };
 
 
 
      void SetGradeDefects(bool defects)
      {
        SetDirty();
        defects_ = defects;
      };
 
 
      bool GradeDefects() const
      {
        return defects_;
      };
 
 
 
      void SetGradeDecodability(bool decodability)
      {
        SetDirty();
        decodability_ = decodability;
      };
 
 
      bool GradeDecodability() const
      {
        return decodability_;
      };
 
    protected:
      SmartBool decode_;
      SmartBool reflectanceMin_;
      SmartBool edgeContrastMin_;
      SmartBool defects_;
      SmartBool decodability_;
 
    public:
      virtual Symbology Type() const override { return Symbology::BarcodeGrading; };
 
 
      static std::unique_ptr<BarcodeGrading> FromHandle(const HandleGuard<ReaderConfig>& guard, bool& isActiveOut)
      {
        auto pConfig = std::unique_ptr<BarcodeGrading>(new BarcodeGrading());
        isActiveOut = pConfig->ReadFromHandle(guard);
        return pConfig;
      }
 
    protected:
      virtual bool ReadFromHandle_(const HandleGuard<ReaderConfig>& guard) override
      {
        short rMin, rMax;
        CExports::cvbbool_t active;
        CVB_CALL_CAPI(CvcBcGetCodeGrading1DEx(reinterpret_cast<std::intptr_t>(guard.Handle()),
          &active,
          &rMin,
          &rMax,
          decode_.Ptr(),
          reflectanceMin_.Ptr(),
          symbolContrast_.Ptr(),
          edgeContrastMin_.Ptr(),
          modulation_.Ptr(),
          defects_.Ptr(),
          decodability_.Ptr()));
        reflectanceReference_ = Cvb::ValueRange<int>(rMin, rMax);
 
        return SmartBool(active);
      }
 
      virtual void WriteToHandle_(bool active, HandleGuard<ReaderConfig>& guard) override
      {
        Internal::DoResCall([&]()
        {
          return CVB_CALL_CAPI(CvcBcSetCodeGrading1DEx(reinterpret_cast<intptr_t>(guard.Handle()),
            SmartBool(active),
            static_cast<short>(reflectanceReference_.Min()), static_cast<short>(reflectanceReference_.Max()),
            decode_,
            reflectanceMin_,
            symbolContrast_,
            edgeContrastMin_,
            modulation_,
            defects_,
            decodability_));
        });
      }
 
      BarcodeGrading()
        : GraderConfigBase()
      {
      }
 
 
    };
 
    using BarcodeGradingPtr = std::shared_ptr<BarcodeGrading>;
  }
 
  CVB_END_INLINE_NS
}