The Ocean Math Library provides basic numerical and algebraic functionalities. More...

Data Structures
class	Ocean::AnyCameraT< T >
	This class implements the abstract base class for all AnyCamera objects. More...

class	Ocean::CameraProjectionCheckerT< T >
	This class implements a helper class allowing to check whether a 3D object point projects into the camera image. More...

class	Ocean::AnyCameraWrappingT< T, TCameraWrapper >
	This class implements a specialized AnyCamera object wrapping the actual camera model. More...

class	Ocean::CameraWrapperT< T, TCameraWrapperBase >
	This class implements a wrapper for an actual camera object. More...

class	Ocean::CameraWrapperBasePinholeT< T >
	This class implements the base wrapper around Ocean's pinhole camera profile. More...

class	Ocean::CameraWrapperBaseFisheyeT< T >
	This class implements the base wrapper around Ocean's fisheye camera profile. More...

class	Ocean::InvalidCameraT< T >
	This class implements invalid camera profiles, e.g. More...

class	Ocean::CameraWrapperBaseInvalidT< T >
	This class implements the base wrapper around an invalid camera profile. More...

class	Ocean::Approximation
	This class implements several numeric function with approximated results but with fast performances. More...

class	Ocean::AutomaticDifferentiationT< T, TNumeric >
	This class implements an automatic differentiation functionality. More...

class	Ocean::BoundingBox
	This class implements a 3D bounding box. More...

class	Ocean::BoundingSphere
	This class implements a bounding sphere. More...

class	Ocean::BoxT2< T >
	This class implements an axis aligned 2D box object. More...

class	Ocean::BoxT3< T >
	This class implements an axis aligned 3D bounding box. More...

class	Ocean::CameraT< T >
	This class implements the base class for all cameras. More...

class	Ocean::Clustering< tUseIndices >
	This class implements the base class for all classes providing clustering algorithms. More...

class	Ocean::ClusteringKMeans< T, tDimension, TSum, TSquareDistance, tUseIndices >
	This class implements a k-means clustering algorithm. More...

class	Ocean::ClusteringSpectral
	This class implements spectral clustering. More...

class	Ocean::ConeT3< T >
	This class implements a (possibly truncated) 3D cone. More...

class	Ocean::CylinderT3< T >
	This class implements a 3D cylinder defined by its origin, axis, radius, and (signed) starting and stopping points along its axis. More...

class	Ocean::DiscreteCosineTransform
	This class implements discrete cosine transform functions. More...

class	Ocean::EquationT< T >
	This class provides several functions to solve equations with different degree using floating point values with the precission specified by type T. More...

class	Ocean::EulerT< T >
	This class implements an euler rotation with angles: yaw, pitch and roll. More...

class	Ocean::ExponentialMapT< T >
	This class implements an exponential map defining a rotation by three parameters. More...

class	Ocean::FiniteLineT2< T >
	This class implements an finite line in 2D space. More...

class	Ocean::FiniteLineT3< T >
	This class implements an finite line in 3D space. More...

class	Ocean::FisheyeCameraT< T >
	Class representing a fisheye camera. More...

class	Ocean::FourierTransformation
	This class implements Fourier transformation functions. More...

class	Ocean::FrustumT< T >
	This class implements a viewing frustum. More...

class	Ocean::HomogenousMatrixT4< T >
	This class implements a 4x4 homogeneous transformation matrix using floating point values with the precision specified by type T. More...

class	Ocean::HSVAColor
	This class implements a color defined by hue, saturation, value and alpha parameters. More...

class	Ocean::Interpolation
	This class implements data interpolation functions. More...

class	Ocean::InterpolationMap< TKey, TValue, TFactor >
	This class implements an interpolation map allowing to determine an interplated value between several individual key values. More...

class	Ocean::LineT2< T >
	This class implements an infinite line in 2D space. More...

class	Ocean::LineT3< T >
	This class implements an infinite line in 3D space. More...

class	Ocean::Lookup2< T, TScalar >
	This class implements a 2D lookup object allowing to separate a two dimensional lookup area into individual bins. More...

class	Ocean::LookupCenter2< T, TScalar >
	This class implements a 2D lookup object with values at the bins' center positions defining the individual lookup values. More...

class	Ocean::AdvancedLookupCenter2< T, TScalar >
	This class implements an advanced 2D lookup object with values at the bins' center positions defining the individual lookup values. More...

class	Ocean::LookupCorner2< T, TScalar >
	This class implements a 2D lookup object with values at the bins' corners defining the individual lookup values. More...

class	Ocean::MathUtilities
	This class implements utility functions for the math library. More...

class	Ocean::MatrixT< T >
	This class implements a matrix with arbitrary size. More...

class	Ocean::NumericT< T >
	This class provides basic numeric functionalities. More...

class	Ocean::PinholeCameraT< T >
	Definition of a pinhole camera model. More...

class	Ocean::PlaneT3< T >
	This class implements a plane in 3D space. More...

class	Ocean::PoseT< T >
	This class implements a camera pose with six degrees of freedom (6-DOF). More...

class	Ocean::QuaternionT< T >
	This class implements a unit quaternion rotation. More...

class	Ocean::RandomT< T >
	This class provides several random functions for different data types using a floating point type for its elements that is specified by T. More...

class	Ocean::RateCalculator
	This class implements a calculate for rates like frame rates. More...

class	Ocean::RGBAColor
	This class implements a color defined by red, green, blue and alpha parameters. More...

class	Ocean::RotationT< T >
	This class implements a axis-angle rotation using floating point values. More...

class	Ocean::SampleMap< T >
	This class stores samples of e.g., sensor or tracking data in a map. More...

class	Ocean::SophusUtilities
	This class implements utilitiy functions for Sophus. More...

class	Ocean::SparseMatrixT< T >
	This class implements a sparse matrix using a float type for its elements that is specified by T. More...

class	Ocean::SphereT3< T >
	This class implements a 3D sphere. More...

class	Ocean::SphericalExponentialMap
	This class implements an exponential map representing a 2-DOF rotation. More...

class	Ocean::SquareMatrixT2< T >
	This class implements a 2x2 square matrix. More...

class	Ocean::SquareMatrixT3< T >
	This class implements a 3x3 square matrix. More...

class	Ocean::SquareMatrixT4< T >
	This class implements a 4x4 square matrix. More...

class	Ocean::StaticMatrix< T, tRows, tColumns >
	This class implements a matrix with static dimensions. More...

class	Ocean::SuccessionSubset< T, tDimensions >
	This class implements a data container for abstract data objects with several dimensions. More...

class	Ocean::ToonUtilities
	This class implements utilitiy functions for TooN. More...

class	Ocean::TriangleT< T >
	This class implements a base class for all triangle classes. More...

class	Ocean::TriangleT2< T >
	This class implements a 2D triangle with Cartesian coordinates. More...

class	Ocean::TriangleT3< T >
	This class implements a 3D triangle. More...

class	Ocean::VarianceT< T >
	This class allows to determine the variance in a given data set. More...

class	Ocean::VectorT2< T >
	This class implements a vector with two elements. More...

class	Ocean::VectorT3< T >
	This class implements a vector with three elements. More...

class	Ocean::VectorT4< T >
	This class implements a vector with four elements. More...

Typedefs
using	Ocean::Geometry::GravityConstraints = GravityConstraintsT< Scalar >
	Definition of the GravityConstraints object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

using	Ocean::Geometry::GravityConstraintsD = GravityConstraintsT< double >
	Definition of the GravityConstraints object, using double floating point precision.

using	Ocean::Geometry::GravityConstraintsF = GravityConstraintsT< float >
	Definition of the GravityConstraints object, using single floating point precision.

using	Ocean::AnyCamera = AnyCameraT< Scalar >
	Definition of an AnyCamera object with Scalar precision.

using	Ocean::AnyCameraD = AnyCameraT< double >
	Definition of an AnyCamera object with double precision.

using	Ocean::AnyCameraF = AnyCameraT< float >
	Definition of an AnyCamera object with float precision.

template<typename T >
using	Ocean::SharedAnyCameraT = std::shared_ptr< AnyCameraT< T > >
	Definition of a shared pointer holding an AnyCamera object with Scalar precision.

using	Ocean::SharedAnyCamera = std::shared_ptr< AnyCamera >
	Definition of a shared pointer holding an AnyCamera object with Scalar precision.

using	Ocean::SharedAnyCameraD = std::shared_ptr< AnyCameraD >
	Definition of a shared pointer holding an AnyCamera object with double precision.

using	Ocean::SharedAnyCameraF = std::shared_ptr< AnyCameraF >
	Definition of a shared pointer holding an AnyCamera object with float precision.

template<typename T >
using	Ocean::SharedAnyCamerasT = std::vector< std::shared_ptr< AnyCameraT< T > > >
	Definition of a typename alias for vectors with shared AnyCameraT objects.

using	Ocean::SharedAnyCameras = SharedAnyCamerasT< Scalar >
	Definition of a vector holding AnyCamera objects.

using	Ocean::SharedAnyCamerasD = SharedAnyCamerasT< double >
	Definition of a vector holding AnyCameraD objects.

using	Ocean::SharedAnyCamerasF = SharedAnyCamerasT< float >
	Definition of a vector holding AnyCameraF objects.

using	Ocean::CameraProjectionChecker = CameraProjectionCheckerT< Scalar >
	Definition of an ProjectionChecker object with Scalar precision.

using	Ocean::CameraProjectionCheckerD = CameraProjectionCheckerT< double >
	Definition of an ProjectionChecker object with double precision.

using	Ocean::CameraProjectionCheckerF = CameraProjectionCheckerT< float >
	Definition of an ProjectionChecker object with float precision.

using	Ocean::InvalidCamera = InvalidCameraT< Scalar >
	Definition of an invalid camera object based with element precision 'Scalar'.

using	Ocean::InvalidCameraD = InvalidCameraT< double >
	Definition of an invalid camera object based with element precision 'double'.

using	Ocean::InvalidCameraF = InvalidCameraT< float >
	Definition of an invalid camera object based with element precision 'float'.

template<typename T >
using	Ocean::AnyCameraPinholeT = AnyCameraWrappingT< T, CameraWrapperT< T, CameraWrapperBasePinholeT< T > > >
	Definition of an AnyCamera object based on Ocean's pinhole camera class with template parameter to define the element precision.

using	Ocean::AnyCameraPinhole = AnyCameraPinholeT< Scalar >
	Definition of an AnyCamera object based on Ocean's pinhole camera class with element precision 'Scalar'.

using	Ocean::AnyCameraPinholeD = AnyCameraPinholeT< double >
	Definition of an AnyCamera object based on Ocean's pinhole camera class with element precision 'double'.

