detail_result_handle.hpp

#pragma once
 
#include "../_decl/decl_result_handle.hpp"
#include "../_decl/decl_symbology_conversion.hpp"
#include "../../point_2d.hpp"
#include "../../size_2d.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  namespace CodeReader
  {
    inline Cvb::optional<Result2D> ResultHandle::TryCreateResult2D(size_t i) const
    {
      // try to get 2D properties
      double width = 0;
      if (CVB_CALL_CAPI(
              CVCRGetDecoderResultDouble(Handle(), i, CExports::CVCRResultPropertyDouble::CVCRRPF_Width, width))
          == 0)
      {
        // size
        const auto height = Internal::DoResCallValueOut<double>([&](double &value) {
          return CVB_CALL_CAPI(
              CVCRGetDecoderResultDouble(Handle(), i, CExports::CVCRResultPropertyDouble::CVCRRPF_Height, value));
        });
 
        // rows
        const auto rows = Internal::DoResCallValueOut<int>([&](int &value) {
          return CVB_CALL_CAPI(
              CVCRGetDecoderResultInt(Handle(), i, CExports::CVCRResultPropertyInt::CVCRRPI_Rows, value));
        });
 
        // columns
        const auto cols = Internal::DoResCallValueOut<int>([&](int &value) {
          return CVB_CALL_CAPI(
              CVCRGetDecoderResultInt(Handle(), i, CExports::CVCRResultPropertyInt::CVCRRPI_Columns, value));
        });
 
        // quality
        const auto quality = Internal::DoResCallValueOut<int>([&](int &value) {
          return CVB_CALL_CAPI(
              CVCRGetDecoderResultInt(Handle(), i, CExports::CVCRResultPropertyInt::CVCRRPI_Quality, value));
        });
 
        // error correction codewords
        const auto errorCorrectionCodewords = Internal::DoResCallValueOut<int>([&](int &value) {
          return CVB_CALL_CAPI(CVCRGetDecoderResultInt(
              Handle(), i, CExports::CVCRResultPropertyInt::CVCRRPI_ErrorCorrectionCodewords, value));
        });
 
        // error correction erasure codewords
        const auto errorCorrectionErasureCodewords = Internal::DoResCallValueOut<int>([&](int &value) {
          return CVB_CALL_CAPI(CVCRGetDecoderResultInt(
              Handle(), i, CExports::CVCRResultPropertyInt::CVCRRPI_ErrorCorrectionErasureCodewords, value));
        });
 
        // composite type
        const auto compositeType =
            static_cast<CodeReader::CompositeType>(Internal::DoResCallValueOut<int>([&](int &value) {
              return CVB_CALL_CAPI(
                  CVCRGetDecoderResultInt(Handle(), i, CExports::CVCRResultPropertyInt::CVCRRPI_CompositeType, value));
            }));
 
        return Result2D(quality, rows, cols, Cvb::Size2D<double>(width, height), errorCorrectionCodewords,
                        errorCorrectionErasureCodewords, compositeType);
      }
 
      return {};
    }
 
    inline std::vector<Result> ResultHandle::CreateResultVector() const
    {
      // number of detected codes
      const auto numSymbolsDetected = Internal::DoResCallValueOut<size_t>(
          [&](size_t &value) { return CVB_CALL_CAPI(CVCRGetDecoderResultCount(Handle(), value)); });
      auto results = std::vector<Result>(numSymbolsDetected);
 
      for (size_t i = 0; i < numSymbolsDetected; i++)
      {
        // General code parameters (1D and 2D)
 
        // decoded data
        size_t size = 0;
        CVB_CALL_CAPI_CHECKED(CVCRGetDecoderResultDataTyped(Handle(), i, reinterpret_cast<Char *>(NULL), size));
        String data(size - 1, '\0');
        CVB_CALL_CAPI_CHECKED(CVCRGetDecoderResultDataTyped(Handle(), i, &data[0], size));
 
        // symbology
        Symbology symbology            = Symbology::Unknown;
        const auto symbolInt           = Internal::DoResCallValueOut<int>([&](int &value) {
          return CVB_CALL_CAPI(
              CVCRGetDecoderResultInt(Handle(), i, CExports::CVCRResultPropertyInt::CVCRRPI_Symbology, value));
        });
        const auto isExtendedSymbology = Internal::DoResCallValueOut<int>([&](int &value) {
          return CVB_CALL_CAPI(CVCRGetDecoderResultInt(
              Handle(), i, CExports::CVCRResultPropertyInt::CVCRRPI_IsExtendedSymbology, value));
        });
        if (isExtendedSymbology == 1)  // extended symbology
        {
          symbology = SymbologyConversion::Convert(static_cast<CExports::CVCRValueSymbologyEx>(symbolInt));
        }
        else
        {
          symbology = SymbologyConversion::Convert(static_cast<CExports::CVCRValueSymbology>(symbolInt));
        }
 
        // decode status
        const auto decodeStatus =
            static_cast<CodeReader::DecodeStatus>(Internal::DoResCallValueOut<int>([&](int &value) {
              return CVB_CALL_CAPI(
                  CVCRGetDecoderResultInt(Handle(), i, CExports::CVCRResultPropertyInt::CVCRRPI_DecodeStatus, value));
            }));
 
        // center
        Cvb::Point2D<int> center;
        Internal::DoResCall([&]() {
          return CVB_CALL_CAPI(
              CVCRGetDecoderResultCenter(Handle(), i, *reinterpret_cast<CExports::CVCRPoint *>(&center)));
        });
 
        // corners
        std::array<Point2D<int>, 4> corners;
        Internal::DoResCall([&]() {
          return CVB_CALL_CAPI(
              CVCRGetDecoderResultCorners(Handle(), i, reinterpret_cast<CExports::CVCRPoint *>(corners.data())));
        });
 
        // try to get 2D parameters
        const auto result2D = TryCreateResult2D(i);
        results[i]          = Result(std::move(data), center, std::move(corners), symbology, decodeStatus, result2D);
      }
      return results;
    }
 
  }  // namespace CodeReader
 
  CVB_END_INLINE_NS
}  // namespace Cvb