ScanbotSDK.hpp

//
//
//#pragma once
//#ifndef SCANBOTSDK_HPP
//#define SCANBOTSDK_HPP
//
//#include <array>
//#include <string>
//#include <vector>
//#include <iostream>
//
//#include <ScanbotSDK.h>
//
//
//namespace scanbotsdk {
//
//struct BarcodeItem {
//    /// The barcode data as text.
//    std::string text;
//    /// The barcode format, also called its symbology.
//    scanbotsdk_barcode_format_t format;
//    /**
//     * @brief The coordinates of the barcode's quadrangle in the image.
//     * @details The coordinates are returned in the following order:
//     * - 0 : top-left-x,
//     * - 1 : top-left-y,
//     * - 2 : top-right-x,
//     * - 3 : top-right-y,
//     * - 4 : bottom-right-x,
//     * - 5 : bottom-right-y,
//     * - 6 : bottom-left-x,
//     * - 7 : bottom-left-y
//     */
//    std::array<int, 8> quad;
//    /// The barcode data as raw bytes.
//    std::vector<unsigned char> rawBytes;
//};
//
// * @brief The initialization parameters for the Scanbot SDK.
// */
//struct InitParams {
//    /// The license key.
//    std::string licenseKey;
//};
//
// * @brief Initialize the Scanbot SDK. You must call this function once before using any other Scanbot SDK
// * functions.
// * @param params: The initialization parameters. You must provide a valid license key.
// * @return: Error code, <see cref="SCANBOTSDK_OK"/> if initialization was successful.
// */
//static scanbotsdk_error_code_t initialize(const InitParams& params) {
//    scanbotsdk_init_params_t initParams = {};
//    initParams.license_key = params.licenseKey.c_str();
//    return scanbotsdk_initialize(&initParams);
//}
//
// * @brief Returns the current license status.
// */
//static scanbotsdk_license_status_t getLicenseStatus() {
//    scanbotsdk_license_status_t status;
//    scanbotsdk_get_license_status(&status);
//    return status;
//}
//
// * @brief The barcode recognizer is capable of detecting and decoding barcodes in images.
// */
//class BarcodeRecognizer {
//   public:
//
//    /**
//     * @brief The initialization parameters for the barcode recognizer.
//     */
//    struct InitializationParams{
//        /** @brief The barcode recognition image schedule type mode. */
//        scanbotsdk_barcode_engine_mode_t engine_mode = SCANBOTSDK_BARCODE_ENGINE_MODE_NEXT_GEN;
//        /** @brief If the barcode recognition is performed in tryHarderMode. */
//        bool is_live = false;
//        /** @brief The barcode formats to detect. If empty, all formats will be recognized */
//        std::vector<scanbotsdk_barcode_format_t> formats;
//        /**
//        * @brief If true, the barcode recognizer will use the TensorRT backend for GPU acceleration.
//        * @details When enabling TensorRT, use the smallest input image size that fits your use case. The bigger the image size, the more memory is
//        * required at runtime. It takes around 3 minutes to build the TensorRT engine for the first time. The engine is then cached on disk and reused.
//        * The cached engine can be copied to other devices with the same device model, Jetpack version, CUDA version and TensorRT version.
//        */
//        bool useTensorRT = false;
//        /** @brief The maximum input width in pixels for TensorRT. If 0, the default value will be used. */
//        int tensorrtMaxInputWidth = 0;
//        /** @brief The maximum input height in pixels for TensorRT. If 0, the default value will be used. */
//        int tensorrtMaxInputHeight = 0;
//        /** @brief The maximum workspace size in bytes for TensorRT. If 0, the default value will be used. */
//        size_t tensorrtMaxWorkspaceSize = 0;
//    };
//
//    /**
//     * @brief Creates a new barcode recognizer.
//     * @param params: The initialization parameters.
//     */
//    BarcodeRecognizer(const BarcodeRecognizer::InitializationParams& params) {
//
//        scanbotsdk_barcode_scanner_init_params_t init_params = {.engine_mode = params.engine_mode,
//                                                                   .is_live = params.is_live,
//                                                                   .formats = params.formats.data(),
//                                                                   .formats_count = static_cast<int>(params.formats.size()),
//                                                                   .use_tensorrt = params.useTensorRT,
//                                                                   .tensorrt_max_input_width = params.tensorrtMaxInputWidth,
//                                                                   .tensorrt_max_input_height = params.tensorrtMaxInputHeight,
//                                                                   .tensorrt_max_workspace_size = params.tensorrtMaxWorkspaceSize
//                                                                   };
//
//        auto ret = scanbotsdk_barcode_scanner_create(&init_params, &recognizer);
//        if (ret != scanbotsdk_error_code_t::SCANBOTSDK_OK) {
//            recognizer = nullptr;
//        }
//    }
//
//    ~BarcodeRecognizer() {
//        if (recognizer != nullptr){
//            scanbotsdk_barcode_scanner_free(recognizer);
//        }
//    }
//
//    /**
//     * @brief Recognizes barcodes in the given image.
//     * @param image: The image to recognize barcodes in.
//     * @return: A list of recognized barcodes.
//     */
//    std::vector<BarcodeItem> recognize(scanbotsdk_image_t image){
//
//        if (recognizer == nullptr){
//            scanbotsdk_log_error("Aborted due to invalid recognizer state.");
//            return {};
//        }
//
//        scanbotsdk_barcode_result_t* barcode_result = nullptr;
//        auto ret = scanbotsdk_barcode_scanner_scan(recognizer, &image, &barcode_result);
//        if (ret != SCANBOTSDK_OK) {
//            return {};
//        }
//
//        std::vector<BarcodeItem> retval;
//        int count = 0;
//        if (scanbotsdk_barcode_result_get_count(barcode_result, &count) != SCANBOTSDK_OK) {
//            return {};
//        }
//
//        for (int barcode_idx = 0; barcode_idx < count; barcode_idx++) {
//            BarcodeItem item;
//
//            const char* cText = nullptr;
//            if (scanbotsdk_barcode_result_get_text(barcode_result, barcode_idx, &cText) != SCANBOTSDK_OK) {
//                return {};
//            }
//
//            item.text = std::string(cText);
//
//            int rawBytesLength = 0;
//            const unsigned char* cRawBytes = nullptr;
//            if(scanbotsdk_barcode_result_get_raw_bytes(barcode_result, barcode_idx,
//                                                        &cRawBytes, &rawBytesLength) != SCANBOTSDK_OK) {
//                return {};
//            }
//            item.rawBytes = std::vector<unsigned char>(cRawBytes, cRawBytes + rawBytesLength);
//
//            if (scanbotsdk_barcode_result_get_format(barcode_result, barcode_idx,
//                                                                    &item.format) != SCANBOTSDK_OK) {
//                return {};
//            }
//
//            if(scanbotsdk_barcode_result_get_quad(barcode_result, barcode_idx, item.quad.data()) != SCANBOTSDK_OK) {
//                return {};
//            }
//
//            retval.push_back(item);
//        }
//
//        if (scanbotsdk_barcode_result_free(barcode_result)!=SCANBOTSDK_OK) {
//            return {};
//        }
//
//        return retval;
//    }
//
//    private:
//        scanbotsdk_barcode_scanner_t* recognizer = nullptr;
//};
//
//}  // namespace scanbotsdk::barcode
//#endif // SCANBOTSDK_HPP