RealSense (JavaCPP Presets for librealsense 1.12.1-1.5.1 API)

java.lang.Object
- org.bytedeco.librealsense.presets.RealSense
- - org.bytedeco.librealsense.global.RealSense

All Implemented Interfaces:: InfoMapper

public class RealSense
extends RealSense

Nested Class Summary
- Nested classes/interfaces inherited from class org.bytedeco.librealsense.presets.RealSense
  RealSense.FrameFunction, RealSense.LogCallbackFunction, RealSense.MotionFunction, RealSense.TimestampFunction

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`actual_exposure` enum class rs::frame_metadata
`static int`	`actual_fps` enum class rs::frame_metadata
`static int`	`adapter_board` enum class rs::capabilities
`static int`	`adapter_board_firmware_version` enum class rs::camera_info
`static byte`	`all_sources` enum class rs::source
`static int`	`any` enum class rs::format
`static int`	`best_quality` enum class rs::preset
`static int`	`bgr8` enum class rs::format
`static int`	`bgra8` enum class rs::format
`static int`	`build_date` enum class rs::camera_info
`static int`	`calibration_date` enum class rs::camera_info
`static int`	`camera` enum class rs::timestamp_domain
`static int`	`camera_firmware_version` enum class rs::camera_info
`static int`	`camera_type` enum class rs::camera_info
`static int`	`color` enum class rs::capabilities
`static int`	`color_aligned_to_depth` enum class rs::stream
`static int`	`color_backlight_compensation` enum class rs::option
`static int`	`color_brightness` enum class rs::option
`static int`	`color_contrast` enum class rs::option
`static int`	`color_enable_auto_exposure` enum class rs::option
`static int`	`color_enable_auto_white_balance` enum class rs::option
`static int`	`color_exposure` enum class rs::option
`static int`	`color_gain` enum class rs::option
`static int`	`color_gamma` enum class rs::option
`static int`	`color_hue` enum class rs::option
`static int`	`color_saturation` enum class rs::option
`static int`	`color_sharpness` enum class rs::option
`static int`	`color_white_balance` enum class rs::option
`static int`	`content_version` enum class rs::camera_info
`static int`	`continous` enum class rs::output_buffer_format
`static int`	`debug` enum class rs::log_severity
`static int`	`depth` enum class rs::capabilities
`static int`	`depth_aligned_to_color` enum class rs::stream
`static int`	`depth_aligned_to_infrared2` enum class rs::stream
`static int`	`depth_aligned_to_rectified_color` enum class rs::stream
`static int`	`device_name` enum class rs::camera_info
`static int`	`disparity16` enum class rs::format
`static int`	`distortion_ftheta` enum class rs::distortion
`static int`	`emitter_type` enum class rs::camera_info
`static int`	`enumeration` enum class rs::capabilities
`static int`	`error` enum class rs::log_severity
`static byte`	`event_imu_accel` enum class rs::event
`static byte`	`event_imu_depth_cam` enum class rs::event
`static byte`	`event_imu_g0_sync` enum class rs::event
`static byte`	`event_imu_g1_sync` enum class rs::event
`static byte`	`event_imu_g2_sync` enum class rs::event
`static byte`	`event_imu_gyro` enum class rs::event
`static byte`	`event_imu_motion_cam` enum class rs::event
`static int`	`f200_accuracy` enum class rs::option
`static int`	`f200_confidence_threshold` enum class rs::option
`static int`	`f200_dynamic_fps` enum class rs::option
`static int`	`f200_filter_option` enum class rs::option
`static int`	`f200_laser_power` enum class rs::option
`static int`	`f200_motion_range` enum class rs::option
`static int`	`fatal` enum class rs::log_severity
`static int`	`fish_eye` enum class rs::capabilities
`static int`	`fisheye` enum class rs::stream
`static int`	`fisheye_color_auto_exposure` enum class rs::option
`static int`	`fisheye_color_auto_exposure_mode` enum class rs::option
`static int`	`fisheye_color_auto_exposure_rate` enum class rs::option
`static int`	`fisheye_color_auto_exposure_sample_rate` enum class rs::option
`static int`	`fisheye_color_auto_exposure_skip_frames` enum class rs::option
`static int`	`fisheye_exposure` enum class rs::option
`static int`	`fisheye_external_trigger` enum class rs::option
`static int`	`fisheye_gain` enum class rs::option
`static int`	`fisheye_strobe` enum class rs::option
`static int`	`focus_alignment_date` enum class rs::camera_info
`static int`	`focus_value` enum class rs::camera_info
`static int`	`frames_queue_size` enum class rs::option
`static int`	`hardware_logger_enabled` enum class rs::option
`static int`	`highest_framerate` enum class rs::preset
`static int`	`imager_model_number` enum class rs::camera_info
`static int`	`info` enum class rs::log_severity
`static int`	`infrared` enum class rs::capabilities
`static int`	`infrared2` enum class rs::capabilities
`static int`	`infrared2_aligned_to_depth` enum class rs::stream
`static int`	`inverse_brown_conrady` enum class rs::distortion
`static int`	`isp_fw_version` enum class rs::camera_info
`static int`	`largest_image` enum class rs::preset
`static int`	`lens_coating_type` enum class rs::camera_info
`static int`	`lens_nominal_baseline` enum class rs::camera_info
`static int`	`lens_type` enum class rs::camera_info
`static int`	`log_none` enum class rs::log_severity
`static int`	`microcontroller` enum class rs::timestamp_domain
`static int`	`modified_brown_conrady` enum class rs::distortion
`static int`	`module_version` enum class rs::camera_info
`static byte`	`motion_data` enum class rs::source
`static int`	`motion_events` enum class rs::capabilities
`static int`	`motion_module_firmware_update` enum class rs::blob_type
`static int`	`motion_module_firmware_version` enum class rs::camera_info
`static int`	`motion_module_fw_update` enum class rs::capabilities
`static int`	`none` enum class rs::distortion
`static int`	`oem_id` enum class rs::camera_info
`static int`	`output_native` enum class rs::output_buffer_format
`static int`	`points` enum class rs::stream
`static int`	`program_date` enum class rs::camera_info
`static int`	`r200_auto_exposure_bottom_edge` enum class rs::option
`static int`	`r200_auto_exposure_bright_ratio_set_point` enum class rs::option
`static int`	`r200_auto_exposure_kp_dark_threshold` enum class rs::option
`static int`	`r200_auto_exposure_kp_exposure` enum class rs::option
`static int`	`r200_auto_exposure_kp_gain` enum class rs::option
`static int`	`r200_auto_exposure_left_edge` enum class rs::option
`static int`	`r200_auto_exposure_mean_intensity_set_point` enum class rs::option
`static int`	`r200_auto_exposure_right_edge` enum class rs::option
`static int`	`r200_auto_exposure_top_edge` enum class rs::option
`static int`	`r200_depth_clamp_max` enum class rs::option
`static int`	`r200_depth_clamp_min` enum class rs::option
`static int`	`r200_depth_control_estimate_median_decrement` enum class rs::option
`static int`	`r200_depth_control_estimate_median_increment` enum class rs::option
`static int`	`r200_depth_control_lr_threshold` enum class rs::option
`static int`	`r200_depth_control_median_threshold` enum class rs::option
`static int`	`r200_depth_control_neighbor_threshold` enum class rs::option
`static int`	`r200_depth_control_score_maximum_threshold` enum class rs::option
`static int`	`r200_depth_control_score_minimum_threshold` enum class rs::option
`static int`	`r200_depth_control_second_peak_threshold` enum class rs::option
`static int`	`r200_depth_control_texture_count_threshold` enum class rs::option
`static int`	`r200_depth_control_texture_difference_threshold` enum class rs::option
`static int`	`r200_depth_units` enum class rs::option
`static int`	`r200_disparity_multiplier` enum class rs::option
`static int`	`r200_disparity_shift` enum class rs::option
`static int`	`r200_emitter_enabled` enum class rs::option
`static int`	`r200_lr_auto_exposure_enabled` enum class rs::option
`static int`	`r200_lr_exposure` enum class rs::option
`static int`	`r200_lr_gain` enum class rs::option
`static int`	`raw10` enum class rs::format
`static int`	`raw16` enum class rs::format
`static int`	`raw8` enum class rs::format
`static int`	`rectified_color` enum class rs::stream
`static int`	`rgb8` enum class rs::format
`static int`	`rgba8` enum class rs::format
`static int`	`RS_API_MAJOR_VERSION`
`static int`	`RS_API_MINOR_VERSION`
`static int`	`RS_API_PATCH_VERSION`
`static int`	`RS_API_VERSION`
`static String`	`RS_API_VERSION_STR`
`static int`	`RS_BLOB_TYPE_COUNT` enum rs_blob_type
`static int`	`RS_BLOB_TYPE_MOTION_MODULE_FIRMWARE_UPDATE` enum rs_blob_type
`static int`	`RS_CAMERA_INFO_3RD_LENS_COATING_TYPE` enum rs_camera_info
`static int`	`RS_CAMERA_INFO_3RD_LENS_TYPE` enum rs_camera_info
`static int`	`RS_CAMERA_INFO_3RD_NOMINAL_BASELINE` enum rs_camera_info
`static int`	`RS_CAMERA_INFO_ADAPTER_BOARD_FIRMWARE_VERSION` enum rs_camera_info
`static int`	`RS_CAMERA_INFO_BUILD_DATE` enum rs_camera_info
`static int`	`RS_CAMERA_INFO_CALIBRATION_DATE` enum rs_camera_info
`static int`	`RS_CAMERA_INFO_CAMERA_FIRMWARE_VERSION` enum rs_camera_info
`static int`	`RS_CAMERA_INFO_CAMERA_TYPE` enum rs_camera_info
`static int`	`RS_CAMERA_INFO_CONTENT_VERSION` enum rs_camera_info
`static int`	`RS_CAMERA_INFO_COUNT` enum rs_camera_info
`static int`	`RS_CAMERA_INFO_DEVICE_NAME` enum rs_camera_info
`static int`	`RS_CAMERA_INFO_DEVICE_SERIAL_NUMBER` enum rs_camera_info
`static int`	`RS_CAMERA_INFO_EMITTER_TYPE` enum rs_camera_info
`static int`	`RS_CAMERA_INFO_FOCUS_ALIGNMENT_DATE` enum rs_camera_info
`static int`	`RS_CAMERA_INFO_FOCUS_VALUE` enum rs_camera_info
`static int`	`RS_CAMERA_INFO_IMAGER_MODEL_NUMBER` enum rs_camera_info
`static int`	`RS_CAMERA_INFO_ISP_FW_VERSION` enum rs_camera_info
`static int`	`RS_CAMERA_INFO_LENS_COATING__TYPE` enum rs_camera_info
`static int`	`RS_CAMERA_INFO_LENS_TYPE` enum rs_camera_info
`static int`	`RS_CAMERA_INFO_MODULE_VERSION` enum rs_camera_info
`static int`	`RS_CAMERA_INFO_MOTION_MODULE_FIRMWARE_VERSION` enum rs_camera_info
`static int`	`RS_CAMERA_INFO_NOMINAL_BASELINE` enum rs_camera_info
`static int`	`RS_CAMERA_INFO_OEM_ID` enum rs_camera_info
`static int`	`RS_CAMERA_INFO_PROGRAM_DATE` enum rs_camera_info
`static int`	`RS_CAPABILITIES_ADAPTER_BOARD` enum rs_capabilities
`static int`	`RS_CAPABILITIES_COLOR` enum rs_capabilities
`static int`	`RS_CAPABILITIES_COUNT` enum rs_capabilities
`static int`	`RS_CAPABILITIES_DEPTH` enum rs_capabilities
`static int`	`RS_CAPABILITIES_ENUMERATION` enum rs_capabilities
`static int`	`RS_CAPABILITIES_FISH_EYE` enum rs_capabilities
`static int`	`RS_CAPABILITIES_INFRARED` enum rs_capabilities
`static int`	`RS_CAPABILITIES_INFRARED2` enum rs_capabilities
`static int`	`RS_CAPABILITIES_MOTION_EVENTS` enum rs_capabilities
`static int`	`RS_CAPABILITIES_MOTION_MODULE_FW_UPDATE` enum rs_capabilities
`static int`	`RS_DISTORTION_COUNT` enum rs_distortion
`static int`	`RS_DISTORTION_FTHETA` enum rs_distortion
`static int`	`RS_DISTORTION_INVERSE_BROWN_CONRADY` enum rs_distortion
`static int`	`RS_DISTORTION_MODIFIED_BROWN_CONRADY` enum rs_distortion
`static int`	`RS_DISTORTION_NONE` enum rs_distortion
`static int`	`RS_EVENT_G0_SYNC` enum rs_event_source
`static int`	`RS_EVENT_G1_SYNC` enum rs_event_source
`static int`	`RS_EVENT_G2_SYNC` enum rs_event_source
`static int`	`RS_EVENT_IMU_ACCEL` enum rs_event_source
`static int`	`RS_EVENT_IMU_DEPTH_CAM` enum rs_event_source
`static int`	`RS_EVENT_IMU_GYRO` enum rs_event_source
`static int`	`RS_EVENT_IMU_MOTION_CAM` enum rs_event_source
`static int`	`RS_EVENT_SOURCE_COUNT` enum rs_event_source
`static int`	`RS_FORMAT_ANY` enum rs_format
`static int`	`RS_FORMAT_BGR8` enum rs_format
`static int`	`RS_FORMAT_BGRA8` enum rs_format
`static int`	`RS_FORMAT_COUNT` enum rs_format
`static int`	`RS_FORMAT_DISPARITY16` enum rs_format
`static int`	`RS_FORMAT_RAW10` enum rs_format
`static int`	`RS_FORMAT_RAW16` enum rs_format
`static int`	`RS_FORMAT_RAW8` enum rs_format
`static int`	`RS_FORMAT_RGB8` enum rs_format
`static int`	`RS_FORMAT_RGBA8` enum rs_format
`static int`	`RS_FORMAT_XYZ32F` enum rs_format
`static int`	`RS_FORMAT_Y16` enum rs_format
`static int`	`RS_FORMAT_Y8` enum rs_format
`static int`	`RS_FORMAT_YUYV` enum rs_format
`static int`	`RS_FORMAT_Z16` enum rs_format
`static int`	`RS_FRAME_METADATA_ACTUAL_EXPOSURE` enum rs_frame_metadata
`static int`	`RS_FRAME_METADATA_ACTUAL_FPS` enum rs_frame_metadata
`static int`	`RS_FRAME_METADATA_COUNT` enum rs_frame_metadata
`static int`	`RS_IVCAM_PRESET_BACKGROUND_SEGMENTATION` enum rs_ivcam_preset
`static int`	`RS_IVCAM_PRESET_COUNT` enum rs_ivcam_preset
`static int`	`RS_IVCAM_PRESET_DEFAULT` enum rs_ivcam_preset
`static int`	`RS_IVCAM_PRESET_FACE_ANALYTICS` enum rs_ivcam_preset
`static int`	`RS_IVCAM_PRESET_FACE_LOGIN` enum rs_ivcam_preset
`static int`	`RS_IVCAM_PRESET_GESTURE_RECOGNITION` enum rs_ivcam_preset
`static int`	`RS_IVCAM_PRESET_GR_CURSOR` enum rs_ivcam_preset
`static int`	`RS_IVCAM_PRESET_IR_ONLY` enum rs_ivcam_preset
`static int`	`RS_IVCAM_PRESET_LONG_RANGE` enum rs_ivcam_preset
`static int`	`RS_IVCAM_PRESET_MID_RANGE` enum rs_ivcam_preset
`static int`	`RS_IVCAM_PRESET_OBJECT_SCANNING` enum rs_ivcam_preset
`static int`	`RS_IVCAM_PRESET_SHORT_RANGE` enum rs_ivcam_preset
`static int`	`RS_LOG_SEVERITY_COUNT` enum rs_log_severity
`static int`	`RS_LOG_SEVERITY_DEBUG` enum rs_log_severity
`static int`	`RS_LOG_SEVERITY_ERROR` enum rs_log_severity
`static int`	`RS_LOG_SEVERITY_FATAL` enum rs_log_severity
`static int`	`RS_LOG_SEVERITY_INFO` enum rs_log_severity
`static int`	`RS_LOG_SEVERITY_NONE` enum rs_log_severity
`static int`	`RS_LOG_SEVERITY_WARN` enum rs_log_severity
`static int`	`RS_OPTION_COLOR_BACKLIGHT_COMPENSATION` enum rs_option
`static int`	`RS_OPTION_COLOR_BRIGHTNESS` enum rs_option
`static int`	`RS_OPTION_COLOR_CONTRAST` enum rs_option
`static int`	`RS_OPTION_COLOR_ENABLE_AUTO_EXPOSURE` enum rs_option
`static int`	`RS_OPTION_COLOR_ENABLE_AUTO_WHITE_BALANCE` enum rs_option
`static int`	`RS_OPTION_COLOR_EXPOSURE` enum rs_option
`static int`	`RS_OPTION_COLOR_GAIN` enum rs_option
`static int`	`RS_OPTION_COLOR_GAMMA` enum rs_option
`static int`	`RS_OPTION_COLOR_HUE` enum rs_option
`static int`	`RS_OPTION_COLOR_SATURATION` enum rs_option
`static int`	`RS_OPTION_COLOR_SHARPNESS` enum rs_option
`static int`	`RS_OPTION_COLOR_WHITE_BALANCE` enum rs_option
`static int`	`RS_OPTION_COUNT` enum rs_option
`static int`	`RS_OPTION_F200_ACCURACY` enum rs_option
`static int`	`RS_OPTION_F200_CONFIDENCE_THRESHOLD` enum rs_option
`static int`	`RS_OPTION_F200_DYNAMIC_FPS` enum rs_option
`static int`	`RS_OPTION_F200_FILTER_OPTION` enum rs_option
`static int`	`RS_OPTION_F200_LASER_POWER` enum rs_option
`static int`	`RS_OPTION_F200_MOTION_RANGE` enum rs_option
`static int`	`RS_OPTION_FISHEYE_AUTO_EXPOSURE_ANTIFLICKER_RATE` enum rs_option
`static int`	`RS_OPTION_FISHEYE_AUTO_EXPOSURE_MODE` enum rs_option
`static int`	`RS_OPTION_FISHEYE_AUTO_EXPOSURE_PIXEL_SAMPLE_RATE` enum rs_option
`static int`	`RS_OPTION_FISHEYE_AUTO_EXPOSURE_SKIP_FRAMES` enum rs_option
`static int`	`RS_OPTION_FISHEYE_ENABLE_AUTO_EXPOSURE` enum rs_option
`static int`	`RS_OPTION_FISHEYE_EXPOSURE` enum rs_option
`static int`	`RS_OPTION_FISHEYE_EXTERNAL_TRIGGER` enum rs_option
`static int`	`RS_OPTION_FISHEYE_GAIN` enum rs_option
`static int`	`RS_OPTION_FISHEYE_STROBE` enum rs_option
`static int`	`RS_OPTION_FRAMES_QUEUE_SIZE` enum rs_option
`static int`	`RS_OPTION_HARDWARE_LOGGER_ENABLED` enum rs_option
`static int`	`RS_OPTION_R200_AUTO_EXPOSURE_BOTTOM_EDGE` enum rs_option
`static int`	`RS_OPTION_R200_AUTO_EXPOSURE_BRIGHT_RATIO_SET_POINT` enum rs_option
`static int`	`RS_OPTION_R200_AUTO_EXPOSURE_KP_DARK_THRESHOLD` enum rs_option
`static int`	`RS_OPTION_R200_AUTO_EXPOSURE_KP_EXPOSURE` enum rs_option
`static int`	`RS_OPTION_R200_AUTO_EXPOSURE_KP_GAIN` enum rs_option
`static int`	`RS_OPTION_R200_AUTO_EXPOSURE_LEFT_EDGE` enum rs_option
`static int`	`RS_OPTION_R200_AUTO_EXPOSURE_MEAN_INTENSITY_SET_POINT` enum rs_option
`static int`	`RS_OPTION_R200_AUTO_EXPOSURE_RIGHT_EDGE` enum rs_option
`static int`	`RS_OPTION_R200_AUTO_EXPOSURE_TOP_EDGE` enum rs_option
`static int`	`RS_OPTION_R200_DEPTH_CLAMP_MAX` enum rs_option
`static int`	`RS_OPTION_R200_DEPTH_CLAMP_MIN` enum rs_option
`static int`	`RS_OPTION_R200_DEPTH_CONTROL_ESTIMATE_MEDIAN_DECREMENT` enum rs_option
`static int`	`RS_OPTION_R200_DEPTH_CONTROL_ESTIMATE_MEDIAN_INCREMENT` enum rs_option
`static int`	`RS_OPTION_R200_DEPTH_CONTROL_LR_THRESHOLD` enum rs_option
`static int`	`RS_OPTION_R200_DEPTH_CONTROL_MEDIAN_THRESHOLD` enum rs_option
`static int`	`RS_OPTION_R200_DEPTH_CONTROL_NEIGHBOR_THRESHOLD` enum rs_option
`static int`	`RS_OPTION_R200_DEPTH_CONTROL_SCORE_MAXIMUM_THRESHOLD` enum rs_option
`static int`	`RS_OPTION_R200_DEPTH_CONTROL_SCORE_MINIMUM_THRESHOLD` enum rs_option
`static int`	`RS_OPTION_R200_DEPTH_CONTROL_SECOND_PEAK_THRESHOLD` enum rs_option
`static int`	`RS_OPTION_R200_DEPTH_CONTROL_TEXTURE_COUNT_THRESHOLD` enum rs_option
`static int`	`RS_OPTION_R200_DEPTH_CONTROL_TEXTURE_DIFFERENCE_THRESHOLD` enum rs_option
`static int`	`RS_OPTION_R200_DEPTH_UNITS` enum rs_option
`static int`	`RS_OPTION_R200_DISPARITY_MULTIPLIER` enum rs_option
`static int`	`RS_OPTION_R200_DISPARITY_SHIFT` enum rs_option
`static int`	`RS_OPTION_R200_EMITTER_ENABLED` enum rs_option
`static int`	`RS_OPTION_R200_LR_AUTO_EXPOSURE_ENABLED` enum rs_option
`static int`	`RS_OPTION_R200_LR_EXPOSURE` enum rs_option
`static int`	`RS_OPTION_R200_LR_GAIN` enum rs_option
`static int`	`RS_OPTION_SR300_AUTO_RANGE_ENABLE_LASER` enum rs_option
`static int`	`RS_OPTION_SR300_AUTO_RANGE_ENABLE_MOTION_VERSUS_RANGE` enum rs_option
`static int`	`RS_OPTION_SR300_AUTO_RANGE_LOWER_THRESHOLD` enum rs_option
`static int`	`RS_OPTION_SR300_AUTO_RANGE_MAX_LASER` enum rs_option
`static int`	`RS_OPTION_SR300_AUTO_RANGE_MAX_MOTION_VERSUS_RANGE` enum rs_option
`static int`	`RS_OPTION_SR300_AUTO_RANGE_MIN_LASER` enum rs_option
`static int`	`RS_OPTION_SR300_AUTO_RANGE_MIN_MOTION_VERSUS_RANGE` enum rs_option
`static int`	`RS_OPTION_SR300_AUTO_RANGE_START_LASER` enum rs_option
`static int`	`RS_OPTION_SR300_AUTO_RANGE_START_MOTION_VERSUS_RANGE` enum rs_option
`static int`	`RS_OPTION_SR300_AUTO_RANGE_UPPER_THRESHOLD` enum rs_option
`static int`	`RS_OPTION_TOTAL_FRAME_DROPS` enum rs_option
`static int`	`RS_OUTPUT_BUFFER_FORMAT_CONTINUOUS` enum rs_output_buffer_format
`static int`	`RS_OUTPUT_BUFFER_FORMAT_COUNT` enum rs_output_buffer_format
`static int`	`RS_OUTPUT_BUFFER_FORMAT_NATIVE` enum rs_output_buffer_format
`static int`	`RS_PRESET_BEST_QUALITY` enum rs_preset
`static int`	`RS_PRESET_COUNT` enum rs_preset
`static int`	`RS_PRESET_HIGHEST_FRAMERATE` enum rs_preset
`static int`	`RS_PRESET_LARGEST_IMAGE` enum rs_preset
`static int`	`RS_SOURCE_ALL` enum rs_source
`static int`	`RS_SOURCE_COUNT` enum rs_source
`static int`	`RS_SOURCE_MOTION_TRACKING` enum rs_source
`static int`	`RS_SOURCE_VIDEO` enum rs_source
`static int`	`RS_STREAM_COLOR` enum rs_stream
`static int`	`RS_STREAM_COLOR_ALIGNED_TO_DEPTH` enum rs_stream
`static int`	`RS_STREAM_COUNT` enum rs_stream
`static int`	`RS_STREAM_DEPTH` enum rs_stream
`static int`	`RS_STREAM_DEPTH_ALIGNED_TO_COLOR` enum rs_stream
`static int`	`RS_STREAM_DEPTH_ALIGNED_TO_INFRARED2` enum rs_stream
`static int`	`RS_STREAM_DEPTH_ALIGNED_TO_RECTIFIED_COLOR` enum rs_stream
`static int`	`RS_STREAM_FISHEYE` enum rs_stream
`static int`	`RS_STREAM_INFRARED` enum rs_stream
`static int`	`RS_STREAM_INFRARED2` enum rs_stream
`static int`	`RS_STREAM_INFRARED2_ALIGNED_TO_DEPTH` enum rs_stream
`static int`	`RS_STREAM_POINTS` enum rs_stream
`static int`	`RS_STREAM_RECTIFIED_COLOR` enum rs_stream
`static int`	`RS_TIMESTAMP_DOMAIN_CAMERA` enum rs_timestamp_domain
`static int`	`RS_TIMESTAMP_DOMAIN_COUNT` enum rs_timestamp_domain
`static int`	`RS_TIMESTAMP_DOMAIN_MICROCONTROLLER` enum rs_timestamp_domain
`static int`	`serial_number` enum class rs::camera_info
`static int`	`sr300_auto_range_enable_laser` enum class rs::option
`static int`	`sr300_auto_range_enable_motion_versus_range` enum class rs::option
`static int`	`sr300_auto_range_lower_threshold` enum class rs::option
`static int`	`sr300_auto_range_max_laser` enum class rs::option
`static int`	`sr300_auto_range_max_motion_versus_range` enum class rs::option
`static int`	`sr300_auto_range_min_laser` enum class rs::option
`static int`	`sr300_auto_range_min_motion_versus_range` enum class rs::option
`static int`	`sr300_auto_range_start_laser` enum class rs::option
`static int`	`sr300_auto_range_start_motion_versus_range` enum class rs::option
`static int`	`sr300_auto_range_upper_threshold` enum class rs::option
`static int`	`third_lens_coating_type` enum class rs::camera_info
`static int`	`third_lens_nominal_baseline` enum class rs::camera_info
`static int`	`third_lens_type` enum class rs::camera_info
`static int`	`total_frame_drops` enum class rs::option
`static byte`	`video` enum class rs::source
`static int`	`warn` enum class rs::log_severity
`static int`	`xyz32f` enum class rs::format
`static int`	`y16` enum class rs::format
`static int`	`y8` enum class rs::format
`static int`	`yuyv` enum class rs::format
`static int`	`z16` enum class rs::format

