qr_grading.hpp

#pragma once

#include "../../_cexports/c_barcode.h"
#include "grader_2d_config_base.hpp"

namespace Cvb
{
  CVB_BEGIN_INLINE_NS

  namespace Barcode
  {


    class QrGrading : public Grader2DConfigBase
    {
    public:


      void SetExpectReducedQuietzone(bool expectReducedQuietzone)
      {
        SetDirty();
        expectReducedQuietzone_ = expectReducedQuietzone;
      };


      bool ExpectReducedQuietzone() const
      {
        return expectReducedQuietzone_;
      };



      void SetGradeFormatInformation(bool formatInformation)
      {
        SetDirty();
        formatInformation_ = formatInformation;
      };


      bool GradeFormatInformation() const
      {
        return formatInformation_;
      };



      void SetGradeVersionInformation(bool versionInformation)
      {
        SetDirty();
        versionInformation_ = versionInformation;
      };


      bool GradeVersionInformation() const
      {
        return versionInformation_;
      };


    protected:
      SmartBool expectReducedQuietzone_;
      SmartBool formatInformation_;
      SmartBool versionInformation_;

    public:
      virtual Symbology Type() const override { return Symbology::QrGrading; };


      static std::unique_ptr<QrGrading> FromHandle(const HandleGuard<ReaderConfig>& guard, bool& isActiveOut)
      {
        auto pConfig = std::unique_ptr<QrGrading>(new QrGrading());
        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(CvcBcGetQRCodeGradingEx(
          reinterpret_cast<std::intptr_t>(guard.Handle()), &active,
          symbolContrast_.Ptr(),
          axialNonUniformity_.Ptr(),
          gridNonUniformity_.Ptr(),
          unusedErrorCorrection_.Ptr(),
          angleOfDistortion_.Ptr(),
          modulation_.Ptr(),
          reflectanceMargin_.Ptr(),
          fixedPatternDamage_.Ptr(),
          formatInformation_.Ptr(),
          versionInformation_.Ptr(),
          expectReducedQuietzone_.Ptr(),
          &rMin,
          &rMax
        ));
        reflectanceReference_ = Cvb::ValueRange<int>(rMin, rMax);

        return SmartBool(active);
      }

      virtual void WriteToHandle_(bool active, HandleGuard<ReaderConfig>& guard) override
      {
        Internal::DoResCall([&]()
        {
          return CVB_CALL_CAPI(CvcBcSetQRCodeGradingEx(reinterpret_cast<intptr_t>(guard.Handle()),
            SmartBool(active),
            symbolContrast_,
            axialNonUniformity_,
            gridNonUniformity_,
            unusedErrorCorrection_,
            angleOfDistortion_,
            modulation_,
            reflectanceMargin_,
            fixedPatternDamage_,
            formatInformation_,
            versionInformation_,
            expectReducedQuietzone_,
            static_cast<short>(reflectanceReference_.Min()),
            static_cast<short>(reflectanceReference_.Max())));
        });
      }

      QrGrading()
        : Grader2DConfigBase()
      {
      }


    };

    using QrGradingPtr = std::shared_ptr<QrGrading>;
  }

  CVB_END_INLINE_NS
}