Signal.h File Reference

#include <algorithm>
#include <limits>
#include <Eigen/Core>
#include <SO2.h>
#include <SO3.h>
#include <SE2.h>
#include <SE3.h>
#include "Utils.h"

Go to the source code of this file.

Classes
class	Signal< T, BaseSignalSpec, TangentSignalSpec >
	Template class for time-series signals with interpolation, extrapolation, and derivative capabilities. More...
struct	Signal< T, BaseSignalSpec, TangentSignalSpec >::SignalDP
	Data point structure storing time, value, and derivative. More...
struct	ScalarSignalSpec< T >
	Type specification for scalar-valued signals. More...
struct	VectorSignalSpec< T, d >
	Type specification for vector-valued signals. More...
struct	ManifoldSignalSpec< T, ManifoldType >
	Type specification for manifold-valued signals (e.g., SO2, SO3, SE2, SE3). More...

Macros
#define	MAKE_VECTOR_SIGNAL(Dimension)
#define	MAKE_MANIF_SIGNAL(Manif, Dimension)

Typedefs
template<typename T>
using	ScalarSignal = Signal<T, ScalarSignalSpec<T>, ScalarSignalSpec<T>>
template<typename T, size_t d>
using	VectorSignal = Signal<T, VectorSignalSpec<T, d>, VectorSignalSpec<T, d>>
template<typename T, typename ManifoldType, size_t d>
using	ManifoldSignal = Signal<T, ManifoldSignalSpec<T, ManifoldType>, VectorSignalSpec<T, d>>
typedef ScalarSignal< double >	ScalardSignal
template<typename T>
using	Vector1Signal = VectorSignal<T, 1>
typedef Vector1Signal< double >	Vector1dSignal
template<typename T>
using	Vector2Signal = VectorSignal<T, 2>
typedef Vector2Signal< double >	Vector2dSignal
template<typename T>
using	Vector3Signal = VectorSignal<T, 3>
typedef Vector3Signal< double >	Vector3dSignal
template<typename T>
using	Vector4Signal = VectorSignal<T, 4>
typedef Vector4Signal< double >	Vector4dSignal
template<typename T>
using	Vector5Signal = VectorSignal<T, 5>
typedef Vector5Signal< double >	Vector5dSignal
template<typename T>
using	Vector6Signal = VectorSignal<T, 6>
typedef Vector6Signal< double >	Vector6dSignal
template<typename T>
using	Vector7Signal = VectorSignal<T, 7>
typedef Vector7Signal< double >	Vector7dSignal
template<typename T>
using	Vector8Signal = VectorSignal<T, 8>
typedef Vector8Signal< double >	Vector8dSignal
template<typename T>
using	Vector9Signal = VectorSignal<T, 9>
typedef Vector9Signal< double >	Vector9dSignal
template<typename T>
using	Vector10Signal = VectorSignal<T, 10>
typedef Vector10Signal< double >	Vector10dSignal
template<typename T>
using	SO2Signal = ManifoldSignal<T, SO2<T>, 1>
typedef SO2Signal< double >	SO2dSignal
template<typename T>
using	SO3Signal = ManifoldSignal<T, SO3<T>, 3>
typedef SO3Signal< double >	SO3dSignal
template<typename T>
using	SE2Signal = ManifoldSignal<T, SE2<T>, 3>
typedef SE2Signal< double >	SE2dSignal
template<typename T>
using	SE3Signal = ManifoldSignal<T, SE3<T>, 6>
typedef SE3Signal< double >	SE3dSignal

Enumerations
enum	InterpolationMethod { ZERO_ORDER_HOLD , LINEAR , CUBIC_SPLINE }
	Methods for interpolating signal values between discrete time points. More...
enum	ExtrapolationMethod { NANS , ZEROS , CLOSEST }
	Methods for extrapolating signal values outside the defined time range. More...
enum	DerivativeMethod { DIRTY , FINITE_DIFF }
	Methods for computing numerical derivatives of signals. More...

Functions
template<typename T, typename BaseSignalSpec, typename TangentSignalSpec>
Signal< T, BaseSignalSpec, TangentSignalSpec >	operator+ (const Signal< T, BaseSignalSpec, TangentSignalSpec > &l, const Signal< T, TangentSignalSpec, TangentSignalSpec > &r)
	Add a tangent signal to a base signal.
