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.

#include "Config.hpp"
#include "logger/Logger.hpp"
#include "stream/StreamProfileFactory.hpp"
#include <algorithm>

namespace libobsensor {

void Config::enableStream(std::shared_ptr<const StreamProfile> prf) {
    auto iter = std::find_if(enabledStreamProfileList_.begin(), enabledStreamProfileList_.end(),
                             [prf](const std::shared_ptr<const StreamProfile> &p) { return p->getType() == prf->getType(); });
    if(iter != enabledStreamProfileList_.end()) {
        enabledStreamProfileList_.erase(iter);
    }
    enabledStreamProfileList_.push_back(prf);
}

void Config::enableStream(OBStreamType type) {
    auto prf = StreamProfileFactory::createStreamProfile(type);
    enableStream(prf);
}

void Config::enableVideoStream(OBStreamType type, uint32_t width, uint32_t height, uint32_t fps, OBFormat format) {
    auto prf = StreamProfileFactory::createVideoStreamProfile(type, format, width, height, fps);
    enableStream(prf);
}
void Config::enableAccelStream(OBAccelFullScaleRange fullScaleRange, ob_accel_sample_rate sampleRate) {
    auto prf = StreamProfileFactory::createAccelStreamProfile(fullScaleRange, sampleRate);
    enableStream(prf);
}

void Config::enableGyroStream(OBGyroFullScaleRange fullScaleRange, ob_gyro_sample_rate sampleRate) {
    auto prf = StreamProfileFactory::createGyroStreamProfile(fullScaleRange, sampleRate);
    enableStream(prf);
}

void Config::disableStream(OBStreamType type) {
    auto prfIter = enabledStreamProfileList_.begin();
    while(prfIter != enabledStreamProfileList_.end()) {
        if((*prfIter)->getType() == type) {
            enabledStreamProfileList_.erase(prfIter);
            break;
        }
        else {
            prfIter++;
        }
    }
}

StreamProfileList Config::getEnabledStreamProfileList() const {
    return enabledStreamProfileList_;
}

std::shared_ptr<const StreamProfile> Config::getEnabledStreamProfile(OBStreamType type) const {
    for(auto prf: enabledStreamProfileList_) {
        if(prf->getType() == type) {
            return prf;
        }
    }
    return nullptr;
}

void Config::setAlignMode(OBAlignMode mode) {
    alignMode_ = mode;
}

OBAlignMode Config::getAlignMode() const {
    return alignMode_;
}

void Config::setDepthScaleAfterAlignRequire(bool enable) {
    depthScaleRequire_ = enable;
}

bool Config::getDepthScaleAfterAlignRequire() const {
    return depthScaleRequire_;
}

void Config::disableAllStream() {
    enabledStreamProfileList_.clear();
}

void Config::setFrameAggregateOutputMode(OBFrameAggregateOutputMode mode) {
    frameAggregateOutputMode_ = mode;
}

OBFrameAggregateOutputMode Config::getFrameAggregateOutputMode() const {
    return frameAggregateOutputMode_;
}

bool Config::operator==(const Config &cmp) const {
    if(cmp.alignMode_ != alignMode_ || cmp.depthScaleRequire_ != depthScaleRequire_
       || cmp.enabledStreamProfileList_.size() != enabledStreamProfileList_.size()) {
        return false;
    }

    for(const auto &sp: enabledStreamProfileList_) {
        bool found = false;
        for(const auto &cmpSp: cmp.enabledStreamProfileList_) {
            if(sp.get() == cmpSp.get()) {
                found = true;
                break;
            }
        }

        if(!found) {
            return false;
        }
    }

    return true;
}

bool Config::operator!=(const Config &cmp) const {
    return !operator==(cmp);
}

std::shared_ptr<Config> Config::clone() const {
    auto config                       = std::make_shared<Config>();
    config->alignMode_                = alignMode_;
    config->depthScaleRequire_        = depthScaleRequire_;
    config->enabledStreamProfileList_ = enabledStreamProfileList_;
    config->frameAggregateOutputMode_ = frameAggregateOutputMode_;
    return config;
}

bool Config::isStreamEnabled(OBStreamType type) const {
    for(auto sp: enabledStreamProfileList_) {
        if(sp->getType() == type) {
            return true;
        }
    }
    return false;
}

}  // namespace libobsensor