Constructor Summary

Constructors
Constructor and Description

RealSense()

Constructors
Constructor and Description
`RealSense()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`apply_depth_control_preset(device device, int preset)`
`static void`	`apply_ivcam_preset(device device, int preset)`
`static void`	`log_to_callback(int min_severity, RealSense.LogCallbackFunction callback)`
`static void`	`log_to_console(int min_severity)`
`static void`	`log_to_file(int min_severity, BytePointer file_path)`
`static void`	`log_to_file(int min_severity, String file_path)`
`static String`	`RS_API_VERSION_STR()`
`static void`	`rs_apply_depth_control_preset(rs_device device, int preset)`
`static void`	`rs_apply_ivcam_preset(rs_device device, int preset)`
`static BytePointer`	`rs_blob_type_to_string(int type)`
`static BytePointer`	`rs_camera_info_to_string(int info)`
`static BytePointer`	`rs_capabilities_to_string(int capability)`
`static rs_context`	`rs_create_context(int api_version, PointerPointer error)` create realsense context required for rest of the API
`static rs_context`	`rs_create_context(int api_version, rs_error error)`
`static void`	`rs_delete_context(rs_context context, PointerPointer error)` frees the relevant context object, this might invalidate rs_device pointers created from this context
`static void`	`rs_delete_context(rs_context context, rs_error error)`
`static void`	`rs_deproject_pixel_to_point(float[] point, rs_intrinsics intrin, float[] pixel, float depth)`
`static void`	`rs_deproject_pixel_to_point(FloatBuffer point, rs_intrinsics intrin, FloatBuffer pixel, float depth)`
`static void`	`rs_deproject_pixel_to_point(FloatPointer point, rs_intrinsics intrin, FloatPointer pixel, float depth)`
`static int`	`rs_device_supports_option(rs_device device, int option, PointerPointer error)` determine if the device allows a specific option to be queried and set
`static int`	`rs_device_supports_option(rs_device device, int option, rs_error error)`
`static void`	`rs_disable_motion_tracking(rs_device device, PointerPointer error)` disable motion-tracking handlers
`static void`	`rs_disable_motion_tracking(rs_device device, rs_error error)`
`static void`	`rs_disable_stream(rs_device device, int stream, PointerPointer error)` disable a specific stream
`static void`	`rs_disable_stream(rs_device device, int stream, rs_error error)`
`static BytePointer`	`rs_distortion_to_string(int distortion)`
`static void`	`rs_enable_motion_tracking_cpp(rs_device device, rs_motion_callback motion_callback, rs_timestamp_callback timestamp_callback, PointerPointer error)` enable and configure motion-tracking data handlers Note: rs_enable_motion_tracking is responsible for activating the motion module on-board the device.
`static void`	`rs_enable_motion_tracking_cpp(rs_device device, rs_motion_callback motion_callback, rs_timestamp_callback timestamp_callback, rs_error error)`
`static void`	`rs_enable_motion_tracking(rs_device device, rs_motion_callback_ptr on_motion_event, Pointer motion_handler, rs_timestamp_callback_ptr on_timestamp_event, Pointer timestamp_handler, PointerPointer error)` enable and configure motion-tracking data handlers
`static void`	`rs_enable_motion_tracking(rs_device device, rs_motion_callback_ptr on_motion_event, Pointer motion_handler, rs_timestamp_callback_ptr on_timestamp_event, Pointer timestamp_handler, rs_error error)`
`static void`	`rs_enable_stream_ex(rs_device device, int stream, int width, int height, int format, int framerate, int output_format, PointerPointer error)` enable a specific stream and request specific properties
`static void`	`rs_enable_stream_ex(rs_device device, int stream, int width, int height, int format, int framerate, int output_format, rs_error error)`
`static void`	`rs_enable_stream_preset(rs_device device, int stream, int preset, PointerPointer error)` enable a specific stream and request properties using a preset
`static void`	`rs_enable_stream_preset(rs_device device, int stream, int preset, rs_error error)`
`static void`	`rs_enable_stream(rs_device device, int stream, int width, int height, int format, int framerate, PointerPointer error)` enable a specific stream and request specific properties
`static void`	`rs_enable_stream(rs_device device, int stream, int width, int height, int format, int framerate, rs_error error)`
`static BytePointer`	`rs_event_to_string(int event)`
`static BytePointer`	`rs_format_to_string(int format)`
`static BytePointer`	`rs_frame_metadata_to_string(int md)`
`static void`	`rs_free_error(rs_error error)` frees memory of an error object
`static int`	`rs_get_api_version(PointerPointer error)` retrieve the API version from the source code.
`static int`	`rs_get_api_version(rs_error error)`
`static int`	`rs_get_detached_frame_bpp(rs_frame_ref frame, PointerPointer error)` retrive frame bits per pixel
`static int`	`rs_get_detached_frame_bpp(rs_frame_ref frame, rs_error error)`
`static Pointer`	`rs_get_detached_frame_data(rs_frame_ref frame, PointerPointer error)` retrive data from safe frame handle, returned from detach, clone_ref or from frame callback
`static Pointer`	`rs_get_detached_frame_data(rs_frame_ref frame, rs_error error)`
`static int`	`rs_get_detached_frame_format(rs_frame_ref frame, PointerPointer error)` retrive frame format
`static int`	`rs_get_detached_frame_format(rs_frame_ref frame, rs_error error)`
`static int`	`rs_get_detached_frame_height(rs_frame_ref frame, PointerPointer error)` retrive frame intrinsic height
`static int`	`rs_get_detached_frame_height(rs_frame_ref frame, rs_error error)`
`static double`	`rs_get_detached_frame_metadata(rs_frame_ref frame, int frame_metadata, PointerPointer error)` retrive metadata from safe frame handle, returned from detach, clone_ref or from frame callback
`static double`	`rs_get_detached_frame_metadata(rs_frame_ref frame, int frame_metadata, rs_error error)`
`static long`	`rs_get_detached_frame_number(rs_frame_ref frame, PointerPointer error)` retrive frame number from safe frame handle, returned from detach, clone_ref or from frame callback
`static long`	`rs_get_detached_frame_number(rs_frame_ref frame, rs_error error)`
`static int`	`rs_get_detached_frame_stream_type(rs_frame_ref frameset, PointerPointer error)` retrive frame stream type
`static int`	`rs_get_detached_frame_stream_type(rs_frame_ref frameset, rs_error error)`
`static int`	`rs_get_detached_frame_stride(rs_frame_ref frame, PointerPointer error)` retrive frame stride, meaning the actual line width in memory in bytes (not the logical image width)
`static int`	`rs_get_detached_frame_stride(rs_frame_ref frame, rs_error error)`
`static int`	`rs_get_detached_frame_timestamp_domain(rs_frame_ref frameset, PointerPointer error)` retrive timestamp domain from safe frame handle, returned from detach, clone_ref or from frame callback this method is used to check if two timestamp values are comparable (generated from the same clock)
`static int`	`rs_get_detached_frame_timestamp_domain(rs_frame_ref frameset, rs_error error)`
`static double`	`rs_get_detached_frame_timestamp(rs_frame_ref frame, PointerPointer error)` retrive timestamp from safe frame handle, returned from detach, clone_ref or from frame callback
`static double`	`rs_get_detached_frame_timestamp(rs_frame_ref frame, rs_error error)`
`static int`	`rs_get_detached_frame_width(rs_frame_ref frame, PointerPointer error)` retrive frame intrinsic width in pixels
`static int`	`rs_get_detached_frame_width(rs_frame_ref frame, rs_error error)`
`static int`	`rs_get_detached_framerate(rs_frame_ref frameset, PointerPointer error)` retrive frame intrinsic framerate
`static int`	`rs_get_detached_framerate(rs_frame_ref frameset, rs_error error)`
`static int`	`rs_get_device_count(rs_context context, PointerPointer error)` determine number of connected devices
`static int`	`rs_get_device_count(rs_context context, rs_error error)`
`static float`	`rs_get_device_depth_scale(rs_device device, PointerPointer error)` retrieve mapping between the units of the depth image and meters
`static float`	`rs_get_device_depth_scale(rs_device device, rs_error error)`
`static void`	`rs_get_device_extrinsics(rs_device device, int from_stream, int to_stream, rs_extrinsics extrin, PointerPointer error)` retrieve extrinsic transformation between the viewpoints of two different streams
`static void`	`rs_get_device_extrinsics(rs_device device, int from_stream, int to_stream, rs_extrinsics extrin, rs_error error)`
`static BytePointer`	`rs_get_device_firmware_version(rs_device device, PointerPointer error)` retrieve the version of the firmware currently installed on the device
`static BytePointer`	`rs_get_device_firmware_version(rs_device device, rs_error error)`
`static BytePointer`	`rs_get_device_info(rs_device device, int info, PointerPointer error)` retrieve camera specific information, like versions of various internal componnents
`static BytePointer`	`rs_get_device_info(rs_device device, int info, rs_error error)`
`static BytePointer`	`rs_get_device_name(rs_device device, PointerPointer error)` retrieve a human readable device model string
`static BytePointer`	`rs_get_device_name(rs_device device, rs_error error)`
`static BytePointer`	`rs_get_device_option_description(rs_device device, int option, PointerPointer error)` retrieve a static description of what a particular option does on given device
`static BytePointer`	`rs_get_device_option_description(rs_device device, int option, rs_error error)`
`static void`	`rs_get_device_option_range_ex(rs_device device, int option, double[] min, double[] max, double[] step, double[] def, rs_error error)`
`static void`	`rs_get_device_option_range_ex(rs_device device, int option, DoubleBuffer min, DoubleBuffer max, DoubleBuffer step, DoubleBuffer def, rs_error error)`
`static void`	`rs_get_device_option_range_ex(rs_device device, int option, DoublePointer min, DoublePointer max, DoublePointer step, DoublePointer def, PointerPointer error)` retrieve the available range of values of a supported option
`static void`	`rs_get_device_option_range_ex(rs_device device, int option, DoublePointer min, DoublePointer max, DoublePointer step, DoublePointer def, rs_error error)`
`static void`	`rs_get_device_option_range(rs_device device, int option, double[] min, double[] max, double[] step, rs_error error)`
`static void`	`rs_get_device_option_range(rs_device device, int option, DoubleBuffer min, DoubleBuffer max, DoubleBuffer step, rs_error error)`
`static void`	`rs_get_device_option_range(rs_device device, int option, DoublePointer min, DoublePointer max, DoublePointer step, PointerPointer error)` retrieve the available range of values of a supported option
`static void`	`rs_get_device_option_range(rs_device device, int option, DoublePointer min, DoublePointer max, DoublePointer step, rs_error error)`
`static double`	`rs_get_device_option(rs_device device, int option, PointerPointer error)` retrieve the current value of a single option
`static double`	`rs_get_device_option(rs_device device, int option, rs_error error)`
`static void`	`rs_get_device_options(rs_device device, int[] options, int count, double[] values, rs_error error)`
`static void`	`rs_get_device_options(rs_device device, IntBuffer options, int count, DoubleBuffer values, rs_error error)`
`static void`	`rs_get_device_options(rs_device device, IntPointer options, int count, DoublePointer values, PointerPointer error)` efficiently retrieve the value of an arbitrary number of options, using minimal hardware IO
`static void`	`rs_get_device_options(rs_device device, IntPointer options, int count, DoublePointer values, rs_error error)`
`static BytePointer`	`rs_get_device_serial(rs_device device, PointerPointer error)` retrieve the unique serial number of the device
`static BytePointer`	`rs_get_device_serial(rs_device device, rs_error error)`
`static BytePointer`	`rs_get_device_usb_port_id(rs_device device, PointerPointer error)` retrieve the USB port number of the device
`static BytePointer`	`rs_get_device_usb_port_id(rs_device device, rs_error error)`
`static rs_device`	`rs_get_device(rs_context context, int index, PointerPointer error)` retrieve connected device by index
`static rs_device`	`rs_get_device(rs_context context, int index, rs_error error)`
`static BytePointer`	`rs_get_error_message(rs_error error)` returns static pointer to the error message
`static BytePointer`	`rs_get_failed_args(rs_error error)` returns static pointer to the arguments of failing function in case of error
`static BytePointer`	`rs_get_failed_function(rs_error error)` returns static pointer to the name of failing function in case of error
`static Pointer`	`rs_get_frame_data(rs_device device, int stream, PointerPointer error)` retrieve the contents of the latest frame on a stream
`static Pointer`	`rs_get_frame_data(rs_device device, int stream, rs_error error)`
`static long`	`rs_get_frame_number(rs_device device, int stream, PointerPointer error)` retrieve the frame number
`static long`	`rs_get_frame_number(rs_device device, int stream, rs_error error)`
`static double`	`rs_get_frame_timestamp(rs_device device, int stream, PointerPointer error)` retrieve the time at which the latest frame on a stream was captured
`static double`	`rs_get_frame_timestamp(rs_device device, int stream, rs_error error)`
`static void`	`rs_get_motion_extrinsics_from(rs_device device, int from, rs_extrinsics extrin, PointerPointer error)` retrieve extrinsic transformation between specific stream and the motion module
`static void`	`rs_get_motion_extrinsics_from(rs_device device, int from, rs_extrinsics extrin, rs_error error)`
`static void`	`rs_get_motion_intrinsics(rs_device device, rs_motion_intrinsics intrinsic, PointerPointer error)` retrieve intrinsic camera parameters for a motion module
`static void`	`rs_get_motion_intrinsics(rs_device device, rs_motion_intrinsics intrinsic, rs_error error)`
`static int`	`rs_get_stream_format(rs_device device, int stream, PointerPointer error)` retrieve the pixel format for a specific stream
`static int`	`rs_get_stream_format(rs_device device, int stream, rs_error error)`
`static int`	`rs_get_stream_framerate(rs_device device, int stream, PointerPointer error)` retrieve the framerate for a specific stream
`static int`	`rs_get_stream_framerate(rs_device device, int stream, rs_error error)`
`static int`	`rs_get_stream_height(rs_device device, int stream, PointerPointer error)` retrieve the height in pixels of a specific stream, equivalent to the height field from the stream's intrinsic
`static int`	`rs_get_stream_height(rs_device device, int stream, rs_error error)`
`static void`	`rs_get_stream_intrinsics(rs_device device, int stream, rs_intrinsics intrin, PointerPointer error)` retrieve intrinsic camera parameters for a specific stream
`static void`	`rs_get_stream_intrinsics(rs_device device, int stream, rs_intrinsics intrin, rs_error error)`
`static int`	`rs_get_stream_mode_count(rs_device device, int stream, PointerPointer error)` determine the number of streaming modes available for a given stream
`static int`	`rs_get_stream_mode_count(rs_device device, int stream, rs_error error)`
`static void`	`rs_get_stream_mode(rs_device device, int stream, int index, int[] width, int[] height, int[] format, int[] framerate, rs_error error)`
`static void`	`rs_get_stream_mode(rs_device device, int stream, int index, IntBuffer width, IntBuffer height, IntBuffer format, IntBuffer framerate, rs_error error)`
`static void`	`rs_get_stream_mode(rs_device device, int stream, int index, IntPointer width, IntPointer height, IntPointer format, IntPointer framerate, PointerPointer error)` determine the properties of a specific streaming mode
`static void`	`rs_get_stream_mode(rs_device device, int stream, int index, IntPointer width, IntPointer height, IntPointer format, IntPointer framerate, rs_error error)`
`static int`	`rs_get_stream_width(rs_device device, int stream, PointerPointer error)` retrieve the width in pixels of a specific stream, equivalent to the width field from the stream's intrinsic
`static int`	`rs_get_stream_width(rs_device device, int stream, rs_error error)`
`static int`	`rs_is_device_streaming(rs_device device, PointerPointer error)` determine if the device is currently streaming
`static int`	`rs_is_device_streaming(rs_device device, rs_error error)`
`static int`	`rs_is_motion_tracking_active(rs_device device, PointerPointer error)` check if data acquisition is active
`static int`	`rs_is_motion_tracking_active(rs_device device, rs_error error)`
`static int`	`rs_is_stream_enabled(rs_device device, int stream, PointerPointer error)` determine if a specific stream is enabled
`static int`	`rs_is_stream_enabled(rs_device device, int stream, rs_error error)`
`static void`	`rs_log_to_callback_cpp(int min_severity, rs_log_callback callback, PointerPointer error)` start logging to user provided callback
`static void`	`rs_log_to_callback_cpp(int min_severity, rs_log_callback callback, rs_error error)`
`static void`	`rs_log_to_callback(int min_severity, rs_log_callback_ptr on_log, Pointer user, PointerPointer error)` start logging to user provided callback (C version)
`static void`	`rs_log_to_callback(int min_severity, rs_log_callback_ptr on_log, Pointer user, rs_error error)`
`static void`	`rs_log_to_console(int min_severity, PointerPointer error)` start logging to console
`static void`	`rs_log_to_console(int min_severity, rs_error error)`
`static void`	`rs_log_to_file(int min_severity, BytePointer file_path, PointerPointer error)` start logging to file
`static void`	`rs_log_to_file(int min_severity, BytePointer file_path, rs_error error)`
`static void`	`rs_log_to_file(int min_severity, String file_path, rs_error error)`
`static BytePointer`	`rs_option_to_string(int option)`
`static int`	`rs_poll_for_frames(rs_device device, PointerPointer error)` check if new frames are available, without blocking
`static int`	`rs_poll_for_frames(rs_device device, rs_error error)`
`static BytePointer`	`rs_preset_to_string(int preset)`
`static void`	`rs_project_point_to_pixel(float[] pixel, rs_intrinsics intrin, float[] point)`
`static void`	`rs_project_point_to_pixel(FloatBuffer pixel, rs_intrinsics intrin, FloatBuffer point)`
`static void`	`rs_project_point_to_pixel(FloatPointer pixel, rs_intrinsics intrin, FloatPointer point)`
`static void`	`rs_release_frame(rs_device device, rs_frame_ref frame, PointerPointer error)` relases the frame handle
`static void`	`rs_release_frame(rs_device device, rs_frame_ref frame, rs_error error)`
`static void`	`rs_reset_device_options_to_default(rs_device device, int[] options, int count, rs_error error)`
`static void`	`rs_reset_device_options_to_default(rs_device device, IntBuffer options, int count, rs_error error)`
`static void`	`rs_reset_device_options_to_default(rs_device device, IntPointer options, int count, PointerPointer error)` efficiently reset the value of an arbitrary number of options to default
`static void`	`rs_reset_device_options_to_default(rs_device device, IntPointer options, int count, rs_error error)`
`static void`	`rs_send_blob_to_device(rs_device device, int type, Pointer data, int size, PointerPointer error)` send a blob of data to the device.
`static void`	`rs_send_blob_to_device(rs_device device, int type, Pointer data, int size, rs_error error)`
`static void`	`rs_set_device_option(rs_device device, int option, double value, PointerPointer error)` set the current value of a single option
`static void`	`rs_set_device_option(rs_device device, int option, double value, rs_error error)`
`static void`	`rs_set_device_options(rs_device device, int[] options, int count, double[] values, rs_error error)`
`static void`	`rs_set_device_options(rs_device device, IntBuffer options, int count, DoubleBuffer values, rs_error error)`
`static void`	`rs_set_device_options(rs_device device, IntPointer options, int count, DoublePointer values, PointerPointer error)` efficiently set the value of an arbitrary number of options, using minimal hardware IO
`static void`	`rs_set_device_options(rs_device device, IntPointer options, int count, DoublePointer values, rs_error error)`
`static void`	`rs_set_frame_callback_cpp(rs_device device, int stream, rs_frame_callback callback, PointerPointer error)` set up a frame callback that will be called immediately when an image is available, with no synchronization logic applied (This variant is provided specificly to enable passing lambdas with capture lists safely into the library)
`static void`	`rs_set_frame_callback_cpp(rs_device device, int stream, rs_frame_callback callback, rs_error error)`
`static void`	`rs_set_frame_callback(rs_device device, int stream, rs_frame_callback_ptr on_frame, Pointer user, PointerPointer error)` set up a frame callback that will be called immediately when an image is available, with no synchronization logic applied
`static void`	`rs_set_frame_callback(rs_device device, int stream, rs_frame_callback_ptr on_frame, Pointer user, rs_error error)`
`static BytePointer`	`rs_source_to_string(int source)`
`static void`	`rs_start_device(rs_device device, PointerPointer error)` begin streaming on all enabled streams for this device
`static void`	`rs_start_device(rs_device device, rs_error error)`
`static void`	`rs_start_source(rs_device device, int source, PointerPointer error)` begin streaming on all enabled streams for this device
`static void`	`rs_start_source(rs_device device, int source, rs_error error)`
`static void`	`rs_stop_device(rs_device device, PointerPointer error)` end data acquisition for the specified source providers
`static void`	`rs_stop_device(rs_device device, rs_error error)`
`static void`	`rs_stop_source(rs_device device, int source, PointerPointer error)` end data acquisition for the specified source providers
`static void`	`rs_stop_source(rs_device device, int source, rs_error error)`
`static BytePointer`	`rs_stream_to_string(int stream)`
`static int`	`rs_supports_camera_info(rs_device device, int info_param, PointerPointer error)` specialization over generic support to verify camera header block support
`static int`	`rs_supports_camera_info(rs_device device, int info_param, rs_error error)`
`static int`	`rs_supports_frame_metadata(rs_frame_ref frame, int frame_metadata, PointerPointer error)` determine device metadata
`static int`	`rs_supports_frame_metadata(rs_frame_ref frame, int frame_metadata, rs_error error)`
`static int`	`rs_supports(rs_device device, int capability, PointerPointer error)` determine device capabilities
`static int`	`rs_supports(rs_device device, int capability, rs_error error)`
`static BytePointer`	`rs_timestamp_domain_to_string(int info)`
`static void`	`rs_transform_point_to_point(float[] to_point, rs_extrinsics extrin, float[] from_point)`
`static void`	`rs_transform_point_to_point(FloatBuffer to_point, rs_extrinsics extrin, FloatBuffer from_point)`
`static void`	`rs_transform_point_to_point(FloatPointer to_point, rs_extrinsics extrin, FloatPointer from_point)`
`static void`	`rs_wait_for_frames(rs_device device, PointerPointer error)` block until new frames are available
`static void`	`rs_wait_for_frames(rs_device device, rs_error error)`
`static Pointer`	`shiftLeft(Pointer o, byte src)`
`static Pointer`	`shiftLeft(Pointer o, int stream)`

Methods inherited from class org.bytedeco.librealsense.presets.RealSense
map

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- RS_API_MAJOR_VERSION
```
public static final int RS_API_MAJOR_VERSION
```
  See Also:
  
  Constant Field Values
- RS_API_MINOR_VERSION
```
public static final int RS_API_MINOR_VERSION
```
  See Also:
  
  Constant Field Values
- RS_API_PATCH_VERSION
```
public static final int RS_API_PATCH_VERSION
```
  See Also:
  
  Constant Field Values
- RS_API_VERSION
```
public static final int RS_API_VERSION
```
  See Also:
  
  Constant Field Values
- RS_API_VERSION_STR
```
public static final String RS_API_VERSION_STR
```
- RS_STREAM_DEPTH
```
public static final int RS_STREAM_DEPTH
```
  enum rs_stream
  
  See Also:
  
  Constant Field Values
- RS_STREAM_COLOR
```
public static final int RS_STREAM_COLOR
```
  enum rs_stream
  
  See Also:
  
  Constant Field Values
- RS_STREAM_INFRARED
```
public static final int RS_STREAM_INFRARED
```
  enum rs_stream
  
  See Also:
  
  Constant Field Values
- RS_STREAM_INFRARED2
```
public static final int RS_STREAM_INFRARED2
```
  enum rs_stream
  
  See Also:
  
  Constant Field Values
- RS_STREAM_FISHEYE
```
public static final int RS_STREAM_FISHEYE
```
  enum rs_stream
  
  See Also:
  
  Constant Field Values
- RS_STREAM_POINTS
```
public static final int RS_STREAM_POINTS
```
  enum rs_stream
  
  See Also:
  
  Constant Field Values
- RS_STREAM_RECTIFIED_COLOR
```
public static final int RS_STREAM_RECTIFIED_COLOR
```
  enum rs_stream
  
  See Also:
  
  Constant Field Values
- RS_STREAM_COLOR_ALIGNED_TO_DEPTH
```
public static final int RS_STREAM_COLOR_ALIGNED_TO_DEPTH
```
  enum rs_stream
  
  See Also:
  
  Constant Field Values
- RS_STREAM_INFRARED2_ALIGNED_TO_DEPTH
```
public static final int RS_STREAM_INFRARED2_ALIGNED_TO_DEPTH
```
  enum rs_stream
  
  See Also:
  
  Constant Field Values
- RS_STREAM_DEPTH_ALIGNED_TO_COLOR
```
public static final int RS_STREAM_DEPTH_ALIGNED_TO_COLOR
```
  enum rs_stream
  
  See Also:
  
  Constant Field Values
- RS_STREAM_DEPTH_ALIGNED_TO_RECTIFIED_COLOR
```
public static final int RS_STREAM_DEPTH_ALIGNED_TO_RECTIFIED_COLOR
```
  enum rs_stream
  
  See Also:
  
  Constant Field Values
- RS_STREAM_DEPTH_ALIGNED_TO_INFRARED2
```
public static final int RS_STREAM_DEPTH_ALIGNED_TO_INFRARED2
```
  enum rs_stream
  
  See Also:
  
  Constant Field Values
- RS_STREAM_COUNT
```
public static final int RS_STREAM_COUNT
```
  enum rs_stream
  
  See Also:
  
  Constant Field Values
- RS_FORMAT_ANY
```
public static final int RS_FORMAT_ANY
```
  enum rs_format
  
  See Also:
  
  Constant Field Values
- RS_FORMAT_Z16
```
public static final int RS_FORMAT_Z16
```
  enum rs_format
  
  See Also:
  
  Constant Field Values
- RS_FORMAT_DISPARITY16
```
public static final int RS_FORMAT_DISPARITY16
```
  enum rs_format
  
  See Also:
  
  Constant Field Values
- RS_FORMAT_XYZ32F
```
public static final int RS_FORMAT_XYZ32F
```
  enum rs_format
  
  See Also:
  
  Constant Field Values
- RS_FORMAT_YUYV
```
public static final int RS_FORMAT_YUYV
```
  enum rs_format
  
  See Also:
  
  Constant Field Values
- RS_FORMAT_RGB8
```
public static final int RS_FORMAT_RGB8
```
  enum rs_format
  
  See Also:
  
  Constant Field Values
- RS_FORMAT_BGR8
```
public static final int RS_FORMAT_BGR8
```
  enum rs_format
  
  See Also:
  
  Constant Field Values
- RS_FORMAT_RGBA8
```
public static final int RS_FORMAT_RGBA8
```
  enum rs_format
  
  See Also:
  
  Constant Field Values
- RS_FORMAT_BGRA8
```
public static final int RS_FORMAT_BGRA8
```
  enum rs_format
  
  See Also:
  
  Constant Field Values
- RS_FORMAT_Y8
```
public static final int RS_FORMAT_Y8
```
  enum rs_format
  
  See Also:
  
  Constant Field Values
- RS_FORMAT_Y16
```
public static final int RS_FORMAT_Y16
```
  enum rs_format
  
  See Also:
  
  Constant Field Values
- RS_FORMAT_RAW10
```
public static final int RS_FORMAT_RAW10
```
  enum rs_format
  
  See Also:
  
  Constant Field Values
- RS_FORMAT_RAW16
```
public static final int RS_FORMAT_RAW16
```
  enum rs_format
  
  See Also:
  
  Constant Field Values
- RS_FORMAT_RAW8
```
public static final int RS_FORMAT_RAW8
```
  enum rs_format
  
  See Also:
  
  Constant Field Values
- RS_FORMAT_COUNT
```
public static final int RS_FORMAT_COUNT
```
  enum rs_format
  
  See Also:
  
  Constant Field Values
- RS_OUTPUT_BUFFER_FORMAT_CONTINUOUS
```
public static final int RS_OUTPUT_BUFFER_FORMAT_CONTINUOUS
```
  enum rs_output_buffer_format
  
  See Also:
  
  Constant Field Values
- RS_OUTPUT_BUFFER_FORMAT_NATIVE
```
public static final int RS_OUTPUT_BUFFER_FORMAT_NATIVE
```
  enum rs_output_buffer_format
  
  See Also:
  
  Constant Field Values
- RS_OUTPUT_BUFFER_FORMAT_COUNT
```
public static final int RS_OUTPUT_BUFFER_FORMAT_COUNT
```
  enum rs_output_buffer_format
  
  See Also:
  
  Constant Field Values
- RS_PRESET_BEST_QUALITY
```
public static final int RS_PRESET_BEST_QUALITY
```
  enum rs_preset
  
  See Also:
  
  Constant Field Values
- RS_PRESET_LARGEST_IMAGE
```
public static final int RS_PRESET_LARGEST_IMAGE
```
  enum rs_preset
  
  See Also:
  
  Constant Field Values
- RS_PRESET_HIGHEST_FRAMERATE
```
public static final int RS_PRESET_HIGHEST_FRAMERATE
```
  enum rs_preset
  
  See Also:
  
  Constant Field Values
- RS_PRESET_COUNT
```
public static final int RS_PRESET_COUNT
```
  enum rs_preset
  
  See Also:
  
  Constant Field Values
- RS_SOURCE_VIDEO
```
public static final int RS_SOURCE_VIDEO
```
  enum rs_source
  
  See Also:
  
  Constant Field Values
- RS_SOURCE_MOTION_TRACKING
```
public static final int RS_SOURCE_MOTION_TRACKING
```
  enum rs_source
  
  See Also:
  
  Constant Field Values
- RS_SOURCE_ALL
```
public static final int RS_SOURCE_ALL
```
  enum rs_source
  
  See Also:
  
  Constant Field Values
- RS_SOURCE_COUNT
```
public static final int RS_SOURCE_COUNT
```
  enum rs_source
  
  See Also:
  
  Constant Field Values
- RS_DISTORTION_NONE
```
public static final int RS_DISTORTION_NONE
```
  enum rs_distortion
  
  See Also:
  
  Constant Field Values
- RS_DISTORTION_MODIFIED_BROWN_CONRADY
```
public static final int RS_DISTORTION_MODIFIED_BROWN_CONRADY
```
  enum rs_distortion
  
  See Also:
  
  Constant Field Values
- RS_DISTORTION_INVERSE_BROWN_CONRADY
```
public static final int RS_DISTORTION_INVERSE_BROWN_CONRADY
```
  enum rs_distortion
  
  See Also:
  
  Constant Field Values
- RS_DISTORTION_FTHETA
```
public static final int RS_DISTORTION_FTHETA
```
  enum rs_distortion
  
  See Also:
  
  Constant Field Values
- RS_DISTORTION_COUNT
```
public static final int RS_DISTORTION_COUNT
```
  enum rs_distortion
  
  See Also:
  
  Constant Field Values
- RS_IVCAM_PRESET_SHORT_RANGE
```
public static final int RS_IVCAM_PRESET_SHORT_RANGE
```
  enum rs_ivcam_preset
  
  See Also:
  
  Constant Field Values
- RS_IVCAM_PRESET_LONG_RANGE
```
public static final int RS_IVCAM_PRESET_LONG_RANGE
```
  enum rs_ivcam_preset
  
  See Also:
  
  Constant Field Values
- RS_IVCAM_PRESET_BACKGROUND_SEGMENTATION
```
public static final int RS_IVCAM_PRESET_BACKGROUND_SEGMENTATION
```
  enum rs_ivcam_preset
  
  See Also:
  
  Constant Field Values
- RS_IVCAM_PRESET_GESTURE_RECOGNITION
```
public static final int RS_IVCAM_PRESET_GESTURE_RECOGNITION
```
  enum rs_ivcam_preset
  
  See Also:
  
  Constant Field Values
- RS_IVCAM_PRESET_OBJECT_SCANNING
```
public static final int RS_IVCAM_PRESET_OBJECT_SCANNING
```
  enum rs_ivcam_preset
  
  See Also:
  
  Constant Field Values
- RS_IVCAM_PRESET_FACE_ANALYTICS
```
public static final int RS_IVCAM_PRESET_FACE_ANALYTICS
```
  enum rs_ivcam_preset
  
  See Also:
  
  Constant Field Values
- RS_IVCAM_PRESET_FACE_LOGIN
```
public static final int RS_IVCAM_PRESET_FACE_LOGIN
```
  enum rs_ivcam_preset
  
  See Also:
  
  Constant Field Values
- RS_IVCAM_PRESET_GR_CURSOR
```
public static final int RS_IVCAM_PRESET_GR_CURSOR
```
  enum rs_ivcam_preset
  
  See Also:
  
  Constant Field Values
- RS_IVCAM_PRESET_DEFAULT
```
public static final int RS_IVCAM_PRESET_DEFAULT
```
  enum rs_ivcam_preset
  
  See Also:
  
  Constant Field Values
- RS_IVCAM_PRESET_MID_RANGE
```
public static final int RS_IVCAM_PRESET_MID_RANGE
```
  enum rs_ivcam_preset
  
  See Also:
  
  Constant Field Values
- RS_IVCAM_PRESET_IR_ONLY
```
public static final int RS_IVCAM_PRESET_IR_ONLY
```
  enum rs_ivcam_preset
  
  See Also:
  
  Constant Field Values
- RS_IVCAM_PRESET_COUNT
```
public static final int RS_IVCAM_PRESET_COUNT
```
  enum rs_ivcam_preset
  
  See Also:
  
  Constant Field Values
- RS_OPTION_COLOR_BACKLIGHT_COMPENSATION
```
public static final int RS_OPTION_COLOR_BACKLIGHT_COMPENSATION
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_COLOR_BRIGHTNESS
```
public static final int RS_OPTION_COLOR_BRIGHTNESS
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_COLOR_CONTRAST
```
public static final int RS_OPTION_COLOR_CONTRAST
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_COLOR_EXPOSURE
```
public static final int RS_OPTION_COLOR_EXPOSURE
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_COLOR_GAIN
```
public static final int RS_OPTION_COLOR_GAIN
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_COLOR_GAMMA
```
public static final int RS_OPTION_COLOR_GAMMA
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_COLOR_HUE
```
public static final int RS_OPTION_COLOR_HUE
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_COLOR_SATURATION
```
public static final int RS_OPTION_COLOR_SATURATION
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_COLOR_SHARPNESS
```
public static final int RS_OPTION_COLOR_SHARPNESS
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_COLOR_WHITE_BALANCE
```
public static final int RS_OPTION_COLOR_WHITE_BALANCE
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_COLOR_ENABLE_AUTO_EXPOSURE
```
public static final int RS_OPTION_COLOR_ENABLE_AUTO_EXPOSURE
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_COLOR_ENABLE_AUTO_WHITE_BALANCE
```
public static final int RS_OPTION_COLOR_ENABLE_AUTO_WHITE_BALANCE
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_F200_LASER_POWER
```
public static final int RS_OPTION_F200_LASER_POWER
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_F200_ACCURACY
```
public static final int RS_OPTION_F200_ACCURACY
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_F200_MOTION_RANGE
```
public static final int RS_OPTION_F200_MOTION_RANGE
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_F200_FILTER_OPTION
```
public static final int RS_OPTION_F200_FILTER_OPTION
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_F200_CONFIDENCE_THRESHOLD
```
public static final int RS_OPTION_F200_CONFIDENCE_THRESHOLD
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_F200_DYNAMIC_FPS
```
public static final int RS_OPTION_F200_DYNAMIC_FPS
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_SR300_AUTO_RANGE_ENABLE_MOTION_VERSUS_RANGE
```
public static final int RS_OPTION_SR300_AUTO_RANGE_ENABLE_MOTION_VERSUS_RANGE
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_SR300_AUTO_RANGE_ENABLE_LASER
```
public static final int RS_OPTION_SR300_AUTO_RANGE_ENABLE_LASER
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_SR300_AUTO_RANGE_MIN_MOTION_VERSUS_RANGE
```
public static final int RS_OPTION_SR300_AUTO_RANGE_MIN_MOTION_VERSUS_RANGE
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_SR300_AUTO_RANGE_MAX_MOTION_VERSUS_RANGE
```
public static final int RS_OPTION_SR300_AUTO_RANGE_MAX_MOTION_VERSUS_RANGE
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_SR300_AUTO_RANGE_START_MOTION_VERSUS_RANGE
```
public static final int RS_OPTION_SR300_AUTO_RANGE_START_MOTION_VERSUS_RANGE
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_SR300_AUTO_RANGE_MIN_LASER
```
public static final int RS_OPTION_SR300_AUTO_RANGE_MIN_LASER
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_SR300_AUTO_RANGE_MAX_LASER
```
public static final int RS_OPTION_SR300_AUTO_RANGE_MAX_LASER
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_SR300_AUTO_RANGE_START_LASER
```
public static final int RS_OPTION_SR300_AUTO_RANGE_START_LASER
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_SR300_AUTO_RANGE_UPPER_THRESHOLD
```
public static final int RS_OPTION_SR300_AUTO_RANGE_UPPER_THRESHOLD
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_SR300_AUTO_RANGE_LOWER_THRESHOLD
```
public static final int RS_OPTION_SR300_AUTO_RANGE_LOWER_THRESHOLD
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_R200_LR_AUTO_EXPOSURE_ENABLED
```
public static final int RS_OPTION_R200_LR_AUTO_EXPOSURE_ENABLED
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_R200_LR_GAIN
```
public static final int RS_OPTION_R200_LR_GAIN
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_R200_LR_EXPOSURE
```
public static final int RS_OPTION_R200_LR_EXPOSURE
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_R200_EMITTER_ENABLED
```
public static final int RS_OPTION_R200_EMITTER_ENABLED
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_R200_DEPTH_UNITS
```
public static final int RS_OPTION_R200_DEPTH_UNITS
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_R200_DEPTH_CLAMP_MIN
```
public static final int RS_OPTION_R200_DEPTH_CLAMP_MIN
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_R200_DEPTH_CLAMP_MAX
```
public static final int RS_OPTION_R200_DEPTH_CLAMP_MAX
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_R200_DISPARITY_MULTIPLIER
```
public static final int RS_OPTION_R200_DISPARITY_MULTIPLIER
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_R200_DISPARITY_SHIFT
```
public static final int RS_OPTION_R200_DISPARITY_SHIFT
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_R200_AUTO_EXPOSURE_MEAN_INTENSITY_SET_POINT
```
public static final int RS_OPTION_R200_AUTO_EXPOSURE_MEAN_INTENSITY_SET_POINT
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_R200_AUTO_EXPOSURE_BRIGHT_RATIO_SET_POINT
```
public static final int RS_OPTION_R200_AUTO_EXPOSURE_BRIGHT_RATIO_SET_POINT
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_R200_AUTO_EXPOSURE_KP_GAIN
```
public static final int RS_OPTION_R200_AUTO_EXPOSURE_KP_GAIN
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_R200_AUTO_EXPOSURE_KP_EXPOSURE
```
public static final int RS_OPTION_R200_AUTO_EXPOSURE_KP_EXPOSURE
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_R200_AUTO_EXPOSURE_KP_DARK_THRESHOLD
```
public static final int RS_OPTION_R200_AUTO_EXPOSURE_KP_DARK_THRESHOLD
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_R200_AUTO_EXPOSURE_TOP_EDGE
```
public static final int RS_OPTION_R200_AUTO_EXPOSURE_TOP_EDGE
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_R200_AUTO_EXPOSURE_BOTTOM_EDGE
```
public static final int RS_OPTION_R200_AUTO_EXPOSURE_BOTTOM_EDGE
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_R200_AUTO_EXPOSURE_LEFT_EDGE
```
public static final int RS_OPTION_R200_AUTO_EXPOSURE_LEFT_EDGE
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_R200_AUTO_EXPOSURE_RIGHT_EDGE
```
public static final int RS_OPTION_R200_AUTO_EXPOSURE_RIGHT_EDGE
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_R200_DEPTH_CONTROL_ESTIMATE_MEDIAN_DECREMENT
```
public static final int RS_OPTION_R200_DEPTH_CONTROL_ESTIMATE_MEDIAN_DECREMENT
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_R200_DEPTH_CONTROL_ESTIMATE_MEDIAN_INCREMENT
```
public static final int RS_OPTION_R200_DEPTH_CONTROL_ESTIMATE_MEDIAN_INCREMENT
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_R200_DEPTH_CONTROL_MEDIAN_THRESHOLD
```
public static final int RS_OPTION_R200_DEPTH_CONTROL_MEDIAN_THRESHOLD
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_R200_DEPTH_CONTROL_SCORE_MINIMUM_THRESHOLD
```
public static final int RS_OPTION_R200_DEPTH_CONTROL_SCORE_MINIMUM_THRESHOLD
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_R200_DEPTH_CONTROL_SCORE_MAXIMUM_THRESHOLD
```
public static final int RS_OPTION_R200_DEPTH_CONTROL_SCORE_MAXIMUM_THRESHOLD
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_R200_DEPTH_CONTROL_TEXTURE_COUNT_THRESHOLD
```
public static final int RS_OPTION_R200_DEPTH_CONTROL_TEXTURE_COUNT_THRESHOLD
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_R200_DEPTH_CONTROL_TEXTURE_DIFFERENCE_THRESHOLD
```
public static final int RS_OPTION_R200_DEPTH_CONTROL_TEXTURE_DIFFERENCE_THRESHOLD
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_R200_DEPTH_CONTROL_SECOND_PEAK_THRESHOLD
```
public static final int RS_OPTION_R200_DEPTH_CONTROL_SECOND_PEAK_THRESHOLD
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_R200_DEPTH_CONTROL_NEIGHBOR_THRESHOLD
```
public static final int RS_OPTION_R200_DEPTH_CONTROL_NEIGHBOR_THRESHOLD
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_R200_DEPTH_CONTROL_LR_THRESHOLD
```
public static final int RS_OPTION_R200_DEPTH_CONTROL_LR_THRESHOLD
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_FISHEYE_EXPOSURE
```
public static final int RS_OPTION_FISHEYE_EXPOSURE
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_FISHEYE_GAIN
```
public static final int RS_OPTION_FISHEYE_GAIN
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_FISHEYE_STROBE
```
public static final int RS_OPTION_FISHEYE_STROBE
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_FISHEYE_EXTERNAL_TRIGGER
```
public static final int RS_OPTION_FISHEYE_EXTERNAL_TRIGGER
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_FISHEYE_ENABLE_AUTO_EXPOSURE
```
public static final int RS_OPTION_FISHEYE_ENABLE_AUTO_EXPOSURE
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_FISHEYE_AUTO_EXPOSURE_MODE
```
public static final int RS_OPTION_FISHEYE_AUTO_EXPOSURE_MODE
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_FISHEYE_AUTO_EXPOSURE_ANTIFLICKER_RATE
```
public static final int RS_OPTION_FISHEYE_AUTO_EXPOSURE_ANTIFLICKER_RATE
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_FISHEYE_AUTO_EXPOSURE_PIXEL_SAMPLE_RATE
```
public static final int RS_OPTION_FISHEYE_AUTO_EXPOSURE_PIXEL_SAMPLE_RATE
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_FISHEYE_AUTO_EXPOSURE_SKIP_FRAMES
```
public static final int RS_OPTION_FISHEYE_AUTO_EXPOSURE_SKIP_FRAMES
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_FRAMES_QUEUE_SIZE
```
public static final int RS_OPTION_FRAMES_QUEUE_SIZE
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_HARDWARE_LOGGER_ENABLED
```
public static final int RS_OPTION_HARDWARE_LOGGER_ENABLED
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_TOTAL_FRAME_DROPS
```
public static final int RS_OPTION_TOTAL_FRAME_DROPS
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_OPTION_COUNT
```
public static final int RS_OPTION_COUNT
```
  enum rs_option
  
  See Also:
  
  Constant Field Values
- RS_FRAME_METADATA_ACTUAL_EXPOSURE
```
public static final int RS_FRAME_METADATA_ACTUAL_EXPOSURE
```
  enum rs_frame_metadata
  
  See Also:
  
  Constant Field Values
- RS_FRAME_METADATA_ACTUAL_FPS
```
public static final int RS_FRAME_METADATA_ACTUAL_FPS
```
  enum rs_frame_metadata
  
  See Also:
  
  Constant Field Values
- RS_FRAME_METADATA_COUNT
```
public static final int RS_FRAME_METADATA_COUNT
```
  enum rs_frame_metadata
  
  See Also:
  
  Constant Field Values
- RS_CAPABILITIES_DEPTH
```
public static final int RS_CAPABILITIES_DEPTH
```
  enum rs_capabilities
  
  See Also:
  
  Constant Field Values
- RS_CAPABILITIES_COLOR
```
public static final int RS_CAPABILITIES_COLOR
```
  enum rs_capabilities
  
  See Also:
  
  Constant Field Values
- RS_CAPABILITIES_INFRARED
```
public static final int RS_CAPABILITIES_INFRARED
```
  enum rs_capabilities
  
  See Also:
  
  Constant Field Values
- RS_CAPABILITIES_INFRARED2
```
public static final int RS_CAPABILITIES_INFRARED2
```
  enum rs_capabilities
  
  See Also:
  
  Constant Field Values
- RS_CAPABILITIES_FISH_EYE
```
public static final int RS_CAPABILITIES_FISH_EYE
```
  enum rs_capabilities
  
  See Also:
  
  Constant Field Values
- RS_CAPABILITIES_MOTION_EVENTS
```
public static final int RS_CAPABILITIES_MOTION_EVENTS
```
  enum rs_capabilities
  
  See Also:
  
  Constant Field Values
- RS_CAPABILITIES_MOTION_MODULE_FW_UPDATE
```
public static final int RS_CAPABILITIES_MOTION_MODULE_FW_UPDATE
```
  enum rs_capabilities
  
  See Also:
  
  Constant Field Values
- RS_CAPABILITIES_ADAPTER_BOARD
```
public static final int RS_CAPABILITIES_ADAPTER_BOARD
```
  enum rs_capabilities
  
  See Also:
  
  Constant Field Values
- RS_CAPABILITIES_ENUMERATION
```
public static final int RS_CAPABILITIES_ENUMERATION
```
  enum rs_capabilities
  
  See Also:
  
  Constant Field Values
- RS_CAPABILITIES_COUNT
```
public static final int RS_CAPABILITIES_COUNT
```
  enum rs_capabilities
  
  See Also:
  
  Constant Field Values
- RS_BLOB_TYPE_MOTION_MODULE_FIRMWARE_UPDATE
```
public static final int RS_BLOB_TYPE_MOTION_MODULE_FIRMWARE_UPDATE
```
  enum rs_blob_type
  
  See Also:
  
  Constant Field Values
- RS_BLOB_TYPE_COUNT
```
public static final int RS_BLOB_TYPE_COUNT
```
  enum rs_blob_type
  
  See Also:
  
  Constant Field Values
- RS_CAMERA_INFO_DEVICE_NAME
```
public static final int RS_CAMERA_INFO_DEVICE_NAME
```
  enum rs_camera_info
  
  See Also:
  
  Constant Field Values
- RS_CAMERA_INFO_DEVICE_SERIAL_NUMBER
```
public static final int RS_CAMERA_INFO_DEVICE_SERIAL_NUMBER
```
  enum rs_camera_info
  
  See Also:
  
  Constant Field Values
- RS_CAMERA_INFO_CAMERA_FIRMWARE_VERSION
```
public static final int RS_CAMERA_INFO_CAMERA_FIRMWARE_VERSION
```
  enum rs_camera_info
  
  See Also:
  
  Constant Field Values
- RS_CAMERA_INFO_ADAPTER_BOARD_FIRMWARE_VERSION
```
public static final int RS_CAMERA_INFO_ADAPTER_BOARD_FIRMWARE_VERSION
```
  enum rs_camera_info
  
  See Also:
  
  Constant Field Values
- RS_CAMERA_INFO_MOTION_MODULE_FIRMWARE_VERSION
```
public static final int RS_CAMERA_INFO_MOTION_MODULE_FIRMWARE_VERSION
```
  enum rs_camera_info
  
  See Also:
  
  Constant Field Values
- RS_CAMERA_INFO_CAMERA_TYPE
```
public static final int RS_CAMERA_INFO_CAMERA_TYPE
```
  enum rs_camera_info
  
  See Also:
  
  Constant Field Values
- RS_CAMERA_INFO_OEM_ID
```
public static final int RS_CAMERA_INFO_OEM_ID
```
  enum rs_camera_info
  
  See Also:
  
  Constant Field Values
- RS_CAMERA_INFO_ISP_FW_VERSION
```
public static final int RS_CAMERA_INFO_ISP_FW_VERSION
```
  enum rs_camera_info
  
  See Also:
  
  Constant Field Values
- RS_CAMERA_INFO_CONTENT_VERSION
```
public static final int RS_CAMERA_INFO_CONTENT_VERSION
```
  enum rs_camera_info
  
  See Also:
  
  Constant Field Values
- RS_CAMERA_INFO_MODULE_VERSION
```
public static final int RS_CAMERA_INFO_MODULE_VERSION
```
  enum rs_camera_info
  
  See Also:
  
  Constant Field Values
- RS_CAMERA_INFO_IMAGER_MODEL_NUMBER
```
public static final int RS_CAMERA_INFO_IMAGER_MODEL_NUMBER
```
  enum rs_camera_info
  
  See Also:
  
  Constant Field Values
- RS_CAMERA_INFO_BUILD_DATE
```
public static final int RS_CAMERA_INFO_BUILD_DATE
```
  enum rs_camera_info
  
  See Also:
  
  Constant Field Values
- RS_CAMERA_INFO_CALIBRATION_DATE
```
public static final int RS_CAMERA_INFO_CALIBRATION_DATE
```
  enum rs_camera_info
  
  See Also:
  
  Constant Field Values
- RS_CAMERA_INFO_PROGRAM_DATE
```
public static final int RS_CAMERA_INFO_PROGRAM_DATE
```
  enum rs_camera_info
  
  See Also:
  
  Constant Field Values
- RS_CAMERA_INFO_FOCUS_ALIGNMENT_DATE
```
public static final int RS_CAMERA_INFO_FOCUS_ALIGNMENT_DATE
```
  enum rs_camera_info
  
  See Also:
  
  Constant Field Values
- RS_CAMERA_INFO_EMITTER_TYPE
```
public static final int RS_CAMERA_INFO_EMITTER_TYPE
```
  enum rs_camera_info
  
  See Also:
  
  Constant Field Values
- RS_CAMERA_INFO_FOCUS_VALUE
```
public static final int RS_CAMERA_INFO_FOCUS_VALUE
```
  enum rs_camera_info
  
  See Also:
  
  Constant Field Values
- RS_CAMERA_INFO_LENS_TYPE
```
public static final int RS_CAMERA_INFO_LENS_TYPE
```
  enum rs_camera_info
  
  See Also:
  
  Constant Field Values
- RS_CAMERA_INFO_3RD_LENS_TYPE
```
public static final int RS_CAMERA_INFO_3RD_LENS_TYPE
```
  enum rs_camera_info
  
  See Also:
  
  Constant Field Values
- RS_CAMERA_INFO_LENS_COATING__TYPE
```
public static final int RS_CAMERA_INFO_LENS_COATING__TYPE
```
  enum rs_camera_info
  
  See Also:
  
  Constant Field Values
- RS_CAMERA_INFO_3RD_LENS_COATING_TYPE
```
public static final int RS_CAMERA_INFO_3RD_LENS_COATING_TYPE
```
  enum rs_camera_info
  
  See Also:
  
  Constant Field Values
- RS_CAMERA_INFO_NOMINAL_BASELINE
```
public static final int RS_CAMERA_INFO_NOMINAL_BASELINE
```
  enum rs_camera_info
  
  See Also:
  
  Constant Field Values
- RS_CAMERA_INFO_3RD_NOMINAL_BASELINE
```
public static final int RS_CAMERA_INFO_3RD_NOMINAL_BASELINE
```
  enum rs_camera_info
  
  See Also:
  
  Constant Field Values
- RS_CAMERA_INFO_COUNT
```
public static final int RS_CAMERA_INFO_COUNT
```
  enum rs_camera_info
  
  See Also:
  
  Constant Field Values
- RS_LOG_SEVERITY_DEBUG
```
public static final int RS_LOG_SEVERITY_DEBUG
```
  enum rs_log_severity
  
  See Also:
  
  Constant Field Values
- RS_LOG_SEVERITY_INFO
```
public static final int RS_LOG_SEVERITY_INFO
```
  enum rs_log_severity
  
  See Also:
  
  Constant Field Values
- RS_LOG_SEVERITY_WARN
```
public static final int RS_LOG_SEVERITY_WARN
```
  enum rs_log_severity
  
  See Also:
  
  Constant Field Values
- RS_LOG_SEVERITY_ERROR
```
public static final int RS_LOG_SEVERITY_ERROR
```
  enum rs_log_severity
  
  See Also:
  
  Constant Field Values
- RS_LOG_SEVERITY_FATAL
```
public static final int RS_LOG_SEVERITY_FATAL
```
  enum rs_log_severity
  
  See Also:
  
  Constant Field Values
- RS_LOG_SEVERITY_NONE
```
public static final int RS_LOG_SEVERITY_NONE
```
  enum rs_log_severity
  
  See Also:
  
  Constant Field Values
- RS_LOG_SEVERITY_COUNT
```
public static final int RS_LOG_SEVERITY_COUNT
```
  enum rs_log_severity
  
  See Also:
  
  Constant Field Values
- RS_EVENT_IMU_ACCEL
```
public static final int RS_EVENT_IMU_ACCEL
```
  enum rs_event_source
  
  See Also:
  
  Constant Field Values
- RS_EVENT_IMU_GYRO
```
public static final int RS_EVENT_IMU_GYRO
```
  enum rs_event_source
  
  See Also:
  
  Constant Field Values
- RS_EVENT_IMU_DEPTH_CAM
```
public static final int RS_EVENT_IMU_DEPTH_CAM
```
  enum rs_event_source
  
  See Also:
  
  Constant Field Values
- RS_EVENT_IMU_MOTION_CAM
```
public static final int RS_EVENT_IMU_MOTION_CAM
```
  enum rs_event_source
  
  See Also:
  
  Constant Field Values
- RS_EVENT_G0_SYNC
```
public static final int RS_EVENT_G0_SYNC
```
  enum rs_event_source
  
  See Also:
  
  Constant Field Values
- RS_EVENT_G1_SYNC
```
public static final int RS_EVENT_G1_SYNC
```
  enum rs_event_source
  
  See Also:
  
  Constant Field Values
- RS_EVENT_G2_SYNC
```
public static final int RS_EVENT_G2_SYNC
```
  enum rs_event_source
  
  See Also:
  
  Constant Field Values
- RS_EVENT_SOURCE_COUNT
```
public static final int RS_EVENT_SOURCE_COUNT
```
  enum rs_event_source
  
  See Also:
  
  Constant Field Values
- RS_TIMESTAMP_DOMAIN_CAMERA
```
public static final int RS_TIMESTAMP_DOMAIN_CAMERA
```
  enum rs_timestamp_domain
  
  See Also:
  
  Constant Field Values
- RS_TIMESTAMP_DOMAIN_MICROCONTROLLER
```
public static final int RS_TIMESTAMP_DOMAIN_MICROCONTROLLER
```
  enum rs_timestamp_domain
  
  See Also:
  
  Constant Field Values
- RS_TIMESTAMP_DOMAIN_COUNT
```
public static final int RS_TIMESTAMP_DOMAIN_COUNT
```
  enum rs_timestamp_domain
  
  See Also:
  
  Constant Field Values
- fisheye
```
public static final int fisheye
```
  enum class rs::stream
  
  See Also:
  
  Constant Field Values
- points
```
public static final int points
```
  enum class rs::stream
  
  See Also:
  
  Constant Field Values
- rectified_color
```
public static final int rectified_color
```
  enum class rs::stream
  
  See Also:
  
  Constant Field Values
- color_aligned_to_depth
```
public static final int color_aligned_to_depth
```
  enum class rs::stream
  
  See Also:
  
  Constant Field Values
- infrared2_aligned_to_depth
```
public static final int infrared2_aligned_to_depth
```
  enum class rs::stream
  
  See Also:
  
  Constant Field Values
- depth_aligned_to_color
```
public static final int depth_aligned_to_color
```
  enum class rs::stream
  
  See Also:
  
  Constant Field Values
- depth_aligned_to_rectified_color
```
public static final int depth_aligned_to_rectified_color
```
  enum class rs::stream
  
  See Also:
  
  Constant Field Values
- depth_aligned_to_infrared2
```
public static final int depth_aligned_to_infrared2
```
  enum class rs::stream
  
  See Also:
  
  Constant Field Values
- any
```
public static final int any
```
  enum class rs::format
  
  See Also:
  
  Constant Field Values
- z16
```
public static final int z16
```
  enum class rs::format
  
  See Also:
  
  Constant Field Values
- disparity16
```
public static final int disparity16
```
  enum class rs::format
  
  See Also:
  
  Constant Field Values
- xyz32f
```
public static final int xyz32f
```
  enum class rs::format
  
  See Also:
  
  Constant Field Values
- yuyv
```
public static final int yuyv
```
  enum class rs::format
  
  See Also:
  
  Constant Field Values
- rgb8
```
public static final int rgb8
```
  enum class rs::format
  
  See Also:
  
  Constant Field Values
- bgr8
```
public static final int bgr8
```
  enum class rs::format
  
  See Also:
  
  Constant Field Values
- rgba8
```
public static final int rgba8
```
  enum class rs::format
  
  See Also:
  
  Constant Field Values
- bgra8
```
public static final int bgra8
```
  enum class rs::format
  
  See Also:
  
  Constant Field Values
- y8
```
public static final int y8
```
  enum class rs::format
  
  See Also:
  
  Constant Field Values
- y16
```
public static final int y16
```
  enum class rs::format
  
  See Also:
  
  Constant Field Values
- raw10
```
public static final int raw10
```
  enum class rs::format
  
  See Also:
  
  Constant Field Values
- raw16
```
public static final int raw16
```
  enum class rs::format
  
  See Also:
  
  Constant Field Values
- raw8
```
public static final int raw8
```
  enum class rs::format
  
  See Also:
  
  Constant Field Values
- continous
```
public static final int continous
```
  enum class rs::output_buffer_format
  
  See Also:
  
  Constant Field Values
- output_native
```
public static final int output_native
```
  enum class rs::output_buffer_format
  
  See Also:
  
  Constant Field Values
- best_quality
```
public static final int best_quality
```
  enum class rs::preset
  
  See Also:
  
  Constant Field Values
- largest_image
```
public static final int largest_image
```
  enum class rs::preset
  
  See Also:
  
  Constant Field Values
- highest_framerate
```
public static final int highest_framerate
```
  enum class rs::preset
  
  See Also:
  
  Constant Field Values
- none
```
public static final int none
```
  enum class rs::distortion
  
  See Also:
  
  Constant Field Values
- modified_brown_conrady
```
public static final int modified_brown_conrady
```
  enum class rs::distortion
  
  See Also:
  
  Constant Field Values
- inverse_brown_conrady
```
public static final int inverse_brown_conrady
```
  enum class rs::distortion
  
  See Also:
  
  Constant Field Values
- distortion_ftheta
```
public static final int distortion_ftheta
```
  enum class rs::distortion
  
  See Also:
  
  Constant Field Values
- color_backlight_compensation
```
public static final int color_backlight_compensation
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- color_brightness
```
public static final int color_brightness
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- color_contrast
```
public static final int color_contrast
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- color_exposure
```
public static final int color_exposure
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- color_gain
```
public static final int color_gain
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- color_gamma
```
public static final int color_gamma
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- color_hue
```
public static final int color_hue
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- color_saturation
```
public static final int color_saturation
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- color_sharpness
```
public static final int color_sharpness
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- color_white_balance
```
public static final int color_white_balance
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- color_enable_auto_exposure
```
public static final int color_enable_auto_exposure
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- color_enable_auto_white_balance
```
public static final int color_enable_auto_white_balance
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- f200_laser_power
```
public static final int f200_laser_power
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- f200_accuracy
```
public static final int f200_accuracy
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- f200_motion_range
```
public static final int f200_motion_range
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- f200_filter_option
```
public static final int f200_filter_option
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- f200_confidence_threshold
```
public static final int f200_confidence_threshold
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- f200_dynamic_fps
```
public static final int f200_dynamic_fps
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- sr300_auto_range_enable_motion_versus_range
```
public static final int sr300_auto_range_enable_motion_versus_range
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- sr300_auto_range_enable_laser
```
public static final int sr300_auto_range_enable_laser
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- sr300_auto_range_min_motion_versus_range
```
public static final int sr300_auto_range_min_motion_versus_range
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- sr300_auto_range_max_motion_versus_range
```
public static final int sr300_auto_range_max_motion_versus_range
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- sr300_auto_range_start_motion_versus_range
```
public static final int sr300_auto_range_start_motion_versus_range
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- sr300_auto_range_min_laser
```
public static final int sr300_auto_range_min_laser
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- sr300_auto_range_max_laser
```
public static final int sr300_auto_range_max_laser
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- sr300_auto_range_start_laser
```
public static final int sr300_auto_range_start_laser
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- sr300_auto_range_upper_threshold
```
public static final int sr300_auto_range_upper_threshold
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- sr300_auto_range_lower_threshold
```
public static final int sr300_auto_range_lower_threshold
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- r200_lr_auto_exposure_enabled
```
public static final int r200_lr_auto_exposure_enabled
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- r200_lr_gain
```
public static final int r200_lr_gain
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- r200_lr_exposure
```
public static final int r200_lr_exposure
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- r200_emitter_enabled
```
public static final int r200_emitter_enabled
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- r200_depth_units
```
public static final int r200_depth_units
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- r200_depth_clamp_min
```
public static final int r200_depth_clamp_min
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- r200_depth_clamp_max
```
public static final int r200_depth_clamp_max
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- r200_disparity_multiplier
```
public static final int r200_disparity_multiplier
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- r200_disparity_shift
```
public static final int r200_disparity_shift
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- r200_auto_exposure_mean_intensity_set_point
```
public static final int r200_auto_exposure_mean_intensity_set_point
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- r200_auto_exposure_bright_ratio_set_point
```
public static final int r200_auto_exposure_bright_ratio_set_point
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- r200_auto_exposure_kp_gain
```
public static final int r200_auto_exposure_kp_gain
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- r200_auto_exposure_kp_exposure
```
public static final int r200_auto_exposure_kp_exposure
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- r200_auto_exposure_kp_dark_threshold
```
public static final int r200_auto_exposure_kp_dark_threshold
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- r200_auto_exposure_top_edge
```
public static final int r200_auto_exposure_top_edge
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- r200_auto_exposure_bottom_edge
```
public static final int r200_auto_exposure_bottom_edge
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- r200_auto_exposure_left_edge
```
public static final int r200_auto_exposure_left_edge
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- r200_auto_exposure_right_edge
```
public static final int r200_auto_exposure_right_edge
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- r200_depth_control_estimate_median_decrement
```
public static final int r200_depth_control_estimate_median_decrement
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- r200_depth_control_estimate_median_increment
```
public static final int r200_depth_control_estimate_median_increment
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- r200_depth_control_median_threshold
```
public static final int r200_depth_control_median_threshold
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- r200_depth_control_score_minimum_threshold
```
public static final int r200_depth_control_score_minimum_threshold
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- r200_depth_control_score_maximum_threshold
```
public static final int r200_depth_control_score_maximum_threshold
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- r200_depth_control_texture_count_threshold
```
public static final int r200_depth_control_texture_count_threshold
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- r200_depth_control_texture_difference_threshold
```
public static final int r200_depth_control_texture_difference_threshold
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- r200_depth_control_second_peak_threshold
```
public static final int r200_depth_control_second_peak_threshold
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- r200_depth_control_neighbor_threshold
```
public static final int r200_depth_control_neighbor_threshold
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- r200_depth_control_lr_threshold
```
public static final int r200_depth_control_lr_threshold
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- fisheye_exposure
```
public static final int fisheye_exposure
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- fisheye_gain
```
public static final int fisheye_gain
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- fisheye_strobe
```
public static final int fisheye_strobe
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- fisheye_external_trigger
```
public static final int fisheye_external_trigger
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- fisheye_color_auto_exposure
```
public static final int fisheye_color_auto_exposure
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- fisheye_color_auto_exposure_mode
```
public static final int fisheye_color_auto_exposure_mode
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- fisheye_color_auto_exposure_rate
```
public static final int fisheye_color_auto_exposure_rate
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- fisheye_color_auto_exposure_sample_rate
```
public static final int fisheye_color_auto_exposure_sample_rate
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- fisheye_color_auto_exposure_skip_frames
```
public static final int fisheye_color_auto_exposure_skip_frames
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- frames_queue_size
```
public static final int frames_queue_size
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- hardware_logger_enabled
```
public static final int hardware_logger_enabled
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- total_frame_drops
```
public static final int total_frame_drops
```
  enum class rs::option
  
  See Also:
  
  Constant Field Values
