C++ API and example¶

1. Introduction¶

This page exist in order to extract the examples from the Doxygen documentation, Please have look at the end of this page there are all the examples.

2. C++ API and example¶

struct _SubjectData_v3

#include <types.hpp>

Public Functions

template<class Archive> inline void serialize(Archive &archive)

template<class Archive> inline void serialize(Archive &archive)

Public Members

bool is_visible

std::array<double, 3> global_translation

std::array<double, 4> global_rotation_quaternion

double quality

class BadResultError : public runtime_error

#include <errors.hpp>

Indicates that a Vicon SDK function returned a bad result.

The actual result is provided in the exception’s message.

Public Functions

inline BadResultError(ViconDataStreamSDK::CPP::Result::Enum result)

inline BadResultError(ViconDataStreamSDK::CPP::Result::Enum result)

template<size_t NUM_SUBJECTS> struct FixedSizeViconFrame

#include <types.hpp>

This is an alternative to ViconFrame with a fixed number of subjects.

For some applications like o80 the data structure needs to be of fixed size. This is not the case in ViconFrame due to the use of std::map for the subjects. FixedSizeViconFrame can be used as an (less flexible) alternative for these applications.

Note that here, the names of the subjects are not stored, so one needs to keep track of the order of subjects in a different way (e.g. by having a fixed mapping from subject name to index).

Public Functions

template<class Archive> inline void serialize(Archive &archive)

template<class Archive> inline void serialize(Archive &archive)

Public Members

int frame_number = 0: Frame sequence number.

double frame_rate = 0.0: Frame rate of the Vicon system.

double latency = 0.0: Latency of the frame.

int64_t time_stamp = 0: Time stamp when the frame was acquired.

std::array<SubjectData, NUM_SUBJECTS> subjects

List of subjects.

Note that this list always contains entries for all registered subjects, even if they are not visible in the current frame. Therefore, always check the is_visible field of the subject before using its pose.

Public Static Attributes

static constexpr size_t max_num_subjects = NUM_SUBJECTS

Friends

template<size_t N> friend std::ostream &operator<<(std::ostream &os, const FixedSizeViconFrame<N> &vf)

template<size_t N> friend std::ostream &operator<<(std::ostream &os, const FixedSizeViconFrame<N> &vf)

template<> struct formatter<ViconDataStreamSDK::CPP::Direction::Enum> : public formatter<string_view>

#include <fmt.hpp>

Public Functions

template<typename FormatContext> inline auto format(const ViconDataStreamSDK::CPP::Direction::Enum &dir, FormatContext &ctx)

template<typename FormatContext> inline auto format(const ViconDataStreamSDK::CPP::Direction::Enum &dir, FormatContext &ctx)

template<> struct formatter<ViconDataStreamSDK::CPP::Output_GetVersion> : public formatter<string_view>

#include <fmt.hpp>

Public Functions

template<typename FormatContext> inline auto format(const ViconDataStreamSDK::CPP::Output_GetVersion &version, FormatContext &ctx)

template<typename FormatContext> inline auto format(const ViconDataStreamSDK::CPP::Output_GetVersion &version, FormatContext &ctx)

template<> struct formatter<ViconDataStreamSDK::CPP::Result::Enum> : public formatter<string_view>

#include <fmt.hpp>

Public Functions

template<typename FormatContext> inline auto format(const ViconDataStreamSDK::CPP::Result::Enum &result, FormatContext &ctx)

template<typename FormatContext> inline auto format(const ViconDataStreamSDK::CPP::Result::Enum &result, FormatContext &ctx)

class JsonReceiver : public vicon_transformer::Receiver

#include <vicon_receiver.hpp>

Load a single frame from a JSON file and return it on every read() call.

Meant for testing.

Public Functions

JsonReceiver(const std::filesystem::path &filename)

virtual ViconFrame read() override: Return the frame that was loaded from the file.

JsonReceiver(const std::filesystem::path &filename)

