ScanbotSDK.hpp

Go to the documentation of this file.

 
#pragma once
#ifndef SCANBOTSDK_HPP
#define SCANBOTSDK_HPP
 
#include <array>
#include <string>
#include <vector>
#include <iostream>
 
#include <ScanbotSDK.h>
 
 
namespace scanbotsdk {
 
struct BarCodeItem {
    std::string text;
    scanbotsdk_barcode_format_t format;
    std::array<int, 8> quad;
    std::vector<unsigned char> rawBytes;
};
 
struct InitParams {
    std::string licenseKey;
};
 
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);
}
 
static scanbotsdk_license_status_t getLicenseStatus() {
    scanbotsdk_license_status_t status;
    scanbotsdk_get_license_status(&status);
    return status;
}
 
class BarcodeRecognizer {
   public:
 
    struct InitializationParams{
        scanbotsdk_barcode_engine_mode_t engineMode = SCANBOTSDK_BARCODE_ENGINE_MODE_BALANCED;
        std::vector<scanbotsdk_barcode_format_t> formats;
        bool useTensorRT = false;
        int tensorrtMaxInputWidth = 0;
        int tensorrtMaxInputHeight = 0;
        size_t tensorrtMaxWorkspaceSize = 0;
    };
 
    BarcodeRecognizer(const BarcodeRecognizer::InitializationParams& params) {
 
        scanbotsdk_barcode_recognizer_init_params_t init_params = {.engine_mode = params.engineMode,
                                                                   .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_recognizer_create(&init_params, &recognizer);
        if (ret != scanbotsdk_error_code_t::SCANBOTSDK_OK) {
            recognizer = nullptr;
        }
    }
 
    ~BarcodeRecognizer() {
        if (recognizer != nullptr){
            scanbotsdk_barcode_recognizer_free(recognizer);
        }
    }
 
    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_recognizer_recognize(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_recognizer_t* recognizer = nullptr;
};
 
}  // namespace scanbotsdk::barcode
#endif // SCANBOTSDK_HPP