Intel® RealSense™ Cross Platform API
Intel Realsense Cross-platform API
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
librealsense Namespace Reference

Namespaces

 device_serializer
 
 ds
 
 ivcam
 
 ivcam2
 
 legacy_file_format
 
 platform
 
 util
 

Classes

class  actual_fps_calculator
 
class  advanced_mode_preset_option
 
struct  advanced_mode_traits
 
class  align
 
class  archive_interface
 
struct  arg_streamer
 
struct  arg_streamer< T *, false >
 
struct  arg_streamer< T *, true >
 
class  arithmetic_wraparound
 
class  asic_and_projector_temperature_options
 
class  auto_disabling_control
 auto_disabling_control class provided a control that disable auto-control when changing the auto disabling control value More...
 
class  auto_exposure_algorithm
 
class  auto_exposure_antiflicker_rate_option
 
struct  auto_exposure_control
 
class  auto_exposure_mechanism
 
class  auto_exposure_mode_option
 
class  auto_exposure_state
 
class  auto_exposure_step_option
 
struct  auto_white_balance_control
 
class  backend_exception
 
class  backend_stream_profile
 
struct  backlight_compensation_control
 
class  big_endian
 
struct  brightness_control
 
class  calibration_validator
 
struct  callback_invocation
 
struct  callback_invocation_holder
 
class  camera_disconnected_exception
 
class  color_map
 
class  colorizer
 
struct  command
 
class  command_transfer_over_xu
 
class  composite_frame
 
class  composite_matcher
 
class  const_value_option
 
class  context
 
struct  contrast_control
 
class  controller_event_serializer
 
class  debug_interface
 
class  debug_snapshot
 
class  decimation_filter
 
class  depth_frame
 
class  depth_scale_option
 
class  depth_sensor
 
class  depth_sensor_snapshot
 
class  depth_stereo_sensor
 
class  depth_stereo_sensor_snapshot
 
class  device
 
class  device_hub
 
class  device_info
 
class  device_interface
 
class  devices_changed_callback
 
class  devices_changed_callback_internal
 
struct  devices_data
 
class  disparity_frame
 
class  disparity_transform
 
class  ds5_active
 
class  ds5_advanced_mode_base
 
class  ds5_advanced_mode_interface
 
class  ds5_color
 
class  ds5_color_sensor
 
class  ds5_custom_hid_timestamp_reader
 
class  ds5_device
 
class  ds5_iio_hid_timestamp_reader
 
class  ds5_info
 
class  ds5_md_attribute_actual_fps
 
class  ds5_motion
 
class  ds5_notification_decoder
 
class  ds5_rolling_shutter
 
class  ds5_timestamp_reader
 
class  ds5_timestamp_reader_from_metadata
 
class  ds5u_device
 
class  emitter_option
 
class  enable_auto_exposure_option
 
class  enable_motion_correction
 
class  environment
 
struct  exposure_control
 
class  extendable_interface
 
class  extension_snapshot
 
struct  ExtensionToType
 
class  extrinsics_graph
 
class  ExtrinsicsQuery
 
class  FalseQuery
 
class  firmware_version
 
struct  float2
 
struct  float3
 
struct  float3x3
 
struct  float4
 
class  frame
 
struct  frame_and_callback
 
class  frame_callback
 
class  frame_continuation
 
struct  frame_holder
 
class  frame_holder_callback
 
class  frame_interface
 
class  frame_number_composite_matcher
 
class  frame_source
 
struct  frame_timestamp_reader
 
class  FrameQuery
 
struct  gain_control
 
struct  gamma_control
 
struct  hid_device_info
 
class  hid_sensor
 
class  hole_filling_filter
 
struct  hue_control
 
class  hw_monitor
 
class  identity_matcher
 
class  info_container
 
class  info_interface
 
struct  int2
 
class  internal_frame_callback
 
class  internal_frame_processor_callback
 
class  internal_frame_processor_fptr_callback
 
class  invalid_value_exception
 
class  io_exception
 
class  is_streamable
 
struct  json_field
 
struct  json_ignored_field
 
struct  json_invert_struct_field
 
struct  json_string_struct_field
 
struct  json_struct_field
 
class  l500_device
 
class  l500_info
 
class  l500_timestamp_reader
 
struct  laser_power_control
 
struct  laser_state_control
 
class  lazy
 
class  librealsense_exception
 
class  linux_backend_exception
 
class  locked_transfer
 
class  matcher
 
class  matcher_factory
 
class  matcher_interface
 
class  md_additional_parser
 provide attributes generated and stored internally by the library More...
 
class  md_attribute_parser
 The metadata parser class directly access the metadata attribute in the blob received from HW. Given the metadata-nested construct, and the c++ lack of pointers to the inner struct, we pre-calculate and store the attribute offset internally http://stackoverflow.com/questions/1929887/is-pointer-to-inner-struct-member-forbidden. More...
 
class  md_attribute_parser_base
 Base class that establishes the interface for retrieving metadata attributes. More...
 
struct  md_calibration_mode
 
struct  md_camera_extrinsic
 
struct  md_camera_intrinsic
 
struct  md_capture_stats
 md_capture_stats - properties associated with optical sensor during video streaming. Corresponds to FW STMetaDataCaptureStats object More...
 
struct  md_capture_timing
 md_capture_timing - properties associated with sensor configuration during video streaming. Corresponds to FW STMetaDataIntelCaptureTiming object More...
 
struct  md_configuration
 md_configuration - device/stream configuration. Corresponds to FW's STMetaDataIntelConfiguration object More...
 
class  md_constant_parser
 
struct  md_depth_control
 md_depth_control - depth data-related parameters. Corresponds to FW's STMetaDataIntelDepthControl object More...
 
union  md_depth_mode
 
struct  md_depth_y_normal_mode
 
struct  md_extrinsic_calibrated_transform
 
struct  md_fisheye_control
 md_fisheye_control - fisheye-related parameters. Corresponds to FW's STMetaDataIntelFishEyeControl object More...
 
union  md_fisheye_mode
 
struct  md_fisheye_normal_mode
 
struct  md_header
 md_header - metadata header is a integral part of all rs4XX metadata objects More...
 
struct  md_intel_stat
 md_intel_stat Corresponds to FW's STMetaDataIntelStat object More...
 
struct  md_intrinsic_distortion_model
 md_intrinsic_distortion_model - Distortion coefficients of sensor instrinsic More...
 
struct  md_intrinsic_pinhole_cam_model
 
union  md_modes
 metadata_raw - aggrevative structure that represents all the possible metadata struct types to be handled More...
 
struct  md_pinhole_cam_intrinsic_model
 md_pinhole_cam_intrinsic_model - Pinhole sensor's characteristics More...
 
struct  md_pinhole_camera_intrinsics
 
struct  md_rgb_control
 md_rgb_control - Realtec RGB sensor attributes. More...
 
union  md_rgb_mode
 
struct  md_rgb_normal_mode
 
class  md_rs400_sensor_timestamp
 Optical timestamp for RS4xx devices is calculated internally. More...
 
class  md_sr300_attribute_parser
 The SR300 metadata parser class. More...
 
struct  md_sr300_depth
 
struct  md_sr300_rgb
 
struct  md_stat_mode
 
class  md_time_of_arrival_parser
 
struct  md_type_trait
 
class  md_uvc_header_parser
 A UVC-Header parser class. More...
 
struct  metadata_intel_basic
 metadata_intel_basic - a subset of the full metadata required to provide the essential sensor attributes only More...
 
struct  metadata_raw
 metadata_raw - metadata structure layout as transmitted and received by backend More...
 
struct  mf_camera_extrinsic
 
class  motion_frame
 
class  motion_module_temperature_option
 
class  motion_stream_profile
 
class  motion_stream_profile_interface
 
class  MultipleRegexTopicQuery
 
struct  native_pixel_format
 
class  not_implemented_exception
 
struct  notification
 
class  notification_callback
 
class  notification_decoder
 
class  notifications_callback
 
class  notifications_processor
 
class  NotificationsQuery
 
class  occlusion_filter
 
class  option
 
class  option_base
 
struct  option_range
 
class  optional_value
 
class  options_container
 
class  options_interface
 
class  OptionsQuery
 
struct  param_group
 
class  pipeline
 
class  pipeline_config
 
class  pipeline_processing_block
 
class  pipeline_profile
 
struct  pixel_format_unpacker
 
class  playback_device
 
class  playback_device_info
 
class  playback_sensor
 
class  pointcloud
 
class  points
 
class  polling_device_watcher
 
class  polling_error_handler
 
class  polling_errors_disable
 
struct  pose
 
class  pose_frame
 
class  pose_stream_profile
 
class  pose_stream_profile_interface
 
struct  power_line_frequency_control
 
struct  preset
 
struct  preset_param_group
 
class  processing_block
 
class  processing_block_interface
 
class  ptr_option
 
class  readonly_device_info
 
class  readonly_option
 
class  record_device
 
class  record_sensor
 
class  recordable
 
class  recoverable_exception
 
class  RegexTopicQuery
 
struct  region_of_interest
 
class  region_of_interest_method
 
struct  request_mapping
 
struct  resolution
 
class  roi_sensor_interface
 
class  ros_reader
 
class  ros_topic
 
class  ros_writer
 
struct  saturation_control
 
class  sensor_base
 
class  sensor_interface
 
class  sensor_part
 
class  SensorInfoQuery
 
struct  sharpness_control
 
class  signal
 
class  small_heap
 
class  software_device
 
class  software_sensor
 
class  spatial_filter
 
class  sr300_camera
 
class  sr300_info
 
class  sr300_timestamp_reader
 
class  sr300_timestamp_reader_from_metadata
 
class  stream
 
struct  stream_descriptor
 
class  stream_interface
 
struct  stream_output
 
struct  stream_profile
 
class  stream_profile_base
 
class  stream_profile_interface
 
class  StreamQuery
 
class  struct_field_option
 
struct  struct_interface
 
class  sync_lock
 
class  syncer_process_unit
 