- actual_exposure
```
public static final int actual_exposure
```
  enum class rs::frame_metadata
  
  See Also:
  
  Constant Field Values
- actual_fps
```
public static final int actual_fps
```
  enum class rs::frame_metadata
  
  See Also:
  
  Constant Field Values
- depth
```
public static final int depth
```
  enum class rs::capabilities
  
  See Also:
  
  Constant Field Values
- color
```
public static final int color
```
  enum class rs::capabilities
  
  See Also:
  
  Constant Field Values
- infrared
```
public static final int infrared
```
  enum class rs::capabilities
  
  See Also:
  
  Constant Field Values
- infrared2
```
public static final int infrared2
```
  enum class rs::capabilities
  
  See Also:
  
  Constant Field Values
- fish_eye
```
public static final int fish_eye
```
  enum class rs::capabilities
  
  See Also:
  
  Constant Field Values
- motion_events
```
public static final int motion_events
```
  enum class rs::capabilities
  
  See Also:
  
  Constant Field Values
- motion_module_fw_update
```
public static final int motion_module_fw_update
```
  enum class rs::capabilities
  
  See Also:
  
  Constant Field Values
- adapter_board
```
public static final int adapter_board
```
  enum class rs::capabilities
  
  See Also:
  
  Constant Field Values
