Skip to content

Namespace ILLIXR::data_format

Namespace List > ILLIXR > data_format

Namespaces

Type Name
namespace camera
namespace coordinates
namespace ht
namespace image
namespace units

Classes

Type Name
struct binocular_cam_type
struct cam_base_type
struct cam_type_zed
struct camera_data
Data structure to hold information about the full camera system. This information is mostly constant.
struct ccd_data
A data structure to hold relevant camera information. This information is constant (per camera)
struct compressed_frame
struct connection_signal
struct depth_type
struct fast_pose_type
struct hmd_physical_info
struct hologram_input
struct image_handle
struct imu_integrator_input
struct imu_params
struct imu_raw_type
struct imu_type
struct monocular_cam_type
struct point
struct point_with_units
struct point_with_validity
struct points_with_units
struct pose_data
class pose_prediction
struct pose_type
class proper_quaternion <typename Scalar_, Options_>
A more complete implementation of the Eigen::Quaternion.
struct raw_point
struct raw_pose
struct rect
struct rendered_frame
struct rgb_depth_type
struct signal_to_quad
struct texture_pose
struct vk_image_handle

Public Types

Type Name
typedef std::map< units::eyes, ccd_data > ccd_map
mapping of ccd information to the eye it is associated with, for monocular cameras use units::LEFT_EYE __
enum graphics_api
typedef std::map< units::eyes, pose_type > multi_pose_map
typedef proper_quaternion< double > proper_quaterniond
typedef proper_quaternion< float > proper_quaternionf
enum swapchain_usage
typedef struct ILLIXR::data_format::vk_image_handle vk_image_handle

Public Functions

Type Name
point abs (const point & pnt)
point_with_validity abs (const point_with_validity & pnt)
point_with_units abs (const point_with_units & pnt)
bool compare (const std::string & input, const std::string & val)
void denormalize (T & obj, const float width, const float height, const float depth, units::measurement_unit unit_=units::PIXEL)
void denormalize (T & obj, const float width, const float height, units::measurement_unit unit_=units::PIXEL)
void denormalize< ht::hand_points > (ht::hand_points & obj, const float width, const float height, const float depth, units::measurement_unit unit_)
void denormalize< ht::ht_detection > (ht::ht_detection & obj, const float width, const float height, const float depth, units::measurement_unit unit)
void denormalize< ht::ht_frame > (ht::ht_frame & obj, const float width, const float height, const float depth, units::measurement_unit unit)
void denormalize< ht::velocity > (ht::velocity & obj, const float width, const float height, const float depth, units::measurement_unit unit_)
void denormalize< points_with_units > (points_with_units & obj, const float width, const float height, const float depth, units::measurement_unit unit_)
void denormalize< rect > (rect & obj, const float width, const float height, const float depth, units::measurement_unit unit)
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< ht::hand_points > (ht::hand_points & obj, const float width, const float height, const float depth)
void normalize< ht::ht_detection > (ht::ht_detection & obj, const float width, const float height, const float depth)
void normalize< ht::ht_frame > (ht::ht_frame & obj, const float width, const float height, const float depth)
void normalize< ht::velocity > (ht::velocity & obj, const float width, const float height, const float depth)
void normalize< points_with_units > (points_with_units & obj, const float width, const float height, const float depth)
void normalize< rect > (rect & obj, const float width, const float height, const float depth)
proper_quaternion< Scalar_ > operator* (Scalar_ x, const proper_quaternion< Scalar_ > & pq)
Multiplication of scalar and ProperQuaternion.
proper_quaternion< Scalar_ > operator/ (const proper_quaternion< Scalar_ > & pq, Scalar_ x)
Division of a ProperQuaternion by a scalar.
std::ostream & operator<< (std::ostream & os, const proper_quaternion< T > & pq)

Public Types Documentation

typedef ccd_map

mapping of ccd information to the eye it is associated with, for monocular cameras use units::LEFT_EYE __ 

typedef std::map<units::eyes, ccd_data> ILLIXR::data_format::ccd_map;

enum graphics_api

enum ILLIXR::data_format::graphics_api {
    OPENGL,
    VULKAN,
    TBD
};

typedef multi_pose_map

typedef std::map<units::eyes, pose_type> ILLIXR::data_format::multi_pose_map;

typedef proper_quaterniond

typedef proper_quaternion<double> ILLIXR::data_format::proper_quaterniond;