struct  syncronization_environment
 
class  synthetic_source
 
class  synthetic_source_interface
 
class  temporal_filter
 
class  timestamp_composite_matcher
 
class  tm2_context
 
class  tm2_device
 
class  tm2_extensions
 
class  tm2_info
 
class  tm2_sensor
 
struct  to_string
 
struct  TypeToExtension
 
class  unique_id
 
class  unrecoverable_exception
 
struct  usb_device_info
 
struct  uvc_device_info
 
class  uvc_pu_option
 
class  uvc_sensor
 
class  uvc_xu_option
 
class  video_frame
 
class  video_sensor_interface
 
class  video_stream_profile
 
class  video_stream_profile_interface
 
struct  white_balance_control
 
class  windows_backend_exception
 
class  wrong_api_call_sequence_exception
 

Typedefs

typedef std::map< rs2_frame_metadata_value, std::shared_ptr< md_attribute_parser_base > > metadata_parser_map
 
typedef std::vector< std::shared_ptr< device_info > > devices_info
 
using on_frame = std::function< void(frame_interface *)>
 
using stream_profiles = std::vector< std::shared_ptr< stream_profile_interface >>
 
using json = nlohmann::json
 
typedef std::map< std::string, std::shared_ptr< json_field > > parsers_map
 
typedef std::function< rs2_metadata_type(const rs2_metadata_type &param)> attrib_modifyer
 Post-processing adjustment of the metadata attribute e.g change auto_exposure enum to boolean, change units from nano->ms,etc'. More...
 
typedef std::function< void(rs2_stream, frame_interface *, callback_invocation_holder)> on_before_frame_callback
 
typedef std::function< void(std::vector< platform::stream_profile >)> on_open
 
typedef int stream_id
 
typedef std::function< void(frame_holder, syncronization_environment)> sync_callback
 
typedef float float_4[4]
 
typedef std::tuple< uint32_t, int, size_t > native_pixel_format_tuple
 
typedef std::tuple< rs2_stream, int, rs2_formatoutput_tuple
 
typedef std::tuple< platform::stream_profile_tuple, native_pixel_format_tuple, std::vector< output_tuple > > request_mapping_tuple
 
using resolution_func = std::function< resolution(resolution res)>
 
typedef void(* frame_callback_function_ptr) (rs2_frame *frame, void *user)
 
typedef void(* notifications_callback_function_ptr) (rs2_notification *notification, void *user)
 
typedef void(* devices_changed_function_ptr) (rs2_device_list *removed, rs2_device_list *added, void *user)
 
typedef std::unique_ptr< rs2_log_callback, void(*)(rs2_log_callback *)> log_callback_ptr
 
typedef std::shared_ptr< rs2_frame_callbackframe_callback_ptr
 
typedef std::shared_ptr< rs2_frame_processor_callbackframe_processor_callback_ptr
 
typedef std::shared_ptr< rs2_notifications_callbacknotifications_callback_ptr
 
typedef std::shared_ptr< rs2_devices_changed_callbackdevices_changed_callback_ptr
 
using internal_callback = std::function< void(rs2_device_list *removed, rs2_device_list *added)>
 
typedef std::function< void(devices_data old, devices_data curr)> device_changed_callback
 
typedef librealsense::small_heap< callback_invocation, 1 > callbacks_heap
 

Enumerations

enum  auto_exposure_modes { auto_exposure_modes::static_auto_exposure = 0, auto_exposure_modes::auto_exposure_anti_flicker, auto_exposure_modes::auto_exposure_hybrid }
 
enum  backend_type { backend_type::standard, backend_type::record, backend_type::playback }
 
enum  frame_metadata_internal {
  RS2_FRAME_METADATA_HW_TYPE = RS2_FRAME_METADATA_COUNT +1, RS2_FRAME_METADATA_SKU_ID, RS2_FRAME_METADATA_FORMAT, RS2_FRAME_METADATA_WIDTH,
  RS2_FRAME_METADATA_HEIGHT, RS2_FRAME_METADATA_COUNT
}
 Metadata fields that are utilized internally by librealsense Provides extention to the r2_frame_metadata list of attributes. More...
 
enum  md_type : uint32_t {
  md_type::META_DATA_INTEL_DEPTH_CONTROL_ID = 0x80000000, md_type::META_DATA_INTEL_CAPTURE_TIMING_ID = 0x80000001, md_type::META_DATA_INTEL_CONFIGURATION_ID = 0x80000002, md_type::META_DATA_INTEL_STAT_ID = 0x80000003,
  md_type::META_DATA_INTEL_FISH_EYE_CONTROL_ID = 0x80000004, md_type::META_DATA_INTEL_RGB_CONTROL_ID = 0x80000005, md_type::META_DATA_INTEl_FE_FOV_MODEL_ID = 0x80000006, md_type::META_DATA_INTEl_FE_CAMERA_EXTRINSICS_ID = 0x80000007,
  md_type::META_DATA_CAPTURE_STATS_ID = 0x00000003, md_type::META_DATA_CAMERA_EXTRINSICS_ID = 0x00000004, md_type::META_DATA_CAMERA_INTRINSICS_ID = 0x00000005, md_type::META_DATA_CAMERA_DEBUG_ID = 0x800000FF
}
 md_mode - enumerates the types of metadata modes(structs) supported More...
 
enum  md_capture_timing_attributes : uint32_t {
  md_capture_timing_attributes::frame_counter_attribute = (1u << 0), md_capture_timing_attributes::sensor_timestamp_attribute = (1u << 1), md_capture_timing_attributes::readout_time_attribute = (1u << 2), md_capture_timing_attributes::exposure_attribute = (1u << 3),
  md_capture_timing_attributes::frame_interval_attribute = (1u << 4), md_capture_timing_attributes::pipe_latency_attribute = (1u << 5)
}
 md_capture_timing_attributes - enumerate the bit offset to check a specific attribute of md_capture_timing struct for validity. The enumeration includes up to 32 attributes, according to the size of flags parameter in all the defined structs More...
 
enum  md_capture_stat_attributes : uint32_t {
  md_capture_stat_attributes::exposure_time_attribute = (1u << 0), md_capture_stat_attributes::exposure_compensation_attribute = (1u << 1), md_capture_stat_attributes::iso_speed_attribute = (1u << 2), md_capture_stat_attributes::focus_state_attribute = (1u << 3),
  md_capture_stat_attributes::lens_posiiton_attribute = (1u << 4), md_capture_stat_attributes::white_balance_attribute = (1u << 5), md_capture_stat_attributes::flash_attribute = (1u << 6), md_capture_stat_attributes::flash_power_attribute = (1u << 7),
  md_capture_stat_attributes::zoom_factor_attribute = (1u << 8), md_capture_stat_attributes::scene_mode_attribute = (1u << 9), md_capture_stat_attributes::sensor_framerate_attribute = (1u << 10)
}
 md_capture_stat_attributes - bit mask to find enabled attributes in md_capture_stats More...
 
enum  md_depth_control_attributes : uint32_t {
  md_depth_control_attributes::gain_attribute = (1u << 0), md_depth_control_attributes::exposure_attribute = (1u << 1), md_depth_control_attributes::laser_pwr_attribute = (1u << 2), md_depth_control_attributes::ae_mode_attribute = (1u << 3),
  md_depth_control_attributes::exposure_priority_attribute = (1u << 4), md_depth_control_attributes::roi_attribute = (1u << 5), md_depth_control_attributes::preset_attribute = (1u << 6)
}
 md_depth_control_attributes - bit mask to find active attributes, md_depth_control struct More...
 
enum  md_fisheye_control_attributes : uint32_t { md_fisheye_control_attributes::gain_attribute = (1u << 0), md_fisheye_control_attributes::exposure_attribute = (1u << 1) }
 md_fisheye_control_attributes - bit mask to find active attributes, md_fisheye_control struct More...
 
enum  md_rgb_control_attributes : uint32_t {
  md_rgb_control_attributes::brightness_attribute = (1u << 0), md_rgb_control_attributes::contrast_attribute = (1u << 1), md_rgb_control_attributes::saturation_attribute = (1u << 2), md_rgb_control_attributes::sharpness_attribute = (1u << 3),
  md_rgb_control_attributes::ae_mode_attribute = (1u << 4), md_rgb_control_attributes::awb_temp_attribute = (1u << 5), md_rgb_control_attributes::gain_attribute = (1u << 6), md_rgb_control_attributes::backlight_comp_attribute = (1u << 7),
  md_rgb_control_attributes::gamma_attribute = (1u << 8), md_rgb_control_attributes::hue_attribute = (1u << 9), md_rgb_control_attributes::manual_exp_attribute = (1u << 10), md_rgb_control_attributes::manual_wb_attribute = (1u << 11),
  md_rgb_control_attributes::power_line_frequency_attribute = (1u << 12), md_rgb_control_attributes::low_light_comp_attribute = (1u << 13)
}
 md_rgb_control_attributes - bit mask to find active attributes, md_rgb_control struct More...
 
enum  md_configuration_attributes : uint32_t {
  md_configuration_attributes::hw_type_attribute = (1u << 0), md_configuration_attributes::sku_id_attribute = (1u << 1), md_configuration_attributes::cookie_attribute = (1u << 2), md_configuration_attributes::format_attribute = (1u << 3),
  md_configuration_attributes::width_attribute = (1u << 4), md_configuration_attributes::height_attribute = (1u << 5), md_configuration_attributes::fps_attribute = (1u << 6), md_configuration_attributes::trigger_attribute = (1u << 7),
  md_configuration_attributes::calibration_count_attribute = (1u << 8)
}
 md_configuration_attributes - bit mask to find active attributes, md_configuration struct More...
 