virtual ViconFrame read() override: Return the frame that was loaded from the file.

Private Members

ViconFrame frame_¶

class None: #include <o80_driver.hpp>

class NotConnectedError : public runtime_error

#include <errors.hpp>

Indicates that the client is not connected to a Vicon server.

Public Functions

inline NotConnectedError()

inline NotConnectedError()

template<size_t NUM_SUBJECTS, size_t (*map_name_to_index)(const std::string&)> class o80Driver : public o80::Driver<None, FixedSizeViconFrame<NUM_SUBJECTS>>

#include <o80_driver.hpp>

Generic o80 driver to provide Vicon data.

Since the shared memory used by o80 requires observations to be of fixed size, the number of subjects observed by Vicon needs to be provided at compile time via the template argument.

Likewise the subject names are not stored in the observation. Instead the subject data is provided in an array with an order which is defined by the map_name_to_index function. The client code on the other end will likewise need to have access to this mapping to know which subject is listed at which position.

map_name_to_index is expected to throw an UnknownSubjectError if an unexpected name is passed to it. In this case, the driver will ignore that subject.

Subjects for which no information is provided by Vicon will have the is_visible field set to false.

The driver uses ViconTransformer with the given receiver to acquire the Vicon frames and provide poses relative to the specified origin subject.

Template Parameters:

NUM_SUBJECTS – Number of subjects.
map_name_to_index – Function that maps a subject name to an index in the subject array. The indices must be less than NUM_SUBJECTS - 1.

Public Functions

inline o80Driver(std::shared_ptr<vicon_transformer::Receiver> receiver, const std::string &origin_subject_name, std::shared_ptr<spdlog::logger> logger = nullptr)

Parameters:

receiver – Initialised receiver instance which provides Vicon frames
origin_subject_name – Name of the origin subject. Has to be one of the subjects that is tracked by Vicon. Poses of all subjects will be given relative to the origin subject.
logger – A logger instance used for logging output.

inline void start() override

inline void stop() override

inline void set(const None&) override

inline FixedSizeViconFrame<NUM_SUBJECTS> get() override

inline o80Driver(std::shared_ptr<vicon_transformer::Receiver> receiver, const std::string &origin_subject_name, std::shared_ptr<spdlog::logger> logger = nullptr)

Parameters:

receiver – Initialised receiver instance which provides Vicon frames
origin_subject_name – Name of the origin subject. Has to be one of the subjects that is tracked by Vicon. Poses of all subjects will be given relative to the origin subject.
logger – A logger instance used for logging output.

inline void start() override

inline void stop() override

inline void set(const None&) override

inline FixedSizeViconFrame<NUM_SUBJECTS> get() override

Private Members

ViconTransformer vicon_transformer_¶

std::shared_ptr<spdlog::logger> log_¶

template<typename Driver> class o80Standalone : public o80::Standalone<STANDALONE_QUEUE_SIZE, STANDALONE_N_ACTUATORS, Driver, o80::VoidState, Driver::DRIVER_OUT>

#include <o80_standalone.hpp>

o80 standalone over the o80Driver.

The Vicon system is a passive sensor without actuation, so the number of actuators is zero and o80::VoidState is used for the states (i.e. one cannot send commands to the system). All data provided by Vicon is written to the extended state.

Template Parameters:: Driver – An actual implementation of o80Driver.

Public Functions

inline o80::States<STANDALONE_N_ACTUATORS, o80::VoidState> convert(const typename Driver::DRIVER_OUT&) override

inline None convert(const o80::States<STANDALONE_N_ACTUATORS, o80::VoidState>&) override

inline void enrich_extended_state(typename Driver::DRIVER_OUT &extended_state, const typename Driver::DRIVER_OUT &observation) override

inline o80::States<STANDALONE_N_ACTUATORS, o80::VoidState> convert(const typename Driver::DRIVER_OUT&) override

inline None convert(const o80::States<STANDALONE_N_ACTUATORS, o80::VoidState>&) override