using	Ocean::AnyCameraPinholeF = AnyCameraPinholeT< float >
	Definition of an AnyCamera object based on Ocean's pinhole camera class with element precision 'float'.

template<typename T >
using	Ocean::AnyCameraFisheyeT = AnyCameraWrappingT< T, CameraWrapperT< T, CameraWrapperBaseFisheyeT< T > > >
	Definition of an AnyCamera object based on Ocean's fisheye camera class with template parameter to define the element precision.

using	Ocean::AnyCameraFisheye = AnyCameraFisheyeT< Scalar >
	Definition of an AnyCamera object based on Ocean's fisheye camera class with element precision 'Scalar'.

using	Ocean::AnyCameraFisheyeD = AnyCameraFisheyeT< double >
	Definition of an AnyCamera object based on Ocean's fisheye camera class with element precision 'double'.

using	Ocean::AnyCameraFisheyeF = AnyCameraFisheyeT< float >
	Definition of an AnyCamera object based on Ocean's fisheye camera class with element precision 'float'.

template<typename T >
using	Ocean::AnyCameraInvalidT = AnyCameraWrappingT< T, CameraWrapperT< T, CameraWrapperBaseInvalidT< T > > >
	Definition of an AnyCamera object based on an invalid (by design) camera with template parameter to define the element precision.

using	Ocean::AnyCameraInvalid = AnyCameraInvalidT< Scalar >
	Definition of an AnyCamera object based on an invalid (by design) camera with element precision 'Scalar'.

using	Ocean::AnyCameraInvalidD = AnyCameraInvalidT< double >
	Definition of an AnyCamera object based on an invalid (by design) camera with element precision 'double'.

using	Ocean::AnyCameraInvalidF = AnyCameraInvalidT< float >
	Definition of an AnyCamera object based on an invalid (by design) camera with element precision 'float'.

using	Ocean::AutomaticDifferentiation = AutomaticDifferentiationT< Scalar, Numeric >
	Definition of a scalar differentiation object using the data type of Scalar as parameter.

using	Ocean::AutomaticDifferentiationD = AutomaticDifferentiationT< double, NumericD >
	Definition of a scalar differentiation object using double as data type.

using	Ocean::AutomaticDifferentiationF = AutomaticDifferentiationT< float, NumericF >
	Definition of a scalar differentiation object using float as data type.

using	Ocean::Box2 = BoxT2< Scalar >
	Definition of the Box2 object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

using	Ocean::BoxD2 = BoxT2< double >
	Instantiation of the BoxT2 template class using a double precision float data type.

using	Ocean::BoxF2 = BoxT2< float >
	Instantiation of the BoxT2 template class using a single precision float data type.

template<typename T >
using	Ocean::BoxesT2 = std::vector< BoxT2< T > >
	Definition of a typename alias for vectors with BoxT2 objects.

using	Ocean::Boxes2 = std::vector< Box2 >
	Definition of a vector holding Box2 objects.

using	Ocean::Box3 = BoxT3< Scalar >
	Definition of the Box3 object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

using	Ocean::BoxD3 = BoxT3< double >
	Instantiation of the BoxT3 template class using a double precision float data type.

using	Ocean::BoxF3 = BoxT3< float >
	Instantiation of the BoxT3 template class using a single precision float data type.

template<typename T >
using	Ocean::BoxesT3 = std::vector< BoxT3< T > >
	Definition of a typename alias for vectors with BoxT3 objects.

using	Ocean::Boxes3 = std::vector< Box3 >
	Definition of a vector holding Box3 objects.

using	Ocean::Camera = CameraT< Scalar >
	Definition of an Camera object with Scalar precision.

using	Ocean::CameraD = CameraT< double >
	Definition of an Camera object with double precision.

using	Ocean::CameraF = CameraT< float >
	Definition of an Camera object with float precision.

using	Ocean::ComplexD = std::complex< double >
	Definition of a complex number based on the double precision floating point data type.

using	Ocean::ComplexF = std::complex< float >
	Definition of a complex number based on the single precision floating point data type.

using	Ocean::Complex = std::complex< Scalar >
	Definition of a complex number based on the default floating point precision data type.

using	Ocean::Complexes = std::vector< Complex >
	Definition of a vector holding complex objects.

using	Ocean::Cone3 = ConeT3< Scalar >
	Definition of the Cone3 object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

using	Ocean::ConeD3 = ConeT3< double >
	Definition of a 3D cone with double values.

using	Ocean::ConeF3 = ConeT3< float >
	Definition of a 3D cone with float values.

using	Ocean::Cones3 = std::vector< Cone3 >
	Definition of a vector holding Cone3 objects.

using	Ocean::Cylinder3 = CylinderT3< Scalar >
	Definition of the Cylinder3 object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

using	Ocean::CylinderD3 = CylinderT3< double >
	Definition of a 3D cylinder with double values.

using	Ocean::CylinderF3 = CylinderT3< float >
	Definition of a 3D cylinder with float values.

using	Ocean::Cylinders3 = std::vector< Cylinder3 >
	Definition of a vector holding Cylinder3 objects.

using	Ocean::Equation = EquationT< Scalar >
	Definition of the Equation object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

using	Ocean::EquationD = EquationT< double >
	Definition of the Equation class using double values.

using	Ocean::EquationF = EquationT< float >
	Definition of the Equation class using float values.

using	Ocean::Euler = EulerT< Scalar >
	Definition of the Euler object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

using	Ocean::EulerD = EulerT< double >
	Instantiation of the EulerT template class using a double precision float data type.

using	Ocean::EulerF = EulerT< float >
	Instantiation of the EulerT template class using a single precision float data type.

template<typename T >
using	Ocean::EulersT = std::vector< EulerT< T > >
	Definition of a typename alias for vectors with EulerT objects.

using	Ocean::Eulers = std::vector< Euler >
	Definition of a vector holding euler objects.

using	Ocean::ExponentialMap = ExponentialMapT< Scalar >
	Definition of the ExponentialMap object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION flag either with single or double precision float data type.

using	Ocean::ExponentialMapD = ExponentialMapT< double >
	Instantiation of the ExponentialMapT template class using a double precision float data type.

using	Ocean::ExponentialMapF = ExponentialMapT< float >
	Instantiation of the ExponentialMapT template class using a single precision float data type.

template<typename T >
using	Ocean::ExponentialMapsT = std::vector< ExponentialMapT< T > >
	Definition of a typename alias for vectors with ExponentialMapT objects.

using	Ocean::ExponentialMaps = std::vector< ExponentialMap >
	Definition of a vector holding ExponentialMap objects.

using	Ocean::FiniteLine2 = FiniteLineT2< Scalar >
	Definition of the FiniteLine2 object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

using	Ocean::FiniteLineD2 = FiniteLineT2< double >
	Instantiation of the LineT2 template class using a double precision float data type.

using	Ocean::FiniteLineF2 = FiniteLineT2< float >
	Instantiation of the LineT2 template class using a single precision float data type.

template<typename T >
using	Ocean::FiniteLinesT2 = std::vector< FiniteLineT2< T > >
	Definition of a typename alias for vectors with FiniteLineT2 objects.

using	Ocean::FiniteLines2 = std::vector< FiniteLine2 >
	Definition of a vector holding FiniteLine2 objects.

using	Ocean::FiniteLinesD2 = std::vector< FiniteLineD2 >
	Definition of a vector holding FiniteLineD2 objects.

using	Ocean::FiniteLinesF2 = std::vector< FiniteLineF2 >
	Definition of a vector holding FiniteLineF2 objects.

using	Ocean::FiniteLine3 = FiniteLineT3< Scalar >
	Definition of the FiniteLine3 object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

using	Ocean::FiniteLineD3 = FiniteLineT3< double >
	Instantiation of the LineT3 template class using a double precision float data type.

using	Ocean::FiniteLineF3 = FiniteLineT3< float >
	Instantiation of the LineT3 template class using a single precision float data type.

template<typename T >
using	Ocean::FiniteLinesT3 = std::vector< FiniteLineT3< T > >
	Definition of a typename alias for vectors with FiniteLineT3 objects.

using	Ocean::FiniteLines3 = std::vector< FiniteLine3 >
	Definition of a vector holding FiniteLine3 objects.

using	Ocean::FisheyeCamera = FisheyeCameraT< Scalar >
	Definition of a FisheyeCamera object using Scalar as data type.

using	Ocean::FisheyeCameraF = FisheyeCameraT< float >
	Definition of a FisheyeCamera object using 'float'' as data type.

using	Ocean::FisheyeCameraD = FisheyeCameraT< double >
	Definition of a FisheyeCamera object using 'double'' as data type.

template<typename T >
using	Ocean::FisheyeCamerasT = std::vector< FisheyeCameraT< T > >
	Definition of a typename alias for vectors with FisheyeCameraT objects.

using	Ocean::FisheyeCameras = std::vector< FisheyeCamera >
	Definition of a vector holding camera objects.

using	Ocean::Frustum = FrustumT< Scalar >
	Definition of a frustum.

using	Ocean::FrustumD = FrustumT< double >
	Definition of a frustum with double values.

using	Ocean::FrustumF = FrustumT< float >
	Definition of a frustum vector with float values.

template<typename T >
using	Ocean::FrustumsT = std::vector< FrustumT< T > >
	Definition of a typename alias for vectors with FrustumT objects.

using	Ocean::Frustums = std::vector< Frustum >
	Definition of a vector holding Frustum objects.

using	Ocean::FrustumsD = std::vector< FrustumD >
	Definition of a vector holding FrustumD objects.

using	Ocean::FrustumsF = std::vector< FrustumF >
	Definition of a vector holding FrustumF objects.

using	Ocean::HomogenousMatrix4 = HomogenousMatrixT4< Scalar >
	Definition of the HomogenousMatrix4 object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION flag either with single or double precision float data type.

using	Ocean::HomogenousMatrixD4 = HomogenousMatrixT4< double >
	Instantiation of the HomogenousMatrixT4 template class using a double precision float data type.

using	Ocean::HomogenousMatrixF4 = HomogenousMatrixT4< float >
	Instantiation of the HomogenousMatrixT4 template class using a float precision float data type.

template<typename T >
using	Ocean::HomogenousMatricesT4 = std::vector< HomogenousMatrixT4< T > >
	Definition of a typename alias for vectors with HomogenousMatrixT4 objects.

using	Ocean::HomogenousMatrices4 = std::vector< HomogenousMatrix4 >
	Definition of a vector holding HomogenousMatrix4 objects.

using	Ocean::HomogenousMatricesD4 = std::vector< HomogenousMatrixD4 >
	Definition of a vector holding HomogenousMatrixD4 objects.

