Skip to content

Namespace ILLIXR

Namespace List > ILLIXR

RAC_ERRNO_MSG. More...

Namespaces

Type Name
namespace coordinates
namespace data_format
namespace decode
namespace detail
namespace display
namespace math_util
namespace network
namespace vk
namespace vulkan
namespace zed_capture

Classes

Type Name
struct Dependency
struct DistortionCorrectionVertex
struct DistortionMatrix
class HMD
struct OpenWarpVertex
struct WarpMatrices
class ada_video_decoder
class ada_video_encoder
class boba_immersive
class boba_streaming_server
class cancellable_sleep
class data_injection
class data_use_indicator
A helper class that lets one dynamically determine if some data gets used.
class debugview
class depthai
class device_rx
class device_tx
struct display_params
Display parameters.
class dynamic_lib
class event
A boolean condition-variable.
class fauxpose
class fauxpose_impl
Create a "pose_prediction" type service.
class frame_dumper
class gldemo
class ground_truth_slam
class gtsam_integrator
struct index_params
class lazy_load_image
class lighthouse
class managed_thread
An object that manages a std::thread; it joins and exits when the object gets destructed.
class mesh_compression
class mesh_decompression
struct model
class native_renderer
class ndk_encoder
class network_latency_rx
Network latency measurement server plugin (RX side).
class network_latency_tx
Network latency measurement client plugin (TX side).
class no_op_record_logger
class nvdec_decoder
class offline_cam
class offline_imu
class offline_scannet
class offload_data
class offload_reader
class offload_rendering_client
class offload_rendering_server
Main server implementation for offload rendering.
class offload_rendering_server_loader
Plugin loader for the offload rendering server.
class offload_writer
class openni_plugin
class openwarp_vk
class openwarp_vk_plugin
class openxr_quest_controller
class oxr_relay
class passthrough_integrator
struct pending_rgb
class phonebook
A service locator forILLIXR .
class plugin
A dynamically-loadable plugin for Spindle.
struct pose_history_entry
class pose_lookup_impl
struct pose_map_entry
class pose_prediction_impl
class pose_relay
struct py_query_response_writer
struct py_semantic_data_reader
struct py_voice_query_reader
struct quest3_params
struct raw_imu_type
class realsense
class record
This class represents a tuple of fields which get logged by record_logger .
class record_coalescer
Coalesces logs of the same type to be written back as a single-transaction.
class record_header
Schema of each record.
class record_imu_cam
class record_logger
The ILLIXR logging service for structured records.
class record_rgb_depth
class relative_clock
Relative clock for all of ILLIXR .
struct rendering_params
Rendering parameters.
class rk4_integrator
class runtime
class scene_management
class semantic_python
struct sensor_types
struct server_params
class server_reader
class server_rx
class server_writer
class spatial_hash
class sqlite_record_logger
class sqlite_thread
struct state_plus
class stdout_record_logger
class stereo_renderer
Stereo video renderer for Quest 3 — Vulkan backend.
class stoplight
Start/stop synchronization for the whole application.
class switchboard
A manager for typesafe, threadsafe, named event-streams (called topics).
class tcp_network_backend
struct texture
class threadloop
A reusable threadloop for plugins.
class time_point
class timewarp_gl
class timewarp_vk
class timewarp_vk_plugin
class udp_network_backend
struct velocity_filter
struct vertex
class video_decoder
class video_encoder
class viewer
class vio_video_decoder
class vio_video_encoder
class vkdemo
class vkdemo_plugin
class webcam
class xlib_gl_extended_window
class xr_sensor_capture
ILLIXR plugin that co-captures HEVC-encoded RGB frames, depth frames, and per-sensor matched head poses on the Meta Quest 3.
class zed_camera
class zed_camera_thread
class zed_imu_thread

Public Types