- enumeration
```
public static final int enumeration
```
  enum class rs::capabilities
  
  See Also:
  
  Constant Field Values
- motion_module_firmware_update
```
public static final int motion_module_firmware_update
```
  enum class rs::blob_type
  
  See Also:
  
  Constant Field Values
- device_name
```
public static final int device_name
```
  enum class rs::camera_info
  
  See Also:
  
  Constant Field Values
- serial_number
```
public static final int serial_number
```
  enum class rs::camera_info
  
  See Also:
  
  Constant Field Values
- camera_firmware_version
```
public static final int camera_firmware_version
```
  enum class rs::camera_info
  
  See Also:
  
  Constant Field Values
- adapter_board_firmware_version
```
public static final int adapter_board_firmware_version
```
  enum class rs::camera_info
  
  See Also:
  
  Constant Field Values
- motion_module_firmware_version
```
public static final int motion_module_firmware_version
```
  enum class rs::camera_info
  
  See Also:
  
  Constant Field Values
- camera_type
```
public static final int camera_type
```
  enum class rs::camera_info
  
  See Also:
  
  Constant Field Values
- oem_id
```
public static final int oem_id
```
  enum class rs::camera_info
  
  See Also:
  
  Constant Field Values
- isp_fw_version
```
public static final int isp_fw_version
```
  enum class rs::camera_info
  
  See Also:
  
  Constant Field Values
