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
}