rs.hpp
Go to the documentation of this file.
1 // License: Apache 2.0. See LICENSE file in root directory.
2 // Copyright(c) 2015 Intel Corporation. All Rights Reserved.
3 
7 
8 #ifndef LIBREALSENSE_RS_HPP
9 #define LIBREALSENSE_RS_HPP
10 
11 #include "rsutil.h"
12 #include "rscore.hpp"
13 #include <cmath>
14 #include <cstdint>
15 #include <cstring>
16 #include <sstream>
17 #include <stdexcept>
18 #include <functional>
19 #include <vector>
20 
21 namespace rs
22 {
24  enum class stream : int32_t
25  {
26  depth ,
27  color ,
28  infrared ,
29  infrared2 ,
30  fisheye ,
31  points ,
38  };
39 
42  enum class format : int32_t
43  {
44  any ,
45  z16 ,
46  disparity16 ,
47  xyz32f ,
48  yuyv ,
49  rgb8 ,
50  bgr8 ,
51  rgba8 ,
52  bgra8 ,
53  y8 ,
54  y16 ,
55  raw10 ,
56  raw16 ,
57  raw8
58  };
59 
61  enum class output_buffer_format : int32_t
62  {
63  continous ,
64  native
65  };
66 
68  enum class preset : int32_t
69  {
70  best_quality ,
73  };
74 
76  enum class distortion : int32_t
77  {
78  none ,
82  };
83 
87  enum class option : int32_t
88  {
93  color_gain ,
94  color_gamma ,
95  color_hue ,
102  f200_accuracy ,
118  r200_lr_gain ,
146  fisheye_gain ,
147  fisheye_strobe ,
157  };
158 
160  enum class frame_metadata
161  {
163  actual_fps
164  };
165 
169  enum class capabilities : int32_t
170  {
171  depth,
172  color,
173  infrared,
174  infrared2,
175  fish_eye,
176  motion_events,
178  adapter_board,
179  enumeration,
180  };
181 
183  enum class blob_type
184  {
186  };
187 
192  enum class camera_info {
193  device_name ,
194  serial_number ,
198  camera_type ,
199  oem_id ,
200  isp_fw_version ,
201  content_version ,
202  module_version ,
204  build_date ,
206  program_date ,
208  emitter_type ,
209  focus_value ,
210  lens_type ,
211  third_lens_type ,
216  };
217 
219  enum class source : uint8_t
220  {
221  video ,
222  motion_data,
223  all_sources,
224  };
225 
227  enum class event : uint8_t
228  {
229  event_imu_accel ,
230  event_imu_gyro ,
236  };
237 
239 
242  enum class timestamp_domain
243  {
244  camera,
246  };
247 
248  struct float2 { float x,y; };
249  struct float3 { float x,y,z; };
250 
253  {
254  float hfov() const { return (atan2f(ppx + 0.5f, fx) + atan2f(width - (ppx + 0.5f), fx)) * 57.2957795f; }
255  float vfov() const { return (atan2f(ppy + 0.5f, fy) + atan2f(height - (ppy + 0.5f), fy)) * 57.2957795f; }
257 
258  // Helpers for mapping between pixel coordinates and texture coordinates
259  float2 pixel_to_texcoord(const float2 & pixel) const { return {(pixel.x+0.5f)/width, (pixel.y+0.5f)/height}; }
260  float2 texcoord_to_pixel(const float2 & coord) const { return {coord.x*width - 0.5f, coord.y*height - 0.5f}; }
261 
262  // Helpers for mapping from image coordinates into 3D space
263  float3 deproject(const float2 & pixel, float depth) const { float3 point = {}; rs_deproject_pixel_to_point(&point.x, this, &pixel.x, depth); return point; }
264  float3 deproject_from_texcoord(const float2 & coord, float depth) const { return deproject(texcoord_to_pixel(coord), depth); }
265 
266  // Helpers for mapping from 3D space into image coordinates
267  float2 project(const float3 & point) const { float2 pixel = {}; rs_project_point_to_pixel(&pixel.x, this, &point.x); return pixel; }
268  float2 project_to_texcoord(const float3 & point) const { return pixel_to_texcoord(project(point)); }
269 
270  bool operator == (const intrinsics & r) const { return memcmp(this, &r, sizeof(r)) == 0; }
271 
272  };
273 
276  {
278  };
279 
282  {
283  bool is_identity() const { return (rotation[0] == 1) && (rotation[4] == 1) && (translation[0] == 0) && (translation[1] == 0) && (translation[2] == 0); }
284  float3 transform(const float3 & point) const { float3 p = {}; rs_transform_point_to_point(&p.x, this, &point.x); return p; }
285  };
286 
289  {
292  };
293 
296  {
299  };
300 
301  class context;
302  class device;
303 
304  class error : public std::runtime_error
305  {
306  std::string function, args;
307  public:
308  error(rs_error * err) : std::runtime_error(rs_get_error_message(err))
309  {
310  function = (nullptr != rs_get_failed_function(err)) ? rs_get_failed_function(err) : std::string();
311  args = (nullptr != rs_get_failed_args(err)) ? rs_get_failed_args(err) : std::string();
312  rs_free_error(err);
313  }
314  const std::string & get_failed_function() const { return function; }
315  const std::string & get_failed_args() const { return args; }
316  static void handle(rs_error * e) { if(e) throw error(e); }
317  };
319  class context
320  {
322  context(const context &) = delete;
323  context & operator = (const context &) = delete;
324  public:
325 
328  {
329  rs_error * e = nullptr;
330  handle = rs_create_context(RS_API_VERSION, &e);
331  error::handle(e);
332  }
333 
334  explicit context(rs_context * handle) : handle(handle) {}
335 
337  {
338  rs_delete_context(handle, nullptr);
339  }
340 
343  int get_device_count() const
344  {
345  rs_error * e = nullptr;
346  auto r = rs_get_device_count(handle, &e);
347  error::handle(e);
348  return r;
349  }
350 
355  {
356  rs_error * e = nullptr;
357  auto r = rs_get_device(handle, index, &e);
358  error::handle(e);
359  return (device *)r;
360  }
361  };
362 
364  {
365  std::function<void(motion_data)> on_event_function;
366  public:
367  explicit motion_callback(std::function<void(motion_data)> on_event) : on_event_function(on_event) {}
368 
369  void on_event(rs_motion_data e) override
370  {
371  on_event_function(motion_data(e));
372  }
373 
374  void release() override { delete this; }
375  };
376 
378  {
379  std::function<void(timestamp_data)> on_event_function;
380  public:
381  explicit timestamp_callback(std::function<void(timestamp_data)> on_event) : on_event_function(on_event) {}
382 
384  {
385  on_event_function(std::move(data));
386  }
387 
388  void release() override { delete this; }
389  };
390 
392  class frame
393  {
396 
397  frame(const frame &) = delete;
398 
399  public:
400  frame() : device(nullptr), frame_ref(nullptr) {}
401  frame(rs_device * device, rs_frame_ref * frame_ref) : device(device), frame_ref(frame_ref) {}
402  frame(frame&& other) : device(other.device), frame_ref(other.frame_ref) { other.frame_ref = nullptr; }
404  {
405  swap(other);
406  return *this;
407  }
408  void swap(frame& other)
409  {
410  std::swap(device, other.device);
411  std::swap(frame_ref, other.frame_ref);
412  }
413 
415  {
416  if (device && frame_ref)
417  {
418  rs_error * e = nullptr;
419  rs_release_frame(device, frame_ref, &e);
420  error::handle(e);
421  }
422  }
423 
426  double get_timestamp() const
427  {
428  rs_error * e = nullptr;
429  auto r = rs_get_detached_frame_timestamp(frame_ref, &e);
430  error::handle(e);
431  return r;
432  }
433 
437  {
438  rs_error * e = nullptr;
439  auto r = rs_get_detached_frame_timestamp_domain(frame_ref, &e);
440  error::handle(e);
441  return static_cast<timestamp_domain>(r);
442  }
443 
448  {
449  rs_error * e = nullptr;
450  auto r = rs_get_detached_frame_metadata(frame_ref, (rs_frame_metadata)frame_metadata, &e);
451  error::handle(e);
452  return r;
453  }
454 
459  {
460  rs_error * e = nullptr;
461  auto r = rs_supports_frame_metadata(frame_ref, frame_metadata, &e);
462  error::handle(e);
463  return r != 0;
464  }
465 
468  unsigned long long get_frame_number() const
469  {
470  rs_error * e = nullptr;
471  auto r = rs_get_detached_frame_number(frame_ref, &e);
472  error::handle(e);
473  return r;
474  }
475 
478  const void * get_data() const
479  {
480  rs_error * e = nullptr;
481  auto r = rs_get_detached_frame_data(frame_ref, &e);
482  error::handle(e);
483  return r;
484  }
485 
487  int get_width() const
488  {
489  rs_error * e = nullptr;
490  auto r = rs_get_detached_frame_width(frame_ref, &e);
491  error::handle(e);
492  return r;
493  }
494 
496  int get_height() const
497  {
498  rs_error * e = nullptr;
499  auto r = rs_get_detached_frame_height(frame_ref, &e);
500  error::handle(e);
501  return r;
502  }
503 
505  int get_framerate() const
506  {
507  rs_error * e = nullptr;
508  auto r = rs_get_detached_framerate(frame_ref, &e);
509  error::handle(e);
510  return r;
511  }
512 
514  int get_stride() const
515  {
516  rs_error * e = nullptr;
517  auto r = rs_get_detached_frame_stride(frame_ref, &e);
518  error::handle(e);
519  return r;
520  }
521 
524  int get_bpp() const
525  {
526  rs_error * e = nullptr;
527  auto r = rs_get_detached_frame_bpp(frame_ref, &e);
528  error::handle(e);
529  return r;
530  }
531 
535  {
536  rs_error * e = nullptr;
537  auto r = rs_get_detached_frame_format(frame_ref, &e);
538  error::handle(e);
539  return static_cast<format>(r);
540  }
541 
545  {
546  rs_error * e = nullptr;
547  auto s = rs_get_detached_frame_stream_type(frame_ref, &e);
548  error::handle(e);
549  return static_cast<stream>(s);
550  }
551  };
552 
554  {
555  std::function<void(frame)> on_frame_function;
556  public:
557  explicit frame_callback(std::function<void(frame)> on_frame) : on_frame_function(on_frame) {}
558 
559  void on_frame(rs_device * device, rs_frame_ref * fref) override
560  {
561  on_frame_function(std::move(frame(device, fref)));
562  }
563 
564  void release() override { delete this; }
565  };
567  class device
568  {
569  device() = delete;
570  device(const device &) = delete;
571  device & operator = (const device &) = delete;
572  ~device() = delete;
573 
574 
575  public:
578  const char * get_name() const
579  {
580  rs_error * e = nullptr;
581  auto r = rs_get_device_name((const rs_device *)this, &e);
582  error::handle(e);
583  return r;
584  }
585 
588  const char * get_serial() const
589  {
590  rs_error * e = nullptr;
591  auto r = rs_get_device_serial((const rs_device *)this, &e);
592  error::handle(e);
593  return r;
594  }
595 
598  const char * get_usb_port_id() const
599  {
600  rs_error * e = nullptr;
601  auto r = rs_get_device_usb_port_id((const rs_device *)this, &e);
602  error::handle(e);
603  return r;
604  }
605 
608  const char * get_firmware_version() const
609  {
610  rs_error * e = nullptr;
611  auto r = rs_get_device_firmware_version((const rs_device *)this, &e);
612  error::handle(e);
613  return r;
614  }
615 
618  const char * get_info(camera_info info) const
619  {
620  rs_error * e = nullptr;
621  auto r = rs_get_device_info((const rs_device *)this, (rs_camera_info)info, &e);
622  error::handle(e);
623  return r;
624  }
625 
630  extrinsics get_extrinsics(stream from_stream, stream to_stream) const
631  {
632  rs_error * e = nullptr;
633  extrinsics extrin;
634  rs_get_device_extrinsics((const rs_device *)this, (rs_stream)from_stream, (rs_stream)to_stream, &extrin, &e);
635  error::handle(e);
636  return extrin;
637  }
638 
643  {
644  rs_error * e = nullptr;
645  extrinsics extrin;
646  rs_get_motion_extrinsics_from((const rs_device *)this, (rs_stream)from_stream, &extrin, &e);
647  error::handle(e);
648  return extrin;
649  }
650 
653  float get_depth_scale() const
654  {
655  rs_error * e = nullptr;
656  auto r = rs_get_device_depth_scale((const rs_device *)this, &e);
657  error::handle(e);
658  return r;
659  }
660 
665  {
666  rs_error * e = nullptr;
667  auto r = rs_device_supports_option((const rs_device *)this, (rs_option)option, &e);
668  error::handle(e);
669  return r != 0;
670  }
671 
676  {
677  rs_error * e = nullptr;
678  auto r = rs_get_stream_mode_count((const rs_device *)this, (rs_stream)stream, &e);
679  error::handle(e);
680  return r;
681  }
682 
690  void get_stream_mode(stream stream, int index, int & width, int & height, format & format, int & framerate) const
691  {
692  rs_error * e = nullptr;
693  rs_get_stream_mode((const rs_device *)this, (rs_stream)stream, index, &width, &height, (rs_format *)&format, &framerate, &e);
694  error::handle(e);
695  }
696 
705  {
706  rs_error * e = nullptr;
707  rs_enable_stream_ex((rs_device *)this, (rs_stream)stream, width, height, (rs_format)format, framerate, (rs_output_buffer_format)output_buffer_type, &e);
708  error::handle(e);
709  }
710 
715  {
716  rs_error * e = nullptr;
717  rs_enable_stream_preset((rs_device *)this, (rs_stream)stream, (rs_preset)preset, &e);
718  error::handle(e);
719  }
720 
724  {
725  rs_error * e = nullptr;
726  rs_disable_stream((rs_device *)this, (rs_stream)stream, &e);
727  error::handle(e);
728  }
729 
734  {
735  rs_error * e = nullptr;
736  auto r = rs_is_stream_enabled((const rs_device *)this, (rs_stream)stream, &e);
737  error::handle(e);
738  return r != 0;
739  }
740 
745  {
746  rs_error * e = nullptr;
747  auto r = rs_get_stream_width((const rs_device *)this, (rs_stream)stream, &e);
748  error::handle(e);
749  return r;
750  }
751 
756  {
757  rs_error * e = nullptr;
758  auto r = rs_get_stream_height((const rs_device *)this, (rs_stream)stream, &e);
759  error::handle(e);
760  return r;
761  }
762 
767  {
768  rs_error * e = nullptr;
769  auto r = rs_get_stream_format((const rs_device *)this, (rs_stream)stream, &e);
770  error::handle(e);
771  return (format)r;
772  }
773 
778  {
779  rs_error * e = nullptr;
780  auto r = rs_get_stream_framerate((const rs_device *)this, (rs_stream)stream, &e);
781  error::handle(e);
782  return r;
783  }
784 
789  {
790  rs_error * e = nullptr;
791  intrinsics intrin;
792  rs_get_stream_intrinsics((const rs_device *)this, (rs_stream)stream, &intrin, &e);
793  error::handle(e);
794  return intrin;
795  }
796 
800  {
801  rs_error * e = nullptr;
803  rs_get_motion_intrinsics((const rs_device *)this, &intrinsics, &e);
804  error::handle(e);
805  return intrinsics;
806  }
807 
817  void set_frame_callback(rs::stream stream, std::function<void(frame)> frame_handler)
818  {
819  rs_error * e = nullptr;
820  rs_set_frame_callback_cpp((rs_device *)this, (rs_stream)stream, new frame_callback(frame_handler), &e);
821  error::handle(e);
822  }
823 
837 
841  void enable_motion_tracking(std::function<void(motion_data)> motion_handler, std::function<void(timestamp_data)> timestamp_handler)
842  {
843  rs_error * e = nullptr;
845  error::handle(e);
846  }
847 
854  {
855  rs_error * e = nullptr;
857  error::handle(e);
858  }
859 
862  {
863  rs_error * e = nullptr;
865  error::handle(e);
866  }
867 
870  {
871  rs_error * e = nullptr;
872  auto result = rs_is_motion_tracking_active((rs_device *)this,&e);
873  error::handle(e);
874  return result;
875  }
876 
877 
880  {
881  rs_error * e = nullptr;
882  rs_start_source((rs_device *)this, (rs_source)source, &e);
883  error::handle(e);
884  }
885 
888  {
889  rs_error * e = nullptr;
890  rs_stop_source((rs_device *)this, (rs_source)source, &e);
891  error::handle(e);
892  }
893 
896  bool is_streaming() const
897  {
898  rs_error * e = nullptr;
899  auto r = rs_is_device_streaming((const rs_device *)this, &e);
900  error::handle(e);
901  return r != 0;
902  }
903 
909  void get_option_range(option option, double & min, double & max, double & step)
910  {
911  rs_error * e = nullptr;
912  rs_get_device_option_range((rs_device *)this, (rs_option)option, &min, &max, &step, &e);
913  error::handle(e);
914  }
915 
922  void get_option_range(option option, double & min, double & max, double & step, double & def)
923  {
924  rs_error * e = nullptr;
925  rs_get_device_option_range_ex((rs_device *)this, (rs_option)option, &min, &max, &step, &def, &e);
926  error::handle(e);
927  }
928 
933  void get_options(const option * options, size_t count, double * values)
934  {
935  rs_error * e = nullptr;
936  rs_get_device_options((rs_device *)this, (const rs_option *)options, (unsigned int)count, values, &e);
937  error::handle(e);
938  }
939 
944  void set_options(const option * options, size_t count, const double * values)
945  {
946  rs_error * e = nullptr;
947  rs_set_device_options((rs_device *)this, (const rs_option *)options, (unsigned int)count, values, &e);
948  error::handle(e);
949  }
950 
955  {
956  rs_error * e = nullptr;
957  auto r = rs_get_device_option((rs_device *)this, (rs_option)option, &e);
958  error::handle(e);
959  return r;
960  }
961 
966  {
967  rs_error * e = nullptr;
968  auto r = rs_get_device_option_description((rs_device *)this, (rs_option)option, &e);
969  error::handle(e);
970  return r;
971  }
972 
977  {
978  rs_error * e = nullptr;
979  rs_set_device_option((rs_device *)this, (rs_option)option, value, &e);
980  error::handle(e);
981  }
982 
986  {
987  rs_error * e = nullptr;
988  rs_wait_for_frames((rs_device *)this, &e);
989  error::handle(e);
990  }
991 
995  {
996  rs_error * e = nullptr;
997  auto r = rs_poll_for_frames((rs_device *)this, &e);
998  error::handle(e);
999  return r != 0;
1000  }
1001 
1005  bool supports(capabilities capability) const
1006  {
1007  rs_error * e = nullptr;
1008  auto r = rs_supports((rs_device *)this, (rs_capabilities)capability, &e);
1009  error::handle(e);
1010  return r? true: false;
1011  }
1012 
1013 
1017  bool supports(camera_info info_param) const
1018  {
1019  rs_error * e = nullptr;
1020  auto r = rs_supports_camera_info((rs_device *)this, (rs_camera_info)info_param, &e);
1021  error::handle(e);
1022  return r ? true : false;
1023  }
1024 
1028  double get_frame_timestamp(stream stream) const
1029  {
1030  rs_error * e = nullptr;
1031  auto r = rs_get_frame_timestamp((const rs_device *)this, (rs_stream)stream, &e);
1032  error::handle(e);
1033  return r;
1034  }
1035 
1039  unsigned long long get_frame_number(stream stream) const
1040  {
1041  rs_error * e = nullptr;
1042  auto r = rs_get_frame_number((const rs_device *)this, (rs_stream)stream, &e);
1043  error::handle(e);
1044  return r;
1045  }
1046 
1050  const void * get_frame_data(stream stream) const
1051  {
1052  rs_error * e = nullptr;
1053  auto r = rs_get_frame_data((const rs_device *)this, (rs_stream)stream, &e);
1054  error::handle(e);
1055  return r;
1056  }
1057 
1063  {
1064  rs_error * e = nullptr;
1065  rs_send_blob_to_device((rs_device *)this, (rs_blob_type)type, data, size, &e);
1066  error::handle(e);
1067  }
1068  };
1069 
1070  inline std::ostream & operator << (std::ostream & o, stream stream) { return o << rs_stream_to_string((rs_stream)stream); }
1071  inline std::ostream & operator << (std::ostream & o, format format) { return o << rs_format_to_string((rs_format)format); }
1072  inline std::ostream & operator << (std::ostream & o, preset preset) { return o << rs_preset_to_string((rs_preset)preset); }
1073  inline std::ostream & operator << (std::ostream & o, distortion distortion) { return o << rs_distortion_to_string((rs_distortion)distortion); }
1074  inline std::ostream & operator << (std::ostream & o, option option) { return o << rs_option_to_string((rs_option)option); }
1075  inline std::ostream & operator << (std::ostream & o, capabilities capability) { return o << rs_capabilities_to_string((rs_capabilities)capability); }
1076  inline std::ostream & operator << (std::ostream & o, source src) { return o << rs_source_to_string((rs_source)src); }
1077  inline std::ostream & operator << (std::ostream & o, event evt) { return o << rs_event_to_string((rs_event_source)evt); }
1078 
1080  enum class log_severity : int32_t
1081  {
1082  debug = 0,
1083  info = 1,
1084  warn = 2,
1085  error = 3,
1086  fatal = 4,
1087  none = 5,
1088  };
1089 
1091  {
1092  std::function<void(log_severity, const char *)> on_event_function;
1093  public:
1094  explicit log_callback(std::function<void(log_severity, const char *)> on_event) : on_event_function(on_event) {}
1095 
1096  void on_event(rs_log_severity severity, const char * message) override
1097  {
1098  on_event_function((log_severity)severity, message);
1099  }
1100 
1101  void release() override { delete this; }
1102  };
1103 
1104  inline void log_to_console(log_severity min_severity)
1105  {
1106  rs_error * e = nullptr;
1107  rs_log_to_console((rs_log_severity)min_severity, &e);
1108  error::handle(e);
1109  }
1110 
1111  inline void log_to_file(log_severity min_severity, const char * file_path)
1112  {
1113  rs_error * e = nullptr;
1114  rs_log_to_file((rs_log_severity)min_severity, file_path, &e);
1115  error::handle(e);
1116  }
1117 
1118  inline void log_to_callback(log_severity min_severity, std::function<void(log_severity, const char *)> callback)
1119  {
1120  rs_error * e = nullptr;
1121  rs_log_to_callback_cpp((rs_log_severity)min_severity, new log_callback(callback), &e);
1122  error::handle(e);
1123  }
1124 
1125  // Additional utilities
1128  inline void apply_ivcam_preset(device * device, int preset) { rs_apply_ivcam_preset((rs_device *)device, (rs_ivcam_preset)preset); } // duplicate for better backward compatibility with existing applications
1129 }
1130 #endif
float2 project_to_texcoord(const float3 &point) const
Definition: rs.hpp:268
int rs_get_stream_width(const rs_device *device, rs_stream stream, rs_error **error)
Retrieves the width in pixels of a specific stream, equivalent to the width field from the stream&#39;s i...
Definition: rs.cpp:257
void log_to_console(log_severity min_severity)
Definition: rs.hpp:1104
Provides convenience methods relating to devices.
Definition: rs.hpp:567
intrinsics get_stream_intrinsics(stream stream) const
Retrieves intrinsic camera parameters for specific stream.
Definition: rs.hpp:788
#define RS_API_VERSION
Definition: rs.h:28
static void rs_apply_ivcam_preset(rs_device *device, rs_ivcam_preset preset)
Definition: rsutil.h:89
motion_data(rs_motion_data orig)
Definition: rs.hpp:297
void timestamp_callback(rs_device *, rs_timestamp_data, void *)
int get_width() const
Returns image width in pixels.
Definition: rs.hpp:487
int rs_supports(rs_device *device, rs_capabilities capability, rs_error **error)
Determines device capabilities.
Definition: rs.cpp:442
void rs_get_motion_extrinsics_from(const rs_device *device, rs_stream from, rs_extrinsics *extrin, rs_error **error)
Retrieves extrinsic transformation between specific stream and the motion module. ...
Definition: rs.cpp:173
void rs_get_stream_intrinsics(const rs_device *device, rs_stream stream, rs_intrinsics *intrin, rs_error **error)
Retrieves intrinsic camera parameters for a specific stream.
Definition: rs.cpp:289
void enable_stream(stream stream, int width, int height, format format, int framerate, output_buffer_format output_buffer_type=output_buffer_format::continous)
Enables specific stream and requests specific properties.
Definition: rs.hpp:704
int get_stride() const
Retrieves frame stride, meaning the actual line width in memory in bytes (not the logical image width...
Definition: rs.hpp:514
const char * rs_stream_to_string(rs_stream stream)
Definition: rs.cpp:754
void rs_start_source(rs_device *device, rs_source source, rs_error **error)
Begins streaming on all enabled streams for this device.
Definition: rs.cpp:390
void rs_disable_motion_tracking(rs_device *device, rs_error **error)
Disables motion-tracking handlers.
Definition: rs.cpp:366
void rs_log_to_callback_cpp(rs_log_severity min_severity, rs_log_callback *callback, rs_error **error)
Starts logging to user-provided callback.
Definition: rs.cpp:331
const char * rs_source_to_string(rs_source source)
Definition: rs.cpp:760
float vfov() const
Definition: rs.hpp:255
const std::string & get_failed_args() const
Definition: rs.hpp:315
Definition: rs.cpp:16
int rs_supports_frame_metadata(const rs_frame_ref *frame, rs_frame_metadata frame_metadata, rs_error **error)
Determines device metadata.
Definition: rs.cpp:466
float3 deproject_from_texcoord(const float2 &coord, float depth) const
Definition: rs.hpp:264
std::function< void(log_severity, const char *)> on_event_function
Definition: rs.hpp:1092
float y
Definition: rs.hpp:248
extrinsics get_extrinsics(stream from_stream, stream to_stream) const
Retrieves extrinsic transformation between viewpoints of two different streams.
Definition: rs.hpp:630
rs_error * e
int rs_get_device_count(const rs_context *context, rs_error **error)
Determines number of connected devices.
Definition: rs.cpp:113
std::ostream & operator<<(std::ostream &o, stream stream)
Definition: rs.hpp:1070
frame_metadata
Types of value provided from the device with each frame.
Definition: rs.hpp:160
GLint GLint GLsizei GLsizei height
Definition: glext.h:112
rs_context * handle
Definition: rs.hpp:321
Cross-stream extrinsics: encode the topology describing how the different devices are connected...
Definition: rs.hpp:281
const char * get_firmware_version() const
Retrieves version of firmware currently installed on device.
Definition: rs.hpp:608
rs_blob_type
Proprietary formats for direct communication with device firmware.
Definition: rs.h:228
GLint GLint GLint GLint GLint GLint y
Definition: glext.h:114
void rs_log_to_console(rs_log_severity min_severity, rs_error **error)
Starts logging to console.
Definition: rs.cpp:769
log_severity
Severity of the librealsense logger.
Definition: rs.hpp:1080
rs_format rs_get_detached_frame_format(const rs_frame_ref *frame, rs_error **error)
Retrieves frame format.
Definition: rs.cpp:555
void rs_enable_stream_ex(rs_device *device, rs_stream stream, int width, int height, rs_format format, int framerate, rs_output_buffer_format output_format, rs_error **error)
Enables a specific stream and requests specific properties.
Definition: rs.cpp:207
void rs_get_device_options(rs_device *device, const rs_option *options, unsigned int count, double *values, rs_error **error)
Efficiently retrieves the value of an arbitrary number of options, using minimal hardware IO...
void motion_callback(rs_device *, rs_motion_data, void *)
void rs_set_device_options(rs_device *device, const rs_option *options, unsigned int count, const double *values, rs_error **error)
Efficiently sets the value of an arbitrary number of options, using minimal hardware IO...
rs_timestamp_domain rs_get_detached_frame_timestamp_domain(const rs_frame_ref *frame, rs_error **error)
Retrieves timestamp domain from frame reference.
Definition: rs.cpp:505
GLuint GLsizei const GLchar * message
Definition: glext.h:2482
const char * get_info(camera_info info) const
Retrieves camera-specific information such as versions of various components.
Definition: rs.hpp:618
void on_event(rs_timestamp_data data) override
Definition: rs.hpp:383
unsigned long long rs_get_detached_frame_number(const rs_frame_ref *frame, rs_error **error)
Retrieves frame number from frame reference.
Definition: rs.cpp:570
double get_frame_metadata(rs_frame_metadata frame_metadata) const
Definition: rs.hpp:447
void get_option_range(option option, double &min, double &max, double &step)
Retrieves available range of values of supported option.
Definition: rs.hpp:909
double rs_get_frame_timestamp(const rs_device *device, rs_stream stream, rs_error **error)
Retrieves time at which the latest frame on a stream was captured.
Definition: rs.cpp:474
void on_event(rs_motion_data e) override
Definition: rs.hpp:369
const void * rs_get_frame_data(const rs_device *device, rs_stream stream, rs_error **error)
Retrieves the contents of the latest frame on a stream.
Definition: rs.cpp:490
int rs_is_device_streaming(const rs_device *device, rs_error **error)
Determines if the device is currently streaming.
Definition: rs.cpp:413
GLsizei const GLchar *const * string
Definition: glext.h:683
Video stream intrinsics.
Definition: rs.hpp:252
bool supports(camera_info info_param) const
Determines device capabilities.
Definition: rs.hpp:1017
const char * get_usb_port_id() const
Retrieves USB port number of device.
Definition: rs.hpp:598
int get_stream_width(stream stream) const
Retrieves width, in pixels, of a specific stream, equivalent to the width field from the stream&#39;s int...
Definition: rs.hpp:744
Motion data from gyroscope and accelerometer from the microcontroller.
Definition: rs.hpp:295
void enable_stream(stream stream, preset preset)
Enables specific stream and requests properties using preset.
Definition: rs.hpp:714
void apply_depth_control_preset(device *device, int preset)
Definition: rs.hpp:1126
const char * rs_distortion_to_string(rs_distortion distortion)
Definition: rs.cpp:757
GLint GLint GLsizei GLsizei GLsizei depth
Definition: glext.h:112
void log_to_callback(log_severity min_severity, std::function< void(log_severity, const char *)> callback)
Definition: rs.hpp:1118
float2 pixel_to_texcoord(const float2 &pixel) const
Definition: rs.hpp:259
void rs_delete_context(rs_context *context, rs_error **error)
Frees the relevant context object.
Definition: rs.cpp:106
frame(frame &&other)
Definition: rs.hpp:402
camera_info
Read-only strings that can be queried from the device.
Definition: rs.hpp:192
void enable_motion_tracking(std::function< void(motion_data)> motion_handler)
Sets the callback for motion module event.
Definition: rs.hpp:853
void rs_set_device_option(rs_device *device, rs_option option, double value, rs_error **error)
Sets the current value of a single option.
Definition: rs.cpp:712
const char * rs_get_device_name(const rs_device *device, rs_error **error)
Retrieves human-readable device model string.
Definition: rs.cpp:128
rs_option
Defines general configuration controls.
Definition: rs.h:128
const char * rs_get_error_message(const rs_error *error)
Returns static pointer to error message.
Definition: rs.cpp:751
float rs_get_device_depth_scale(const rs_device *device, rs_error **error)
Retrieves mapping between the units of the depth image and meters.
Definition: rs.cpp:420
GLenum src
Definition: glext.h:1735
rs_output_buffer_format
Output buffer format: sets how librealsense works with frame memory.
Definition: rs.h:73
const void * get_frame_data(stream stream) const
Retrieves contents of latest frame on a stream.
Definition: rs.hpp:1050
static void rs_project_point_to_pixel(float pixel[2], const struct rs_intrinsics *intrin, const float point[3])
Definition: rsutil.h:11
timestamp_data(rs_timestamp_data orig)
Definition: rs.hpp:290
const char * rs_get_device_usb_port_id(const rs_device *device, rs_error **error)
Retrieves the USB port number of the device.
Definition: rs.cpp:149
GLuint coord
Definition: glext.h:5871
void rs_log_to_file(rs_log_severity min_severity, const char *file_path, rs_error **error)
Starts logging to file.
Definition: rs.cpp:775
static void rs_transform_point_to_point(float to_point[3], const struct rs_extrinsics *extrin, const float from_point[3])
Definition: rsutil.h:55
context(rs_context *handle)
Definition: rs.hpp:334
format get_stream_format(stream stream) const
Retrieves pixel format for specific stream.
Definition: rs.hpp:766
rs_stream rs_get_detached_frame_stream_type(const rs_frame_ref *frame, rs_error **error)
Retrieves frame stream type.
Definition: rs.cpp:562
void rs_get_stream_mode(const rs_device *device, rs_stream stream, int index, int *width, int *height, rs_format *format, int *framerate, rs_error **error)
Determines the properties of a specific streaming mode.
Definition: rs.cpp:198
timestamp_domain get_frame_timestamp_domain() const
Definition: rs.hpp:436
event
Source device that triggered specific timestamp event from the motion module.
Definition: rs.hpp:227
void send_blob_to_device(rs::blob_type type, void *data, int size)
Sends device-specific data to device.
Definition: rs.hpp:1062
bool is_identity() const
Definition: rs.hpp:283
float x
Definition: rs.hpp:248
int rs_get_stream_mode_count(const rs_device *device, rs_stream stream, rs_error **error)
Determines the number of streaming modes available for a given stream.
Definition: rs.cpp:190
frame & operator=(frame other)
Definition: rs.hpp:403
int get_stream_mode_count(stream stream) const
Determines number of streaming modes available for given stream.
Definition: rs.hpp:675
int rs_poll_for_frames(rs_device *device, rs_error **error)
Checks if new frames are available, without blocking.
Definition: rs.cpp:435
void apply_ivcam_preset(device *device, rs_ivcam_preset preset)
Definition: rs.hpp:1127
frame_callback(std::function< void(frame)> on_frame)
Definition: rs.hpp:557
void release() override
Definition: rs.hpp:388
Motion device intrinsics: scale, bias, and variances.
Definition: rs.hpp:275
void stop(rs::source source=rs::source::video)
Ends streaming on all streams for this device.
Definition: rs.hpp:887
rs_frame_ref * frame_ref
Definition: rs.hpp:395
const char * rs_get_failed_function(const rs_error *error)
Returns static pointer to name of a failing function in case of error.
Definition: rs.cpp:749
std::function< void(motion_data)> on_event_function
Definition: rs.hpp:365
rs_format rs_get_stream_format(const rs_device *device, rs_stream stream, rs_error **error)
Retrieves the pixel format for a specific stream.
Definition: rs.cpp:273
rs_context * rs_create_context(int api_version, rs_error **error)
Creates RealSense context that is required for the rest of the API.
Definition: rs.cpp:75
int get_height() const
Returns image height in pixels.
Definition: rs.hpp:496
static void rs_apply_depth_control_preset(rs_device *device, int preset)
Definition: rsutil.h:63
const char * rs_capabilities_to_string(rs_capabilities capability)
Definition: rs.cpp:759
double rs_get_device_option(rs_device *device, rs_option option, rs_error **error)
Retrieves the current value of a single option.
Definition: rs.cpp:694
void rs_get_device_option_range_ex(rs_device *device, rs_option option, double *min, double *max, double *step, double *def, rs_error **error)
Retrieves the available range of values for a supported option.
Definition: rs.cpp:645
int rs_get_detached_frame_bpp(const rs_frame_ref *frame, rs_error **error)
Retrieves frame bits per pixel.
Definition: rs.cpp:548
stream
Streams are different types of data provided by RealSense devices.
Definition: rs.hpp:24
timestamp_domain
Specifies the clock in relation to which the frame timestamp was measured.
Definition: rs.hpp:242
void rs_disable_stream(rs_device *device, rs_stream stream, rs_error **error)
Disables a specific stream.
Definition: rs.cpp:241
int get_stream_height(stream stream) const
Retrieves height, in pixels, of a specific stream, equivalent to the height field from the stream&#39;s i...
Definition: rs.hpp:755
GLuint index
Definition: glext.h:655
int rs_get_detached_framerate(const rs_frame_ref *frame, rs_error **error)
Retrieves frame intrinsic frame rate.
Definition: rs.cpp:533
void frame_callback(rs_device *dev, rs_frame_ref *frame, void *user)
void rs_release_frame(rs_device *device, rs_frame_ref *frame, rs_error **error)
Releases frame handle.
Definition: rs.cpp:577
void set_options(const option *options, size_t count, const double *values)
Efficiently sets value of arbitrary number of options, using minimal hardware IO. ...
Definition: rs.hpp:944
GLuint GLuint GLsizei count
Definition: glext.h:111
Motion data from gyroscope and accelerometer from the microcontroller.
Definition: rs.h:347
bool is_stream_enabled(stream stream) const
Determines if specific stream is enabled.
Definition: rs.hpp:733
void rs_get_device_extrinsics(const rs_device *device, rs_stream from_stream, rs_stream to_stream, rs_extrinsics *extrin, rs_error **error)
Retrieves extrinsic transformation between the viewpoints of two different streams.
Definition: rs.cpp:163
error(rs_error *err)
Definition: rs.hpp:308
Context.
Definition: rs.hpp:319
void disable_motion_tracking(void)
Disables events polling.
Definition: rs.hpp:861
rs_camera_info
Read-only strings that can be queried from the device.
Definition: rs.h:237
void swap(frame &other)
Definition: rs.hpp:408
GLfloat f
Definition: glext.h:1868
int rs_device_supports_option(const rs_device *device, rs_option option, rs_error **error)
Determines if the device allows a specific option to be queried and set.
Definition: rs.cpp:182
Motion module intrinsics: includes accelerometer and gyroscope intrinsics structs of type rs_motion_d...
Definition: rs.h:325
format get_format() const
Retrieves frame format.
Definition: rs.hpp:534
const char * get_name() const
Retrieves human-readable device model string.
Definition: rs.hpp:578
format
Formats: defines how each stream can be encoded. rs_format specifies how a frame is represented in me...
Definition: rs.hpp:42
auto timestamp_handler
void rs_send_blob_to_device(rs_device *device, rs_blob_type type, void *data, int size, rs_error **error)
Sends arbitrary binary data to the device.
Definition: rs.cpp:731
void get_stream_mode(stream stream, int index, int &width, int &height, format &format, int &framerate) const
Determines properties of specific streaming mode.
Definition: rs.hpp:690
int rs_get_detached_frame_height(const rs_frame_ref *frame, rs_error **error)
Retrieves frame intrinsic height.
Definition: rs.cpp:526
void start(rs::source source=rs::source::video)
Begins streaming on all enabled streams for this device.
Definition: rs.hpp:879
int get_stream_framerate(stream stream) const
Retrieves frame rate for specific stream.
Definition: rs.hpp:777
const char * rs_get_device_firmware_version(const rs_device *device, rs_error **error)
Retrieves the version of the firmware currently installed on the device.
Definition: rs.cpp:156
void enable_motion_tracking(std::function< void(motion_data)> motion_handler, std::function< void(timestamp_data)> timestamp_handler)
Sets callback for motion module event.
Definition: rs.hpp:841
float2 texcoord_to_pixel(const float2 &coord) const
Definition: rs.hpp:260
void on_event(rs_log_severity severity, const char *message) override
Definition: rs.hpp:1096
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const void * data
Definition: glext.h:223
const void * get_data() const
Definition: rs.hpp:478
double get_option(option option)
Retrieves current value of single option.
Definition: rs.hpp:954
Definition: rs.hpp:21
static void rs_deproject_pixel_to_point(float point[3], const struct rs_intrinsics *intrin, const float pixel[2], float depth)
Definition: rsutil.h:33
unsigned long long get_frame_number(stream stream) const
Retrieves frame number.
Definition: rs.hpp:1039
auto motion_handler
const char * rs_get_device_option_description(rs_device *device, rs_option option, rs_error **error)
Retrieves a static description of what a particular option does on given device.
Definition: rs.cpp:704
source
Allows the user to choose between available hardware subdevices.
Definition: rs.hpp:219
const char * rs_get_failed_args(const rs_error *error)
Returns static pointer to arguments of a failing function in case of error.
Definition: rs.cpp:750
rs_format
Formats: defines how each stream can be encoded.
Definition: rs.h:53
std::function< void(timestamp_data)> on_event_function
Definition: rs.hpp:379
const char * rs_event_to_string(rs_event_source event)
Definition: rs.cpp:761
void get_option_range(option option, double &min, double &max, double &step, double &def)
Retrieves available range of values of supported option.
Definition: rs.hpp:922
double rs_get_detached_frame_timestamp(const rs_frame_ref *frame, rs_error **error)
Retrieves timestamp from frame reference.
Definition: rs.cpp:498
int is_motion_tracking_active()
Checks if data acquisition is active.
Definition: rs.hpp:869
const char * rs_get_device_info(const rs_device *device, rs_camera_info info, rs_error **error)
Retrieves camera specific information, such as versions of various internal componnents.
Definition: rs.cpp:142
int get_framerate() const
Returns configured frame rate.
Definition: rs.hpp:505
void rs_stop_source(rs_device *device, rs_source source, rs_error **error)
Ends data acquisition for the specified source providers.
Definition: rs.cpp:405
distortion model() const
Definition: rs.hpp:256
int rs_get_detached_frame_width(const rs_frame_ref *frame, rs_error **error)
Retrieves frame intrinsic width in pixels.
Definition: rs.cpp:519
void release() override
Definition: rs.hpp:374
Timestamp data from the motion microcontroller.
Definition: rs.h:339
extrinsics get_motion_extrinsics_from(stream from_stream) const
Retrieves extrinsic transformation between viewpoints of specific stream and motion module...
Definition: rs.hpp:642
void log_to_file(log_severity min_severity, const char *file_path)
Definition: rs.hpp:1111
int rs_get_detached_frame_stride(const rs_frame_ref *frame, rs_error **error)
Retrieves frame stride, meaning the actual line width in memory in bytes (not the logical image width...
Definition: rs.cpp:540
unsigned long long rs_get_frame_number(const rs_device *device, rs_stream stream, rs_error **error)
Retrieves frame number.
Definition: rs.cpp:482
int rs_supports_camera_info(rs_device *device, rs_camera_info info_param, rs_error **error)
Returns true if given camera information parameter is supported by the device.
Definition: rs.cpp:450
static void handle(rs_error *e)
Definition: rs.hpp:316
GLsizei const GLfloat * value
Definition: glext.h:693
void rs_free_error(rs_error *error)
Frees memory of an error object.
Definition: rs.cpp:748
const char * get_serial() const
Retrieves unique serial number of device.
Definition: rs.hpp:588
rs_source
Source: allows you to choose between available hardware subdevices.
Definition: rs.h:90
void on_frame(rs_device *device, rs_frame_ref *fref) override
Definition: rs.hpp:559
output_buffer_format
Output buffer format: sets how librealsense works with frame memory.
Definition: rs.hpp:61
Video stream intrinsics.
Definition: rs.h:300
int rs_is_motion_tracking_active(rs_device *device, rs_error **error)
Checks if data acquisition is active.
Definition: rs.cpp:375
bool supports_option(option option) const
Determines if device allows specific option to be queried and set.
Definition: rs.hpp:664
double get_frame_timestamp(stream stream) const
Retrieves time at which the latest frame on a stream was captured.
Definition: rs.hpp:1028
blob_type
Proprietary formats for direct communication with device firmware.
Definition: rs.hpp:183
Cross-stream extrinsics: encode the topology describing how the different devices are connected...
Definition: rs.h:332
void disable_stream(stream stream)
Disables specific stream.
Definition: rs.hpp:723
void rs_get_device_option_range(rs_device *device, rs_option option, double *min, double *max, double *step, rs_error **error)
Retrieves the available range of values for a supported option.
Definition: rs.cpp:635
stream get_stream_type() const
Retrieves frame stream type.
Definition: rs.hpp:544
frame(rs_device *device, rs_frame_ref *frame_ref)
Definition: rs.hpp:401
frame()
Definition: rs.hpp:400
const char * rs_preset_to_string(rs_preset preset)
Definition: rs.cpp:756
rs_preset
Presets: general preferences that are translated by librealsense into concrete resolution and FPS...
Definition: rs.h:81
Frame.
Definition: rs.hpp:392
int rs_get_stream_framerate(const rs_device *device, rs_stream stream, rs_error **error)
Retrieves the frame rate for a specific stream.
Definition: rs.cpp:281
GLenum GLsizei GLsizei GLint * values
Definition: glext.h:1484
bool poll_for_frames()
Checks if new frames are available, without blocking.
Definition: rs.hpp:994
GLdouble s
Definition: glext.h:231
const char * rs_format_to_string(rs_format format)
Definition: rs.cpp:755
distortion
Distortion model: defines how pixel coordinates should be mapped to sensor coordinates.
Definition: rs.hpp:76
rs_stream
Streams are different types of data provided by RealSense devices.
Definition: rs.h:33
GLint GLint GLsizei width
Definition: glext.h:112
const char * rs_option_to_string(rs_option option)
Definition: rs.cpp:758
double get_timestamp() const
Definition: rs.hpp:426
float z
Definition: rs.hpp:249
void release() override
Definition: rs.hpp:564
int get_bpp() const
Retrieves bits per pixel.
Definition: rs.hpp:524
GLsizeiptr size
Definition: glext.h:532
unsigned long long get_frame_number() const
Definition: rs.hpp:468
motion_intrinsics get_motion_intrinsics() const
Retrieves intrinsic camera parameters for motion module.
Definition: rs.hpp:799
rs_log_severity
Severity of the librealsense logger.
Definition: rs.h:265
double rs_get_detached_frame_metadata(const rs_frame_ref *frame, rs_frame_metadata frame_metadata, rs_error **error)
Retrieves metadata from a frame reference.
Definition: rs.cpp:458
rs_capabilities
Specifies various capabilities of a RealSense device.
Definition: rs.h:213
void rs_set_frame_callback_cpp(rs_device *device, rs_stream stream, rs_frame_callback *callback, rs_error **error)
Sets up a frame callback that is called immediately when an image is available, with no synchronizati...
Definition: rs.cpp:315
void set_frame_callback(rs::stream stream, std::function< void(frame)> frame_handler)
Sets callback for frame arrival event.
Definition: rs.hpp:817
rs_device * rs_get_device(rs_context *context, int index, rs_error **error)
Retrieves connected device by index.
Definition: rs.cpp:120
const char * rs_get_device_serial(const rs_device *device, rs_error **error)
Retrieves unique serial number of the device.
Definition: rs.cpp:135
void rs_wait_for_frames(rs_device *device, rs_error **error)
Blocks until new frames are available.
Definition: rs.cpp:428
void rs_enable_stream_preset(rs_device *device, rs_stream stream, rs_preset preset, rs_error **error)
Enables a specific stream and requests properties using a preset.
Definition: rs.cpp:232
float get_depth_scale() const
Retrieves mapping between units of depth image and meters.
Definition: rs.hpp:653
const char * get_option_description(option option)
Retrieves device-specific option description.
Definition: rs.hpp:965
rs_distortion model
Definition: rs.h:308
bool supports_frame_metadata(rs_frame_metadata frame_metadata) const
Definition: rs.hpp:458
std::function< void(frame)> on_frame_function
Definition: rs.hpp:555
~frame()
Definition: rs.hpp:414
bool supports(capabilities capability) const
Determines device capabilities.
Definition: rs.hpp:1005
rs_distortion
Distortion model: defines how pixel coordinates should be mapped to sensor coordinates.
Definition: rs.h:99
float x
Definition: rs.hpp:249
rs_frame_metadata
Types of value provided from the device with each frame.
Definition: rs.h:203
float3 deproject(const float2 &pixel, float depth) const
Definition: rs.hpp:263
context()
Creates RealSense context that is required for the rest of the API.
Definition: rs.hpp:327
bool is_streaming() const
Determines if device is currently streaming.
Definition: rs.hpp:896
timestamp_callback(std::function< void(timestamp_data)> on_event)
Definition: rs.hpp:381
bool operator==(const float3 &a, const float3 &b)
Definition: types.h:113
rs_device * device
Definition: rs.hpp:394
device * get_device(int index)
Definition: rs.hpp:354
float3 transform(const float3 &point) const
Definition: rs.hpp:284
void set_option(option option, double value)
Sets current value of single option.
Definition: rs.hpp:976
log_callback(std::function< void(log_severity, const char *)> on_event)
Definition: rs.hpp:1094
GLfloat GLfloat p
Definition: glext.h:11539
int rs_is_stream_enabled(const rs_device *device, rs_stream stream, rs_error **error)
Determines if a specific stream is enabled.
Definition: rs.cpp:249
GLenum GLenum severity
Definition: glext.h:2478
rs_ivcam_preset
For SR300 devices: provides optimized settings (presets) for specific types of usage.
Definition: rs.h:109
const std::string & get_failed_function() const
Definition: rs.hpp:314
Timestamp data from the motion microcontroller.
Definition: rs.hpp:288
capabilities
Specifies various capabilities of a RealSense device.
Definition: rs.hpp:169
int rs_get_stream_height(const rs_device *device, rs_stream stream, rs_error **error)
Retrieves the height in pixels of a specific stream, equivalent to the height field from the stream&#39;s...
Definition: rs.cpp:265
GLdouble GLdouble GLdouble r
Definition: glext.h:247
GLuint64EXT * result
Definition: glext.h:9881
void release() override
Definition: rs.hpp:1101
GLint GLint GLint GLint GLint x
Definition: glext.h:114
rs_event_source
Source device that triggered a specific timestamp event from the motion module.
Definition: rs.h:276
const void * rs_get_detached_frame_data(const rs_frame_ref *frame, rs_error **error)
Retrieves data from frame reference.
Definition: rs.cpp:512
void get_options(const option *options, size_t count, double *values)
Efficiently retrieves value of arbitrary number of options, using minimal hardware IO...
Definition: rs.hpp:933
motion_callback(std::function< void(motion_data)> on_event)
Definition: rs.hpp:367
float2 project(const float3 &point) const
Definition: rs.hpp:267
void wait_for_frames()
Blocks until new frames are available.
Definition: rs.hpp:985
int get_device_count() const
Definition: rs.hpp:343
void rs_get_motion_intrinsics(const rs_device *device, rs_motion_intrinsics *intrinsic, rs_error **error)
Retrieves intrinsic camera parameters for a motion module.
Definition: rs.cpp:298
float hfov() const
Definition: rs.hpp:254
GLuint GLuint GLsizei GLenum type
Definition: glext.h:111
~context()
Definition: rs.hpp:336
preset
Presets: general preferences that are translated by librealsense into concrete resolution and FPS...
Definition: rs.hpp:68
void rs_enable_motion_tracking_cpp(rs_device *device, rs_motion_callback *motion_callback, rs_timestamp_callback *timestamp_callback, rs_error **error)
Enables and configures motion-tracking data handlers.
Definition: rs.cpp:352


librealsense
Author(s): Sergey Dorodnicov , Mark Horn , Reagan Lopez
autogenerated on Fri Mar 13 2020 03:16:17