using	Ocean::HomogenousMatricesF4 = std::vector< HomogenousMatrixF4 >
	Definition of a vector holding HomogenousMatrixF4 objects.

using	Ocean::HSVAColors = std::vector< HSVAColor >
	Definition of a vector holding rgba color objects.

using	Ocean::Line2 = LineT2< Scalar >
	Definition of the Line2 object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

using	Ocean::LineD2 = LineT2< double >
	Instantiation of the LineT2 template class using a double precision float data type.

using	Ocean::LineF2 = LineT2< float >
	Instantiation of the LineT2 template class using a single precision float data type.

template<typename T >
using	Ocean::LinesT2 = std::vector< LineT2< T > >
	Definition of a typename alias for vectors with LineT2 objects.

using	Ocean::Lines2 = std::vector< Line2 >
	Definition of a vector holding Line2 objects.

using	Ocean::LinesF2 = std::vector< LineF2 >
	Definition of a vector holding Line2 objects with single precision float data type.

using	Ocean::LinesD2 = std::vector< LineD2 >
	Definition of a vector holding Line2 objects with double precision float data type.

using	Ocean::Line3 = LineT3< Scalar >
	Definition of the Line3 object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

using	Ocean::LineD3 = LineT3< double >
	Instantiation of the LineT3 template class using a double precision float data type.

using	Ocean::LineF3 = LineT3< float >
	Instantiation of the LineT3 template class using a single precision float data type.

template<typename T >
using	Ocean::LinesT3 = std::vector< LineT3< T > >
	Definition of a typename alias for vectors with LineT3 objects.

using	Ocean::Lines3 = std::vector< Line3 >
	Definition of a vector holding Line3 objects.

using	Ocean::Scalar = float
	Definition of a scalar type.

using	Ocean::Scalars = std::vector< Scalar >
	Definition of a vector holding Scalar objects.

using	Ocean::Matrix = MatrixT< Scalar >
	Definition of the Matrix object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

using	Ocean::MatrixD = MatrixT< double >
	Definition of the MatrixT template class using a double precision float data type.

using	Ocean::MatrixF = MatrixT< float >
	Definition of the MatrixT template class using a single precision float data type.

using	Ocean::Matrices = std::vector< Matrix >
	Definition of a vector holding matrix objects.

using	Ocean::Numeric = NumericT< Scalar >
	Definition of a Numeric class.

using	Ocean::NumericD = NumericT< double >
	Definition of a Numeric class with double values.

using	Ocean::NumericF = NumericT< float >
	Definition of a Numeric class with float values.

using	Ocean::PinholeCamera = PinholeCameraT< Scalar >
	Definition of an pinhole camera object with Scalar precision.

using	Ocean::PinholeCameraD = PinholeCameraT< double >
	Definition of an pinhole camera object with double precision.

using	Ocean::PinholeCameraF = PinholeCameraT< float >
	Definition of an pinhole camera object with float precision.

template<typename T >
using	Ocean::PinholeCamerasT = std::vector< PinholeCameraT< T > >
	Definition of a typename alias for vectors with PinholeCameraT objects.

using	Ocean::PinholeCameras = PinholeCamerasT< Scalar >
	Definition of a vector holding pinhole camera objects.

using	Ocean::PinholeCamerasD = PinholeCamerasT< double >
	Definition of a vector holding PinholeCameraD objects.

using	Ocean::PinholeCamerasF = PinholeCamerasT< float >
	Definition of a vector holding PinholeCameraF objects.

using	Ocean::Plane3 = PlaneT3< Scalar >
	Definition of the Plane3 object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

using	Ocean::PlaneD3 = PlaneT3< double >
	Definition of a 3D plane with double values.

using	Ocean::PlaneF3 = PlaneT3< float >
	Definition of a 3D plane with float values.

template<typename T >
using	Ocean::PlanesT3 = std::vector< PlaneT3< T > >
	Definition of a typename alias for vectors with PlaneT3 objects.

using	Ocean::Planes3 = std::vector< Plane3 >
	Definition of a vector holding Plane3 objects.

using	Ocean::Pose = PoseT< Scalar >
	Definition of the Pose object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION flag either with single or double precision float data type.

using	Ocean::PoseD = PoseT< double >
	Instantiation of the ExponentialMapT template class using a double precision float data type.

using	Ocean::PoseF = PoseT< float >
	Instantiation of the ExponentialMapT template class using a single precision float data type.

template<typename T >
using	Ocean::PosesT = std::vector< PoseT< T > >
	Definition of a typename alias for vectors with PoseT objects.

using	Ocean::Poses = std::vector< Pose >
	Definition of a vector holding ExponentialMap objects.

using	Ocean::Quaternion = QuaternionT< Scalar >
	Definition of the Quaternion object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

using	Ocean::QuaternionD = QuaternionT< double >
	Instantiation of the QuaternionT template class using a double precision float data type.

using	Ocean::QuaternionF = QuaternionT< float >
	Instantiation of the QuaternionT template class using a single precision float data type.

template<typename T >
using	Ocean::QuaternionsT = std::vector< QuaternionT< T > >
	Definition of a typename alias for vectors with QuaternionT objects.

using	Ocean::Quaternions = std::vector< Quaternion >
	Definition of a vector holding quaternion objects.

using	Ocean::QuaternionsF = std::vector< QuaternionF >
	Definition of a vector holding quaternion objects with single precision float data type.

using	Ocean::QuaternionsD = std::vector< QuaternionD >
	Definition of a vector holding quaternion objects with double precision float data type.

using	Ocean::Random = RandomT< Scalar >
	Definition of the Random object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

using	Ocean::RandomD = RandomT< double >
	Instantiation of the RandomT template class using a double precision float data type.

using	Ocean::RandomF = RandomT< float >
	Instantiation of the RandomT template class using a single precision float data type.

using	Ocean::RGBAColors = std::vector< RGBAColor >
	Definition of a vector holding rgba color objects.

using	Ocean::Rotation = RotationT< Scalar >
	Definition of the Rotation object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION flag either with single or double precision float data type.

using	Ocean::RotationD = RotationT< double >
	Instantiation of the RotationT template class using a double precision float data type.

using	Ocean::RotationF = RotationT< float >
	Instantiation of the RotationT template class using a single precision float data type.

template<typename T >
using	Ocean::RotationsT = std::vector< RotationT< T > >
	Definition of a typename alias for vectors with RotationT objects.

using	Ocean::Rotations = std::vector< Rotation >
	Definition of a vector holding rotation objects.

using	Ocean::SparseMatrix = SparseMatrixT< Scalar >
	Definition of the SparseMatrix object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

using	Ocean::SparseMatrixD = SparseMatrixT< double >
	Instantiation of the SparseMatrixT template class using a double precision float data type.

using	Ocean::SparseMatrixF = SparseMatrixT< float >
	Instantiation of the SparseMatrixT template class using a single precision float data type.

using	Ocean::SparseMatrices = std::vector< SparseMatrix >
	Definition of a vector holding sparse matrix objects.

using	Ocean::Sphere3 = SphereT3< Scalar >
	Definition of the Sphere3 object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

using	Ocean::SphereD3 = SphereT3< double >
	Definition of a 3D sphere with double values.

using	Ocean::SphereF3 = SphereT3< float >
	Definition of a 3D sphere with float values.

using	Ocean::Spheres3 = std::vector< Sphere3 >
	Definition of a vector holding Shpere3 objects.

using	Ocean::SquareMatrix2 = SquareMatrixT2< Scalar >
	Definition of the SquareMatrix2 object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

using	Ocean::SquareMatrixD2 = SquareMatrixT2< double >
	Instantiation of the SquareMatrixT2 template class using a double precision float data type.

using	Ocean::SquareMatrixF2 = SquareMatrixT2< float >
	Instantiation of the SquareMatrixT2 template class using a single precision float data type.

template<typename T >
using	Ocean::SquareMatricesT2 = std::vector< SquareMatrixT2< T > >
	Definition of a typename alias for vectors with SquareMatrixT2 objects.

using	Ocean::SquareMatrices2 = std::vector< SquareMatrix2 >
	Definition of a vector holding SquareMatrix2 objects.

using	Ocean::SquareMatrix3 = SquareMatrixT3< Scalar >
	Definition of the SquareMatrix3 object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

using	Ocean::SquareMatrixD3 = SquareMatrixT3< double >
	Instantiation of the SquareMatrixT3 template class using a double precision float data type.

using	Ocean::SquareMatrixF3 = SquareMatrixT3< float >
	Instantiation of the SquareMatrixT3 template class using a single precision float data type.

template<typename T >
using	Ocean::SquareMatricesT3 = std::vector< SquareMatrixT3< T > >
	Definition of a typename alias for vectors with SquareMatrixT3 objects.

using	Ocean::SquareMatrices3 = std::vector< SquareMatrix3 >
	Definition of a vector holding SquareMatrix3 objects.

using	Ocean::SquareMatrix4 = SquareMatrixT4< Scalar >
	Definition of the SquareMatrix4 object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

using	Ocean::SquareMatrixD4 = SquareMatrixT4< double >
	Instantiation of the SquareMatrixT4 template class using a double precision float data type.

using	Ocean::SquareMatrixF4 = SquareMatrixT4< float >
	Instantiation of the SquareMatrixT4 template class using a double precision float data type.

template<typename T >
using	Ocean::SquareMatricesT4 = std::vector< SquareMatrixT4< T > >
	Definition of a typename alias for vectors with SquareMatrixT4 objects.

using	Ocean::SquareMatrices4 = std::vector< SquareMatrix4 >
	Definition of a vector holding SquareMatrix4 objects.

using	Ocean::Triangle = TriangleT< Scalar >
	Definition of the Triangle object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

using	Ocean::TriangleD = TriangleT< double >
	Instantiation of the TriangleT template class using a double precision float data type.

using	Ocean::TriangleF = TriangleT< float >
	Instantiation of the TriangleT template class using a single precision float data type.

using	Ocean::Triangle2 = TriangleT2< Scalar >
	Definition of the Triangle2 object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

using	Ocean::TriangleD2 = TriangleT2< double >
	Instantiation of the TriangleT2 template class using a double precision float data type.

using	Ocean::TriangleF2 = TriangleT2< float >
	Instantiation of the TriangleT2 template class using a single precision float data type.

template<typename T >
using	Ocean::TrianglesT2 = std::vector< TriangleT2< T > >
	Definition of a typename alias for vectors with TriangleT2 objects.

using	Ocean::Triangles2 = std::vector< Triangle2 >
	Definition of a vector holding 2D triangles.

using	Ocean::TrianglesF2 = std::vector< TriangleF2 >
	Definition of a vector holding 2D triangles with single precision float data type.