template<typename T, typename BaseSignalSpec, typename TangentSignalSpec>
Signal< T, TangentSignalSpec, TangentSignalSpec >	operator- (const Signal< T, BaseSignalSpec, TangentSignalSpec > &l, const Signal< T, BaseSignalSpec, TangentSignalSpec > &r)
	Subtract one signal from another, producing a tangent signal.
template<typename T, typename BaseSignalSpec, typename TangentSignalSpec>
Signal< T, BaseSignalSpec, TangentSignalSpec >	operator* (const double &l, const Signal< T, BaseSignalSpec, TangentSignalSpec > &r)
	Multiply a signal by a scalar from the left.
template<typename T, typename BaseSignalSpec, typename TangentSignalSpec>
Signal< T, BaseSignalSpec, TangentSignalSpec >	operator* (const Signal< T, BaseSignalSpec, TangentSignalSpec > &l, const double &r)
	Multiply a signal by a scalar from the right.
template<typename T>
std::ostream &	operator<< (std::ostream &os, const ScalarSignal< T > &x)
template<typename T, size_t d>
std::ostream &	operator<< (std::ostream &os, const VectorSignal< T, d > &x)
template<typename T, typename ManifoldType, size_t d>
std::ostream &	operator<< (std::ostream &os, const ManifoldSignal< T, ManifoldType, d > &x)

Macro Definition Documentation

MAKE_MANIF_SIGNAL

#define MAKE_MANIF_SIGNAL	(		Manif,
			Dimension )

Value:

    template<typename T>                                                                                               \
    using Manif##Signal = ManifoldSignal<T, Manif<T>, Dimension>;                                                      \
    typedef Manif##Signal<double> Manif##dSignal;

MAKE_VECTOR_SIGNAL

#define MAKE_VECTOR_SIGNAL

(

Dimension

)

Value:

    template<typename T>                                                                                               \
    using Vector##Dimension##Signal = VectorSignal<T, Dimension>;                                                      \
    typedef Vector##Dimension##Signal<double> Vector##Dimension##dSignal;

Typedef Documentation

ManifoldSignal

template<typename T, typename ManifoldType, size_t d>

using ManifoldSignal = Signal<T, ManifoldSignalSpec<T, ManifoldType>, VectorSignalSpec<T, d>>

ScalardSignal

typedef ScalarSignal<double> ScalardSignal

ScalarSignal

template<typename T>

using ScalarSignal = Signal<T, ScalarSignalSpec<T>, ScalarSignalSpec<T>>

SE2dSignal

typedef SE2Signal<double> SE2dSignal

SE2Signal

template<typename T>

using SE2Signal = ManifoldSignal<T, SE2<T>, 3>

SE3dSignal

typedef SE3Signal<double> SE3dSignal

SE3Signal

template<typename T>

using SE3Signal = ManifoldSignal<T, SE3<T>, 6>

SO2dSignal

typedef SO2Signal<double> SO2dSignal

SO2Signal

template<typename T>

using SO2Signal = ManifoldSignal<T, SO2<T>, 1>

SO3dSignal

typedef SO3Signal<double> SO3dSignal

SO3Signal

template<typename T>

using SO3Signal = ManifoldSignal<T, SO3<T>, 3>

Vector10dSignal

typedef Vector10Signal<double> Vector10dSignal

Vector10Signal

template<typename T>

using Vector10Signal = VectorSignal<T, 10>

Vector1dSignal

typedef Vector1Signal<double> Vector1dSignal

Vector1Signal

template<typename T>

using Vector1Signal = VectorSignal<T, 1>

Vector2dSignal

typedef Vector2Signal<double> Vector2dSignal

Vector2Signal

template<typename T>

using Vector2Signal = VectorSignal<T, 2>

Vector3dSignal

typedef Vector3Signal<double> Vector3dSignal

Vector3Signal

template<typename T>

using Vector3Signal = VectorSignal<T, 3>

Vector4dSignal

typedef Vector4Signal<double> Vector4dSignal

Vector4Signal

template<typename T>

using Vector4Signal = VectorSignal<T, 4>

Vector5dSignal

typedef Vector5Signal<double> Vector5dSignal

Vector5Signal

template<typename T>