enum  md_stat_attributes : uint32_t {
  md_stat_attributes::left_sum_attribute = (1u << 0), md_stat_attributes::left_dark_count_attribute = (1u << 1), md_stat_attributes::left_bright_count_attribute = (1u << 2), md_stat_attributes::right_sum_attribute = (1u << 3),
  md_stat_attributes::right_dark_count_attribute = (1u << 4), md_stat_attributes::right_bright_count_attribute = (1u << 5), md_stat_attributes::red_frame_count_attribute = (1u << 6), md_stat_attributes::left_red_sum_attribute = (1u << 7),
  md_stat_attributes::left_greeen1_attribute = (1u << 8), md_stat_attributes::left_greeen2_attribute = (1u << 9), md_stat_attributes::left_blue_sum_attribute = (1u << 10), md_stat_attributes::right_red_sum_attribute = (1u << 11),
  md_stat_attributes::right_greeen1_attribute = (1u << 12), md_stat_attributes::right_greeen2_attribute = (1u << 13), md_stat_attributes::right_blue_sum_attribute = (1u << 14)
}
 md_stat_attributes - bit mask to find active attributes, md_stat struct More...
 
enum  holes_filling_types : uint8_t { hf_fill_from_left, hf_farest_from_around, hf_nearest_from_around, hf_max_value }
 
enum  occlusion_rect_type : uint8_t { occlusion_none, occlusion_monotonic_scan, occlusion_exhaustic_search, occlusion_max }
 

Functions

template<class T >
void stream_args (std::ostream &out, const char *names, const T &last)
 
template<class T , class... U>
void stream_args (std::ostream &out, const char *names, const T &first, const U &... rest)
 
 MAP_EXTENSION (RS2_EXTENSION_POINTS, librealsense::points)
 
 MAP_EXTENSION (RS2_EXTENSION_COMPOSITE_FRAME, librealsense::composite_frame)
 
 MAP_EXTENSION (RS2_EXTENSION_VIDEO_FRAME, librealsense::video_frame)
 
 MAP_EXTENSION (RS2_EXTENSION_DEPTH_FRAME, librealsense::depth_frame)
 
 MAP_EXTENSION (RS2_EXTENSION_DISPARITY_FRAME, librealsense::disparity_frame)
 
 MAP_EXTENSION (RS2_EXTENSION_MOTION_FRAME, librealsense::motion_frame)
 
 MAP_EXTENSION (RS2_EXTENSION_POSE_FRAME, librealsense::pose_frame)
 
std::shared_ptr< archive_interfacemake_archive (rs2_extension type, std::atomic< uint32_t > *in_max_frame_queue_size, std::shared_ptr< platform::time_service > ts, std::shared_ptr< metadata_parser_map > parsers)
 
template<class T >
bool list_changed (const std::vector< T > &list1, const std::vector< T > &list2, std::function< bool(T, T)> equal=[](T first, T second) { return first==second;})
 
double monotonic_to_realtime (double monotonic)
 
std::vector< platform::uvc_device_infofilter_by_product (const std::vector< platform::uvc_device_info > &devices, const std::set< uint16_t > &pid_list)
 
std::vector< std::pair< std::vector< platform::uvc_device_info >, std::vector< platform::hid_device_info > > > group_devices_and_hids_by_unique_id (const std::vector< std::vector< platform::uvc_device_info >> &devices, const std::vector< platform::hid_device_info > &hids)
 
std::vector< std::vector< platform::uvc_device_info > > group_devices_by_unique_id (const std::vector< platform::uvc_device_info > &devices)
 
void trim_device_list (std::vector< platform::uvc_device_info > &devices, const std::vector< platform::uvc_device_info > &chosen)
 
bool mi_present (const std::vector< platform::uvc_device_info > &devices, uint32_t mi)
 
platform::uvc_device_info get_mi (const std::vector< platform::uvc_device_info > &devices, uint32_t mi)
 
std::vector< platform::uvc_device_infofilter_by_mi (const std::vector< platform::uvc_device_info > &devices, uint32_t mi)
 
std::vector< platform::usb_device_infofilter_by_product (const std::vector< platform::usb_device_info > &devices, const std::set< uint16_t > &pid_list)
 
void trim_device_list (std::vector< platform::usb_device_info > &devices, const std::vector< platform::usb_device_info > &chosen)
 
 MAP_ADVANCED_MODE (STDepthControlGroup, etDepthControl)
 
 MAP_ADVANCED_MODE (STRsm, etRsm)
 
 MAP_ADVANCED_MODE (STRauSupportVectorControl, etRauSupportVectorControl)
 
 MAP_ADVANCED_MODE (STColorControl, etColorControl)
 
 MAP_ADVANCED_MODE (STRauColorThresholdsControl, etRauColorThresholdsControl)
 
 MAP_ADVANCED_MODE (STSloColorThresholdsControl, etSloColorThresholdsControl)
 
 MAP_ADVANCED_MODE (STSloPenaltyControl, etSloPenaltyControl)
 
 MAP_ADVANCED_MODE (STHdad, etHdad)
 
 MAP_ADVANCED_MODE (STColorCorrection, etColorCorrection)
 
 MAP_ADVANCED_MODE (STDepthTableControl, etDepthTableControl)
 
 MAP_ADVANCED_MODE (STAEControl, etAEControl)
 
 MAP_ADVANCED_MODE (STCensusRadius, etCencusRadius9)
 
 MAP_EXTENSION (RS2_EXTENSION_ADVANCED_MODE, librealsense::ds5_advanced_mode_interface)
 
 MAP_EXTENSION (RS2_EXTENSION_DEBUG, librealsense::debug_interface)
 
template<typename To >
bool try_extend (std::shared_ptr< extension_snapshot > from, void **ext)
 
template<typename T , typename P >
std::shared_ptr< T > As (std::shared_ptr< P > ptr)
 
template<typename T , typename P >
T * As (P *ptr)
 
template<typename T , typename P >
bool Is (std::shared_ptr< P > ptr)
 
template<typename T , typename P >
bool Is (P *ptr)
 
 MAP_EXTENSION (RS2_EXTENSION_INFO, librealsense::info_interface)
 
 MAP_EXTENSION (RS2_EXTENSION_MOTION_PROFILE, librealsense::motion_stream_profile_interface)
 
 MAP_EXTENSION (RS2_EXTENSION_POSE_PROFILE, librealsense::pose_stream_profile_interface)
 
 MAP_EXTENSION (RS2_EXTENSION_TM2, librealsense::tm2_extensions)
 
 MAP_EXTENSION (RS2_EXTENSION_OPTIONS, librealsense::options_interface)
 
 MAP_EXTENSION (RS2_EXTENSION_ROI, librealsense::roi_sensor_interface)
 
 MAP_EXTENSION (RS2_EXTENSION_DEPTH_SENSOR, librealsense::depth_sensor)
 
 MAP_EXTENSION (RS2_EXTENSION_DEPTH_STEREO_SENSOR, librealsense::depth_stereo_sensor)
 
 MAP_EXTENSION (RS2_EXTENSION_VIDEO, librealsense::video_sensor_interface)
 
 MAP_EXTENSION (RS2_EXTENSION_VIDEO_PROFILE, librealsense::video_stream_profile_interface)
 
stream_interfacefind_profile (rs2_stream stream, int index, std::vector< stream_interface *> profiles)
 
template<class T , class S >
std::shared_ptr< json_fieldmake_field (T &strct, S T::group_type::*field, float scale=1.0f, bool is_duplicated_field=false)
 
template<class T , class S >
std::shared_ptr< json_fieldmake_string_field (T &strct, S T::group_type::*field, const std::map< std::string, float > &values, bool is_duplicated_field=false)
 
std::shared_ptr< json_fieldmake_ignored_field ()
 
template<class T , class S >
std::shared_ptr< json_fieldmake_invert_field (T &strct, S T::group_type::*field, bool is_duplicated_field=false)
 
template<class T , typename S >
void insert_control_to_map (parsers_map &map, bool was_set, const std::string &name, param_group< T > &control, S field)
 
template<class T , typename S >
void insert_string_control_to_map (parsers_map &map, bool was_set, const std::string &name, param_group< T > &control, S field, const std::map< std::string, float > &values)
 
template<typename T >
void update_preset_control (T &preset_control, const param_group< T > &param)
 
template<typename T >
void update_preset_camera_control (T &camera_control, const param_group< T > &param)
 
parsers_map initialize_field_parsers (preset_param_group &p)
 
std::vector< uint8_t > generate_json (const preset &in_preset)
 
void update_structs (const std::string &content, preset &in_preset)
 
void default_400 (preset &p)
 
void default_405 (preset &p)
 
void default_410 (preset &p)
 
void default_420 (preset &p)
 
void default_430 (preset &p)
 
void high_res_high_accuracy (preset &p)
 
void high_res_high_density (preset &p)
 
void high_res_mid_density (preset &p)
 
void low_res_high_accuracy (preset &p)
 
void low_res_high_density (preset &p)
 
void low_res_mid_density (preset &p)
 
void mid_res_high_accuracy (preset &p)
 
void mid_res_high_density (preset &p)
 
void mid_res_mid_density (preset &p)
 
void hand_gesture (preset &p)
 
void d415_remove_ir (preset &p)
 
void d460_remove_ir (preset &p)
 
size_t get_image_size (int width, int height, rs2_format format)
 
int get_image_bpp (rs2_format format)
 
void deproject_z (float *points, const rs2_intrinsics &z_intrin, const uint16_t *z_pixels, float z_scale)
 
void deproject_disparity (float *points, const rs2_intrinsics &disparity_intrin, const uint16_t *disparity_pixels, float disparity_scale)
 
void align_z_to_other (byte *z_aligned_to_other, const uint16_t *z_pixels, float z_scale, const rs2_intrinsics &z_intrin, const rs2_extrinsics &z_to_other, const rs2_intrinsics &other_intrin)
 
void align_disparity_to_other (byte *disparity_aligned_to_other, const uint16_t *disparity_pixels, float disparity_scale, const rs2_intrinsics &disparity_intrin, const rs2_extrinsics &disparity_to_other, const rs2_intrinsics &other_intrin)
 
void align_other_to_z (byte *other_aligned_to_z, const uint16_t *z_pixels, float z_scale, const rs2_intrinsics &z_intrin, const rs2_extrinsics &z_to_other, const rs2_intrinsics &other_intrin, const byte *other_pixels, rs2_format other_format)
 