inline void enrich_extended_state(typename Driver::DRIVER_OUT &extended_state, const typename Driver::DRIVER_OUT &observation) override

class PlaybackReceiver : public vicon_transformer::Receiver

#include <vicon_receiver.hpp>

Load frames from a recorded file and play it back.

To record frames from the live system, use the vicon_record executable.

Public Functions

PlaybackReceiver(const std::filesystem::path &filename, std::shared_ptr<spdlog::logger> logger = nullptr)

Parameters:

filename – Path to the recorded file.
logger – A logger instance used for logging output. If not set, a logger with name “ViconReceiver” used.

virtual ViconFrame read() override

Get next frame from the recorded file.

Throws:: std::out_of_range – if end of the recording is reached.
Returns:: Next frame from the recorded file.

PlaybackReceiver(const std::filesystem::path &filename, std::shared_ptr<spdlog::logger> logger = nullptr)

Parameters:

filename – Path to the recorded file.
logger – A logger instance used for logging output. If not set, a logger with name “ViconReceiver” used.

virtual ViconFrame read() override

Get next frame from the recorded file.

Throws:: std::out_of_range – if end of the recording is reached.
Returns:: Next frame from the recorded file.

Private Members

std::shared_ptr<spdlog::logger> log_¶

std::vector<ViconFrame> tape_¶

size_t tape_index_¶

class Receiver

#include <vicon_receiver.hpp>

Base class for ViconFrame receiver classes.

Subclassed by vicon_transformer::JsonReceiver, vicon_transformer::PlaybackReceiver, vicon_transformer::ViconReceiver

Public Functions

inline virtual ~Receiver()

virtual ViconFrame read() = 0

Get new frame.

Block if no new frame is available yet.

Returns:: The acquired frame.

inline virtual ~Receiver()

virtual ViconFrame read() = 0

Get new frame.

Block if no new frame is available yet.

Returns:: The acquired frame.

struct SubjectData

#include <types.hpp>

Information about a subject in a Vicon frame.

A “subject” corresponds to an object that is registered in the Vicon Tracker software.

Public Functions

template<class Archive> inline void serialize(Archive &archive)

template<class Archive> inline void serialize(Archive &archive)

Public Members

bool is_visible = false

Whether the subject is visible in the frame.

IMPORTANT: If this is false, the values of all other fields of this struct are undefined!

spatial_transformation::Transformation global_pose

Pose of the subject w.r.t.

the global origin.

This field is only set if is_visible is true.

double quality = 0.0: Quality measure of the pose estimation.

class SubjectNotVisibleError : public runtime_error

#include <errors.hpp>

The subject is not visible (and thus no transform data available).

The actual result is provided in the exception’s message.

Public Functions

inline SubjectNotVisibleError(const std::string &subject_name)

inline SubjectNotVisibleError(const std::string &subject_name)

class UnknownSubjectError : public runtime_error

#include <errors.hpp>

The requested subject does not exist.

The subject name is provided in the exception’s message.

Public Functions

inline UnknownSubjectError(const std::string &subject_name)

inline UnknownSubjectError(const std::string &subject_name)

struct ViconFrame

#include <types.hpp>

All data of a single Vicon frame.

Public Functions

template<class Archive> inline void serialize(Archive &archive)

template<class Archive> inline void serialize(Archive &archive)

Public Members

int frame_number = 0: Frame sequence number.

double frame_rate = 0.0: Frame rate of the Vicon system.

double latency = 0.0: Latency of the frame.

int64_t time_stamp = 0: Time stamp when the frame was acquired.

std::map<std::string, SubjectData> subjects

List of subjects.

Note that this list always contains entries for all registered subjects, even if they are not visible in the current frame. Therefore, always check the is_visible field of the subject before using its pose.

Friends

friend std::ostream &operator<<(std::ostream &os, const ViconFrame &vf)

