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
  {
    class ResultHandle;

    enum TimeLimitStatus
    {
      InTime = 0,
      TimeLimitReached
    };

    using TimeLimitedDecoderResult = std::tuple<std::vector<Result>, TimeLimitStatus>;


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


      Robust = CExports::CVCRCustomPerformance::CVCRCP_Robust,


      ExtendedRange2D = CExports::CVCRCustomPerformance::CVCRCP_ExtendedRange2D
    };


    class Decoder final
    {
      template <class T>
      friend class ConfigBase;
 
    private:
      enum class Properties
      {
        BasicInkjet     = CExports::CVCRPerformanceProperties::CVCRPP_BasicInkjet,
        CodeSearchSpeed = CExports::CVCRPerformanceProperties::CVCRPP_CodeSearchSpeed,
        TimeLimitDecode = CExports::CVCRPerformanceProperties::CVCRPP_TimeLimitDecode
      };
 
      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 <class Rep, class Period>
      TimeLimitedDecoderResult ExecuteFor(const ImagePlane &plane, const Rect<int> &aoi,
                                        const std::chrono::duration<Rep, Period> &timeSpan)
      {
        auto originalTimeSpan = TimeLimitDecode();
        SetTimeLimitDecode(timeSpan);
 
        auto pResult = Internal::DoResCallObjectOut<ResultHandle>([&](void *&handle) {
          return CVB_CALL_CAPI(CVCRDecodeMultiImageParallelizableRect(Handle(), plane.Handle(), 0, aoi.Left(),
                                                                      aoi.Top(), aoi.Right(), aoi.Bottom(), 0, handle));
        });
 
        SetTimeLimitDecode(originalTimeSpan);
        return std::make_tuple(pResult->CreateResultVector(), pResult->IsTimeLimitReached());
      }


      template <class Rep, class Period>
      TimeLimitedDecoderResult ExecuteFor(const ImagePlane &plane, const std::chrono::duration<Rep, Period> &timeSpan)
      {
        const auto size = plane.Parent().Size();
        const auto aoi  = Rect<int>(0, 0, size.Width() - 1, size.Height() - 1);
 
        return ExecuteFor(plane, aoi, timeSpan);
      }


      template <Symbology SYM>
      typename Config::Mapper<SYM>::Type &Config()
      {
        return std::get<typename Config::Mapper<SYM>::Type>(config_);
      }


      void SetBasicInkjetDPMEnabled(bool value);


      bool IsBasicInkjetDPMEnabled() const;


      void SetCustomPerformance(CustomPerformance value);


      CodeReader::CustomPerformance CustomPerformance() const;


      void SetDetectorDensity(int value);


      int DetectorDensity() const;


      void SetCodeSearchSpeed(int value);


      int CodeSearchSpeed() const;
 
    private:
      Decoder(Decoder &&other) noexcept
          : handle_(std::move(other.handle_))
          , config_(std::move(other.config_))
      {
      }
 
      template <class Rep, class Period>
      void SetTimeLimitDecode(const std::chrono::duration<Rep, Period> &timeSpan)
      {
        if (timeSpan.count() < 0 || timeSpan > std::chrono::milliseconds(60000))
          throw std::invalid_argument("value for TimeLimitDecode must be <= 60000 ms");
 
        CVB_CALL_CAPI_CHECKED(CVCRSetPropertyInt(
            Handle(), static_cast<int>(CExports::CVCRPerformanceProperties::CVCRPP_TimeLimitDecode),
            static_cast<int>(std::chrono::duration_cast<std::chrono::milliseconds>(timeSpan).count())));
      }
 
      std::chrono::milliseconds TimeLimitDecode() const;
 
    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 CodeReader
 
  CVB_END_INLINE_NS
}  // namespace Cvb