void align_other_to_disparity (byte *other_aligned_to_disparity, const uint16_t *disparity_pixels, float disparity_scale, const rs2_intrinsics &disparity_intrin, const rs2_extrinsics &disparity_to_other, const rs2_intrinsics &other_intrin, const byte *other_pixels, rs2_format other_format)
 
std::vector< int > compute_rectification_table (const rs2_intrinsics &rect_intrin, const rs2_extrinsics &rect_to_unrect, const rs2_intrinsics &unrect_intrin)
 
void rectify_image (uint8_t *rect_pixels, const std::vector< int > &rectification_table, const uint8_t *unrect_pixels, rs2_format format)
 
 MAP_EXTENSION (RS2_EXTENSION_PLAYBACK, playback_device)
 
 MAP_EXTENSION (RS2_EXTENSION_RECORD, record_device)
 
void convert (rs2_format source, std::string &target)
 
void convert (const std::string &source, rs2_format &target)
 
void convert (const std::string &source, rs2_stream &target)
 
void convert (const std::string &source, rs2_distortion &target)
 
void convert (const std::string &source, rs2_option &target)
 
void convert (const std::string &source, rs2_frame_metadata_value &target)
 
void convert (const std::string &source, rs2_camera_info &target)
 
void convert (const std::string &source, rs2_timestamp_domain &target)
 
void convert (const std::string &source, rs2_notification_category &target)
 
void convert (const std::string &source, rs2_log_severity &target)
 
void convert (const std::string &source, double &target)
 
void convert (const std::string &source, long long &target)
 
void quat2rot (const geometry_msgs::Transform::_rotation_type &q, float(&r)[9])
 
void rot2quat (const float(&r)[9], geometry_msgs::Transform::_rotation_type &q)
 
void convert (const geometry_msgs::Transform &source, rs2_extrinsics &target)
 
void convert (const rs2_extrinsics &source, geometry_msgs::Transform &target)
 
constexpr uint32_t get_file_version ()
 
constexpr uint32_t get_minimum_supported_file_version ()
 
constexpr uint32_t get_device_index ()
 
constexpr device_serializer::nanoseconds get_static_file_info_timestamp ()
 
device_serializer::nanoseconds to_nanoseconds (const ros::Time &t)
 
ros::Time to_rostime (const device_serializer::nanoseconds &t)
 
template<class S , class Attribute , typename Flag >
std::shared_ptr< md_attribute_parser_basemake_attribute_parser (Attribute S::*attribute, Flag flag, unsigned long long offset, attrib_modifyer mod=nullptr)
 A helper function to create a specialized attribute parser. Return it as a pointer to a base-class. More...
 
template<class St , class Attribute >
std::shared_ptr< md_attribute_parser_basemake_uvc_header_parser (Attribute St::*attribute, attrib_modifyer mod=nullptr)
 A utility function to create UVC metadata header parser. More...
 
template<class St , class Attribute >
std::shared_ptr< md_attribute_parser_basemake_additional_data_parser (Attribute St::*attribute)
 A utility function to create additional_data parser. More...
 
std::shared_ptr< md_attribute_parser_basemake_rs400_sensor_ts_parser (std::shared_ptr< md_attribute_parser_base > frame_ts_parser, std::shared_ptr< md_attribute_parser_base > sensor_ts_parser)
 A helper function to create a specialized parser for RS4xx sensor timestamp. More...
 
template<class S , class Attribute >
std::shared_ptr< md_attribute_parser_basemake_sr300_attribute_parser (Attribute S::*attribute, unsigned long long offset, attrib_modifyer mod=nullptr)
 A helper function to create a specialized attribute parser. Return it as a pointer to a base-class. More...
 
std::string hexify (unsigned char n)
 
template<class T , class R , class W , class U >
std::shared_ptr< struct_field_option< T, R, W, U > > make_field_option (std::shared_ptr< struct_interface< T, R, W >> struct_interface, U T::*field, const option_range &range)
 
 MAP_EXTENSION (RS2_EXTENSION_SOFTWARE_SENSOR, software_sensor)
 
 MAP_EXTENSION (RS2_EXTENSION_SOFTWARE_DEVICE, software_device)
 
stream_profile to_profile (const stream_profile_interface *sp)
 
std::vector< stream_profileto_profiles (const std::vector< std::shared_ptr< stream_profile_interface >> &vec)
 
template<size_t SIZE>
std::string buffer_to_string (const uint8_t(&buff)[SIZE], char separator=',', bool as_hex=false)
 
std::string get_string (perc::Status value)
 
std::ostream & operator<< (std::ostream &os, const perc::TrackingData::Version &v)
 
rs2_format convertTm2PixelFormat (perc::PixelFormat format)
 
perc::PixelFormat convertToTm2PixelFormat (rs2_format format)
 
bool try_convert (rs2_stream stream, perc::SensorType &out)
 
rs2_distortion convertTm2CameraModel (int model)
 
uint32_t convertTm2InterruptRate (perc::SIXDOF_INTERRUPT_RATE rate)
 
float3 toFloat3 (perc::TrackingData::Axis a)
 
float3 toFloat3 (perc::TrackingData::EulerAngles a)
 
float4 toFloat4 (perc::TrackingData::Quaternion q)
 
template<typename T , size_t size>
size_t copy_array (T(&dst)[size], const T(&src)[size])
 
template<typename T , size_t sizem, size_t sizen>
size_t copy_2darray (T(&dst)[sizem][sizen], const T(&src)[sizem][sizen])
 
void copy (void *dst, void const *src, size_t size)
 
std::string make_less_screamy (const char *str)
 
void log_to_console (rs2_log_severity min_severity)
 
void log_to_file (rs2_log_severity min_severity, const char *file_path)
 
template<typename T >
clamp_val (T val, const T &min, const T &max)
 
template<typename T , int sz>
int arr_size (T(&)[sz])
 
template<typename T >
std::string array2str (T &data)
 
bool operator== (const float3 &a, const float3 &b)
 
float3 operator+ (const float3 &a, const float3 &b)
 
float3 operator* (const float3 &a, float b)
 
bool operator== (const float4 &a, const float4 &b)
 
float4 operator+ (const float4 &a, const float4 &b)
 
bool operator== (const float3x3 &a, const float3x3 &b)
 
float3 operator* (const float3x3 &a, const float3 &b)
 
float3x3 operator* (const float3x3 &a, const float3x3 &b)
 
float3x3 transpose (const float3x3 &a)
 
bool operator== (const pose &a, const pose &b)
 
float3 operator* (const pose &a, const float3 &b)
 
pose operator* (const pose &a, const pose &b)
 
pose inverse (const pose &a)
 
pose to_pose (const rs2_extrinsics &a)
 
rs2_extrinsics from_pose (pose a)
 
rs2_extrinsics identity_matrix ()
 
rs2_extrinsics inverse (const rs2_extrinsics &a)
 
bool operator== (const stream_profile &a, const stream_profile &b)
 
bool operator< (const request_mapping &first, const request_mapping &second)
 
bool operator== (const request_mapping &a, const request_mapping &b)
 
template<class T , class R , class W >
std::shared_ptr< struct_interface< T, R, W > > make_struct_interface (R r, W w)
 
rs2_intrinsics pad_crop_intrinsics (const rs2_intrinsics &i, int pad_crop)
 
rs2_intrinsics scale_intrinsics (const rs2_intrinsics &i, int width, int height)
 
bool operator== (const rs2_intrinsics &a, const rs2_intrinsics &b)
 
uint32_t pack (uint8_t c0, uint8_t c1, uint8_t c2, uint8_t c3)
 
bool operator== (const uvc_device_info &a, const uvc_device_info &b)
 
bool operator== (const usb_device_info &a, const usb_device_info &b)
 
bool operator== (const hid_device_info &a, const hid_device_info &b)
 
bool check_not_all_zeros (std::vector< byte > data)
 
std::string datetime_string ()
 
bool file_exists (const char *filename)
 
float3x3 calc_rotation_from_rodrigues_angles (const std::vector< double > rot)
 
uint32_t calc_crc32 (const uint8_t *buf, size_t bufsize)
 

Variables

const native_pixel_format pf_fe_raw8_unpatched_kernel
 
const native_pixel_format pf_raw8
 
const native_pixel_format pf_rw10
 
const native_pixel_format pf_w10
 
const native_pixel_format pf_rw16
 
const native_pixel_format pf_bayer16
 
const native_pixel_format pf_yuy2
 
const native_pixel_format pf_yuyv
 
const native_pixel_format pf_y8
 
const native_pixel_format pf_y8i
 
const native_pixel_format pf_y16
 
const native_pixel_format pf_y12i
 
const native_pixel_format pf_z16
 
const native_pixel_format pf_invz
 
const native_pixel_format pf_f200_invi
 
const native_pixel_format pf_f200_inzi
 
const native_pixel_format pf_sr300_invi
 
const native_pixel_format pf_sr300_inzi
 
const native_pixel_format pf_uyvyl
 
const native_pixel_format pf_accel_axes
 
const native_pixel_format pf_gyro_axes
 
const native_pixel_format pf_rgb888
 
const native_pixel_format pf_gpio_timestamp
 
const native_pixel_format pf_confidence_l500
 
const native_pixel_format pf_z16_l500
 
const native_pixel_format pf_y8_l500
 
const uint16_t SR300_PID = 0x0aa5
 
const double TIMESTAMP_10NSEC_TO_MSEC = 0.00001
 
const uint16_t L500_PID = 0x0b0d
 
constexpr const char * TIMESTAMP_DOMAIN_MD_STR = "timestamp_domain"
 
constexpr const char * SYSTEM_TIME_MD_STR = "system_time"
 
constexpr const char * MAPPER_CONFIDENCE_MD_STR = "Mapper Confidence"
 
constexpr const char * FRAME_TIMESTAMP_MD_STR = "frame_timestamp"
 
