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
}