OB2Camera.hpp

浏览该文件的文档.

#pragma once
 
#include "OB2Types.hpp"
 
extern "C" {
#include "h/ob2camera.h"
}
 
#include <functional>
#include <memory>
#include <string>
 
namespace ob2 {
 
// 前置声明
class device;
class capture;
class image;
 
class cameras_config {
public:
    cameras_config(ob2_cameras_config_t &&cameras_config_handle) : m_cameras_config_handle(cameras_config_handle) {
        VALIDATE_NOT_NULL(m_cameras_config_handle);
    }
 
    cameras_config(cameras_config &&config) : m_cameras_config_handle(config.m_cameras_config_handle) {
        VALIDATE_NOT_NULL(m_cameras_config_handle);
        config.m_cameras_config_handle = nullptr;
    }
 
    virtual ~cameras_config() noexcept {
        ob2_status_t status;
        if(m_cameras_config_handle != nullptr) {
            ob2_cameras_config_release(m_cameras_config_handle, &status);
        }
    }
 
    virtual void set_camera_stream_profile(ob2_camera_type_t camera_type, const ob2_camera_stream_profile_t &stream_profile) {
        ob2_status_t status;
        ob2_cameras_config_set_camera_stream_profile(m_cameras_config_handle, camera_type, &stream_profile, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    virtual void enable_camera_stream(ob2_camera_type_t camera_type) {
        ob2_status_t status;
        ob2_cameras_config_enable_camera_stream(m_cameras_config_handle, camera_type, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    virtual void enable_camera_stream(ob2_camera_type_t camera_type, uint32_t width_pixels, uint32_t height_pixels, uint32_t frame_rate,
                                      ob2_image_format_t format) {
        ob2_status_t status;
        ob2_cameras_config_set_and_enable_camera_stream(m_cameras_config_handle, camera_type, width_pixels, height_pixels, frame_rate, format, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    virtual void set_disable_camera_stream(ob2_camera_type_t camera_type) {
        ob2_status_t status;
        ob2_cameras_config_disable_camera_stream(m_cameras_config_handle, camera_type, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    virtual void set_images_sync_mode(ob2_images_sync_mode_t images_sync_mode) {
        ob2_status_t status;
        ob2_cameras_config_set_images_sync_mode(m_cameras_config_handle, images_sync_mode, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    virtual void set_produce_capture_policy(ob2_produce_capture_policy_t policy) {
        ob2_status_t status;
        ob2_cameras_config_set_produce_capture_policy(m_cameras_config_handle, policy, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    virtual void set_images_align_mode(ob2_images_align_mode_t images_align_mode) {
        ob2_status_t status;
        ob2_cameras_config_set_images_align_mode(m_cameras_config_handle, images_align_mode, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    virtual void set_cameras_sync_mode(ob2_cameras_sync_mode_t cameras_sync_mode) {
        ob2_status_t status;
        ob2_cameras_config_set_cameras_sync_mode(m_cameras_config_handle, cameras_sync_mode, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    virtual void set_cameras_sync_delay_usec(uint32_t delay_usec) {
        ob2_status_t status;
        ob2_cameras_config_set_cameras_sync_delay_usec(m_cameras_config_handle, delay_usec, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    virtual void set_wired_sync_mode(ob2_wired_sync_mode_t wired_sync_mode) {
        ob2_status_t status;
        ob2_cameras_config_set_wired_sync_mode(m_cameras_config_handle, wired_sync_mode, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    virtual void set_secondary_delay_off_primary_usec(uint32_t delay_usec) {
        ob2_status_t status;
        ob2_cameras_config_set_secondary_delay_off_primary_usec(m_cameras_config_handle, delay_usec, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    virtual ob2_cameras_config_t get_handle() {
        return m_cameras_config_handle;
    }
 
protected:
    ob2_cameras_config_t m_cameras_config_handle;
};
 
class image {
public:
    image(ob2_camera_type_t source_camera_type, ob2_image_format_t image_format, uint32_t width_pixels, uint32_t height_pixels, uint32_t stride_bytes) {
        ob2_status_t status;
        m_image_handle = ob2_image_create(source_camera_type, image_format, width_pixels, height_pixels, stride_bytes, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    image(ob2_camera_type_t source_camera_type, ob2_image_format_t image_format, uint32_t width_pixels, uint32_t height_pixels, uint32_t stride_bytes,
          uint8_t *buffer, uint32_t buffer_size, buffer_release_cb cb) {
        ob2_status_t status;
        m_buffer_release_cb = cb;
        m_image_handle      = ob2_image_create_from_buffer(source_camera_type, image_format, width_pixels, height_pixels,  //
                                                      stride_bytes, buffer, buffer_size, &image::buffer_release_callback, this, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    image(ob2_image_t &&image_handle) : m_image_handle(image_handle) {
        VALIDATE_NOT_NULL(image_handle);
    }
 
    image(image &&img) : m_image_handle(img.m_image_handle) {
        VALIDATE_NOT_NULL(m_image_handle);
        img.m_image_handle = nullptr;
    }
 
    virtual ~image() noexcept {
        ob2_status_t status;
        if(m_image_handle != nullptr) {
            ob2_image_release(m_image_handle, &status);
        }
    }
 
    virtual uint8_t *get_buffer() {
        ob2_status_t status;
        auto         buffer = ob2_image_get_buffer(m_image_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return buffer;
    }
 
    virtual uint32_t get_size() {
        ob2_status_t status;
        auto         size = ob2_image_get_size(m_image_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return size;
    }
 
    virtual ob2_image_format_t get_format() {
        ob2_status_t status;
        auto         format = ob2_image_get_format(m_image_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return format;
    }
 
    virtual uint32_t get_width_pixels() {
        ob2_status_t status;
        auto         width = ob2_image_get_width_pixels(m_image_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return width;
    }
 
    virtual uint32_t get_height_pixels() {
        ob2_status_t status;
        auto         height = ob2_image_get_height_pixels(m_image_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return height;
    }
 
    virtual uint32_t get_stride_bytes() {
        ob2_status_t status;
        auto         stride = ob2_image_get_stride_bytes(m_image_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return stride;
    }
 
    virtual uint64_t get_device_timestamp_usec() {
        ob2_status_t status;
        auto         timestamp = ob2_image_get_device_timestamp_usec(m_image_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return timestamp;
    }
 
    virtual uint64_t get_system_timestamp_usec() {
        ob2_status_t status;
        auto         timestamp = ob2_image_get_system_timestamp_usec(m_image_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return timestamp;
    }
 
    virtual ob2_camera_type_t get_source_camera_type() {
        ob2_status_t status;
        auto         camera_type = ob2_image_get_source_camera_type(m_image_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return camera_type;
    }
 
    virtual uint8_t get_available_bits_for_each_pixel() {
        ob2_status_t status;
        auto         bits = ob2_image_get_available_bits_for_each_pixel(m_image_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return bits;
    }
 
    virtual float get_value_scale() {
        ob2_status_t status;
        auto         scale = ob2_depth_image_get_value_scale(m_image_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        return scale;
    }
 
    virtual ob2_image_t get_handle() {
        return m_image_handle;
    }
 
protected:
    static void buffer_release_callback(uint8_t *buffer, void *user_data) {
        auto im = (image *)user_data;
        im->m_buffer_release_cb(buffer);
    }
 
protected:
    ob2_image_t       m_image_handle;
    buffer_release_cb m_buffer_release_cb;
};
 
class capture {
public:
    capture() {
        ob2_status_t status;
        m_capture_handle = ob2_capture_create(&status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    capture(ob2_capture_t &&capture_handle) : m_capture_handle(capture_handle) {
        VALIDATE_NOT_NULL(capture_handle);
    }
 
    capture(capture &&cap) : m_capture_handle(cap.m_capture_handle) {
        VALIDATE_NOT_NULL(m_capture_handle);
        cap.m_capture_handle = nullptr;
    }
 
    virtual ~capture() noexcept {
        ob2_status_t status;
        if(nullptr != m_capture_handle) {
            ob2_capture_release(m_capture_handle, &status);
        }
    }
 
    virtual std::shared_ptr<image> get_image(ob2_camera_type_t camera_type) {
        ob2_status_t status;
        auto         image_handle = ob2_capture_get_image(m_capture_handle, camera_type, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        if(nullptr != image_handle) {
            return std::make_shared<image>(std::move(image_handle));
        }
        return nullptr;
    }
 
    virtual std::shared_ptr<image> get_color_image() {
        ob2_status_t status;
        auto         image_handle = ob2_capture_get_color_image(m_capture_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        if(nullptr != image_handle) {
            return std::make_shared<image>(std::move(image_handle));
        }
        return nullptr;
    }
 
    virtual std::shared_ptr<image> get_depth_image() {
        ob2_status_t status;
        auto         image_handle = ob2_capture_get_depth_image(m_capture_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        if(nullptr != image_handle) {
            return std::make_shared<image>(std::move(image_handle));
        }
        return nullptr;
    }
 
    virtual std::shared_ptr<image> get_ir_image() {
        ob2_status_t status;
        auto         image_handle = ob2_capture_get_ir_image(m_capture_handle, &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
        if(nullptr != image_handle) {
            return std::make_shared<image>(std::move(image_handle));
        }
        return nullptr;
    }
 
    virtual void set_image(ob2_camera_type_t camera_type, std::shared_ptr<image> im) {
        ob2_status_t status;
        ob2_capture_set_image(m_capture_handle, camera_type, im->get_handle(), &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    virtual void set_color_image(std::shared_ptr<image> im) {
        ob2_status_t status;
        ob2_capture_set_color_image(m_capture_handle, im->get_handle(), &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    virtual void set_depth_image(std::shared_ptr<image> im) {
        ob2_status_t status;
        ob2_capture_set_depth_image(m_capture_handle, im->get_handle(), &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    virtual void set_ir_image(std::shared_ptr<image> im) {
        ob2_status_t status;
        ob2_capture_set_ir_image(m_capture_handle, im->get_handle(), &status);
        CHECK_OB2_STATUS_ERROR_THROW(status);
    }
 
    virtual ob2_capture_t get_handle() {
        return m_capture_handle;
    }
 
protected:
    ob2_capture_t m_capture_handle;
};
 
typedef std::function<void(std::shared_ptr<capture>)> capture_cb;
}  // namespace ob2