tami/MYNT-EYE-S-SDK
6
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

refactor(synthetic): callback complete

Browse Source
This commit is contained in:
TinyOh 2019-01-22 16:21:04 +08:00
parent c894ca4a4f
commit cdc5db724d
2 changed files with 69 additions and 294 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

113
src/mynteye/api/synthetic.cc
View File

@ -158,16 +158,9 @@ const struct Synthetic::stream_control_t Synthetic::getControlDateWithStream(
std::shared_ptr<Processor> Synthetic::getProcessorWithStream( std::shared_ptr<Processor> Synthetic::getProcessorWithStream(
const Stream& stream) { const Stream& stream) {
// for (auto &&it : processors_) {
// std::cout << it->Name();
// for (auto it_s : it->getTargetStreams()) {
// std::cout << it_s.stream << "----" << it_s.mode << std::endl;
// }
// }
for (auto &&it : processors_) { for (auto &&it : processors_) {
for (auto it_s : it->getTargetStreams()) { for (auto it_s : it->getTargetStreams()) {
if (it_s.stream == stream) { if (it_s.stream == stream) {
// std::cout << it_s.stream << "----" << it_s.mode << std::endl;
return it; return it;
} }
} }
@ -190,20 +183,20 @@ void Synthetic::setControlDateCallbackWithStream(
LOG(ERROR) << "ERROR: no suited processor for stream "<< ctr_data.stream; LOG(ERROR) << "ERROR: no suited processor for stream "<< ctr_data.stream;
} }
void Synthetic::setControlDateModeWithStream( // void Synthetic::setControlDateModeWithStream(
const struct stream_control_t& ctr_data) { // const struct stream_control_t& ctr_data) {
for (auto &&it : processors_) { // for (auto &&it : processors_) {
int i = 0; // int i = 0;
for (auto it_s : it->getTargetStreams()) { // for (auto it_s : it->getTargetStreams()) {
if (it_s.stream == ctr_data.stream) { // if (it_s.stream == ctr_data.stream) {
it->target_streams_[i].mode = ctr_data.mode; // it->target_streams_[i].mode = ctr_data.mode;
return; // return;
} // }
i++; // i++;
} // }
} // }
LOG(ERROR) << "ERROR: no suited processor for stream "<< ctr_data.stream; // LOG(ERROR) << "ERROR: no suited processor for stream "<< ctr_data.stream;
} // }
bool Synthetic::checkControlDateWithStream(const Stream& stream) const { bool Synthetic::checkControlDateWithStream(const Stream& stream) const {
for (auto &&it : processors_) { for (auto &&it : processors_) {
@ -220,15 +213,15 @@ bool Synthetic::checkControlDateWithStream(const Stream& stream) const {
// return checkControlDateWithStream(stream); // return checkControlDateWithStream(stream);
// } // }
Synthetic::status_mode_t Synthetic::GetStreamStatusMode( // Synthetic::status_mode_t Synthetic::GetStreamStatusMode(
const Stream &stream) const { // const Stream &stream) const {
if (checkControlDateWithStream(stream)) { // if (checkControlDateWithStream(stream)) {
auto ctrData = getControlDateWithStream(stream); // auto ctrData = getControlDateWithStream(stream);
return ctrData.mode; // return ctrData.mode;
} else { // } else {
return MODE_STATUS_LAST; // return MODE_STATUS_LAST;
} // }
} // }
// void Synthetic::EnableStreamData(const Stream &stream) { // void Synthetic::EnableStreamData(const Stream &stream) {
// // Activate processors of synthetic stream // // Activate processors of synthetic stream
@ -283,15 +276,24 @@ bool Synthetic::IsStreamDataEnabled(const Stream &stream) const {
void Synthetic::SetStreamCallback( void Synthetic::SetStreamCallback(
const Stream &stream, stream_callback_t callback) { const Stream &stream, stream_callback_t callback) {
stream_control_t data;
data.stream = stream;
if (callback == nullptr) { if (callback == nullptr) {
stream_callbacks_.erase(stream); data.stream_callback = nullptr;
} else { } else {
stream_callbacks_[stream] = callback; data.stream_callback = callback;
} }
setControlDateCallbackWithStream(data);
} }
bool Synthetic::HasStreamCallback(const Stream &stream) const { bool Synthetic::HasStreamCallback(const Stream &stream) const {
return stream_callbacks_.find(stream) != stream_callbacks_.end(); if (checkControlDateWithStream(stream)) {
auto data = getControlDateWithStream(stream);
if (data.stream_callback != nullptr) {
return true;
}
}
return false;
} }
void Synthetic::StartVideoStreaming() { void Synthetic::StartVideoStreaming() {
@ -308,7 +310,8 @@ void Synthetic::StartVideoStreaming() {
ProcessNativeStream(stream, stream_data); ProcessNativeStream(stream, stream_data);
// Need mutex if set callback after start // Need mutex if set callback after start
if (HasStreamCallback(stream)) { if (HasStreamCallback(stream)) {
stream_callbacks_.at(stream)(stream_data); auto data = getControlDateWithStream(stream);
data.stream_callback(stream_data);
} }
}, },
true); true);
@ -790,14 +793,22 @@ void Synthetic::InitProcessors() {
std::make_shared<RootProcessor>(RECTIFY_PROC_PERIOD); std::make_shared<RootProcessor>(RECTIFY_PROC_PERIOD);
root_processor->AddChild(rectify_processor); root_processor->AddChild(rectify_processor);
rectify_processor->addTargetStreams({Stream::LEFT_RECTIFIED, StatusMode::MODE_STATUS_LAST, Mode::MODE_LAST, Mode::MODE_LAST, nullptr}); rectify_processor->addTargetStreams(
rectify_processor->addTargetStreams({Stream::RIGHT_RECTIFIED, StatusMode::MODE_STATUS_LAST, Mode::MODE_LAST, Mode::MODE_LAST, nullptr}); {Stream::LEFT_RECTIFIED, Mode::MODE_LAST, Mode::MODE_LAST, nullptr});
disparity_processor->addTargetStreams({Stream::DISPARITY, StatusMode::MODE_STATUS_LAST, Mode::MODE_LAST, Mode::MODE_LAST, nullptr}); rectify_processor->addTargetStreams(
disparitynormalized_processor->addTargetStreams({Stream::DISPARITY_NORMALIZED, StatusMode::MODE_STATUS_LAST, Mode::MODE_LAST, Mode::MODE_LAST, nullptr}); {Stream::RIGHT_RECTIFIED, Mode::MODE_LAST, Mode::MODE_LAST, nullptr});
points_processor->addTargetStreams({Stream::POINTS, StatusMode::MODE_STATUS_LAST, Mode::MODE_LAST, Mode::MODE_LAST, nullptr}); disparity_processor->addTargetStreams(
depth_processor->addTargetStreams({Stream::DEPTH, StatusMode::MODE_STATUS_LAST, Mode::MODE_LAST, Mode::MODE_LAST, nullptr}); {Stream::DISPARITY, Mode::MODE_LAST, Mode::MODE_LAST, nullptr});
root_processor->addTargetStreams({Stream::LEFT, StatusMode::MODE_STATUS_LAST, Mode::MODE_NATIVE, Mode::MODE_NATIVE, nullptr}); disparitynormalized_processor->addTargetStreams(
root_processor->addTargetStreams({Stream::RIGHT, StatusMode::MODE_STATUS_LAST, Mode::MODE_NATIVE, Mode::MODE_NATIVE, nullptr}); {Stream::DISPARITY_NORMALIZED, Mode::MODE_LAST, Mode::MODE_LAST, nullptr});
points_processor->addTargetStreams(
{Stream::POINTS, Mode::MODE_LAST, Mode::MODE_LAST, nullptr});
depth_processor->addTargetStreams(
{Stream::DEPTH, Mode::MODE_LAST, Mode::MODE_LAST, nullptr});
root_processor->addTargetStreams(
{Stream::LEFT, Mode::MODE_NATIVE, Mode::MODE_NATIVE, nullptr});
root_processor->addTargetStreams(
{Stream::RIGHT, Mode::MODE_NATIVE, Mode::MODE_NATIVE, nullptr});
processors_.push_back(root_processor); processors_.push_back(root_processor);
processors_.push_back(rectify_processor); processors_.push_back(rectify_processor);
@ -1007,11 +1018,13 @@ bool Synthetic::OnDepthProcess(
void Synthetic::OnRectifyPostProcess(Object *const out) { void Synthetic::OnRectifyPostProcess(Object *const out) {
const ObjMat2 *output = Object::Cast<ObjMat2>(out); const ObjMat2 *output = Object::Cast<ObjMat2>(out);
if (HasStreamCallback(Stream::LEFT_RECTIFIED)) { if (HasStreamCallback(Stream::LEFT_RECTIFIED)) {
stream_callbacks_.at(Stream::LEFT_RECTIFIED)( auto data = getControlDateWithStream(Stream::LEFT_RECTIFIED);
data.stream_callback(
{output->first_data, output->first, nullptr, output->first_id}); {output->first_data, output->first, nullptr, output->first_id});
} }
if (HasStreamCallback(Stream::RIGHT_RECTIFIED)) { if (HasStreamCallback(Stream::RIGHT_RECTIFIED)) {
stream_callbacks_.at(Stream::RIGHT_RECTIFIED)( auto data = getControlDateWithStream(Stream::RIGHT_RECTIFIED);
data.stream_callback(
{output->second_data, output->second, nullptr, output->second_id}); {output->second_data, output->second, nullptr, output->second_id});
} }
} }
@ -1019,7 +1032,8 @@ void Synthetic::OnRectifyPostProcess(Object *const out) {
void Synthetic::OnDisparityPostProcess(Object *const out) { void Synthetic::OnDisparityPostProcess(Object *const out) {
const ObjMat *output = Object::Cast<ObjMat>(out); const ObjMat *output = Object::Cast<ObjMat>(out);
if (HasStreamCallback(Stream::DISPARITY)) { if (HasStreamCallback(Stream::DISPARITY)) {
stream_callbacks_.at(Stream::DISPARITY)( auto data = getControlDateWithStream(Stream::DISPARITY);
data.stream_callback(
{output->data, output->value, nullptr, output->id}); {output->data, output->value, nullptr, output->id});
} }
} }
@ -1027,7 +1041,8 @@ void Synthetic::OnDisparityPostProcess(Object *const out) {
void Synthetic::OnDisparityNormalizedPostProcess(Object *const out) { void Synthetic::OnDisparityNormalizedPostProcess(Object *const out) {
const ObjMat *output = Object::Cast<ObjMat>(out); const ObjMat *output = Object::Cast<ObjMat>(out);
if (HasStreamCallback(Stream::DISPARITY_NORMALIZED)) { if (HasStreamCallback(Stream::DISPARITY_NORMALIZED)) {
stream_callbacks_.at(Stream::DISPARITY_NORMALIZED)( auto data = getControlDateWithStream(Stream::DISPARITY_NORMALIZED);
data.stream_callback(
{output->data, output->value, nullptr, output->id}); {output->data, output->value, nullptr, output->id});
} }
} }
@ -1035,7 +1050,8 @@ void Synthetic::OnDisparityNormalizedPostProcess(Object *const out) {
void Synthetic::OnPointsPostProcess(Object *const out) { void Synthetic::OnPointsPostProcess(Object *const out) {
const ObjMat *output = Object::Cast<ObjMat>(out); const ObjMat *output = Object::Cast<ObjMat>(out);
if (HasStreamCallback(Stream::POINTS)) { if (HasStreamCallback(Stream::POINTS)) {
stream_callbacks_.at(Stream::POINTS)( auto data = getControlDateWithStream(Stream::POINTS);
data.stream_callback(
{output->data, output->value, nullptr, output->id}); {output->data, output->value, nullptr, output->id});
} }
} }
@ -1043,7 +1059,8 @@ void Synthetic::OnPointsPostProcess(Object *const out) {
void Synthetic::OnDepthPostProcess(Object *const out) { void Synthetic::OnDepthPostProcess(Object *const out) {
const ObjMat *output = Object::Cast<ObjMat>(out); const ObjMat *output = Object::Cast<ObjMat>(out);
if (HasStreamCallback(Stream::DEPTH)) { if (HasStreamCallback(Stream::DEPTH)) {
stream_callbacks_.at(Stream::DEPTH)( auto data = getControlDateWithStream(Stream::DEPTH);
data.stream_callback(
{output->data, output->value, nullptr, output->id}); {output->data, output->value, nullptr, output->id});
} }
} }

250
src/mynteye/api/synthetic.h
View File

@ -41,16 +41,8 @@ class Synthetic {
MODE_LAST // Unsupported MODE_LAST // Unsupported
} mode_t; } mode_t;
typedef enum StatusMode {
MODE_STATUS_NATIVE, // Native stream
MODE_STATUS_DISABLE, // Synthetic stream
MODE_STATUS_ENABLE, // Synthetic stream
MODE_STATUS_LAST // Unsupported
} status_mode_t;
struct stream_control_t { struct stream_control_t {
Stream stream; Stream stream;
status_mode_t mode;
mode_t support_mode_; mode_t support_mode_;
mode_t enabled_mode_; mode_t enabled_mode_;
stream_callback_t stream_callback; stream_callback_t stream_callback;
@ -82,11 +74,11 @@ class Synthetic {
void SetPlugin(std::shared_ptr<Plugin> plugin); void SetPlugin(std::shared_ptr<Plugin> plugin);
bool HasPlugin() const; bool HasPlugin() const;
const struct stream_control_t getControlDateWithStream(const Stream& stream) const; const struct stream_control_t getControlDateWithStream(
void setControlDateCallbackWithStream(const struct stream_control_t& ctr_data); const Stream& stream) const;
void setControlDateModeWithStream(const struct stream_control_t& ctr_data); void setControlDateCallbackWithStream(
const struct stream_control_t& ctr_data);
bool checkControlDateWithStream(const Stream& stream) const; bool checkControlDateWithStream(const Stream& stream) const;
status_mode_t GetStreamStatusMode(const Stream &stream) const;
std::shared_ptr<Processor> getProcessorWithStream(const Stream& stream); std::shared_ptr<Processor> getProcessorWithStream(const Stream& stream);
private: private:
@ -133,8 +125,6 @@ class Synthetic {
API *api_; API *api_;
std::map<Stream, stream_callback_t> stream_callbacks_;
std::shared_ptr<Processor> processor_; std::shared_ptr<Processor> processor_;
std::shared_ptr<Plugin> plugin_; std::shared_ptr<Plugin> plugin_;
@ -223,235 +213,3 @@ MYNTEYE_END_NAMESPACE
#endif // MYNTEYE_API_SYNTHETIC_H_ #endif // MYNTEYE_API_SYNTHETIC_H_
/*
// Copyright 2018 Slightech Co., Ltd. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef MYNTEYE_API_SYNTHETIC_H_
#define MYNTEYE_API_SYNTHETIC_H_
#pragma once
#include <map>
#include <memory>
#include <string>
#include <vector>
#include "mynteye/api/api.h"
#include "mynteye/api/config.h"
// #include "mynteye/api/processor.h"
MYNTEYE_BEGIN_NAMESPACE
class API;
class Plugin;
class Processor;
struct Object;
class Synthetic {
public:
using stream_callback_t = API::stream_callback_t;
typedef enum Mode {
MODE_NATIVE, // Native stream
MODE_SYNTHETIC, // Synthetic stream
MODE_LAST // Unsupported
} mode_t;
typedef enum StatusMode {
MODE_STATUS_NATIVE, // Native stream
MODE_STATUS_DISABLE, // Synthetic stream
MODE_STATUS_ENABLE, // Synthetic stream
MODE_STATUS_LAST // Unsupported
} status_mode_t;
struct stream_control_t {
Stream stream;
status_mode_t mode;
stream_callback_t stream_callback;
};
explicit Synthetic(API *api, CalibrationModel calib_model);
~Synthetic();
void NotifyImageParamsChanged();
bool Supports(const Stream &stream) const;
void EnableStreamData(const Stream &stream);
void DisableStreamData(const Stream &stream);
bool IsStreamDataEnabled(const Stream &stream) const;
bool IsStreamDataNative(const Stream &stream) const;
void SetStreamCallback(const Stream &stream, stream_callback_t callback);
bool HasStreamCallback(const Stream &stream) const;
void StartVideoStreaming();
void StopVideoStreaming();
void WaitForStreams();
api::StreamData GetStreamData(const Stream &stream);
std::vector<api::StreamData> GetStreamDatas(const Stream &stream);
void SetPlugin(std::shared_ptr<Plugin> plugin);
bool HasPlugin() const;
private:
void InitCalibInfo();
void InitStreamSupports();
status_mode_t GetStreamStatusMode(const Stream &stream) const;
std::shared_ptr<Processor> getProcessorWithStream(
const Stream& stream);
// mode_t GetStreamEnabledMode(const Stream &stream) const;
bool IsStreamEnabledNative(const Stream &stream) const;
bool IsStreamEnabledSynthetic(const Stream &stream) const;
// void EnableStreamData(const Stream &stream, std::uint32_t depth);
// void DisableStreamData(const Stream &stream, std::uint32_t depth);
void InitProcessors();
template <class T>
bool ActivateProcessor();
template <class T>
bool DeactivateProcessor();
void ProcessNativeStream(const Stream &stream, const api::StreamData &data);
bool OnRectifyProcess(
Object *const in, Object *const out,
std::shared_ptr<Processor> const parent);
bool OnDisparityProcess(
Object *const in, Object *const out,
std::shared_ptr<Processor> const parent);
bool OnDisparityNormalizedProcess(
Object *const in, Object *const out,
std::shared_ptr<Processor> const parent);
bool OnPointsProcess(
Object *const in, Object *const out,
std::shared_ptr<Processor> const parent);
bool OnDepthProcess(
Object *const in, Object *const out,
std::shared_ptr<Processor> const parent);
void OnRectifyPostProcess(Object *const out);
void OnDisparityPostProcess(Object *const out);
void OnDisparityNormalizedPostProcess(Object *const out);
void OnPointsPostProcess(Object *const out);
void OnDepthPostProcess(Object *const out);
const struct stream_control_t
getControlDateWithStream(const Stream& stream) const;
void setControlDateModeWithStream(const struct stream_control_t& ctr_data);
void setControlDateCallbackWithStream(
const struct stream_control_t& ctr_data);
bool checkControlDateWithStream(const Stream& stream) const;
std::vector<std::shared_ptr<Processor>> processors_;
API *api_;
std::map<Stream, mode_t> stream_supports_mode_;
std::map<Stream, mode_t> stream_enabled_mode_;
std::map<Stream, stream_callback_t> stream_callbacks_;
std::shared_ptr<Processor> processor_;
std::shared_ptr<Plugin> plugin_;
CalibrationModel calib_model_;
std::shared_ptr<IntrinsicsBase> intr_left_;
std::shared_ptr<IntrinsicsBase> intr_right_;
std::shared_ptr<Extrinsics> extr_;
bool calib_default_tag_;
};
class SyntheticProcessorPart {
private:
inline std::vector<Synthetic::stream_control_t> getTargetStreams() {
return target_streams_;
}
inline Stream addTargetStreams(const Synthetic::stream_control_t& strm) {
target_streams_.push_back(strm);
}
std::vector<Synthetic::stream_control_t> target_streams_;
inline unsigned int getStreamsSum() {return target_streams_.size();}
friend Synthetic;
};
template <class T, class P>
std::shared_ptr<T> find_processor(const P &processor) {
return find_processor<T>(processor, T::NAME);
}
template <class T, class P>
std::shared_ptr<T> find_processor(const P &processor, const std::string &name) {
if (processor->Name() == name) {
return std::dynamic_pointer_cast<T>(processor);
}
auto &&childs = processor->GetChilds();
return find_processor<T>(std::begin(childs), std::end(childs), name);
}
template <class T, class InputIt>
std::shared_ptr<T> find_processor(
InputIt first, InputIt last, const std::string &name) {
if (first == last)
return nullptr;
for (auto it = first; it != last; ++it) {
if ((*it)->Name() == name) {
return std::dynamic_pointer_cast<T>(*it);
}
}
for (auto it = first; it != last; ++it) {
auto &&childs = (*it)->GetChilds();
if (childs.empty())
continue;
auto &&result =
find_processor<T>(std::begin(childs), std::end(childs), name);
if (result == nullptr)
continue;
return result;
}
return nullptr;
}
template <class T>
bool Synthetic::ActivateProcessor() {
auto &&processor = find_processor<T>(processor_);
if (processor == nullptr)
return false;
processor->Activate();
return true;
}
template <class T>
bool Synthetic::DeactivateProcessor() {
auto &&processor = find_processor<T>(processor_);
if (processor == nullptr)
return false;
processor->Deactivate();
return true;
}
MYNTEYE_END_NAMESPACE
#endif // MYNTEYE_API_SYNTHETIC_H_
*/