3DiVi Face SDK  3.23.0
 Указатель Классы Пространства имен Файлы Функции Переменные Определения типов Перечисления Элементы перечислений Свойства Группы Страницы
Context.h
1 
9 #ifndef CONTEXT_H
10 #define CONTEXT_H
11 
12 #ifndef WITHOUT_PROCESSING_BLOCK
13 
14 #if defined(_WIN32)
15 #define NOMINMAX
16 #endif
17 
18 #include <functional>
19 #include <iostream>
20 #include <memory>
21 #include <string>
22 #include <unordered_map>
23 
24 #include <pbio/DllHandle.h>
25 #include <pbio/RawImage.h>
26 #include <pbio/RawSample.h>
27 
28 
29 namespace pbio {
30 
31 typedef LightSmartPtr<import::DllHandle>::tPtr DHPtr;
32 
33 inline void tdvCheckException(const DHPtr& dll_handle, ContextEH*& out_exception) {
34  if(out_exception)
35  {
36  auto err = Error(dll_handle->TDVException_getErrorCode(out_exception), dll_handle->TDVException_getMessage(out_exception));
37  dll_handle->TDVException_deleteException(out_exception);
38  out_exception = nullptr;
39  throw err;
40  }
41 }
42 
43 class ContextRef;
44 
45 
52 class Context
53 {
54 
55  friend class FacerecService;
56  friend class RawSample;
57 
58  template<bool isConst=false>
59  class ContextArrayIterator
60  {
61  class charsList {
62  public:
63  size_t length_;
64  char** ptr_;
65  charsList(size_t length, char** ptr) : length_(length), ptr_(ptr) {}
66  char* operator[](size_t index) const {
67  return (index<length_) ? *(ptr_+index) : nullptr;
68  }
69  };
70 
71  const Context& base_;
72  size_t length_;
73  size_t index_;
74  Context* curr_;
75  const bool isObj_;
76  std::shared_ptr<charsList> keys_;
77 
78  void charsList_deleter(charsList* ptr) {
79  for(size_t indx=0; indx < ptr->length_; ++indx)
80  base_.dll_handle->TDVContext_freePtr(ptr->ptr_[indx]);
81  base_.dll_handle->TDVContext_freePtr(ptr->ptr_);
82  };
83 
84  public:
85  typedef std::ptrdiff_t difference_type;
86  typedef std::forward_iterator_tag iterator_category;
87  typedef Context value_type;
88  typedef typename std::conditional<isConst, const value_type*, value_type*>::type pointer;
89  typedef typename std::conditional<isConst, const value_type&, value_type&>::type reference;
90  typedef const value_type& const_reference;
91 
92  ContextArrayIterator(const Context& ctx, long long index);
93  ContextArrayIterator(const Context& ctx, const std::string& key);
94 
95  ContextArrayIterator(const ContextArrayIterator& iter);
96  ContextArrayIterator& operator=(const ContextArrayIterator& iter) = delete;
97  ContextArrayIterator(ContextArrayIterator&& iter);
98  ContextArrayIterator& operator=(ContextArrayIterator&& iter) = delete;
99 
100  ~ContextArrayIterator() {
101  if(curr_)
102  delete curr_;
103  }
104 
105  bool operator==(const ContextArrayIterator& other) const {
106  return ((this->base_ == other.base_) && (this->curr_ == other.curr_));
107  }
108 
109  bool operator!=(const ContextArrayIterator& other) const {
110  return (!(this->base_ == other.base_) || !(this->curr_ == other.curr_));
111  }
112 
113  ContextArrayIterator& operator++();
114  ContextArrayIterator operator++(int);
115 
116  reference operator*() {
117  return *curr_;
118  }
119 
120  pointer operator->() {
121  return curr_;
122  }
123 
124  std::string key() const {
125  if (keys_ && index_ < length_)
126  return std::string(keys_->operator[](index_));
127  return std::string();
128  }
129  };
130 
131 public:
132  enum Format
133  {
134  FORMAT_BGR = 0,
135  FORMAT_RGB = 1,
136  FORMAT_BGRA8888 = 2,
137  FORMAT_YUV420 = 3,
138  FORMAT_YUV_NV12 = 4,
139  FORMAT_NV21 = 5,
140  };
141 
142 protected:
143 
144  Context(const DHPtr& dll_handle) : dll_handle(dll_handle), weak_(false), eh_(nullptr) {
145  handle_ = dll_handle->TDVContext_create(&eh_);
146  tdvCheckException(dll_handle, eh_);
147  }
148 
149  Context(const DHPtr& dll_handle, HContext* handle, bool weak = true) : dll_handle(dll_handle), weak_(weak), eh_(nullptr) {
150  if(weak_)
151  handle_ = handle;
152  else
153  {
154  handle_ = dll_handle->TDVContext_clone(handle, &eh_);
155  tdvCheckException(dll_handle, eh_);
156  }
157  }
158 
159  Context(const DHPtr& dll_handle, const uint8_t* data, uint64_t dataSize) :
160  dll_handle(dll_handle),
161  weak_(false),
162  eh_(nullptr)
163  {
164  handle_ = dll_handle->TDVContext_createFromEncodedImage(data, dataSize, &eh_);
165  tdvCheckException(dll_handle, eh_);
166  }
167 
168  Context(const DHPtr& dll_handle, uint8_t* data, int32_t width, int32_t height, Format format, int32_t baseAngle) :
169  dll_handle(dll_handle),
170  weak_(false),
171  eh_(nullptr)
172  {
173  handle_ = dll_handle->TDVContext_createFromFrame(data, width, height, static_cast<int32_t>(format), baseAngle, &eh_);
174  tdvCheckException(dll_handle, eh_);
175  }
176 
177  Context(const DHPtr& dll_handle, const char* path) :
178  dll_handle(dll_handle),
179  weak_(false),
180  eh_(nullptr)
181  {
182  handle_ = dll_handle->TDVContext_createFromJsonFile(path, &eh_);
183  tdvCheckException(dll_handle, eh_);
184  }
185 
186  DHPtr dll_handle;
187  HContext* handle_;
188  bool weak_;
189  mutable ContextEH* eh_;
190 
191 public:
192 
193  typedef ContextRef Ref;
194 
195  virtual ~Context()
196  {
197  if(!weak_) {
198  dll_handle->TDVContext_destroy(handle_, &eh_);
199  if (eh_ && std::uncaught_exception())
200  std::cerr << Error(dll_handle->TDVException_getErrorCode(eh_), dll_handle->TDVException_getMessage(eh_)).what();
201  else
202  tdvCheckException(dll_handle, eh_);
203  }
204  }
205 
206  Context(const Context& other) : dll_handle(other.dll_handle), weak_(false), eh_(nullptr) {
207  handle_ = dll_handle->TDVContext_clone(other.handle_, &eh_);
208  tdvCheckException(dll_handle, eh_);
209  }
210 
211  Context& operator=(const Context& other) {
212  if (&other != this)
213  {
214  if(weak_)
215  dll_handle->TDVContext_copy(other.handle_, handle_, &eh_);
216  else {
217  HContext* copy = dll_handle->TDVContext_clone(other.handle_, &eh_); // copy-swap
218  tdvCheckException(dll_handle, eh_);
219  std::swap(handle_, copy);
220  dll_handle->TDVContext_destroy(copy, &eh_);
221  }
222  tdvCheckException(dll_handle, eh_);
223  }
224  return *this;
225  }
226 
227  Context(Context&& other) : dll_handle(other.dll_handle), weak_(false), eh_(nullptr) {
228  if(other.weak_)
229  {
230  handle_ = dll_handle->TDVContext_clone(other.handle_, &eh_);
231  tdvCheckException(dll_handle, eh_);
232  }
233  else
234  {
235  handle_ = other.handle_;
236  other.handle_ = nullptr;
237  other.weak_ = true;
238  }
239  }
240 
241  Context& operator=(Context&& other){
242  if (&other != this)
243  {
244  if(weak_) {
245  dll_handle->TDVContext_copy(other.handle_, handle_, &eh_);
246  tdvCheckException(dll_handle, eh_);
247  }
248  else
249  {
250  if(other.weak_)
251  {
252  HContext* copy = dll_handle->TDVContext_clone(other.handle_, &eh_);
253  tdvCheckException(dll_handle, eh_);
254  std::swap(handle_, copy);
255  dll_handle->TDVContext_destroy(copy, &eh_);
256  tdvCheckException(dll_handle, eh_);
257  }
258  else
259  {
260  handle_ = other.handle_;
261  other.handle_ = nullptr;
262  other.weak_ = true;
263  }
264  }
265  }
266  return *this;
267  }
268 
269  operator ContextRef();
270 
279  template <typename T, typename = typename std::enable_if<!std::is_base_of<Context, typename std::decay<T>::type>::value>::type>
280  Context& operator=(T&& value) {
281  setValue(std::forward<T>(value));
282  return *this;
283  }
284 
285  bool operator==(const Context& other) const
286  {return this->handle_ == other.handle_;}
287 
296  size_t size() const {
297  size_t lenght = dll_handle->TDVContext_getLength(handle_, &eh_);
298  tdvCheckException(dll_handle, eh_);
299  return lenght;
300  }
301 
302  ContextArrayIterator<> begin(){
303  return ContextArrayIterator<>(*this, 0);
304  }
305 
306  ContextArrayIterator<> end(){
307  return ContextArrayIterator<>(*this, -1);
308  }
309 
310  ContextArrayIterator<true> begin() const {
311  return ContextArrayIterator<true>(*this, 0);
312  }
313 
314  ContextArrayIterator<true> end() const {
315  return ContextArrayIterator<true>(*this, -1);
316  }
317 
318  ContextArrayIterator<true> cbegin() const {
319  return ContextArrayIterator<true>(*this, 0);
320  }
321 
322  ContextArrayIterator<true> cend() const {
323  return ContextArrayIterator<true>(*this, -1);
324  }
325 
334  Ref operator[](const std::string& key);
335  Ref operator[](const char* key);
336 
345  Ref operator[](const int index);
346 
347  const Ref operator[](const std::string& key) const;
348  const Ref operator[](const char* key) const;
349  const Ref operator[](const int index) const;
350 
351  Ref at(const char* key);
352  Ref at(const std::string& key);
353  Ref at(const int index);
354 
355  const Ref at(const char* key) const;
356  const Ref at(const std::string& key) const;
357  const Ref at(const int index) const;
358 
369  bool contains(const std::string& key) const {
370  bool result = dll_handle->TDVContext_contains(handle_, key.data(), &eh_);
371  tdvCheckException(dll_handle, eh_);
372 
373  return result;
374  }
375 
386  bool compare(const Context& other) const {
387  bool result = dll_handle->TDVContext_compare(handle_, other.handle_, &eh_);
388  tdvCheckException(dll_handle, eh_);
389 
390  return result;
391  }
392 
401  std::vector<std::string> getKeys(){
402  size_t length = size();
403 
404  auto keys = dll_handle->TDVContext_getKeys(handle_, length, &eh_);
405  tdvCheckException(dll_handle, eh_);
406 
407  std::vector<std::string> result(length);
408  for (size_t i = 0; i < length; ++i)
409  result.emplace_back(keys[i]);
410 
411  return result;
412  }
413 
414  ContextArrayIterator<> find(const std::string& key) {
415  return ContextArrayIterator<>(*this, key);
416  }
417 
418  ContextArrayIterator<true> find(const std::string& key) const {
419  return ContextArrayIterator<true>(*this, key);
420  }
421 
422  template<typename T>
423  typename std::enable_if<!std::is_base_of<Context, typename std::decay<T>::type>::value>::type push_back(T&& data) {
424  Context elem(dll_handle);
425  elem.setValue(std::forward<T>(data));
426  // use r-value version of push_back without a copy
427  push_back(std::move(elem));
428  }
429 
438  void push_back(const Context& data) {
439  dll_handle->TDVContext_pushBack(handle_, data.handle_, true, &eh_);
440  tdvCheckException(dll_handle, eh_);
441  }
442 
443  void push_back(Context&& data) {
444  dll_handle->TDVContext_pushBack(handle_, data.handle_, weak_, &eh_); // can not move weak object
445  tdvCheckException(dll_handle, eh_);
446  }
447 
456  double getDouble() const {
457  double ret = dll_handle->TDVContext_getDouble(handle_, &eh_);
458  tdvCheckException(dll_handle, eh_);
459  return ret;
460  }
461 
470  long getLong() const {
471  long ret = dll_handle->TDVContext_getLong(handle_, &eh_);
472  tdvCheckException(dll_handle, eh_);
473  return ret;
474  }
475 
484  bool getBool() const {
485  bool ret = dll_handle->TDVContext_getBool(handle_, &eh_);
486  tdvCheckException(dll_handle, eh_);
487  return ret;
488  }
489 
498  std::string getString() const {
499  unsigned long str_size = dll_handle->TDVContext_getStrSize(handle_, &eh_);
500  tdvCheckException(dll_handle, eh_);
501  std::string ret;
502  ret.resize(str_size);
503  dll_handle->TDVContext_getStr(handle_, &ret[0], &eh_);
504  tdvCheckException(dll_handle, eh_);
505  return ret; // copy elision (NRVO)
506  }
507 
516  unsigned char* getDataPtr() const {
517  unsigned char* ret = dll_handle->TDVContext_getDataPtr(handle_, &eh_);
518  tdvCheckException(dll_handle, eh_);
519  return ret;
520  }
521 
530  void setString(const char* str) {
531  dll_handle->TDVContext_putStr(handle_, str, &eh_);
532  tdvCheckException(dll_handle, eh_);
533  }
534 
543  void setString(const std::string& str) {
544  dll_handle->TDVContext_putStr(handle_, str.c_str(), &eh_);
545  tdvCheckException(dll_handle, eh_);
546  }
547 
556  void setLong(long val) {
557  dll_handle->TDVContext_putLong(handle_, val, &eh_);
558  tdvCheckException(dll_handle, eh_);
559  }
560 
569  void setDouble(double val) {
570  dll_handle->TDVContext_putDouble(handle_, val, &eh_);
571  tdvCheckException(dll_handle, eh_);
572  }
573 
582  void setBool(bool val) {
583  dll_handle->TDVContext_putBool(handle_, val, &eh_);
584  tdvCheckException(dll_handle, eh_);
585  }
586 
597  unsigned char* setDataPtr(void* ptr, int copy_sz = 0) {
598  unsigned char* ret{nullptr};
599  if(copy_sz && !ptr)
600  ret = dll_handle->TDVContext_allocDataPtr(handle_, copy_sz, &eh_);
601  else
602  ret = dll_handle->TDVContext_putDataPtr(handle_, static_cast<unsigned char*>(ptr), copy_sz, &eh_);
603  tdvCheckException(dll_handle, eh_);
604  return ret;
605  }
606 
607  unsigned char* setDataPtr(const void* ptr, int copy_sz) {
608  unsigned char* ret = dll_handle->TDVContext_putConstDataPtr(handle_, static_cast<const unsigned char*>(ptr), copy_sz, &eh_);
609  tdvCheckException(dll_handle, eh_);
610  return ret;
611  }
612 
621  bool isNone() const {
622  bool value = dll_handle->TDVContext_isNone(handle_, &eh_);
623  tdvCheckException(dll_handle, eh_);
624  return value;
625  }
626 
635  bool isArray() const {
636  bool value = dll_handle->TDVContext_isArray(handle_, &eh_);
637  tdvCheckException(dll_handle, eh_);
638  return value;
639  }
640 
649  bool isObject() const {
650  bool value = dll_handle->TDVContext_isObject(handle_, &eh_);
651  tdvCheckException(dll_handle, eh_);
652  return value;
653  }
654 
663  bool isBool() const {
664  bool val = dll_handle->TDVContext_isBool(handle_, &eh_);
665  tdvCheckException(dll_handle, eh_);
666  return val;
667  }
668 
677  bool isLong() const {
678  bool val = dll_handle->TDVContext_isLong(handle_, &eh_);
679  tdvCheckException(dll_handle, eh_);
680  return val;
681  }
682 
691  bool isDouble() const {
692  bool val = dll_handle->TDVContext_isDouble(handle_, &eh_);
693  tdvCheckException(dll_handle, eh_);
694  return val;
695  }
696 
705  bool isString() const {
706  bool val = dll_handle->TDVContext_isString(handle_, &eh_);
707  tdvCheckException(dll_handle, eh_);
708  return val;
709  }
710 
719  bool isDataPtr() const {
720  bool val = dll_handle->TDVContext_isDataPtr(handle_, &eh_);
721  tdvCheckException(dll_handle, eh_);
722  return val;
723  }
724 
725  HContext* getHandle() {return handle_;}
726  const HContext* getHandle() const {return handle_;}
727 
734  void clear() {
735  dll_handle->TDVContext_clear(handle_, &eh_);
736  tdvCheckException(dll_handle,eh_);
737  }
738 
747  void erase(const char* str) {
748  dll_handle->TDVContext_erase(handle_, str, &eh_);
749  tdvCheckException(dll_handle,eh_);
750  }
751 
760  void erase(const std::string& str) {
761  erase(str.data());
762  }
763 
772  void reserve(const size_t size) {
773  dll_handle->TDVContext_reserve(handle_, size, &eh_);
774  tdvCheckException(dll_handle,eh_);
775  }
776 
785  void saveToJsonFile(std::string& path)
786  {
787  dll_handle->TDVContext_saveToJsonFile(handle_, path.c_str(), &eh_);
788  tdvCheckException(dll_handle,eh_);
789  }
790 
799  void saveToJsonFile(const char* path)
800  {
801  dll_handle->TDVContext_saveToJsonFile(handle_, path, &eh_);
802  tdvCheckException(dll_handle,eh_);
803  }
804 
805 protected:
806 
807  void setValue(const char* str) {
808  dll_handle->TDVContext_putStr(handle_, str, &eh_);
809  tdvCheckException(dll_handle, eh_);
810  }
811  void setValue(const std::string& str) {
812  dll_handle->TDVContext_putStr(handle_, str.c_str(), &eh_);
813  tdvCheckException(dll_handle, eh_);
814  }
815 
816  template<typename T, typename = typename std::enable_if<std::is_enum<T>::value || std::is_integral<T>::value>::type>
817  void setValue(T val) {
818  dll_handle->TDVContext_putLong(handle_, val, &eh_);
819  tdvCheckException(dll_handle, eh_);
820  }
821 
822  void setValue(double val) {
823  dll_handle->TDVContext_putDouble(handle_, val, &eh_);
824  tdvCheckException(dll_handle, eh_);
825  }
826  void setValue(float val) {
827  dll_handle->TDVContext_putDouble(handle_, val, &eh_);
828  tdvCheckException(dll_handle, eh_);
829  }
830  void setValue(bool val) {
831  dll_handle->TDVContext_putBool(handle_, val, &eh_);
832  tdvCheckException(dll_handle, eh_);
833  }
834  void setValue(void* ptr, int copy_sz = 0) {
835  dll_handle->TDVContext_putDataPtr(handle_, static_cast<unsigned char*>(ptr), copy_sz, &eh_);
836  tdvCheckException(dll_handle, eh_);
837  }
838 };
839 
840 class ContextRef : public Context {
841 public:
842 
843  ContextRef(const DHPtr &dll_handle, HContext* handle) : Context(dll_handle ,handle, true) {}
844 
845  ContextRef* getContextPtr () const { return new ContextRef(dll_handle, handle_); }
846 
847  template <typename T, typename = typename std::enable_if<!std::is_base_of<Context, typename std::decay<T>::type>::value>::type>
848  void operator=(T&& value) {
849  setValue(std::forward<T>(value));
850  }
851 };
852 
853 template<bool isConst>
854 Context::ContextArrayIterator<isConst>::ContextArrayIterator(const Context& ctx, long long index) : base_(ctx), curr_(nullptr), isObj_(ctx.isObject())
855 {
856  length_ = base_.dll_handle->TDVContext_getLength(base_.handle_, &(base_.eh_));
857  tdvCheckException(base_.dll_handle, base_.eh_);
858  index_ = (index > -1) ? std::min<size_t>(static_cast<size_t>(index), length_) : length_;
859  if(index_ < length_) {
860  if(isObj_)
861  {
862  auto keys = base_.dll_handle->TDVContext_getKeys(base_.handle_, length_, &(base_.eh_));
863  tdvCheckException(base_.dll_handle, base_.eh_);
864  keys_ = std::shared_ptr<charsList>(new charsList(length_, keys), std::bind(&ContextArrayIterator::charsList_deleter, this, std::placeholders::_1));
865  curr_ = new Context(base_[keys_->operator[](index)]);
866  }
867  else
868  curr_ = new Context(base_[index]);
869  }
870 }
871 
872 template<bool isConst>
873 Context::ContextArrayIterator<isConst>::ContextArrayIterator(const Context& ctx, const std::string& key) : base_(ctx), curr_(nullptr), isObj_(ctx.isObject())
874 {
875  length_ = base_.dll_handle->TDVContext_getLength(base_.handle_, &(base_.eh_));
876  tdvCheckException(base_.dll_handle, base_.eh_);
877  index_ = length_;
878  if(isObj_ && length_) {
879  auto keys = base_.dll_handle->TDVContext_getKeys(base_.handle_, length_, &(base_.eh_));
880  tdvCheckException(base_.dll_handle, base_.eh_);
881  keys_ = std::shared_ptr<charsList>(new charsList(length_, keys), std::bind(&ContextArrayIterator::charsList_deleter, this, std::placeholders::_1));
882  size_t i=0;
883  do {
884  if(!key.compare(keys_->operator[](i))) {
885  index_ = i;
886  curr_ = new Context(base_[key]);
887  break;
888  }
889  } while((++i)<length_);
890  }
891 }
892 
893 template<bool isConst>
894 Context::ContextArrayIterator<isConst>::ContextArrayIterator(const ContextArrayIterator& iter) :
895  base_(iter.base_), length_(iter.length_), index_(iter.index_), curr_(iter.curr_ ? new Context(*(iter.curr_)) : nullptr), isObj_(iter.isObj_), keys_(iter.keys_)
896 {};
897 
898 template<bool isConst>
899 Context::ContextArrayIterator<isConst>::ContextArrayIterator(ContextArrayIterator&& iter) :
900  base_(iter.base_), length_(iter.length_), index_(iter.index_), curr_(iter.curr_), isObj_(iter.isObj_), keys_(std::move(iter.keys_)) {
901  iter.curr_ = nullptr;
902 }
903 
904 template<bool isConst>
905 Context::ContextArrayIterator<isConst>& Context::ContextArrayIterator<isConst>::operator++() {
906  if(curr_)
907  delete curr_;
908  index_ = std::min(index_+1, length_);
909  if(isObj_)
910  curr_ = (index_ < length_) ? new Context(base_[keys_->operator[](index_)]) : nullptr;
911  else
912  curr_ = (index_ < length_) ? new Context(base_[index_]) : nullptr;
913  return *this;
914 }
915 
916 template<bool isConst>
917 Context::ContextArrayIterator<isConst> Context::ContextArrayIterator<isConst>::operator++(int) {
918  ContextArrayIterator tmp = *this;
919  index_ = std::min(index_+1, length_);
920  if(isObj_)
921  curr_ = (index_ < length_) ? new Context(base_[keys_->operator[](index_)]) : nullptr;
922  else
923  curr_ = (index_ < length_) ? new Context(base_[index_]) : nullptr;
924  return tmp;
925 }
926 
927 inline Context::operator ContextRef()
928 {
929  return ContextRef(dll_handle, handle_);
930 }
931 
932 inline Context::Ref Context::operator[](const std::string& key) {
933  HContext* handle = dll_handle->TDVContext_getOrInsertByKey(handle_, key.c_str(), &eh_);
934  tdvCheckException(dll_handle, eh_);
935  return Ref(dll_handle, handle);
936 }
937 
938 inline Context::Ref Context::operator[](const char* key) {
939  HContext* handle = dll_handle->TDVContext_getOrInsertByKey(handle_, key, &eh_);
940  tdvCheckException(dll_handle, eh_);
941  return Ref(dll_handle, handle);
942 }
943 
944 inline Context::Ref Context::operator[](const int index) {
945  HContext* handle = dll_handle->TDVContext_getByIndex(handle_, index, &eh_);
946  tdvCheckException(dll_handle, eh_);
947  return Ref(dll_handle, handle);
948 }
949 
950 inline const Context::Ref Context::operator[](const std::string& key) const {
951  HContext* handle = dll_handle->TDVContext_getByKey(handle_, key.c_str(), &eh_);
952  tdvCheckException(dll_handle, eh_);
953  return Ref(dll_handle, handle);
954 }
955 
956 inline const Context::Ref Context::operator[](const char* key) const {
957  HContext* handle = dll_handle->TDVContext_getByKey(handle_, key, &eh_);
958  tdvCheckException(dll_handle, eh_);
959  return Ref(dll_handle, handle);
960 }
961 
962 inline const Context::Ref Context::operator[](const int index) const {
963  HContext* handle = dll_handle->TDVContext_getByIndex(handle_, index, &eh_);
964  tdvCheckException(dll_handle, eh_);
965  return Ref(dll_handle, handle);
966 }
967 
968 inline Context::Ref Context::at(const char* key) {
969  HContext* handle = dll_handle->TDVContext_getByKey(handle_, key, &eh_);
970  tdvCheckException(dll_handle, eh_);
971  return Ref(dll_handle, handle);
972 }
973 
974 inline Context::Ref Context::at(const std::string& key) {
975  HContext* handle = dll_handle->TDVContext_getByKey(handle_, key.c_str(), &eh_);
976  tdvCheckException(dll_handle, eh_);
977  return Ref(dll_handle, handle);
978 }
979 
980 inline Context::Ref Context::at(const int index) {
981  HContext* handle = dll_handle->TDVContext_getByIndex(handle_, index, &eh_);
982  tdvCheckException(dll_handle, eh_);
983  return Ref(dll_handle, handle);
984 }
985 
986 inline const Context::Ref Context::at(const char* key) const {
987  HContext* handle = dll_handle->TDVContext_getByKey(handle_, key, &eh_);
988  tdvCheckException(dll_handle, eh_);
989  return Ref(dll_handle, handle);
990 }
991 
992 inline const Context::Ref Context::at(const std::string& key) const {
993  HContext* handle = dll_handle->TDVContext_getByKey(handle_, key.c_str(), &eh_);
994  tdvCheckException(dll_handle, eh_);
995  return Ref(dll_handle, handle);
996 }
997 
998 inline const Context::Ref Context::at(const int index) const {
999  HContext* handle = dll_handle->TDVContext_getByIndex(handle_, index, &eh_);
1000  tdvCheckException(dll_handle, eh_);
1001  return Ref(dll_handle, handle);
1002 }
1003 
1004 
1005 namespace context_utils {
1006 
1007 static std::unordered_map<int, std::string> color_mode{{IRawImage::FORMAT_GRAY, "GRAY"}, {IRawImage::FORMAT_BGR, "BGR"}, {IRawImage::FORMAT_RGB, "RGB"}};
1008 
1009 inline void putImage(Context& ctx, const RawImage& raw_image) {
1010  ctx.clear();
1011  ctx["format"] = "NDARRAY";
1012  ctx["color_space"] = color_mode.at(raw_image.format);
1013  size_t channels = (raw_image.format == IRawImage::FORMAT_GRAY) ? 1 : 3;
1014  size_t copy_sz = raw_image.height * raw_image.width * channels * sizeof(uint8_t);
1015  if (raw_image.with_crop)
1016  {
1017  unsigned char* buff{nullptr};
1018  buff = ctx["blob"].setDataPtr(buff, copy_sz);
1019  size_t shift = (raw_image.crop_info_offset_y*raw_image.crop_info_data_image_width + raw_image.crop_info_offset_x)*channels*sizeof(uint8_t);
1020  size_t stride = raw_image.width*channels*sizeof(uint8_t);
1021  unsigned char* ptr = buff;
1022  for(int row=0; row<raw_image.height; ++row)
1023  {
1024  std::memcpy(ptr, raw_image.data+shift, stride);
1025  shift += raw_image.crop_info_data_image_width*channels*sizeof(uint8_t);
1026  ptr += stride;
1027  }
1028  }
1029  else
1030  ctx["blob"].setDataPtr(raw_image.data, copy_sz);
1031  ctx["dtype"] = "uint8_t";
1032  ctx["shape"].push_back(static_cast<int64_t>(raw_image.height));
1033  ctx["shape"].push_back(static_cast<int64_t>(raw_image.width));
1034  ctx["shape"].push_back(static_cast<int64_t>(channels));
1035 }
1036 
1037 inline void putImage(Context& ctx, unsigned char* data, size_t height, size_t width, pbio::IRawImage::Format format, bool copy) {
1038  ctx.clear();
1039  ctx["format"] = "NDARRAY";
1040  ctx["color_space"] = color_mode.at(format);
1041  size_t channels = (format == IRawImage::FORMAT_GRAY) ? 1 : 3;
1042  size_t copy_sz = copy ? height * width * channels * sizeof(uint8_t) : 0;
1043  ctx["blob"].setDataPtr(data, copy_sz);
1044  ctx["dtype"] = "uint8_t";
1045  ctx["shape"].push_back(static_cast<int64_t>(height));
1046  ctx["shape"].push_back(static_cast<int64_t>(width));
1047  ctx["shape"].push_back(static_cast<int64_t>(channels));
1048 }
1049 
1050 }
1051 }
1052 
1053 #endif // WITHOUT_PROCESSING_BLOCK
1054 #endif // CONTEXT_H
bool isString() const
проверяет является ли контейнер значением типа string.
Definition: Context.h:705
Интерфейсный объект для создания других интерфейсных объектов.
Definition: FacerecService.h:64
RGB, 24 бита на пиксел, 8 бит на канал.
Definition: IRawImage.h:60
bool isDataPtr() const
проверяет является ли контейнер указателем на данные
Definition: Context.h:719
Интерфейсный объект, хранящий образец лица.
Definition: RawSample.h:49
void saveToJsonFile(std::string &path)
сохраняет содержимое контейнера в json файл
Definition: Context.h:785
void erase(const char *str)
удаляет содержимое контейнера-Context хранящиеся по ключу.
Definition: Context.h:747
void setString(const char *str)
добавляет значение типа string в контейнер
Definition: Context.h:530
void erase(const std::string &str)
удаляет содержимое контейнера-Context хранящиеся по ключу.
Definition: Context.h:760
void saveToJsonFile(const char *path)
сохраняет содержимое контейнера в json файл
Definition: Context.h:799
void reserve(const size_t size)
выделяет память под num элементов в массиве.
Definition: Context.h:772
Оттенки серого, 8 бит на пиксел.
Definition: IRawImage.h:53
void setDouble(double val)
добавляет значение типа double в контейнер
Definition: Context.h:569
std::vector< std::string > getKeys()
возвращает список ключей в контейнере-Context.
Definition: Context.h:401
void setString(const std::string &str)
добавляет значение типа std::string в контейнер
Definition: Context.h:543
unsigned char * getDataPtr() const
возвращает указатель на данные из контейнера
Definition: Context.h:516
bool isDouble() const
проверяет является ли контейнер значением типа double.
Definition: Context.h:691
RawSample - Интерфейсный объект, хранящий образец лица.
void push_back(const Context &data)
добавляет объект в контейнер.
Definition: Context.h:438
bool compare(const Context &other) const
сравнивает два объекта Context.
Definition: Context.h:386
bool isBool() const
проверяет является ли контейнер значением типа bool.
Definition: Context.h:663
void clear()
очищает содержимое контейнера-Context.
Definition: Context.h:734
BGR, 24 бита на пиксел, 8 бит на канал.
Definition: IRawImage.h:67
size_t size() const
Получить размер контейнера.
Definition: Context.h:296
bool contains(const std::string &key) const
проверяет существование элемента по определённому ключу
Definition: Context.h:369
bool isNone() const
проверяет нет ли в контейнере элементов
Definition: Context.h:621
Класс исключений, выбрасываемых при возникновении ошибок.
Definition: Error.h:26
Context & operator=(T &&value)
добавляет значение в контейнер
Definition: Context.h:280
bool isLong() const
проверяет является ли контейнер значением типа long.
Definition: Context.h:677
long getLong() const
возвращает значение типа long из контейнера
Definition: Context.h:470
bool isObject() const
проверяет является ли контейнер объектом
Definition: Context.h:649
Definition: Context.h:840
double getDouble() const
возвращает значение типа double из контейнера
Definition: Context.h:456
void setLong(long val)
добавляет значение типа long в контейнер
Definition: Context.h:556
bool getBool() const
возвращает значение типа bool из контейнера
Definition: Context.h:484
Context - интерфейсный объект для хранения данных и взаимодействия с методами из Processing Block API...
Definition: Context.h:52
unsigned char * setDataPtr(void *ptr, int copy_sz=0)
добавляет указатель на данные в контейнер
Definition: Context.h:597
std::string getString() const
возвращает значение типа std::string из контейнера
Definition: Context.h:498
void setBool(bool val)
добавляет значение типа bool в контейнер
Definition: Context.h:582
Ref operator[](const std::string &key)
индексация по ключу.
Definition: Context.h:932
bool isArray() const
проверяет является ли контейнере массивом
Definition: Context.h:635
Format
Формат данных изображения.
Definition: IRawImage.h:46