- content_version
```
public static final int content_version
```
  enum class rs::camera_info
  
  See Also:
  
  Constant Field Values
- module_version
```
public static final int module_version
```
  enum class rs::camera_info
  
  See Also:
  
  Constant Field Values
- imager_model_number
```
public static final int imager_model_number
```
  enum class rs::camera_info
  
  See Also:
  
  Constant Field Values
- build_date
```
public static final int build_date
```
  enum class rs::camera_info
  
  See Also:
  
  Constant Field Values
- calibration_date
```
public static final int calibration_date
```
  enum class rs::camera_info
  
  See Also:
  
  Constant Field Values
- program_date
```
public static final int program_date
```
  enum class rs::camera_info
  
  See Also:
  
  Constant Field Values
- focus_alignment_date
```
public static final int focus_alignment_date
```
  enum class rs::camera_info
  
  See Also:
  
  Constant Field Values
- emitter_type
```
public static final int emitter_type
```
  enum class rs::camera_info
  
  See Also:
  
  Constant Field Values
- focus_value
```
public static final int focus_value
```
  enum class rs::camera_info
  
  See Also:
  
  Constant Field Values
- lens_type
```
public static final int lens_type
```
  enum class rs::camera_info
  
  See Also:
  
  Constant Field Values
- third_lens_type
```
public static final int third_lens_type
```
  enum class rs::camera_info
  
  See Also:
  
  Constant Field Values
- lens_coating_type
```
public static final int lens_coating_type
```
  enum class rs::camera_info
  
  See Also:
  
  Constant Field Values
- third_lens_coating_type
```
public static final int third_lens_coating_type
```
  enum class rs::camera_info
  
  See Also:
  
  Constant Field Values
- lens_nominal_baseline
```
public static final int lens_nominal_baseline
```
  enum class rs::camera_info
  
  See Also:
  
  Constant Field Values
- third_lens_nominal_baseline
```
public static final int third_lens_nominal_baseline
```
  enum class rs::camera_info
  
  See Also:
  
  Constant Field Values
- video
```
public static final byte video
```
  enum class rs::source
  
  See Also:
  
  Constant Field Values
- motion_data
```
public static final byte motion_data
```
  enum class rs::source
  
  See Also:
  
  Constant Field Values
- all_sources
```
public static final byte all_sources
```
  enum class rs::source
  
  See Also:
  
  Constant Field Values
- event_imu_accel
```
public static final byte event_imu_accel
```
  enum class rs::event
  
  See Also:
  
  Constant Field Values
- event_imu_gyro
```
public static final byte event_imu_gyro
```
  enum class rs::event
  
  See Also:
  
  Constant Field Values
- event_imu_depth_cam
```
public static final byte event_imu_depth_cam
```
  enum class rs::event
  
  See Also:
  
  Constant Field Values
- event_imu_motion_cam
```
public static final byte event_imu_motion_cam
```
  enum class rs::event
  
  See Also:
  
  Constant Field Values