friend std::ostream &operator<<(std::ostream &os, const ViconFrame &vf)

class ViconReceiver : public vicon_transformer::Receiver

#include <vicon_receiver.hpp>

Receive frames from a running Vicon system.

This assumes that a compatible Vicon software (e.g. Vicon Tracker) is set up and running on the specified host.

Public Functions

ViconReceiver(const std::string &host_name, const ViconReceiverConfig &config, std::shared_ptr<spdlog::logger> logger = nullptr)

Parameters:

host_name – Host name or IP address of the Vicon PC.
config – Receiver configuration.
logger – A logger instance used for logging output. If not set, a logger with name “ViconReceiver” used.

~ViconReceiver()

bool is_connected() const: Check if connected to a Vicon server.

void connect(): Connect to the Vicon server on the specified host.

void disconnect(): Disconnect from the Vicon server.

void print_info() const: Print some info about the server configuration.

virtual ViconFrame read() override: Get a new frame from the Vicon system.

void print_latency_info() const: Print detailed latency information.

ViconReceiver(const std::string &host_name, const ViconReceiverConfig &config, std::shared_ptr<spdlog::logger> logger = nullptr)

Parameters:

host_name – Host name or IP address of the Vicon PC.
config – Receiver configuration.
logger – A logger instance used for logging output. If not set, a logger with name “ViconReceiver” used.

~ViconReceiver()

bool is_connected() const: Check if connected to a Vicon server.

void connect(): Connect to the Vicon server on the specified host.

void disconnect(): Disconnect from the Vicon server.

void print_info() const: Print some info about the server configuration.

virtual ViconFrame read() override: Get a new frame from the Vicon system.

void print_latency_info() const: Print detailed latency information.

Private Functions

void client_get_frame()¶

void filter_subjects(const std::vector<std::string> &subjects)¶

Only receive data for the listed subjects.

If set, pose data is only provided for the listed subjects. Note that other subjects will still be included in the frame data but their pose will not be set and they will be marked as not visible. This can be used to reduce the required bandwidth, if only a few of the subjects are of interest.

Parameters:: subjects – List of subject names.

void client_get_frame()

void filter_subjects(const std::vector<std::string> &subjects)

Only receive data for the listed subjects.

If set, pose data is only provided for the listed subjects. Note that other subjects will still be included in the frame data but their pose will not be set and they will be marked as not visible. This can be used to reduce the required bandwidth, if only a few of the subjects are of interest.

Parameters:: subjects – List of subject names.

Private Members

std::shared_ptr<spdlog::logger> log_¶

ViconDataStreamSDK::CPP::Client client_¶

const std::string host_name_¶

const ViconReceiverConfig config_¶

struct ViconReceiverConfig

#include <vicon_receiver.hpp>

Configuration structure for the ViconReceiver class.

Public Functions

template<class Archive> inline void serialize(Archive &archive)

template<class Archive> inline void serialize(Archive &archive)

Public Members

bool enable_lightweight = false

Enable lightweight mode.

If enabled, the pose information of the subjects is provided with reduced precision, thus reducing the amount of data that needs to be transmitted. See the Vicon documentation for more information.

unsigned int buffer_size = 0

Buffer size used by the Vicon client.

If set to zero, no buffer is used, i.e. the client always provides the newest frame.

std::vector<std::string> filtered_subjects

Filter for the listed subjects to save bandwidth.

If set, pose information is only provided for the subjects whose name is included in the list. This can be used to reduce the required bandwidth of the connection to the Vicon server.

Note that other subjects are still listed in the frame data but marked as not visible.

If left empty, no filtering is done (i.e. all subjects are included in the frame data).

class ViconTransformer

#include <vicon_transformer.hpp>

Get data from a ViconReceiver and provide poses of subjects relative to an “origin subject”.

Vicon provides positions and orientations of subjects relative to an origin that is defined when calibrating the system. Unfortunately, it is not easy precisely specify this, so the actual origin can be in a not very well defined location and can vary over time if the system is recalibrated.

