decl_decoder.hpp

#pragma once
 
#include <tuple>
 
#include "../shims/stdoptional.hpp"
 
#include "../../global.hpp"
#include "../../image.hpp"
#include "../../rect.hpp"
 
#include "../../_cexports/c_barcode.h"
#include "decl_config.hpp"
#include "../result.hpp"
 
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  template <>
  inline HandleGuard<Barcode::Decoder>::HandleGuard(void *handle) noexcept
      : HandleGuard<Barcode::Decoder>(handle, [](void *handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
  {
  }
 
  namespace Barcode
  {
 
    class Decoder final
    {
      template <class T>
      friend class ConfigBase;
 
      enum class Properties
      {
        BasicInkjet = 370
      };
 
      enum class ResultProperties
      {
        Corners           = CExports::CVBCResultProperties::CVBCRP_Corners,
        Center            = CExports::CVBCResultProperties::CVBCRP_Center,
        SymbolType        = CExports::CVBCResultProperties::CVBCRP_SymbolType,
        SymbolTypeEx      = CExports::CVBCResultProperties::CVBCRP_SymbolTypeEx,
        Length            = CExports::CVBCResultProperties::CVBCRP_Length,
        String            = CExports::CVBCResultProperties::CVBCRP_String,
        Quality           = CExports::CVBCResultProperties::CVBCRP_Quality,
        Status            = CExports::CVBCResultProperties::CVBCRP_Status,
 
        // Result properties 2D barcodes
        ECCError          = CExports::CVBCResultProperties2D::CVBCRP2D_ECCError, 
        ECCErasure        = CExports::CVBCResultProperties2D::CVBCRP2D_ECCErasure,
        SymbolHeightWidth = CExports::CVBCResultProperties2D::CVBCRP2D_SymbolHeightWidth,
        SymbolRowsColumns = CExports::CVBCResultProperties2D::CVBCRP2D_SymbolRowsColumns
      };
 
      struct PrivateTag{};
 
    public:
 
      static std::unique_ptr<Decoder> Create();
 
 
      std::vector<Result> Execute(const ImagePlane &plane, Rect<int> aoi);
 
 
      std::vector<Result> Execute(const ImagePlane &plane);
 
 
 
      template <Symbology SYM>
      typename Config::Mapper<SYM>::Type &Config()
      {
        return std::get<typename Config::Mapper<SYM>::Type>(config_);
      }
 
 
      void SetEnableBasicInkjetDPM(bool value);
 
 
      bool EnabledBasicInkjetDPM() const;
 
 
    private:
      Decoder(Decoder &&other) noexcept
          : handle_(std::move(other.handle_))
          , config_(std::move(other.config_))
      {
      }
 
      int GetIntProperty(ResultProperties property, int index);
      String GetPropertyString(ResultProperties property, int index);
      std::vector<int> GetStructProperty(ResultProperties property, int index);       
 
      Symbology GetSymbology(int index);      
      Point2D<int> GetCenter(int index);            
      std::array<Point2D<int>, 4> GetCorners(int index);
 
      bool SymbolContainsCompositeType(int symbol, enum class Result2D::CompositeType compositeType);
      enum class Result2D::CompositeType GetCompositeType(int index); 
      
      float ConvertSizeToPixelCount(int value);
      Cvb::optional<Result2D> GetResult2D(int index);      
      Result GetResult(int index);
      std::vector<Result> CreateResultVector(int numSymbolsDetected);
 
    public:
      Decoder(const Decoder &other) = delete;
      Decoder &operator=(const Decoder &other) = delete;
      explicit Decoder(HandleGuard<Decoder> &&guard, PrivateTag) noexcept
          : handle_(std::move(guard))
          , config_(std::make_tuple(
            Config::DataMatrix(*this), 
            Config::QR(*this), 
            Config::MicroQR(*this),
            Config::Pdf417(*this), 
            Config::MicroPdf417(*this), 
            Config::GS1DataBar14(*this),            
            Config::GS1DataBarStacked(*this), 
            Config::GS1DataBarLimited(*this),
            Config::GS1DataBarExpanded(*this), 
            Config::GS1DataBarExpandedStacked(*this),
            Config::Ean8(*this), 
            Config::Ean13(*this), 
            Config::UpcA(*this),
            Config::UpcE(*this),
            Config::Code128(*this),
            Config::Code39(*this), 
            Config::Code93(*this),
            Config::Interleaved2of5(*this),
            Config::UspsIntelligentMail(*this),
            Config::DutchPost(*this),
            Config::AustraliaPost(*this),
            Config::RoyalMail(*this),
            Config::Pharmacode(*this),
            Config::Code32(*this), 
            Config::Code11(*this)))
      {
      }
      virtual ~Decoder() = default;
 
      static std::unique_ptr<Decoder> FromHandle(HandleGuard<Decoder> &&guard);
 
      void *Handle() const noexcept
      {
        return handle_.Handle();
      }
 
    private:
      HandleGuard<Decoder> handle_;
      std::tuple<
        Config::DataMatrix, 
        Config::QR, 
        Config::MicroQR, 
        Config::Pdf417, 
        Config::MicroPdf417, 
        Config::GS1DataBar14, 
        Config::GS1DataBarStacked, 
        Config::GS1DataBarLimited, 
        Config::GS1DataBarExpanded, 
        Config::GS1DataBarExpandedStacked, 
        Config::Ean8, 
        Config::Ean13, 
        Config::UpcA, 
        Config::UpcE,
        Config::Code128,
        Config::Code39, 
        Config::Code93,
        Config::Interleaved2of5,
        Config::UspsIntelligentMail,
        Config::DutchPost,
        Config::AustraliaPost,
        Config::RoyalMail,
        Config::Pharmacode,
        Config::Code32,
        Config::Code11> 
          config_;
    };
  }  // namespace Barcode
 
  CVB_END_INLINE_NS
}  // namespace Cvb