pharma_code.hpp

#pragma once
 
#include "reader_config_base.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  namespace Barcode
  {
    using namespace Internal;
 
 
 
    class PharmaCode : public ReaderConfigBase
    {
    public:
 
      void SetDirection(PharmaCodeRunDirection direction)
      {
        if(direction_ != direction)
          SetDirty();
        direction_ = direction;
      }
 
 
      PharmaCodeRunDirection Direction() const
      {
        return direction_;
      }
 
 
      void SetMaxDigits(int maxDigits)
      {
        if(maxDigits < minDigitsLimit_ || maxDigits > maxDigitsLimit_ || maxDigits < minDigits_)
          throw std::runtime_error("MaxDigits out of range [2, 16] or less then MinDigits");
        if(maxDigits_ != maxDigits)
          SetDirty();
        maxDigits_ = static_cast<short>(maxDigits);
      }
 
 
      int MaxDigits() const
      {
        return maxDigits_;
      }
 
 
 
      void SetMinDigits(int minDigits)
      {
        if(minDigits < minDigitsLimit_ || minDigits > maxDigitsLimit_ || minDigits > maxDigits_)
          throw std::runtime_error("MinDigits out of range [2, 16] or higher then MaxDigits");
        if(minDigits_ != minDigits)
          SetDirty();
        minDigits_ = static_cast<short>(minDigits);
      }
 
 
      int MinDigits() const
      {
        return minDigits_;
      }
 
 
      void SetPixelReference(int pixelRef)
      {
        if(pixelRef < minPixelReferenceLimit_ || pixelRef > maxPixelReferenceLimit_)
          throw std::runtime_error("PixelReference out of range [0, 1000]");
        if(pixelRef_ != pixelRef)
          SetDirty();
        pixelRef_ = static_cast<short>(pixelRef);
      }
 
 
      int PixelReference() const
      {
        return pixelRef_;
      }
 
 
      void SetQuietzoneWidth(int quietzoneWidth)
      {
        if(quietzoneWidth < minQuietzoneWidthLimit_ || quietzoneWidth > maxQuietzoneWidthLimit_)
          throw std::runtime_error("Quietzone width out of range [10, 200]");
        if(quietzoneWidth_ != quietzoneWidth)
          SetDirty();
        quietzoneWidth_ = static_cast<short>(quietzoneWidth);
      }
 
 
      int QuietzoneWidth() const
      {
        return quietzoneWidth_;
      }
 
 
      void SetScaleFactor(int scaleFactor)
      {
        if(scaleFactor < minScaleFactorLimit_ || scaleFactor > maxScaleFactorLimit_)
          throw std::runtime_error("Scale factor out of range [50, 200]");
        if(scaleFactor_ != scaleFactor)
          SetDirty();
        scaleFactor_ = static_cast<short>(scaleFactor);
      }
 
 
      int ScaleFactor() const
      {
        return scaleFactor_;
      }
 
      //void SetSkew(PharmaCodeSkew skew)
      //{
      //  if(skew_ != skew)
      //    SetDirty();
      //  skew_ = skew;
      //}
      //PharmaCodeSkew Skew() const
      //{
      //  return skew_;
      //}
 
 
 
      void SetThreshold(int threshold)
      {
        if(threshold < 0 || threshold > 100)
          throw std::runtime_error("Threshold out of range [0, 100]");
        if(threshold_ != threshold)
          SetDirty();
        threshold_ = static_cast<short>(threshold);
      }
 
 
      int Threshold() const
      {
        return threshold_;
      }
 
      //void SetTolerance(PharmaCodeTolerance tolerance)
      //{
      //  if(tolerance_ != tolerance)
      //    SetDirty();
      //  tolerance_ = tolerance;
      //}
      //PharmaCodeTolerance Tolerance() const
      //{
      //  return tolerance_;
      //}
 
    protected:
      PharmaCodeRunDirection direction_;
      short maxDigits_;
      short minDigits_;
      short pixelRef_;
      short quietzoneWidth_;
      short scaleFactor_;
      PharmaCodeSkew skew_;
      short threshold_;
 
 
      const short minDigitsLimit_ = 2;
      const short maxDigitsLimit_ = 16;
 
      const short minPixelReferenceLimit_ = 0;
      const short maxPixelReferenceLimit_ = 1000;
 
      const short minQuietzoneWidthLimit_ = 10;
      const short maxQuietzoneWidthLimit_ = 200;
 
      const short minScaleFactorLimit_ = 50;
      const short maxScaleFactorLimit_ = 200;
 
 
 
 
 
    public:
      virtual Symbology Type() const override { return Symbology::PharmaCode; }
 
 
      static std::unique_ptr<PharmaCode> FromHandle(const HandleGuard<ReaderConfig>& guard, bool& isActiveOut)
      {
        auto pConfig = std::unique_ptr<PharmaCode>(new PharmaCode());
        isActiveOut = pConfig->ReadFromHandle(guard);
        return pConfig;
      }
 
    protected:
      virtual bool ReadFromHandle_(const HandleGuard<ReaderConfig>& guard) override
      {
        CExports::cvbbool_t active;
        short tmpDirection;
        CVB_CALL_CAPI(CvcBcGetPharmacode( reinterpret_cast<std::intptr_t>(guard.Handle()),
          &active,
          &tmpDirection,
          &minDigits_,
          &maxDigits_,
          &scaleFactor_,
          &quietzoneWidth_,
          &pixelRef_,
          &threshold_,
          inverse_.Ptr()
          ));
        direction_ = static_cast<PharmaCodeRunDirection>(tmpDirection);
        return SmartBool(active);
      }
 
      virtual void WriteToHandle_(bool active, HandleGuard<ReaderConfig>& guard) override
      {
        Internal::DoResCall([&]()
        {
          return CVB_CALL_CAPI(CvcBcSetPharmacode(reinterpret_cast<std::intptr_t>(guard.Handle()),
            SmartBool(active),
            static_cast<short>(direction_),
            minDigits_,
            maxDigits_,
            scaleFactor_,
            quietzoneWidth_,
            pixelRef_,
            threshold_,
            inverse_
            ));
        });
      }
    protected:
      PharmaCode()
        : ReaderConfigBase()
      {
      }
 
    };
 
    using PharmaCodePtr = std::shared_ptr<PharmaCode>;
  }
 
  CVB_END_INLINE_NS
}