Instead, this class provides the option to specify a static object which doesn’t move over time (e.g. some markers attached to a wall) as “origin

subject” and provide poses of all other subjects relative to this origin subject. This makes the poses independent of the actual origin used by Vicon and will give repeatable results, even if the system is recalibrated in between (at least as long as the markers of the origin subject are not moved).

Public Functions

ViconTransformer(std::shared_ptr<Receiver> receiver, const std::string &origin_subject_name, std::shared_ptr<spdlog::logger> logger = nullptr)

Parameters:

origin_subject_name – Name of the subject that shall be used as origin.
logger – A logger instance used for logging output. If not set, a logger with name “ViconTransformer” used.

std::shared_ptr<Receiver> receiver(): Return a pointer to the receiver instance.

std::shared_ptr<const Receiver> receiver() const: Return a const pointer to the receiver instance.

void update(): Update transformations by getting a new frame from the receiver.

void set_frame(const ViconFrame &frame): Set the Vicon frame that is used by the transformer.

void wait_for_origin_subject_data()

Wait until the receiver provides a valid data for the origin subject.

Calls update() in a loop until a frame is provided in which the origin subject is visible. This is needed, even if the origin subject is always in the scene, because after connecting it takes a bit until the Vicon server provides proper data (in the first frames all subjects are marked as not visible).

If no origin subject has been specified (i.e. origin_subject_name is an empty string), this method returns immediately.

int64_t get_timestamp_ns() const: Get timestamp of the frame in nanoseconds.

std::vector<std::string> get_subject_names() const: Get list with the names of all registered subjects.

bool is_visible(const std::string &subject_name) const

Check if the specified subject is visible.

Parameters:: subject_name – Name of the subject.
Throws:: UnknownSubjectError – if there is no subject with the given name.
Returns:: True if it is visible in the current frame, false if not

Transformation get_transform(const std::string &subject_name) const

Get transformation of a subject relative to the origin subject.

Parameters:: subject_name – Name of the subject
Throws:: SubjectNotVisibleError – if the subject is not visible in the current frame.
Returns:: Transformation from the origin subject to the requested subject.

Transformation get_raw_transform(const std::string &subject_name) const

Get transformation of a subject relative to Vicons global origin.

Note

The Vicon origin can be at an arbitrary pose and can vary over time if the system is recalibrated. For more reliable results, specify a static object as “origin subject” and use get_transform instead of this method.

Parameters:: subject_name – Name of the subject
Throws:: SubjectNotVisibleError – if the subject is not visible in the current frame.
Returns:: Transformation from the Vicon origin to the requested subject.

ViconFrame get_frame() const: Get the whole frame data with all subject poses relative to the origin subject.

ViconTransformer(std::shared_ptr<Receiver> receiver, const std::string &origin_subject_name, std::shared_ptr<spdlog::logger> logger = nullptr)

Parameters:

origin_subject_name – Name of the subject that shall be used as origin.
logger – A logger instance used for logging output. If not set, a logger with name “ViconTransformer” used.

std::shared_ptr<Receiver> receiver(): Return a pointer to the receiver instance.

std::shared_ptr<const Receiver> receiver() const: Return a const pointer to the receiver instance.

void update(): Update transformations by getting a new frame from the receiver.

void set_frame(const ViconFrame &frame): Set the Vicon frame that is used by the transformer.

void wait_for_origin_subject_data()

Wait until the receiver provides a valid data for the origin subject.

Calls update() in a loop until a frame is provided in which the origin subject is visible. This is needed, even if the origin subject is always in the scene, because after connecting it takes a bit until the Vicon server provides proper data (in the first frames all subjects are marked as not visible).

If no origin subject has been specified (i.e. origin_subject_name is an empty string), this method returns immediately.

int64_t get_timestamp_ns() const: Get timestamp of the frame in nanoseconds.

std::vector<std::string> get_subject_names() const: Get list with the names of all registered subjects.