using	Ocean::TrianglesD2 = std::vector< TriangleD2 >
	Definition of a vector holding 2D triangles with double precision float data type.

using	Ocean::Triangle3 = TriangleT3< Scalar >
	Definition of the Triangle3 object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

using	Ocean::TriangleD3 = TriangleT3< double >
	Instantiation of the TriangleT3 template class using a double precision float data type.

using	Ocean::TriangleF3 = TriangleT3< float >
	Instantiation of the TriangleT3 template class using a single precision float data type.

template<typename T >
using	Ocean::TrianglesT3 = std::vector< TriangleT3< T > >
	Definition of a typename alias for vectors with TriangleT3 objects.

using	Ocean::Triangles3 = std::vector< Triangle3 >
	Definition of a vector holding 3D triangles.

using	Ocean::TrianglesF3 = std::vector< TriangleF3 >
	Definition of a vector holding 3D triangles with single precision float data type.

using	Ocean::TrianglesD3 = std::vector< TriangleD3 >
	Definition of a vector holding 3D triangles with double precision float data type.

using	Ocean::Variance = VarianceT< Scalar >
	Definition of a variance object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

using	Ocean::VarianceD = VarianceT< double >
	Definition of a variance object with double values.

using	Ocean::VarianceF = VarianceT< float >
	Definition of a variance object with float values.

using	Ocean::Variances = std::vector< Variance >
	Definition of a vector holding variance objects.

using	Ocean::Vector2 = VectorT2< Scalar >
	Definition of a 2D vector.

using	Ocean::VectorD2 = VectorT2< double >
	Definition of a 2D vector with double values.

using	Ocean::VectorF2 = VectorT2< float >
	Definition of a 2D vector with float values.

using	Ocean::VectorI2 = VectorT2< int >
	Definition of a 2D vector with integer values.

template<typename T >
using	Ocean::VectorsT2 = std::vector< VectorT2< T > >
	Definition of a typename alias for vectors with VectorT2 objects.

using	Ocean::Vectors2 = std::vector< Vector2 >
	Definition of a vector holding Vector2 objects.

using	Ocean::VectorsD2 = std::vector< VectorD2 >
	Definition of a vector holding VectorD2 objects.

using	Ocean::VectorsF2 = std::vector< VectorF2 >
	Definition of a vector holding VectorF2 objects.

using	Ocean::VectorsI2 = std::vector< VectorI2 >
	Definition of a vector holding VectorI2 objects.

using	Ocean::Vector3 = VectorT3< Scalar >
	Definition of a 3D vector.

using	Ocean::VectorD3 = VectorT3< double >
	Definition of a 3D vector with double values.

using	Ocean::VectorF3 = VectorT3< float >
	Definition of a 3D vector with float values.

using	Ocean::VectorI3 = VectorT3< int >
	Definition of a 3D vector with integer values.

template<typename T >
using	Ocean::VectorsT3 = std::vector< VectorT3< T > >
	Definition of a typename alias for vectors with VectorT3 objects.

using	Ocean::Vectors3 = std::vector< Vector3 >
	Definition of a vector holding Vector3 objects.

using	Ocean::VectorsD3 = std::vector< VectorD3 >
	Definition of a vector holding VectorD3 objects.

using	Ocean::VectorsF3 = std::vector< VectorF3 >
	Definition of a vector holding VectorF3 objects.

using	Ocean::VectorsI3 = std::vector< VectorI3 >
	Definition of a vector holding VectorI3 objects.

using	Ocean::Vector4 = VectorT4< Scalar >
	Definition of a 4D vector.

using	Ocean::VectorD4 = VectorT4< double >
	Definition of a 4D vector with double values.

using	Ocean::VectorF4 = VectorT4< float >
	Definition of a 4D vector with float values.

using	Ocean::VectorI4 = VectorT4< int >
	Definition of a 4D vector with integer values.

template<typename T >
using	Ocean::VectorsT4 = std::vector< VectorT4< T > >
	Definition of a typename alias for vectors with VectorT4 objects.

using	Ocean::Vectors4 = std::vector< Vector4 >
	Definition of a vector holding Vector4 objects.

using	Ocean::VectorsD4 = std::vector< VectorD4 >
	Definition of a vector holding VectorD4 objects.

using	Ocean::VectorsF4 = std::vector< VectorF4 >
	Definition of a vector holding VectorF4 objects.

using	Ocean::VectorsI4 = std::vector< VectorI4 >
	Definition of a vector holding VectorI4 objects.

Enumerations
enum class	Ocean::AnyCameraType : uint32_t { Ocean::AnyCameraType::INVALID = 0u , Ocean::AnyCameraType::PINHOLE , Ocean::AnyCameraType::FISHEYE }
	Definition of individual camera types. More...

Detailed Description

The Ocean Math Library provides basic numerical and algebraic functionalities.

The library is platform independent.

The Math Library supports floating point numbers with single (32bit) and double (64bit) precision.
The library defines an own type for floating point numbers allowing to compile the entire library for a specific default type of floating point numbers (either float or double).
Thus, use the Scalar type to implement code for either 32bit or 64bit floating point values.
The preprocessor define 'OCEAN_MATH_USE_SINGLE_PRECISION' distinguishes whether single or double precision is used as default floating point numbers.

See also: Scalar.

The library implements template-based classes allowing the explicit application of single or double precision floating point numbers.
The template-based classes are necessary to store or convert mathematical data between the Ocean framework and 3rd party libraries which rely either on 32bit or 64bit floating point numbers.
Further, the library implements classes that consistently applies the Scalar default floating point type avoiding a template-based implementation.
All template-based class names end with a 'T' identifying the template implementation.
However, for each template class three typedef definitions exist: a single,a double and a default precision version.
The single precision version ends with a 'F' (for float), the double precision version ends with a 'D' (for double).
The name of the default precision version is the normal class name without 'T', 'F' or 'D'.

See also: VectorT3, VectorF3, VectorD3, Vector3.; PlaneT3, PlaneF3, PlaneD3, Plane3.; VarianceT, VarianceF, VarianceD, Variance.

The NumericT class provides template-based access to numerical functions for single (NumericF) and double (NumericD) precision floating point numbers.
Use the default Numeric class to access the numerical functions with default floating point number type.

See also: NumericT, NumericF, NumericD, Numeric.

The Math Library provides 2D, 3D and 4D vector classes with a wide variety of functions necessary for linear algebra tasks.

See also: VectorT2, VectorT3, VectorT4.

The SquareMatrix2, SquareMatrix3 and SquareMatrix4 classes can be used for e.g., matrix-matrix or matrix-vector multipliations.
Each of the three matrix classes implement a square matrix with either 2, 3 or 4 rows and columns.

See also: SquareMatrixT2, SquareMatrixT3, SquareMatrixT4.

The HomogenousMatrix4 is comparable to the SquareMatrix4 class.
However, the homogenous matrix is designed to store homogenous transformations in 3D space like e.g., camera poses or coordinate system transformations.

See also: HomogenousMatrix4.

Matrix object with arbitrary (dynamic or static dimensions) are implemented by the classes Matrix and StaticMatrix.
A sparse matrix is realized in the SparseMatrix class.

See also: Matrix, StaticMatrix, SparseMatrix.

Rotation in 3D space can be expressed by the Euler, ExponentialMap, Quaternion, Rotation, SquareMatrix3 classes.

See also: EulerT, ExponentialMap, QuaternionT, RotationT, SquareMatrixT3.

An extrinsic camera matrix (a camera pose) can be represented by an HomogenousMatrix4 object or by a Pose object.
An intrinsic camera matrix (camera profile) is implemented by the PinholeCamera class further supporting camera distortion profiles.

See also: HomogenousMatrix4, Pose.

Further, the library supports 2D and 3D finite and infinite lines (rays) and 2D and 3D triangles.

See also: Line2, Line3, FiniteLine2, FiniteLine3, Triangle2, Triangle3.

The Plane3 class implements an infinite 3D plane.

See also: Plane3.

2D rectangles, 3D boxes and sphere as well as bounding volumes are realized by the Box2, Box3, Sphere3, BoundingBox and BoundingSphere classes.

See also: Box2, Box3, Sphere3, BoundingBox, BoundingSphere.

A Fourier transformation and a discrete cosine transformation can be accessed by the FourierTransformation and DiscreteCosineTransformation classes.

See also: FourierTransformation, DiscreteCosineTransformation.

However, the Math Library provides several further classes and functions.

In general, the Math library (but also the remaining entire framework) is using a right-handed coordinate system (as long as not explicitly documented differently).
Please refer to the Geometry library regarding a more detailed overview of the individual coordinate systems and how the framework handles transformations by default.

Typedef Documentation

◆ AnyCamera

using Ocean::AnyCamera = typedef AnyCameraT<Scalar>

Definition of an AnyCamera object with Scalar precision.

See also: AnyCameraT

◆ AnyCameraD

using Ocean::AnyCameraD = typedef AnyCameraT<double>

Definition of an AnyCamera object with double precision.

See also: AnyCameraT

◆ AnyCameraF

using Ocean::AnyCameraF = typedef AnyCameraT<float>

Definition of an AnyCamera object with float precision.

See also: AnyCameraT

◆ AnyCameraFisheye

using Ocean::AnyCameraFisheye = typedef AnyCameraFisheyeT<Scalar>

Definition of an AnyCamera object based on Ocean's fisheye camera class with element precision 'Scalar'.

See also: AnyCameraT, AnyCameraFisheyeT.

◆ AnyCameraFisheyeD

using Ocean::AnyCameraFisheyeD = typedef AnyCameraFisheyeT<double>

Definition of an AnyCamera object based on Ocean's fisheye camera class with element precision 'double'.

See also: AnyCameraT, AnyCameraFisheyeT.

◆ AnyCameraFisheyeF

using Ocean::AnyCameraFisheyeF = typedef AnyCameraFisheyeT<float>

Definition of an AnyCamera object based on Ocean's fisheye camera class with element precision 'float'.

See also: AnyCameraT, AnyCameraFisheyeT.

◆ AnyCameraFisheyeT

template<typename T >

using Ocean::AnyCameraFisheyeT = typedef AnyCameraWrappingT<T, CameraWrapperT<T, CameraWrapperBaseFisheyeT<T> >>

Definition of an AnyCamera object based on Ocean's fisheye camera class with template parameter to define the element precision.

Template Parameters

T	The scalar data type

See also: AnyCameraT, CameraWrapperBaseFisheyeT, AnyCameraFisheye, AnyCameraFisheyeD, AnyCameraFisheyeF.

◆ AnyCameraInvalid

using Ocean::AnyCameraInvalid = typedef AnyCameraInvalidT<Scalar>