constexpr const char * TRACKER_CONFIDENCE_MD_STR = "Tracker Confidence"
 
const int META_DATA_INTEL_DEPTH_CONTROL_VERSION = 0x1
 
const int META_DATA_INTEL_CONFIGURATION_VERSION = 0x1
 
const int META_DATA_INTEL_STAT_VERSION = 0x1
 
const int META_DATA_INTEL_CAPTURE_TIMING_VERSION = 0x1
 
constexpr uint8_t md_capture_timing_size = sizeof(md_capture_timing)
 
const uint8_t INTRINSICS_MODEL_COUNT = 1
 
const uint8_t UVC_GUID_SIZE = 16
 
const uint8_t TRANSFORM_COUNT = 1
 
constexpr uint8_t metadata_raw_size = sizeof(metadata_raw)
 
const size_t PRESISTENCY_LUT_SIZE = 256
 
const std::map< perc::PixelFormat, rs2_formattm2_formats_map
 
const double TIMESTAMP_USEC_TO_MSEC = 0.001
 

Typedef Documentation

§ attrib_modifyer

Post-processing adjustment of the metadata attribute e.g change auto_exposure enum to boolean, change units from nano->ms,etc'.

§ callbacks_heap

§ device_changed_callback

typedef std::function<void(devices_data old, devices_data curr)> librealsense::device_changed_callback

§ devices_changed_callback_ptr

§ devices_changed_function_ptr

typedef void(* librealsense::devices_changed_function_ptr) (rs2_device_list *removed, rs2_device_list *added, void *user)

§ devices_info

typedef std::vector<std::shared_ptr<device_info> > librealsense::devices_info

§ float_4

typedef float librealsense::float_4[4]

§ frame_callback_function_ptr

typedef void(* librealsense::frame_callback_function_ptr) (rs2_frame *frame, void *user)

§ frame_callback_ptr

§ frame_processor_callback_ptr

§ internal_callback

using librealsense::internal_callback = typedef std::function<void(rs2_device_list* removed, rs2_device_list* added)>

§ json

using librealsense::json = typedef nlohmann::json

§ log_callback_ptr

§ metadata_parser_map

§ native_pixel_format_tuple

typedef std::tuple<uint32_t, int, size_t> librealsense::native_pixel_format_tuple

§ notifications_callback_function_ptr

typedef void(* librealsense::notifications_callback_function_ptr) (rs2_notification *notification, void *user)

§ notifications_callback_ptr

§ on_before_frame_callback

§ on_frame

using librealsense::on_frame = typedef std::function<void(frame_interface*)>

§ on_open

typedef std::function<void(std::vector<platform::stream_profile>)> librealsense::on_open

§ output_tuple

§ parsers_map

typedef std::map<std::string, std::shared_ptr<json_field> > librealsense::parsers_map

§ request_mapping_tuple

§ resolution_func

using librealsense::resolution_func = typedef std::function<resolution(resolution res)>

§ stream_id

§ stream_profiles

using librealsense::stream_profiles = typedef std::vector<std::shared_ptr<stream_profile_interface>>

§ sync_callback

Enumeration Type Documentation

§ auto_exposure_modes

Enumerator
static_auto_exposure 
auto_exposure_anti_flicker 
auto_exposure_hybrid 

§ backend_type

Enumerator
standard 
record 
playback 

§ frame_metadata_internal

Metadata fields that are utilized internally by librealsense Provides extention to the r2_frame_metadata list of attributes.

Enumerator
RS2_FRAME_METADATA_HW_TYPE 

8-bit Module type: RS4xx, IVCAM

RS2_FRAME_METADATA_SKU_ID 

8-bit SKU Id

RS2_FRAME_METADATA_FORMAT 

16-bit Frame format

RS2_FRAME_METADATA_WIDTH 

16-bit Frame width. pixels

RS2_FRAME_METADATA_HEIGHT 

16-bit Frame height. pixels

RS2_FRAME_METADATA_COUNT 

§ holes_filling_types

Enumerator
hf_fill_from_left 
hf_farest_from_around 
hf_nearest_from_around 
hf_max_value 

§ md_capture_stat_attributes

md_capture_stat_attributes - bit mask to find enabled attributes in md_capture_stats

Enumerator
exposure_time_attribute 
exposure_compensation_attribute 
iso_speed_attribute 
focus_state_attribute 
lens_posiiton_attribute 
white_balance_attribute 
flash_attribute 
flash_power_attribute 
zoom_factor_attribute 
scene_mode_attribute 
sensor_framerate_attribute 

§ md_capture_timing_attributes

md_capture_timing_attributes - enumerate the bit offset to check a specific attribute of md_capture_timing struct for validity. The enumeration includes up to 32 attributes, according to the size of flags parameter in all the defined structs

Enumerator
frame_counter_attribute 
sensor_timestamp_attribute 
readout_time_attribute 
exposure_attribute 
frame_interval_attribute 
pipe_latency_attribute 

§ md_configuration_attributes

md_configuration_attributes - bit mask to find active attributes, md_configuration struct

Enumerator
hw_type_attribute 
sku_id_attribute 
cookie_attribute 
format_attribute 
width_attribute 
height_attribute 
fps_attribute 
trigger_attribute 
calibration_count_attribute 

§ md_depth_control_attributes

md_depth_control_attributes - bit mask to find active attributes, md_depth_control struct

Enumerator
gain_attribute 
exposure_attribute 
laser_pwr_attribute 
ae_mode_attribute 
exposure_priority_attribute 
roi_attribute 
preset_attribute 

§ md_fisheye_control_attributes

md_fisheye_control_attributes - bit mask to find active attributes, md_fisheye_control struct

Enumerator
gain_attribute 
exposure_attribute 

§ md_rgb_control_attributes

md_rgb_control_attributes - bit mask to find active attributes, md_rgb_control struct

Enumerator
brightness_attribute 
contrast_attribute 
saturation_attribute 
sharpness_attribute 
ae_mode_attribute 
awb_temp_attribute 
gain_attribute 
backlight_comp_attribute 
gamma_attribute 
hue_attribute 
manual_exp_attribute 
manual_wb_attribute 
power_line_frequency_attribute 
low_light_comp_attribute 

§ md_stat_attributes

enum librealsense::md_stat_attributes : uint32_t
strong

md_stat_attributes - bit mask to find active attributes, md_stat struct

Enumerator
left_sum_attribute 
left_dark_count_attribute 
left_bright_count_attribute 
right_sum_attribute 
right_dark_count_attribute 
right_bright_count_attribute 
red_frame_count_attribute 
left_red_sum_attribute 
left_greeen1_attribute 
left_greeen2_attribute 
left_blue_sum_attribute 
right_red_sum_attribute 
right_greeen1_attribute 
right_greeen2_attribute 
right_blue_sum_attribute 

§ md_type

enum librealsense::md_type : uint32_t
strong

md_mode - enumerates the types of metadata modes(structs) supported

Enumerator
META_DATA_INTEL_DEPTH_CONTROL_ID 
META_DATA_INTEL_CAPTURE_TIMING_ID 
META_DATA_INTEL_CONFIGURATION_ID 
META_DATA_INTEL_STAT_ID 
META_DATA_INTEL_FISH_EYE_CONTROL_ID 
META_DATA_INTEL_RGB_CONTROL_ID 
META_DATA_INTEl_FE_FOV_MODEL_ID 
META_DATA_INTEl_FE_CAMERA_EXTRINSICS_ID 
META_DATA_CAPTURE_STATS_ID 
META_DATA_CAMERA_EXTRINSICS_ID 
META_DATA_CAMERA_INTRINSICS_ID 
META_DATA_CAMERA_DEBUG_ID 

§ occlusion_rect_type

Enumerator
occlusion_none 
occlusion_monotonic_scan 
occlusion_exhaustic_search 
occlusion_max 

Function Documentation

§ align_disparity_to_other()

void librealsense::align_disparity_to_other ( byte disparity_aligned_to_other,
const uint16_t *  disparity_pixels,
float  disparity_scale,
const rs2_intrinsics disparity_intrin,
const rs2_extrinsics disparity_to_other,
const rs2_intrinsics other_intrin 
)

§ align_other_to_disparity()

void librealsense::align_other_to_disparity ( byte other_aligned_to_disparity,
const uint16_t *  disparity_pixels,
float  disparity_scale,
const rs2_intrinsics disparity_intrin,
const rs2_extrinsics disparity_to_other,
const rs2_intrinsics other_intrin,
const byte other_pixels,
rs2_format  other_format 
)

§ align_other_to_z()

void librealsense::align_other_to_z ( byte other_aligned_to_z,
const uint16_t *  z_pixels,
float  z_scale,
const rs2_intrinsics z_intrin,
const rs2_extrinsics z_to_other,
const rs2_intrinsics other_intrin,
const byte other_pixels,
rs2_format  other_format 
)

§ align_z_to_other()

void librealsense::align_z_to_other ( byte z_aligned_to_other,
const uint16_t *  z_pixels,
float  z_scale,
const rs2_intrinsics z_intrin,
const rs2_extrinsics z_to_other,
const rs2_intrinsics other_intrin 
)

§ arr_size()

template<typename T , int sz>
int librealsense::arr_size ( T(&)  [sz])

§ array2str()

template<typename T >
std::string librealsense::array2str ( T &  data)

§ As() [1/2]

template<typename T , typename P >
std::shared_ptr<T> librealsense::As ( std::shared_ptr< P >  ptr)
inline

§ As() [2/2]

template<typename T , typename P >
T* librealsense::As ( P *  ptr)
inline

§ buffer_to_string()

template<size_t SIZE>
std::string librealsense::buffer_to_string ( const uint8_t(&)  buff[SIZE],
char  separator = ',',
bool  as_hex = false 
)
inline

§ calc_crc32()

uint32_t librealsense::calc_crc32 ( const uint8_t *  buf,
size_t  bufsize 
)

§ calc_rotation_from_rodrigues_angles()

float3x3 librealsense::calc_rotation_from_rodrigues_angles ( const std::vector< double >  rot)

