data_matrix_grading.hpp

#pragma once

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

namespace Cvb
{
  CVB_BEGIN_INLINE_NS

  namespace Barcode
  {


    class DataMatrixGrading : public Grader2DConfigBase
    {
    public:



      void SetGradePrintGrowth(bool printGrowth)
      {
        SetDirty();
        printGrowth_ = printGrowth;
      };



      bool GradePrintGrowth() const
      {
        return printGrowth_;
      };

    protected:
      SmartBool printGrowth_;

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


      static std::unique_ptr<DataMatrixGrading> FromHandle(const HandleGuard<ReaderConfig>& guard, bool& isActiveOut)
      {
        auto pConfig = std::unique_ptr<DataMatrixGrading>(new DataMatrixGrading());
        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(CvcBcGetCodeGradingEx(reinterpret_cast<std::intptr_t>(guard.Handle()),
          &active,
          symbolContrast_.Ptr(),
          axialNonUniformity_.Ptr(),
          gridNonUniformity_.Ptr(),
          unusedErrorCorrection_.Ptr(),
          printGrowth_.Ptr(),
          angleOfDistortion_.Ptr(),
          modulation_.Ptr(),
          reflectanceMargin_.Ptr(),
          fixedPatternDamage_.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(CvcBcSetCodeGradingEx(reinterpret_cast<std::intptr_t>(guard.Handle()), SmartBool(active),
            symbolContrast_,
            axialNonUniformity_,
            gridNonUniformity_,
            unusedErrorCorrection_,
            printGrowth_,
            angleOfDistortion_,
            modulation_,
            reflectanceMargin_,
            fixedPatternDamage_,
            static_cast<short>(reflectanceReference_.Min()),
            static_cast<short>(reflectanceReference_.Max())));
        });
      }

      DataMatrixGrading()
        : Grader2DConfigBase()
      {
      }


    };

    using DataMatrixGradingPtr = std::shared_ptr<DataMatrixGrading>;
  }

  CVB_END_INLINE_NS
}