Type Name
typedef std::function< void(cv::Mat &&, cv::Mat &&)> DecodeCallback
typedef std::function< void(const GstMapInfo &, const GstMapInfo &)> FrameCallback
typedef std::tuple< VoxelBlockIndex, std::vector< Eigen::Vector3d >, std::vector< Eigen::Vector3d > > NewVB
typedef std::tuple< int, int, std::vector< int > > Nullified_Ranges
typedef HGLRC TW_GL_CONTEXT
typedef std::tuple< VoxelBlockIndex, int, int > Vector_range
typedef std::tuple< int, int, int > VoxelBlockIndex
typedef std::chrono::duration< clock_rep_, clock_period_ > clock_duration_
typedef std::nano clock_period_
typedef long long clock_rep_
typedef relative_clock::duration duration
typedef plugin *(* plugin_factory
typedef std::size_t plugin_id_t
typedef ILLIXR::data_format::pose::fast_head_pose_type pose_point
typedef data_format::pose::head_pose_type sensor_types
typedef threadloop timewarp_type
typedef std::unique_ptr< void, std::function< void(void *)> > void_ptr

Public Attributes

Type Name
const std::vector< std::string > ENV_VARS = /* multi line expression */
const size_t LOG_PERIOD = 20
const record_header _plugin_start_header = /* multi line expression */
const record_header _switchboard_callback_header = /* multi line expression */
const record_header _switchboard_topic_stop_header = /* multi line expression */
const record_header _threadloop_iteration_header = /* multi line expression */
const std::string delimiter = "EEND!"
const data_format::proper_quaterniond dq_0
const std::vector< std::string > ignore_vars = {"plugins"}
size_t log_count_ = 0
constexpr float server_fov = 0.99[**f**](namespaceILLIXR.md#function-normalize)

Public Static Attributes

Type Name
const bool ENABLE_VERBOSE_ERRORS = /* multi line expression */
std::chrono::milliseconds LOG_BUFFER_DELAY = {1000}

Public Functions

Type Name
const Eigen::Vector3d Gravity (0. 0, 0. 0, 9. 81)
void abort (const std::string & msg="", const int error_val=1)
Exits the application during a fatal error.
std::string configured_headset ()
data_format::proper_quaterniond delta_q (const data_format::proper_quaterniond & k_n)
void denormalize (T & obj, const float width, const float height, const float depth)
void denormalize (T & obj, const float width, const float height)
void denormalize< data_format::shapes::rect > (data_format::shapes::rect & obj, const float width, const float height, const float depth)
double duration_to_double (duration dur)
constexpr duration freq_to_period (double fps)
std::string get_app_files_dir (android_app * app)
Eigen::Matrix4d makeOmega (const Eigen::Vector3d & w)
Generate the Omega matrix from the input 3-element vector.
std::shared_ptr< data_format::compressed_frame > make_ffmpeg_queued_frame (Args &&... args)
void normalize (T & obj, const float width, const float height, const float depth)
void normalize (T & obj, const float width, const float height)
void normalize< data_format::shapes::rect > (data_format::shapes::rect & obj, const float width, const float height, const float depth)
bool operator!= (const time_point & lhs, const time_point & rhs)
time_point operator+ (const time_point & pt, const time_point::duration & d)
time_point operator+ (const time_point::duration & d, const time_point & pt)
time_point::duration operator- (const time_point & lhs, const time_point & rhs)
bool operator< (const time_point & lhs, const time_point & rhs)
std::ostream & operator<< (std::ostream & os, const state_plus & sp)
bool operator<= (const time_point & lhs, const time_point & rhs)
bool operator== (const time_point & lhs, const time_point & rhs)
bool operator> (const time_point & lhs, const time_point & rhs)
bool operator>= (const time_point & lhs, const time_point & rhs)
Eigen::Vector3d p_dot (const Eigen::Vector3d & iv, const Eigen::Vector3d & k_n)
f(x) for the position Calculate the new position based on the initial velocity and change in velocity
state_plus predict_mean_rk4 (double dt, const state_plus & sp, const Eigen::Vector3d & ang_vel, const Eigen::Vector3d & linear_acc, const Eigen::Vector3d & ang_vel2, const Eigen::Vector3d & linear_acc2)
data_format::proper_quaterniond q_dot (const Eigen::Vector3d & av, const data_format::proper_quaterniond & dq)
void register_bindings (pybind11::module_ & m)
void report_and_clear_errno (const std::string & file, const int & line, const std::string & function, const std::string & msg="")
Support function to report errno values when debugging (NDEBUG).
MY_EXPORT_API int run (const cxxopts::ParseResult & options)
MY_EXPORT_API runtime * runtime_factory ()
T solve (const T & yn, const T & k1, const T & k2, const T & k3, const T & k4)
Solve for the Runge-Kutta 4th order approximation.
std::vector< std::string > split (const std::string & s, char delimiter)
Splits a string into tokens by a delimiter character.
bool str_to_bool (const std::string & var)
Convert a string containing a (python) boolean to the bool type.
Eigen::Matrix3d symmetric_skew (const Eigen::Vector3d & vec)
Generates a skew-symmetric matrix from the given 3-element vector.
void track_time (const std::string & message, const std::function< void()> & func)
Eigen::Vector3d v_dot (const data_format::proper_quaterniond & dq, const data_format::proper_quaterniond & q, const Eigen::Vector3d & l_acc)
f(x) for the velocity Calculate the updated velocity from the acceleration and initial and delta quaternions

Public Static Functions

Type Name
pybind11::array_t< uint8_t > entry_to_numpy (const decode::decoded_frame_cache::Entry * entry)
pybind11::array_t< float > intrinsics_to_numpy (const data_format::camera_intrinsics & intr)
pybind11::array_t< float > to_numpy_4x4_safe (std::shared_ptr< const data_format::semantic_frame > owner, const float * data)
pybind11::array_t< uint8_t > to_numpy_flat_safe (std::shared_ptr< const data_format::semantic_frame > owner, const uint8_t * data, size_t size)

Detailed Description

There are many SQLite3 wrapper libraries. List source TODO: this

Public Types Documentation

typedef DecodeCallback

using ILLIXR::DecodeCallback = typedef std::function<void(cv::Mat&&, cv::Mat&&)>;

typedef FrameCallback

using ILLIXR::FrameCallback = typedef std::function<void(const GstMapInfo&, const GstMapInfo&)>;

typedef NewVB

typedef std::tuple< VoxelBlockIndex, std::vector< Eigen::Vector3d >, std::vector< Eigen::Vector3d > > ILLIXR::NewVB;

typedef Nullified_Ranges

using ILLIXR::Nullified_Ranges = typedef std::tuple<int, int, std::vector<int> >;

typedef TW_GL_CONTEXT

typedef HGLRC ILLIXR::TW_GL_CONTEXT;

typedef Vector_range

using ILLIXR::Vector_range = typedef std::tuple<VoxelBlockIndex, int, int>;

typedef VoxelBlockIndex

typedef std::tuple< int, int, int > ILLIXR::VoxelBlockIndex;

typedef clock_duration_

using ILLIXR::clock_duration_ = typedef std::chrono::duration<clock_rep_, clock_period_>;

typedef clock_period_

using ILLIXR::clock_period_ = typedef std::nano;

typedef clock_rep_

using ILLIXR::clock_rep_ = typedef long long;

Mimic of std::chrono::time_point<Clock, Rep> 1.

Can't use std::chrono::time_point<Clock, Rep>, because the Clock must satisfy the Clock interface 2, but relative_clock cannot satisfy this interface because relative_clock::now() is a stateful (instance method) not pure (class method). Instead, we will mimic the interface of 1 here.

typedef duration

using ILLIXR::duration = typedef relative_clock::duration;

typedef plugin_factory

typedef plugin *(* ILLIXR::plugin_factory) (phonebook *);

typedef plugin_id_t

typedef std::size_t ILLIXR::plugin_id_t;

typedef pose_point

typedef ILLIXR::data_format::pose::fast_head_pose_type ILLIXR::pose_point;

typedef sensor_types

typedef data_format::pose::head_pose_type ILLIXR::sensor_types;

typedef timewarp_type

typedef threadloop ILLIXR::timewarp_type;

typedef void_ptr

using ILLIXR::void_ptr = typedef std::unique_ptr<void, std::function<void(void*)> >;

Public Attributes Documentation

variable ENV_VARS

const std::vector<std::string> ILLIXR::ENV_VARS;

variable LOG_PERIOD

const size_t ILLIXR::LOG_PERIOD;

variable _plugin_start_header

const record_header ILLIXR::_plugin_start_header;

variable _switchboard_callback_header

const record_header ILLIXR::_switchboard_callback_header;

@Should be private to Switchboard.

variable _switchboard_topic_stop_header

const record_header ILLIXR::_switchboard_topic_stop_header;

@Should be private to Switchboard.

variable _threadloop_iteration_header

const record_header ILLIXR::_threadloop_iteration_header;

variable delimiter

const std::string ILLIXR::delimiter;

variable dq_0

const data_format::proper_quaterniond ILLIXR::dq_0(1., 0., 0., 0.);

variable ignore_vars

const std::vector<std::string> ILLIXR::ignore_vars;

variable log_count_

size_t ILLIXR::log_count_;

variable server_fov

constexpr float ILLIXR::server_fov;

Public Static Attributes Documentation

variable ENABLE_VERBOSE_ERRORS

const bool ILLIXR::ENABLE_VERBOSE_ERRORS;

variable LOG_BUFFER_DELAY

std::chrono::milliseconds ILLIXR::LOG_BUFFER_DELAY;

Public Functions Documentation

function Gravity

const Eigen::Vector3d ILLIXR::Gravity (
    0. 0,
    0. 0,
    9. 81
)

Initial quaternion

function abort

Exits the application during a fatal error. 

inline void ILLIXR::abort (
    const std::string & msg="",
    const  int error_val=1
)

Switches to using abort during debugging over std::exit so that we can capture SIGABRT for debugging.

function configured_headset

inline std::string ILLIXR::configured_headset ()

function delta_q

inline data_format::proper_quaterniond ILLIXR::delta_q (
    const  data_format::proper_quaterniond & k_n
)

Calculate the change in orientation based on the input Quaternion

Parameters:

  • k_n The input Quaternion

Returns:

The change in orientation

function denormalize

template<typename T>
inline void ILLIXR::denormalize (
    T & obj,
    const  float width,
    const  float height,
    const  float depth
)

function denormalize

template<typename T>
inline void ILLIXR::denormalize (
    T & obj,
    const  float width,
    const  float height
)

function denormalize< data_format::shapes::rect >

template<>
inline void ILLIXR::denormalize< data_format::shapes::rect > (
    data_format::shapes::rect & obj,
    const  float width,
    const  float height,
    const  float depth
)

function duration_to_double

template<typename Unit>
double ILLIXR::duration_to_double (
    duration dur
)

function freq_to_period

constexpr  duration ILLIXR::freq_to_period (
    double fps
)

function get_app_files_dir

inline std::string ILLIXR::get_app_files_dir (
    android_app * app
)

function makeOmega

Generate the Omega matrix from the input 3-element vector. 

inline Eigen::Matrix4d ILLIXR::makeOmega (
    const Eigen::Vector3d & w
)

Based on equation 48 of http://mars.cs.umn.edu/tr/reports/Trawny05b.pdf

function make_ffmpeg_queued_frame

template<typename... Args>
std::shared_ptr< data_format::compressed_frame > ILLIXR::make_ffmpeg_queued_frame (
    Args &&... args
)

function normalize

template<typename T>
inline void ILLIXR::normalize (
    T & obj,
    const float width,
    const float height,
    const float depth
)

function normalize

template<typename T>
inline void ILLIXR::normalize (
    T & obj,
    const float width,
    const float height
)

function normalize< data_format::shapes::rect >

template<>
inline void ILLIXR::normalize< data_format::shapes::rect > (
    data_format::shapes::rect & obj,
    const  float width,
    const  float height,
    const  float depth
)

function operator!=

inline bool ILLIXR::operator!= (
    const  time_point & lhs,
    const  time_point & rhs
)

function operator+

inline time_point ILLIXR::operator+ (
    const  time_point & pt,
    const  time_point::duration & d
)

function operator+

inline time_point ILLIXR::operator+ (
    const  time_point::duration & d,
    const  time_point & pt
)

function operator-

inline time_point::duration ILLIXR::operator- (
    const  time_point & lhs,
    const  time_point & rhs
)

function operator<

inline bool ILLIXR::operator< (
    const  time_point & lhs,
    const  time_point & rhs
)

function operator<<

std::ostream & ILLIXR::operator<< (
    std::ostream & os,
    const  state_plus & sp
)

function operator<=

inline bool ILLIXR::operator<= (
    const  time_point & lhs,
    const  time_point & rhs
)

function operator==

inline bool ILLIXR::operator== (
    const  time_point & lhs,
    const  time_point & rhs
)

function operator>

inline bool ILLIXR::operator> (
    const  time_point & lhs,
    const  time_point & rhs
)

function operator>=

inline bool ILLIXR::operator>= (
    const  time_point & lhs,
    const  time_point & rhs
)

function p_dot

f(x) for the position Calculate the new position based on the initial velocity and change in velocity 

inline Eigen::Vector3d ILLIXR::p_dot (
    const Eigen::Vector3d & iv,
    const Eigen::Vector3d & k_n
)

Parameters:

  • iv The initial velocity as a vector
  • k_n The change in velocity as a vector

Returns:

The updated position

function predict_mean_rk4

state_plus ILLIXR::predict_mean_rk4 (
    double dt,
    const  state_plus & sp,
    const Eigen::Vector3d & ang_vel,
    const Eigen::Vector3d & linear_acc,
    const Eigen::Vector3d & ang_vel2,
    const Eigen::Vector3d & linear_acc2
)

Calculate the updated state (orientation, position, and velocity) based on the initial and final velocities and accelerations

Parameters:

  • dt The time between initial and final states (time step)
  • sp The initial state
  • ang_vel The initial angular velocity
  • linear_acc The initial linear acceleration
  • ang_vel2 The final angular velocity
  • linear_acc2 The final angular acceleration

Returns:

The final state

function q_dot

inline data_format::proper_quaterniond ILLIXR::q_dot (
    const Eigen::Vector3d & av,
    const  data_format::proper_quaterniond & dq
)

f(x) for the orientation quaternion

Parameters:

  • av Vector representing the angular velocity
  • dq The current orientation represented by a quaternion

Returns:

The updated quaternion as a new instance

function register_bindings

inline void ILLIXR::register_bindings (
    pybind11::module_ & m
)

function report_and_clear_errno

Support function to report errno values when debugging (NDEBUG). 

inline void ILLIXR::report_and_clear_errno (
    const std::string & file,
    const  int & line,
    const std::string & function,
    const std::string & msg=""
)

If errno is set, this function will report errno's value and the calling context. It will subsequently clear errno (reset value to 0). Otherwise, this function does nothing.

function run

MY_EXPORT_API  int ILLIXR::run (
    const  cxxopts::ParseResult & options
)

function runtime_factory

MY_EXPORT_API  runtime * ILLIXR::runtime_factory ()

function solve

Solve for the Runge-Kutta 4th order approximation. 

template<typename T>
inline T ILLIXR::solve (
    const  T & yn,
    const  T & k1,
    const  T & k2,
    const  T & k3,
    const  T & k4
)

Template parameters:

  • T The data type

Parameters:

  • yn The value at the last time step
  • k1 Runge-Kutta first order
  • k2 Runge-Kutta second order
  • k3 Runge-Kutta third order
  • k4 Runge-Kutta fourth order

Returns:

The approximated value

function split

Splits a string into tokens by a delimiter character. 

inline std::vector< std::string > ILLIXR::split (
    const std::string & s,
    char delimiter
)

Parameters:

  • s The string to split.
  • delimiter The character to split on.

Returns:

A vector of token strings.

function str_to_bool

Convert a string containing a (python) boolean to the bool type. 

inline bool ILLIXR::str_to_bool (
    const std::string & var
)

function symmetric_skew

Generates a skew-symmetric matrix from the given 3-element vector. 

inline Eigen::Matrix3d ILLIXR::symmetric_skew (
    const Eigen::Vector3d & vec
)

Gravitational acceleration, at sea level, on Earth

Based on equation 6 from http://mars.cs.umn.edu/tr/reports/Trawny05b.pdf

function track_time

void ILLIXR::track_time (
    const std::string & message,
    const std::function< void ()> & func
)

function v_dot

f(x) for the velocity Calculate the updated velocity from the acceleration and initial and delta quaternions 

inline Eigen::Vector3d ILLIXR::v_dot (
    const  data_format::proper_quaterniond & dq,
    const  data_format::proper_quaterniond & q,
    const Eigen::Vector3d & l_acc
)

Parameters:

  • dq The delta quaternion (change)
  • q The initial quaternion
  • l_acc The acceleration as a vector

Returns:

The calculated velocity as a vector

Public Static Functions Documentation

function entry_to_numpy

static pybind11::array_t< uint8_t > ILLIXR::entry_to_numpy (
    const  decode::decoded_frame_cache::Entry * entry
)

function intrinsics_to_numpy

static pybind11::array_t< float > ILLIXR::intrinsics_to_numpy (
    const  data_format::camera_intrinsics & intr
)

function to_numpy_4x4_safe

static pybind11::array_t< float > ILLIXR::to_numpy_4x4_safe (
    std::shared_ptr< const  data_format::semantic_frame > owner,
    const  float * data
)

function to_numpy_flat_safe

static pybind11::array_t< uint8_t > ILLIXR::to_numpy_flat_safe (
    std::shared_ptr< const  data_format::semantic_frame > owner,
    const  uint8_t * data,
    size_t size
)

The documentation for this class was generated from the following file /home/friedel/devel/ILLIXR/illixr_release/ILLIXR/include/illixr/dynamic_lib.hpp