orbbec-sdk-sys 0.1.2+2.5.5

Low-level Rust bindings for https://github.com/orbbec/OrbbecSDK_v2
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

// Copyright (c) Orbbec Inc. All Rights Reserved.
// Licensed under the MIT License.

#pragma once
#include "IDevice.hpp"
#include "FilterDecorator.hpp"
#include "PrivFrameProcessorTypes.h"
#include "DeviceComponentBase.hpp"
#include "InternalTypes.hpp"
#include <dylib.hpp>
#include <map>

namespace libobsensor {
class FrameProcessor;
struct FrameProcessorContext {
    ob_frame_processor_context *context = nullptr;

    pfunc_ob_create_frame_processor_context          create_context          = nullptr;
    pfunc_ob_create_frame_processor                  create_processor        = nullptr;
    pfunc_ob_frame_processor_get_config_schema       get_config_schema       = nullptr;
    pfunc_ob_frame_processor_update_config           update_config           = nullptr;
    pfunc_ob_frame_processor_process_frame           process_frame           = nullptr;
    pfunc_ob_destroy_frame_processor                 destroy_processor       = nullptr;
    pfunc_ob_destroy_frame_processor_context         destroy_context         = nullptr;
    pfunc_ob_frame_processor_set_hardware_d2c_params set_hardware_d2c_params = nullptr;
};

class FrameProcessorFactory : public DeviceComponentBase {
public:
    explicit FrameProcessorFactory(IDevice *owner);
    ~FrameProcessorFactory() noexcept override;

    std::shared_ptr<FrameProcessor> createFrameProcessor(OBSensorType sensorType);

private:
    std::shared_ptr<dylib> dylib_;

    std::shared_ptr<FrameProcessorContext> context_;

    std::map<OBSensorType, std::shared_ptr<FrameProcessor>> frameProcessors_;
};

class FrameProcessor : public FilterExtension, public IBasicPropertyAccessor, public DeviceComponentBase {
public:
    using IBasicPropertyAccessor::getPropertyRange;

    FrameProcessor(IDevice *owner, std::shared_ptr<FrameProcessorContext> context, OBSensorType sensorType);
    virtual ~FrameProcessor() noexcept override;

    const std::string &getConfigSchema() const override;
    void updateConfig(std::vector<std::string> &params) override;

    OBSensorType getSensorType() {
        return sensorType_;
    }

    virtual void getPropertyRange(const std::string &configName, OBPropertyRange *range);

    std::shared_ptr<Frame> process(std::shared_ptr<const Frame> frame) override;

protected:
    std::shared_ptr<FrameProcessorContext> context_;

    ob_frame_processor *privateProcessor_;

private:
    OBSensorType sensorType_;

    std::string configSchema_;
};

class DepthFrameProcessor : public FrameProcessor {
public:
    using FrameProcessor::getPropertyRange;

    DepthFrameProcessor(IDevice *owner, std::shared_ptr<FrameProcessorContext> context);
    virtual ~DepthFrameProcessor() noexcept override;

    void setHardwareD2CProcessParams(std::shared_ptr<const VideoStreamProfile> colorVideoStreamProfile,std::shared_ptr<const VideoStreamProfile> depthVideoStreamProfile,std::vector<OBCameraParam> calibrationCameraParams, std::vector<OBD2CProfile> d2cProfiles, bool matchTargetResolution);

    void enableHardwareD2CProcess(bool enable);

private:
    OBD2CProfile  currentD2CProfile_ = {};

    virtual void setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) override;
    virtual void getPropertyValue(uint32_t propertyId, OBPropertyValue *value) override;
    virtual void getPropertyRange(uint32_t propertyId, OBPropertyRange *range) override;
};

class ColorFrameProcessor : public FrameProcessor {
public:
    using FrameProcessor::getPropertyRange;

    ColorFrameProcessor(IDevice *owner, std::shared_ptr<FrameProcessorContext> context);
    virtual ~ColorFrameProcessor() noexcept override = default;

    virtual void setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) override;
    virtual void getPropertyValue(uint32_t propertyId, OBPropertyValue *value) override;
    virtual void getPropertyRange(uint32_t propertyId, OBPropertyRange *range) override;
};

class IRFrameProcessor : public FrameProcessor {
public:
    using FrameProcessor::getPropertyRange;

    IRFrameProcessor(IDevice *owner, std::shared_ptr<FrameProcessorContext> context, OBSensorType sensorType = OB_SENSOR_IR);
    virtual ~IRFrameProcessor() noexcept override = default;

    virtual void setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) override;
    virtual void getPropertyValue(uint32_t propertyId, OBPropertyValue *value) override;
    virtual void getPropertyRange(uint32_t propertyId, OBPropertyRange *range) override;
};

class IRRightFrameProcessor : public FrameProcessor {
public:
    using FrameProcessor::getPropertyRange;

    IRRightFrameProcessor(IDevice *owner, std::shared_ptr<FrameProcessorContext> context);
    virtual ~IRRightFrameProcessor() noexcept override = default;

    virtual void setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) override;
    virtual void getPropertyValue(uint32_t propertyId, OBPropertyValue *value) override;
    virtual void getPropertyRange(uint32_t propertyId, OBPropertyRange *range) override;
};

class ConfidenceFrameProcessor : public FrameProcessor {
public:
    using FrameProcessor::getPropertyRange;

    ConfidenceFrameProcessor(IDevice *owner, std::shared_ptr<FrameProcessorContext> context);
    virtual ~ConfidenceFrameProcessor() noexcept override = default;

    virtual void setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) override;
    virtual void getPropertyValue(uint32_t propertyId, OBPropertyValue *value) override;
    virtual void getPropertyRange(uint32_t propertyId, OBPropertyRange *range) override;
};
}  // namespace libobsensor