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
}