3DiVi Face SDK  3.23.0
 Указатель Классы Пространства имен Файлы Функции Переменные Определения типов Перечисления Элементы перечислений Свойства Группы Страницы
VideoWorker.h
См. документацию.
1 
11 #ifndef __PBIO_API__PBIO__VIDEOWORKER_H_
12 #define __PBIO_API__PBIO__VIDEOWORKER_H_
13 
14 
15 #include <iostream>
16 #include <istream>
17 #include <sstream>
18 #include <vector>
19 #include <stdexcept>
20 
21 
22 
23 #include "ComplexObject.h"
24 #include "deprecated_macro.h"
25 #include "Error.h"
26 #include "ExceptionCheck.h"
27 #include "RawSample.h"
28 #include "Recognizer.h"
29 #include "SmartPtr.h"
30 #include "stl_wraps_impls/WrapIStreamBufferImpl.h"
31 #include "stl_wraps_impls/WrapIStreamImpl.h"
32 #include "stl_wraps_impls/WrapOStreamImpl.h"
33 #include "AgeGenderEstimator.h"
34 #include "EmotionsEstimator.h"
35 #include "Template.h"
36 #include "DepthLivenessEstimator.h"
37 #include "DepthMapRaw.h"
38 #include "IRLivenessEstimator.h"
39 #include "IRFrameRaw.h"
40 #include "StructStorageFields.h"
41 #include "SampleCheckStatus.h"
42 #include "Config.h"
43 #include "ActiveLiveness.h"
44 #include "util693bcd72/util.h"
45 
46 namespace pbio
47 {
48 
49 class FacerecService;
50 
63 class VideoWorker : public ComplexObject
64 {
65 public:
66 
72  typedef LightSmartPtr<VideoWorker>::tPtr Ptr;
73 
81  static const uint64_t MATCH_NOT_FOUND_ID = (uint64_t) (-1);
82 
83 
89  struct Params
90  {
95  Params();
96 
101  def_param_field_693bcd72(Params, pbio::Config , video_worker_config);
102 
107  def_param_field_693bcd72(Params, std::string , recognizer_ini_file);
108 
113  def_param_field_693bcd72(Params, pbio::Config , recognizer_config);
114 
119  def_param_field_693bcd72(Params, int , streams_count);
120 
125  def_param_field_693bcd72(Params, int , processing_threads_count);
126 
131  def_param_field_693bcd72(Params, int , matching_threads_count);
132 
137  def_param_field_693bcd72(Params, int , age_gender_estimation_threads_count);
138 
143  def_param_field_693bcd72(Params, int , emotions_estimation_threads_count);
144 
149  def_param_field_693bcd72(Params, bool , short_time_identification_enabled);
150 
155  def_param_field_693bcd72(Params, float , short_time_identification_distance_threshold);
156 
161  def_param_field_693bcd72(Params, float , short_time_identification_outdate_time_seconds);
162 
167  def_param_field_693bcd72(Params, std::vector<ActiveLiveness::CheckType> , active_liveness_checks_order);
168 
169  };
170 
171 
178  {
186  uint64_t person_id;
187 
195  uint64_t element_id;
196 
203  };
204 
205 
257  typedef
259  const int stream_id,
260  const int frame_id,
261  const std::vector<RawSample::Ptr> &samples,
262  const std::vector<bool> &samples_weak,
263  const std::vector<float> &samples_quality,
264  void* const userdata);
265 
275  {
286  int64_t stream_id;
287 
298  int64_t frame_id;
299 
320  std::vector<RawSample::Ptr> samples;
321 
334  std::vector<int> samples_track_id;
335 
356  std::vector<bool> samples_weak;
357 
370  std::vector<float> samples_quality;
371 
382  std::vector<SampleCheckStatus::Verdict> samples_good_light_and_blur;
383 
394  std::vector<SampleCheckStatus::Verdict> samples_good_angles;
395 
408  std::vector<SampleCheckStatus::Verdict> samples_good_face_size;
409 
420  std::vector<SampleCheckStatus::Verdict> samples_detector_confirmed;
421 
436  std::vector<DepthLivenessEstimator::Liveness> samples_depth_liveness_confirmed;
437 
452  std::vector<IRLivenessEstimator::Liveness> samples_ir_liveness_confirmed;
453 
464  std::vector<bool> samples_track_age_gender_set;
465 
476  std::vector<AgeGenderEstimator::AgeGender> samples_track_age_gender;
477 
488  std::vector<bool> samples_track_emotions_set;
489 
500  std::vector<EmotionsEstimator::EstimatedEmotionsVector> samples_track_emotions;
501 
516  std::vector<ActiveLiveness::ActiveLivenessStatus> samples_active_liveness_status;
517  };
518 
563  typedef
565  const TrackingCallbackData &data,
566  void* const userdata);
567 
581  PBIO_API_DEPRECATED_744e321c
582  typedef
584  const TrackingCallbackData &data,
585  void* const userdata);
586 
638  typedef
640  const int stream_id,
641  const int frame_id,
642  const RawSample::Ptr &sample,
643  const float quality,
644  const Template::Ptr &templ,
645  void* const userdata);
646 
656  {
667  int64_t stream_id;
668 
679  int64_t frame_id;
680 
690 
701  double quality;
702 
712  };
713 
714 
750  typedef
752  const TemplateCreatedCallbackData &data,
753  void* const userdata);
754 
768  PBIO_API_DEPRECATED_744e321c
769  typedef
771  const TemplateCreatedCallbackData &data,
772  void* const userdata);
773 
843  typedef
845  const int stream_id,
846  const int frame_id,
847  const uint64_t person_id,
848  const uint64_t element_id,
849  const RawSample::Ptr &sample,
850  const float quality,
851  const Template::Ptr &templ,
852  const Recognizer::MatchResult match_result,
853  void* const userdata);
854 
885  typedef
887  const int stream_id,
888  const int frame_id,
889  const RawSample::Ptr &sample,
890  const float quality,
891  const Template::Ptr &templ,
892  const std::vector<SearchResult> &search_result,
893  void* const userdata);
894 
904  {
915  int64_t stream_id;
916 
927  int64_t frame_id;
928 
938 
949  double quality;
950 
960 
981  std::vector<SearchResult> search_results;
982  };
983 
1057  typedef
1059  const MatchFoundCallbackData &data,
1060  void* const userdata);
1061 
1075  PBIO_API_DEPRECATED_744e321c
1076  typedef
1078  const MatchFoundCallbackData &data,
1079  void* const userdata);
1080 
1146  typedef
1148  const int stream_id,
1149  const int first_frame_id,
1150  const int last_frame_id,
1151  const float best_quality,
1152  const int best_quality_frame_id,
1153  const RawSample::Ptr &best_quality_sample,
1154  const Template::Ptr &best_quality_templ,
1155  void* const userdata);
1156 
1166  {
1177  int64_t stream_id;
1178 
1188 
1197  int64_t last_frame_id;
1198 
1208 
1218 
1232 
1244 
1255  int64_t track_id;
1256 
1268 
1279  int64_t sti_person_id;
1280  };
1281 
1325  typedef
1327  const TrackingLostCallbackData &data,
1328  void* const userdata);
1329 
1345  PBIO_API_DEPRECATED_744e321c
1346  typedef
1348  const TrackingLostCallbackData &data,
1349  void* const userdata);
1350 
1351 
1352 
1362  {
1373  int64_t stream_id;
1374 
1385  int64_t sti_person_id;
1386  };
1387 
1388 
1389 
1413  typedef
1415  const StiPersonOutdatedCallbackData &data,
1416  void* const userdata);
1417 
1418 
1419 
1435  {
1443  uint64_t element_id;
1444 
1452  uint64_t person_id;
1453 
1462 
1482  };
1483 
1484 
1502  std::string getMethodName() const;
1503 
1504 
1522  int getStreamsCount() const;
1523 
1524 
1556  int getTrackingConveyorSize(const int stream_id) const;
1557 
1558 
1584  void setDatabase(
1585  const std::vector<DatabaseElement> &elements,
1587  acceleration = Recognizer::SEARCH_ACCELERATION_1);
1588 
1636  int addVideoFrame(
1637  const RawImage frame,
1638  const int stream_id,
1639  const uint64_t timestamp_microsec = uint64_t(-1));
1640 
1673  void addDepthFrame(
1674  const DepthMapRaw &depth_frame,
1675  const int stream_id,
1676  const uint64_t timestamp_microsec);
1677 
1710  void addIRFrame(
1711  const IRFrameRaw &ir_frame,
1712  const int stream_id,
1713  const uint64_t timestamp_microsec);
1714 
1734  void resetTrackerOnStream(const int stream_id);
1735 
1736 
1737 
1779  int resetStream(const int stream_id);
1780 
1781 
1795  void checkExceptions();
1796 
1834  PBIO_API_DEPRECATED_744e321c
1835  int addTrackingCallback(
1836  const TrackingCallbackFunc callback,
1837  void* const userdata);
1838 
1873  const TrackingCallbackU callback,
1874  void* const userdata);
1875 
1913  PBIO_API_DEPRECATED_744e321c
1915  const TemplateCreatedCallbackFunc callback,
1916  void* const userdata);
1917 
1952  const TemplateCreatedCallbackU callback,
1953  void* const userdata);
1954 
1992  PBIO_API_DEPRECATED_744e321c
1994  const MatchFoundCallbackFunc callback,
1995  void* const userdata);
1996 
1997 
2035  PBIO_API_DEPRECATED_744e321c
2037  const MatchFoundCallbackFuncExt callback,
2038  void* const userdata);
2039 
2074  const MatchFoundCallbackU callback,
2075  void* const userdata);
2076 
2077 
2112  const StiPersonOutdatedCallbackU callback,
2113  void* const userdata);
2114 
2115 
2153  PBIO_API_DEPRECATED_744e321c
2155  const TrackingLostCallbackFunc callback,
2156  void* const userdata);
2157 
2192  const TrackingLostCallbackU callback,
2193  void* const userdata);
2194 
2212  void removeTrackingCallback(const int callback_id);
2213 
2214 
2232  void removeTemplateCreatedCallback(const int callback_id);
2233 
2234 
2254  void removeMatchFoundCallback(const int callback_id);
2255 
2256 
2274  void removeStiPersonOutdatedCallback(const int callback_id);
2275 
2293  void removeTrackingLostCallback(const int callback_id);
2294 
2295 
2317  void disableProcessingOnStream(const int stream_id);
2318 
2319 
2341  void enableProcessingOnStream(const int stream_id);
2342 
2343 
2344 
2364  void disableAgeGenderEstimationOnStream(const int stream_id);
2365 
2366 
2367 
2387  void enableAgeGenderEstimationOnStream(const int stream_id);
2388 
2408  void disableEmotionsEstimationOnStream(const int stream_id);
2409 
2410 
2411 
2431  void enableEmotionsEstimationOnStream(const int stream_id);
2432 
2434  void setParameter(
2435  const std::string parameter,
2436  const double value);
2438 
2439 
2440 // add callbacks for functor objects (lambda, for example)
2441 public:
2442 
2443  template<typename T>
2444  int addTrackingCallbackU(T* functor)
2445  {
2446  return addTrackingCallbackU(
2447  callCallbackFunctor<T, TrackingCallbackData>,
2448  (void*)functor);
2449  }
2450 
2451  template<typename T>
2452  int addTemplateCreatedCallbackU(T* functor)
2453  {
2455  callCallbackFunctor<T, TemplateCreatedCallbackData>,
2456  (void*)functor);
2457  }
2458 
2459  template<typename T>
2460  int addMatchFoundCallbackU(T* functor)
2461  {
2462  return addMatchFoundCallbackU(
2463  callCallbackFunctor<T, MatchFoundCallbackData>,
2464  (void*)functor);
2465  }
2466 
2467  template<typename T>
2468  int addStiPersonOutdatedCallbackU(T* functor)
2469  {
2471  callCallbackFunctor<T, StiPersonOutdatedCallbackData>,
2472  (void*)functor);
2473  }
2474 
2475  template<typename T>
2476  int addTrackingLostCallbackU(T* functor)
2477  {
2478  return addTrackingLostCallbackU(
2479  callCallbackFunctor<T, TrackingLostCallbackData>,
2480  (void*)functor);
2481  }
2482 
2483 private:
2484 
2485  template<typename T, typename DT>
2486  static
2487  void callCallbackFunctor(
2488  const DT &data,
2489  void* const userdata)
2490  {
2491  (*reinterpret_cast<T*>(userdata))(data);
2492  }
2493 
2494 
2495 
2496  static
2497  void STrackingCallback(
2498  void* err_stream,
2499  void* this_vw,
2500  void const* callback_data,
2501 
2502  const int32_t callbacks_count,
2503  void* const* const callbacks_func,
2504  void* const* const callbacks_userdata,
2505  const int32_t u_callbacks_count,
2506  void* const* const u_callbacks_func,
2507  void* const* const u_callbacks_userdata);
2508 
2509  static
2510  void STemplateCreatedCallback(
2511  void* err_stream,
2512  void* this_vw,
2513  void const* callback_data,
2514 
2515  const int32_t callbacks_count,
2516  void* const* const callbacks_func,
2517  void* const* const callbacks_userdata,
2518  const int32_t u_callbacks_count,
2519  void* const* const u_callbacks_func,
2520  void* const* const u_callbacks_userdata);
2521 
2522  static
2523  void SMatchFoundCallback(
2524  void* err_stream,
2525  void* this_vw,
2526  void const* callback_data,
2527 
2528  const int32_t callbacks_count,
2529  void* const* const callbacks_func,
2530  void* const* const callbacks_userdata,
2531  const int32_t ext_callbacks_count,
2532  void* const* const ext_callbacks_func,
2533  void* const* const ext_callbacks_userdata,
2534  const int32_t u_callbacks_count,
2535  void* const* const u_callbacks_func,
2536  void* const* const u_callbacks_userdata);
2537 
2538 
2539  static
2540  void STrackingLostCallback(
2541  void* err_stream,
2542  void* this_vw,
2543  void const* callback_data,
2544 
2545  const int32_t callbacks_count,
2546  void* const* const callbacks_func,
2547  void* const* const callbacks_userdata,
2548  const int32_t u_callbacks_count,
2549  void* const* const u_callbacks_func,
2550  void* const* const u_callbacks_userdata);
2551 
2552  static
2553  void SStiPersonOutdatedCallback(
2554  void* err_stream,
2555  void* this_vw__,
2556  void const* callback_data,
2557 
2558  const int32_t callbacks_count,
2559  void* const* const callbacks_func,
2560  void* const* const callbacks_userdata);
2561 
2562 
2563  void toggleSomething(
2564  const int stream_id,
2565  const int something);
2566 
2567  VideoWorker(
2568  const DHPtr &dll_handle,
2569  void* impl);
2570 
2571  friend class FacerecService;
2572  friend class object_with_ref_counter<VideoWorker>;
2573 };
2574 
2575 } // pbio namespace
2576 
2577 
2578 
2582 
2583 namespace pbio
2584 {
2585 
2586 
2587 
2588 inline
2589 VideoWorker::VideoWorker(
2590  const DHPtr &dll_handle,
2591  void* impl):
2592 ComplexObject(dll_handle, impl)
2593 {
2594  void* exception = NULL;
2595 
2596  _dll_handle->VideoWorker_setThisVW(
2597  _impl,
2598  this,
2599  &exception);
2600 
2601  checkException(exception, *_dll_handle);
2602 }
2603 
2604 inline
2605 std::string VideoWorker::getMethodName() const
2606 {
2607  std::ostringstream name_stream;
2608  pbio::stl_wraps::WrapOStreamImpl name_stream_wrap(name_stream);
2609 
2610  void* exception = NULL;
2611 
2612  _dll_handle->VideoWorker_getMethodName(
2613  _impl,
2614  &name_stream_wrap,
2615  pbio::stl_wraps::WrapOStream::write_func,
2616  &exception);
2617 
2618  checkException(exception, *_dll_handle);
2619 
2620  return name_stream.str();
2621 }
2622 
2623 
2624 inline
2626 {
2627  void* exception = NULL;
2628 
2629  const int result = _dll_handle->VideoWorker_getStreamsCount(
2630  _impl,
2631  &exception);
2632 
2633  checkException(exception, *_dll_handle);
2634 
2635  return result;
2636 }
2637 
2638 
2639 inline
2640 int VideoWorker::getTrackingConveyorSize(const int stream_id) const
2641 {
2642  void* exception = NULL;
2643 
2644  const int result = _dll_handle->VideoWorker_getTrackingConveyorSize(
2645  _impl,
2646  stream_id,
2647  &exception);
2648 
2649  checkException(exception, *_dll_handle);
2650 
2651  return result;
2652 }
2653 
2654 
2655 inline
2657  const std::vector<DatabaseElement> &elements,
2658  const Recognizer::SearchAccelerationType acceleration)
2659 {
2660  std::vector<uint64_t> element_ids_v(elements.size());
2661  std::vector<uint64_t> person_ids_v(elements.size());
2662  std::vector<pbio::facerec::TemplateImpl const*> templates_v(elements.size());
2663  std::vector<float> thresholds_v(elements.size());
2664 
2665  for(size_t i = 0; i < elements.size(); ++i)
2666  {
2667  element_ids_v[i] = elements[i].element_id;
2668  person_ids_v[i] = elements[i].person_id;
2669  templates_v[i] = (pbio::facerec::TemplateImpl const*) elements[i].face_template->_impl;
2670  thresholds_v[i] = elements[i].distance_threshold;
2671  }
2672 
2673  void* exception = NULL;
2674 
2675  _dll_handle->VideoWorker_setDatabase(
2676  _impl,
2677  acceleration,
2678  elements.size(),
2679  element_ids_v.data(),
2680  person_ids_v.data(),
2681  templates_v.data(),
2682  thresholds_v.data(),
2683  &exception);
2684 
2685  checkException(exception, *_dll_handle);
2686 }
2687 
2688 inline
2690  const RawImage frame,
2691  const int stream_id,
2692  const uint64_t timestamp_microsec)
2693 {
2694  void* exception = NULL;
2695 
2696  const RawImage::CapiData cdata = frame.makeCapiData();
2697 
2698  const int result = _dll_handle->VideoWorker_addVideoFrameWithTimestamp_with_crop(
2699  _impl,
2700 
2701  cdata.data,
2702  cdata.width,
2703  cdata.height,
2704  cdata.format,
2705 
2706  cdata.with_crop,
2707  cdata.crop_info_offset_x,
2708  cdata.crop_info_offset_y,
2709  cdata.crop_info_data_image_width,
2710  cdata.crop_info_data_image_height,
2711 
2712  stream_id,
2713  timestamp_microsec,
2714  &exception);
2715 
2716  checkException(exception, *_dll_handle);
2717 
2718  return result;
2719 }
2720 
2721 inline
2723  const DepthMapRaw &depth_frame,
2724  const int stream_id,
2725  const uint64_t timestamp_microsec)
2726 {
2727  void* exception = NULL;
2728 
2729  _dll_handle->VideoWorker_addDepthFrame(
2730  _impl,
2731  depth_frame.depth_map_rows,
2732  depth_frame.depth_map_cols,
2733  depth_frame.depth_map_2_image_offset_x,
2734  depth_frame.depth_map_2_image_offset_y,
2735  depth_frame.depth_map_2_image_scale_x,
2736  depth_frame.depth_map_2_image_scale_y,
2737  depth_frame.horizontal_fov,
2738  depth_frame.vertical_fov,
2739  depth_frame.depth_unit_in_millimeters,
2740  depth_frame.depth_data,
2741  depth_frame.depth_data_stride_in_bytes,
2742  stream_id,
2743  timestamp_microsec,
2744  &exception);
2745 
2746  checkException(exception, *_dll_handle);
2747 }
2748 
2749 inline
2751  const IRFrameRaw &ir_frame,
2752  const int stream_id,
2753  const uint64_t timestamp_microsec)
2754 {
2755  void* exception = NULL;
2756 
2757  _dll_handle->VideoWorker_addIRFrame(
2758  _impl,
2759  ir_frame.ir_frame_rows,
2760  ir_frame.ir_frame_cols,
2761  ir_frame.ir_frame_2_image_offset_x,
2762  ir_frame.ir_frame_2_image_offset_y,
2763  ir_frame.ir_frame_2_image_scale_x,
2764  ir_frame.ir_frame_2_image_scale_y,
2765  ir_frame.ir_horizontal_fov,
2766  ir_frame.ir_vertical_fov,
2767  ir_frame.ir_frame_data,
2768  ir_frame.ir_data_stride_in_bytes,
2769  stream_id,
2770  timestamp_microsec,
2771  &exception);
2772 
2773  checkException(exception, *_dll_handle);
2774 }
2775 
2776 inline
2777 void VideoWorker::resetTrackerOnStream(const int stream_id)
2778 {
2779  void* exception = NULL;
2780 
2781  _dll_handle->VideoWorker_resetTrackerOnStream(
2782  _impl,
2783  stream_id,
2784  &exception);
2785 
2786  checkException(exception, *_dll_handle);
2787 }
2788 
2789 
2790 inline
2791 int VideoWorker::resetStream(const int stream_id)
2792 {
2793  void* exception = NULL;
2794 
2795  const int threshold_track_id = _dll_handle->VideoWorker_resetStream(
2796  _impl,
2797  stream_id,
2798  &exception);
2799 
2800  checkException(exception, *_dll_handle);
2801 
2802  return threshold_track_id;
2803 }
2804 
2805 
2806 inline
2808 {
2809  void* exception = NULL;
2810 
2811  _dll_handle->VideoWorker_checkExceptions(
2812  _impl,
2813  &exception);
2814 
2815  checkException(exception, *_dll_handle);
2816 }
2817 
2818 inline
2820  const TrackingCallbackFunc callback,
2821  void* const userdata)
2822 {
2823  void* exception = NULL;
2824 
2825  const int result = _dll_handle->VideoWorker_addTrackingCallback(
2826  _impl,
2827  reinterpret_cast<void*>(callback),
2828  userdata,
2829  &exception);
2830 
2831  checkException(exception, *_dll_handle);
2832 
2833  return result;
2834 }
2835 
2836 inline
2838  const TrackingCallbackU callback,
2839  void* const userdata)
2840 {
2841  void* exception = NULL;
2842 
2843  const int result = _dll_handle->VideoWorker_addTrackingCallbackU(
2844  _impl,
2845  reinterpret_cast<void*>(callback),
2846  userdata,
2847  &exception);
2848 
2849  checkException(exception, *_dll_handle);
2850 
2851  return result;
2852 }
2853 
2854 
2855 
2856 inline
2858  const TemplateCreatedCallbackFunc callback,
2859  void* const userdata)
2860 {
2861  void* exception = NULL;
2862 
2863  const int result = _dll_handle->VideoWorker_addTemplateCreatedCallback(
2864  _impl,
2865  reinterpret_cast<void*>(callback),
2866  userdata,
2867  &exception);
2868 
2869  checkException(exception, *_dll_handle);
2870 
2871  return result;
2872 }
2873 
2874 inline
2876  const TemplateCreatedCallbackU callback,
2877  void* const userdata)
2878 {
2879  void* exception = NULL;
2880 
2881  const int result = _dll_handle->VideoWorker_addTemplateCreatedCallbackU(
2882  _impl,
2883  reinterpret_cast<void*>(callback),
2884  userdata,
2885  &exception);
2886 
2887  checkException(exception, *_dll_handle);
2888 
2889  return result;
2890 }
2891 
2892 
2893 inline
2895  const MatchFoundCallbackFunc callback,
2896  void* const userdata)
2897 {
2898  void* exception = NULL;
2899 
2900  const int result = _dll_handle->VideoWorker_addMatchFoundCallback(
2901  _impl,
2902  reinterpret_cast<void*>(callback),
2903  userdata,
2904  &exception);
2905 
2906  checkException(exception, *_dll_handle);
2907 
2908  return result;
2909 }
2910 
2911 
2912 inline
2914  const MatchFoundCallbackFuncExt callback,
2915  void* const userdata)
2916 {
2917  void* exception = NULL;
2918 
2919  const int result = _dll_handle->VideoWorker_addMatchFoundCallbackExt(
2920  _impl,
2921  reinterpret_cast<void*>(callback),
2922  userdata,
2923  &exception);
2924 
2925  checkException(exception, *_dll_handle);
2926 
2927  return result;
2928 }
2929 
2930 inline
2932  const MatchFoundCallbackU callback,
2933  void* const userdata)
2934 {
2935  void* exception = NULL;
2936 
2937  const int result = _dll_handle->VideoWorker_addMatchFoundCallbackU(
2938  _impl,
2939  reinterpret_cast<void*>(callback),
2940  userdata,
2941  &exception);
2942 
2943  checkException(exception, *_dll_handle);
2944 
2945  return result;
2946 }
2947 
2948 
2949 inline
2951  const TrackingLostCallbackFunc callback,
2952  void* const userdata)
2953 {
2954  void* exception = NULL;
2955 
2956  const int result = _dll_handle->VideoWorker_addTrackingLostCallback(
2957  _impl,
2958  reinterpret_cast<void*>(callback),
2959  userdata,
2960  &exception);
2961 
2962  checkException(exception, *_dll_handle);
2963 
2964  return result;
2965 }
2966 
2967 inline
2969  const TrackingLostCallbackU callback,
2970  void* const userdata)
2971 {
2972  void* exception = NULL;
2973 
2974  const int result = _dll_handle->VideoWorker_addTrackingLostCallbackU(
2975  _impl,
2976  reinterpret_cast<void*>(callback),
2977  userdata,
2978  &exception);
2979 
2980  checkException(exception, *_dll_handle);
2981 
2982  return result;
2983 }
2984 
2985 inline
2987  const StiPersonOutdatedCallbackU callback,
2988  void* const userdata)
2989 {
2990  void* exception = NULL;
2991 
2992  const int result = _dll_handle->VideoWorker_addStiPersonOutdatedCallbackU(
2993  _impl,
2994  reinterpret_cast<void*>(callback),
2995  userdata,
2996  &exception);
2997 
2998  checkException(exception, *_dll_handle);
2999 
3000  return result;
3001 }
3002 
3003 
3004 
3005 inline
3007  const int callback_id)
3008 {
3009  void* exception = NULL;
3010 
3011  _dll_handle->VideoWorker_removeTrackingCallback(
3012  _impl,
3013  callback_id,
3014  &exception);
3015 
3016  checkException(exception, *_dll_handle);
3017 }
3018 
3019 inline
3021  const int callback_id)
3022 {
3023  void* exception = NULL;
3024 
3025  _dll_handle->VideoWorker_removeTemplateCreatedCallback(
3026  _impl,
3027  callback_id,
3028  &exception);
3029 
3030  checkException(exception, *_dll_handle);
3031 }
3032 
3033 inline
3035  const int callback_id)
3036 {
3037  void* exception = NULL;
3038 
3039  _dll_handle->VideoWorker_removeMatchFoundCallback(
3040  _impl,
3041  callback_id,
3042  &exception);
3043 
3044  checkException(exception, *_dll_handle);
3045 }
3046 
3047 
3048 inline
3050  const int callback_id)
3051 {
3052  void* exception = NULL;
3053 
3054  _dll_handle->VideoWorker_removeStiPersonOutdatedCallback(
3055  _impl,
3056  callback_id,
3057  &exception);
3058 
3059  checkException(exception, *_dll_handle);
3060 }
3061 
3062 inline
3064  const int callback_id)
3065 {
3066  void* exception = NULL;
3067 
3068  _dll_handle->VideoWorker_removeTrackingLostCallback(
3069  _impl,
3070  callback_id,
3071  &exception);
3072 
3073  checkException(exception, *_dll_handle);
3074 }
3075 
3076 
3077 
3078 #define __0x6ce24ef9_VideoWorker_static_callback_functions_catch_exceptions(name) \
3079  catch(const std::exception &e) \
3080  { \
3081  const std::string error = \
3082  "VideoWorker " name " catch std::excetion: '" + \
3083  std::string( e.what() ) + "'."; \
3084  const VideoWorker &this_vw = *reinterpret_cast<VideoWorker const*>(this_vw__); \
3085  this_vw._dll_handle->VideoWorker_errStreamWriteFunc(err_stream, error.c_str(), error.length()); \
3086  } \
3087  catch(...) \
3088  { \
3089  const std::string error = "VideoWorker " name " catch '...'."; \
3090  const VideoWorker &this_vw = *reinterpret_cast<VideoWorker const*>(this_vw__); \
3091  this_vw._dll_handle->VideoWorker_errStreamWriteFunc(err_stream, error.c_str(), error.length()); \
3092  }
3093 
3094 
3095 // static
3096 inline
3097 void VideoWorker::STrackingCallback(
3098  void* err_stream,
3099  void* this_vw__,
3100  void const* callback_data,
3101 
3102  const int32_t callbacks_count,
3103  void* const* const callbacks_func,
3104  void* const* const callbacks_userdata,
3105  const int32_t u_callbacks_count,
3106  void* const* const u_callbacks_func,
3107  void* const* const u_callbacks_userdata)
3108 {
3109  try
3110  {
3111  const VideoWorker &this_vw = *reinterpret_cast<VideoWorker const*>(this_vw__);
3112 
3113  void* exception = NULL;
3114 
3115  const int64_t stream_id = this_vw._dll_handle->StructStorage_get_int64(
3116  callback_data,
3117  StructStorageFields::video_worker_stream_id_t,
3118  &exception);
3119 
3120  checkException(exception, *this_vw._dll_handle);
3121 
3122  const int64_t frame_id = this_vw._dll_handle->StructStorage_get_int64(
3123  callback_data,
3124  StructStorageFields::video_worker_frame_id_t,
3125  &exception);
3126 
3127  checkException(exception, *this_vw._dll_handle);
3128 
3129  const int64_t samples_count = this_vw._dll_handle->StructStorage_get_int64(
3130  callback_data,
3131  StructStorageFields::video_worker_samples_count_t,
3132  &exception);
3133 
3134  checkException(exception, *this_vw._dll_handle);
3135 
3136  pbio::facerec::RawSampleImpl* const* const samples_impls = static_cast<pbio::facerec::RawSampleImpl* const* const>(
3137  this_vw._dll_handle->StructStorage_get_pointer(
3138  callback_data,
3139  StructStorageFields::video_worker_samples_t,
3140  &exception));
3141 
3142  checkException(exception, *this_vw._dll_handle);
3143 
3144  int32_t const* const weak_samples = static_cast<int32_t const* const>(
3145  this_vw._dll_handle->StructStorage_get_pointer(
3146  callback_data,
3147  pbio::StructStorageFields::video_worker_weak_samples_t,
3148  &exception));
3149 
3150  checkException(exception, *this_vw._dll_handle);
3151 
3152  float const* const samples_quality = static_cast<float const* const>(
3153  this_vw._dll_handle->StructStorage_get_pointer(
3154  callback_data,
3155  StructStorageFields::video_worker_samples_quality_t,
3156  &exception));
3157 
3158  checkException(exception, *this_vw._dll_handle);
3159 
3160  int32_t const* const samples_good_light_and_blur = static_cast<int32_t const* const>(
3161  this_vw._dll_handle->StructStorage_get_pointer(
3162  callback_data,
3163  pbio::StructStorageFields::video_worker_good_light_and_blur_samples_t,
3164  &exception));
3165 
3166  checkException(exception, *this_vw._dll_handle);
3167 
3168  int32_t const* const samples_good_angles = static_cast<int32_t const* const>(
3169  this_vw._dll_handle->StructStorage_get_pointer(
3170  callback_data,
3171  pbio::StructStorageFields::video_worker_good_angles_samples_t,
3172  &exception));
3173 
3174  checkException(exception, *this_vw._dll_handle);
3175 
3176  int32_t const* const samples_good_face_size = static_cast<int32_t const* const>(
3177  this_vw._dll_handle->StructStorage_get_pointer(
3178  callback_data,
3179  pbio::StructStorageFields::video_worker_good_face_size_samples_t,
3180  &exception));
3181 
3182  checkException(exception, *this_vw._dll_handle);
3183 
3184 
3185  int32_t const* const samples_detector_confirmed = static_cast<int32_t const* const>(
3186  this_vw._dll_handle->StructStorage_get_pointer(
3187  callback_data,
3188  pbio::StructStorageFields::video_worker_detector_confirmed_samples_t,
3189  &exception));
3190 
3191  checkException(exception, *this_vw._dll_handle);
3192 
3193  int32_t const* const samples_depth_liveness_confirmed = static_cast<int32_t const* const>(
3194  this_vw._dll_handle->StructStorage_get_pointer(
3195  callback_data,
3196  pbio::StructStorageFields::video_worker_depth_liveness_confirmed_samples_t,
3197  &exception));
3198 
3199  checkException(exception, *this_vw._dll_handle);
3200 
3201  int32_t const* const samples_ir_liveness_confirmed = static_cast<int32_t const* const>(
3202  this_vw._dll_handle->StructStorage_get_pointer(
3203  callback_data,
3204  pbio::StructStorageFields::video_worker_ir_liveness_confirmed_samples_t,
3205  &exception));
3206 
3207  checkException(exception, *this_vw._dll_handle);
3208 
3209 
3210  int32_t const* const samples_track_age_gender_set = static_cast<int32_t const* const>(
3211  this_vw._dll_handle->StructStorage_get_pointer(
3212  callback_data,
3213  pbio::StructStorageFields::video_worker_samples_track_age_gender_set_t,
3214  &exception));
3215  checkException(exception, *this_vw._dll_handle);
3216 
3217  int32_t const* const samples_track_gender = static_cast<int32_t const* const>(
3218  this_vw._dll_handle->StructStorage_get_pointer(
3219  callback_data,
3220  pbio::StructStorageFields::video_worker_samples_track_gender_t,
3221  &exception));
3222  checkException(exception, *this_vw._dll_handle);
3223 
3224  int32_t const* const samples_track_age = static_cast<int32_t const* const>(
3225  this_vw._dll_handle->StructStorage_get_pointer(
3226  callback_data,
3227  pbio::StructStorageFields::video_worker_samples_track_age_t,
3228  &exception));
3229  checkException(exception, *this_vw._dll_handle);
3230 
3231  float const* const samples_track_age_years = static_cast<float const* const>(
3232  this_vw._dll_handle->StructStorage_get_pointer(
3233  callback_data,
3234  pbio::StructStorageFields::video_worker_samples_track_age_years_t,
3235  &exception));
3236  checkException(exception, *this_vw._dll_handle);
3237 
3238  int32_t const* const samples_track_emotions_set = static_cast<int32_t const* const>(
3239  this_vw._dll_handle->StructStorage_get_pointer(
3240  callback_data,
3241  pbio::StructStorageFields::video_worker_samples_track_emotions_set_t,
3242  &exception));
3243  checkException(exception, *this_vw._dll_handle);
3244 
3245  int32_t const* const samples_track_emotions_count = static_cast<int32_t const* const>(
3246  this_vw._dll_handle->StructStorage_get_pointer(
3247  callback_data,
3248  pbio::StructStorageFields::video_worker_samples_track_emotions_count_t,
3249  &exception));
3250  checkException(exception, *this_vw._dll_handle);
3251 
3252  float const* const samples_track_emotions_confidence = static_cast<float const* const>(
3253  this_vw._dll_handle->StructStorage_get_pointer(
3254  callback_data,
3255  pbio::StructStorageFields::video_worker_samples_track_emotions_confidence_t,
3256  &exception));
3257  checkException(exception, *this_vw._dll_handle);
3258 
3259  int32_t const* const samples_track_emotions_emotion = static_cast<int32_t const* const>(
3260  this_vw._dll_handle->StructStorage_get_pointer(
3261  callback_data,
3262  pbio::StructStorageFields::video_worker_samples_track_emotions_emotion_t,
3263  &exception));
3264  checkException(exception, *this_vw._dll_handle);
3265 
3266  int32_t const* const samples_track_active_liveness_type = static_cast<int32_t const* const>(
3267  this_vw._dll_handle->StructStorage_get_pointer(
3268  callback_data,
3269  pbio::StructStorageFields::video_worker_active_liveness_type_samples_t,
3270  &exception));
3271  checkException(exception, *this_vw._dll_handle);
3272 
3273  int32_t const* const samples_track_active_liveness_confirmed = static_cast<int32_t const* const>(
3274  this_vw._dll_handle->StructStorage_get_pointer(
3275  callback_data,
3276  pbio::StructStorageFields::video_worker_active_liveness_confirmed_samples_t,
3277  &exception));
3278  checkException(exception, *this_vw._dll_handle);
3279 
3280  float const* const samples_track_active_liveness_progress = static_cast<float const* const>(
3281  this_vw._dll_handle->StructStorage_get_pointer(
3282  callback_data,
3283  pbio::StructStorageFields::video_worker_active_liveness_score_samples_t,
3284  &exception));
3285  checkException(exception, *this_vw._dll_handle);
3286 
3287 
3288  TrackingCallbackData data;
3289 
3290  data.stream_id = stream_id;
3291  data.frame_id = frame_id;
3292  data.samples.resize(samples_count);
3293  data.samples_track_id.resize(samples_count);
3294  data.samples_weak.resize(samples_count);
3295  data.samples_quality.resize(samples_count);
3296  data.samples_good_light_and_blur.resize(samples_count);
3297  data.samples_good_angles.resize(samples_count);
3298  data.samples_good_face_size.resize(samples_count);
3299  data.samples_detector_confirmed.resize(samples_count);
3300  data.samples_depth_liveness_confirmed.resize(samples_count);
3301  data.samples_ir_liveness_confirmed.resize(samples_count);
3302  data.samples_track_age_gender_set.resize(samples_count);
3303  data.samples_track_age_gender.resize(samples_count);
3304  data.samples_track_emotions_set.resize(samples_count);
3305  data.samples_track_emotions.resize(samples_count);
3306  data.samples_active_liveness_status.resize(samples_count);
3307 
3308  for(int i = 0, emotions_i = 0; i < samples_count; ++i)
3309  {
3310  data.samples[i] = RawSample::Ptr( RawSample::Ptr::make(this_vw._dll_handle, samples_impls[i]) );
3311  data.samples_track_id[i] = data.samples[i]->getID();
3312 
3313  data.samples_weak[i] = weak_samples[i];
3314  data.samples_quality[i] = samples_quality[i];
3315 
3316  data.samples_good_light_and_blur[i] = (SampleCheckStatus::Verdict)samples_good_light_and_blur[i];
3317  data.samples_good_angles[i] = (SampleCheckStatus::Verdict)samples_good_angles[i];
3318  data.samples_good_face_size[i] = (SampleCheckStatus::Verdict)samples_good_face_size[i];
3319  data.samples_detector_confirmed[i] = (SampleCheckStatus::Verdict)samples_detector_confirmed[i];
3320 
3321  data.samples_depth_liveness_confirmed[i] = (DepthLivenessEstimator::Liveness)samples_depth_liveness_confirmed[i];
3322 
3323  data.samples_ir_liveness_confirmed[i] = (IRLivenessEstimator::Liveness)samples_ir_liveness_confirmed[i];
3324 
3325  data.samples_active_liveness_status[i].check_type = (ActiveLiveness::CheckType)samples_track_active_liveness_type[i];
3326  data.samples_active_liveness_status[i].verdict = (ActiveLiveness::Liveness)samples_track_active_liveness_confirmed[i];
3327  data.samples_active_liveness_status[i].progress_level = samples_track_active_liveness_progress[i];
3328 
3329  data.samples_track_age_gender_set[i] = samples_track_age_gender_set[i];
3330 
3331  data.samples_track_age_gender[i].gender = (AgeGenderEstimator::Gender) samples_track_gender[i];
3332  data.samples_track_age_gender[i].age = (AgeGenderEstimator::Age) samples_track_age[i];
3333  data.samples_track_age_gender[i].age_years = samples_track_age_years[i];
3334 
3335  data.samples_track_emotions_set[i] = samples_track_emotions_set[i];
3336 
3337  const int emotions_count = samples_track_emotions_count[i];
3338 
3339  for(int k = 0; k < emotions_count; ++k, ++emotions_i)
3340  {
3342 
3343  ec.emotion = (EmotionsEstimator::Emotion) samples_track_emotions_emotion[emotions_i];
3344  ec.confidence = samples_track_emotions_confidence[emotions_i];
3345 
3346  data.samples_track_emotions[i].push_back(ec);
3347  }
3348  }
3349 
3350 
3351  for(int i = 0; i < u_callbacks_count; ++i)
3352  {
3353  try
3354  {
3355  const TrackingCallbackU u_callback_function_i =
3356  reinterpret_cast<TrackingCallbackU>(u_callbacks_func[i]);
3357 
3358  u_callback_function_i(
3359  data,
3360  u_callbacks_userdata[i]);
3361  }
3362  __0x6ce24ef9_VideoWorker_static_callback_functions_catch_exceptions("TrackingCallbackU")
3363  }
3364 
3365 
3366  for(int i = 0; i < callbacks_count; ++i)
3367  {
3368  try
3369  {
3370  const TrackingCallbackFunc callback_function_i =
3371  reinterpret_cast<TrackingCallbackFunc>(callbacks_func[i]);
3372 
3373  callback_function_i(
3374  data.stream_id,
3375  data.frame_id,
3376  data.samples,
3377  data.samples_weak,
3378  data.samples_quality,
3379  callbacks_userdata[i]);
3380  }
3381  __0x6ce24ef9_VideoWorker_static_callback_functions_catch_exceptions("TrackingCallback")
3382  }
3383  }
3384  __0x6ce24ef9_VideoWorker_static_callback_functions_catch_exceptions("TrackingCallback_")
3385 }
3386 
3387 
3388 
3389 
3390 // static
3391 inline
3392 void VideoWorker::STemplateCreatedCallback(
3393  void* err_stream,
3394  void* this_vw__,
3395  void const* callback_data,
3396 
3397  const int32_t callbacks_count,
3398  void* const* const callbacks_func,
3399  void* const* const callbacks_userdata,
3400  const int32_t u_callbacks_count,
3401  void* const* const u_callbacks_func,
3402  void* const* const u_callbacks_userdata)
3403 {
3404  try
3405  {
3406  const VideoWorker &this_vw = *reinterpret_cast<VideoWorker const*>(this_vw__);
3407 
3408  void* exception = NULL;
3409 
3410  const int64_t stream_id = this_vw._dll_handle->StructStorage_get_int64(
3411  callback_data,
3412  StructStorageFields::video_worker_stream_id_t,
3413  &exception);
3414 
3415  checkException(exception, *this_vw._dll_handle);
3416 
3417  const int64_t frame_id = this_vw._dll_handle->StructStorage_get_int64(
3418  callback_data,
3419  StructStorageFields::video_worker_frame_id_t,
3420  &exception);
3421 
3422  checkException(exception, *this_vw._dll_handle);
3423 
3424  const double quality = this_vw._dll_handle->StructStorage_get_double(
3425  callback_data,
3426  StructStorageFields::video_worker_quality_t,
3427  &exception);
3428 
3429  checkException(exception, *this_vw._dll_handle);
3430 
3431  pbio::facerec::RawSampleImpl* const sample_impl = static_cast<pbio::facerec::RawSampleImpl* const>(
3432  this_vw._dll_handle->StructStorage_get_pointer(
3433  callback_data,
3434  StructStorageFields::video_worker_samples_t,
3435  &exception));
3436 
3437  checkException(exception, *this_vw._dll_handle);
3438 
3439  pbio::facerec::TemplateImpl* const templ_impl = static_cast<pbio::facerec::TemplateImpl* const>(
3440  this_vw._dll_handle->StructStorage_get_pointer(
3441  callback_data,
3442  StructStorageFields::video_worker_templ_t,
3443  &exception));
3444 
3445  checkException(exception, *this_vw._dll_handle);
3446 
3447  const RawSample::Ptr sample( RawSample::Ptr::make(this_vw._dll_handle, sample_impl));
3448 
3449  const Template::Ptr templ( Template::Ptr::make(this_vw._dll_handle, templ_impl));
3450 
3451  TemplateCreatedCallbackData data;
3452 
3453  data.stream_id = stream_id;
3454  data.frame_id = frame_id;
3455  data.quality = quality;
3456  data.sample = sample;
3457  data.templ = templ;
3458 
3459 
3460 
3461 
3462  for(int i = 0; i < u_callbacks_count; ++i)
3463  {
3464  try
3465  {
3466  const TemplateCreatedCallbackU u_callback_function_i =
3467  reinterpret_cast<TemplateCreatedCallbackU>(u_callbacks_func[i]);
3468 
3469  u_callback_function_i(
3470  data,
3471  u_callbacks_userdata[i]);
3472  }
3473  __0x6ce24ef9_VideoWorker_static_callback_functions_catch_exceptions("TemplateCreatedCallbackU")
3474  }
3475 
3476 
3477 
3478  for(int i = 0; i < callbacks_count; ++i)
3479  {
3480  try
3481  {
3482  const TemplateCreatedCallbackFunc callback_function_i =
3483  reinterpret_cast<TemplateCreatedCallbackFunc>(callbacks_func[i]);
3484 
3485  callback_function_i(
3486  data.stream_id,
3487  data.frame_id,
3488  data.sample,
3489  data.quality,
3490  data.templ,
3491  callbacks_userdata[i]);
3492  }
3493  __0x6ce24ef9_VideoWorker_static_callback_functions_catch_exceptions("TemplateCreatedCallback")
3494  }
3495 
3496 
3497  }
3498  __0x6ce24ef9_VideoWorker_static_callback_functions_catch_exceptions("TemplateCreatedCallback_")
3499 }
3500 
3501 
3502 
3503 
3504 
3505 // static
3506 inline
3507 void VideoWorker::SMatchFoundCallback(
3508  void* err_stream,
3509  void* this_vw__,
3510  void const* callback_data,
3511 
3512  const int32_t callbacks_count,
3513  void* const* const callbacks_func,
3514  void* const* const callbacks_userdata,
3515  const int32_t ext_callbacks_count,
3516  void* const* const ext_callbacks_func,
3517  void* const* const ext_callbacks_userdata,
3518  const int32_t u_callbacks_count,
3519  void* const* const u_callbacks_func,
3520  void* const* const u_callbacks_userdata)
3521 {
3522  try
3523  {
3524  const VideoWorker &this_vw = *reinterpret_cast<VideoWorker const*>(this_vw__);
3525 
3526  void* exception = NULL;
3527 
3528  const int64_t stream_id = this_vw._dll_handle->StructStorage_get_int64(
3529  callback_data,
3530  StructStorageFields::video_worker_stream_id_t,
3531  &exception);
3532 
3533  checkException(exception, *this_vw._dll_handle);
3534 
3535  const int64_t frame_id = this_vw._dll_handle->StructStorage_get_int64(
3536  callback_data,
3537  StructStorageFields::video_worker_frame_id_t,
3538  &exception);
3539 
3540  checkException(exception, *this_vw._dll_handle);
3541 
3542  const double quality = this_vw._dll_handle->StructStorage_get_double(
3543  callback_data,
3544  StructStorageFields::video_worker_quality_t,
3545  &exception);
3546 
3547  checkException(exception, *this_vw._dll_handle);
3548 
3549  pbio::facerec::RawSampleImpl* const sample_impl = static_cast<pbio::facerec::RawSampleImpl* const>(
3550  this_vw._dll_handle->StructStorage_get_pointer(
3551  callback_data,
3552  StructStorageFields::video_worker_samples_t,
3553  &exception));
3554 
3555  checkException(exception, *this_vw._dll_handle);
3556 
3557  pbio::facerec::TemplateImpl* const templ_impl = static_cast<pbio::facerec::TemplateImpl* const>(
3558  this_vw._dll_handle->StructStorage_get_pointer(
3559  callback_data,
3560  StructStorageFields::video_worker_templ_t,
3561  &exception));
3562 
3563  checkException(exception, *this_vw._dll_handle);
3564 
3565  const int64_t search_result_size = this_vw._dll_handle->StructStorage_get_int64(
3566  callback_data,
3567  StructStorageFields::video_worker_search_result_size_t,
3568  &exception);
3569 
3570  checkException(exception, *this_vw._dll_handle);
3571 
3572  uint64_t const* const search_result_person_ids = static_cast<uint64_t const* const>(
3573  this_vw._dll_handle->StructStorage_get_pointer(
3574  callback_data,
3575  StructStorageFields::video_worker_search_result_person_ids_t,
3576  &exception));
3577 
3578  checkException(exception, *this_vw._dll_handle);
3579 
3580  uint64_t const* const search_result_element_ids = static_cast<uint64_t const* const>(
3581  this_vw._dll_handle->StructStorage_get_pointer(
3582  callback_data,
3583  StructStorageFields::video_worker_search_result_element_ids_t,
3584  &exception));
3585 
3586  checkException(exception, *this_vw._dll_handle);
3587 
3588  float const* const search_result_match_result_distances = static_cast<float const* const>(
3589  this_vw._dll_handle->StructStorage_get_pointer(
3590  callback_data,
3591  StructStorageFields::video_worker_search_result_match_result_distance_t,
3592  &exception));
3593 
3594  checkException(exception, *this_vw._dll_handle);
3595 
3596  float const* const search_result_match_result_far_s = static_cast<float const* const>(
3597  this_vw._dll_handle->StructStorage_get_pointer(
3598  callback_data,
3599  StructStorageFields::video_worker_search_result_match_result_fa_r_t,
3600  &exception));
3601 
3602  checkException(exception, *this_vw._dll_handle);
3603 
3604  float const* const search_result_match_result_frr_s = static_cast<float const* const>(
3605  this_vw._dll_handle->StructStorage_get_pointer(
3606  callback_data,
3607  StructStorageFields::video_worker_search_result_match_result_fr_r_t,
3608  &exception));
3609 
3610  checkException(exception, *this_vw._dll_handle);
3611 
3612  float const* const search_result_match_result_scores = static_cast<float const* const>(
3613  this_vw._dll_handle->StructStorage_get_pointer(
3614  callback_data,
3615  StructStorageFields::video_worker_search_result_match_result_score_t,
3616  &exception));
3617 
3618  checkException(exception, *this_vw._dll_handle);
3619 
3620 
3621  const RawSample::Ptr sample( RawSample::Ptr::make(this_vw._dll_handle, sample_impl));
3622 
3623  const Template::Ptr templ( Template::Ptr::make(this_vw._dll_handle, templ_impl));
3624 
3625  std::vector<SearchResult> search_results(search_result_size);
3626 
3627  for(int i = 0; i < search_result_size; ++i)
3628  {
3629  search_results[i].person_id = search_result_person_ids[i];
3630  search_results[i].element_id = search_result_element_ids[i];
3631  search_results[i].match_result.distance = search_result_match_result_distances[i];
3632  search_results[i].match_result.fa_r = search_result_match_result_far_s[i];
3633  search_results[i].match_result.fr_r = search_result_match_result_frr_s[i];
3634  search_results[i].match_result.score = search_result_match_result_scores[i];
3635  }
3636 
3637  MatchFoundCallbackData data;
3638  data.stream_id = stream_id;
3639  data.frame_id = frame_id;
3640  data.quality = quality;
3641  data.sample = sample;
3642  data.templ = templ;
3643  data.search_results = search_results;
3644 
3645 
3646 
3647 
3648 
3649  for(int i = 0; i < u_callbacks_count; ++i)
3650  {
3651  try
3652  {
3653  const MatchFoundCallbackU u_callback_function_i =
3654  reinterpret_cast<MatchFoundCallbackU>(u_callbacks_func[i]);
3655 
3656  u_callback_function_i(
3657  data,
3658  u_callbacks_userdata[i]);
3659  }
3660  __0x6ce24ef9_VideoWorker_static_callback_functions_catch_exceptions("MatchFoundCallbackU")
3661  }
3662 
3663 
3664  for(int i = 0; i < ext_callbacks_count; ++i)
3665  {
3666  try
3667  {
3668  const MatchFoundCallbackFuncExt ext_callback_function_i =
3669  reinterpret_cast<MatchFoundCallbackFuncExt>(ext_callbacks_func[i]);
3670 
3671  ext_callback_function_i(
3672  data.stream_id,
3673  data.frame_id,
3674  data.sample,
3675  data.quality,
3676  data.templ,
3677  data.search_results,
3678  ext_callbacks_userdata[i]);
3679  }
3680  __0x6ce24ef9_VideoWorker_static_callback_functions_catch_exceptions("MatchFoundCallbackExt")
3681  }
3682 
3683 
3684  for(int i = 0; i < callbacks_count; ++i)
3685  {
3686  try
3687  {
3688  const MatchFoundCallbackFunc callback_function_i =
3689  reinterpret_cast<MatchFoundCallbackFunc>(callbacks_func[i]);
3690 
3691  callback_function_i(
3692  data.stream_id,
3693  data.frame_id,
3694  data.search_results[0].person_id,
3695  data.search_results[0].element_id,
3696  data.sample,
3697  data.quality,
3698  data.templ,
3699  data.search_results[0].match_result,
3700  callbacks_userdata[i]);
3701  }
3702  __0x6ce24ef9_VideoWorker_static_callback_functions_catch_exceptions("MatchFoundCallback")
3703  }
3704 
3705  }
3706  __0x6ce24ef9_VideoWorker_static_callback_functions_catch_exceptions("MatchFoundCallback_")
3707 }
3708 
3709 
3710 // static
3711 inline
3712 void VideoWorker::SStiPersonOutdatedCallback(
3713  void* err_stream,
3714  void* this_vw__,
3715  void const* callback_data,
3716 
3717  const int32_t callbacks_count,
3718  void* const* const callbacks_func,
3719  void* const* const callbacks_userdata)
3720 {
3721  try
3722  {
3723  const VideoWorker &this_vw = *reinterpret_cast<VideoWorker const*>(this_vw__);
3724 
3725  void* exception = NULL;
3726 
3727  const int64_t stream_id = this_vw._dll_handle->StructStorage_get_int64(
3728  callback_data,
3729  StructStorageFields::video_worker_stream_id_t,
3730  &exception);
3731 
3732  checkException(exception, *this_vw._dll_handle);
3733 
3734  const int64_t sti_person_id = this_vw._dll_handle->StructStorage_get_int64(
3735  callback_data,
3736  StructStorageFields::video_worker_sti_person_id_t,
3737  &exception);
3738 
3739  checkException(exception, *this_vw._dll_handle);
3740 
3741 
3742  StiPersonOutdatedCallbackData data;
3743  data.stream_id = stream_id;
3744  data.sti_person_id = sti_person_id;
3745 
3746  for(int i = 0; i < callbacks_count; ++i)
3747  {
3748  try
3749  {
3750  const StiPersonOutdatedCallbackU callback_function_i =
3751  reinterpret_cast<StiPersonOutdatedCallbackU>(callbacks_func[i]);
3752 
3753  callback_function_i(
3754  data,
3755  callbacks_userdata[i]);
3756  }
3757  __0x6ce24ef9_VideoWorker_static_callback_functions_catch_exceptions("StiPersonOutdated")
3758  }
3759  }
3760  __0x6ce24ef9_VideoWorker_static_callback_functions_catch_exceptions("StiPersonOutdated")
3761 }
3762 
3763 // static
3764 inline
3765 void VideoWorker::STrackingLostCallback(
3766  void* err_stream,
3767  void* this_vw__,
3768  void const* callback_data,
3769 
3770  const int32_t callbacks_count,
3771  void* const* const callbacks_func,
3772  void* const* const callbacks_userdata,
3773  const int32_t u_callbacks_count,
3774  void* const* const u_callbacks_func,
3775  void* const* const u_callbacks_userdata)
3776 {
3777  try
3778  {
3779  const VideoWorker &this_vw = *reinterpret_cast<VideoWorker const*>(this_vw__);
3780 
3781  void* exception = NULL;
3782 
3783  const int64_t stream_id = this_vw._dll_handle->StructStorage_get_int64(
3784  callback_data,
3785  StructStorageFields::video_worker_stream_id_t,
3786  &exception);
3787 
3788  checkException(exception, *this_vw._dll_handle);
3789 
3790  const int64_t first_frame_id = this_vw._dll_handle->StructStorage_get_int64(
3791  callback_data,
3792  StructStorageFields::video_worker_first_frame_id_t,
3793  &exception);
3794 
3795  checkException(exception, *this_vw._dll_handle);
3796 
3797  const int64_t last_frame_id = this_vw._dll_handle->StructStorage_get_int64(
3798  callback_data,
3799  StructStorageFields::video_worker_last_frame_id_t,
3800  &exception);
3801 
3802  checkException(exception, *this_vw._dll_handle);
3803 
3804  const double best_quality = this_vw._dll_handle->StructStorage_get_double(
3805  callback_data,
3806  StructStorageFields::video_worker_best_quality_t,
3807  &exception);
3808 
3809  checkException(exception, *this_vw._dll_handle);
3810 
3811  const int64_t best_quality_frame_id = this_vw._dll_handle->StructStorage_get_int64(
3812  callback_data,
3813  StructStorageFields::video_worker_best_qaulity_frame_id_t,
3814  &exception);
3815 
3816  checkException(exception, *this_vw._dll_handle);
3817 
3818  pbio::facerec::RawSampleImpl* const best_quality_sample_impl = static_cast<pbio::facerec::RawSampleImpl* const>(
3819  this_vw._dll_handle->StructStorage_get_pointer(
3820  callback_data,
3821  StructStorageFields::video_worker_samples_t,
3822  &exception));
3823 
3824  checkException(exception, *this_vw._dll_handle);
3825 
3826  const RawSample::Ptr sample =
3827  best_quality_sample_impl ?
3828  RawSample::Ptr::make(this_vw._dll_handle, best_quality_sample_impl) :
3829  RawSample::Ptr();
3830 
3831 
3832  pbio::facerec::TemplateImpl* const best_quality_template_impl = static_cast<pbio::facerec::TemplateImpl* const>(
3833  this_vw._dll_handle->StructStorage_get_pointer(
3834  callback_data,
3835  StructStorageFields::video_worker_templ_t,
3836  &exception));
3837 
3838  checkException(exception, *this_vw._dll_handle);
3839 
3840  const Template::Ptr templ =
3841  best_quality_template_impl ?
3842  Template::Ptr( Template::Ptr::make(this_vw._dll_handle, best_quality_template_impl)) :
3843  Template::Ptr();
3844 
3845 
3846  const int64_t track_id = this_vw._dll_handle->StructStorage_get_int64(
3847  callback_data,
3848  StructStorageFields::video_worker_track_id_t,
3849  &exception);
3850 
3851  checkException(exception, *this_vw._dll_handle);
3852 
3853 
3854  const int64_t sti_person_id = this_vw._dll_handle->StructStorage_get_int64(
3855  callback_data,
3856  StructStorageFields::video_worker_sti_person_id_t,
3857  &exception);
3858 
3859  checkException(exception, *this_vw._dll_handle);
3860 
3861 
3862  const bool sti_person_id_set = this_vw._dll_handle->StructStorage_get_int64(
3863  callback_data,
3864  StructStorageFields::video_worker_sti_person_id_set_t,
3865  &exception);
3866 
3867  checkException(exception, *this_vw._dll_handle);
3868 
3869 
3870 
3871  TrackingLostCallbackData data;
3872  data.stream_id = stream_id;
3873  data.first_frame_id = first_frame_id;
3874  data.last_frame_id = last_frame_id;
3875  data.best_quality = best_quality;
3876  data.best_quality_frame_id = best_quality_frame_id;
3877  data.best_quality_sample = sample;
3878  data.best_quality_templ = templ;
3879  data.track_id = track_id;
3880  data.sti_person_id = sti_person_id;
3881  data.sti_person_id_set = sti_person_id_set;
3882 
3883 
3884 
3885 
3886 
3887  for(int i = 0; i < u_callbacks_count; ++i)
3888  {
3889  try
3890  {
3891  const TrackingLostCallbackU u_callback_function_i =
3892  reinterpret_cast<TrackingLostCallbackU>(u_callbacks_func[i]);
3893 
3894  u_callback_function_i(
3895  data,
3896  u_callbacks_userdata[i]);
3897  }
3898  __0x6ce24ef9_VideoWorker_static_callback_functions_catch_exceptions("TrackingLostCallbackU")
3899  }
3900 
3901 
3902  for(int i = 0; i < callbacks_count; ++i)
3903  {
3904  try
3905  {
3906  const TrackingLostCallbackFunc callback_function_i =
3907  reinterpret_cast<TrackingLostCallbackFunc>(callbacks_func[i]);
3908 
3909  callback_function_i(
3910  data.stream_id,
3911  data.first_frame_id,
3912  data.last_frame_id,
3913  data.best_quality,
3914  data.best_quality_frame_id,
3915  data.best_quality_sample,
3916  data.best_quality_templ,
3917  callbacks_userdata[i]);
3918  }
3919  __0x6ce24ef9_VideoWorker_static_callback_functions_catch_exceptions("TrackingLostCallback")
3920  }
3921 
3922  }
3923  __0x6ce24ef9_VideoWorker_static_callback_functions_catch_exceptions("TrackingLostCallback_")
3924 }
3925 
3926 
3927 inline
3928 void VideoWorker::toggleSomething(
3929  const int stream_id,
3930  const int something)
3931 {
3932  void* exception = NULL;
3933 
3934  _dll_handle->VideoWorker_toggleSomething(
3935  _impl,
3936  stream_id,
3937  something,
3938  &exception);
3939 
3940  checkException(exception, *_dll_handle);
3941 }
3942 
3943 
3944 inline
3946 {
3947  toggleSomething(stream_id, pbio::facerec::capi::VideoWorker_something_Processing_Disable);
3948 }
3949 
3950 
3951 inline
3952 void VideoWorker::enableProcessingOnStream(const int stream_id)
3953 {
3954  toggleSomething(stream_id, pbio::facerec::capi::VideoWorker_something_Processing_Enable);
3955 }
3956 
3957 
3958 inline
3960 {
3961  toggleSomething(stream_id, pbio::facerec::capi::VideoWorker_something_AgeGender_Disable);
3962 }
3963 
3964 inline
3966 {
3967  toggleSomething(stream_id, pbio::facerec::capi::VideoWorker_something_AgeGender_Enable);
3968 }
3969 
3970 inline
3972 {
3973  toggleSomething(stream_id, pbio::facerec::capi::VideoWorker_something_Emotions_Disable);
3974 }
3975 
3976 inline
3978 {
3979  toggleSomething(stream_id, pbio::facerec::capi::VideoWorker_something_Emotions_Enable);
3980 }
3981 
3982 
3983 
3984 
3985 inline
3987 : _video_worker_config(std::string())
3988 , _recognizer_ini_file()
3989 , _recognizer_config(std::string())
3990 , _streams_count(0)
3991 , _processing_threads_count(0)
3992 , _matching_threads_count(0)
3993 , _age_gender_estimation_threads_count(0)
3994 , _emotions_estimation_threads_count(0)
3995 , _short_time_identification_enabled(false)
3996 , _short_time_identification_distance_threshold(0)
3997 , _short_time_identification_outdate_time_seconds(0)
3998 , _active_liveness_checks_order()
3999 {
4000  // nothing else
4001 }
4002 
4003 
4004 inline
4005 void VideoWorker::setParameter(
4006  const std::string parameter,
4007  const double value)
4008 {
4009  void* exception = NULL;
4010 
4011  _dll_handle->VideoWorker_setParameter(
4012  _impl,
4013  parameter.c_str(),
4014  value,
4015  &exception);
4016 
4017  checkException(exception, *_dll_handle);
4018 }
4019 
4020 
4021 } // pbio namespace
4022 
4023 
4024 #endif // __PBIO_API__PBIO__VIDEOWORKER_H_
int64_t frame_id
Definition: VideoWorker.h:679
float depth_map_2_image_scale_x
Параметр соответствия координат исходного изображения и карты глубины.
Definition: DepthMapRaw.h:56
void removeStiPersonOutdatedCallback(const int callback_id)
Удалить обработчик события StiPersonOutdated. Потокобезопасный.
Definition: VideoWorker.h:3049
int64_t sti_person_id
Идентификатор "sti_person" - набора треков, объединенных кратковременной идентификацией. Значение sti_person_id совпадает с track_id первого элемента, сформировавшего этот набор "sti_person".
Definition: VideoWorker.h:1279
int resetStream(const int stream_id)
Сбросить состояние работы для указанного видеопотока. В процессе происходит ожидание выполняющихся в ...
Definition: VideoWorker.h:2791
Liveness
Результат определения принадлежности лица живому человеку.
Definition: IRLivenessEstimator.h:50
int64_t last_frame_id
Целочисленный идентификатор кадра, после которого трекинг лица был потерян.
Definition: VideoWorker.h:1197
std::vector< SampleCheckStatus::Verdict > samples_good_angles
Результат проверки сэмпла на отсутствие слишком больших углов поворота лица (samples_good_angles.size() == samples.size())
Definition: VideoWorker.h:394
Структура, предоставляющая данные изображения в "сыром" формате и опциональную информацию для обрезки...
Definition: RawImage.h:28
void(* TrackingLostCallbackU)(const TrackingLostCallbackData &data, void *const userdata)
Тип функции коллбэка потери трекинга лица (TrackingLost) (например, когда человек вышел из кадра)...
Definition: VideoWorker.h:1326
Результат поиска шаблона (для VideoWorker::MatchFoundCallbackFuncU).
Definition: VideoWorker.h:177
void(* TemplateCreatedCallbackU)(const TemplateCreatedCallbackData &data, void *const userdata)
Тип функции коллбэка создания шаблона (TemplateCreated).
Definition: VideoWorker.h:751
double quality
Качество сэмпла. Точно такое же, как и у FaceQualityEstimator.
Definition: VideoWorker.h:949
Liveness
Состояние проверки активной (сценарной) оценки принадлежности лица живому человеку.
Definition: ActiveLiveness.h:47
float depth_unit_in_millimeters
Масштаб значений, содержащихся в depth_data.
Definition: DepthMapRaw.h:84
void enableProcessingOnStream(const int stream_id)
Включить генерацию шаблонов для данного потока. Соответственно, сравнения также возобновятся. Потокобезопасный.
Definition: VideoWorker.h:3952
std::vector< float > samples_quality
Качество сэмпла. Точно такое же, как и у FaceQualityEstimator (samples_quality.size() == samples...
Definition: VideoWorker.h:370
int depth_data_stride_in_bytes
Шаг в байтах.
Definition: DepthMapRaw.h:98
float horizontal_fov
Горизонтальный угол обзора карты глубины в градусах.
Definition: DepthMapRaw.h:70
int depth_map_cols
Ширина карты глубины.
Definition: DepthMapRaw.h:35
Template::Ptr templ
Definition: VideoWorker.h:711
int addMatchFoundCallback(const MatchFoundCallbackFunc callback, void *const userdata)
Добавить обработчик события распознавания (MatchFound). Потокобезопасный.
Definition: VideoWorker.h:2894
Recognizer - Интерфейсный объект для создания и сравнения шаблонов.
Params & short_time_identification_enabled(const bool value)
Задать флаг, включающий кратковременную идентификацию.
Definition: VideoWorker.h:149
void addIRFrame(const IRFrameRaw &ir_frame, const int stream_id, const uint64_t timestamp_microsec)
Подать кадр определенного видеопотока c инфракрасными данными. Потокобезопасный.
Definition: VideoWorker.h:2750
int64_t first_frame_id
Целочисленный идентификатор кадра, на котором лицо было замечено впервые.
Definition: VideoWorker.h:1187
int64_t stream_id
Definition: VideoWorker.h:667
float depth_map_2_image_offset_y
Параметр соответствия координат исходного изображения и карты глубины.
Definition: DepthMapRaw.h:49
uint64_t element_id
Уникальный идентификатор элемента.
Definition: VideoWorker.h:1443
int addTrackingCallback(const TrackingCallbackFunc callback, void *const userdata)
Добавить обработчик события трекинга (Tracking). Потокобезопасный.
Definition: VideoWorker.h:2819
int addMatchFoundCallbackExt(const MatchFoundCallbackFuncExt callback, void *const userdata)
Добавить обработчик события распознавания (MatchFound). Потокобезопасный.
Definition: VideoWorker.h:2913
Инфракрасное изображение, отрегистрированное в соответствии с исходным цветным изображением. Соответствие между координатами исходного изображения и инфракрасного изображения:     пусть (x; y) - точка на инфракрасном изображении, тогда соответствующая точка на исходном изображении - это:     (ir_frame_2_image_offset_x + ir_frame_2_image_scale_x * x; ir_frame_2_image_offset_y + ir_frame_2_image_scale_y * y).
Definition: IRFrameRaw.h:21
int addTrackingLostCallback(const TrackingLostCallbackFunc callback, void *const userdata)
Добавить обработчик события потери трекинга лица (TrackingLost). Потокобезопасный.
Definition: VideoWorker.h:2950
void disableEmotionsEstimationOnStream(const int stream_id)
Отключить определение эмоций для данного потока. Потокобезопасный.
Definition: VideoWorker.h:3971
LightSmartPtr< VideoWorker >::tPtr Ptr
Псевдоним для типа умного указателя на VideoWorker.
Definition: VideoWorker.h:72
Эвристически ускоренный линейный поиск. Эвристика уменьшает TAR (true acceptance rate) на тесте 1:N н...
Definition: Recognizer.h:143
std::vector< int > samples_track_id
Вектор идентификаторов лиц (track_id). track_id равен sample.getID() для сэмпла в любом VideoWorker к...
Definition: VideoWorker.h:334
void checkExceptions()
Исключения, выброшенные в коллбэках и внутренних потоках, будут выброшены повторно при вызове данного...
Definition: VideoWorker.h:2807
void(* TrackingCallbackFuncU)(const TrackingCallbackData &data, void *const userdata)
Тип функции коллбэка трекинга (Tracking).
Definition: VideoWorker.h:583
int64_t stream_id
Целочисленный идентификатор видеопотока (0 <= stream_id < streams_count).
Definition: VideoWorker.h:1177
std::vector< SampleCheckStatus::Verdict > samples_detector_confirmed
Результат проверки сэмпла фронтальным детектором лиц (samples_detector_confirmed.size() == samples...
Definition: VideoWorker.h:420
std::vector< IRLivenessEstimator::Liveness > samples_ir_liveness_confirmed
Результат проверки сэмпла посредством IRLivenessEstimator, требуются инфракрасные кадры...
Definition: VideoWorker.h:452
RawSample::Ptr sample
Definition: VideoWorker.h:689
Параметры конструктора VideoWorker.
Definition: VideoWorker.h:89
LightSmartPtr< Template >::tPtr Ptr
Псевдоним для типа умного указателя на Template.
Definition: Template.h:46
std::vector< RawSample::Ptr > samples
Вектор лиц, найденных трекером. Большинство сэмплов будут получены с кадра frame_id, но некоторые могут быть получены с предыдущих кадров. Используйте метод RawSample::getFrameID, чтобы определить, к какому кадру относится сэмпл.
Definition: VideoWorker.h:320
bool sti_person_id_set
Флаг, обозначающий что sti_person_id определен. Значение sti_person_id не определено, если кратковременная идентификация отключена, либо если для данного трека не было сгенерировано ни одного шаблона.
Definition: VideoWorker.h:1267
int addTrackingCallbackU(const TrackingCallbackU callback, void *const userdata)
Добавить обработчик события трекинга (Tracking). Потокобезопасный.
Definition: VideoWorker.h:2837
DepthLivenessEstimator - Интерфейсный объект для определения принадлежности лица реальному человеку...
Age
Возрастные группы.
Definition: AgeGenderEstimator.h:62
Verdict
Definition: SampleCheckStatus.h:17
std::vector< ActiveLiveness::ActiveLivenessStatus > samples_active_liveness_status
Состояние проверки лица на принадлежность живому человеку посредством сценария. См. также ActiveLiveness::ActiveLivenessStatus. (samples_active_liveness_status.size() == samples.size())
Definition: VideoWorker.h:516
EmotionsEstimator - интерфейсный объект для определения эмоций.
void enableEmotionsEstimationOnStream(const int stream_id)
Включить определение эмоций для данного потока. Потокобезопасный.
Definition: VideoWorker.h:3977
Класс для переопределения параметров конфигурации во время выполнения.
Definition: Config.h:19
Данные TrackingLost коллбэка.
Definition: VideoWorker.h:1165
void(* MatchFoundCallbackFunc)(const int stream_id, const int frame_id, const uint64_t person_id, const uint64_t element_id, const RawSample::Ptr &sample, const float quality, const Template::Ptr &templ, const Recognizer::MatchResult match_result, void *const userdata)
Тип функции коллбэка распознавания (MatchFound).
Definition: VideoWorker.h:844
float ir_vertical_fov
Вертикальный угол обзора инфракрасного изображения в градусах.
Definition: IRFrameRaw.h:77
LightSmartPtr< RawSample >::tPtr Ptr
Псевдоним для типа умного указателя на RawSample.
Definition: RawSample.h:58
uint16_t const * ir_frame_data
Указатель на данные ИК кадра.
Definition: IRFrameRaw.h:84
int depth_map_rows
Высота карты глубины.
Definition: DepthMapRaw.h:28
int getTrackingConveyorSize(const int stream_id) const
Получить размер N конвейера трекинга. Tracking коллбэк будет вызван с frame_id = X не раньше...
Definition: VideoWorker.h:2640
void(* MatchFoundCallbackFuncU)(const MatchFoundCallbackData &data, void *const userdata)
Тип функции коллбэка распознавания (MatchFound).
Definition: VideoWorker.h:1077
int64_t stream_id
Целочисленный идентификатор видеопотока (0 <= stream_id < streams_count).
Definition: VideoWorker.h:286
float ir_frame_2_image_offset_x
Параметр соответствия координат исходного изображения и инфракрасного.
Definition: IRFrameRaw.h:42
void(* TrackingCallbackU)(const TrackingCallbackData &data, void *const userdata)
Тип функции коллбэка трекинга (Tracking). Этот коллбэк вызывается каждый раз, когда кадр был обработа...
Definition: VideoWorker.h:564
void resetTrackerOnStream(const int stream_id)
Сбросить состояние трекера для указанного видеопотока. Потокобезопасный.
Definition: VideoWorker.h:2777
Error - класс исключений, выбрасываемых при возникновении ошибок.
Template - Интерфейсный объект для сохранения шаблона лица.
int64_t stream_id
Целочисленный идентификатор видеопотока (0 <= stream_id < streams_count).
Definition: VideoWorker.h:1373
VideoWorker - интерфейсный объект для трекинга, обработки и распознавания лиц на нескольких видеопото...
Definition: VideoWorker.h:63
RawSample - Интерфейсный объект, хранящий образец лица.
AgeGenderEstimator - интерфейсный объект для определения пола и возраста
Template::Ptr best_quality_templ
Шаблон, созданный из best_quality_sample. Будет равен NULL при нулевом количестве потоков обработки и...
Definition: VideoWorker.h:1243
SearchAccelerationType
Типы ускорения поиска.
Definition: Recognizer.h:119
Результат сравнения шаблонов.
Definition: Recognizer.h:53
Данные MatchFound коллбэка.
Definition: VideoWorker.h:903
Эмоция с коэффициентом уверенности.
Definition: EmotionsEstimator.h:114
void removeTrackingLostCallback(const int callback_id)
Удалить обработчик события потери трекинга лица (TrackingLost). Потокобезопасный. ...
Definition: VideoWorker.h:3063
std::vector< EmotionsEstimator::EstimatedEmotionsVector > samples_track_emotions
Оценка эмоций для этого трека. (samples_track_emotions.size() == samples.size())
Definition: VideoWorker.h:500
float ir_horizontal_fov
Горизонтальный угол обзора инфракрасного изображения в градусах.
Definition: IRFrameRaw.h:70
void disableAgeGenderEstimationOnStream(const int stream_id)
Отключить определение пола и возраста для данного потока. Потокобезопасный.
Definition: VideoWorker.h:3959
RawSample::Ptr sample
Сэмпл лица.
Definition: VideoWorker.h:937
int64_t frame_id
Целочисленный идентификатор кадра (который был возвращен методом VideoWorker::addVideoFrame).
Definition: VideoWorker.h:927
uint64_t person_id
Уникальный идентификатор человека.
Definition: VideoWorker.h:186
Params & recognizer_ini_file(const std::string value)
Задать имя конфигурационного файла для используемого распознавателя (Recognizer). ...
Definition: VideoWorker.h:107
Params & matching_threads_count(const int value)
Задать количество потоков для сравнения шаблонов, созданных из видеопотоков, с базой.
Definition: VideoWorker.h:131
float ir_frame_2_image_scale_y
Параметр соответствия координат исходного изображения и инфракрасного.
Definition: IRFrameRaw.h:63
Recognizer::MatchResult match_result
Результат сравнения шаблонов.
Definition: VideoWorker.h:202
int addStiPersonOutdatedCallbackU(const StiPersonOutdatedCallbackU callback, void *const userdata)
Добавить обработчик события StiPersonOutdated. Потокобезопасный.
Definition: VideoWorker.h:2986
static const uint64_t MATCH_NOT_FOUND_ID
Специальное значение для параметров person_id и element_id в MatchFoundCallback.
Definition: VideoWorker.h:81
Params & processing_threads_count(const int value)
Задать количество потоков для создания шаблонов.
Definition: VideoWorker.h:125
std::vector< DepthLivenessEstimator::Liveness > samples_depth_liveness_confirmed
Результат проверки сэмпла посредством DepthLivenessEstimator, требуются кадры глубины, см. VideoWorker::addDepthFrame. См. также DepthLivenessEstimator::Liveness. (samples_depth_liveness_confirmed.size() == samples.size())
Definition: VideoWorker.h:436
std::vector< bool > samples_track_age_gender_set
Флаг, обозначающий что пол и возраст определены для этого трека. (samples_track_age_gender_set.size() == samples.size())
Definition: VideoWorker.h:464
void(* TemplateCreatedCallbackFunc)(const int stream_id, const int frame_id, const RawSample::Ptr &sample, const float quality, const Template::Ptr &templ, void *const userdata)
Тип функции коллбэка создания шаблона (TemplateCreated).
Definition: VideoWorker.h:639
int addTrackingLostCallbackU(const TrackingLostCallbackU callback, void *const userdata)
Добавить обработчик события потери трекинга лица (TrackingLost). Потокобезопасный.
Definition: VideoWorker.h:2968
int addMatchFoundCallbackU(const MatchFoundCallbackU callback, void *const userdata)
Добавить обработчик события распознавания (MatchFound). Потокобезопасный.
Definition: VideoWorker.h:2931
void setDatabase(const std::vector< DatabaseElement > &elements, const Recognizer::SearchAccelerationType acceleration=Recognizer::SEARCH_ACCELERATION_1)
Задать / заменить базу (можно вызывать в любое время). Доступно только при ненулевом количестве поток...
Definition: VideoWorker.h:2656
RawSample::Ptr best_quality_sample
Лучший сэмпл лица с кадра best_quality_frame_id. Будет равен NULL, если включен флаг "weak_tracks_in_...
Definition: VideoWorker.h:1231
int addTemplateCreatedCallbackU(const TemplateCreatedCallbackU callback, void *const userdata)
Добавить обработчик события создания шаблона (TemplateCreated). Потокобезопасный. ...
Definition: VideoWorker.h:2875
std::vector< SampleCheckStatus::Verdict > samples_good_light_and_blur
Результат проверки сэмпла на хорошие условия освещения и отсутствие сильного размытия (samples_good_l...
Definition: VideoWorker.h:382
uint64_t element_id
Уникальный идентификатор элемента.
Definition: VideoWorker.h:195
std::vector< AgeGenderEstimator::AgeGender > samples_track_age_gender
Оценки пола и возраста для этого трека. (samples_track_age_gender.size() == samples.size())
Definition: VideoWorker.h:476
float confidence
Положительное вещественное число из диапазона [0; 1].
Definition: EmotionsEstimator.h:128
Emotion emotion
Эмоция.
Definition: EmotionsEstimator.h:121
void(* MatchFoundCallbackFuncExt)(const int stream_id, const int frame_id, const RawSample::Ptr &sample, const float quality, const Template::Ptr &templ, const std::vector< SearchResult > &search_result, void *const userdata)
Тип функции коллбэка распознавания (MatchFound).
Definition: VideoWorker.h:886
Карта глубины, отрегистрированная в соответствии с исходным цветным изображением. Соответствие межд...
Definition: DepthMapRaw.h:21
double quality
Definition: VideoWorker.h:701
Params & age_gender_estimation_threads_count(const int value)
Задать количество потоков для определения пола и возраста.
Definition: VideoWorker.h:137
Params & active_liveness_checks_order(const std::vector< ActiveLiveness::CheckType > value)
Задать порядок для проверки активаного (сценарного) liveness.
Definition: VideoWorker.h:167
Emotion
Эмоции.
Definition: EmotionsEstimator.h:57
int addVideoFrame(const RawImage frame, const int stream_id, const uint64_t timestamp_microsec=uint64_t(-1))
Подать новый кадр определенного видеопотока. Результаты трекинга и распознавания будут возвращаться а...
Definition: VideoWorker.h:2689
void addDepthFrame(const DepthMapRaw &depth_frame, const int stream_id, const uint64_t timestamp_microsec)
Подать кадр определенного видеопотока c данными глубины. Потокобезопасный.
Definition: VideoWorker.h:2722
void(* StiPersonOutdatedCallbackU)(const StiPersonOutdatedCallbackData &data, void *const userdata)
Тип функции коллбэка StiPersonOutdated.
Definition: VideoWorker.h:1414
void(* TrackingLostCallbackFunc)(const int stream_id, const int first_frame_id, const int last_frame_id, const float best_quality, const int best_quality_frame_id, const RawSample::Ptr &best_quality_sample, const Template::Ptr &best_quality_templ, void *const userdata)
Тип функции коллбэка потери трекинга лица (TrackingLost) (например, когда человек вышел из кадра)...
Definition: VideoWorker.h:1147
void removeMatchFoundCallback(const int callback_id)
Удалить обработчик события распознавания (MatchFound). Потокобезопасный.
Definition: VideoWorker.h:3034
void(* TemplateCreatedCallbackFuncU)(const TemplateCreatedCallbackData &data, void *const userdata)
Тип функции коллбэка создания шаблона (TemplateCreated).
Definition: VideoWorker.h:770
float ir_frame_2_image_offset_y
Параметр соответствия координат исходного изображения и инфракрасного.
Definition: IRFrameRaw.h:49
Данные TemplateCreated коллбэка.
Definition: VideoWorker.h:655
std::vector< SampleCheckStatus::Verdict > samples_good_face_size
Результат проверки сэмпла на приемлемый размер лица, см. параметр min_template_generation_face_size в...
Definition: VideoWorker.h:408
Params & video_worker_config(const pbio::Config value)
Задать конфигурационный файл VideoWorker с опционально переопределенными параметрами.
Definition: VideoWorker.h:101
int32_t ir_data_stride_in_bytes
Шаг в байтах.
Definition: IRFrameRaw.h:91
int ir_frame_cols
Ширина IR кадра.
Definition: IRFrameRaw.h:35
SmartPtr.
float distance_threshold
Порог распознавания.
Definition: VideoWorker.h:1481
Params & emotions_estimation_threads_count(const int value)
Задать количество потоков для определения эмоций.
Definition: VideoWorker.h:143
int64_t stream_id
Целочисленный идентификатор видеопотока (0 <= stream_id < streams_count).
Definition: VideoWorker.h:915
void removeTrackingCallback(const int callback_id)
Удалить обработчик события трекинга (Tracking). Потокобезопасный.
Definition: VideoWorker.h:3006
IRLivenessEstimator - интерфейсный объект для определения принадлежности лица реальному человеку...
int64_t track_id
Идентификатор потерянного лица (track_id). track_id равен sample.getID() для сэмпла в любом VideoWork...
Definition: VideoWorker.h:1255
std::vector< bool > samples_weak
Так как это трекинг, то некоторые сэмплы могут быть ошибочными, поэтому мы помечаем сэмплы флагом "we...
Definition: VideoWorker.h:356
Gender
Пол.
Definition: AgeGenderEstimator.h:98
float ir_frame_2_image_scale_x
Параметр соответствия координат исходного изображения и инфракрасного.
Definition: IRFrameRaw.h:56
int64_t sti_person_id
Идентификатор "sti_person" - набора треков, объединенных кратковременной идентификацией. Значение sti_person_id совпадает с track_id первого элемента, сформировавшего этот набор "sti_person".
Definition: VideoWorker.h:1385
Params & short_time_identification_outdate_time_seconds(const float value)
Задать в секундах длину временного интервала для кратковременной идентификации.
Definition: VideoWorker.h:161
void disableProcessingOnStream(const int stream_id)
Отключить генерацию шаблонов для данного потока. Соответственно, сравнения также остановятся. Потокобезопасный.
Definition: VideoWorker.h:3945
float depth_map_2_image_scale_y
Параметр соответствия координат исходного изображения и карты глубины.
Definition: DepthMapRaw.h:63
float depth_map_2_image_offset_x
Параметр соответствия координат исходного изображения и карты глубины.
Definition: DepthMapRaw.h:42
Элемент базы. Если имеется несколько шаблонов для одного человека, нужно создать по одному элементу д...
Definition: VideoWorker.h:1434
float vertical_fov
Вертикальный угол обзора карты глубины в градусах.
Definition: DepthMapRaw.h:77
Данные StiPersonOutdated коллбэка.
Definition: VideoWorker.h:1361
void enableAgeGenderEstimationOnStream(const int stream_id)
Включить определение пола и возраста для данного потока. Потокобезопасный.
Definition: VideoWorker.h:3965
void(* MatchFoundCallbackU)(const MatchFoundCallbackData &data, void *const userdata)
Тип функции коллбэка распознавания (MatchFound).
Definition: VideoWorker.h:1058
std::vector< SearchResult > search_results
Найденные элементы с расстоянием меньше distance_threshold (но не более k ближайших элементов; величи...
Definition: VideoWorker.h:981
double best_quality
Лучшее качество среди всех кадров.
Definition: VideoWorker.h:1207
int addTemplateCreatedCallback(const TemplateCreatedCallbackFunc callback, void *const userdata)
Добавить обработчик события создания шаблона (TemplateCreated). Потокобезопасный. ...
Definition: VideoWorker.h:2857
CheckType
Тип проверки для активной (сценарной) оценки принадлежности лица живому человеку. ...
Definition: ActiveLiveness.h:14
int64_t best_quality_frame_id
Целочисленный идентификатор кадра с наилучшим качеством.
Definition: VideoWorker.h:1217
uint64_t person_id
Уникальный идентификатор человека.
Definition: VideoWorker.h:1452
Params & streams_count(const int value)
Задать количество видеопотоков.
Definition: VideoWorker.h:119
Данные Tracking коллбэка.
Definition: VideoWorker.h:274
std::string getMethodName() const
Получить имя метода используемого распознавателя. Потокобезопасный.
Definition: VideoWorker.h:2605
void(* TrackingLostCallbackFuncU)(const TrackingLostCallbackData &data, void *const userdata)
Тип функции коллбэка потери трекинга лица (TrackingLost) (например, когда человек вышел из кадра)...
Definition: VideoWorker.h:1347
Template::Ptr templ
Шаблон, созданный из sample.
Definition: VideoWorker.h:959
Params()
Конструктор по умолчанию, устанавливает строки пустыми, числа нулем, флаги выключены.
Definition: VideoWorker.h:3986
int ir_frame_rows
Высота IR кадра.
Definition: IRFrameRaw.h:28
void(* TrackingCallbackFunc)(const int stream_id, const int frame_id, const std::vector< RawSample::Ptr > &samples, const std::vector< bool > &samples_weak, const std::vector< float > &samples_quality, void *const userdata)
Тип функции коллбэка трекинга (Tracking).
Definition: VideoWorker.h:258
int getStreamsCount() const
Получить количество видеопотоков. Потокобезопасный.
Definition: VideoWorker.h:2625
int64_t frame_id
Целочисленный идентификатор кадра (который был возвращен методом VideoWorker::addVideoFrame).
Definition: VideoWorker.h:298
std::vector< bool > samples_track_emotions_set
Флаг, обозначающий что эмоции определены для этого трека. (samples_track_emotions_set.size() == samples.size())
Definition: VideoWorker.h:488
Template::Ptr face_template
Шаблон лица.
Definition: VideoWorker.h:1461
Params & short_time_identification_distance_threshold(const float value)
Задать порог распознавания для кратковременной идентификации.
Definition: VideoWorker.h:155
Liveness
Результат определения принадлежности лица живому человеку.
Definition: DepthLivenessEstimator.h:50
void removeTemplateCreatedCallback(const int callback_id)
Удалить обработчик события создания шаблона (TemplateCreated). Потокобезопасный.
Definition: VideoWorker.h:3020
uint16_t const * depth_data
Указатель на данные глубины.
Definition: DepthMapRaw.h:91
Params & recognizer_config(const pbio::Config value)
Задать конфигурационный файл Recognizer с опционально переопределенными параметрами.
Definition: VideoWorker.h:113