Intel® RealSense™ Cross Platform API
Intel Realsense Cross-platform API
Functions
rs_processing.h File Reference

Exposes RealSense processing-block functionality for C compilers. More...

#include "rs_types.h"
#include "rs_sensor.h"
#include "rs_option.h"

Go to the source code of this file.

Functions

rs2_processing_blockrs2_create_colorizer (rs2_error **error)
 
rs2_processing_blockrs2_create_sync_processing_block (rs2_error **error)
 
rs2_processing_blockrs2_create_pointcloud (rs2_error **error)
 
rs2_processing_blockrs2_create_yuy_decoder (rs2_error **error)
 
rs2_processing_blockrs2_create_threshold (rs2_error **error)
 
rs2_processing_blockrs2_create_units_transform (rs2_error **error)
 
rs2_processing_blockrs2_create_processing_block (rs2_frame_processor_callback *proc, rs2_error **error)
 
rs2_processing_blockrs2_create_processing_block_fptr (rs2_frame_processor_callback_ptr proc, void *context, rs2_error **error)
 
int rs2_processing_block_register_simple_option (rs2_processing_block *block, rs2_option option_id, float min, float max, float step, float def, rs2_error **error)
 
void rs2_start_processing (rs2_processing_block *block, rs2_frame_callback *on_frame, rs2_error **error)
 
void rs2_start_processing_fptr (rs2_processing_block *block, rs2_frame_callback_ptr on_frame, void *user, rs2_error **error)
 
void rs2_start_processing_queue (rs2_processing_block *block, rs2_frame_queue *queue, rs2_error **error)
 
void rs2_process_frame (rs2_processing_block *block, rs2_frame *frame, rs2_error **error)
 
void rs2_delete_processing_block (rs2_processing_block *block)
 
rs2_frame_queuers2_create_frame_queue (int capacity, rs2_error **error)
 
void rs2_delete_frame_queue (rs2_frame_queue *queue)
 
rs2_framers2_wait_for_frame (rs2_frame_queue *queue, unsigned int timeout_ms, rs2_error **error)
 
int rs2_poll_for_frame (rs2_frame_queue *queue, rs2_frame **output_frame, rs2_error **error)
 
int rs2_try_wait_for_frame (rs2_frame_queue *queue, unsigned int timeout_ms, rs2_frame **output_frame, rs2_error **error)
 
void rs2_enqueue_frame (rs2_frame *frame, void *queue)
 
rs2_processing_blockrs2_create_align (rs2_stream align_to, rs2_error **error)
 
rs2_processing_blockrs2_create_decimation_filter_block (rs2_error **error)
 
rs2_processing_blockrs2_create_temporal_filter_block (rs2_error **error)
 
rs2_processing_blockrs2_create_spatial_filter_block (rs2_error **error)
 
rs2_processing_blockrs2_create_disparity_transform_block (unsigned char transform_to_disparity, rs2_error **error)
 
rs2_processing_blockrs2_create_hole_filling_filter_block (rs2_error **error)
 
rs2_processing_blockrs2_create_rates_printer_block (rs2_error **error)
 
rs2_processing_blockrs2_create_zero_order_invalidation_block (rs2_error **error)
 
rs2_processing_blockrs2_create_huffman_depth_decompress_block (rs2_error **error)
 
rs2_processing_blockrs2_create_hdr_merge_processing_block (rs2_error **error)
 
rs2_processing_blockrs2_create_sequence_id_filter (rs2_error **error)
 
const char * rs2_get_processing_block_info (const rs2_processing_block *block, rs2_camera_info info, rs2_error **error)
 
int rs2_supports_processing_block_info (const rs2_processing_block *block, rs2_camera_info info, rs2_error **error)
 
int rs2_is_processing_block_extendable_to (const rs2_processing_block *block, rs2_extension extension_type, rs2_error **error)
 

Detailed Description

Exposes RealSense processing-block functionality for C compilers.

Function Documentation

◆ rs2_create_align()

rs2_processing_block* rs2_create_align ( rs2_stream  align_to,
rs2_error **  error 
)

Creates Align processing block.

Parameters
[in]align_tostream type to be used as the target of frameset alignment
[out]errorif non-null, receives any error that occurs during this call, otherwise, errors are ignored