§ check_not_all_zeros()

bool librealsense::check_not_all_zeros ( std::vector< byte data)
inline

§ clamp_val()

template<typename T >
T librealsense::clamp_val ( val,
const T &  min,
const T &  max 
)
inline

§ compute_rectification_table()

std::vector<int> librealsense::compute_rectification_table ( const rs2_intrinsics rect_intrin,
const rs2_extrinsics rect_to_unrect,
const rs2_intrinsics unrect_intrin 
)

§ convert() [1/14]

void librealsense::convert ( rs2_format  source,
std::string &  target 
)
inline

§ convert() [2/14]

void librealsense::convert ( const std::string &  source,
rs2_format target 
)
inline

§ convert() [3/14]

void librealsense::convert ( const std::string &  source,
rs2_stream target 
)
inline

§ convert() [4/14]

void librealsense::convert ( const std::string &  source,
rs2_distortion target 
)
inline

§ convert() [5/14]

void librealsense::convert ( const std::string &  source,
rs2_option target 
)
inline

§ convert() [6/14]

void librealsense::convert ( const std::string &  source,
rs2_frame_metadata_value target 
)
inline

§ convert() [7/14]

void librealsense::convert ( const std::string &  source,
rs2_camera_info target 
)
inline

§ convert() [8/14]

void librealsense::convert ( const std::string &  source,
rs2_timestamp_domain target 
)
inline

§ convert() [9/14]

void librealsense::convert ( const std::string &  source,
rs2_notification_category target 
)
inline

§ convert() [10/14]

void librealsense::convert ( const std::string &  source,
rs2_log_severity target 
)
inline

§ convert() [11/14]

void librealsense::convert ( const std::string &  source,
double &  target 
)
inline

§ convert() [12/14]

void librealsense::convert ( const std::string &  source,
long long &  target 
)
inline

§ convert() [13/14]

void librealsense::convert ( const geometry_msgs::Transform &  source,
rs2_extrinsics target 
)
inline

§ convert() [14/14]

void librealsense::convert ( const rs2_extrinsics source,
geometry_msgs::Transform &  target 
)
inline

§ convertTm2CameraModel()

rs2_distortion librealsense::convertTm2CameraModel ( int  model)
inline

§ convertTm2InterruptRate()

uint32_t librealsense::convertTm2InterruptRate ( perc::SIXDOF_INTERRUPT_RATE  rate)
inline

§ convertTm2PixelFormat()

rs2_format librealsense::convertTm2PixelFormat ( perc::PixelFormat  format)
inline

§ convertToTm2PixelFormat()

perc::PixelFormat librealsense::convertToTm2PixelFormat ( rs2_format  format)
inline

§ copy()

void librealsense::copy ( void *  dst,
void const *  src,
size_t  size 
)

§ copy_2darray()

template<typename T , size_t sizem, size_t sizen>
size_t librealsense::copy_2darray ( T(&)  dst[sizem][sizen],
const T(&)  src[sizem][sizen] 
)
inline

§ copy_array()

template<typename T , size_t size>
size_t librealsense::copy_array ( T(&)  dst[size],
const T(&)  src[size] 
)
inline

§ d415_remove_ir()

void librealsense::d415_remove_ir ( preset p)

§ d460_remove_ir()

void librealsense::d460_remove_ir ( preset p)

§ datetime_string()

std::string librealsense::datetime_string ( )

§ default_400()

void librealsense::default_400 ( preset p)

§ default_405()

void librealsense::default_405 ( preset p)

§ default_410()

void librealsense::default_410 ( preset p)

§ default_420()

void librealsense::default_420 ( preset p)

§ default_430()

void librealsense::default_430 ( preset p)

§ deproject_disparity()

void librealsense::deproject_disparity ( float *  points,
const rs2_intrinsics disparity_intrin,
const uint16_t *  disparity_pixels,
float  disparity_scale 
)

§ deproject_z()

void librealsense::deproject_z ( float *  points,
const rs2_intrinsics z_intrin,
const uint16_t *  z_pixels,
float  z_scale 
)

§ file_exists()

bool librealsense::file_exists ( const char *  filename)

§ filter_by_mi()

std::vector<platform::uvc_device_info> librealsense::filter_by_mi ( const std::vector< platform::uvc_device_info > &  devices,
uint32_t  mi 
)

§ filter_by_product() [1/2]

std::vector<platform::uvc_device_info> librealsense::filter_by_product ( const std::vector< platform::uvc_device_info > &  devices,
const std::set< uint16_t > &  pid_list 
)

§ filter_by_product() [2/2]

std::vector<platform::usb_device_info> librealsense::filter_by_product ( const std::vector< platform::usb_device_info > &  devices,
const std::set< uint16_t > &  pid_list 
)

§ find_profile()

stream_interface* librealsense::find_profile ( rs2_stream  stream,
int  index,
std::vector< stream_interface *>  profiles 
)

§ from_pose()

rs2_extrinsics librealsense::from_pose ( pose  a)
inline

§ generate_json()

std::vector<uint8_t> librealsense::generate_json ( const preset in_preset)
inline

§ get_device_index()

constexpr uint32_t librealsense::get_device_index ( )

§ get_file_version()

constexpr uint32_t librealsense::get_file_version ( )

Incremental number of the RealSense file format version Since we maintain backward compatability, changes to topics/messages are reflected by the version

§ get_image_bpp()

int librealsense::get_image_bpp ( rs2_format  format)

§ get_image_size()

size_t librealsense::get_image_size ( int  width,
int  height,
rs2_format  format 
)

§ get_mi()

platform::uvc_device_info librealsense::get_mi ( const std::vector< platform::uvc_device_info > &  devices,
uint32_t  mi 
)

§ get_minimum_supported_file_version()

constexpr uint32_t librealsense::get_minimum_supported_file_version ( )

§ get_static_file_info_timestamp()

constexpr device_serializer::nanoseconds librealsense::get_static_file_info_timestamp ( )

§ get_string()

std::string librealsense::get_string ( perc::Status  value)

§ group_devices_and_hids_by_unique_id()

std::vector<std::pair<std::vector<platform::uvc_device_info>, std::vector<platform::hid_device_info> > > librealsense::group_devices_and_hids_by_unique_id ( const std::vector< std::vector< platform::uvc_device_info >> &  devices,
const std::vector< platform::hid_device_info > &  hids 
)

§ group_devices_by_unique_id()

std::vector<std::vector<platform::uvc_device_info> > librealsense::group_devices_by_unique_id ( const std::vector< platform::uvc_device_info > &  devices)

§ hand_gesture()

void librealsense::hand_gesture ( preset p)

§ hexify()

std::string librealsense::hexify ( unsigned char  n)
inline

§ high_res_high_accuracy()

void librealsense::high_res_high_accuracy ( preset p)

§ high_res_high_density()

void librealsense::high_res_high_density ( preset p)

§ high_res_mid_density()

void librealsense::high_res_mid_density ( preset p)

§ identity_matrix()

rs2_extrinsics librealsense::identity_matrix ( )
inline

§ initialize_field_parsers()

parsers_map librealsense::initialize_field_parsers ( preset_param_group p)
inline

§ insert_control_to_map()

template<class T , typename S >
void librealsense::insert_control_to_map ( parsers_map map,
bool  was_set,
const std::string &  name,
param_group< T > &  control,
field 
)

§ insert_string_control_to_map()

template<class T , typename S >
void librealsense::insert_string_control_to_map ( parsers_map map,
bool  was_set,
const std::string &  name,
param_group< T > &  control,
field,
const std::map< std::string, float > &  values 
)

§ inverse() [1/2]

pose librealsense::inverse ( const pose a)
inline

§ inverse() [2/2]

rs2_extrinsics librealsense::inverse ( const rs2_extrinsics a)
inline

§ Is() [1/2]

template<typename T , typename P >
bool librealsense::Is ( std::shared_ptr< P >  ptr)
inline

§ Is() [2/2]

template<typename T , typename P >
bool librealsense::Is ( P *  ptr)
inline

§ list_changed()

template<class T >
bool librealsense::list_changed ( const std::vector< T > &  list1,
const std::vector< T > &  list2,
std::function< bool(T, T)>  equal = [](T first, T second) { return first == second; } 
)

§ log_to_console()

void librealsense::log_to_console ( rs2_log_severity  min_severity)
inline

§ log_to_file()

void librealsense::log_to_file ( rs2_log_severity  min_severity,
const char *  file_path 
)
inline

§ low_res_high_accuracy()

void librealsense::low_res_high_accuracy ( preset p)

§ low_res_high_density()

void librealsense::low_res_high_density ( preset p)

§ low_res_mid_density()

void librealsense::low_res_mid_density ( preset p)

§ make_additional_data_parser()

template<class St , class Attribute >
std::shared_ptr<md_attribute_parser_base> librealsense::make_additional_data_parser ( Attribute St::*  attribute)

A utility function to create additional_data parser.

§ make_archive()

std::shared_ptr<archive_interface> librealsense::make_archive ( rs2_extension  type,
std::atomic< uint32_t > *  in_max_frame_queue_size,
std::shared_ptr< platform::time_service ts,
std::shared_ptr< metadata_parser_map parsers 
)

§ make_attribute_parser()

template<class S , class Attribute , typename Flag >
std::shared_ptr<md_attribute_parser_base> librealsense::make_attribute_parser ( Attribute S::*  attribute,
Flag  flag,
unsigned long long  offset,
attrib_modifyer  mod = nullptr 
)

A helper function to create a specialized attribute parser. Return it as a pointer to a base-class.

§ make_field()

template<class T , class S >
std::shared_ptr<json_field> librealsense::make_field ( T &  strct,
S T::group_type::*  field,
float  scale = 1.0f,
bool  is_duplicated_field = false 
)

§ make_field_option()

template<class T , class R , class W , class U >
std::shared_ptr<struct_field_option<T, R, W, U> > librealsense::make_field_option ( std::shared_ptr< struct_interface< T, R, W >>  struct_interface,
U T::*  field,
const option_range range 
)

