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

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

#include "PlaybackDeviceParamManager.hpp"
#include "stream/StreamIntrinsicsManager.hpp"
#include "property/InternalProperty.hpp"

namespace libobsensor {

PlaybackDeviceParamManager::PlaybackDeviceParamManager(IDevice *owner, std::shared_ptr<PlaybackDevicePort> port) : DeviceComponentBase(owner), port_(port) {
    initDeviceParams();
    auto dispSpList = port_->getStreamProfileList(OB_SENSOR_DEPTH);
    if(dispSpList.empty()) {
        LOG_WARN("No disparity stream found on playback device");
        return;
    }

    auto dispSp = dispSpList.front()->as<DisparityBasedStreamProfile>();
    try {
        disparityParam_ = dispSp->getDisparityParam();
    }
    catch(const std::exception &e) {
        LOG_WARN("Playback Device get disparity param failed: {}", e.what());
    }
}
void PlaybackDeviceParamManager::bindStreamProfileParams(std::vector<std::shared_ptr<const StreamProfile>> streamProfileList) {
    utils::unusedVar((streamProfileList));
}

const std::vector<OBD2CProfile> &PlaybackDeviceParamManager::getD2CProfileList() const {
    return d2cProfileList_;
}

const std::vector<OBCameraParam> &PlaybackDeviceParamManager::getCalibrationCameraParamList() const {
    return cameraParamList_;
}

const OBIMUCalibrateParams &PlaybackDeviceParamManager::getIMUCalibrationParam() const {
    return imuCalibrationParam_;
}

const OBDisparityParam &PlaybackDeviceParamManager::getDisparityParam() const {
    return disparityParam_;
}

const OpenNIFrameProcessParam &PlaybackDeviceParamManager::getOpenNIFrameProcessParam() const {
    return frameProcessParam_;
}

void PlaybackDeviceParamManager::bindDisparityParam(std::vector<std::shared_ptr<const StreamProfile>> streamProfileList) {
    const auto &dispParam    = getDisparityParam();
    auto        intrinsicMgr = StreamIntrinsicsManager::getInstance();
    for(const auto &sp: streamProfileList) {
        if(!sp->is<DisparityBasedStreamProfile>()) {
            continue;
        }
        intrinsicMgr->registerDisparityBasedStreamDisparityParam(sp, dispParam);
    }
}

void PlaybackDeviceParamManager::initDeviceParams() {
    std::vector<uint8_t> rawData   = port_->getRecordedStructData(OB_RAW_DATA_D2C_ALIGN_SUPPORT_PROFILE_LIST);
    auto itemCount = rawData.size() / sizeof(OBD2CProfile);
    for(uint32_t i = 0; i < itemCount; i++) {
        auto item = reinterpret_cast<OBD2CProfile *>(rawData.data() + i * sizeof(OBD2CProfile));
        d2cProfileList_.push_back(*item);
    }

    rawData.clear();
    rawData = port_->getRecordedStructData(OB_RAW_DATA_ALIGN_CALIB_PARAM);
    itemCount = rawData.size() / sizeof(OBCameraParam);
    for(uint32_t i = 0; i < itemCount; i++) {
        auto item = reinterpret_cast<OBCameraParam *>(rawData.data() + i * sizeof(OBCameraParam));
        cameraParamList_.push_back(*item);
    }

    rawData.clear();
    rawData = port_->getRecordedStructData(OB_RAW_DATA_IMU_CALIB_PARAM);
    if(!rawData.empty()) {
        imuCalibrationParam_ = *(reinterpret_cast<OBIMUCalibrateParams *>(rawData.data()));
    }

    rawData.clear();
    rawData = port_->getRecordedStructData(OB_OPENNI_DEPTH_PROCESSOR_PARAM);
    if(!rawData.empty()) {
        frameProcessParam_ = *(reinterpret_cast<OpenNIFrameProcessParam *>(rawData.data()));
    }
}


}  // namespace libobsensor