- event_imu_g0_sync
```
public static final byte event_imu_g0_sync
```
  enum class rs::event
  
  See Also:
  
  Constant Field Values
- event_imu_g1_sync
```
public static final byte event_imu_g1_sync
```
  enum class rs::event
  
  See Also:
  
  Constant Field Values
- event_imu_g2_sync
```
public static final byte event_imu_g2_sync
```
  enum class rs::event
  
  See Also:
  
  Constant Field Values
- camera
```
public static final int camera
```
  enum class rs::timestamp_domain
  
  See Also:
  
  Constant Field Values
- microcontroller
```
public static final int microcontroller
```
  enum class rs::timestamp_domain
  
  See Also:
  
  Constant Field Values
- debug
```
public static final int debug
```
  enum class rs::log_severity
  
  See Also:
  
  Constant Field Values
- info
```
public static final int info
```
  enum class rs::log_severity
  
  See Also:
  
  Constant Field Values
- warn
```
public static final int warn
```
  enum class rs::log_severity
  
  See Also:
  
  Constant Field Values
- error
```
public static final int error
```
  enum class rs::log_severity
  
  See Also:
  
  Constant Field Values
- fatal
```
public static final int fatal
```
  enum class rs::log_severity
  
  See Also:
  
  Constant Field Values
- log_none
```
public static final int log_none
```
  enum class rs::log_severity
  
  See Also:
  
  Constant Field Values

Constructor Detail
- RealSense
```
public RealSense()
```

Method Detail

RS_API_VERSION_STR

@MemberGetter
public static String RS_API_VERSION_STR()

rs_create_context
```
public static rs_context rs_create_context(int api_version,
                                           @Cast(value="rs_error**")
                                           PointerPointer error)
```
create realsense context required for rest of the API

Parameters:

api_version - [in] the user is expected to pass his version of RS_API_VERSION to make sure he is running with correct librealsense version

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

Returns:

context object

rs_create_context

public static rs_context rs_create_context(int api_version,
                                           @ByPtrPtr
                                           rs_error error)

rs_delete_context
```
public static void rs_delete_context(rs_context context,
                                     @Cast(value="rs_error**")
                                     PointerPointer error)
```
frees the relevant context object, this might invalidate rs_device pointers created from this context

Parameters:

context - [in] the object that is no longer needed

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs_delete_context

public static void rs_delete_context(rs_context context,
                                     @ByPtrPtr
                                     rs_error error)

rs_get_device_count

public static int rs_get_device_count(@Const
                                      rs_context context,
                                      @Cast(value="rs_error**")
                                      PointerPointer error)

determine number of connected devices

Parameters:: error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the count of devices

rs_get_device_count

public static int rs_get_device_count(@Const
                                      rs_context context,
                                      @ByPtrPtr
                                      rs_error error)

rs_get_device

public static rs_device rs_get_device(rs_context context,
                                      int index,
                                      @Cast(value="rs_error**")
                                      PointerPointer error)

retrieve connected device by index

Parameters:: index - [in] the zero based index of device to retrieve; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the requested device

rs_get_device

public static rs_device rs_get_device(rs_context context,
                                      int index,
                                      @ByPtrPtr
                                      rs_error error)

rs_get_device_name

@Cast(value="const char*")
public static BytePointer rs_get_device_name(@Const
                                                                        rs_device device,
                                                                        @Cast(value="rs_error**")
                                                                        PointerPointer error)

retrieve a human readable device model string

Parameters:: error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the model string, such as "Intel RealSense F200" or "Intel RealSense R200"

rs_get_device_name

@Cast(value="const char*")
public static BytePointer rs_get_device_name(@Const
                                                                        rs_device device,
                                                                        @ByPtrPtr
                                                                        rs_error error)

rs_get_device_serial

@Cast(value="const char*")
public static BytePointer rs_get_device_serial(@Const
                                                                          rs_device device,
                                                                          @Cast(value="rs_error**")
                                                                          PointerPointer error)

retrieve the unique serial number of the device

Parameters:: error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the serial number, in a format specific to the device model

rs_get_device_serial

@Cast(value="const char*")
public static BytePointer rs_get_device_serial(@Const
                                                                          rs_device device,
                                                                          @ByPtrPtr
                                                                          rs_error error)

rs_get_device_info

@Cast(value="const char*")
public static BytePointer rs_get_device_info(@Const
                                                                        rs_device device,
                                                                        @Cast(value="rs_camera_info")
                                                                        int info,
                                                                        @Cast(value="rs_error**")
                                                                        PointerPointer error)

retrieve camera specific information, like versions of various internal componnents

Parameters:: error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the requested camera info string, in a format specific to the device model

rs_get_device_info

@Cast(value="const char*")
public static BytePointer rs_get_device_info(@Const
                                                                        rs_device device,
                                                                        @Cast(value="rs_camera_info")
                                                                        int info,
                                                                        @ByPtrPtr
                                                                        rs_error error)

rs_get_device_usb_port_id

@Cast(value="const char*")
public static BytePointer rs_get_device_usb_port_id(@Const
                                                                               rs_device device,
                                                                               @Cast(value="rs_error**")
                                                                               PointerPointer error)

retrieve the USB port number of the device

Parameters:: error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the USB port number in a string form "##-##"

rs_get_device_usb_port_id

@Cast(value="const char*")
public static BytePointer rs_get_device_usb_port_id(@Const
                                                                               rs_device device,
                                                                               @ByPtrPtr
                                                                               rs_error error)

rs_get_device_firmware_version

@Cast(value="const char*")
public static BytePointer rs_get_device_firmware_version(@Const
                                                                                    rs_device device,
                                                                                    @Cast(value="rs_error**")
                                                                                    PointerPointer error)

retrieve the version of the firmware currently installed on the device

Parameters:: error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: firmware version string, in a format is specific to device model

rs_get_device_firmware_version

@Cast(value="const char*")
public static BytePointer rs_get_device_firmware_version(@Const
                                                                                    rs_device device,
                                                                                    @ByPtrPtr
                                                                                    rs_error error)

rs_get_device_extrinsics

public static void rs_get_device_extrinsics(@Const
                                            rs_device device,
                                            @Cast(value="rs_stream")
                                            int from_stream,
                                            @Cast(value="rs_stream")
                                            int to_stream,
                                            rs_extrinsics extrin,
                                            @Cast(value="rs_error**")
                                            PointerPointer error)

retrieve extrinsic transformation between the viewpoints of two different streams

Parameters:: from_stream - [in] stream whose coordinate space we will transform from; to_stream - [in] stream whose coordinate space we will transform to; extrin - [out] the transformation between the two streams; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs_get_device_extrinsics

public static void rs_get_device_extrinsics(@Const
                                            rs_device device,
                                            @Cast(value="rs_stream")
                                            int from_stream,
                                            @Cast(value="rs_stream")
                                            int to_stream,
                                            rs_extrinsics extrin,
                                            @ByPtrPtr
                                            rs_error error)

rs_get_motion_extrinsics_from

public static void rs_get_motion_extrinsics_from(@Const
                                                 rs_device device,
                                                 @Cast(value="rs_stream")
                                                 int from,
                                                 rs_extrinsics extrin,
                                                 @Cast(value="rs_error**")
                                                 PointerPointer error)

retrieve extrinsic transformation between specific stream and the motion module

Parameters:: from_stream - [in] stream whose coordinate space we will transform from; extrin - [out] the transformation between the specific stream and motion module; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs_get_motion_extrinsics_from

public static void rs_get_motion_extrinsics_from(@Const
                                                 rs_device device,
                                                 @Cast(value="rs_stream")
                                                 int from,
                                                 rs_extrinsics extrin,
                                                 @ByPtrPtr
                                                 rs_error error)

rs_get_device_depth_scale

public static float rs_get_device_depth_scale(@Const
                                              rs_device device,
                                              @Cast(value="rs_error**")
                                              PointerPointer error)

retrieve mapping between the units of the depth image and meters

Parameters:: error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: depth in meters corresponding to a depth value of 1

rs_get_device_depth_scale

public static float rs_get_device_depth_scale(@Const
                                              rs_device device,
                                              @ByPtrPtr
                                              rs_error error)

rs_device_supports_option

public static int rs_device_supports_option(@Const
                                            rs_device device,
                                            @Cast(value="rs_option")
                                            int option,
                                            @Cast(value="rs_error**")
                                            PointerPointer error)

determine if the device allows a specific option to be queried and set

Parameters:: option - [in] the option to check for support; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: true if the option can be queried and set

rs_device_supports_option

public static int rs_device_supports_option(@Const
                                            rs_device device,
                                            @Cast(value="rs_option")
                                            int option,
                                            @ByPtrPtr
                                            rs_error error)

rs_get_stream_mode_count

public static int rs_get_stream_mode_count(@Const
                                           rs_device device,
                                           @Cast(value="rs_stream")
                                           int stream,
                                           @Cast(value="rs_error**")
                                           PointerPointer error)

determine the number of streaming modes available for a given stream

Parameters:: stream - [in] the stream whose modes will be enumerated; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the count of available modes

rs_get_stream_mode_count

public static int rs_get_stream_mode_count(@Const
                                           rs_device device,
                                           @Cast(value="rs_stream")
                                           int stream,
                                           @ByPtrPtr
                                           rs_error error)

rs_get_stream_mode

public static void rs_get_stream_mode(@Const
                                      rs_device device,
                                      @Cast(value="rs_stream")
                                      int stream,
                                      int index,
                                      IntPointer width,
                                      IntPointer height,
                                      @Cast(value="rs_format*")
                                      IntPointer format,
                                      IntPointer framerate,
                                      @Cast(value="rs_error**")
                                      PointerPointer error)

determine the properties of a specific streaming mode

Parameters:: stream - [in] the stream whose mode will be queried; index - [in] the zero based index of the streaming mode; width - [out] the width of a frame image in pixels; height - [out] the height of a frame image in pixels; format - [out] the pixel format of a frame image; framerate - [out] the number of frames which will be streamed per second; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs_get_stream_mode

public static void rs_get_stream_mode(@Const
                                      rs_device device,
                                      @Cast(value="rs_stream")
                                      int stream,
                                      int index,
                                      IntPointer width,
                                      IntPointer height,
                                      @Cast(value="rs_format*")
                                      IntPointer format,
                                      IntPointer framerate,
                                      @ByPtrPtr
                                      rs_error error)

rs_get_stream_mode

public static void rs_get_stream_mode(@Const
                                      rs_device device,
                                      @Cast(value="rs_stream")
                                      int stream,
                                      int index,
                                      IntBuffer width,
                                      IntBuffer height,
                                      @Cast(value="rs_format*")
                                      IntBuffer format,
                                      IntBuffer framerate,
                                      @ByPtrPtr
                                      rs_error error)

rs_get_stream_mode

public static void rs_get_stream_mode(@Const
                                      rs_device device,
                                      @Cast(value="rs_stream")
                                      int stream,
                                      int index,
                                      int[] width,
                                      int[] height,
                                      @Cast(value="rs_format*")
                                      int[] format,
                                      int[] framerate,
                                      @ByPtrPtr
                                      rs_error error)

rs_enable_stream_ex

public static void rs_enable_stream_ex(rs_device device,
                                       @Cast(value="rs_stream")
                                       int stream,
                                       int width,
                                       int height,
                                       @Cast(value="rs_format")
                                       int format,
                                       int framerate,
                                       @Cast(value="rs_output_buffer_format")
                                       int output_format,
                                       @Cast(value="rs_error**")
                                       PointerPointer error)

enable a specific stream and request specific properties

Parameters:: stream - [in] the stream to enable; width - [in] the desired width of a frame image in pixels, or 0 if any width is acceptable; height - [in] the desired height of a frame image in pixels, or 0 if any height is acceptable; format - [in] the pixel format of a frame image, or ANY if any format is acceptable; framerate - [in] the number of frames which will be streamed per second, or 0 if any framerate is acceptable; output_format - [in] output buffer format (contious in memory / native with pitch); error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs_enable_stream_ex

public static void rs_enable_stream_ex(rs_device device,
                                       @Cast(value="rs_stream")
                                       int stream,
                                       int width,
                                       int height,
                                       @Cast(value="rs_format")
                                       int format,
                                       int framerate,
                                       @Cast(value="rs_output_buffer_format")
                                       int output_format,
                                       @ByPtrPtr
                                       rs_error error)

rs_enable_stream

public static void rs_enable_stream(rs_device device,
                                    @Cast(value="rs_stream")
                                    int stream,
                                    int width,
                                    int height,
                                    @Cast(value="rs_format")
                                    int format,
                                    int framerate,
                                    @Cast(value="rs_error**")
                                    PointerPointer error)

enable a specific stream and request specific properties

Parameters:: stream - [in] the stream to enable; width - [in] the desired width of a frame image in pixels, or 0 if any width is acceptable; height - [in] the desired height of a frame image in pixels, or 0 if any height is acceptable; format - [in] the pixel format of a frame image, or ANY if any format is acceptable; framerate - [in] the number of frames which will be streamed per second, or 0 if any framerate is acceptable; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs_enable_stream

public static void rs_enable_stream(rs_device device,
                                    @Cast(value="rs_stream")
                                    int stream,
                                    int width,
                                    int height,
                                    @Cast(value="rs_format")
                                    int format,
                                    int framerate,
                                    @ByPtrPtr
                                    rs_error error)

rs_enable_stream_preset

public static void rs_enable_stream_preset(rs_device device,
                                           @Cast(value="rs_stream")
                                           int stream,
                                           @Cast(value="rs_preset")
                                           int preset,
                                           @Cast(value="rs_error**")
                                           PointerPointer error)

enable a specific stream and request properties using a preset

Parameters:: stream - [in] the stream to enable; preset - [in] the preset to use to enable the stream; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs_enable_stream_preset

public static void rs_enable_stream_preset(rs_device device,
                                           @Cast(value="rs_stream")
                                           int stream,
                                           @Cast(value="rs_preset")
                                           int preset,
                                           @ByPtrPtr
                                           rs_error error)

rs_disable_stream

public static void rs_disable_stream(rs_device device,
                                     @Cast(value="rs_stream")
                                     int stream,
                                     @Cast(value="rs_error**")
                                     PointerPointer error)

disable a specific stream

Parameters:: stream - [in] the stream to disable; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs_disable_stream

public static void rs_disable_stream(rs_device device,
                                     @Cast(value="rs_stream")
                                     int stream,
                                     @ByPtrPtr
                                     rs_error error)

rs_is_stream_enabled

public static int rs_is_stream_enabled(@Const
                                       rs_device device,
                                       @Cast(value="rs_stream")
                                       int stream,
                                       @Cast(value="rs_error**")
                                       PointerPointer error)

determine if a specific stream is enabled

Parameters:: stream - [in] the stream to check; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: true if the stream is currently enabled

rs_is_stream_enabled

public static int rs_is_stream_enabled(@Const
                                       rs_device device,
                                       @Cast(value="rs_stream")
                                       int stream,
                                       @ByPtrPtr
                                       rs_error error)

rs_get_stream_width

public static int rs_get_stream_width(@Const
                                      rs_device device,
                                      @Cast(value="rs_stream")
                                      int stream,
                                      @Cast(value="rs_error**")
                                      PointerPointer error)

retrieve the width in pixels of a specific stream, equivalent to the width field from the stream's intrinsic

Parameters:: stream - [in] the stream whose width to retrieve; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the width in pixels of images from this stream

rs_get_stream_width

public static int rs_get_stream_width(@Const
                                      rs_device device,
                                      @Cast(value="rs_stream")
                                      int stream,
                                      @ByPtrPtr
                                      rs_error error)

rs_get_stream_height

public static int rs_get_stream_height(@Const
                                       rs_device device,
                                       @Cast(value="rs_stream")
                                       int stream,
                                       @Cast(value="rs_error**")
                                       PointerPointer error)

retrieve the height in pixels of a specific stream, equivalent to the height field from the stream's intrinsic

Parameters:: stream - [in] the stream whose height to retrieve; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the height in pixels of images from this stream

rs_get_stream_height

public static int rs_get_stream_height(@Const
                                       rs_device device,
                                       @Cast(value="rs_stream")
                                       int stream,
                                       @ByPtrPtr
                                       rs_error error)

rs_get_stream_format

@Cast(value="rs_format")
public static int rs_get_stream_format(@Const
                                                                rs_device device,
                                                                @Cast(value="rs_stream")
                                                                int stream,
                                                                @Cast(value="rs_error**")
                                                                PointerPointer error)

retrieve the pixel format for a specific stream

Parameters:: stream - [in] the stream whose format to retrieve; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the pixel format of the stream

rs_get_stream_format

@Cast(value="rs_format")
public static int rs_get_stream_format(@Const
                                                                rs_device device,
                                                                @Cast(value="rs_stream")
                                                                int stream,
                                                                @ByPtrPtr
                                                                rs_error error)

rs_get_stream_framerate

public static int rs_get_stream_framerate(@Const
                                          rs_device device,
                                          @Cast(value="rs_stream")
                                          int stream,
                                          @Cast(value="rs_error**")
                                          PointerPointer error)

retrieve the framerate for a specific stream

Parameters:: stream - [in] the stream whose framerate to retrieve; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the framerate of the stream, in frames per second

rs_get_stream_framerate

public static int rs_get_stream_framerate(@Const
                                          rs_device device,
                                          @Cast(value="rs_stream")
                                          int stream,
                                          @ByPtrPtr
                                          rs_error error)

rs_get_stream_intrinsics

public static void rs_get_stream_intrinsics(@Const
                                            rs_device device,
                                            @Cast(value="rs_stream")
                                            int stream,
                                            rs_intrinsics intrin,
                                            @Cast(value="rs_error**")
                                            PointerPointer error)

retrieve intrinsic camera parameters for a specific stream

Parameters:: stream - [in] the stream whose parameters to retrieve; intrin - [out] the intrinsic parameters of the stream; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs_get_stream_intrinsics

public static void rs_get_stream_intrinsics(@Const
                                            rs_device device,
                                            @Cast(value="rs_stream")
                                            int stream,
                                            rs_intrinsics intrin,
                                            @ByPtrPtr
                                            rs_error error)

rs_get_motion_intrinsics

public static void rs_get_motion_intrinsics(@Const
                                            rs_device device,
                                            rs_motion_intrinsics intrinsic,
                                            @Cast(value="rs_error**")
                                            PointerPointer error)

retrieve intrinsic camera parameters for a motion module

Parameters:: intrinsic - [out] the intrinsic parameters; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs_get_motion_intrinsics

public static void rs_get_motion_intrinsics(@Const
                                            rs_device device,
                                            rs_motion_intrinsics intrinsic,
                                            @ByPtrPtr
                                            rs_error error)

rs_set_frame_callback

public static void rs_set_frame_callback(rs_device device,
                                         @Cast(value="rs_stream")
                                         int stream,
                                         rs_frame_callback_ptr on_frame,
                                         Pointer user,
                                         @Cast(value="rs_error**")
                                         PointerPointer error)

set up a frame callback that will be called immediately when an image is available, with no synchronization logic applied

Parameters:: stream - [in] the stream for whose images the callback should be registered; on_frame - [in] the callback which will receive the frame data and timestamp; user - [in] a user data point to be passed to the callback; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs_set_frame_callback

public static void rs_set_frame_callback(rs_device device,
                                         @Cast(value="rs_stream")
                                         int stream,
                                         rs_frame_callback_ptr on_frame,
                                         Pointer user,
                                         @ByPtrPtr
                                         rs_error error)

rs_enable_motion_tracking

public static void rs_enable_motion_tracking(rs_device device,
                                             rs_motion_callback_ptr on_motion_event,
                                             Pointer motion_handler,
                                             rs_timestamp_callback_ptr on_timestamp_event,
                                             Pointer timestamp_handler,
                                             @Cast(value="rs_error**")
                                             PointerPointer error)

