data_matrix.hpp

#pragma once
 
#include "reader_2d_config_base.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  namespace Barcode
  {
    using namespace Internal;
 
 
 
    class DataMatrix : public Reader2DConfigBase
    {
public:
 
      void SetLevels(DataMatrixLevels levels)
      {
        if(levels_ != levels)
          SetDirty();
        levels_ = levels;
      }
      DataMatrixLevels Levels() const
      {
        return levels_;
      };
 
 
 
      void SetFormats(DataMatrixFormats formats)
      {
        if(formats_ != formats)
          SetDirty();
        formats_ = formats;
      }
 
 
      DataMatrixFormats Formats() const
      {
        return formats_;
      };
 
 
      void SetMinSize(int minSize)
      {
        if(minSize < MinSizeLimit_ ||
          minSize > maxSize_)
          throw std::runtime_error("MinSize out of range");
        if(minSize_ != minSize)
          SetDirty();
        minSize_ = static_cast<short>(minSize);
      }
 
 
      int MinSize() const
      {
        return static_cast<int>(minSize_);
      };
 
 
 
      void SetMaxSize(int maxSize)
      {
        if(maxSize < minSize_ ||
          maxSize > MaxSizeLimit_)
          throw std::runtime_error("MaxSize out of range");
        if(maxSize_ != maxSize)
          SetDirty();
        maxSize_ = static_cast<short>(maxSize);
      }
 
 
      int MaxSize() const
      {
        return static_cast<int>(maxSize_);
      };
 
 
      void SetAllowRectangular(bool rectangular)
      {
        SetDirty();
        rectangular_ = rectangular;
      }
 
 
      bool AllowRectangular() const
      {
        return rectangular_;
      };
 
 
 
      void SetAllowDistorted(bool distorted)
      {
        SetDirty();
        distorted_ = distorted;
      }
 
 
      bool AllowDistorted() const
      {
        return distorted_;
      };
 
 
 
      void SetSubType(DataMatrixSubType subType)
      {
        if(subType_ != subType)
          SetDirty();
        subType_ = subType;
      }
 
 
      DataMatrixSubType SubType() const
      {
        return subType_;
      };
 
 
 
      void SetPharmaCode2DBar1(PharmaCode2DDisposition pharmaCode2DBar1)
      {
        if(pharmaCode2DBar1_ != pharmaCode2DBar1)
          SetDirty();
        pharmaCode2DBar1_ = pharmaCode2DBar1;
      }
 
 
      PharmaCode2DDisposition PharmaCode2DBar1() const
      {
        return pharmaCode2DBar1_;
      };
 
 
 
      void SetPharmaCode2DBar2(PharmaCode2DDisposition pharmaCode2DBar2)
      {
        if(pharmaCode2DBar2_ != pharmaCode2DBar2)
          SetDirty();
        pharmaCode2DBar2_ = pharmaCode2DBar2;
      }
 
 
      PharmaCode2DDisposition PharmaCode2DBar2() const
      {
        return pharmaCode2DBar2_;
      };
 
 
 
      void SetPharmaCode2DBar3(PharmaCode2DDisposition pharmaCode2DBar3)
      {
        if(pharmaCode2DBar3_ != pharmaCode2DBar3)
          SetDirty();
        pharmaCode2DBar3_ = pharmaCode2DBar3;
      }
 
 
      PharmaCode2DDisposition PharmaCode2DBar3() const
      {
        return pharmaCode2DBar3_;
      };
 
 
 
      void SetPharmaCode2DBar4(PharmaCode2DDisposition pharmaCode2DBar4)
      {
        if(pharmaCode2DBar4_ != pharmaCode2DBar4)
          SetDirty();
        pharmaCode2DBar4_ = pharmaCode2DBar4;
      }
 
 
      PharmaCode2DDisposition PharmaCode2DBar4() const
      {
        return pharmaCode2DBar4_;
      };
 
 
 
      void SetPharmaCode2DBar5(PharmaCode2DDisposition pharmaCode2DBar5)
      {
        if(pharmaCode2DBar5_ != pharmaCode2DBar5)
          SetDirty();
        pharmaCode2DBar5_ = pharmaCode2DBar5;
      }
 
 
      PharmaCode2DDisposition PharmaCode2DBar5() const
      {
        return pharmaCode2DBar5_;
      };
 
 
 
      void SetPharmaCode2DBar6(PharmaCode2DDisposition pharmaCode2DBar6)
      {
        if(pharmaCode2DBar6_ != pharmaCode2DBar6)
          SetDirty();
        pharmaCode2DBar6_ = pharmaCode2DBar6;
      }
 
 
      PharmaCode2DDisposition PharmaCode2DBar6() const
      {
        return pharmaCode2DBar6_;
      };
 
 
 
      void SetPharmaCode2DBar7(PharmaCode2DDisposition pharmaCode2DBar7)
      {
        if(pharmaCode2DBar7_ != pharmaCode2DBar7)
          SetDirty();
        pharmaCode2DBar7_ = pharmaCode2DBar7;
      }
 
 
      PharmaCode2DDisposition PharmaCode2DBar7() const
      {
        return pharmaCode2DBar7_;
      };
 
 
 
      void SetPharmaCode2DBar8(PharmaCode2DDisposition pharmaCode2DBar8)
      {
        if(pharmaCode2DBar8_ != pharmaCode2DBar8)
          SetDirty();
        pharmaCode2DBar8_ = pharmaCode2DBar8;
      }
 
 
      PharmaCode2DDisposition PharmaCode2DBar8() const
      {
        return pharmaCode2DBar8_;
      };
 
 
 
      void SetPharmaCode2DThreshold(int threshold)
      {
        if(threshold < 0 ||
          threshold > 100)
          throw std::runtime_error("PharmaCode2DThreshold out of range");
        if(threshold_ != threshold)
          SetDirty();
        threshold_ = static_cast<short>(threshold);
      }
 
 
      int PharmaCode2DThreshold() const
      {
        return static_cast<int>(threshold_);
      };
 
 
 
      void SetPharmaCode2DExpanded(bool expanded)
      {
        SetDirty();
        expanded_ = expanded;
      }
 
 
      bool PharmaCode2DExpanded() const
      {
        return expanded_;
      };
 
 
 
      void SetDottedContrast(int contrast)
      {
        if(contrast < MinDottedContrastLimit_ ||
          contrast > MaxDottedContrastLimit_)
          throw std::runtime_error("Dotted Contrast out of range");
        if(contrast_ != contrast)
          SetDirty();
        contrast_ = static_cast<short>(contrast);
      }
 
 
      int DottedContrast() const
      {
        return static_cast<int>(contrast_);
      };
 
 
 
      void SetDottedModuleWidth(int moduleWidth)
      {
        if(moduleWidth < MinDottedModuleWidthLimit_ ||
          moduleWidth > MaxDottedModuleWidthLimit_)
          throw std::runtime_error("Dotted module width out of range");
        if(moduleWidth_ != moduleWidth)
          SetDirty();
        moduleWidth_ = static_cast<short>(moduleWidth);
      }
 
 
      int DottedModuleWidth() const
      {
        return static_cast<int>(moduleWidth_);
      };
 
 
 
      void SetDottedQuietzoneWidth(int quietzone)
      {
        if(quietzone < MinDottedQuietZoneWidthLimit_ ||
          quietzone > MaxDottedQuietZoneWidthLimit_)
          throw std::runtime_error("Dotted quietzone width out of range");
        if(quietzone_ != quietzone)
          SetDirty();
        quietzone_ = static_cast<short>(quietzone);
      }
 
 
      int DottedQuietzoneWidth() const
      {
        return static_cast<int>(quietzone_);
      };
 
    protected:
      DataMatrixLevels levels_;
      DataMatrixFormats formats_;
      short minSize_;
      short maxSize_;
      SmartBool rectangular_;
      SmartBool distorted_;
      DataMatrixSubType subType_;
      PharmaCode2DDisposition pharmaCode2DBar1_;
      PharmaCode2DDisposition pharmaCode2DBar2_;
      PharmaCode2DDisposition pharmaCode2DBar3_;
      PharmaCode2DDisposition pharmaCode2DBar4_;
      PharmaCode2DDisposition pharmaCode2DBar5_;
      PharmaCode2DDisposition pharmaCode2DBar6_;
      PharmaCode2DDisposition pharmaCode2DBar7_;
      PharmaCode2DDisposition pharmaCode2DBar8_;
      short threshold_;
      SmartBool expanded_;
      short contrast_;
      short moduleWidth_;
      short quietzone_;
 
 
 
 
      const short MinSizeLimit_ = 7;
 
      const short MaxSizeLimit_ = 144;
 
      const short MinDottedContrastLimit_ = 10;
 
      const short MaxDottedContrastLimit_ = 100;
 
      const short MinDottedModuleWidthLimit_ = 30;
 
      const short MaxDottedModuleWidthLimit_ = 150;
 
      const short MinDottedQuietZoneWidthLimit_ = 3;
 
      const short MaxDottedQuietZoneWidthLimit_ = 5;
 
 
    public:
      virtual Symbology Type() const override { return Symbology::DataMatrix; };
 
 
      static std::unique_ptr<DataMatrix> FromHandle(const HandleGuard<ReaderConfig>& guard, bool& isActiveOut)
      {
        auto pConfig = std::unique_ptr<DataMatrix>(new DataMatrix());
        isActiveOut = pConfig->ReadFromHandle(guard);
        return pConfig;
      }
 
    protected:
      virtual bool ReadFromHandle_(const HandleGuard<ReaderConfig>& guard) override
      {
        unsigned short tmpLevels;
        unsigned short tmpFormats;
        short tmpSubType;
        short tmpBar1;
        short tmpBar2;
        short tmpBar3;
        short tmpBar4;
        short tmpBar5;
        short tmpBar6;
        short tmpBar7;
        short tmpBar8;
 
        CVB_CALL_CAPI(CvcBcGetDataMatrixEx(reinterpret_cast<std::intptr_t>(guard.Handle()),
          &tmpLevels,
          &tmpFormats,
          &minSize_,
          &maxSize_,
          rectangular_.Ptr(),
          mirrored_.Ptr(),
          inverse_.Ptr(),
          distorted_.Ptr(),
          &tmpSubType,
          &tmpBar1,
          &tmpBar2,
          &tmpBar3,
          &tmpBar4,
          &tmpBar5,
          &tmpBar6,
          &tmpBar7,
          &tmpBar8,
          &threshold_,
          expanded_.Ptr(),
          &contrast_,
          &moduleWidth_,
          &quietzone_
          ));
        levels_ = static_cast<DataMatrixLevels>(tmpLevels);
        formats_ = static_cast<DataMatrixFormats>(tmpFormats);
        subType_ = static_cast<DataMatrixSubType>(tmpSubType);
        pharmaCode2DBar1_ = static_cast<PharmaCode2DDisposition>(tmpBar1);
        pharmaCode2DBar2_ = static_cast<PharmaCode2DDisposition>(tmpBar2);
        pharmaCode2DBar3_ = static_cast<PharmaCode2DDisposition>(tmpBar3);
        pharmaCode2DBar4_ = static_cast<PharmaCode2DDisposition>(tmpBar4);
        pharmaCode2DBar5_ = static_cast<PharmaCode2DDisposition>(tmpBar5);
        pharmaCode2DBar6_ = static_cast<PharmaCode2DDisposition>(tmpBar6);
        pharmaCode2DBar7_ = static_cast<PharmaCode2DDisposition>(tmpBar7);
        pharmaCode2DBar8_ = static_cast<PharmaCode2DDisposition>(tmpBar8);
        return tmpLevels != 0;
      }
 
      virtual void WriteToHandle_(bool active, HandleGuard<ReaderConfig>& guard) override
      {
        if (!active)
          levels_ = static_cast<DataMatrixLevels>(0);
        Internal::DoResCall([&]()
        {
          return CVB_CALL_CAPI(CvcBcSetDataMatrixEx(reinterpret_cast<std::intptr_t>(guard.Handle()),
            static_cast<unsigned short>(levels_),
            static_cast<unsigned short>(formats_),
            minSize_,
            maxSize_,
            rectangular_,
            mirrored_,
            inverse_,
            distorted_,
            static_cast<short>(subType_),
            static_cast<short>(pharmaCode2DBar1_),
            static_cast<short>(pharmaCode2DBar2_),
            static_cast<short>(pharmaCode2DBar3_),
            static_cast<short>(pharmaCode2DBar4_),
            static_cast<short>(pharmaCode2DBar5_),
            static_cast<short>(pharmaCode2DBar6_),
            static_cast<short>(pharmaCode2DBar7_),
            static_cast<short>(pharmaCode2DBar8_),
            threshold_,
            expanded_,
            contrast_,
            moduleWidth_,
            quietzone_
          ));
        });
      }
    protected:
      DataMatrix()
        : Reader2DConfigBase()
      {
      }
 
    };
 
    using DataMatrixPtr = std::shared_ptr<DataMatrix>;
  }
 
  CVB_END_INLINE_NS
}