◆ rs2_create_colorizer()

rs2_processing_block* rs2_create_colorizer ( rs2_error **  error)

Creates Depth-Colorizer processing block that can be used to quickly visualize the depth data This block will accept depth frames as input and replace them by depth frames with format RGB8 Non-depth frames are passed through Further customization will be added soon (format, color-map, histogram equalization control)

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

◆ rs2_create_decimation_filter_block()

rs2_processing_block* rs2_create_decimation_filter_block ( rs2_error **  error)

Creates Depth post-processing filter block. This block accepts depth frames, applies decimation filter and plots modified prames Note that due to the modifiedframe size, the decimated frame repaces the original one

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

◆ rs2_create_disparity_transform_block()

rs2_processing_block* rs2_create_disparity_transform_block ( unsigned char  transform_to_disparity,
rs2_error **  error 
)

Creates a post processing block that provides for depth<->disparity domain transformation for stereo-based depth modules

Parameters
[in]transform_to_disparityflag select the transform direction: true = depth->disparity, and vice versa
[out]errorif non-null, receives any error that occurs during this call, otherwise, errors are ignored

◆ rs2_create_frame_queue()

rs2_frame_queue* rs2_create_frame_queue ( int  capacity,
rs2_error **  error 
)

create frame queue. frame queues are the simplest x-platform synchronization primitive provided by librealsense to help developers who are not using async APIs

Parameters
[in]capacitymax number of frames to allow to be stored in the queue before older frames will start to get dropped
[out]errorif non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns
handle to the frame queue, must be released using rs2_delete_frame_queue

◆ rs2_create_hdr_merge_processing_block()

rs2_processing_block* rs2_create_hdr_merge_processing_block ( rs2_error **  error)

Creates a hdr_merge processing block. The block merges between two depth frames with different exposure values

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

◆ rs2_create_hole_filling_filter_block()

rs2_processing_block* rs2_create_hole_filling_filter_block ( rs2_error **  error)

Creates Depth post-processing hole filling block. The filter replaces empty pixels with data from adjacent pixels based on the method selected

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

◆ rs2_create_huffman_depth_decompress_block()

rs2_processing_block* rs2_create_huffman_depth_decompress_block ( rs2_error **  error)

Creates Depth frame decompression module. Decoded frames compressed and transmitted with Z16H variable-lenght Huffman code to standartized Z16 Depth data format. Using the compression allows to reduce the Depth frames bandwidth by more than 50 percent

Parameters
[out]errorIf non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns
Huffman-code decompression processing block

◆ rs2_create_pointcloud()

rs2_processing_block* rs2_create_pointcloud ( rs2_error **  error)

Creates Point-Cloud processing block. This block accepts depth frames and outputs Points frames In addition, given non-depth frame, the block will align texture coordinate to the non-depth stream

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

◆ rs2_create_processing_block()

rs2_processing_block* rs2_create_processing_block ( rs2_frame_processor_callback proc,
rs2_error **  error 
)

This method creates new custom processing block. This lets the users pass frames between module boundaries for processing This is an infrastructure function aimed at middleware developers, and also used by provided blocks such as sync, colorizer, etc..

Parameters
procProcessing function to be applied to every frame entering the block
[out]errorif non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns
new processing block, to be released by rs2_delete_processing_block

◆ rs2_create_processing_block_fptr()

rs2_processing_block* rs2_create_processing_block_fptr ( rs2_frame_processor_callback_ptr  proc,
void *  context,
rs2_error **  error 
)

This method creates new custom processing block from function pointer. This lets the users pass frames between module boundaries for processing This is an infrastructure function aimed at middleware developers, and also used by provided blocks such as sync, colorizer, etc..

Parameters
procProcessing function pointer to be applied to every frame entering the block
contextUser context (can be anything or null) to be passed later as ctx param of the callback
[out]errorif non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns
new processing block, to be released by rs2_delete_processing_block

◆ rs2_create_rates_printer_block()

rs2_processing_block* rs2_create_rates_printer_block ( rs2_error **  error)

