Intel® RealSense™ Cross Platform API
Intel Realsense Cross-platform API
rs_device.hpp
Go to the documentation of this file.
1 // License: Apache 2.0. See LICENSE file in root directory.
2 // Copyright(c) 2017 Intel Corporation. All Rights Reserved.
3 
4 #ifndef LIBREALSENSE_RS2_DEVICE_HPP
5 #define LIBREALSENSE_RS2_DEVICE_HPP
6 
7 #include "rs_types.hpp"
8 #include "rs_sensor.hpp"
9 #include <array>
10 
11 namespace rs2
12 {
13  class context;
14  class device_list;
15  class pipeline_profile;
16  class device_hub;
17 
18  class device
19  {
20  public:
25  std::vector<sensor> query_sensors() const
26  {
27  rs2_error* e = nullptr;
28  std::shared_ptr<rs2_sensor_list> list(
29  rs2_query_sensors(_dev.get(), &e),
31  error::handle(e);
32 
33  auto size = rs2_get_sensors_count(list.get(), &e);
34  error::handle(e);
35 
36  std::vector<sensor> results;
37  for (auto i = 0; i < size; i++)
38  {
39  std::shared_ptr<rs2_sensor> dev(
40  rs2_create_sensor(list.get(), i, &e),
42  error::handle(e);
43 
44  sensor rs2_dev(dev);
45  results.push_back(rs2_dev);
46  }
47 
48  return results;
49  }
50 
51  template<class T>
52  T first() const
53  {
54  for (auto&& s : query_sensors())
55  {
56  if (auto t = s.as<T>()) return t;
57  }
58  throw rs2::error("Could not find requested sensor type!");
59  }
60 
66  bool supports(rs2_camera_info info) const
67  {
68  rs2_error* e = nullptr;
69  auto is_supported = rs2_supports_device_info(_dev.get(), info, &e);
70  error::handle(e);
71  return is_supported > 0;
72  }
73 
79  const char* get_info(rs2_camera_info info) const
80  {
81  rs2_error* e = nullptr;
82  auto result = rs2_get_device_info(_dev.get(), info, &e);
83  error::handle(e);
84  return result;
85  }
86 
91  {
92  rs2_error* e = nullptr;
93 
94  rs2_hardware_reset(_dev.get(), &e);
95  error::handle(e);
96  }
97 
98  device& operator=(const std::shared_ptr<rs2_device> dev)
99  {
100  _dev.reset();
101  _dev = dev;
102  return *this;
103  }
104  device& operator=(const device& dev)
105  {
106  *this = nullptr;
107  _dev = dev._dev;
108  return *this;
109  }
110  device() : _dev(nullptr) {}
111 
112  operator bool() const
113  {
114  return _dev != nullptr;
115  }
116  const std::shared_ptr<rs2_device>& get() const
117  {
118  return _dev;
119  }
120 
121  template<class T>
122  bool is() const
123  {
124  T extension(*this);
125  return extension;
126  }
127 
128  template<class T>
129  T as() const
130  {
131  T extension(*this);
132  return extension;
133  }
134  virtual ~device()
135  {
136  }
137 
138  explicit operator std::shared_ptr<rs2_device>() { return _dev; };
139  explicit device(std::shared_ptr<rs2_device> dev) : _dev(dev) {}
140  protected:
141  friend class rs2::context;
142  friend class rs2::device_list;
143  friend class rs2::pipeline_profile;
144  friend class rs2::device_hub;
145 
146  std::shared_ptr<rs2_device> _dev;
147 
148  };
149 
150  template<class T>
152  {
153  T _callback;
154 
155  public:
156  explicit update_progress_callback(T callback) : _callback(callback) {}
157 
158  void on_update_progress(const float progress) override
159  {
160  _callback(progress);
161  }
162 
163  void release() override { delete this; }
164  };
165 
166  class updatable : public device
167  {
168  public:
169  updatable() : device() {}
171  : device(d.get())
172  {
173  rs2_error* e = nullptr;
174  if (rs2_is_device_extendable_to(_dev.get(), RS2_EXTENSION_UPDATABLE, &e) == 0 && !e)
175  {
176  _dev.reset();
177  }
178  error::handle(e);
179  }
180 
181  // Move the device to update state, this will cause the updatable device to disconnect and reconnect as an update device.
182  void enter_update_state() const
183  {
184  rs2_error* e = nullptr;
185  rs2_enter_update_state(_dev.get(), &e);
186  error::handle(e);
187  }
188 
189  // Create backup of camera flash memory. Such backup does not constitute valid firmware image, and cannot be
190  // loaded back to the device, but it does contain all calibration and device information."
191  std::vector<uint8_t> create_flash_backup() const
192  {
193  std::vector<uint8_t> results;
194 
195  rs2_error* e = nullptr;
196  std::shared_ptr<const rs2_raw_data_buffer> list(
197  rs2_create_flash_backup_cpp(_dev.get(), nullptr, &e),
199  error::handle(e);
200 
201  auto size = rs2_get_raw_data_size(list.get(), &e);
202  error::handle(e);
203 
204  auto start = rs2_get_raw_data(list.get(), &e);
205 
206  results.insert(results.begin(), start, start + size);
207 
208  return results;
209  }
210 
211  template<class T>
212  std::vector<uint8_t> create_flash_backup(T callback) const
213  {
214  std::vector<uint8_t> results;
215 
216  rs2_error* e = nullptr;
217  std::shared_ptr<const rs2_raw_data_buffer> list(
218  rs2_create_flash_backup_cpp(_dev.get(), new update_progress_callback<T>(std::move(callback)), &e),
220  error::handle(e);
221 
222  auto size = rs2_get_raw_data_size(list.get(), &e);
223  error::handle(e);
224 
225  auto start = rs2_get_raw_data(list.get(), &e);
226 
227  results.insert(results.begin(), start, start + size);
228 
229  return results;
230  }
231 
232  // Update an updatable device to the provided unsigned firmware. This call is executed on the caller's thread.
233  void update_unsigned(const std::vector<uint8_t>& image, int update_mode = RS2_UNSIGNED_UPDATE_MODE_UPDATE) const
234  {
235  rs2_error* e = nullptr;
236  rs2_update_firmware_unsigned_cpp(_dev.get(), image.data(), (int)image.size(), nullptr, update_mode, &e);
237  error::handle(e);
238  }
239 
240  // Update an updatable device to the provided unsigned firmware. This call is executed on the caller's thread and it supports progress notifications via the callback.
241  template<class T>
242  void update_unsigned(const std::vector<uint8_t>& image, T callback, int update_mode = RS2_UNSIGNED_UPDATE_MODE_UPDATE) const
243  {
244  rs2_error* e = nullptr;
245  rs2_update_firmware_unsigned_cpp(_dev.get(), image.data(), int(image.size()), new update_progress_callback<T>(std::move(callback)), update_mode, &e);
246  error::handle(e);
247  }
248  };
249 
250  class update_device : public device
251  {
252  public:
255  : device(d.get())
256  {
257  rs2_error* e = nullptr;
259  {
260  _dev.reset();
261  }
262  error::handle(e);
263  }
264 
265  // Update an updatable device to the provided firmware.
266  // This call is executed on the caller's thread.
267  void update(const std::vector<uint8_t>& fw_image) const
268  {
269  rs2_error* e = nullptr;
270  rs2_update_firmware_cpp(_dev.get(), fw_image.data(), (int)fw_image.size(), NULL, &e);
271  error::handle(e);
272  }
273 
274  // Update an updatable device to the provided firmware.
275  // This call is executed on the caller's thread and it supports progress notifications via the callback.
276  template<class T>
277  void update(const std::vector<uint8_t>& fw_image, T callback) const
278  {
279  rs2_error* e = nullptr;
280  rs2_update_firmware_cpp(_dev.get(), fw_image.data(), int(fw_image.size()), new update_progress_callback<T>(std::move(callback)), &e);
281  error::handle(e);
282  }
283  };
284 
285  typedef std::vector<uint8_t> calibration_table;
286 
287  class calibrated_device : public device
288  {
289  public:
291  : device(d.get())
292  {}
293 
297  void write_calibration() const
298  {
299  rs2_error* e = nullptr;
300  rs2_write_calibration(_dev.get(), &e);
301  error::handle(e);
302  }
303 
308  {
309  rs2_error* e = nullptr;
311  error::handle(e);
312  }
313  };
314 
316  {
317  public:
319  : calibrated_device(d)
320  {
321  rs2_error* e = nullptr;
323  {
324  _dev.reset();
325  }
326  error::handle(e);
327  }
328 
349  template<class T>
350  calibration_table run_on_chip_calibration(std::string json_content, float* health, T callback, int timeout_ms = 5000) const
351  {
352  std::vector<uint8_t> results;
353 
354  rs2_error* e = nullptr;
355  std::shared_ptr<const rs2_raw_data_buffer> list(
356  rs2_run_on_chip_calibration_cpp(_dev.get(), json_content.data(), int(json_content.size()), health, new update_progress_callback<T>(std::move(callback)), timeout_ms, &e),
358  error::handle(e);
359 
360  auto size = rs2_get_raw_data_size(list.get(), &e);
361  error::handle(e);
362 
363  auto start = rs2_get_raw_data(list.get(), &e);
364 
365  results.insert(results.begin(), start, start + size);
366 
367  return results;
368  }
369 
389  calibration_table run_on_chip_calibration(std::string json_content, float* health, int timeout_ms = 5000) const
390  {
391  std::vector<uint8_t> results;
392 
393  rs2_error* e = nullptr;
394  std::shared_ptr<const rs2_raw_data_buffer> list(
395  rs2_run_on_chip_calibration_cpp(_dev.get(), json_content.data(), static_cast< int >( json_content.size() ), health, nullptr, timeout_ms, &e),
397  error::handle(e);
398  auto size = rs2_get_raw_data_size(list.get(), &e);
399  error::handle(e);
400 
401  auto start = rs2_get_raw_data(list.get(), &e);
402 
403  results.insert(results.begin(), start, start + size);
404 
405  return results;
406  }
407 
430  template<class T>
431  calibration_table run_tare_calibration(float ground_truth_mm, std::string json_content, T callback, int timeout_ms = 5000) const
432  {
433  std::vector<uint8_t> results;
434 
435  rs2_error* e = nullptr;
436  std::shared_ptr<const rs2_raw_data_buffer> list(
437  rs2_run_tare_calibration_cpp(_dev.get(), ground_truth_mm, json_content.data(), int(json_content.size()), new update_progress_callback<T>(std::move(callback)), timeout_ms, &e),
439  error::handle(e);
440 
441  auto size = rs2_get_raw_data_size(list.get(), &e);
442  error::handle(e);
443 
444  auto start = rs2_get_raw_data(list.get(), &e);
445 
446  results.insert(results.begin(), start, start + size);
447 
448  return results;
449  }
450 
472  calibration_table run_tare_calibration(float ground_truth_mm, std::string json_content, int timeout_ms = 5000) const
473  {
474  std::vector<uint8_t> results;
475 
476  rs2_error* e = nullptr;
477  std::shared_ptr<const rs2_raw_data_buffer> list(
478  rs2_run_tare_calibration_cpp(_dev.get(), ground_truth_mm, json_content.data(), static_cast< int >( json_content.size() ), nullptr, timeout_ms, &e),
480  error::handle(e);
481 
482  auto size = rs2_get_raw_data_size(list.get(), &e);
483  error::handle(e);
484 
485  auto start = rs2_get_raw_data(list.get(), &e);
486 
487  results.insert(results.begin(), start, start + size);
488 
489  return results;
490  }
491 
497  {
498  std::vector<uint8_t> results;
499 
500  rs2_error* e = nullptr;
501  std::shared_ptr<const rs2_raw_data_buffer> list(
502  rs2_get_calibration_table(_dev.get(), &e),
504  error::handle(e);
505 
506  auto size = rs2_get_raw_data_size(list.get(), &e);
507  error::handle(e);
508 
509  auto start = rs2_get_raw_data(list.get(), &e);
510 
511  results.insert(results.begin(), start, start + size);
512 
513  return results;
514  }
515 
520  void set_calibration_table(const calibration_table& calibration)
521  {
522  rs2_error* e = nullptr;
523  rs2_set_calibration_table(_dev.get(), calibration.data(), static_cast< int >( calibration.size() ), &e);
524  error::handle(e);
525  }
526 
527 
528  };
529 
530  /*
531  Wrapper around any callback function that is given to calibration_change_callback.
532  */
533  template< class callback >
535  {
536  //using callback = std::function< void( rs2_calibration_status ) >;
537  callback _callback;
538  public:
539  calibration_change_callback( callback cb ) : _callback( cb ) {}
540 
541  void on_calibration_change( rs2_calibration_status status ) noexcept override
542  {
543  _callback( status );
544  }
545  void release() override { delete this; }
546  };
547 
548  class device_calibration : public device
549  {
550  public:
552  : device( d.get() )
553  {
554  rs2_error* e = nullptr;
556  {
557  _dev.reset();
558  }
559  error::handle( e );
560  }
561 
562  /*
563  Your callback should look like this, for example:
564  sensor.register_calibration_change_callback(
565  []( rs2_calibration_status ) noexcept
566  {
567  ...
568  })
569  */
570  template< typename T >
572  {
573  // We wrap the callback with an interface and pass it to librealsense, who will
574  // now manage its lifetime. Rather than deleting it, though, it will call its
575  // release() function, where (back in our context) it can be safely deleted:
576  rs2_error* e = nullptr;
578  _dev.get(),
579  new calibration_change_callback< T >( std::move( callback )),
580  &e );
581  error::handle( e );
582  }
583 
588  {
589  rs2_error* e = nullptr;
590  rs2_trigger_device_calibration( _dev.get(), type, &e );
591  error::handle( e );
592  }
593  };
594 
595  class debug_protocol : public device
596  {
597  public:
599  : device(d.get())
600  {
601  rs2_error* e = nullptr;
602  if(rs2_is_device_extendable_to(_dev.get(), RS2_EXTENSION_DEBUG, &e) == 0 && !e)
603  {
604  _dev.reset();
605  }
606  error::handle(e);
607  }
608 
609  std::vector<uint8_t> send_and_receive_raw_data(const std::vector<uint8_t>& input) const
610  {
611  std::vector<uint8_t> results;
612 
613  rs2_error* e = nullptr;
614  std::shared_ptr<const rs2_raw_data_buffer> list(
615  rs2_send_and_receive_raw_data(_dev.get(), (void*)input.data(), (uint32_t)input.size(), &e),
617  error::handle(e);
618 
619  auto size = rs2_get_raw_data_size(list.get(), &e);
620  error::handle(e);
621 
622  auto start = rs2_get_raw_data(list.get(), &e);
623 
624  results.insert(results.begin(), start, start + size);
625 
626  return results;
627  }
628  };
629 
631  {
632  public:
633  explicit device_list(std::shared_ptr<rs2_device_list> list)
634  : _list(move(list)) {}
635 
637  : _list(nullptr) {}
638 
639  operator std::vector<device>() const
640  {
641  std::vector<device> res;
642  for (auto&& dev : *this) res.push_back(dev);
643  return res;
644  }
645 
646  bool contains(const device& dev) const
647  {
648  rs2_error* e = nullptr;
649  auto res = !!(rs2_device_list_contains(_list.get(), dev.get().get(), &e));
650  error::handle(e);
651  return res;
652  }
653 
654  device_list& operator=(std::shared_ptr<rs2_device_list> list)
655  {
656  _list = move(list);
657  return *this;
658  }
659 
660  device operator[](uint32_t index) const
661  {
662  rs2_error* e = nullptr;
663  std::shared_ptr<rs2_device> dev(
664  rs2_create_device(_list.get(), index, &e),
666  error::handle(e);
667 
668  return device(dev);
669  }
670 
671  uint32_t size() const
672  {
673  rs2_error* e = nullptr;
674  auto size = rs2_get_device_count(_list.get(), &e);
675  error::handle(e);
676  return size;
677  }
678 
679  device front() const { return std::move((*this)[0]); }
680  device back() const
681  {
682  return std::move((*this)[size() - 1]);
683  }
684 
686  {
688  const device_list& device_list,
689  uint32_t uint32_t)
690  : _list(device_list),
691  _index(uint32_t)
692  {
693  }
694 
695  public:
697  {
698  return _list[_index];
699  }
700  bool operator!=(const device_list_iterator& other) const
701  {
702  return other._index != _index || &other._list != &_list;
703  }
704  bool operator==(const device_list_iterator& other) const
705  {
706  return !(*this != other);
707  }
709  {
710  _index++;
711  return *this;
712  }
713  private:
714  friend device_list;
715  const device_list& _list;
716  uint32_t _index;
717  };
718 
720  {
721  return device_list_iterator(*this, 0);
722  }
724  {
725  return device_list_iterator(*this, size());
726  }
727  const rs2_device_list* get_list() const
728  {
729  return _list.get();
730  }
731 
732  operator std::shared_ptr<rs2_device_list>() { return _list; };
733 
734  private:
735  std::shared_ptr<rs2_device_list> _list;
736  };
737 
747  class tm2 : public calibrated_device // TODO: add to wrappers [Python done]
748  {
749  public:
751  : calibrated_device(d)
752  {
753  rs2_error* e = nullptr;
754  if (rs2_is_device_extendable_to(_dev.get(), RS2_EXTENSION_TM2, &e) == 0 && !e)
755  {
756  _dev.reset();
757  }
758  error::handle(e);
759  }
760 
765  void enable_loopback(const std::string& from_file)
766  {
767  rs2_error* e = nullptr;
768  rs2_loopback_enable(_dev.get(), from_file.c_str(), &e);
769  error::handle(e);
770  }
771 
776  {
777  rs2_error* e = nullptr;
778  rs2_loopback_disable(_dev.get(), &e);
779  error::handle(e);
780  }
781 
786  bool is_loopback_enabled() const
787  {
788  rs2_error* e = nullptr;
789  int is_enabled = rs2_loopback_is_enabled(_dev.get(), &e);
790  error::handle(e);
791  return is_enabled != 0;
792  }
793 
798  void connect_controller(const std::array<uint8_t, 6>& mac_addr)
799  {
800  rs2_error* e = nullptr;
801  rs2_connect_tm2_controller(_dev.get(), mac_addr.data(), &e);
802  error::handle(e);
803  }
804 
810  {
811  rs2_error* e = nullptr;
812  rs2_disconnect_tm2_controller(_dev.get(), id, &e);
813  error::handle(e);
814  }
815 
821  void set_intrinsics(int fisheye_sensor_id, const rs2_intrinsics& intrinsics)
822  {
823  rs2_error* e = nullptr;
824  auto fisheye_sensor = get_sensor_profile(RS2_STREAM_FISHEYE, fisheye_sensor_id);
825  rs2_set_intrinsics(fisheye_sensor.first.get().get(), fisheye_sensor.second.get(), &intrinsics, &e);
826  error::handle(e);
827  }
828 
837  void set_extrinsics(rs2_stream from_stream, int from_id, rs2_stream to_stream, int to_id, rs2_extrinsics& extrinsics)
838  {
839  rs2_error* e = nullptr;
840  auto from_sensor = get_sensor_profile(from_stream, from_id);
841  auto to_sensor = get_sensor_profile(to_stream, to_id);
842  rs2_set_extrinsics(from_sensor.first.get().get(), from_sensor.second.get(), to_sensor.first.get().get(), to_sensor.second.get(), &extrinsics, &e);
843  error::handle(e);
844  }
845 
851  void set_motion_device_intrinsics(rs2_stream stream_type, const rs2_motion_device_intrinsic& motion_intriniscs)
852  {
853  rs2_error* e = nullptr;
854  auto motion_sensor = get_sensor_profile(stream_type, 0);
855  rs2_set_motion_device_intrinsics(motion_sensor.first.get().get(), motion_sensor.second.get(), &motion_intriniscs, &e);
856  error::handle(e);
857  }
858 
859  private:
860 
861  std::pair<sensor, stream_profile> get_sensor_profile(rs2_stream stream_type, int stream_index) {
862  for (auto s : query_sensors()) {
863  for (auto p : s.get_stream_profiles()) {
864  if (p.stream_type() == stream_type && p.stream_index() == stream_index)
865  return std::pair<sensor, stream_profile>(s, p);
866  }
867  }
868  return std::pair<sensor, stream_profile>();
869  }
870  };
871 }
872 #endif // LIBREALSENSE_RS2_DEVICE_HPP
rs2::device_list::device_list_iterator::operator!=
bool operator!=(const device_list_iterator &other) const
Definition: rs_device.hpp:700
rs2::device
Definition: rs_device.hpp:19
rs2::updatable::update_unsigned
void update_unsigned(const std::vector< uint8_t > &image, T callback, int update_mode=RS2_UNSIGNED_UPDATE_MODE_UPDATE) const
Definition: rs_device.hpp:242
rs2::device_list::size
uint32_t size() const
Definition: rs_device.hpp:671
rs2::auto_calibrated_device::run_on_chip_calibration
calibration_table run_on_chip_calibration(std::string json_content, float *health, T callback, int timeout_ms=5000) const
Definition: rs_device.hpp:350
RS2_EXTENSION_TM2
@ RS2_EXTENSION_TM2
Definition: rs_types.h:184
rs2::update_progress_callback::update_progress_callback
update_progress_callback(T callback)
Definition: rs_device.hpp:156
RS2_EXTENSION_DEVICE_CALIBRATION
@ RS2_EXTENSION_DEVICE_CALIBRATION
Definition: rs_types.h:211
rs2_calibration_change_callback
Definition: rs_types.hpp:63
rs2_get_raw_data
const unsigned char * rs2_get_raw_data(const rs2_raw_data_buffer *buffer, rs2_error **error)
rs2::tm2::is_loopback_enabled
bool is_loopback_enabled() const
Definition: rs_device.hpp:786
rs2_set_intrinsics
void rs2_set_intrinsics(const rs2_sensor *sensor, const rs2_stream_profile *profile, const rs2_intrinsics *intrinsics, rs2_error **error)
rs2::calibration_table
std::vector< uint8_t > calibration_table
Definition: rs_device.hpp:285
rs2::tm2::set_extrinsics
void set_extrinsics(rs2_stream from_stream, int from_id, rs2_stream to_stream, int to_id, rs2_extrinsics &extrinsics)
Definition: rs_device.hpp:837
RS2_EXTENSION_DEBUG
@ RS2_EXTENSION_DEBUG
Definition: rs_types.h:163
rs2::updatable::enter_update_state
void enter_update_state() const
Definition: rs_device.hpp:182
rs2_extrinsics
Cross-stream extrinsics: encodes the topology describing how the different devices are oriented.
Definition: rs_sensor.h:96
rs2_create_flash_backup_cpp
const rs2_raw_data_buffer * rs2_create_flash_backup_cpp(const rs2_device *device, rs2_update_progress_callback *callback, rs2_error **error)
rs2::update_device::update_device
update_device()
Definition: rs_device.hpp:253
rs2::updatable::updatable
updatable()
Definition: rs_device.hpp:169
rs2::calibrated_device::write_calibration
void write_calibration() const
Definition: rs_device.hpp:297
rs2::device_list::device_list
device_list(std::shared_ptr< rs2_device_list > list)
Definition: rs_device.hpp:633
rs2_disconnect_tm2_controller
void rs2_disconnect_tm2_controller(const rs2_device *device, int id, rs2_error **error)
rs2::device_list::device_list_iterator::operator++
device_list_iterator & operator++()
Definition: rs_device.hpp:708
rs2::device_list::front
device front() const
Definition: rs_device.hpp:679
rs2_intrinsics
Video stream intrinsics.
Definition: rs_types.h:59
RS2_EXTENSION_UPDATE_DEVICE
@ RS2_EXTENSION_UPDATE_DEVICE
Definition: rs_types.h:200
rs2::calibration_change_callback::release
void release() override
Definition: rs_device.hpp:545
rs2::device_list::contains
bool contains(const device &dev) const
Definition: rs_device.hpp:646
rs2_enter_update_state
void rs2_enter_update_state(const rs2_device *device, rs2_error **error)
rs2::update_progress_callback
Definition: rs_device.hpp:152
RS2_EXTENSION_UPDATABLE
@ RS2_EXTENSION_UPDATABLE
Definition: rs_types.h:199
rs2::device::is
bool is() const
Definition: rs_device.hpp:122
rs2::update_progress_callback::release
void release() override
Definition: rs_device.hpp:163
rs2::device_list
Definition: rs_device.hpp:631
rs2_send_and_receive_raw_data
const rs2_raw_data_buffer * rs2_send_and_receive_raw_data(rs2_device *device, void *raw_data_to_send, unsigned size_of_raw_data_to_send, rs2_error **error)
rs2_set_extrinsics
void rs2_set_extrinsics(const rs2_sensor *from_sensor, const rs2_stream_profile *from_profile, rs2_sensor *to_sensor, const rs2_stream_profile *to_profile, const rs2_extrinsics *extrinsics, rs2_error **error)
rs2_delete_raw_data
void rs2_delete_raw_data(const rs2_raw_data_buffer *buffer)
rs2_run_on_chip_calibration_cpp
const rs2_raw_data_buffer * rs2_run_on_chip_calibration_cpp(rs2_device *device, const void *json_content, int content_size, float *health, rs2_update_progress_callback *progress_callback, int timeout_ms, rs2_error **error)
rs2::updatable::updatable
updatable(device d)
Definition: rs_device.hpp:170
rs2::device::device
device()
Definition: rs_device.hpp:110
rs2::auto_calibrated_device::run_tare_calibration
calibration_table run_tare_calibration(float ground_truth_mm, std::string json_content, T callback, int timeout_ms=5000) const
Definition: rs_device.hpp:431
rs2::update_device::update
void update(const std::vector< uint8_t > &fw_image) const
Definition: rs_device.hpp:267
RS2_STREAM_FISHEYE
@ RS2_STREAM_FISHEYE
Definition: rs_sensor.h:48
rs2::device_list::operator=
device_list & operator=(std::shared_ptr< rs2_device_list > list)
Definition: rs_device.hpp:654
rs2::auto_calibrated_device::get_calibration_table
calibration_table get_calibration_table()
Definition: rs_device.hpp:496
rs2_get_raw_data_size
int rs2_get_raw_data_size(const rs2_raw_data_buffer *buffer, rs2_error **error)
rs2::device_list::operator[]
device operator[](uint32_t index) const
Definition: rs_device.hpp:660
rs2::device_calibration::device_calibration
device_calibration(device d)
Definition: rs_device.hpp:551
rs2::device::supports
bool supports(rs2_camera_info info) const
Definition: rs_device.hpp:66
rs2_update_firmware_cpp
void rs2_update_firmware_cpp(const rs2_device *device, const void *fw_image, int fw_image_size, rs2_update_progress_callback *callback, rs2_error **error)
rs2::tm2::disable_loopback
void disable_loopback()
Definition: rs_device.hpp:775
rs2_device_list_contains
int rs2_device_list_contains(const rs2_device_list *info_list, const rs2_device *device, rs2_error **error)
rs2::device_list::back
device back() const
Definition: rs_device.hpp:680
rs2::device_list::device_list_iterator::operator==
bool operator==(const device_list_iterator &other) const
Definition: rs_device.hpp:704
rs2::device_hub
Definition: rs_context.hpp:225
rs2::device_list::device_list_iterator::operator*
device operator*() const
Definition: rs_device.hpp:696
rs2::motion_sensor
Definition: rs_sensor.hpp:390
rs2_loopback_disable
void rs2_loopback_disable(const rs2_device *device, rs2_error **error)
rs2::tm2
Definition: rs_device.hpp:748
rs2_motion_device_intrinsic
Motion device intrinsics: scale, bias, and variances.
Definition: rs_types.h:98
rs2_delete_sensor
void rs2_delete_sensor(rs2_sensor *sensor)
rs2::tm2::tm2
tm2(device d)
Definition: rs_device.hpp:750
rs2::device_list::get_list
const rs2_device_list * get_list() const
Definition: rs_device.hpp:727
rs2::device_list::begin
device_list_iterator begin() const
Definition: rs_device.hpp:719
rs2::device::operator=
device & operator=(const device &dev)
Definition: rs_device.hpp:104
rs2::device::operator=
device & operator=(const std::shared_ptr< rs2_device > dev)
Definition: rs_device.hpp:98
rs2::device::first
T first() const
Definition: rs_device.hpp:52
rs2::device::get
const std::shared_ptr< rs2_device > & get() const
Definition: rs_device.hpp:116
rs2::debug_protocol::debug_protocol
debug_protocol(device d)
Definition: rs_device.hpp:598
rs_sensor.hpp
rs2::updatable::update_unsigned
void update_unsigned(const std::vector< uint8_t > &image, int update_mode=RS2_UNSIGNED_UPDATE_MODE_UPDATE) const
Definition: rs_device.hpp:233
rs2::device::_dev
std::shared_ptr< rs2_device > _dev
Definition: rs_device.hpp:146
rs2::auto_calibrated_device::set_calibration_table
void set_calibration_table(const calibration_table &calibration)
Definition: rs_device.hpp:520
rs2_get_device_info
const char * rs2_get_device_info(const rs2_device *device, rs2_camera_info info, rs2_error **error)
rs2::device::~device
virtual ~device()
Definition: rs_device.hpp:134
rs2::tm2::enable_loopback
void enable_loopback(const std::string &from_file)
Definition: rs_device.hpp:765
rs2_set_calibration_table
void rs2_set_calibration_table(const rs2_device *device, const void *calibration, int calibration_size, rs2_error **error)
rs2_get_calibration_table
const rs2_raw_data_buffer * rs2_get_calibration_table(const rs2_device *dev, rs2_error **error)
rs2
Definition: rs_context.hpp:12
rs2_delete_sensor_list
void rs2_delete_sensor_list(rs2_sensor_list *info_list)
rs2::sensor
Definition: rs_sensor.hpp:103
rs2::device::hardware_reset
void hardware_reset()
Definition: rs_device.hpp:90
rs2_delete_device
void rs2_delete_device(rs2_device *device)
rs2::updatable
Definition: rs_device.hpp:167
rs2_update_firmware_unsigned_cpp
void rs2_update_firmware_unsigned_cpp(const rs2_device *device, const void *fw_image, int fw_image_size, rs2_update_progress_callback *callback, int update_mode, rs2_error **error)
rs2_get_device_count
int rs2_get_device_count(const rs2_device_list *info_list, rs2_error **error)
rs2_run_tare_calibration_cpp
const rs2_raw_data_buffer * rs2_run_tare_calibration_cpp(rs2_device *dev, float ground_truth_mm, const void *json_content, int content_size, rs2_update_progress_callback *progress_callback, int timeout_ms, rs2_error **error)
rs2::device::device
device(std::shared_ptr< rs2_device > dev)
Definition: rs_device.hpp:139
rs2::debug_protocol::send_and_receive_raw_data
std::vector< uint8_t > send_and_receive_raw_data(const std::vector< uint8_t > &input) const
Definition: rs_device.hpp:609
rs2_create_sensor
rs2_sensor * rs2_create_sensor(const rs2_sensor_list *list, int index, rs2_error **error)
rs2::device::as
T as() const
Definition: rs_device.hpp:129
rs2_register_calibration_change_callback_cpp
void rs2_register_calibration_change_callback_cpp(rs2_device *dev, rs2_calibration_change_callback *callback, rs2_error **error)
rs2::tm2::connect_controller
void connect_controller(const std::array< uint8_t, 6 > &mac_addr)
Definition: rs_device.hpp:798
rs2::updatable::create_flash_backup
std::vector< uint8_t > create_flash_backup() const
Definition: rs_device.hpp:191
rs2::device_calibration
Definition: rs_device.hpp:549
rs2::auto_calibrated_device::run_tare_calibration
calibration_table run_tare_calibration(float ground_truth_mm, std::string json_content, int timeout_ms=5000) const
Definition: rs_device.hpp:472
rs2::fisheye_sensor
Definition: rs_sensor.hpp:406
rs2::calibrated_device
Definition: rs_device.hpp:288
rs2::device_calibration::register_calibration_change_callback
void register_calibration_change_callback(T callback)
Definition: rs_device.hpp:571
rs2::sensor::get
const std::shared_ptr< rs2_sensor > & get() const
Definition: rs_sensor.hpp:320
rs2_camera_info
rs2_camera_info
Read-only strings that can be queried from the device. Not all information attributes are available o...
Definition: rs_sensor.h:22
rs2_calibration_type
rs2_calibration_type
Definition: rs_device.h:319
rs2_loopback_is_enabled
int rs2_loopback_is_enabled(const rs2_device *device, rs2_error **error)
rs2::update_device::update_device
update_device(device d)
Definition: rs_device.hpp:254
rs2_write_calibration
void rs2_write_calibration(const rs2_device *device, rs2_error **e)
rs2::device_calibration::trigger_device_calibration
void trigger_device_calibration(rs2_calibration_type type)
Definition: rs_device.hpp:587
rs2::tm2::set_intrinsics
void set_intrinsics(int fisheye_sensor_id, const rs2_intrinsics &intrinsics)
Definition: rs_device.hpp:821
rs2::calibration_change_callback::on_calibration_change
void on_calibration_change(rs2_calibration_status status) noexcept override
Definition: rs_device.hpp:541
rs2_create_device
rs2_device * rs2_create_device(const rs2_device_list *info_list, int index, rs2_error **error)
rs2::auto_calibrated_device::run_on_chip_calibration
calibration_table run_on_chip_calibration(std::string json_content, float *health, int timeout_ms=5000) const
Definition: rs_device.hpp:389
rs2::calibration_change_callback::calibration_change_callback
calibration_change_callback(callback cb)
Definition: rs_device.hpp:539
rs2::update_progress_callback::on_update_progress
void on_update_progress(const float progress) override
Definition: rs_device.hpp:158
rs2::context
Definition: rs_context.hpp:97
rs2_trigger_device_calibration
void rs2_trigger_device_calibration(rs2_device *dev, rs2_calibration_type type, rs2_error **error)
rs2::error
Definition: rs_types.hpp:93
rs2::tm2::disconnect_controller
void disconnect_controller(int id)
Definition: rs_device.hpp:809
rs2::tm2::set_motion_device_intrinsics
void set_motion_device_intrinsics(rs2_stream stream_type, const rs2_motion_device_intrinsic &motion_intriniscs)
Definition: rs_device.hpp:851
rs2::auto_calibrated_device::auto_calibrated_device
auto_calibrated_device(device d)
Definition: rs_device.hpp:318
rs2_update_progress_callback
Definition: rs_types.hpp:84
rs2::device_list::device_list
device_list()
Definition: rs_device.hpp:636
rs2::error::handle
static void handle(rs2_error *e)
Definition: rs_types.hpp:144
rs2::calibrated_device::reset_to_factory_calibration
void reset_to_factory_calibration()
Definition: rs_device.hpp:307
rs2::auto_calibrated_device
Definition: rs_device.hpp:316
rs2_supports_device_info
int rs2_supports_device_info(const rs2_device *device, rs2_camera_info info, rs2_error **error)
rs2::update_device::update
void update(const std::vector< uint8_t > &fw_image, T callback) const
Definition: rs_device.hpp:277
RS2_EXTENSION_AUTO_CALIBRATED_DEVICE
@ RS2_EXTENSION_AUTO_CALIBRATED_DEVICE
Definition: rs_types.h:203
rs2::calibrated_device::calibrated_device
calibrated_device(device d)
Definition: rs_device.hpp:290
rs2::debug_protocol
Definition: rs_device.hpp:596
rs2_query_sensors
rs2_sensor_list * rs2_query_sensors(const rs2_device *device, rs2_error **error)
rs2_calibration_status
rs2_calibration_status
Definition: rs_device.h:330
rs2_connect_tm2_controller
void rs2_connect_tm2_controller(const rs2_device *device, const unsigned char *mac_addr, rs2_error **error)
rs2::device::get_info
const char * get_info(rs2_camera_info info) const
Definition: rs_device.hpp:79
rs2::pipeline_profile
Definition: rs_pipeline.hpp:19
rs2_loopback_enable
void rs2_loopback_enable(const rs2_device *device, const char *from_file, rs2_error **error)
rs2::update_device
Definition: rs_device.hpp:251
rs2::updatable::create_flash_backup
std::vector< uint8_t > create_flash_backup(T callback) const
Definition: rs_device.hpp:212
rs2_hardware_reset
void rs2_hardware_reset(const rs2_device *device, rs2_error **error)
rs2_reset_to_factory_calibration
void rs2_reset_to_factory_calibration(const rs2_device *device, rs2_error **e)
rs2::calibration_change_callback
Definition: rs_device.hpp:535
rs2::device::query_sensors
std::vector< sensor > query_sensors() const
Definition: rs_device.hpp:25
rs2_device_list
struct rs2_device_list rs2_device_list
Definition: rs_types.h:255
rs2_stream
rs2_stream
Streams are different types of data provided by RealSense devices.
Definition: rs_sensor.h:43
rs2::device_list::device_list_iterator
Definition: rs_device.hpp:686
rs2_set_motion_device_intrinsics
void rs2_set_motion_device_intrinsics(const rs2_sensor *sensor, const rs2_stream_profile *profile, const rs2_motion_device_intrinsic *intrinsics, rs2_error **error)
RS2_UNSIGNED_UPDATE_MODE_UPDATE
#define RS2_UNSIGNED_UPDATE_MODE_UPDATE
Definition: rs_device.h:206
rs2::device_list::end
device_list_iterator end() const
Definition: rs_device.hpp:723
rs2_error
struct rs2_error rs2_error
Definition: rs_types.h:247
rs2_is_device_extendable_to
int rs2_is_device_extendable_to(const rs2_device *device, rs2_extension extension, rs2_error **error)
rs2_get_sensors_count
int rs2_get_sensors_count(const rs2_sensor_list *info_list, rs2_error **error)
rs_types.hpp