Definition of an AnyCamera object based on an invalid (by design) camera with element precision 'Scalar'.

See also: AnyCameraT, AnyCameraInvalidT.

◆ AnyCameraInvalidD

using Ocean::AnyCameraInvalidD = typedef AnyCameraInvalidT<double>

Definition of an AnyCamera object based on an invalid (by design) camera with element precision 'double'.

See also: AnyCameraT, AnyCameraInvalidT.

◆ AnyCameraInvalidF

using Ocean::AnyCameraInvalidF = typedef AnyCameraInvalidT<float>

Definition of an AnyCamera object based on an invalid (by design) camera with element precision 'float'.

See also: AnyCameraT, AnyCameraInvalidT.

◆ AnyCameraInvalidT

template<typename T >

using Ocean::AnyCameraInvalidT = typedef AnyCameraWrappingT<T, CameraWrapperT<T, CameraWrapperBaseInvalidT<T> >>

Definition of an AnyCamera object based on an invalid (by design) camera with template parameter to define the element precision.

Template Parameters

T	The scalar data type

See also: AnyCameraT, CameraWrapperBaseFisheyeT, AnyCameraInvalid, AnyCameraInvalidD, AnyCameraInvalidF.

◆ AnyCameraPinhole

using Ocean::AnyCameraPinhole = typedef AnyCameraPinholeT<Scalar>

Definition of an AnyCamera object based on Ocean's pinhole camera class with element precision 'Scalar'.

See also: AnyCameraT, AnyCameraPinholeT.

◆ AnyCameraPinholeD

using Ocean::AnyCameraPinholeD = typedef AnyCameraPinholeT<double>

Definition of an AnyCamera object based on Ocean's pinhole camera class with element precision 'double'.

See also: AnyCameraT, AnyCameraPinholeT.

◆ AnyCameraPinholeF

using Ocean::AnyCameraPinholeF = typedef AnyCameraPinholeT<float>

Definition of an AnyCamera object based on Ocean's pinhole camera class with element precision 'float'.

See also: AnyCameraT, AnyCameraPinholeT.

◆ AnyCameraPinholeT

template<typename T >

using Ocean::AnyCameraPinholeT = typedef AnyCameraWrappingT<T, CameraWrapperT<T, CameraWrapperBasePinholeT<T> >>

Definition of an AnyCamera object based on Ocean's pinhole camera class with template parameter to define the element precision.

Template Parameters

T	The scalar data type

See also: AnyCameraT, CameraWrapperBasePinholeT, AnyCameraPinhole, AnyCameraPinholeD, AnyCameraPinholeF.

◆ AutomaticDifferentiation

using Ocean::AutomaticDifferentiation = typedef AutomaticDifferentiationT<Scalar, Numeric>

Definition of a scalar differentiation object using the data type of Scalar as parameter.

See also: AutomaticDifferentiationT

◆ AutomaticDifferentiationD

using Ocean::AutomaticDifferentiationD = typedef AutomaticDifferentiationT<double, NumericD>

Definition of a scalar differentiation object using double as data type.

See also: AutomaticDifferentiationT

◆ AutomaticDifferentiationF

using Ocean::AutomaticDifferentiationF = typedef AutomaticDifferentiationT<float, NumericF>

Definition of a scalar differentiation object using float as data type.

See also: AutomaticDifferentiationT

◆ Box2

using Ocean::Box2 = typedef BoxT2<Scalar>

Definition of the Box2 object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

See also: BoxT2

◆ Box3

using Ocean::Box3 = typedef BoxT3<Scalar>

Definition of the Box3 object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

See also: BoxT3

◆ BoxD2

using Ocean::BoxD2 = typedef BoxT2<double>

Instantiation of the BoxT2 template class using a double precision float data type.

See also: BoxT2

◆ BoxD3

using Ocean::BoxD3 = typedef BoxT3<double>

Instantiation of the BoxT3 template class using a double precision float data type.

See also: BoxT3

◆ Boxes2

using Ocean::Boxes2 = typedef std::vector<Box2>

Definition of a vector holding Box2 objects.

See also: Box2

◆ Boxes3

using Ocean::Boxes3 = typedef std::vector<Box3>

Definition of a vector holding Box3 objects.

See also: Box3

◆ BoxesT2

template<typename T >

using Ocean::BoxesT2 = typedef std::vector<BoxT2<T> >

Definition of a typename alias for vectors with BoxT2 objects.

See also: BoxT2

◆ BoxesT3

template<typename T >

using Ocean::BoxesT3 = typedef std::vector<BoxT3<T> >

Definition of a typename alias for vectors with BoxT3 objects.

See also: BoxT3

◆ BoxF2

using Ocean::BoxF2 = typedef BoxT2<float>

Instantiation of the BoxT2 template class using a single precision float data type.

See also: BoxT2

◆ BoxF3

using Ocean::BoxF3 = typedef BoxT3<float>

Instantiation of the BoxT3 template class using a single precision float data type.

See also: BoxT3

◆ Camera

using Ocean::Camera = typedef CameraT<Scalar>

Definition of an Camera object with Scalar precision.

See also: CameraT

◆ CameraD

using Ocean::CameraD = typedef CameraT<double>

Definition of an Camera object with double precision.

See also: CameraT

◆ CameraF

using Ocean::CameraF = typedef CameraT<float>

Definition of an Camera object with float precision.

See also: CameraT

◆ CameraProjectionChecker

using Ocean::CameraProjectionChecker = typedef CameraProjectionCheckerT<Scalar>

Definition of an ProjectionChecker object with Scalar precision.

See also: CameraProjectionCheckerT

◆ CameraProjectionCheckerD

using Ocean::CameraProjectionCheckerD = typedef CameraProjectionCheckerT<double>

Definition of an ProjectionChecker object with double precision.

See also: CameraProjectionCheckerT

◆ CameraProjectionCheckerF

using Ocean::CameraProjectionCheckerF = typedef CameraProjectionCheckerT<float>

Definition of an ProjectionChecker object with float precision.

See also: CameraProjectionCheckerT

◆ Complex

using Ocean::Complex = typedef std::complex<Scalar>

Definition of a complex number based on the default floating point precision data type.

◆ ComplexD

using Ocean::ComplexD = typedef std::complex<double>

Definition of a complex number based on the double precision floating point data type.

◆ Complexes

using Ocean::Complexes = typedef std::vector<Complex>

Definition of a vector holding complex objects.

◆ ComplexF

using Ocean::ComplexF = typedef std::complex<float>

Definition of a complex number based on the single precision floating point data type.

◆ Cone3

using Ocean::Cone3 = typedef ConeT3<Scalar>

Definition of the Cone3 object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

See also: ConeT3

◆ ConeD3

using Ocean::ConeD3 = typedef ConeT3<double>

Definition of a 3D cone with double values.

See also: ConeT3

◆ ConeF3

using Ocean::ConeF3 = typedef ConeT3<float>

Definition of a 3D cone with float values.

See also: ConeT3

◆ Cones3

using Ocean::Cones3 = typedef std::vector<Cone3>

Definition of a vector holding Cone3 objects.

See also: Cone3

◆ Cylinder3

using Ocean::Cylinder3 = typedef CylinderT3<Scalar>

Definition of the Cylinder3 object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

See also: CylinderT3

◆ CylinderD3

using Ocean::CylinderD3 = typedef CylinderT3<double>

Definition of a 3D cylinder with double values.

See also: CylinderT3

◆ CylinderF3

using Ocean::CylinderF3 = typedef CylinderT3<float>

Definition of a 3D cylinder with float values.

See also: CylinderT3

◆ Cylinders3

using Ocean::Cylinders3 = typedef std::vector<Cylinder3>

Definition of a vector holding Cylinder3 objects.

See also: Cylinder3

◆ Equation

using Ocean::Equation = typedef EquationT<Scalar>

Definition of the Equation object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

See also: EquationT

◆ EquationD

using Ocean::EquationD = typedef EquationT<double>

Definition of the Equation class using double values.

See also: EquationT

◆ EquationF

using Ocean::EquationF = typedef EquationT<float>

Definition of the Equation class using float values.

See also: EquationT

◆ Euler

using Ocean::Euler = typedef EulerT<Scalar>

Definition of the Euler object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

See also: EulerT

◆ EulerD

using Ocean::EulerD = typedef EulerT<double>

Instantiation of the EulerT template class using a double precision float data type.

See also: EulerT

◆ EulerF

using Ocean::EulerF = typedef EulerT<float>

Instantiation of the EulerT template class using a single precision float data type.

See also: EulerT

◆ Eulers

using Ocean::Eulers = typedef std::vector<Euler>

Definition of a vector holding euler objects.

See also: Euler

◆ EulersT

template<typename T >

using Ocean::EulersT = typedef std::vector<EulerT<T> >

Definition of a typename alias for vectors with EulerT objects.

See also: EulerT

◆ ExponentialMap

using Ocean::ExponentialMap = typedef ExponentialMapT<Scalar>

Definition of the ExponentialMap object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION flag either with single or double precision float data type.

See also: ExponentialMapT

◆ ExponentialMapD

using Ocean::ExponentialMapD = typedef ExponentialMapT<double>

Instantiation of the ExponentialMapT template class using a double precision float data type.

See also: ExponentialMapT

◆ ExponentialMapF

using Ocean::ExponentialMapF = typedef ExponentialMapT<float>

Instantiation of the ExponentialMapT template class using a single precision float data type.

See also: ExponentialMapT

◆ ExponentialMaps

using Ocean::ExponentialMaps = typedef std::vector<ExponentialMap>

Definition of a vector holding ExponentialMap objects.

See also: ExponentialMap

◆ ExponentialMapsT

template<typename T >

using Ocean::ExponentialMapsT = typedef std::vector<ExponentialMapT<T> >

Definition of a typename alias for vectors with ExponentialMapT objects.

See also: ExponentialMapT

◆ FiniteLine2

using Ocean::FiniteLine2 = typedef FiniteLineT2<Scalar>

Definition of the FiniteLine2 object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

See also: FiniteLineT2

◆ FiniteLine3

using Ocean::FiniteLine3 = typedef FiniteLineT3<Scalar>

Definition of the FiniteLine3 object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

See also: FiniteLineT3

◆ FiniteLineD2

using Ocean::FiniteLineD2 = typedef FiniteLineT2<double>

Instantiation of the LineT2 template class using a double precision float data type.

See also: FiniteLineT2

◆ FiniteLineD3

using Ocean::FiniteLineD3 = typedef FiniteLineT3<double>

Instantiation of the LineT3 template class using a double precision float data type.

See also: FiniteLineT3

◆ FiniteLineF2

using Ocean::FiniteLineF2 = typedef FiniteLineT2<float>