using Vector5Signal = VectorSignal<T, 5>

Vector6dSignal

typedef Vector6Signal<double> Vector6dSignal

Vector6Signal

template<typename T>

using Vector6Signal = VectorSignal<T, 6>

Vector7dSignal

typedef Vector7Signal<double> Vector7dSignal

Vector7Signal

template<typename T>

using Vector7Signal = VectorSignal<T, 7>

Vector8dSignal

typedef Vector8Signal<double> Vector8dSignal

Vector8Signal

template<typename T>

using Vector8Signal = VectorSignal<T, 8>

Vector9dSignal

typedef Vector9Signal<double> Vector9dSignal

Vector9Signal

template<typename T>

using Vector9Signal = VectorSignal<T, 9>

VectorSignal

template<typename T, size_t d>

using VectorSignal = Signal<T, VectorSignalSpec<T, d>, VectorSignalSpec<T, d>>

Enumeration Type Documentation

DerivativeMethod

enum DerivativeMethod

Methods for computing numerical derivatives of signals.

Enumerator
DIRTY	Use a discrete-time dirty derivative filter for smoothing.
FINITE_DIFF	Use simple finite difference approximation.

ExtrapolationMethod

enum ExtrapolationMethod

Methods for extrapolating signal values outside the defined time range.

Enumerator
NANS	Return NaN (Not a Number) values outside the defined range.
ZEROS	Return zero values outside the defined range.
CLOSEST	Return the closest boundary value (first or last data point).

InterpolationMethod

enum InterpolationMethod

Methods for interpolating signal values between discrete time points.

Enumerator
ZERO_ORDER_HOLD	Hold the previous value constant until the next data point.
LINEAR	Linearly interpolate between adjacent data points.
CUBIC_SPLINE	Use cubic spline interpolation for smooth transitions.

Function Documentation

operator*() [1/2]

template<typename T, typename BaseSignalSpec, typename TangentSignalSpec>

Signal< T, BaseSignalSpec, TangentSignalSpec > operator*	(	const double &	l,
		const Signal< T, BaseSignalSpec, TangentSignalSpec > &	r )

Multiply a signal by a scalar from the left.

Parameters

l	The scalar multiplier.
r	The signal to multiply.

Returns

A new signal with all values and derivatives scaled by l.

operator*() [2/2]

template<typename T, typename BaseSignalSpec, typename TangentSignalSpec>

Signal< T, BaseSignalSpec, TangentSignalSpec > operator*	(	const Signal< T, BaseSignalSpec, TangentSignalSpec > &	l,
		const double &	r )

Multiply a signal by a scalar from the right.

Parameters

l	The signal to multiply.
r	The scalar multiplier.

Returns

A new signal with all values and derivatives scaled by r.

operator+()

template<typename T, typename BaseSignalSpec, typename TangentSignalSpec>

Signal< T, BaseSignalSpec, TangentSignalSpec > operator+	(	const Signal< T, BaseSignalSpec, TangentSignalSpec > &	l,
		const Signal< T, TangentSignalSpec, TangentSignalSpec > &	r )

Add a tangent signal to a base signal.

Parameters

l	The left-hand side signal (base type).
r	The right-hand side signal (tangent type) to add.

Returns

A new signal with r added to l's values and derivatives.

operator-()

template<typename T, typename BaseSignalSpec, typename TangentSignalSpec>

Signal< T, TangentSignalSpec, TangentSignalSpec > operator-	(	const Signal< T, BaseSignalSpec, TangentSignalSpec > &	l,
		const Signal< T, BaseSignalSpec, TangentSignalSpec > &	r )

Subtract one signal from another, producing a tangent signal.

Parameters

l	The left-hand side signal.
r	The right-hand side signal to subtract.

Returns

A new tangent signal representing the difference l - r.

operator<<() [1/3]

template<typename T, typename ManifoldType, size_t d>

std::ostream & operator<< ( std::ostream & os, const ManifoldSignal< T, ManifoldType, d > & x )

inline

operator<<() [2/3]

template<typename T>

std::ostream & operator<< ( std::ostream & os, const ScalarSignal< T > & x )

inline

operator<<() [3/3]

template<typename T, size_t d>

std::ostream & operator<< ( std::ostream & os, const VectorSignal< T, d > & x )

inline