bool is_visible(const std::string &subject_name) const

Check if the specified subject is visible.

Parameters:: subject_name – Name of the subject.
Throws:: UnknownSubjectError – if there is no subject with the given name.
Returns:: True if it is visible in the current frame, false if not

Transformation get_transform(const std::string &subject_name) const

Get transformation of a subject relative to the origin subject.

Parameters:: subject_name – Name of the subject
Throws:: SubjectNotVisibleError – if the subject is not visible in the current frame.
Returns:: Transformation from the origin subject to the requested subject.

Transformation get_raw_transform(const std::string &subject_name) const

Get transformation of a subject relative to Vicons global origin.

Note

The Vicon origin can be at an arbitrary pose and can vary over time if the system is recalibrated. For more reliable results, specify a static object as “origin subject” and use get_transform instead of this method.

Parameters:: subject_name – Name of the subject
Throws:: SubjectNotVisibleError – if the subject is not visible in the current frame.
Returns:: Transformation from the Vicon origin to the requested subject.

ViconFrame get_frame() const: Get the whole frame data with all subject poses relative to the origin subject.

Protected Functions

const SubjectData &get_subject_data(const std::string &subject_name) const¶

const SubjectData &get_subject_data(const std::string &subject_name) const

Protected Attributes

std::shared_ptr<spdlog::logger> log_¶

std::shared_ptr<Receiver> receiver_¶

std::string origin_subject_name_¶

ViconFrame frame_¶

Transformation origin_tf_¶

namespace fmt

namespace vicon_transformer

Functions

template<size_t N> std::ostream &operator<<(std::ostream &os, const FixedSizeViconFrame<N> &vf)

Variables

constexpr int STANDALONE_QUEUE_SIZE = 50000

constexpr int STANDALONE_N_ACTUATORS = 0: Number of actuators (zero, as the Vicon system does not have actuation).

file CMakeCCompilerId.c

Defines

__has_include(x)

COMPILER_ID

STRINGIFY_HELPER(X)

STRINGIFY(X)

PLATFORM_ID

ARCHITECTURE_ID

DEC(n)

HEX(n)

C_VERSION

Functions

int main(int argc, char *argv[])

Variables

char const * info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]"

char const * info_platform = "INFO" ":" "platform[" PLATFORM_ID "]"

char const * info_arch = "INFO" ":" "arch[" ARCHITECTURE_ID "]"

const char * info_language_standard_default ="INFO" ":" "standard_default[" C_VERSION "]"

const char * info_language_extensions_default = "INFO" ":" "extensions_default[""OFF""]"

file CMakeCXXCompilerId.cpp

Defines

__has_include(x)

COMPILER_ID

STRINGIFY_HELPER(X)

STRINGIFY(X)

PLATFORM_ID

ARCHITECTURE_ID

DEC(n)

HEX(n)

CXX_STD

Functions

int main(int argc, char *argv[])

Variables

char const * info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]"

char const * info_platform = "INFO" ":" "platform[" PLATFORM_ID "]"

char const * info_arch = "INFO" ":" "arch[" ARCHITECTURE_ID "]"

const char * info_language_standard_default = "INFO" ":" "standard_default[""98""]"

const char * info_language_extensions_default = "INFO" ":" "extensions_default[""OFF""]"

file errors.hpp

#include <fmt/format.h>

#include <vicon-datastream-sdk/DataStreamClient.h>

#include “fmt.hpp”

Custom exceptions.

file errors.hpp

#include <fmt/format.h>

#include <vicon-datastream-sdk/DataStreamClient.h>

#include “fmt.hpp”

Custom exceptions.

file fmt.hpp

#include <fmt/format.h>

#include <vicon-datastream-sdk/DataStreamClient.h>

fmt::formatter implementations for various types.

file fmt.hpp

#include <fmt/format.h>

#include <vicon-datastream-sdk/DataStreamClient.h>