enable and configure motion-tracking data handlers

Parameters:: on_motion_event - [in] user-defined routine to be invoked when a motion data arrives; motion_handler - [in] a user data point to be passed to the motion event callback; on_timestamp_event - [in] user-defined routine to be invoked on timestamp; timestamp_handler - [in] a user data point to be passed to the motion event callback; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs_enable_motion_tracking

public static void rs_enable_motion_tracking(rs_device device,
                                             rs_motion_callback_ptr on_motion_event,
                                             Pointer motion_handler,
                                             rs_timestamp_callback_ptr on_timestamp_event,
                                             Pointer timestamp_handler,
                                             @ByPtrPtr
                                             rs_error error)

rs_enable_motion_tracking_cpp
```
public static void rs_enable_motion_tracking_cpp(rs_device device,
                                                 rs_motion_callback motion_callback,
                                                 rs_timestamp_callback timestamp_callback,
                                                 @Cast(value="rs_error**")
                                                 PointerPointer error)
```
enable and configure motion-tracking data handlers Note: rs_enable_motion_tracking is responsible for activating the motion module on-board the device. One of the services it provides is producing shared and high-resolution timestamps for all component hooked-up to it. Usually, librealsense takes care of that and copies the timestamps on the relevant frames. However, when the user has an external device (like a compass) and wishes to synchronize it precisely with image and motion stream he can connect the sensor to a GPIO avaialbe on some devices. Every time sensor will signal, the user will get a timestamp callback with a frame number, source ID and a timestamp. This would allow advanced user to synchronize his compass events (presumably coming though I2C or some other method) with realsense data. (This variant is provided specifically to enable passing lambdas with capture lists safely into the library)

Parameters:

motion_callback - [in] user-defined routine to be invoked when a motion data arrives

timestamp_callback - [in] user-defined routine to be invoked on timestamp

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs_enable_motion_tracking_cpp

public static void rs_enable_motion_tracking_cpp(rs_device device,
                                                 rs_motion_callback motion_callback,
                                                 rs_timestamp_callback timestamp_callback,
                                                 @ByPtrPtr
                                                 rs_error error)

rs_set_frame_callback_cpp

public static void rs_set_frame_callback_cpp(rs_device device,
                                             @Cast(value="rs_stream")
                                             int stream,
                                             rs_frame_callback callback,
                                             @Cast(value="rs_error**")
                                             PointerPointer error)

set up a frame callback that will be called immediately when an image is available, with no synchronization logic applied (This variant is provided specificly to enable passing lambdas with capture lists safely into the library)

Parameters:: stream - [in] the stream for whose images the callback should be registered; callback - [in] the callback which will receive the frame data and timestamp; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs_set_frame_callback_cpp

public static void rs_set_frame_callback_cpp(rs_device device,
                                             @Cast(value="rs_stream")
                                             int stream,
                                             rs_frame_callback callback,
                                             @ByPtrPtr
                                             rs_error error)

rs_disable_motion_tracking

public static void rs_disable_motion_tracking(rs_device device,
                                              @Cast(value="rs_error**")
                                              PointerPointer error)

disable motion-tracking handlers

rs_disable_motion_tracking

public static void rs_disable_motion_tracking(rs_device device,
                                              @ByPtrPtr
                                              rs_error error)

rs_is_motion_tracking_active

public static int rs_is_motion_tracking_active(rs_device device,
                                               @Cast(value="rs_error**")
                                               PointerPointer error)

check if data acquisition is active

rs_is_motion_tracking_active

public static int rs_is_motion_tracking_active(rs_device device,
                                               @ByPtrPtr
                                               rs_error error)

rs_start_device

public static void rs_start_device(rs_device device,
                                   @Cast(value="rs_error**")
                                   PointerPointer error)

begin streaming on all enabled streams for this device

Parameters:: error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs_start_device

public static void rs_start_device(rs_device device,
                                   @ByPtrPtr
                                   rs_error error)

rs_stop_device

public static void rs_stop_device(rs_device device,
                                  @Cast(value="rs_error**")
                                  PointerPointer error)

end data acquisition for the specified source providers

Parameters:: error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs_stop_device

public static void rs_stop_device(rs_device device,
                                  @ByPtrPtr
                                  rs_error error)

rs_start_source

public static void rs_start_source(rs_device device,
                                   @Cast(value="rs_source")
                                   int source,
                                   @Cast(value="rs_error**")
                                   PointerPointer error)

begin streaming on all enabled streams for this device

Parameters:: source - [in] the data source to be activated; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs_start_source

public static void rs_start_source(rs_device device,
                                   @Cast(value="rs_source")
                                   int source,
                                   @ByPtrPtr
                                   rs_error error)

rs_stop_source

public static void rs_stop_source(rs_device device,
                                  @Cast(value="rs_source")
                                  int source,
                                  @Cast(value="rs_error**")
                                  PointerPointer error)

end data acquisition for the specified source providers

Parameters:: source - [in] the data source to be terminated; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs_stop_source

public static void rs_stop_source(rs_device device,
                                  @Cast(value="rs_source")
                                  int source,
                                  @ByPtrPtr
                                  rs_error error)

rs_is_device_streaming

public static int rs_is_device_streaming(@Const
                                         rs_device device,
                                         @Cast(value="rs_error**")
                                         PointerPointer error)

determine if the device is currently streaming

Parameters:: error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: true if the device is currently streaming

rs_is_device_streaming

public static int rs_is_device_streaming(@Const
                                         rs_device device,
                                         @ByPtrPtr
                                         rs_error error)

rs_get_device_option_range

public static void rs_get_device_option_range(rs_device device,
                                              @Cast(value="rs_option")
                                              int option,
                                              DoublePointer min,
                                              DoublePointer max,
                                              DoublePointer step,
                                              @Cast(value="rs_error**")
                                              PointerPointer error)

retrieve the available range of values of a supported option

Parameters:: option - [in] the option whose range should be queried; min - [out] the minimum value which will be accepted for this option; max - [out] the maximum value which will be accepted for this option; step - [out] the granularity of options which accept discrete values, or zero if the option accepts continuous values; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs_get_device_option_range

public static void rs_get_device_option_range(rs_device device,
                                              @Cast(value="rs_option")
                                              int option,
                                              DoublePointer min,
                                              DoublePointer max,
                                              DoublePointer step,
                                              @ByPtrPtr
                                              rs_error error)

rs_get_device_option_range

public static void rs_get_device_option_range(rs_device device,
                                              @Cast(value="rs_option")
                                              int option,
                                              DoubleBuffer min,
                                              DoubleBuffer max,
                                              DoubleBuffer step,
                                              @ByPtrPtr
                                              rs_error error)

rs_get_device_option_range

public static void rs_get_device_option_range(rs_device device,
                                              @Cast(value="rs_option")
                                              int option,
                                              double[] min,
                                              double[] max,
                                              double[] step,
                                              @ByPtrPtr
                                              rs_error error)

rs_get_device_option_range_ex

public static void rs_get_device_option_range_ex(rs_device device,
                                                 @Cast(value="rs_option")
                                                 int option,
                                                 DoublePointer min,
                                                 DoublePointer max,
                                                 DoublePointer step,
                                                 DoublePointer def,
                                                 @Cast(value="rs_error**")
                                                 PointerPointer error)

retrieve the available range of values of a supported option

Parameters:: option - [in] the option whose range should be queried; min - [out] the minimum value which will be accepted for this option; max - [out] the maximum value which will be accepted for this option; step - [out] the granularity of options which accept discrete values, or zero if the option accepts continuous values; def - [out] the default value of the option; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs_get_device_option_range_ex

public static void rs_get_device_option_range_ex(rs_device device,
                                                 @Cast(value="rs_option")
                                                 int option,
                                                 DoublePointer min,
                                                 DoublePointer max,
                                                 DoublePointer step,
                                                 DoublePointer def,
                                                 @ByPtrPtr
                                                 rs_error error)

rs_get_device_option_range_ex

public static void rs_get_device_option_range_ex(rs_device device,
                                                 @Cast(value="rs_option")
                                                 int option,
                                                 DoubleBuffer min,
                                                 DoubleBuffer max,
                                                 DoubleBuffer step,
                                                 DoubleBuffer def,
                                                 @ByPtrPtr
                                                 rs_error error)

rs_get_device_option_range_ex

public static void rs_get_device_option_range_ex(rs_device device,
                                                 @Cast(value="rs_option")
                                                 int option,
                                                 double[] min,
                                                 double[] max,
                                                 double[] step,
                                                 double[] def,
                                                 @ByPtrPtr
                                                 rs_error error)

rs_get_device_options

public static void rs_get_device_options(rs_device device,
                                         @Cast(value="const rs_option*")
                                         IntPointer options,
                                         @Cast(value="unsigned int")
                                         int count,
                                         DoublePointer values,
                                         @Cast(value="rs_error**")
                                         PointerPointer error)

efficiently retrieve the value of an arbitrary number of options, using minimal hardware IO

Parameters:: options - [in] the array of options which should be queried; count - [in] the length of the options and values arrays; values - [out] the array which will receive the values of the queried options; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs_get_device_options

public static void rs_get_device_options(rs_device device,
                                         @Cast(value="const rs_option*")
                                         IntPointer options,
                                         @Cast(value="unsigned int")
                                         int count,
                                         DoublePointer values,
                                         @ByPtrPtr
                                         rs_error error)

rs_get_device_options

public static void rs_get_device_options(rs_device device,
                                         @Cast(value="const rs_option*")
                                         IntBuffer options,
                                         @Cast(value="unsigned int")
                                         int count,
                                         DoubleBuffer values,
                                         @ByPtrPtr
                                         rs_error error)

rs_get_device_options

public static void rs_get_device_options(rs_device device,
                                         @Cast(value="const rs_option*")
                                         int[] options,
                                         @Cast(value="unsigned int")
                                         int count,
                                         double[] values,
                                         @ByPtrPtr
                                         rs_error error)

rs_set_device_options

public static void rs_set_device_options(rs_device device,
                                         @Cast(value="const rs_option*")
                                         IntPointer options,
                                         @Cast(value="unsigned int")
                                         int count,
                                         @Const
                                         DoublePointer values,
                                         @Cast(value="rs_error**")
                                         PointerPointer error)

efficiently set the value of an arbitrary number of options, using minimal hardware IO

Parameters:: options - [in] the array of options which should be set; count - [in] the length of the options and values arrays; values - [in] the array of values to which the options should be set; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs_set_device_options

public static void rs_set_device_options(rs_device device,
                                         @Cast(value="const rs_option*")
                                         IntPointer options,
                                         @Cast(value="unsigned int")
                                         int count,
                                         @Const
                                         DoublePointer values,
                                         @ByPtrPtr
                                         rs_error error)

rs_set_device_options

public static void rs_set_device_options(rs_device device,
                                         @Cast(value="const rs_option*")
                                         IntBuffer options,
                                         @Cast(value="unsigned int")
                                         int count,
                                         @Const
                                         DoubleBuffer values,
                                         @ByPtrPtr
                                         rs_error error)

rs_set_device_options

public static void rs_set_device_options(rs_device device,
                                         @Cast(value="const rs_option*")
                                         int[] options,
                                         @Cast(value="unsigned int")
                                         int count,
                                         @Const
                                         double[] values,
                                         @ByPtrPtr
                                         rs_error error)

rs_reset_device_options_to_default

public static void rs_reset_device_options_to_default(rs_device device,
                                                      @Cast(value="const rs_option*")
                                                      IntPointer options,
                                                      int count,
                                                      @Cast(value="rs_error**")
                                                      PointerPointer error)

efficiently reset the value of an arbitrary number of options to default

Parameters:: options - [in] the array of options which should be set to default; count - [in] the length of the options array; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs_reset_device_options_to_default

public static void rs_reset_device_options_to_default(rs_device device,
                                                      @Cast(value="const rs_option*")
                                                      IntPointer options,
                                                      int count,
                                                      @ByPtrPtr
                                                      rs_error error)

rs_reset_device_options_to_default

public static void rs_reset_device_options_to_default(rs_device device,
                                                      @Cast(value="const rs_option*")
                                                      IntBuffer options,
                                                      int count,
                                                      @ByPtrPtr
                                                      rs_error error)

rs_reset_device_options_to_default

public static void rs_reset_device_options_to_default(rs_device device,
                                                      @Cast(value="const rs_option*")
                                                      int[] options,
                                                      int count,
                                                      @ByPtrPtr
                                                      rs_error error)

rs_get_device_option

public static double rs_get_device_option(rs_device device,
                                          @Cast(value="rs_option")
                                          int option,
                                          @Cast(value="rs_error**")
                                          PointerPointer error)

retrieve the current value of a single option

Parameters:: option - [in] the option whose value should be retrieved; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the value of the option

rs_get_device_option

public static double rs_get_device_option(rs_device device,
                                          @Cast(value="rs_option")
                                          int option,
                                          @ByPtrPtr
                                          rs_error error)

rs_get_device_option_description

@Cast(value="const char*")
public static BytePointer rs_get_device_option_description(rs_device device,
                                                                                      @Cast(value="rs_option")
                                                                                      int option,
                                                                                      @Cast(value="rs_error**")
                                                                                      PointerPointer error)

retrieve a static description of what a particular option does on given device

Parameters:: option - [in] the option whose description should be retrieved; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the value of the option

rs_get_device_option_description

@Cast(value="const char*")
public static BytePointer rs_get_device_option_description(rs_device device,
                                                                                      @Cast(value="rs_option")
                                                                                      int option,
                                                                                      @ByPtrPtr
                                                                                      rs_error error)

rs_set_device_option

public static void rs_set_device_option(rs_device device,
                                        @Cast(value="rs_option")
                                        int option,
                                        double value,
                                        @Cast(value="rs_error**")
                                        PointerPointer error)

set the current value of a single option

Parameters:: option - [in] the option whose value should be set; value - [in] the value of the option; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs_set_device_option

public static void rs_set_device_option(rs_device device,
                                        @Cast(value="rs_option")
                                        int option,
                                        double value,
                                        @ByPtrPtr
                                        rs_error error)

rs_wait_for_frames

public static void rs_wait_for_frames(rs_device device,
                                      @Cast(value="rs_error**")
                                      PointerPointer error)

block until new frames are available

Parameters:: error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs_wait_for_frames

public static void rs_wait_for_frames(rs_device device,
                                      @ByPtrPtr
                                      rs_error error)

rs_poll_for_frames

public static int rs_poll_for_frames(rs_device device,
                                     @Cast(value="rs_error**")
                                     PointerPointer error)

check if new frames are available, without blocking

Parameters:: error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: 1 if new frames are available, 0 if no new frames have arrived

rs_poll_for_frames

public static int rs_poll_for_frames(rs_device device,
                                     @ByPtrPtr
                                     rs_error error)

rs_supports

public static int rs_supports(rs_device device,
                              @Cast(value="rs_capabilities")
                              int capability,
                              @Cast(value="rs_error**")
                              PointerPointer error)

determine device capabilities

Parameters:: capability - [in] the capability to check for support
Returns:: true if device has this capability

rs_supports

public static int rs_supports(rs_device device,
                              @Cast(value="rs_capabilities")
                              int capability,
                              @ByPtrPtr
                              rs_error error)

rs_supports_camera_info

public static int rs_supports_camera_info(rs_device device,
                                          @Cast(value="rs_camera_info")
                                          int info_param,
                                          @Cast(value="rs_error**")
                                          PointerPointer error)

specialization over generic support to verify camera header block support

Parameters:: info_param - [in] the parameter to check for support
Returns:: true if the parameter both exist and well-defined for the specific device

rs_supports_camera_info

public static int rs_supports_camera_info(rs_device device,
                                          @Cast(value="rs_camera_info")
                                          int info_param,
                                          @ByPtrPtr
                                          rs_error error)

rs_get_detached_frame_metadata

public static double rs_get_detached_frame_metadata(@Const
                                                    rs_frame_ref frame,
                                                    @Cast(value="rs_frame_metadata")
                                                    int frame_metadata,
                                                    @Cast(value="rs_error**")
                                                    PointerPointer error)

retrive metadata from safe frame handle, returned from detach, clone_ref or from frame callback

Parameters:: stream - [in] the stream whose latest frame we are interested in; frame_metadata - [in] the rs_frame_metadata whose latest frame we are interested in
Returns:: the metadata value

rs_get_detached_frame_metadata

public static double rs_get_detached_frame_metadata(@Const
                                                    rs_frame_ref frame,
                                                    @Cast(value="rs_frame_metadata")
                                                    int frame_metadata,
                                                    @ByPtrPtr
                                                    rs_error error)

rs_supports_frame_metadata

public static int rs_supports_frame_metadata(@Const
                                             rs_frame_ref frame,
                                             @Cast(value="rs_frame_metadata")
                                             int frame_metadata,
                                             @Cast(value="rs_error**")
                                             PointerPointer error)

determine device metadata

Parameters:: metadata - [in] the metadata to check for support
Returns:: true if device has this metadata

rs_supports_frame_metadata

public static int rs_supports_frame_metadata(@Const
                                             rs_frame_ref frame,
                                             @Cast(value="rs_frame_metadata")
                                             int frame_metadata,
                                             @ByPtrPtr
                                             rs_error error)

rs_get_frame_timestamp

public static double rs_get_frame_timestamp(@Const
                                            rs_device device,
                                            @Cast(value="rs_stream")
                                            int stream,
                                            @Cast(value="rs_error**")
                                            PointerPointer error)

retrieve the time at which the latest frame on a stream was captured

Parameters:: stream - [in] the stream whose latest frame we are interested in; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the timestamp of the frame, in milliseconds since the device was started

rs_get_frame_timestamp

public static double rs_get_frame_timestamp(@Const
                                            rs_device device,
                                            @Cast(value="rs_stream")
                                            int stream,
                                            @ByPtrPtr
                                            rs_error error)

rs_get_frame_number

@Cast(value="unsigned long long")
public static long rs_get_frame_number(@Const
                                                                         rs_device device,
                                                                         @Cast(value="rs_stream")
                                                                         int stream,
                                                                         @Cast(value="rs_error**")
                                                                         PointerPointer error)

retrieve the frame number

Parameters:: stream - [in] the stream whose latest frame we are interested in; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the frame number

rs_get_frame_number

@Cast(value="unsigned long long")
public static long rs_get_frame_number(@Const
                                                                         rs_device device,
                                                                         @Cast(value="rs_stream")
                                                                         int stream,
                                                                         @ByPtrPtr
                                                                         rs_error error)

rs_get_frame_data

@Const
public static Pointer rs_get_frame_data(@Const
                                               rs_device device,
                                               @Cast(value="rs_stream")
                                               int stream,
                                               @Cast(value="rs_error**")
                                               PointerPointer error)

retrieve the contents of the latest frame on a stream

Parameters:: stream - [in] the stream whose latest frame we are interested in; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the pointer to the start of the frame data

rs_get_frame_data

@Const
public static Pointer rs_get_frame_data(@Const
                                               rs_device device,
                                               @Cast(value="rs_stream")
                                               int stream,
                                               @ByPtrPtr
                                               rs_error error)

rs_release_frame

public static void rs_release_frame(rs_device device,
                                    rs_frame_ref frame,
                                    @Cast(value="rs_error**")
                                    PointerPointer error)

relases the frame handle

Parameters:: frame - [in] handle returned either detach, clone_ref or from frame callback; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs_release_frame

public static void rs_release_frame(rs_device device,
                                    rs_frame_ref frame,
                                    @ByPtrPtr
                                    rs_error error)

rs_get_detached_frame_timestamp

public static double rs_get_detached_frame_timestamp(@Const
                                                     rs_frame_ref frame,
                                                     @Cast(value="rs_error**")
                                                     PointerPointer error)