§ make_ignored_field()

std::shared_ptr<json_field> librealsense::make_ignored_field ( )

§ make_invert_field()

template<class T , class S >
std::shared_ptr<json_field> librealsense::make_invert_field ( T &  strct,
S T::group_type::*  field,
bool  is_duplicated_field = false 
)

§ make_less_screamy()

std::string librealsense::make_less_screamy ( const char *  str)

§ make_rs400_sensor_ts_parser()

std::shared_ptr<md_attribute_parser_base> librealsense::make_rs400_sensor_ts_parser ( std::shared_ptr< md_attribute_parser_base frame_ts_parser,
std::shared_ptr< md_attribute_parser_base sensor_ts_parser 
)
inline

A helper function to create a specialized parser for RS4xx sensor timestamp.

§ make_sr300_attribute_parser()

template<class S , class Attribute >
std::shared_ptr<md_attribute_parser_base> librealsense::make_sr300_attribute_parser ( Attribute S::*  attribute,
unsigned long long  offset,
attrib_modifyer  mod = nullptr 
)

A helper function to create a specialized attribute parser. Return it as a pointer to a base-class.

§ make_string_field()

template<class T , class S >
std::shared_ptr<json_field> librealsense::make_string_field ( T &  strct,
S T::group_type::*  field,
const std::map< std::string, float > &  values,
bool  is_duplicated_field = false 
)

§ make_struct_interface()

template<class T , class R , class W >
std::shared_ptr<struct_interface<T, R, W> > librealsense::make_struct_interface ( r,
w 
)

§ make_uvc_header_parser()

template<class St , class Attribute >
std::shared_ptr<md_attribute_parser_base> librealsense::make_uvc_header_parser ( Attribute St::*  attribute,
attrib_modifyer  mod = nullptr 
)

A utility function to create UVC metadata header parser.

§ MAP_ADVANCED_MODE() [1/12]

librealsense::MAP_ADVANCED_MODE ( STDepthControlGroup  ,
etDepthControl   
)

§ MAP_ADVANCED_MODE() [2/12]

librealsense::MAP_ADVANCED_MODE ( STRsm  ,
etRsm   
)

§ MAP_ADVANCED_MODE() [3/12]

librealsense::MAP_ADVANCED_MODE ( STRauSupportVectorControl  ,
etRauSupportVectorControl   
)

§ MAP_ADVANCED_MODE() [4/12]

librealsense::MAP_ADVANCED_MODE ( STColorControl  ,
etColorControl   
)

§ MAP_ADVANCED_MODE() [5/12]

librealsense::MAP_ADVANCED_MODE ( STRauColorThresholdsControl  ,
etRauColorThresholdsControl   
)

§ MAP_ADVANCED_MODE() [6/12]

librealsense::MAP_ADVANCED_MODE ( STSloColorThresholdsControl  ,
etSloColorThresholdsControl   
)

§ MAP_ADVANCED_MODE() [7/12]

librealsense::MAP_ADVANCED_MODE ( STSloPenaltyControl  ,
etSloPenaltyControl   
)

§ MAP_ADVANCED_MODE() [8/12]

librealsense::MAP_ADVANCED_MODE ( STHdad  ,
etHdad   
)

§ MAP_ADVANCED_MODE() [9/12]

librealsense::MAP_ADVANCED_MODE ( STColorCorrection  ,
etColorCorrection   
)

§ MAP_ADVANCED_MODE() [10/12]

librealsense::MAP_ADVANCED_MODE ( STDepthTableControl  ,
etDepthTableControl   
)

§ MAP_ADVANCED_MODE() [11/12]

librealsense::MAP_ADVANCED_MODE ( STAEControl  ,
etAEControl   
)

§ MAP_ADVANCED_MODE() [12/12]

librealsense::MAP_ADVANCED_MODE ( STCensusRadius  ,
etCencusRadius9   
)

§ MAP_EXTENSION() [1/23]

librealsense::MAP_EXTENSION ( RS2_EXTENSION_DEBUG  ,
librealsense::debug_interface   
)

§ MAP_EXTENSION() [2/23]

§ MAP_EXTENSION() [3/23]

librealsense::MAP_EXTENSION ( RS2_EXTENSION_INFO  ,
librealsense::info_interface   
)

§ MAP_EXTENSION() [4/23]

§ MAP_EXTENSION() [5/23]

librealsense::MAP_EXTENSION ( RS2_EXTENSION_VIDEO  ,
librealsense::video_sensor_interface   
)

§ MAP_EXTENSION() [6/23]

§ MAP_EXTENSION() [7/23]

librealsense::MAP_EXTENSION ( RS2_EXTENSION_ROI  ,
librealsense::roi_sensor_interface   
)

§ MAP_EXTENSION() [8/23]

librealsense::MAP_EXTENSION ( RS2_EXTENSION_TM2  ,
librealsense::tm2_extensions   
)

§ MAP_EXTENSION() [9/23]

librealsense::MAP_EXTENSION ( RS2_EXTENSION_OPTIONS  ,
librealsense::options_interface   
)

§ MAP_EXTENSION() [10/23]

librealsense::MAP_EXTENSION ( RS2_EXTENSION_SOFTWARE_SENSOR  ,
software_sensor   
)

§ MAP_EXTENSION() [11/23]

librealsense::MAP_EXTENSION ( RS2_EXTENSION_SOFTWARE_DEVICE  ,
software_device   
)

§ MAP_EXTENSION() [12/23]

librealsense::MAP_EXTENSION ( RS2_EXTENSION_RECORD  ,
record_device   
)

§ MAP_EXTENSION() [13/23]

librealsense::MAP_EXTENSION ( RS2_EXTENSION_PLAYBACK  ,
playback_device   
)

§ MAP_EXTENSION() [14/23]

§ MAP_EXTENSION() [15/23]

librealsense::MAP_EXTENSION ( RS2_EXTENSION_POINTS  ,
librealsense::points   
)

§ MAP_EXTENSION() [16/23]

librealsense::MAP_EXTENSION ( RS2_EXTENSION_DEPTH_SENSOR  ,
librealsense::depth_sensor   
)

§ MAP_EXTENSION() [17/23]

librealsense::MAP_EXTENSION ( RS2_EXTENSION_DEPTH_STEREO_SENSOR  ,
librealsense::depth_stereo_sensor   
)

§ MAP_EXTENSION() [18/23]

librealsense::MAP_EXTENSION ( RS2_EXTENSION_COMPOSITE_FRAME  ,
librealsense::composite_frame   
)

§ MAP_EXTENSION() [19/23]

librealsense::MAP_EXTENSION ( RS2_EXTENSION_VIDEO_FRAME  ,
librealsense::video_frame   
)

§ MAP_EXTENSION() [20/23]

librealsense::MAP_EXTENSION ( RS2_EXTENSION_DEPTH_FRAME  ,
librealsense::depth_frame   
)

§ MAP_EXTENSION() [21/23]

librealsense::MAP_EXTENSION ( RS2_EXTENSION_DISPARITY_FRAME  ,
librealsense::disparity_frame   
)

§ MAP_EXTENSION() [22/23]

librealsense::MAP_EXTENSION ( RS2_EXTENSION_MOTION_FRAME  ,
librealsense::motion_frame   
)

§ MAP_EXTENSION() [23/23]

librealsense::MAP_EXTENSION ( RS2_EXTENSION_POSE_FRAME  ,
librealsense::pose_frame   
)

§ mi_present()

bool librealsense::mi_present ( const std::vector< platform::uvc_device_info > &  devices,
uint32_t  mi 
)

§ mid_res_high_accuracy()

void librealsense::mid_res_high_accuracy ( preset p)

§ mid_res_high_density()

void librealsense::mid_res_high_density ( preset p)

§ mid_res_mid_density()

void librealsense::mid_res_mid_density ( preset p)

§ monotonic_to_realtime()

double librealsense::monotonic_to_realtime ( double  monotonic)

§ operator*() [1/5]

float3 librealsense::operator* ( const float3 a,
float  b 
)
inline

§ operator*() [2/5]

float3 librealsense::operator* ( const float3x3 a,
const float3 b 
)
inline

§ operator*() [3/5]

float3x3 librealsense::operator* ( const float3x3 a,
const float3x3 b 
)
inline

§ operator*() [4/5]

float3 librealsense::operator* ( const pose a,
const float3 b 
)
inline

§ operator*() [5/5]

pose librealsense::operator* ( const pose a,
const pose b 
)
inline

§ operator+() [1/2]

float3 librealsense::operator+ ( const float3 a,
const float3 b 
)
inline

§ operator+() [2/2]

float4 librealsense::operator+ ( const float4 a,
const float4 b 
)
inline

§ operator<()

bool librealsense::operator< ( const request_mapping first,
const request_mapping second 
)
inline

§ operator<<()

std::ostream& librealsense::operator<< ( std::ostream &  os,
const perc::TrackingData::Version &  v 
)
inline

§ operator==() [1/10]

bool librealsense::operator== ( const float3 a,
const float3 b 
)
inline

§ operator==() [2/10]

bool librealsense::operator== ( const float4 a,
const float4 b 
)
inline

§ operator==() [3/10]

bool librealsense::operator== ( const float3x3 a,
const float3x3 b 
)
inline

§ operator==() [4/10]

bool librealsense::operator== ( const pose a,
const pose b 
)
inline

§ operator==() [5/10]

bool librealsense::operator== ( const stream_profile a,
const stream_profile b 
)
inline

§ operator==() [6/10]

bool librealsense::operator== ( const request_mapping a,
const request_mapping b 
)
inline

§ operator==() [7/10]

bool librealsense::operator== ( const rs2_intrinsics a,
const rs2_intrinsics b 
)
inline

§ operator==() [8/10]

bool librealsense::operator== ( const uvc_device_info a,
const uvc_device_info b 
)
inline

§ operator==() [9/10]

bool librealsense::operator== ( const usb_device_info a,
const usb_device_info b 
)
inline

§ operator==() [10/10]

