detail_decoder.hpp

#pragma once
 
#include "../result.hpp"
#include "../_decl/decl_decoder.hpp"
#include "../_decl/decl_result_handle.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  namespace CodeReader
  {
    inline std::unique_ptr<Decoder> Decoder::FromHandle(HandleGuard<Decoder> &&guard)
    {
      if (!guard.Handle())
        throw std::runtime_error("decoder handle must not be null");
 
      return std::make_unique<Decoder>(std::move(guard), PrivateTag{});
    }
 
    inline std::unique_ptr<Decoder> Decoder::Create()
    {
      return Internal::DoResCallObjectOut<Decoder>(
          [&](void *&handle) { return CVB_CALL_CAPI(CVCRCreateDecoder(handle)); });
    }
 
    inline void Decoder::SetBasicInkjetDPMEnabled(bool value)
    {
      CVB_CALL_CAPI_CHECKED(
          CVCRSetPropertyInt(Handle(), static_cast<int>(Properties::BasicInkjet), static_cast<int>(value)));
    }
 
    inline bool Decoder::IsBasicInkjetDPMEnabled() const
    {
      int value = 0;
      CVB_CALL_CAPI_CHECKED(CVCRGetPropertyInt(Handle(), static_cast<int>(Properties::BasicInkjet), value));
      return static_cast<bool>(value);
    }
 
    inline void Decoder::SetCustomPerformance(CodeReader::CustomPerformance value)
    {
      CVB_CALL_CAPI_CHECKED(
          CVCRSetPropertyInt(Handle(), static_cast<int>(CExports::CVCRPerformanceProperties::CVCRPP_CustomPerformance),
                             static_cast<int>(value)));
    }
 
    inline CodeReader::CustomPerformance Decoder::CustomPerformance() const
    {
      int value = 0;
      CVB_CALL_CAPI_CHECKED(CVCRGetPropertyInt(
          Handle(), static_cast<int>(CExports::CVCRPerformanceProperties::CVCRPP_CustomPerformance), value));
      return static_cast<CodeReader::CustomPerformance>(value);
    }
 
    inline void Decoder::SetDetectorDensity(int value)
    {
      if (value < 1 || value > 4)
        throw std::invalid_argument("value for DetectorDensity must be between 1 and 4 (inclusive)");
 
      CVB_CALL_CAPI_CHECKED(
          CVCRSetPropertyInt(Handle(), static_cast<int>(CExports::CVCRPerformanceProperties::CVCRPP_DetectorDensity),
                             static_cast<int>(value)));
    }
 
    inline int Decoder::DetectorDensity() const
    {
      int value = 0;
      CVB_CALL_CAPI_CHECKED(CVCRGetPropertyInt(
          Handle(), static_cast<int>(CExports::CVCRPerformanceProperties::CVCRPP_DetectorDensity), value));
      return value;
    }
 
    inline void Decoder::SetCodeSearchSpeed(int value)
    {
      if (value < 0 || value > 3)
        throw std::invalid_argument("the value for CodeSearchSpeed must be one of 0,1,2 or 3");
 
      CVB_CALL_CAPI_CHECKED(
          CVCRSetPropertyInt(Handle(), static_cast<int>(CExports::CVCRPerformanceProperties::CVCRPP_CodeSearchSpeed),
                             static_cast<int>(value)));
    }
 
    inline int Decoder::CodeSearchSpeed() const
    {
      int value = 0;
      CVB_CALL_CAPI_CHECKED(CVCRGetPropertyInt(
          Handle(), static_cast<int>(CExports::CVCRPerformanceProperties::CVCRPP_CodeSearchSpeed), value));
      return value;
    }
 
    inline std::vector<Result> Decoder::ExecuteSingleInstance(const ImagePlane &plane, const Rect<int> &aoi)
    {
      auto pResult = Internal::DoResCallObjectOut<ResultHandle>([&](void *&handle) {
        return CVB_CALL_CAPI(CVCRDecodeMultiImageWithResultRect(Handle(), plane.Handle(), 0, aoi.Left(), aoi.Top(),
                                                                aoi.Right(), aoi.Bottom(), 0, 0, handle));
      });
 
      return pResult->CreateResultVector();
    }
 
    inline std::vector<Result> Decoder::ExecuteSingleInstance(const ImagePlane &plane)
    {
      const auto size = plane.Parent().Size();
      const auto aoi  = Rect<int>(0, 0, size.Width() - 1, size.Height() - 1);
 
      return ExecuteSingleInstance(plane, aoi);
    }
 
    inline std::vector<Result> Decoder::Execute(const ImagePlane &plane, const Rect<int> &aoi)
    {
      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));
      });
 
      return pResult->CreateResultVector();
    }
 
    inline std::vector<Result> Decoder::Execute(const ImagePlane &plane)
    {
      const auto size = plane.Parent().Size();
      const auto aoi  = Rect<int>(0, 0, size.Width() - 1, size.Height() - 1);
 
      return Execute(plane, aoi);
    }
  }  // namespace CodeReader
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb