OB2Extension.hpp

浏览该文件的文档.

#pragma once
 
#include "OB2Types.hpp"
#include "OB2Device.hpp"
 
extern "C" {
#include "h/ob2extension.h"
#include "h/ob2camera.h"
}
 
#include <memory>
 
namespace ob2 {
 
class transformation {
public:
    transformation(const ob2_cameras_calibration_t &calibration) {
        ob2_status_t status;
        m_transformation_handle = ob2_transformation_create(&calibration, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    transformation(transformation &&trans) : m_transformation_handle(trans.m_transformation_handle) {
        VALIDATE_NOT_NULL(m_transformation_handle);
        trans.m_transformation_handle = nullptr;
    }
 
    virtual ~transformation() noexcept {
        ob2_status_t status;
        if(m_transformation_handle != nullptr) {
            ob2_transformation_destroy(m_transformation_handle, &status);
        }
    }
 
    virtual std::shared_ptr<image> depth_image_to_point_cloud(std::shared_ptr<image> depth_image, float position_scale) {
        ob2_status_t status;
        auto         depth_image_handle  = depth_image->get_handle();
        auto         result_image_handle = ob2_transformation_depth_image_to_point_cloud(m_transformation_handle, depth_image_handle, position_scale, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return std::make_shared<image>(std::move(result_image_handle));
    }
 
    virtual std::shared_ptr<image> depth_image_to_colored_point_cloud(std::shared_ptr<image> depth_image, std::shared_ptr<image> color_image,
                                                                      float position_scale, ob2_enable_ctrl_t color_normalization) {
        ob2_status_t status;
        auto         depth_image_handle = depth_image->get_handle();
        auto         color_image_handle = color_image->get_handle();
        auto result_image_handle        = ob2_transformation_depth_image_to_colored_point_cloud(m_transformation_handle, depth_image_handle, color_image_handle,
                                                                                         position_scale, color_normalization, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return std::make_shared<image>(std::move(result_image_handle));
    }
 
private:
    ob2_transformation_t m_transformation_handle;
};
 
class image_compressor {
public:
    image_compressor() {
        ob2_status_t status;
        m_compressor_handle = ob2_image_compressor_create(&status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    image_compressor(image_compressor &&converter) : m_compressor_handle(converter.m_compressor_handle) {
        VALIDATE_NOT_NULL(m_compressor_handle);
        converter.m_compressor_handle = nullptr;
    }
 
    virtual ~image_compressor() noexcept {
        ob2_status_t status;
        if(m_compressor_handle != nullptr) {
            ob2_image_compressor_destroy(m_compressor_handle, &status);
        }
    }
 
    virtual std::shared_ptr<image> compress_lossless(const std::shared_ptr<image> source_image) {
        ob2_status_t status;
        auto         source_image_handle = source_image->get_handle();
        auto         result_image_handle = ob2_image_compress_lossless(m_compressor_handle, source_image_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return std::make_shared<image>(std::move(result_image_handle));
    }
 
    virtual std::shared_ptr<image> compress_lossy(const std::shared_ptr<image> source_image, uint8_t threshold) {
        ob2_status_t status;
        auto         source_image_handle = source_image->get_handle();
        auto         result_image_handle = ob2_image_compress_lossy(m_compressor_handle, source_image_handle, threshold, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return std::make_shared<image>(std::move(result_image_handle));
    }
 
private:
    ob2_compression_t m_compressor_handle;
};
 
class image_decompressor {
public:
    image_decompressor() {
        ob2_status_t status;
        m_decompressor_handle = ob2_image_decompressor_create(&status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    image_decompressor(image_decompressor &&converter) : m_decompressor_handle(converter.m_decompressor_handle) {
        VALIDATE_NOT_NULL(m_decompressor_handle);
        converter.m_decompressor_handle = nullptr;
    }
 
    virtual ~image_decompressor() noexcept {
        ob2_status_t status;
        if(m_decompressor_handle != nullptr) {
            ob2_image_decompressor_destroy(m_decompressor_handle, &status);
        }
    }
 
    virtual std::shared_ptr<image> decompress(const std::shared_ptr<image> source_image) {
        ob2_status_t status;
        auto         source_image_handle = source_image->get_handle();
        auto         result_image_handle = ob2_image_decompress(m_decompressor_handle, source_image_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return std::make_shared<image>(std::move(result_image_handle));
    }
 
private:
    ob2_decompression_t m_decompressor_handle;
};
 
class image_format_converter {
public:
    image_format_converter() {
        ob2_status_t status;
        m_converter_handle = ob2_image_format_converter_create(&status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    image_format_converter(image_format_converter &&converter) : m_converter_handle(converter.m_converter_handle) {
        VALIDATE_NOT_NULL(m_converter_handle);
        converter.m_converter_handle = nullptr;
    }
 
    virtual ~image_format_converter() noexcept {
        ob2_status_t status;
        if(m_converter_handle != nullptr) {
            ob2_image_format_converter_destroy(m_converter_handle, &status);
        }
    }
 
    virtual std::shared_ptr<image> yuyv_to_rgb(const std::shared_ptr<image> source_image) {
        ob2_status_t status;
        auto         source_image_handle = source_image->get_handle();
        auto         result_image_handle = ob2_image_format_converter_yuyv_to_rgb(m_converter_handle, source_image_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return std::make_shared<image>(std::move(result_image_handle));
    }
 
    virtual std::shared_ptr<image> uyvy_to_rgb(const std::shared_ptr<image> source_image) {
        ob2_status_t status;
        auto         source_image_handle = source_image->get_handle();
        auto         result_image_handle = ob2_image_format_converter_uyvy_to_rgb(m_converter_handle, source_image_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return std::make_shared<image>(std::move(result_image_handle));
    }
 
    virtual std::shared_ptr<image> i420_to_rgb(const std::shared_ptr<image> source_image) {
        ob2_status_t status;
        auto         source_image_handle = source_image->get_handle();
        auto         result_image_handle = ob2_image_format_converter_uyvy_to_rgb(m_converter_handle, source_image_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return std::make_shared<image>(std::move(result_image_handle));
    }
 
    virtual std::shared_ptr<image> nv21_to_rgb(const std::shared_ptr<image> source_image) {
        ob2_status_t status;
        auto         source_image_handle = source_image->get_handle();
        auto         result_image_handle = ob2_image_format_converter_uyvy_to_rgb(m_converter_handle, source_image_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return std::make_shared<image>(std::move(result_image_handle));
    }
 
    virtual std::shared_ptr<image> nv12_to_rgb(const std::shared_ptr<image> source_image) {
        ob2_status_t status;
        auto         source_image_handle = source_image->get_handle();
        auto         result_image_handle = ob2_image_format_converter_nv12_to_rgb(m_converter_handle, source_image_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return std::make_shared<image>(std::move(result_image_handle));
    }
 
    virtual std::shared_ptr<image> rgb_to_bgr(const std::shared_ptr<image> source_image) {
        ob2_status_t status;
        auto         source_image_handle = source_image->get_handle();
        auto         result_image_handle = ob2_image_format_converter_rgb_to_bgr(m_converter_handle, source_image_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return std::make_shared<image>(std::move(result_image_handle));
    }
 
    virtual std::shared_ptr<image> mjpg_to_i420(const std::shared_ptr<image> source_image) {
        ob2_status_t status;
        auto         source_image_handle = source_image->get_handle();
        auto         result_image_handle = ob2_image_format_converter_mjpg_to_i420(m_converter_handle, source_image_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return std::make_shared<image>(std::move(result_image_handle));
    }
 
    virtual std::shared_ptr<image> mjpg_to_nv21(const std::shared_ptr<image> source_image) {
        ob2_status_t status;
        auto         source_image_handle = source_image->get_handle();
        auto         result_image_handle = ob2_image_format_converter_mjpg_to_nv21(m_converter_handle, source_image_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return std::make_shared<image>(std::move(result_image_handle));
    }
 
    virtual std::shared_ptr<image> mjpg_to_rgb(const std::shared_ptr<image> source_image) {
        ob2_status_t status;
        auto         source_image_handle = source_image->get_handle();
        auto         result_image_handle = ob2_image_format_converter_mjpg_to_rgb(m_converter_handle, source_image_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return std::make_shared<image>(std::move(result_image_handle));
    }
 
    virtual std::shared_ptr<image> mjpg_to_bgr(const std::shared_ptr<image> source_image) {
        ob2_status_t status;
        auto         source_image_handle = source_image->get_handle();
        auto         result_image_handle = ob2_image_format_converter_mjpg_to_bgr(m_converter_handle, source_image_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return std::make_shared<image>(std::move(result_image_handle));
    }
 
    virtual std::shared_ptr<image> mjpg_to_bgra(const std::shared_ptr<image> source_image) {
        ob2_status_t status;
        auto         source_image_handle = source_image->get_handle();
        auto         result_image_handle = ob2_image_format_converter_mjpg_to_bgra(m_converter_handle, source_image_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return std::make_shared<image>(std::move(result_image_handle));
    }
 
private:
    ob2_image_format_converter_t m_converter_handle;
};
 
}  // namespace ob2