Creates a rates printer block. The printer prints the actual FPS of the invoked frame stream. The block ignores reapiting frames and calculats the FPS only if the frame number of the relevant frame was changed.

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

◆ rs2_create_sequence_id_filter()

rs2_processing_block* rs2_create_sequence_id_filter ( rs2_error **  error)

Creates a sequence_id_filter processing block. The block lets frames with the selected sequence id pass and blocks frames with other values

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

◆ rs2_create_spatial_filter_block()

rs2_processing_block* rs2_create_spatial_filter_block ( rs2_error **  error)

Creates Depth post-processing spatial filter block. This block accepts depth frames, applies spatial filters and plots modified prames

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

◆ rs2_create_sync_processing_block()

rs2_processing_block* rs2_create_sync_processing_block ( rs2_error **  error)

Creates Sync processing block. This block accepts arbitrary frames and output composite frames of best matches Some frames may be released within the syncer if they are waiting for match for too long Syncronization is done (mostly) based on timestamps so good hardware timestamps are a pre-condition

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

◆ rs2_create_temporal_filter_block()

rs2_processing_block* rs2_create_temporal_filter_block ( rs2_error **  error)

Creates Depth post-processing filter block. This block accepts depth frames, applies temporal filter

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

◆ rs2_create_threshold()

rs2_processing_block* rs2_create_threshold ( rs2_error **  error)

Creates depth thresholding processing block By controlling min and max options on the block, one could filter out depth values that are either too large or too small, as a software post-processing step

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

◆ rs2_create_units_transform()

rs2_processing_block* rs2_create_units_transform ( rs2_error **  error)

Creates depth units transformation processing block All of the pixels are transformed from depth units into meters.

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

◆ rs2_create_yuy_decoder()

rs2_processing_block* rs2_create_yuy_decoder ( rs2_error **  error)

Creates YUY decoder processing block. This block accepts raw YUY frames and outputs frames of other formats. YUY is a common video format used by a variety of web-cams. It benefits from packing pixels into 2 bytes per pixel without signficant quality drop. YUY representation can be converted back to more usable RGB form, but this requires somewhat costly conversion. The SDK will automatically try to use SSE2 and AVX instructions and CUDA where available to get best performance. Other implementations (using GLSL, OpenCL, Neon and NCS) should follow.

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

◆ rs2_create_zero_order_invalidation_block()

rs2_processing_block* rs2_create_zero_order_invalidation_block ( rs2_error **  error)

Creates Depth post-processing zero order fix block. The filter invalidates pixels that has a wrong value due to zero order effect

Parameters
[out]errorIf non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns
zero order fix processing block

◆ rs2_delete_frame_queue()

void rs2_delete_frame_queue ( rs2_frame_queue queue)

deletes frame queue and releases all frames inside it

Parameters
[in]queuequeue to delete

◆ rs2_delete_processing_block()

void rs2_delete_processing_block ( rs2_processing_block block)

Deletes the processing block

Parameters
[in]blockProcessing block

◆ rs2_enqueue_frame()

void rs2_enqueue_frame ( rs2_frame frame,
void *  queue 
)

enqueue new frame into a queue

Parameters
[in]frameframe handle to enqueue (this operation passed ownership to the queue)
[in]queuethe frame queue data structure

◆ rs2_get_processing_block_info()

const char* rs2_get_processing_block_info ( const rs2_processing_block block,
rs2_camera_info  info,
rs2_error **  error 
)

Retrieve processing block specific information, like name.

Parameters
[in]blockThe processing block
[in]infoprocessing block info type to retrieve
[out]errorIf non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns
The requested processing block info string, in a format specific to the device model

◆ rs2_is_processing_block_extendable_to()

int rs2_is_processing_block_extendable_to ( const rs2_processing_block block,
rs2_extension  extension_type,
rs2_error **  error 
)

Test if the given processing block can be extended to the requested extension

Parameters
[in]blockprocessing block
[in]extensionThe extension to which the sensor should be tested if it is extendable
[out]errorif non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns
non-zero value iff the processing block can be extended to the given extension

◆ rs2_poll_for_frame()

int rs2_poll_for_frame ( rs2_frame_queue queue,
rs2_frame **  output_frame,
rs2_error **  error 
)