retrive timestamp from safe frame handle, returned from detach, clone_ref or from frame callback

Parameters:: error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the timestamp of the frame, in milliseconds since the device was started

rs_get_detached_frame_timestamp

public static double rs_get_detached_frame_timestamp(@Const
                                                     rs_frame_ref frame,
                                                     @ByPtrPtr
                                                     rs_error error)

rs_get_detached_frame_timestamp_domain

@Cast(value="rs_timestamp_domain")
public static int rs_get_detached_frame_timestamp_domain(@Const
                                                                                            rs_frame_ref frameset,
                                                                                            @Cast(value="rs_error**")
                                                                                            PointerPointer error)

retrive timestamp domain from safe frame handle, returned from detach, clone_ref or from frame callback this method is used to check if two timestamp values are comparable (generated from the same clock)

Parameters:: error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the timestamp domain of the frame (camera/ microcontroller)

rs_get_detached_frame_timestamp_domain

@Cast(value="rs_timestamp_domain")
public static int rs_get_detached_frame_timestamp_domain(@Const
                                                                                            rs_frame_ref frameset,
                                                                                            @ByPtrPtr
                                                                                            rs_error error)

rs_get_detached_frame_number

@Cast(value="unsigned long long")
public static long rs_get_detached_frame_number(@Const
                                                                                  rs_frame_ref frame,
                                                                                  @Cast(value="rs_error**")
                                                                                  PointerPointer error)

retrive frame number from safe frame handle, returned from detach, clone_ref or from frame callback

Parameters:: error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the frame nubmer of the frame, in milliseconds since the device was started

rs_get_detached_frame_number

@Cast(value="unsigned long long")
public static long rs_get_detached_frame_number(@Const
                                                                                  rs_frame_ref frame,
                                                                                  @ByPtrPtr
                                                                                  rs_error error)

rs_get_detached_frame_data

@Const
public static Pointer rs_get_detached_frame_data(@Const
                                                        rs_frame_ref frame,
                                                        @Cast(value="rs_error**")
                                                        PointerPointer error)

retrive data from safe frame handle, returned from detach, clone_ref or from frame callback

Parameters:: error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: the pointer to the start of the frame data

rs_get_detached_frame_data

@Const
public static Pointer rs_get_detached_frame_data(@Const
                                                        rs_frame_ref frame,
                                                        @ByPtrPtr
                                                        rs_error error)

rs_get_detached_frame_width

public static int rs_get_detached_frame_width(@Const
                                              rs_frame_ref frame,
                                              @Cast(value="rs_error**")
                                              PointerPointer error)

retrive frame intrinsic width in pixels

Parameters:: error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: intrinsic width

rs_get_detached_frame_width

public static int rs_get_detached_frame_width(@Const
                                              rs_frame_ref frame,
                                              @ByPtrPtr
                                              rs_error error)

rs_get_detached_frame_height

public static int rs_get_detached_frame_height(@Const
                                               rs_frame_ref frame,
                                               @Cast(value="rs_error**")
                                               PointerPointer error)

retrive frame intrinsic height

Parameters:: error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: intrinsic height

rs_get_detached_frame_height

public static int rs_get_detached_frame_height(@Const
                                               rs_frame_ref frame,
                                               @ByPtrPtr
                                               rs_error error)

rs_get_detached_framerate

public static int rs_get_detached_framerate(@Const
                                            rs_frame_ref frameset,
                                            @Cast(value="rs_error**")
                                            PointerPointer error)

retrive frame intrinsic framerate

Parameters:: error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: intrinsic framerate

rs_get_detached_framerate

public static int rs_get_detached_framerate(@Const
                                            rs_frame_ref frameset,
                                            @ByPtrPtr
                                            rs_error error)

rs_get_detached_frame_stride

public static int rs_get_detached_frame_stride(@Const
                                               rs_frame_ref frame,
                                               @Cast(value="rs_error**")
                                               PointerPointer error)

retrive frame stride, meaning the actual line width in memory in bytes (not the logical image width)

Parameters:: error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: frame pad crop

rs_get_detached_frame_stride

public static int rs_get_detached_frame_stride(@Const
                                               rs_frame_ref frame,
                                               @ByPtrPtr
                                               rs_error error)

rs_get_detached_frame_bpp

public static int rs_get_detached_frame_bpp(@Const
                                            rs_frame_ref frame,
                                            @Cast(value="rs_error**")
                                            PointerPointer error)

retrive frame **bits** per pixel

Parameters:: error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: frame pad crop

rs_get_detached_frame_bpp

public static int rs_get_detached_frame_bpp(@Const
                                            rs_frame_ref frame,
                                            @ByPtrPtr
                                            rs_error error)

rs_get_detached_frame_format

@Cast(value="rs_format")
public static int rs_get_detached_frame_format(@Const
                                                                        rs_frame_ref frame,
                                                                        @Cast(value="rs_error**")
                                                                        PointerPointer error)

retrive frame format

Parameters:: error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: frame format

rs_get_detached_frame_format

@Cast(value="rs_format")
public static int rs_get_detached_frame_format(@Const
                                                                        rs_frame_ref frame,
                                                                        @ByPtrPtr
                                                                        rs_error error)

rs_get_detached_frame_stream_type

@Cast(value="rs_stream")
public static int rs_get_detached_frame_stream_type(@Const
                                                                             rs_frame_ref frameset,
                                                                             @Cast(value="rs_error**")
                                                                             PointerPointer error)

retrive frame stream type

Parameters:: error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns:: stream type

rs_get_detached_frame_stream_type

@Cast(value="rs_stream")
public static int rs_get_detached_frame_stream_type(@Const
                                                                             rs_frame_ref frameset,
                                                                             @ByPtrPtr
                                                                             rs_error error)

rs_send_blob_to_device

public static void rs_send_blob_to_device(rs_device device,
                                          @Cast(value="rs_blob_type")
                                          int type,
                                          Pointer data,
                                          int size,
                                          @Cast(value="rs_error**")
                                          PointerPointer error)

send a blob of data to the device. at the moment only RS_BLOB_TYPE_MOTION_MODULE_FIRMWARE_UPDATE is support of the motiohn module.

Parameters:: firmware - [in] data.; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs_send_blob_to_device

public static void rs_send_blob_to_device(rs_device device,
                                          @Cast(value="rs_blob_type")
                                          int type,
                                          Pointer data,
                                          int size,
                                          @ByPtrPtr
                                          rs_error error)

rs_get_api_version
```
public static int rs_get_api_version(@Cast(value="rs_error**")
                                     PointerPointer error)
```
retrieve the API version from the source code. Evaluate that the value is conformant to the established policies

Parameters:

error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

Returns:

the version API encoded into integer value "1.9.3" -> 10903

rs_get_api_version

public static int rs_get_api_version(@ByPtrPtr
                                     rs_error error)

rs_get_failed_function

@Cast(value="const char*")
public static BytePointer rs_get_failed_function(@Const
                                                                            rs_error error)

returns static pointer to the name of failing function in case of error

Parameters:: error - [in] error object allocated by realsense API function
Returns:: pointer to function name (memory manager by the error object)

rs_get_failed_args

@Cast(value="const char*")
public static BytePointer rs_get_failed_args(@Const
                                                                        rs_error error)

returns static pointer to the arguments of failing function in case of error

Parameters:: error - [in] error object allocated by realsense API function
Returns:: pointer to arguments string (memory manager by the error object)

rs_get_error_message

@Cast(value="const char*")
public static BytePointer rs_get_error_message(@Const
                                                                          rs_error error)

returns static pointer to the error message

Parameters:: error - [in] error object allocated by realsense API function
Returns:: pointer to the error message (memory manager by the error object)

rs_free_error
```
public static void rs_free_error(rs_error error)
```
frees memory of an error object

Parameters:

error - [in] error object allocated by realsense API function

rs_stream_to_string

@Cast(value="const char*")
public static BytePointer rs_stream_to_string(@Cast(value="rs_stream")
                                                                         int stream)

rs_format_to_string

@Cast(value="const char*")
public static BytePointer rs_format_to_string(@Cast(value="rs_format")
                                                                         int format)

rs_preset_to_string

@Cast(value="const char*")
public static BytePointer rs_preset_to_string(@Cast(value="rs_preset")
                                                                         int preset)

rs_distortion_to_string

@Cast(value="const char*")
public static BytePointer rs_distortion_to_string(@Cast(value="rs_distortion")
                                                                             int distortion)

rs_option_to_string

@Cast(value="const char*")
public static BytePointer rs_option_to_string(@Cast(value="rs_option")
                                                                         int option)

rs_capabilities_to_string

@Cast(value="const char*")
public static BytePointer rs_capabilities_to_string(@Cast(value="rs_capabilities")
                                                                               int capability)

rs_source_to_string

@Cast(value="const char*")
public static BytePointer rs_source_to_string(@Cast(value="rs_source")
                                                                         int source)

rs_event_to_string

@Cast(value="const char*")
public static BytePointer rs_event_to_string(@Cast(value="rs_event_source")
                                                                        int event)

rs_blob_type_to_string

@Cast(value="const char*")
public static BytePointer rs_blob_type_to_string(@Cast(value="rs_blob_type")
                                                                            int type)

rs_camera_info_to_string

@Cast(value="const char*")
public static BytePointer rs_camera_info_to_string(@Cast(value="rs_camera_info")
                                                                              int info)

rs_timestamp_domain_to_string

@Cast(value="const char*")
public static BytePointer rs_timestamp_domain_to_string(@Cast(value="rs_timestamp_domain")
                                                                                   int info)

rs_frame_metadata_to_string

@Cast(value="const char*")
public static BytePointer rs_frame_metadata_to_string(@Cast(value="rs_frame_metadata")
                                                                                 int md)

rs_log_to_console

public static void rs_log_to_console(@Cast(value="rs_log_severity")
                                     int min_severity,
                                     @Cast(value="rs_error**")
                                     PointerPointer error)

start logging to console

Parameters:: min_severity - [in] the minimum severity to be logged; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs_log_to_console

public static void rs_log_to_console(@Cast(value="rs_log_severity")
                                     int min_severity,
                                     @ByPtrPtr
                                     rs_error error)

rs_log_to_file

public static void rs_log_to_file(@Cast(value="rs_log_severity")
                                  int min_severity,
                                  @Cast(value="const char*")
                                  BytePointer file_path,
                                  @Cast(value="rs_error**")
                                  PointerPointer error)

start logging to file

Parameters:: file_path - [in] relative filename to log to, in case file exists it will be appended to; min_severity - [in] the minimum severity to be logged; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs_log_to_file

public static void rs_log_to_file(@Cast(value="rs_log_severity")
                                  int min_severity,
                                  @Cast(value="const char*")
                                  BytePointer file_path,
                                  @ByPtrPtr
                                  rs_error error)

rs_log_to_file

public static void rs_log_to_file(@Cast(value="rs_log_severity")
                                  int min_severity,
                                  String file_path,
                                  @ByPtrPtr
                                  rs_error error)

rs_log_to_callback_cpp

public static void rs_log_to_callback_cpp(@Cast(value="rs_log_severity")
                                          int min_severity,
                                          rs_log_callback callback,
                                          @Cast(value="rs_error**")
                                          PointerPointer error)

start logging to user provided callback

Parameters:: callback - [in] pointer to log into (must be created and used from C++); min_severity - [in] the minimum severity to be logged; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs_log_to_callback_cpp

public static void rs_log_to_callback_cpp(@Cast(value="rs_log_severity")
                                          int min_severity,
                                          rs_log_callback callback,
                                          @ByPtrPtr
                                          rs_error error)

rs_log_to_callback

public static void rs_log_to_callback(@Cast(value="rs_log_severity")
                                      int min_severity,
                                      rs_log_callback_ptr on_log,
                                      Pointer user,
                                      @Cast(value="rs_error**")
                                      PointerPointer error)

start logging to user provided callback (C version)

Parameters:: on_log - [in] callback function pointer; min_severity - [in] the minimum severity to be logged; user - [in] custom pointer for the callback; error - [out] if non-null, receives any error that occurs during this call, otherwise, errors are ignored

rs_log_to_callback

public static void rs_log_to_callback(@Cast(value="rs_log_severity")
                                      int min_severity,
                                      rs_log_callback_ptr on_log,
                                      Pointer user,
                                      @ByPtrPtr
                                      rs_error error)

shiftLeft

@Namespace(value="rs")
 @Cast(value="std::ostream*")
 @ByRef
 @Name(value="operator <<")
public static Pointer shiftLeft(@Cast(value="std::ostream*") @ByRef
                                                                                                                         Pointer o,
                                                                                                                         @Cast(value="rs::stream")
                                                                                                                         int stream)

shiftLeft

@Namespace(value="rs")
 @Cast(value="std::ostream*")
 @ByRef
 @Name(value="operator <<")
public static Pointer shiftLeft(@Cast(value="std::ostream*") @ByRef
                                                                                                                         Pointer o,
                                                                                                                         @Cast(value="rs::source")
                                                                                                                         byte src)

log_to_console

@Namespace(value="rs")
public static void log_to_console(@Cast(value="rs::log_severity")
                                                         int min_severity)

log_to_file

@Namespace(value="rs")
public static void log_to_file(@Cast(value="rs::log_severity")
                                                      int min_severity,
                                                      @Cast(value="const char*")
                                                      BytePointer file_path)

log_to_file

@Namespace(value="rs")
public static void log_to_file(@Cast(value="rs::log_severity")
                                                      int min_severity,
                                                      String file_path)

log_to_callback

@Namespace(value="rs")
public static void log_to_callback(@Cast(value="rs::log_severity")
                                                          int min_severity,
                                                          @ByVal
                                                          RealSense.LogCallbackFunction callback)

apply_depth_control_preset

@Namespace(value="rs")
public static void apply_depth_control_preset(device device,
                                                                     int preset)

apply_ivcam_preset

@Namespace(value="rs")
public static void apply_ivcam_preset(device device,
                                                             @Cast(value="rs_ivcam_preset")
                                                             int preset)

rs_project_point_to_pixel

public static void rs_project_point_to_pixel(FloatPointer pixel,
                                             @Const
                                             rs_intrinsics intrin,
                                             @Const
                                             FloatPointer point)

rs_project_point_to_pixel

public static void rs_project_point_to_pixel(FloatBuffer pixel,
                                             @Const
                                             rs_intrinsics intrin,
                                             @Const
                                             FloatBuffer point)

rs_project_point_to_pixel

public static void rs_project_point_to_pixel(float[] pixel,
                                             @Const
                                             rs_intrinsics intrin,
                                             @Const
                                             float[] point)

rs_deproject_pixel_to_point

public static void rs_deproject_pixel_to_point(FloatPointer point,
                                               @Const
                                               rs_intrinsics intrin,
                                               @Const
                                               FloatPointer pixel,
                                               float depth)

rs_deproject_pixel_to_point

public static void rs_deproject_pixel_to_point(FloatBuffer point,
                                               @Const
                                               rs_intrinsics intrin,
                                               @Const
                                               FloatBuffer pixel,
                                               float depth)

rs_deproject_pixel_to_point

public static void rs_deproject_pixel_to_point(float[] point,
                                               @Const
                                               rs_intrinsics intrin,
                                               @Const
                                               float[] pixel,
                                               float depth)

rs_transform_point_to_point

public static void rs_transform_point_to_point(FloatPointer to_point,
                                               @Const
                                               rs_extrinsics extrin,
                                               @Const
                                               FloatPointer from_point)

rs_transform_point_to_point

public static void rs_transform_point_to_point(FloatBuffer to_point,
                                               @Const
                                               rs_extrinsics extrin,
                                               @Const
                                               FloatBuffer from_point)

rs_transform_point_to_point

public static void rs_transform_point_to_point(float[] to_point,
                                               @Const
                                               rs_extrinsics extrin,
                                               @Const
                                               float[] from_point)

rs_apply_depth_control_preset

public static void rs_apply_depth_control_preset(rs_device device,
                                                 int preset)

rs_apply_ivcam_preset

public static void rs_apply_ivcam_preset(rs_device device,
                                         @Cast(value="rs_ivcam_preset")
                                         int preset)

Class RealSense

Nested Class Summary

Nested classes/interfaces inherited from class org.bytedeco.librealsense.presets.RealSense

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.bytedeco.librealsense.presets.RealSense

Methods inherited from class java.lang.Object

Field Detail

RS_API_MAJOR_VERSION

RS_API_MINOR_VERSION

RS_API_PATCH_VERSION

RS_API_VERSION

RS_API_VERSION_STR

RS_STREAM_DEPTH

RS_STREAM_COLOR

RS_STREAM_INFRARED

RS_STREAM_INFRARED2

RS_STREAM_FISHEYE

RS_STREAM_POINTS

RS_STREAM_RECTIFIED_COLOR

RS_STREAM_COLOR_ALIGNED_TO_DEPTH

RS_STREAM_INFRARED2_ALIGNED_TO_DEPTH

RS_STREAM_DEPTH_ALIGNED_TO_COLOR

RS_STREAM_DEPTH_ALIGNED_TO_RECTIFIED_COLOR

RS_STREAM_DEPTH_ALIGNED_TO_INFRARED2

RS_STREAM_COUNT

RS_FORMAT_ANY

RS_FORMAT_Z16

RS_FORMAT_DISPARITY16

RS_FORMAT_XYZ32F

RS_FORMAT_YUYV

RS_FORMAT_RGB8

RS_FORMAT_BGR8

RS_FORMAT_RGBA8

RS_FORMAT_BGRA8

RS_FORMAT_Y8

RS_FORMAT_Y16

RS_FORMAT_RAW10

RS_FORMAT_RAW16

RS_FORMAT_RAW8

RS_FORMAT_COUNT

RS_OUTPUT_BUFFER_FORMAT_CONTINUOUS

RS_OUTPUT_BUFFER_FORMAT_NATIVE

RS_OUTPUT_BUFFER_FORMAT_COUNT

RS_PRESET_BEST_QUALITY

RS_PRESET_LARGEST_IMAGE

RS_PRESET_HIGHEST_FRAMERATE

RS_PRESET_COUNT

RS_SOURCE_VIDEO

RS_SOURCE_MOTION_TRACKING

RS_SOURCE_ALL

RS_SOURCE_COUNT

RS_DISTORTION_NONE

RS_DISTORTION_MODIFIED_BROWN_CONRADY

RS_DISTORTION_INVERSE_BROWN_CONRADY

RS_DISTORTION_FTHETA

RS_DISTORTION_COUNT

RS_IVCAM_PRESET_SHORT_RANGE

RS_IVCAM_PRESET_LONG_RANGE

RS_IVCAM_PRESET_BACKGROUND_SEGMENTATION

RS_IVCAM_PRESET_GESTURE_RECOGNITION

RS_IVCAM_PRESET_OBJECT_SCANNING

RS_IVCAM_PRESET_FACE_ANALYTICS

RS_IVCAM_PRESET_FACE_LOGIN

RS_IVCAM_PRESET_GR_CURSOR

RS_IVCAM_PRESET_DEFAULT

RS_IVCAM_PRESET_MID_RANGE

RS_IVCAM_PRESET_IR_ONLY

RS_IVCAM_PRESET_COUNT

RS_OPTION_COLOR_BACKLIGHT_COMPENSATION

RS_OPTION_COLOR_BRIGHTNESS

RS_OPTION_COLOR_CONTRAST

RS_OPTION_COLOR_EXPOSURE

RS_OPTION_COLOR_GAIN

RS_OPTION_COLOR_GAMMA

RS_OPTION_COLOR_HUE

RS_OPTION_COLOR_SATURATION

RS_OPTION_COLOR_SHARPNESS

RS_OPTION_COLOR_WHITE_BALANCE