Instantiation of the LineT2 template class using a single precision float data type.

See also: FiniteLineT2

◆ FiniteLineF3

using Ocean::FiniteLineF3 = typedef FiniteLineT3<float>

Instantiation of the LineT3 template class using a single precision float data type.

See also: FiniteLineT3

◆ FiniteLines2

using Ocean::FiniteLines2 = typedef std::vector<FiniteLine2>

Definition of a vector holding FiniteLine2 objects.

See also: FiniteLineF2, Line2

◆ FiniteLines3

using Ocean::FiniteLines3 = typedef std::vector<FiniteLine3>

Definition of a vector holding FiniteLine3 objects.

See also: Line3

◆ FiniteLinesD2

using Ocean::FiniteLinesD2 = typedef std::vector<FiniteLineD2>

Definition of a vector holding FiniteLineD2 objects.

See also: FiniteLineD2, Line2

◆ FiniteLinesF2

using Ocean::FiniteLinesF2 = typedef std::vector<FiniteLineF2>

Definition of a vector holding FiniteLineF2 objects.

See also: FiniteLineF2, Line2

◆ FiniteLinesT2

template<typename T >

using Ocean::FiniteLinesT2 = typedef std::vector<FiniteLineT2<T> >

Definition of a typename alias for vectors with FiniteLineT2 objects.

See also: FiniteLineT2

◆ FiniteLinesT3

template<typename T >

using Ocean::FiniteLinesT3 = typedef std::vector<FiniteLineT3<T> >

Definition of a typename alias for vectors with FiniteLineT3 objects.

See also: FiniteLineT3

◆ FisheyeCamera

using Ocean::FisheyeCamera = typedef FisheyeCameraT<Scalar>

Definition of a FisheyeCamera object using Scalar as data type.

See also: FisheyeCameraT

◆ FisheyeCameraD

using Ocean::FisheyeCameraD = typedef FisheyeCameraT<double>

Definition of a FisheyeCamera object using 'double'' as data type.

See also: FisheyeCameraT

◆ FisheyeCameraF

using Ocean::FisheyeCameraF = typedef FisheyeCameraT<float>

Definition of a FisheyeCamera object using 'float'' as data type.

See also: FisheyeCameraT

◆ FisheyeCameras

using Ocean::FisheyeCameras = typedef std::vector<FisheyeCamera>

Definition of a vector holding camera objects.

◆ FisheyeCamerasT

template<typename T >

using Ocean::FisheyeCamerasT = typedef std::vector<FisheyeCameraT<T> >

Definition of a typename alias for vectors with FisheyeCameraT objects.

See also: FisheyeCameraT

◆ Frustum

using Ocean::Frustum = typedef FrustumT<Scalar>

Definition of a frustum.

See also: FrustumT

◆ FrustumD

using Ocean::FrustumD = typedef FrustumT<double>

Definition of a frustum with double values.

See also: FrustumT

◆ FrustumF

using Ocean::FrustumF = typedef FrustumT<float>

Definition of a frustum vector with float values.

See also: FrustumT

◆ Frustums

using Ocean::Frustums = typedef std::vector<Frustum>

Definition of a vector holding Frustum objects.

See also: Frustum

◆ FrustumsD

using Ocean::FrustumsD = typedef std::vector<FrustumD>

Definition of a vector holding FrustumD objects.

See also: FrustumD

◆ FrustumsF

using Ocean::FrustumsF = typedef std::vector<FrustumF>

Definition of a vector holding FrustumF objects.

See also: FrustumF

◆ FrustumsT

template<typename T >

using Ocean::FrustumsT = typedef std::vector<FrustumT<T> >

Definition of a typename alias for vectors with FrustumT objects.

See also: FrustumT

◆ GravityConstraints

using Ocean::Geometry::GravityConstraints = typedef GravityConstraintsT<Scalar>

Definition of the GravityConstraints object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

See also: GravityConstraintsT

◆ GravityConstraintsD

using Ocean::Geometry::GravityConstraintsD = typedef GravityConstraintsT<double>

Definition of the GravityConstraints object, using double floating point precision.

See also: GravityConstraintsT

◆ GravityConstraintsF

using Ocean::Geometry::GravityConstraintsF = typedef GravityConstraintsT<float>

Definition of the GravityConstraints object, using single floating point precision.

See also: GravityConstraintsT

◆ HomogenousMatrices4

using Ocean::HomogenousMatrices4 = typedef std::vector<HomogenousMatrix4>

Definition of a vector holding HomogenousMatrix4 objects.

See also: HomogenousMatrix4

◆ HomogenousMatricesD4

using Ocean::HomogenousMatricesD4 = typedef std::vector<HomogenousMatrixD4>

Definition of a vector holding HomogenousMatrixD4 objects.

◆ HomogenousMatricesF4

using Ocean::HomogenousMatricesF4 = typedef std::vector<HomogenousMatrixF4>

Definition of a vector holding HomogenousMatrixF4 objects.

◆ HomogenousMatricesT4

template<typename T >

using Ocean::HomogenousMatricesT4 = typedef std::vector<HomogenousMatrixT4<T> >

Definition of a typename alias for vectors with HomogenousMatrixT4 objects.

See also: HomogenousMatrixT4

◆ HomogenousMatrix4

using Ocean::HomogenousMatrix4 = typedef HomogenousMatrixT4<Scalar>

Definition of the HomogenousMatrix4 object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION flag either with single or double precision float data type.

See also: HomogenousMatrixT4

◆ HomogenousMatrixD4

using Ocean::HomogenousMatrixD4 = typedef HomogenousMatrixT4<double>

Instantiation of the HomogenousMatrixT4 template class using a double precision float data type.

See also: HomogenousMatrixT4

◆ HomogenousMatrixF4

using Ocean::HomogenousMatrixF4 = typedef HomogenousMatrixT4<float>

Instantiation of the HomogenousMatrixT4 template class using a float precision float data type.

See also: HomogenousMatrixT4

◆ HSVAColors

using Ocean::HSVAColors = typedef std::vector<HSVAColor>

Definition of a vector holding rgba color objects.

◆ InvalidCamera

using Ocean::InvalidCamera = typedef InvalidCameraT<Scalar>

Definition of an invalid camera object based with element precision 'Scalar'.

See also: AnyCameraT, AnyCameraInvalidT.

◆ InvalidCameraD

using Ocean::InvalidCameraD = typedef InvalidCameraT<double>

Definition of an invalid camera object based with element precision 'double'.

See also: AnyCameraT, AnyCameraInvalidT.

◆ InvalidCameraF

using Ocean::InvalidCameraF = typedef InvalidCameraT<float>

Definition of an invalid camera object based with element precision 'float'.

See also: AnyCameraT, AnyCameraInvalidT.

◆ Line2

using Ocean::Line2 = typedef LineT2<Scalar>

Definition of the Line2 object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

See also: LineT2

◆ Line3

using Ocean::Line3 = typedef LineT3<Scalar>

Definition of the Line3 object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

See also: LineT3

◆ LineD2

using Ocean::LineD2 = typedef LineT2<double>

Instantiation of the LineT2 template class using a double precision float data type.

See also: LineT2

◆ LineD3

using Ocean::LineD3 = typedef LineT3<double>

Instantiation of the LineT3 template class using a double precision float data type.

See also: LineT3

◆ LineF2

using Ocean::LineF2 = typedef LineT2<float>

Instantiation of the LineT2 template class using a single precision float data type.

See also: LineT2

◆ LineF3

using Ocean::LineF3 = typedef LineT3<float>

Instantiation of the LineT3 template class using a single precision float data type.

See also: LineT3

◆ Lines2

using Ocean::Lines2 = typedef std::vector<Line2>

Definition of a vector holding Line2 objects.

See also: Line2

◆ Lines3

using Ocean::Lines3 = typedef std::vector<Line3>

Definition of a vector holding Line3 objects.

See also: Line3

◆ LinesD2

using Ocean::LinesD2 = typedef std::vector<LineD2>

Definition of a vector holding Line2 objects with double precision float data type.

See also: LineD2

◆ LinesF2

using Ocean::LinesF2 = typedef std::vector<LineF2>

Definition of a vector holding Line2 objects with single precision float data type.

See also: LineF2

◆ LinesT2

template<typename T >

using Ocean::LinesT2 = typedef std::vector<LineT2<T> >

Definition of a typename alias for vectors with LineT2 objects.

See also: LineT2

◆ LinesT3

template<typename T >

using Ocean::LinesT3 = typedef std::vector<LineT3<T> >

Definition of a typename alias for vectors with LineT3 objects.

See also: LineT3

◆ Matrices

using Ocean::Matrices = typedef std::vector<Matrix>

Definition of a vector holding matrix objects.

See also: Matrix

◆ Matrix

using Ocean::Matrix = typedef MatrixT<Scalar>

Definition of the Matrix object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

See also: MatrixT

◆ MatrixD

using Ocean::MatrixD = typedef MatrixT<double>

Definition of the MatrixT template class using a double precision float data type.

See also: MatrixT

◆ MatrixF

using Ocean::MatrixF = typedef MatrixT<float>

Definition of the MatrixT template class using a single precision float data type.

See also: MatrixT

◆ Numeric

using Ocean::Numeric = typedef NumericT<Scalar>

Definition of a Numeric class.

See also: NumericT

◆ NumericD

using Ocean::NumericD = typedef NumericT<double>

Definition of a Numeric class with double values.

See also: NumericT

◆ NumericF

using Ocean::NumericF = typedef NumericT<float>

Definition of a Numeric class with float values.

See also: NumericT

◆ PinholeCamera

using Ocean::PinholeCamera = typedef PinholeCameraT<Scalar>

Definition of an pinhole camera object with Scalar precision.

See also: PinholeCameraT

◆ PinholeCameraD

using Ocean::PinholeCameraD = typedef PinholeCameraT<double>

Definition of an pinhole camera object with double precision.

See also: PinholeCameraT

◆ PinholeCameraF

using Ocean::PinholeCameraF = typedef PinholeCameraT<float>

Definition of an pinhole camera object with float precision.

See also: PinholeCameraT

◆ PinholeCameras

using Ocean::PinholeCameras = typedef PinholeCamerasT<Scalar>

Definition of a vector holding pinhole camera objects.

See also: PinholeCamera

◆ PinholeCamerasD

using Ocean::PinholeCamerasD = typedef PinholeCamerasT<double>

Definition of a vector holding PinholeCameraD objects.

See also: PinholeCameraD

◆ PinholeCamerasF

using Ocean::PinholeCamerasF = typedef PinholeCamerasT<float>

Definition of a vector holding PinholeCameraF objects.

See also: PinholeCameraF

◆ PinholeCamerasT

template<typename T >