bool librealsense::operator== ( const hid_device_info a,
const hid_device_info b 
)
inline

§ pack()

uint32_t librealsense::pack ( uint8_t  c0,
uint8_t  c1,
uint8_t  c2,
uint8_t  c3 
)
inline

§ pad_crop_intrinsics()

rs2_intrinsics librealsense::pad_crop_intrinsics ( const rs2_intrinsics i,
int  pad_crop 
)
inline

§ quat2rot()

void librealsense::quat2rot ( const geometry_msgs::Transform::_rotation_type &  q,
float(&)  r[9] 
)
inline

§ rectify_image()

void librealsense::rectify_image ( uint8_t *  rect_pixels,
const std::vector< int > &  rectification_table,
const uint8_t *  unrect_pixels,
rs2_format  format 
)

§ rot2quat()

void librealsense::rot2quat ( const float(&)  r[9],
geometry_msgs::Transform::_rotation_type &  q 
)
inline

§ scale_intrinsics()

rs2_intrinsics librealsense::scale_intrinsics ( const rs2_intrinsics i,
int  width,
int  height 
)
inline

§ stream_args() [1/2]

template<class T >
void librealsense::stream_args ( std::ostream &  out,
const char *  names,
const T &  last 
)

§ stream_args() [2/2]

template<class T , class... U>
void librealsense::stream_args ( std::ostream &  out,
const char *  names,
const T &  first,
const U &...  rest 
)

§ to_nanoseconds()

device_serializer::nanoseconds librealsense::to_nanoseconds ( const ros::Time &  t)
inline

§ to_pose()

pose librealsense::to_pose ( const rs2_extrinsics a)
inline

§ to_profile()

stream_profile librealsense::to_profile ( const stream_profile_interface sp)
inline

§ to_profiles()

std::vector<stream_profile> librealsense::to_profiles ( const std::vector< std::shared_ptr< stream_profile_interface >> &  vec)
inline

§ to_rostime()

ros::Time librealsense::to_rostime ( const device_serializer::nanoseconds t)
inline

§ toFloat3() [1/2]

float3 librealsense::toFloat3 ( perc::TrackingData::Axis  a)
inline

§ toFloat3() [2/2]

float3 librealsense::toFloat3 ( perc::TrackingData::EulerAngles  a)
inline

§ toFloat4()

float4 librealsense::toFloat4 ( perc::TrackingData::Quaternion  q)
inline

§ transpose()

float3x3 librealsense::transpose ( const float3x3 a)
inline

§ trim_device_list() [1/2]

void librealsense::trim_device_list ( std::vector< platform::uvc_device_info > &  devices,
const std::vector< platform::uvc_device_info > &  chosen 
)

§ trim_device_list() [2/2]

void librealsense::trim_device_list ( std::vector< platform::usb_device_info > &  devices,
const std::vector< platform::usb_device_info > &  chosen 
)

§ try_convert()

bool librealsense::try_convert ( rs2_stream  stream,
perc::SensorType &  out 
)
inline

§ try_extend()

template<typename To >
bool librealsense::try_extend ( std::shared_ptr< extension_snapshot from,
void **  ext 
)
inline

§ update_preset_camera_control()

template<typename T >
void librealsense::update_preset_camera_control ( T &  camera_control,
const param_group< T > &  param 
)

§ update_preset_control()

template<typename T >
void librealsense::update_preset_control ( T &  preset_control,
const param_group< T > &  param 
)

§ update_structs()

void librealsense::update_structs ( const std::string &  content,
preset in_preset 
)
inline

Variable Documentation

§ FRAME_TIMESTAMP_MD_STR

constexpr const char* librealsense::FRAME_TIMESTAMP_MD_STR = "frame_timestamp"

§ INTRINSICS_MODEL_COUNT

const uint8_t librealsense::INTRINSICS_MODEL_COUNT = 1

§ L500_PID

const uint16_t librealsense::L500_PID = 0x0b0d

§ MAPPER_CONFIDENCE_MD_STR

constexpr const char* librealsense::MAPPER_CONFIDENCE_MD_STR = "Mapper Confidence"

§ md_capture_timing_size

constexpr uint8_t librealsense::md_capture_timing_size = sizeof(md_capture_timing)

§ META_DATA_INTEL_CAPTURE_TIMING_VERSION

const int librealsense::META_DATA_INTEL_CAPTURE_TIMING_VERSION = 0x1

§ META_DATA_INTEL_CONFIGURATION_VERSION

const int librealsense::META_DATA_INTEL_CONFIGURATION_VERSION = 0x1

§ META_DATA_INTEL_DEPTH_CONTROL_VERSION

const int librealsense::META_DATA_INTEL_DEPTH_CONTROL_VERSION = 0x1

§ META_DATA_INTEL_STAT_VERSION

const int librealsense::META_DATA_INTEL_STAT_VERSION = 0x1

§ metadata_raw_size

constexpr uint8_t librealsense::metadata_raw_size = sizeof(metadata_raw)

§ pf_accel_axes

const native_pixel_format librealsense::pf_accel_axes

§ pf_bayer16

const native_pixel_format librealsense::pf_bayer16

§ pf_confidence_l500

const native_pixel_format librealsense::pf_confidence_l500

§ pf_f200_invi

const native_pixel_format librealsense::pf_f200_invi

§ pf_f200_inzi

const native_pixel_format librealsense::pf_f200_inzi

§ pf_fe_raw8_unpatched_kernel

const native_pixel_format librealsense::pf_fe_raw8_unpatched_kernel

§ pf_gpio_timestamp

const native_pixel_format librealsense::pf_gpio_timestamp

§ pf_gyro_axes

const native_pixel_format librealsense::pf_gyro_axes

§ pf_invz

const native_pixel_format librealsense::pf_invz

§ pf_raw8

const native_pixel_format librealsense::pf_raw8

§ pf_rgb888

const native_pixel_format librealsense::pf_rgb888

§ pf_rw10

const native_pixel_format librealsense::pf_rw10

§ pf_rw16

const native_pixel_format librealsense::pf_rw16

§ pf_sr300_invi

const native_pixel_format librealsense::pf_sr300_invi

§ pf_sr300_inzi

const native_pixel_format librealsense::pf_sr300_inzi

§ pf_uyvyl

const native_pixel_format librealsense::pf_uyvyl

§ pf_w10

const native_pixel_format librealsense::pf_w10

§ pf_y12i

const native_pixel_format librealsense::pf_y12i

§ pf_y16

const native_pixel_format librealsense::pf_y16

§ pf_y8

const native_pixel_format librealsense::pf_y8

§ pf_y8_l500

const native_pixel_format librealsense::pf_y8_l500

§ pf_y8i

const native_pixel_format librealsense::pf_y8i

§ pf_yuy2

const native_pixel_format librealsense::pf_yuy2

§ pf_yuyv

const native_pixel_format librealsense::pf_yuyv

§ pf_z16

const native_pixel_format librealsense::pf_z16

§ pf_z16_l500

const native_pixel_format librealsense::pf_z16_l500

§ PRESISTENCY_LUT_SIZE

const size_t librealsense::PRESISTENCY_LUT_SIZE = 256

§ SR300_PID

const uint16_t librealsense::SR300_PID = 0x0aa5

§ SYSTEM_TIME_MD_STR

constexpr const char* librealsense::SYSTEM_TIME_MD_STR = "system_time"

§ TIMESTAMP_10NSEC_TO_MSEC

const double librealsense::TIMESTAMP_10NSEC_TO_MSEC = 0.00001

§ TIMESTAMP_DOMAIN_MD_STR

constexpr const char* librealsense::TIMESTAMP_DOMAIN_MD_STR = "timestamp_domain"

§ TIMESTAMP_USEC_TO_MSEC

const double librealsense::TIMESTAMP_USEC_TO_MSEC = 0.001

§ tm2_formats_map

const std::map<perc::PixelFormat, rs2_format> librealsense::tm2_formats_map
Initial value:
=
{
{ perc::PixelFormat::ANY, RS2_FORMAT_ANY },
{ perc::PixelFormat::Z16, RS2_FORMAT_Z16 },
{ perc::PixelFormat::DISPARITY16, RS2_FORMAT_DISPARITY16 },
{ perc::PixelFormat::XYZ32F, RS2_FORMAT_XYZ32F },
{ perc::PixelFormat::YUYV, RS2_FORMAT_YUYV },
{ perc::PixelFormat::RGB8, RS2_FORMAT_RGB8 },
{ perc::PixelFormat::BGR8, RS2_FORMAT_BGR8 },
{ perc::PixelFormat::RGBA8, RS2_FORMAT_RGBA8 },
{ perc::PixelFormat::BGRA8, RS2_FORMAT_BGRA8 },
{ perc::PixelFormat::Y8, RS2_FORMAT_Y8 },
{ perc::PixelFormat::Y16, RS2_FORMAT_Y16 },
{ perc::PixelFormat::RAW8, RS2_FORMAT_RAW8 },
{ perc::PixelFormat::RAW10, RS2_FORMAT_RAW10 },
{ perc::PixelFormat::RAW16, RS2_FORMAT_RAW16 }
}
Definition: rs_sensor.h:63
Definition: rs_sensor.h:58
Definition: rs_sensor.h:61
Definition: rs_sensor.h:59
Definition: rs_sensor.h:62
Definition: rs_sensor.h:60
Definition: rs_sensor.h:57
Definition: rs_sensor.h:69
Definition: rs_sensor.h:65
Definition: rs_sensor.h:67
Definition: rs_sensor.h:70
Definition: rs_sensor.h:64
Definition: rs_sensor.h:66
Definition: rs_sensor.h:68

§ TRACKER_CONFIDENCE_MD_STR

constexpr const char* librealsense::TRACKER_CONFIDENCE_MD_STR = "Tracker Confidence"

§ TRANSFORM_COUNT

const uint8_t librealsense::TRANSFORM_COUNT = 1

§ UVC_GUID_SIZE

const uint8_t librealsense::UVC_GUID_SIZE = 16