fmt::formatter implementations for various types.

file o80_driver.hpp

#include <map>

#include <memory>

#include <string>

#include <spdlog/sinks/stdout_color_sinks.h>

#include <spdlog/spdlog.h>

#include <o80/driver.hpp>

#include “vicon_transformer.hpp”

o80 driver for the Vicon system

file o80_driver.hpp

#include <map>

#include <memory>

#include <string>

#include <spdlog/sinks/stdout_color_sinks.h>

#include <spdlog/spdlog.h>

#include <o80/driver.hpp>

#include “vicon_transformer.hpp”

o80 driver for the Vicon system

file o80_standalone.hpp

#include <o80/standalone.hpp>

#include <o80/void_state.hpp>

#include “o80_driver.hpp”

#include “types.hpp”

o80 Standalone implementation for Vicon system.

file o80_standalone.hpp

#include <o80/standalone.hpp>

#include <o80/void_state.hpp>

#include “o80_driver.hpp”

#include “types.hpp”

o80 Standalone implementation for Vicon system.

file types.hpp

#include <array>

#include <map>

#include <fmt/ostream.h>

#include <cereal/cereal.hpp>

#include <cereal/types/array.hpp>

#include <cereal/types/map.hpp>

#include <cereal/types/string.hpp>

#include <spatial_transformation/transformation.hpp>

Data types used in the package.

file types.hpp

#include <array>

#include <map>

#include <fmt/ostream.h>

#include <cereal/cereal.hpp>

#include <cereal/types/array.hpp>

#include <cereal/types/map.hpp>

#include <cereal/types/string.hpp>

#include <spatial_transformation/transformation.hpp>

Data types used in the package.

file vicon_receiver.hpp

#include <filesystem>

#include <spdlog/logger.h>

#include <vicon-datastream-sdk/DataStreamClient.h>

#include <cereal/cereal.hpp>

#include <cereal/types/string.hpp>

#include <cereal/types/vector.hpp>

#include “types.hpp”

file vicon_receiver.hpp

#include <filesystem>

#include <spdlog/logger.h>

#include <vicon-datastream-sdk/DataStreamClient.h>

#include <cereal/cereal.hpp>

#include <cereal/types/string.hpp>

#include <cereal/types/vector.hpp>

#include “types.hpp”

file vicon_transformer.hpp

#include <memory>

#include <string>

#include <vector>

#include <spdlog/logger.h>

#include <spdlog/sinks/stdout_color_sinks.h>

#include <spatial_transformation/transformation.hpp>

#include “vicon_receiver.hpp”

file vicon_transformer.hpp

#include <memory>

#include <string>

#include <vector>

#include <spdlog/logger.h>

#include <spdlog/sinks/stdout_color_sinks.h>

#include <spatial_transformation/transformation.hpp>

#include “vicon_receiver.hpp”

file bindings.cpp

#include <sstream>

#include <pybind11/eigen.h>

#include <pybind11/operators.h>

#include <pybind11/pybind11.h>

#include <pybind11/stl.h>

#include <pybind11/stl/filesystem.h>

#include <serialization_utils/cereal_json.hpp>

#include <vicon_transformer/errors.hpp>

#include <vicon_transformer/types.hpp>

#include <vicon_transformer/vicon_receiver.hpp>

#include <vicon_transformer/vicon_transformer.hpp>

Functions

PYBIND11_MODULE(vicon_transformer_bindings, m)

dir build/vicon_transformer/CMakeFiles/3.26.4

dir build

dir build/vicon_transformer/CMakeFiles

dir build/vicon_transformer/CMakeFiles/3.26.4/CompilerIdC

dir build/vicon_transformer/CMakeFiles/3.26.4/CompilerIdCXX

dir install/vicon_transformer/include

dir include

dir install

dir srcpy

dir install/vicon_transformer

dir build/vicon_transformer

dir include/vicon_transformer

dir install/vicon_transformer/include/vicon_transformer