typedef proper_quaternionf

typedef proper_quaternion<float> ILLIXR::data_format::proper_quaternionf;

enum swapchain_usage

enum ILLIXR::data_format::swapchain_usage {
    LEFT_SWAPCHAIN,
    RIGHT_SWAPCHAIN,
    LEFT_RENDER,
    RIGHT_RENDER,
    NA
};

typedef vk_image_handle

typedef struct ILLIXR::data_format::vk_image_handle ILLIXR::data_format::vk_image_handle;

Public Functions Documentation

function abs

inline point ILLIXR::data_format::abs (
    const point & pnt
)

function abs

inline point_with_validity ILLIXR::data_format::abs (
    const point_with_validity & pnt
)

function abs

inline point_with_units ILLIXR::data_format::abs (
    const point_with_units & pnt
)

Determine the absolute value of a point (done on each coordinate)

Parameters:

  • value The point to take the absolute value of

Returns:

A point containing the result

function compare

inline bool ILLIXR::data_format::compare (
    const std::string & input,
    const std::string & val
)

function denormalize

template<typename T>
inline void ILLIXR::data_format::denormalize (
    T & obj,
    const float width,
    const float height,
    const float depth,
    units::measurement_unit unit_=units::PIXEL
)

function denormalize

template<typename T>
inline void ILLIXR::data_format::denormalize (
    T & obj,
    const float width,
    const float height,
    units::measurement_unit unit_=units::PIXEL
)

function denormalize< ht::hand_points >

template<>
inline void ILLIXR::data_format::denormalize< ht::hand_points > (
    ht::hand_points & obj,
    const float width,
    const float height,
    const float depth,
    units::measurement_unit unit_
)

function denormalize< ht::ht_detection >

template<>
inline void ILLIXR::data_format::denormalize< ht::ht_detection > (
    ht::ht_detection & obj,
    const float width,
    const float height,
    const float depth,
    units::measurement_unit unit
)

function denormalize< ht::ht_frame >

template<>
inline void ILLIXR::data_format::denormalize< ht::ht_frame > (
    ht::ht_frame & obj,
    const float width,
    const float height,
    const float depth,
    units::measurement_unit unit
)

function denormalize< ht::velocity >

template<>
inline void ILLIXR::data_format::denormalize< ht::velocity > (
    ht::velocity & obj,
    const float width,
    const float height,
    const float depth,
    units::measurement_unit unit_
)

function denormalize< points_with_units >

template<>
inline void ILLIXR::data_format::denormalize< points_with_units > (
    points_with_units & obj,
    const float width,
    const float height,
    const float depth,
    units::measurement_unit unit_
)

De-normalize a set of points to coordinates within the given bounds

Parameters:

  • obj the points to de-normalize
  • width the x bound
  • height the y bound
  • depth the z bound
  • unit_ the units for the points

function denormalize< rect >

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

function normalize

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

function normalize

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

function normalize< ht::hand_points >

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

function normalize< ht::ht_detection >

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

function normalize< ht::ht_frame >

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

function normalize< ht::velocity >

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

function normalize< points_with_units >

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

Normalize a set of points based on the given bounds (all values will be 0. - 1.)

Parameters:

  • obj The points to be normalized
  • width The x bound
  • height The y bound
  • depth The z bound

function normalize< rect >

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

function operator*

Multiplication of scalar and ProperQuaternion. 

template<typename Scalar_>
inline proper_quaternion < Scalar_ > ILLIXR::data_format::operator* (
    Scalar_ x,
    const proper_quaternion < Scalar_ > & pq
)

Template parameters:

  • Scalar_

Parameters:

  • x The value to multiply the quaternion by
  • pq The quaternion to multiply

Returns:

The ProperQuaternion containing the result

function operator/

Division of a ProperQuaternion by a scalar. 

template<typename Scalar_>
inline proper_quaternion < Scalar_ > ILLIXR::data_format::operator/ (
    const proper_quaternion < Scalar_ > & pq,
    Scalar_ x
)

Template parameters:

  • Scalar_

Parameters:

  • pq The quaternion to divide
  • x The value to divide the Quaternion by

Returns:

The ProperQuaternion containing the result

function operator<<

template<typename T>
std::ostream & ILLIXR::data_format::operator<< (
    std::ostream & os,
    const proper_quaternion < T > & pq
)

Template parameters:

  • T

Parameters:

  • os
  • pq

Returns:

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