using Ocean::PinholeCamerasT = typedef std::vector<PinholeCameraT<T> >

Definition of a typename alias for vectors with PinholeCameraT objects.

See also: PinholeCameraT

◆ Plane3

using Ocean::Plane3 = typedef PlaneT3<Scalar>

Definition of the Plane3 object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

See also: PlaneT3

◆ PlaneD3

using Ocean::PlaneD3 = typedef PlaneT3<double>

Definition of a 3D plane with double values.

See also: PlaneT3

◆ PlaneF3

using Ocean::PlaneF3 = typedef PlaneT3<float>

Definition of a 3D plane with float values.

See also: PlaneT3

◆ Planes3

using Ocean::Planes3 = typedef std::vector<Plane3>

Definition of a vector holding Plane3 objects.

See also: Plane3

◆ PlanesT3

template<typename T >

using Ocean::PlanesT3 = typedef std::vector<PlaneT3<T> >

Definition of a typename alias for vectors with PlaneT3 objects.

See also: PlaneT3

◆ Pose

using Ocean::Pose = typedef PoseT<Scalar>

Definition of the Pose object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION flag either with single or double precision float data type.

See also: PoseT

◆ PoseD

using Ocean::PoseD = typedef PoseT<double>

Instantiation of the ExponentialMapT template class using a double precision float data type.

See also: ExponentialMapT

◆ PoseF

using Ocean::PoseF = typedef PoseT<float>

Instantiation of the ExponentialMapT template class using a single precision float data type.

See also: ExponentialMapT

◆ Poses

using Ocean::Poses = typedef std::vector<Pose>

Definition of a vector holding ExponentialMap objects.

See also: ExponentialMap

◆ PosesT

template<typename T >

using Ocean::PosesT = typedef std::vector<PoseT<T> >

Definition of a typename alias for vectors with PoseT objects.

See also: PoseT

◆ Quaternion

using Ocean::Quaternion = typedef QuaternionT<Scalar>

Definition of the Quaternion object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

See also: QuaternionT

◆ QuaternionD

using Ocean::QuaternionD = typedef QuaternionT<double>

Instantiation of the QuaternionT template class using a double precision float data type.

See also: QuaternionT

◆ QuaternionF

using Ocean::QuaternionF = typedef QuaternionT<float>

Instantiation of the QuaternionT template class using a single precision float data type.

See also: QuaternionT

◆ Quaternions

using Ocean::Quaternions = typedef std::vector<Quaternion>

Definition of a vector holding quaternion objects.

See also: Quaternion

◆ QuaternionsD

using Ocean::QuaternionsD = typedef std::vector<QuaternionD>

Definition of a vector holding quaternion objects with double precision float data type.

See also: Quaternion

◆ QuaternionsF

using Ocean::QuaternionsF = typedef std::vector<QuaternionF>

Definition of a vector holding quaternion objects with single precision float data type.

See also: Quaternion

◆ QuaternionsT

template<typename T >

using Ocean::QuaternionsT = typedef std::vector<QuaternionT<T> >

Definition of a typename alias for vectors with QuaternionT objects.

See also: QuaternionT

◆ Random

using Ocean::Random = typedef RandomT<Scalar>

Definition of the Random object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

See also: RandomT

◆ RandomD

using Ocean::RandomD = typedef RandomT<double>

Instantiation of the RandomT template class using a double precision float data type.

See also: RandomT

◆ RandomF

using Ocean::RandomF = typedef RandomT<float>

Instantiation of the RandomT template class using a single precision float data type.

See also: RandomT

◆ RGBAColors

using Ocean::RGBAColors = typedef std::vector<RGBAColor>

Definition of a vector holding rgba color objects.

◆ Rotation

using Ocean::Rotation = typedef RotationT<Scalar>

Definition of the Rotation object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION flag either with single or double precision float data type.

See also: RotationT

◆ RotationD

using Ocean::RotationD = typedef RotationT<double>

Instantiation of the RotationT template class using a double precision float data type.

See also: RotationT

◆ RotationF

using Ocean::RotationF = typedef RotationT<float>

Instantiation of the RotationT template class using a single precision float data type.

See also: RotationT

◆ Rotations

using Ocean::Rotations = typedef std::vector<Rotation>

Definition of a vector holding rotation objects.

See also: Rotation

◆ RotationsT

template<typename T >

using Ocean::RotationsT = typedef std::vector<RotationT<T> >

Definition of a typename alias for vectors with RotationT objects.

See also: RotationT

◆ Scalar

typedef double Ocean::Scalar

Definition of a scalar type.

◆ Scalars

using Ocean::Scalars = typedef std::vector<Scalar>

Definition of a vector holding Scalar objects.

◆ SharedAnyCamera

using Ocean::SharedAnyCamera = typedef std::shared_ptr<AnyCamera>

Definition of a shared pointer holding an AnyCamera object with Scalar precision.

See also: AnyCameraT

◆ SharedAnyCameraD

using Ocean::SharedAnyCameraD = typedef std::shared_ptr<AnyCameraD>

Definition of a shared pointer holding an AnyCamera object with double precision.

See also: AnyCameraT

◆ SharedAnyCameraF

using Ocean::SharedAnyCameraF = typedef std::shared_ptr<AnyCameraF>

Definition of a shared pointer holding an AnyCamera object with float precision.

See also: AnyCameraT

◆ SharedAnyCameras

using Ocean::SharedAnyCameras = typedef SharedAnyCamerasT<Scalar>

Definition of a vector holding AnyCamera objects.

See also: AnyCamera

◆ SharedAnyCamerasD

using Ocean::SharedAnyCamerasD = typedef SharedAnyCamerasT<double>

Definition of a vector holding AnyCameraD objects.

See also: AnyCameraD

◆ SharedAnyCamerasF

using Ocean::SharedAnyCamerasF = typedef SharedAnyCamerasT<float>

Definition of a vector holding AnyCameraF objects.

See also: AnyCameraF

◆ SharedAnyCamerasT

template<typename T >

using Ocean::SharedAnyCamerasT = typedef std::vector<std::shared_ptr<AnyCameraT<T> >>

Definition of a typename alias for vectors with shared AnyCameraT objects.

Template Parameters

T	the data type of the scalar to be used either 'float' or 'double'

See also: VectorT2

◆ SharedAnyCameraT

template<typename T >

using Ocean::SharedAnyCameraT = typedef std::shared_ptr<AnyCameraT<T> >

Definition of a shared pointer holding an AnyCamera object with Scalar precision.

Template Parameters

T	the data type of the scalar to be used either 'float' or 'double'

See also: AnyCameraT

◆ SparseMatrices

using Ocean::SparseMatrices = typedef std::vector<SparseMatrix>

Definition of a vector holding sparse matrix objects.

See also: SparseMatrix

◆ SparseMatrix

using Ocean::SparseMatrix = typedef SparseMatrixT<Scalar>

Definition of the SparseMatrix object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

See also: SparseMatrixT

◆ SparseMatrixD

using Ocean::SparseMatrixD = typedef SparseMatrixT<double>

Instantiation of the SparseMatrixT template class using a double precision float data type.

See also: SparseMatrixT

◆ SparseMatrixF

using Ocean::SparseMatrixF = typedef SparseMatrixT<float>

Instantiation of the SparseMatrixT template class using a single precision float data type.

See also: SparseMatrixT

◆ Sphere3

using Ocean::Sphere3 = typedef SphereT3<Scalar>

Definition of the Sphere3 object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

See also: SphereT3

◆ SphereD3

using Ocean::SphereD3 = typedef SphereT3<double>

Definition of a 3D sphere with double values.

See also: SphereT3

◆ SphereF3

using Ocean::SphereF3 = typedef SphereT3<float>

Definition of a 3D sphere with float values.

See also: SphereT3

◆ Spheres3

using Ocean::Spheres3 = typedef std::vector<Sphere3>

Definition of a vector holding Shpere3 objects.

See also: Sphere3

◆ SquareMatrices2

using Ocean::SquareMatrices2 = typedef std::vector<SquareMatrix2>

Definition of a vector holding SquareMatrix2 objects.

See also: SquareMatrix2

◆ SquareMatrices3

using Ocean::SquareMatrices3 = typedef std::vector<SquareMatrix3>

Definition of a vector holding SquareMatrix3 objects.

See also: SquareMatrix3

◆ SquareMatrices4

using Ocean::SquareMatrices4 = typedef std::vector<SquareMatrix4>

Definition of a vector holding SquareMatrix4 objects.

See also: SquareMatrix4

◆ SquareMatricesT2

template<typename T >

using Ocean::SquareMatricesT2 = typedef std::vector<SquareMatrixT2<T> >

Definition of a typename alias for vectors with SquareMatrixT2 objects.

See also: SquareMatrixT2

◆ SquareMatricesT3

template<typename T >

using Ocean::SquareMatricesT3 = typedef std::vector<SquareMatrixT3<T> >

Definition of a typename alias for vectors with SquareMatrixT3 objects.

See also: SquareMatrixT3

◆ SquareMatricesT4

template<typename T >

using Ocean::SquareMatricesT4 = typedef std::vector<SquareMatrixT4<T> >

Definition of a typename alias for vectors with SquareMatrixT4 objects.

See also: SquareMatrixT4

◆ SquareMatrix2

using Ocean::SquareMatrix2 = typedef SquareMatrixT2<Scalar>

Definition of the SquareMatrix2 object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

See also: SquareMatrixT2

◆ SquareMatrix3

using Ocean::SquareMatrix3 = typedef SquareMatrixT3<Scalar>

Definition of the SquareMatrix3 object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

See also: SquareMatrixT3

◆ SquareMatrix4

using Ocean::SquareMatrix4 = typedef SquareMatrixT4<Scalar>

Definition of the SquareMatrix4 object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

See also: SquareMatrixT4

◆ SquareMatrixD2

using Ocean::SquareMatrixD2 = typedef SquareMatrixT2<double>

Instantiation of the SquareMatrixT2 template class using a double precision float data type.

See also: SquareMatrixT2

◆ SquareMatrixD3

using Ocean::SquareMatrixD3 = typedef SquareMatrixT3<double>

Instantiation of the SquareMatrixT3 template class using a double precision float data type.

See also: SquareMatrixT3

◆ SquareMatrixD4

using Ocean::SquareMatrixD4 = typedef SquareMatrixT4<double>

Instantiation of the SquareMatrixT4 template class using a double precision float data type.

See also: SquareMatrixT4

◆ SquareMatrixF2

using Ocean::SquareMatrixF2 = typedef SquareMatrixT2<float>

Instantiation of the SquareMatrixT2 template class using a single precision float data type.

See also: SquareMatrixT2

◆ SquareMatrixF3

