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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

#include "G435LeFrameInterleaveManager.hpp"
#include "property/InternalProperty.hpp"
#include "InternalTypes.hpp"
#include "exception/ObException.hpp"
#include "utils/Utils.hpp"

namespace libobsensor {
const std::string hdr_interleave   = "Depth from HDR";
const std::string laser_interleave = "Laser On-Off";
G435LeFrameInterleaveManager::G435LeFrameInterleaveManager(IDevice *owner) : DeviceComponentBase(owner) {
    availableFrameInterleaves_.emplace_back(hdr_interleave);
    availableFrameInterleaves_.emplace_back(laser_interleave);

    currentIndex_ = -1;

    hdrDefault_[0].depthExposureTime = 7500;
    hdrDefault_[0].depthGain         = 16;
    hdrDefault_[0].depthBrightness   = 60;
    hdrDefault_[0].depthMaxExposure  = 10000;
    hdrDefault_[0].laserSwitch       = 1;

    hdrDefault_[1].depthExposureTime = 1;
    hdrDefault_[1].depthGain         = 16;
    hdrDefault_[1].depthBrightness   = 20;
    hdrDefault_[1].depthMaxExposure  = 2000;
    hdrDefault_[1].laserSwitch       = 1;

    memcpy(hdr_, hdrDefault_, sizeof(hdrDefault_));
    laserInterleaveDefault_[0].depthExposureTime = 3000;
    laserInterleaveDefault_[0].depthGain         = 16;
    laserInterleaveDefault_[0].depthBrightness   = 60;
    laserInterleaveDefault_[0].depthMaxExposure  = 30000;
    laserInterleaveDefault_[0].laserSwitch       = 1;

    laserInterleaveDefault_[1].depthExposureTime = 3000;
    laserInterleaveDefault_[1].depthGain         = 16;
    laserInterleaveDefault_[1].depthBrightness   = 60;
    laserInterleaveDefault_[1].depthMaxExposure  = 30000;
    laserInterleaveDefault_[1].laserSwitch       = 0;

    memcpy(laserInterleave_, laserInterleaveDefault_, sizeof(hdrDefault_));

    auto propServer = owner->getPropertyServer();

    propServer->registerAccessCallback(
        {
            OB_PROP_DEPTH_EXPOSURE_INT,
            OB_PROP_DEPTH_GAIN_INT,
            OB_PROP_IR_BRIGHTNESS_INT,
            OB_PROP_IR_AE_MAX_EXPOSURE_INT,
            OB_PROP_FRAME_INTERLEAVE_CONFIG_INDEX_INT,
            OB_PROP_FRAME_INTERLEAVE_ENABLE_BOOL,
            OB_PROP_LASER_CONTROL_INT,
        },
        [&](uint32_t propertyId, const uint8_t *, size_t, PropertyOperationType operationType) {
            if(operationType == PROP_OP_WRITE) {
                updateFrameInterleaveParam(propertyId);
            }
        });
}

template <typename T> void setPropertyValue(IDevice *dev, uint32_t propertyId, T value) {
    // get and release property server on this scope to avoid handle device resource lock for an extended duration
    auto propServer = dev->getPropertyServer();
    return propServer->setPropertyValueT<T>(propertyId, value);
}

template <typename T> T getPropertyValue(IDevice *dev, uint32_t propertyId) {
    // get and release property server on this scope to avoid handle device resource lock for an extended duration
    auto propServer = dev->getPropertyServer();
    return propServer->getPropertyValueT<T>(propertyId);
}

void G435LeFrameInterleaveManager::loadFrameInterleave(const std::string &frameInterleaveName) {
    if(std::find(availableFrameInterleaves_.begin(), availableFrameInterleaves_.end(), frameInterleaveName) == availableFrameInterleaves_.end()) {
        throw std::invalid_argument("Invalid frame interleave name: " + frameInterleaveName);
    }
    auto owner = getOwner();
    for(int i = 1; i >= 0; i--) {
        setPropertyValue(owner, OB_PROP_FRAME_INTERLEAVE_CONFIG_INDEX_INT, i);

        auto setProperties = [&](const FrameInterleaveParam *interleave, int sequenceId) {
            setPropertyValue(owner, OB_PROP_DEPTH_EXPOSURE_INT, interleave[sequenceId].depthExposureTime);
            setPropertyValue(owner, OB_PROP_DEPTH_GAIN_INT, interleave[sequenceId].depthGain);

            setPropertyValue(owner, OB_PROP_IR_BRIGHTNESS_INT, interleave[sequenceId].depthBrightness);
            setPropertyValue(owner, OB_PROP_IR_AE_MAX_EXPOSURE_INT, interleave[sequenceId].depthMaxExposure);
            setPropertyValue(owner, OB_PROP_LASER_CONTROL_INT, interleave[sequenceId].laserSwitch);
        };

        if(frameInterleaveName == hdr_interleave) {
            setProperties(hdr_, i);
        }
        else if(frameInterleaveName == laser_interleave) {
            setProperties(laserInterleave_, i);
        }
    }

    currentFrameInterleave_ = frameInterleaveName;
}

const std::vector<std::string> &G435LeFrameInterleaveManager::getAvailableFrameInterleaveList() const {
    return availableFrameInterleaves_;
}

void G435LeFrameInterleaveManager::updateFrameInterleaveParam(uint32_t propertyId) {
    auto owner = getOwner();

    if(propertyId == OB_PROP_FRAME_INTERLEAVE_ENABLE_BOOL) {
        auto enable = getPropertyValue<bool>(owner, OB_PROP_FRAME_INTERLEAVE_ENABLE_BOOL);
        if(!enable) {
            currentIndex_ = -1;
        }
    }

    if(propertyId == OB_PROP_FRAME_INTERLEAVE_CONFIG_INDEX_INT) {
        currentIndex_ = getPropertyValue<int>(owner, OB_PROP_FRAME_INTERLEAVE_CONFIG_INDEX_INT);
        // std::cout << "current index:" << currentIndex_ << std::endl;
    }

    if(currentIndex_ < 0 || currentIndex_ > 1) {
        return;
    }

    auto updateProperty = [&](FrameInterleaveParam *interleave) {
        switch(propertyId) {
        case OB_PROP_DEPTH_EXPOSURE_INT:
            interleave[currentIndex_].depthExposureTime = getPropertyValue<int>(owner, OB_PROP_DEPTH_EXPOSURE_INT);
            break;
        case OB_PROP_DEPTH_GAIN_INT:
            interleave[currentIndex_].depthGain = getPropertyValue<int>(owner, OB_PROP_DEPTH_GAIN_INT);
            break;
        case OB_PROP_IR_BRIGHTNESS_INT:
            interleave[currentIndex_].depthBrightness = getPropertyValue<int>(owner, OB_PROP_IR_BRIGHTNESS_INT);
            break;
        case OB_PROP_IR_AE_MAX_EXPOSURE_INT:
            interleave[currentIndex_].depthMaxExposure = getPropertyValue<int>(owner, OB_PROP_IR_AE_MAX_EXPOSURE_INT);
            break;
        case OB_PROP_LASER_CONTROL_INT:
            interleave[currentIndex_].laserSwitch = getPropertyValue<int>(owner, OB_PROP_LASER_CONTROL_INT);
            break;
        default:
            break;
        }
    };

    if(currentFrameInterleave_ == hdr_interleave) {
        updateProperty(hdr_);
    }
    else if(currentFrameInterleave_ == laser_interleave) {
        updateProperty(laserInterleave_);
    }
}

}  // namespace libobsensor