poll if a new frame is available and dequeue if it is

Parameters
[in]queuethe frame queue data structure
[out]output_frameframe handle to be released using rs2_release_frame
[out]errorif non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns
true if new frame was stored to output_frame

◆ rs2_process_frame()

void rs2_process_frame ( rs2_processing_block block,
rs2_frame frame,
rs2_error **  error 
)

This method is used to pass frame into a processing block

Parameters
[in]blockProcessing block
[in]frameFrame to process, ownership is moved to the block object
[out]errorif non-null, receives any error that occurs during this call, otherwise, errors are ignored

◆ rs2_processing_block_register_simple_option()

int rs2_processing_block_register_simple_option ( rs2_processing_block block,
rs2_option  option_id,
float  min,
float  max,
float  step,
float  def,
rs2_error **  error 
)

This method adds a custom option to a custom processing block. This is a simple float that can be accessed via rs2_set_option and rs2_get_option This is an infrastructure function aimed at middleware developers, and also used by provided blocks such as save_to_ply, etc..

Parameters
[in]blockProcessing block
[in]option_idan int ID for referencing the option
[in]minthe minimum value which will be accepted for this option
[in]maxthe maximum value which will be accepted for this option
[in]stepthe granularity of options which accept discrete values, or zero if the option accepts continuous values
[in]defthe default value of the option. This will be the initial value.
[out]errorif non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns
true if adding the option succeeds. false if it fails e.g. an option with this id is already registered

◆ rs2_start_processing()

void rs2_start_processing ( rs2_processing_block block,
rs2_frame_callback on_frame,
rs2_error **  error 
)

This method is used to direct the output from the processing block to some callback or sink object

Parameters
[in]blockProcessing block
[in]on_frameCallback to be invoked every time the processing block calls frame_ready
[out]errorif non-null, receives any error that occurs during this call, otherwise, errors are ignored

◆ rs2_start_processing_fptr()

void rs2_start_processing_fptr ( rs2_processing_block block,
rs2_frame_callback_ptr  on_frame,
void *  user,
rs2_error **  error 
)

This method is used to direct the output from the processing block to some callback or sink object

Parameters
[in]blockProcessing block
[in]on_frameCallback function to be invoked every time the processing block calls frame_ready
[in]userUser context for the callback (can be anything or null)
[out]errorif non-null, receives any error that occurs during this call, otherwise, errors are ignored

◆ rs2_start_processing_queue()

void rs2_start_processing_queue ( rs2_processing_block block,
rs2_frame_queue queue,
rs2_error **  error 
)

This method is used to direct the output from the processing block to a dedicated queue object

Parameters
[in]blockProcessing block
[in]queueQueue to place the processed frames to
[out]errorif non-null, receives any error that occurs during this call, otherwise, errors are ignored

◆ rs2_supports_processing_block_info()

int rs2_supports_processing_block_info ( const rs2_processing_block block,
rs2_camera_info  info,
rs2_error **  error 
)

Check if a processing block supports a specific info type.

Parameters
[in]blockThe processing block to check
[in]infoThe parameter to check for support
[out]errorIf non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns
True if the parameter both exist and well-defined for the specific device

◆ rs2_try_wait_for_frame()

int rs2_try_wait_for_frame ( rs2_frame_queue queue,
unsigned int  timeout_ms,
rs2_frame **  output_frame,
rs2_error **  error 
)

wait until new frame becomes available in the queue and dequeue it

Parameters
[in]queuethe frame queue data structure
[in]timeout_msmax time in milliseconds to wait until a frame becomes available
[out]output_frameframe handle to be released using rs2_release_frame
[out]errorif non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns
true if new frame was stored to output_frame

◆ rs2_wait_for_frame()

rs2_frame* rs2_wait_for_frame ( rs2_frame_queue queue,
unsigned int  timeout_ms,
rs2_error **  error 
)

wait until new frame becomes available in the queue and dequeue it

Parameters
[in]queuethe frame queue data structure
[in]timeout_msmax time in milliseconds to wait until an exception will be thrown
[out]errorif non-null, receives any error that occurs during this call, otherwise, errors are ignored
Returns
frame handle to be released using rs2_release_frame