using Ocean::SquareMatrixF3 = typedef SquareMatrixT3<float>

Instantiation of the SquareMatrixT3 template class using a single precision float data type.

See also: SquareMatrixT3

◆ SquareMatrixF4

using Ocean::SquareMatrixF4 = typedef SquareMatrixT4<float>

Instantiation of the SquareMatrixT4 template class using a double precision float data type.

See also: SquareMatrixT4

◆ Triangle

using Ocean::Triangle = typedef TriangleT<Scalar>

Definition of the Triangle object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

See also: TriangleT

◆ Triangle2

using Ocean::Triangle2 = typedef TriangleT2<Scalar>

Definition of the Triangle2 object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

See also: TriangleT2

◆ Triangle3

using Ocean::Triangle3 = typedef TriangleT3<Scalar>

Definition of the Triangle3 object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

See also: TriangleT3

◆ TriangleD

using Ocean::TriangleD = typedef TriangleT<double>

Instantiation of the TriangleT template class using a double precision float data type.

See also: TriangleT

◆ TriangleD2

using Ocean::TriangleD2 = typedef TriangleT2<double>

Instantiation of the TriangleT2 template class using a double precision float data type.

See also: TriangleT2

◆ TriangleD3

using Ocean::TriangleD3 = typedef TriangleT3<double>

Instantiation of the TriangleT3 template class using a double precision float data type.

See also: TriangleT3

◆ TriangleF

using Ocean::TriangleF = typedef TriangleT<float>

Instantiation of the TriangleT template class using a single precision float data type.

See also: TriangleT

◆ TriangleF2

using Ocean::TriangleF2 = typedef TriangleT2<float>

Instantiation of the TriangleT2 template class using a single precision float data type.

See also: TriangleT2

◆ TriangleF3

using Ocean::TriangleF3 = typedef TriangleT3<float>

Instantiation of the TriangleT3 template class using a single precision float data type.

See also: TriangleT3

◆ Triangles2

using Ocean::Triangles2 = typedef std::vector<Triangle2>

Definition of a vector holding 2D triangles.

See also: Triangle2

◆ Triangles3

using Ocean::Triangles3 = typedef std::vector<Triangle3>

Definition of a vector holding 3D triangles.

See also: Triangle3

◆ TrianglesD2

using Ocean::TrianglesD2 = typedef std::vector<TriangleD2>

Definition of a vector holding 2D triangles with double precision float data type.

See also: Triangle2

◆ TrianglesD3

using Ocean::TrianglesD3 = typedef std::vector<TriangleD3>

Definition of a vector holding 3D triangles with double precision float data type.

See also: Triangle3

◆ TrianglesF2

using Ocean::TrianglesF2 = typedef std::vector<TriangleF2>

Definition of a vector holding 2D triangles with single precision float data type.

See also: Triangle2

◆ TrianglesF3

using Ocean::TrianglesF3 = typedef std::vector<TriangleF3>

Definition of a vector holding 3D triangles with single precision float data type.

See also: Triangle3

◆ TrianglesT2

template<typename T >

using Ocean::TrianglesT2 = typedef std::vector<TriangleT2<T> >

Definition of a typename alias for vectors with TriangleT2 objects.

See also: TriangleT2

◆ TrianglesT3

template<typename T >

using Ocean::TrianglesT3 = typedef std::vector<TriangleT3<T> >

Definition of a typename alias for vectors with TriangleT3 objects.

See also: TriangleT3

◆ Variance

using Ocean::Variance = typedef VarianceT<Scalar>

Definition of a variance object, depending on the OCEAN_MATH_USE_SINGLE_PRECISION either with single or double precision float data type.

See also: VarianceT

◆ VarianceD

using Ocean::VarianceD = typedef VarianceT<double>

Definition of a variance object with double values.

See also: VarianceT

◆ VarianceF

using Ocean::VarianceF = typedef VarianceT<float>

Definition of a variance object with float values.

See also: VarianceT

◆ Variances

using Ocean::Variances = typedef std::vector<Variance>

Definition of a vector holding variance objects.

See also: Variance

◆ Vector2

using Ocean::Vector2 = typedef VectorT2<Scalar>

Definition of a 2D vector.

See also: VectorT2

◆ Vector3

using Ocean::Vector3 = typedef VectorT3<Scalar>

Definition of a 3D vector.

See also: VectorT3

◆ Vector4

using Ocean::Vector4 = typedef VectorT4<Scalar>

Definition of a 4D vector.

See also: VectorT4

◆ VectorD2

using Ocean::VectorD2 = typedef VectorT2<double>

Definition of a 2D vector with double values.

See also: VectorT2

◆ VectorD3

using Ocean::VectorD3 = typedef VectorT3<double>

Definition of a 3D vector with double values.

See also: VectorT3

◆ VectorD4

using Ocean::VectorD4 = typedef VectorT4<double>

Definition of a 4D vector with double values.

See also: VectorT4

◆ VectorF2

using Ocean::VectorF2 = typedef VectorT2<float>

Definition of a 2D vector with float values.

See also: VectorT2

◆ VectorF3

using Ocean::VectorF3 = typedef VectorT3<float>

Definition of a 3D vector with float values.

See also: VectorT3

◆ VectorF4

using Ocean::VectorF4 = typedef VectorT4<float>

Definition of a 4D vector with float values.

See also: VectorT4

◆ VectorI2

using Ocean::VectorI2 = typedef VectorT2<int>

Definition of a 2D vector with integer values.

See also: VectorT2

◆ VectorI3

using Ocean::VectorI3 = typedef VectorT3<int>

Definition of a 3D vector with integer values.

See also: VectorT3

◆ VectorI4

using Ocean::VectorI4 = typedef VectorT4<int>

Definition of a 4D vector with integer values.

See also: VectorT4

◆ Vectors2

using Ocean::Vectors2 = typedef std::vector<Vector2>

Definition of a vector holding Vector2 objects.

See also: Vector2

◆ Vectors3

using Ocean::Vectors3 = typedef std::vector<Vector3>

Definition of a vector holding Vector3 objects.

See also: Vector3

◆ Vectors4

using Ocean::Vectors4 = typedef std::vector<Vector4>

Definition of a vector holding Vector4 objects.

See also: Vector4

◆ VectorsD2

using Ocean::VectorsD2 = typedef std::vector<VectorD2>

Definition of a vector holding VectorD2 objects.

See also: VectorD2

◆ VectorsD3

using Ocean::VectorsD3 = typedef std::vector<VectorD3>

Definition of a vector holding VectorD3 objects.

See also: VectorD3

◆ VectorsD4

using Ocean::VectorsD4 = typedef std::vector<VectorD4>

Definition of a vector holding VectorD4 objects.

See also: VectorD4

◆ VectorsF2

using Ocean::VectorsF2 = typedef std::vector<VectorF2>

Definition of a vector holding VectorF2 objects.

See also: VectorF2

◆ VectorsF3

using Ocean::VectorsF3 = typedef std::vector<VectorF3>

Definition of a vector holding VectorF3 objects.

See also: VectorF3

◆ VectorsF4

using Ocean::VectorsF4 = typedef std::vector<VectorF4>

Definition of a vector holding VectorF4 objects.

See also: VectorF4

◆ VectorsI2

using Ocean::VectorsI2 = typedef std::vector<VectorI2>

Definition of a vector holding VectorI2 objects.

See also: VectorI2

◆ VectorsI3

using Ocean::VectorsI3 = typedef std::vector<VectorI3>

Definition of a vector holding VectorI3 objects.

See also: VectorI3

◆ VectorsI4

using Ocean::VectorsI4 = typedef std::vector<VectorI4>

Definition of a vector holding VectorI4 objects.

See also: VectorI4

◆ VectorsT2

template<typename T >

using Ocean::VectorsT2 = typedef std::vector<VectorT2<T> >

Definition of a typename alias for vectors with VectorT2 objects.

See also: VectorT2

◆ VectorsT3

template<typename T >

using Ocean::VectorsT3 = typedef std::vector<VectorT3<T> >

Definition of a typename alias for vectors with VectorT3 objects.

See also: VectorT3

◆ VectorsT4

template<typename T >

using Ocean::VectorsT4 = typedef std::vector<VectorT4<T> >

Definition of a typename alias for vectors with VectorT4 objects.

See also: VectorT4

Enumeration Type Documentation

◆ AnyCameraType

enum class Ocean::AnyCameraType : uint32_t

strong

Definition of individual camera types.

Enumerator
INVALID	An invalid camera type.
PINHOLE	A pinhole camera.
FISHEYE	A fisheye camera.

Data Structures

Typedefs

Enumerations

Detailed Description

Typedef Documentation

◆ AnyCamera

◆ AnyCameraD

◆ AnyCameraF

◆ AnyCameraFisheye

◆ AnyCameraFisheyeD

◆ AnyCameraFisheyeF

◆ AnyCameraFisheyeT

◆ AnyCameraInvalid

◆ AnyCameraInvalidD

◆ AnyCameraInvalidF

◆ AnyCameraInvalidT

◆ AnyCameraPinhole

◆ AnyCameraPinholeD

◆ AnyCameraPinholeF

◆ AnyCameraPinholeT

◆ AutomaticDifferentiation

◆ AutomaticDifferentiationD

◆ AutomaticDifferentiationF

◆ Box2

◆ Box3

◆ BoxD2

◆ BoxD3

◆ Boxes2

◆ Boxes3

◆ BoxesT2

◆ BoxesT3

◆ BoxF2

◆ BoxF3

◆ Camera

◆ CameraD

◆ CameraF

◆ CameraProjectionChecker

◆ CameraProjectionCheckerD

◆ CameraProjectionCheckerF

◆ Complex

◆ ComplexD

◆ Complexes

◆ ComplexF

◆ Cone3

◆ ConeD3

◆ ConeF3

◆ Cones3

◆ Cylinder3

◆ CylinderD3

◆ CylinderF3

◆ Cylinders3

◆ Equation

◆ EquationD

◆ EquationF

◆ Euler

◆ EulerD

◆ EulerF

◆ Eulers

◆ EulersT

◆ ExponentialMap

◆ ExponentialMapD

◆ ExponentialMapF

◆ ExponentialMaps

◆ ExponentialMapsT

◆ FiniteLine2

◆ FiniteLine3

◆ FiniteLineD2

◆ FiniteLineD3

◆ FiniteLineF2

◆ FiniteLineF3

◆ FiniteLines2

◆ FiniteLines3

◆ FiniteLinesD2

◆ FiniteLinesF2

◆ FiniteLinesT2

◆ FiniteLinesT3

◆ FisheyeCamera

◆ FisheyeCameraD

◆ FisheyeCameraF

◆ FisheyeCameras