decl_decoder.hpp

#pragma once
 
#include <tuple>
 
#include "../../shims/stdoptional.hpp"
 
#include "../../global.hpp"
#include "../../image.hpp"
#include "../../rect.hpp"
 
#include "../../_cexports/c_code_reader.h"
#include "decl_config.hpp"
#include "../result.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  template <>
  inline HandleGuard<CodeReader::Decoder>::HandleGuard(void *handle) noexcept
      : HandleGuard<CodeReader::Decoder>(handle, [](void *handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
  {
  }
 
  namespace CodeReader
  {

    enum class CustomPerformance
    {
      None = CExports::CVCRCustomPerformance::CVCRCP_None,


      Robust = CExports::CVCRCustomPerformance::CVCRCP_Robust,


      ExtendedRange2D = CExports::CVCRCustomPerformance::CVCRCP_ExtendedRange2D
    };
    enum class CustomPerformance {…};


    class Decoder final
    {
      template <class T>
      friend class ConfigBase;
 
    private:
      enum class Properties
      {
        BasicInkjet      = CExports::CVCRPerformanceProperties::CVCRPP_BasicInkjet,
        AllCommon1DCodes = 124,
        All2DCodes       = 125
      };
 
      enum class ResultProperties
      {
        Corners      = CExports::CVCRResultProperties::CVCRRP_Corners,
        Center       = CExports::CVCRResultProperties::CVCRRP_Center,
        SymbolType   = CExports::CVCRResultProperties::CVCRRP_SymbolType,
        SymbolTypeEx = CExports::CVCRResultProperties::CVCRRP_SymbolTypeEx,
        Length       = CExports::CVCRResultProperties::CVCRRP_Length,
        String       = CExports::CVCRResultProperties::CVCRRP_String,
        Quality      = CExports::CVCRResultProperties::CVCRRP_Quality,
        Status       = CExports::CVCRResultProperties::CVCRRP_Status,
 
        // Result properties 2D codes
        ECCError          = CExports::CVCRResultProperties2D::CVCRRP2D_ECCError,
        ECCErasure        = CExports::CVCRResultProperties2D::CVCRRP2D_ECCErasure,
        SymbolHeightWidth = CExports::CVCRResultProperties2D::CVCRRP2D_SymbolHeightWidth,
        SymbolRowsColumns = CExports::CVCRResultProperties2D::CVCRRP2D_SymbolRowsColumns
      };
 
      struct PrivateTag
      {
      };
 
    public:

      static std::unique_ptr<Decoder> Create();

      std::vector<Result> ExecuteSingleInstance(const ImagePlane &plane, const Rect<int> &aoi);

      std::vector<Result> ExecuteSingleInstance(const ImagePlane &plane);


      std::vector<Result> Execute(const ImagePlane &plane, const 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_);
      }
      typename Config::Mapper<SYM>::Type &Config() {…}


      void SetBasicInkjetDPMEnabled(bool value);


      bool IsBasicInkjetDPMEnabled() const;


      void SetAllCommon1DCodesEnabled(bool value);


      bool AllCommon1DCodesEnabled() const;


      void SetAll2DCodesEnabled(bool value);


      bool All2DCodesEnabled() const;


      void SetCustomPerformance(CustomPerformance value);


      CodeReader::CustomPerformance CustomPerformance() const;


      void SetDetectorDensity(int value);


      int DetectorDensity() const;
 
    private:
      Decoder(Decoder &&other) noexcept
          : handle_(std::move(other.handle_))
          , config_(std::move(other.config_))
      {
      }
 
    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_;
    };
    class Decoder final {…};
  }  // namespace CodeReader
 
  CVB_END_INLINE_NS
}  // namespace Cvb