Intel® RealSense™ Cross Platform API
Intel Realsense Cross-platform API
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
21namespace 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 ,
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 {
73 };
74
76 enum class distortion : int32_t
77 {
78 none ,
82 };
83
87 enum class option : int32_t
88 {
93 color_gain ,
95 color_hue ,
118 r200_lr_gain ,
146 fisheye_gain ,
157 };
158
160 enum class frame_metadata
161 {
164 };
165
169 enum class capabilities : int32_t
170 {
171 depth,
172 color,
173 infrared,
174 infrared2,
175 fish_eye,
180 };
181
183 enum class blob_type
184 {
186 };
187
192 enum class camera_info {
193 device_name ,
198 camera_type ,
199 oem_id ,
204 build_date ,
206 program_date ,
208 emitter_type ,
209 focus_value ,
210 lens_type ,
216 };
217
219 enum class source : uint8_t
220 {
221 video ,
224 };
225
227 enum class event : uint8_t
228 {
236 };
237
239
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 };
320 {
321 rs_context * handle;
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
344 {
345 rs_error * e = nullptr;
346 auto r = rs_get_device_count(handle, &e);
347 error::handle(e);
348 return r;
349 }
350
354 device * get_device(int index)
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
383 void on_event(rs_timestamp_data data) override
384 {
385 on_event_function(std::move(data));
386 }
387
388 void release() override { delete this; }
389 };
390
392 class frame
393 {
395 rs_frame_ref * frame_ref;
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;
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
704 void enable_stream(stream stream, int width, int height, format format, int framerate, output_buffer_format output_buffer_type = output_buffer_format::continous)
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;
718 error::handle(e);
719 }
720
724 {
725 rs_error * e = nullptr;
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;
844 rs_enable_motion_tracking_cpp((rs_device *)this, new motion_callback(motion_handler), new timestamp_callback(timestamp_handler), &e);
845 error::handle(e);
846 }
847
853 void enable_motion_tracking(std::function<void(motion_data)> motion_handler)
854 {
855 rs_error * e = nullptr;
856 rs_enable_motion_tracking_cpp((rs_device *)this, new motion_callback(motion_handler), new timestamp_callback([](rs::timestamp_data data) {}), &e);
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;
883 error::handle(e);
884 }
885
888 {
889 rs_error * e = nullptr;
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;
969 error::handle(e);
970 return r;
971 }
972
976 void set_option(option option, double value)
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
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
1062 void send_blob_to_device(rs::blob_type type, void * data, int size)
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
1126 inline void apply_depth_control_preset(device * device, int preset) { rs_apply_depth_control_preset((rs_device *)device, preset); }
1127 inline void apply_ivcam_preset(device * device, rs_ivcam_preset preset) { rs_apply_ivcam_preset((rs_device *)device, preset); }
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
Context.
Definition: rs.hpp:320
context(rs_context *handle)
Definition: rs.hpp:334
context()
Creates RealSense context that is required for the rest of the API.
Definition: rs.hpp:327
int get_device_count() const
Definition: rs.hpp:343
~context()
Definition: rs.hpp:336
device * get_device(int index)
Definition: rs.hpp:354
Provides convenience methods relating to devices.
Definition: rs.hpp:568
int get_stream_framerate(stream stream) const
Retrieves frame rate for specific stream.
Definition: rs.hpp:777
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
void set_option(option option, double value)
Sets current value of single option.
Definition: rs.hpp:976
const char * get_name() const
Retrieves human-readable device model string.
Definition: rs.hpp:578
void disable_stream(stream stream)
Disables specific stream.
Definition: rs.hpp:723
int is_motion_tracking_active()
Checks if data acquisition is active
Definition: rs.hpp:869
double get_frame_timestamp(stream stream) const
Retrieves time at which the latest frame on a stream was captured.
Definition: rs.hpp:1028
int get_stream_height(stream stream) const
Retrieves height, in pixels, of a specific stream, equivalent to the height field from the stream's i...
Definition: rs.hpp:755
int get_stream_mode_count(stream stream) const
Determines number of streaming modes available for given stream.
Definition: rs.hpp:675
void enable_stream(stream stream, preset preset)
Enables specific stream and requests properties using preset.
Definition: rs.hpp:714
motion_intrinsics get_motion_intrinsics() const
Retrieves intrinsic camera parameters for motion module.
Definition: rs.hpp:799
void send_blob_to_device(rs::blob_type type, void *data, int size)
Sends device-specific data to device.
Definition: rs.hpp:1062
bool supports_option(option option) const
Determines if device allows specific option to be queried and set.
Definition: rs.hpp:664
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
bool poll_for_frames()
Checks if new frames are available, without blocking.
Definition: rs.hpp:994
void disable_motion_tracking(void)
Disables events polling.
Definition: rs.hpp:861
const char * get_option_description(option option)
Retrieves device-specific option description.
Definition: rs.hpp:965
void enable_motion_tracking(std::function< void(motion_data)> motion_handler)
Sets the callback for motion module event.
Definition: rs.hpp:853
unsigned long long get_frame_number(stream stream) const
Retrieves frame number.
Definition: rs.hpp:1039
extrinsics get_extrinsics(stream from_stream, stream to_stream) const
Retrieves extrinsic transformation between viewpoints of two different streams.
Definition: rs.hpp:630
bool supports(capabilities capability) const
Determines device capabilities.
Definition: rs.hpp:1005
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
bool is_streaming() const
Determines if device is currently streaming.
Definition: rs.hpp:896
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
void set_frame_callback(rs::stream stream, std::function< void(frame)> frame_handler)
Sets callback for frame arrival event.
Definition: rs.hpp:817
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 start(rs::source source=rs::source::video)
Begins streaming on all enabled streams for this device.
Definition: rs.hpp:879
const char * get_firmware_version() const
Retrieves version of firmware currently installed on device.
Definition: rs.hpp:608
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
const char * get_info(camera_info info) const
Retrieves camera-specific information such as versions of various components.
Definition: rs.hpp:618
void get_option_range(option option, double &min, double &max, double &step)
Retrieves available range of values of supported option.
Definition: rs.hpp:909
const char * get_serial() const
Retrieves unique serial number of device.
Definition: rs.hpp:588
const void * get_frame_data(stream stream) const
Retrieves contents of latest frame on a stream.
Definition: rs.hpp:1050
const char * get_usb_port_id() const
Retrieves USB port number of device.
Definition: rs.hpp:598
double get_option(option option)
Retrieves current value of single option.
Definition: rs.hpp:954
bool is_stream_enabled(stream stream) const
Determines if specific stream is enabled.
Definition: rs.hpp:733
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
format get_stream_format(stream stream) const
Retrieves pixel format for specific stream.
Definition: rs.hpp:766
float get_depth_scale() const
Retrieves mapping between units of depth image and meters.
Definition: rs.hpp:653
int get_stream_width(stream stream) const
Retrieves width, in pixels, of a specific stream, equivalent to the width field from the stream's int...
Definition: rs.hpp:744
intrinsics get_stream_intrinsics(stream stream) const
Retrieves intrinsic camera parameters for specific stream.
Definition: rs.hpp:788
bool supports(camera_info info_param) const
Determines device capabilities.
Definition: rs.hpp:1017
void wait_for_frames()
Blocks until new frames are available.
Definition: rs.hpp:985
void stop(rs::source source=rs::source::video)
Ends streaming on all streams for this device.
Definition: rs.hpp:887
Definition: rs.hpp:305
static void handle(rs_error *e)
Definition: rs.hpp:316
const std::string & get_failed_args() const
Definition: rs.hpp:315
error(rs_error *err)
Definition: rs.hpp:308
const std::string & get_failed_function() const
Definition: rs.hpp:314
Definition: rs.hpp:554
void release() override
Definition: rs.hpp:564
frame_callback(std::function< void(frame)> on_frame)
Definition: rs.hpp:557
void on_frame(rs_device *device, rs_frame_ref *fref) override
Definition: rs.hpp:559
Frame.
Definition: rs.hpp:393
format get_format() const
Retrieves frame format.
Definition: rs.hpp:534
double get_timestamp() const
Definition: rs.hpp:426
frame & operator=(frame other)
Definition: rs.hpp:403
int get_width() const
Returns image width in pixels.
Definition: rs.hpp:487
timestamp_domain get_frame_timestamp_domain() const
Definition: rs.hpp:436
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
~frame()
Definition: rs.hpp:414
frame(frame &&other)
Definition: rs.hpp:402
int get_bpp() const
Retrieves bits per pixel.
Definition: rs.hpp:524
void swap(frame &other)
Definition: rs.hpp:408
frame(rs_device *device, rs_frame_ref *frame_ref)
Definition: rs.hpp:401
const void * get_data() const
Definition: rs.hpp:478
stream get_stream_type() const
Retrieves frame stream type.
Definition: rs.hpp:544
double get_frame_metadata(rs_frame_metadata frame_metadata) const
Definition: rs.hpp:447
int get_height() const
Returns image height in pixels.
Definition: rs.hpp:496
frame()
Definition: rs.hpp:400
bool supports_frame_metadata(rs_frame_metadata frame_metadata) const
Definition: rs.hpp:458
int get_framerate() const
Returns configured frame rate.
Definition: rs.hpp:505
unsigned long long get_frame_number() const
Definition: rs.hpp:468
Definition: rs.hpp:1091
void release() override
Definition: rs.hpp:1101
void on_event(rs_log_severity severity, const char *message) override
Definition: rs.hpp:1096
log_callback(std::function< void(log_severity, const char *)> on_event)
Definition: rs.hpp:1094
Definition: rs.hpp:364
void release() override
Definition: rs.hpp:374
void on_event(rs_motion_data e) override
Definition: rs.hpp:369
motion_callback(std::function< void(motion_data)> on_event)
Definition: rs.hpp:367
Definition: rs.hpp:378
void release() override
Definition: rs.hpp:388
timestamp_callback(std::function< void(timestamp_data)> on_event)
Definition: rs.hpp:381
void on_event(rs_timestamp_data data) override
Definition: rs.hpp:383
Definition: rs.hpp:22
distortion
Distortion model: defines how pixel coordinates should be mapped to sensor coordinates.
Definition: rs.hpp:77
frame_metadata
Types of value provided from the device with each frame.
Definition: rs.hpp:161
timestamp_domain
Specifies the clock in relation to which the frame timestamp was measured.
Definition: rs.hpp:243
output_buffer_format
Output buffer format: sets how librealsense works with frame memory.
Definition: rs.hpp:62
stream
Streams are different types of data provided by RealSense devices.
Definition: rs.hpp:25
@ depth_aligned_to_color
@ color_aligned_to_depth
@ infrared2_aligned_to_depth
@ depth_aligned_to_rectified_color
@ depth_aligned_to_infrared2
format
Formats: defines how each stream can be encoded. rs_format specifies how a frame is represented in me...
Definition: rs.hpp:43
void log_to_console(log_severity min_severity)
Definition: rs.hpp:1104
event
Source device that triggered specific timestamp event from the motion module.
Definition: rs.hpp:228
@ event_imu_motion_cam
@ event_imu_g0_sync
@ event_imu_g1_sync
@ event_imu_g2_sync
@ event_imu_depth_cam
option
Defines general configuration controls.
Definition: rs.hpp:88
@ hardware_logger_enabled
@ sr300_auto_range_max_laser
@ fisheye_external_trigger
@ sr300_auto_range_upper_threshold
@ color_enable_auto_exposure
@ r200_auto_exposure_top_edge
@ sr300_auto_range_enable_motion_versus_range
@ sr300_auto_range_lower_threshold
@ r200_auto_exposure_mean_intensity_set_point
@ r200_depth_clamp_min
@ r200_depth_control_texture_difference_threshold
@ sr300_auto_range_enable_laser
@ r200_auto_exposure_bright_ratio_set_point
@ r200_depth_control_score_maximum_threshold
@ r200_lr_auto_exposure_enabled
@ r200_depth_control_estimate_median_increment
@ sr300_auto_range_min_laser
@ sr300_auto_range_max_motion_versus_range
@ r200_depth_control_median_threshold
@ r200_depth_control_score_minimum_threshold
@ r200_auto_exposure_kp_gain
@ r200_emitter_enabled
@ r200_depth_control_neighbor_threshold
@ color_white_balance
@ f200_filter_option
@ r200_depth_control_texture_count_threshold
@ r200_auto_exposure_kp_dark_threshold
@ r200_disparity_multiplier
@ sr300_auto_range_start_laser
@ fisheye_color_auto_exposure_sample_rate
@ r200_disparity_shift
@ r200_depth_control_second_peak_threshold
@ r200_depth_clamp_max
@ fisheye_color_auto_exposure_skip_frames
@ sr300_auto_range_min_motion_versus_range
@ color_enable_auto_white_balance
@ r200_depth_control_lr_threshold
@ r200_depth_control_estimate_median_decrement
@ color_backlight_compensation
@ r200_auto_exposure_right_edge
@ r200_auto_exposure_bottom_edge
@ r200_auto_exposure_left_edge
@ fisheye_color_auto_exposure_rate
@ f200_confidence_threshold
@ r200_auto_exposure_kp_exposure
@ fisheye_color_auto_exposure
@ fisheye_color_auto_exposure_mode
@ sr300_auto_range_start_motion_versus_range
blob_type
Proprietary formats for direct communication with device firmware.
Definition: rs.hpp:184
@ motion_module_firmware_update
log_severity
Severity of the librealsense logger.
Definition: rs.hpp:1081
capabilities
Specifies various capabilities of a RealSense device.
Definition: rs.hpp:170
std::ostream & operator<<(std::ostream &o, stream stream)
Definition: rs.hpp:1070
preset
Presets: general preferences that are translated by librealsense into concrete resolution and FPS.
Definition: rs.hpp:69
void log_to_file(log_severity min_severity, const char *file_path)
Definition: rs.hpp:1111
void log_to_callback(log_severity min_severity, std::function< void(log_severity, const char *)> callback)
Definition: rs.hpp:1118
void apply_depth_control_preset(device *device, int preset)
Definition: rs.hpp:1126
void apply_ivcam_preset(device *device, rs_ivcam_preset preset)
Definition: rs.hpp:1127
camera_info
Read-only strings that can be queried from the device.
Definition: rs.hpp:192
@ motion_module_firmware_version
@ adapter_board_firmware_version
source
Allows the user to choose between available hardware subdevices.
Definition: rs.hpp:220
const char * rs_get_device_name(const rs_device *device, rs_error **error)
Retrieves human-readable device model string.
const char * rs_preset_to_string(rs_preset preset)
int rs_get_detached_framerate(const rs_frame_ref *frame, rs_error **error)
Retrieves frame intrinsic frame rate.
rs_format rs_get_stream_format(const rs_device *device, rs_stream stream, rs_error **error)
Retrieves the pixel format for a specific stream.
const char * rs_format_to_string(rs_format format)
void rs_delete_context(rs_context *context, rs_error **error)
Frees the relevant context object.
const char * rs_get_failed_function(const rs_error *error)
Returns static pointer to name of a failing function in case of error.
void rs_log_to_console(rs_log_severity min_severity, rs_error **error)
Starts logging to console.
void rs_log_to_file(rs_log_severity min_severity, const char *file_path, rs_error **error)
Starts logging to file.
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.
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...
const void * rs_get_detached_frame_data(const rs_frame_ref *frame, rs_error **error)
Retrieves data from frame reference.
struct rs_error rs_error
Definition: rs.h:357
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's i...
int rs_get_detached_frame_bpp(const rs_frame_ref *frame, rs_error **error)
Retrieves frame bits per pixel.
int rs_is_stream_enabled(const rs_device *device, rs_stream stream, rs_error **error)
Determines if a specific stream is enabled.
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's...
rs_timestamp_domain rs_get_detached_frame_timestamp_domain(const rs_frame_ref *frame, rs_error **error)
Retrieves timestamp domain from frame reference.
const char * rs_stream_to_string(rs_stream stream)
int rs_get_detached_frame_width(const rs_frame_ref *frame, rs_error **error)
Retrieves frame intrinsic width in pixels.
void rs_free_error(rs_error *error)
Frees memory of an error object.
rs_context * rs_create_context(int api_version, rs_error **error)
Creates RealSense context that is required for the rest of the API.
int rs_get_detached_frame_height(const rs_frame_ref *frame, rs_error **error)
Retrieves frame intrinsic height.
rs_stream
Streams are different types of data provided by RealSense devices.
Definition: rs.h:34
const char * rs_option_to_string(rs_option option)
rs_frame_metadata
Types of value provided from the device with each frame.
Definition: rs.h:204
unsigned long long rs_get_frame_number(const rs_device *device, rs_stream stream, rs_error **error)
Retrieves frame number.
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.
int rs_is_device_streaming(const rs_device *device, rs_error **error)
Determines if the device is currently streaming.
float rs_get_device_depth_scale(const rs_device *device, rs_error **error)
Retrieves mapping between the units of the depth image and meters.
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.
rs_event_source
Source device that triggered a specific timestamp event from the motion module.
Definition: rs.h:277
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...
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.
void rs_wait_for_frames(rs_device *device, rs_error **error)
Blocks until new frames are available.
void rs_disable_motion_tracking(rs_device *device, rs_error **error)
Disables motion-tracking handlers.
void rs_log_to_callback_cpp(rs_log_severity min_severity, rs_log_callback *callback, rs_error **error)
Starts logging to user-provided callback.
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.
rs_distortion
Distortion model: defines how pixel coordinates should be mapped to sensor coordinates.
Definition: rs.h:100
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.
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.
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.
double rs_get_device_option(rs_device *device, rs_option option, rs_error **error)
Retrieves the current value of a single option.
double rs_get_detached_frame_timestamp(const rs_frame_ref *frame, rs_error **error)
Retrieves timestamp from frame reference.
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.
void rs_set_device_option(rs_device *device, rs_option option, double value, rs_error **error)
Sets the current value of a single option.
int rs_supports_frame_metadata(const rs_frame_ref *frame, rs_frame_metadata frame_metadata, rs_error **error)
Determines device metadata.
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.
rs_output_buffer_format
Output buffer format: sets how librealsense works with frame memory.
Definition: rs.h:74
const char * rs_get_failed_args(const rs_error *error)
Returns static pointer to arguments of a failing function in case of error.
rs_format rs_get_detached_frame_format(const rs_frame_ref *frame, rs_error **error)
Retrieves frame format.
void rs_get_motion_intrinsics(const rs_device *device, rs_motion_intrinsics *intrinsic, rs_error **error)
Retrieves intrinsic camera parameters for a motion module.
rs_preset
Presets: general preferences that are translated by librealsense into concrete resolution and FPS.
Definition: rs.h:82
rs_log_severity
Severity of the librealsense logger.
Definition: rs.h:265
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.
rs_device * rs_get_device(rs_context *context, int index, rs_error **error)
Retrieves connected device by index.
int rs_poll_for_frames(rs_device *device, rs_error **error)
Checks if new frames are available, without blocking.
rs_option
Defines general configuration controls.
Definition: rs.h:129
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.
int rs_supports(rs_device *device, rs_capabilities capability, rs_error **error)
Determines device capabilities.
const char * rs_distortion_to_string(rs_distortion distortion)
const char * rs_get_error_message(const rs_error *error)
Returns static pointer to error message.
void rs_start_source(rs_device *device, rs_source source, rs_error **error)
Begins streaming on all enabled streams for this device.
const char * rs_get_device_serial(const rs_device *device, rs_error **error)
Retrieves unique serial number of the device.
rs_format
Formats: defines how each stream can be encoded.
Definition: rs.h:54
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.
int rs_is_motion_tracking_active(rs_device *device, rs_error **error)
Checks if data acquisition is active.
const char * rs_capabilities_to_string(rs_capabilities capability)
const char * rs_event_to_string(rs_event_source event)
int rs_get_stream_framerate(const rs_device *device, rs_stream stream, rs_error **error)
Retrieves the frame rate for a specific stream.
rs_blob_type
Proprietary formats for direct communication with device firmware.
Definition: rs.h:228
void rs_stop_source(rs_device *device, rs_source source, rs_error **error)
Ends data acquisition for the specified source providers.
rs_source
Source: allows you to choose between available hardware subdevices.
Definition: rs.h:91
unsigned long long rs_get_detached_frame_number(const rs_frame_ref *frame, rs_error **error)
Retrieves frame number from frame reference.
const char * rs_source_to_string(rs_source source)
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.
rs_camera_info
Read-only strings that can be queried from the device.
Definition: rs.h:237
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.
rs_capabilities
Specifies various capabilities of a RealSense device.
Definition: rs.h:214
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.
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.
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.
const char * rs_get_device_usb_port_id(const rs_device *device, rs_error **error)
Retrieves the USB port number of the device.
#define RS_API_VERSION
Definition: rs.h:28
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.
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.
void rs_release_frame(rs_device *device, rs_frame_ref *frame, rs_error **error)
Releases frame handle.
rs_stream rs_get_detached_frame_stream_type(const rs_frame_ref *frame, rs_error **error)
Retrieves frame stream type.
int rs_get_device_count(const rs_context *context, rs_error **error)
Determines number of connected devices.
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.
void rs_disable_stream(rs_device *device, rs_stream stream, rs_error **error)
Disables a specific stream.
rs_ivcam_preset
For SR300 devices: provides optimized settings (presets) for specific types of usage.
Definition: rs.h:110
Cross-stream extrinsics: encode the topology describing how the different devices are connected.
Definition: rs.hpp:282
bool is_identity() const
Definition: rs.hpp:283
float3 transform(const float3 &point) const
Definition: rs.hpp:284
Definition: rs.hpp:248
float y
Definition: rs.hpp:248
float x
Definition: rs.hpp:248
Definition: rs.hpp:249
float x
Definition: rs.hpp:249
float y
Definition: rs.hpp:249
float z
Definition: rs.hpp:249
Video stream intrinsics.
Definition: rs.hpp:253
float2 project_to_texcoord(const float3 &point) const
Definition: rs.hpp:268
float3 deproject(const float2 &pixel, float depth) const
Definition: rs.hpp:263
float vfov() const
Definition: rs.hpp:255
distortion model() const
Definition: rs.hpp:256
float hfov() const
Definition: rs.hpp:254
bool operator==(const intrinsics &r) const
Definition: rs.hpp:270
float2 project(const float3 &point) const
Definition: rs.hpp:267
float2 texcoord_to_pixel(const float2 &coord) const
Definition: rs.hpp:260
float3 deproject_from_texcoord(const float2 &coord, float depth) const
Definition: rs.hpp:264
float2 pixel_to_texcoord(const float2 &pixel) const
Definition: rs.hpp:259
Motion data from gyroscope and accelerometer from the microcontroller.
Definition: rs.hpp:296
motion_data()
Definition: rs.hpp:298
motion_data(rs_motion_data orig)
Definition: rs.hpp:297
Motion device intrinsics: scale, bias, and variances.
Definition: rs.hpp:276
motion_intrinsics()
Definition: rs.hpp:277
Timestamp data from the motion microcontroller.
Definition: rs.hpp:289
timestamp_data(rs_timestamp_data orig)
Definition: rs.hpp:290
timestamp_data()
Definition: rs.hpp:291
Definition: rscore.hpp:119
Definition: rscore.hpp:65
Cross-stream extrinsics: encode the topology describing how the different devices are connected.
Definition: rs.h:333
float translation[3]
Definition: rs.h:335
float rotation[9]
Definition: rs.h:334
Definition: rscore.hpp:133
Definition: rscore.hpp:45
Video stream intrinsics.
Definition: rs.h:301
float fy
Definition: rs.h:307
rs_distortion model
Definition: rs.h:308
float ppy
Definition: rs.h:305
float fx
Definition: rs.h:306
int height
Definition: rs.h:303
int width
Definition: rs.h:302
float ppx
Definition: rs.h:304
Definition: rscore.hpp:147
Definition: rscore.hpp:126
Motion data from gyroscope and accelerometer from the microcontroller.
Definition: rs.h:348
Motion module intrinsics: includes accelerometer and gyroscope intrinsics structs of type rs_motion_d...
Definition: rs.h:326
Definition: rscore.hpp:140
Timestamp data from the motion microcontroller.
Definition: rs.h:340