This class implements the base class for all cameras. More...

Inheritance diagram for Ocean::CameraT< T >:

Static Public Member Functions
static T	fovX2Y (const T fovX, const T aspectRatio)
	Calculates the vertical FOV from the horizontal FOV and the aspect ratio of the camera image. More...

static T	fovY2X (const T fovY, const T aspectRatio)
	Calculates the horizontal FOV from the vertical FOV and the aspect ratio of the camera image. More...

static T	fieldOfViewToFocalLength (const unsigned int width, const T fovX)
	Converts field of view (and width) to the corresponding focal length. More...

static VectorT2< T >	objectPoint2normalizedImagePoint (const HomogenousMatrixT4< T > &extrinsic, const VectorT3< T > &objectPoint)
	Calculates the normalized image point (the normalized projected object point) for a of given object point with corresponding extrinsic camera matrix. More...

static VectorT2< T >	objectPoint2normalizedImagePointIF (const HomogenousMatrixT4< T > &iFlippedExtrinsic, const VectorT3< T > &objectPoint)
	Calculates the normalized image point (the normalized projected object point) for a given object point with corresponding inverse and flipped extrinsic camera matrix. More...

static void	objectPoints2normalizedImagePoints (const HomogenousMatrixT4< T > &extrinsic, const VectorT3< T > objectPoints, const size_t numberObjectPoints, VectorT2< T > normalizedImagePoints)
	Calculates the normalized image points (the normalized projected object points) for a set of given object points with corresponding extrinsic camera matrix. More...

static void	objectPoints2normalizedImagePointsIF (const HomogenousMatrixT4< T > &iFlippedExtrinsic, const VectorT3< T > objectPoints, const size_t numberObjectPoints, VectorT2< T > normalizedImagePoints)
	Calculates the normalized image points (the normalized projected object points) for a set of given object points with corresponding inverse and flipped extrinsic camera matrix. More...

template<typename U = T>
static SquareMatrixT3< U >	flipMatrix3 ()
	Returns the 3x3 transformation matrix flipping a transformation around the x-axis by 180 deg. More...

template<typename U = T>
static HomogenousMatrixT4< U >	flipMatrix4 ()
	Returns the 4x4 transformation matrix flipping a transformation around the x-axis by 180 deg. More...

template<typename U = T>
static QuaternionT< U >	flipQuaternion ()
	Returns the quaternion flipping a rotation around the x-axis by 180 deg. More...

template<typename U >
static HomogenousMatrixT4< U >	flippedTransformationLeftSide (const HomogenousMatrixT4< U > &left_T_right)
	Flips a transformation matrix around the x-axis by 180 degree. More...

template<typename U >
static HomogenousMatrixT4< U >	flippedTransformationRightSide (const HomogenousMatrixT4< U > &left_T_right)
	Flips a transformation matrix around the x-axis by 180 degree. More...

template<typename U >
static HomogenousMatrixT4< U >	flippedTransformationLeftAndRightSide (const HomogenousMatrixT4< U > &left_T_right)
	Flips a transformation matrix around the x-axis by 180 degree. More...

template<typename U >
static SquareMatrixT3< U >	flippedTransformationLeftSide (const SquareMatrixT3< U > &left_R_right)
	Flips a 3x3 rotation matrix around the x-axis by 180 degree. More...

template<typename U >
static SquareMatrixT3< U >	flippedTransformationRightSide (const SquareMatrixT3< U > &left_R_right)
	Flips a 3x3 rotation matrix around the x-axis by 180 degree. More...

template<typename U >
static SquareMatrixT3< U >	flippedTransformationLeftAndRightSide (const SquareMatrixT3< U > &left_R_right)
	Flips a 3x3 rotation matrix around the x-axis by 180 degree. More...

template<typename U >
static QuaternionT< U >	flippedTransformationLeftSide (const QuaternionT< U > &left_Q_right)
	Flips a quaternion around the x-axis by 180 degree. More...

template<typename U >
static QuaternionT< U >	flippedTransformationRightSide (const QuaternionT< U > &left_Q_right)
	Flips a quaternion around the x-axis by 180 degree. More...

template<typename U >
static QuaternionT< U >	flippedTransformationLeftAndRightSide (const QuaternionT< U > &left_Q_right)
	Flips a quaternion around the x-axis by 180 degree. More...

template<typename U >
static HomogenousMatrixT4< U >	standard2InvertedFlipped (const HomogenousMatrixT4< U > &world_T_camera)
	Transforms a standard homogenous 4x4 viewing (extrinsic camera) matrix into an inverted and flipped camera pose. More...

template<typename U >
static HomogenousMatricesT4< U >	standard2InvertedFlipped (const HomogenousMatrixT4< U > *world_T_cameras, const size_t number)
	Transforms standard homogenous 4x4 viewing (extrinsic camera) matrices into an inverted and flipped camera matrices. More...

template<typename U >
static void	standard2InvertedFlipped (const HomogenousMatrixT4< U > world_T_cameras, HomogenousMatrixT4< U > flippedCameras_T_world, const size_t number)
	Transforms standard homogenous 4x4 viewing (extrinsic camera) matrices into an inverted and flipped camera matrices. More...

template<typename U >
static HomogenousMatricesT4< U >	standard2InvertedFlipped (const HomogenousMatricesT4< U > &world_T_cameras)
	Transforms standard homogenous 4x4 viewing (extrinsic camera) matrices into an inverted and flipped camera matrices. More...

template<typename U >
static SquareMatrixT3< U >	standard2InvertedFlipped (const SquareMatrixT3< U > &world_R_camera)
	Transforms a standard 3x3 rotation matrix into an inverted and flipped rotation matrix. More...

template<typename U >
static QuaternionT< U >	standard2InvertedFlipped (const QuaternionT< U > &world_Q_camera)
	Transforms a standard rotation quaternion into an inverted and flipped rotation quaternion. More...

template<typename U >
static HomogenousMatrixT4< U >	invertedFlipped2Standard (const HomogenousMatrixT4< U > &flippedCamera_T_world)
	Transforms an inverted and flipped camera pose into a standard camera pose. More...

template<typename U >
static HomogenousMatricesT4< U >	invertedFlipped2Standard (const HomogenousMatrixT4< U > *flippedCameras_T_world, const size_t number)
	Transforms inverted and flipped camera matrices into standard viewing (extrinsic camera) matrices. More...

template<typename U >
static void	invertedFlipped2Standard (const HomogenousMatrixT4< U > flippedCameras_T_world, HomogenousMatrixT4< U > world_T_cameras, const size_t number)
	Transforms inverted and flipped camera matrices into standard viewing (extrinsic camera) matrices. More...

template<typename U >
static HomogenousMatricesT4< U >	invertedFlipped2Standard (const HomogenousMatricesT4< U > &flippedCameras_T_world)
	Transforms inverted and flipped camera matrices into standard viewing (extrinsic camera) matrices. More...

template<typename U >
static SquareMatrixT3< U >	invertedFlipped2Standard (const SquareMatrixT3< U > &flippedCamera_R_world)
	Transforms an inverted and flipped rotation matrix into a standard viewing rotation matrix. More...

template<typename U >
static QuaternionT< U >	invertedFlipped2Standard (const QuaternionT< U > &flippedCamera_Q_world)
	Transforms an inverted and flipped rotation quaternion into a standard viewing rotation quaternion. More...

static bool	isObjectPointInFrontIF (const HomogenousMatrixT4< T > &flippedCamera_T_world, const VectorT3< T > &objectPoint, const T epsilon=NumericT< T >::eps())
	Determines whether a given 3D object point lies in front of a camera while the location of the camera is defined by a 6-DOF pose. More...

static bool	isObjectPointInFrontIF (const SquareMatrixT3< T > &flippedCamera_R_world, const VectorT3< T > &objectPoint, const T epsilon=NumericT< T >::eps())
	Determines whether a given 3D object point lies in front of a camera while the location of the camera is defined by a 3-DOF orientation. More...

Detailed Description

template<typename T>
class Ocean::CameraT< T >

This class implements the base class for all cameras.

The base class provides model independent functionalities.
Use AnyCamera in case an entire camera model is needed.

Template Parameters

T	The data type of a scalar, 'float' or 'double'

Member Function Documentation

◆ fieldOfViewToFocalLength()

template<typename T >

T Ocean::CameraT< T >::fieldOfViewToFocalLength	(	const unsigned int	width,
		const T	fovX
	)

static

Converts field of view (and width) to the corresponding focal length.

Parameters

width	The width of the camera in pixel, with range [1, infinity)
fovX	The horizontal field of view of the camera, in radian, with range (0, PI)

Returns: The focal length of the camera, with range (0, infinity)

◆ flipMatrix3()

template<typename T >

template<typename U >

SquareMatrixT3 Ocean::CameraT< T >::flipMatrix3

inlinestatic

Returns the 3x3 transformation matrix flipping a transformation around the x-axis by 180 deg.

The matrix is defined by an angle-axis rotation: Rotation(1, 0, 0, PI).

Returns: The transformation matrix

Template Parameters

U	The data type of the elements of the matrix

See also: flipMatrix4(), flipQuaternion().

◆ flipMatrix4()

template<typename T >

template<typename U >

HomogenousMatrixT4 Ocean::CameraT< T >::flipMatrix4

inlinestatic

Returns the 4x4 transformation matrix flipping a transformation around the x-axis by 180 deg.

The matrix is defined by an angle-axis rotation: Rotation(1, 0, 0, PI).

Returns: The transformation matrix

Template Parameters

U	The data type of the elements of the matrix

See also: flipMatrix3(), flipQuaternion().

◆ flippedTransformationLeftAndRightSide() [1/3]

template<typename T >

template<typename U >

HomogenousMatrixT4 Ocean::CameraT< T >::flippedTransformationLeftAndRightSide ( const HomogenousMatrixT4 & left_T_right )

inlinestatic

Flips a transformation matrix around the x-axis by 180 degree.

The flip transformation is applied at the left and right side of the original matrix.

Parameters

left_T_right The transformation matrix to flip, must be valid

Returns: The flipped transformation matrix, will be flippedLeft_T_flippedRight

Template Parameters

U	The data type of the elements of the matrix

◆ flippedTransformationLeftAndRightSide() [2/3]

template<typename T >

template<typename U >

QuaternionT Ocean::CameraT< T >::flippedTransformationLeftAndRightSide ( const QuaternionT & left_Q_right )

inlinestatic

Flips a quaternion around the x-axis by 180 degree.

The flip transformation is applied at the left and right side of the original rotation.

Parameters

left_Q_right The quaternion to flip, must be valid

Returns: The flipped quaternion, will be flippedLeft_Q_flippedRight

Template Parameters

U	The data type of the elements of the quaternion

◆ flippedTransformationLeftAndRightSide() [3/3]

template<typename T >

template<typename U >

SquareMatrixT3 Ocean::CameraT< T >::flippedTransformationLeftAndRightSide ( const SquareMatrixT3 & left_R_right )

inlinestatic

Flips a 3x3 rotation matrix around the x-axis by 180 degree.

The flip transformation is applied at the left and right side of the original rotation.

Parameters

left_R_right The rotation matrix to flip, must be valid

Returns: The flipped rotation, will be flippedLeft_R_flippedRight

Template Parameters

U	The data type of the elements of the rotation

◆ flippedTransformationLeftSide() [1/3]

template<typename T >

template<typename U >

HomogenousMatrixT4 Ocean::CameraT< T >::flippedTransformationLeftSide ( const HomogenousMatrixT4 & left_T_right )

inlinestatic

Flips a transformation matrix around the x-axis by 180 degree.

The flip transformation is applied at the left side of the given matrix.

Parameters

left_T_right The transformation matrix to flip, must be valid

Returns: The flipped transformation matrix, will be flippedLeft_T_right

Template Parameters

U	The data type of the elements of the matrix

◆ flippedTransformationLeftSide() [2/3]

template<typename T >

template<typename U >

QuaternionT Ocean::CameraT< T >::flippedTransformationLeftSide ( const QuaternionT & left_Q_right )

inlinestatic

Flips a quaternion around the x-axis by 180 degree.

The flip transformation is applied at the left side of the original rotation.

Parameters

left_Q_right The quaternion to flip, must be valid

Returns: The flipped quaternion, will be flippedLeft_Q_right

Template Parameters

U	The data type of the elements of the quaternion

◆ flippedTransformationLeftSide() [3/3]

template<typename T >

template<typename U >

SquareMatrixT3 Ocean::CameraT< T >::flippedTransformationLeftSide ( const SquareMatrixT3 & left_R_right )

inlinestatic

Flips a 3x3 rotation matrix around the x-axis by 180 degree.

The flip transformation is applied at the left side of the original rotation.

Parameters

left_R_right The rotation matrix to flip, must be valid

Returns: The flipped rotation, will be flippedLeft_R_right

Template Parameters

U	The data type of the elements of the rotation

◆ flippedTransformationRightSide() [1/3]

template<typename T >

template<typename U >

HomogenousMatrixT4 Ocean::CameraT< T >::flippedTransformationRightSide ( const HomogenousMatrixT4 & left_T_right )

inlinestatic

Flips a transformation matrix around the x-axis by 180 degree.

The flip transformation is applied at the right side of the given matrix.

Parameters

left_T_right The transformation matrix to flip, must be valid

Returns: The flipped transformation matrix, will be left_T_flippedRight

Template Parameters

U	The data type of the elements of the matrix

◆ flippedTransformationRightSide() [2/3]

template<typename T >

template<typename U >

QuaternionT Ocean::CameraT< T >::flippedTransformationRightSide ( const QuaternionT & left_Q_right )

inlinestatic

Flips a quaternion around the x-axis by 180 degree.

The flip transformation is applied at the right side of the original rotation.

Parameters

left_Q_right The quaternion to flip, must be valid

Returns: The flipped quaternion, will be left_Q_flippedRight

Template Parameters

U	The data type of the elements of the quaternion

◆ flippedTransformationRightSide() [3/3]

template<typename T >

template<typename U >

SquareMatrixT3 Ocean::CameraT< T >::flippedTransformationRightSide ( const SquareMatrixT3 & left_R_right )

inlinestatic

Flips a 3x3 rotation matrix around the x-axis by 180 degree.

The flip transformation is applied at the right side of the original rotation.

Parameters

left_R_right The rotation matrix to flip, must be valid

Returns: The flipped rotation, will be left_R_flippedRight

Template Parameters

U	The data type of the elements of the rotation

◆ flipQuaternion()

template<typename T >

template<typename U >

QuaternionT Ocean::CameraT< T >::flipQuaternion

inlinestatic

Returns the quaternion flipping a rotation around the x-axis by 180 deg.

The quaternion is defined by an angle-axis rotation: Rotation(1, 0, 0, PI).

Returns: The transformation quaternion

Template Parameters

U	The data type of the elements of the quaternion

See also: flipMatrix3(), flipMatrix4().

◆ fovX2Y()

template<typename T >

T Ocean::CameraT< T >::fovX2Y	(	const T	fovX,
		const T	aspectRatio
	)

static

Calculates the vertical FOV from the horizontal FOV and the aspect ratio of the camera image.

Parameters

fovX	The given field of view in x direction (in radian), with range (0, PI)
aspectRatio	The aspect ratio of the camera (width / height)

Returns: The field of view in y direction (in radian)

◆ fovY2X()

template<typename T >

T Ocean::CameraT< T >::fovY2X	(	const T	fovY,
		const T	aspectRatio
	)

static

Calculates the horizontal FOV from the vertical FOV and the aspect ratio of the camera image.

Parameters

fovY	The given field of view in y direction (in radian), with range (0, PI)
aspectRatio	The aspect ratio of the camera (width / height)

Returns: The field of view in x direction (in radian)

◆ invertedFlipped2Standard() [1/6]

template<typename T >

template<typename U >

HomogenousMatricesT4 Ocean::CameraT< T >::invertedFlipped2Standard ( const HomogenousMatricesT4 & flippedCameras_T_world )

inlinestatic

Transforms inverted and flipped camera matrices into standard viewing (extrinsic camera) matrices.

Parameters

flippedCameras_T_world The inverted and flipped camera poses to transform

Returns: The standard camera poses, world_T_cameras

Template Parameters

U	The data type of the elements of the matrix

See also: standard2InvertedFlipped().

◆ invertedFlipped2Standard() [2/6]

template<typename T >

template<typename U >

HomogenousMatrixT4 Ocean::CameraT< T >::invertedFlipped2Standard ( const HomogenousMatrixT4 & flippedCamera_T_world )

inlinestatic

Transforms an inverted and flipped camera pose into a standard camera pose.

Parameters

flippedCamera_T_world The inverted and flipped camera pose to transform, must be valid

Returns: The standard camera pose, world_T_camera

Template Parameters

U	The data type of the elements of the matrix

See also: standard2InvertedFlipped().

◆ invertedFlipped2Standard() [3/6]

template<typename T >

template<typename U >

HomogenousMatricesT4< U > Ocean::CameraT< T >::invertedFlipped2Standard	(	const HomogenousMatrixT4< U > *	flippedCameras_T_world,
		const size_t	number
	)

inlinestatic

Transforms inverted and flipped camera matrices into standard viewing (extrinsic camera) matrices.

Parameters

flippedCameras_T_world	The inverted and flipped camera poses to transform, can be nullptr if number == 0
number	The number of poses, with range [0, infinity)

Returns: The standard viewing poses, world_T_cameras

Template Parameters

U	The data type of the elements of the matrix

See also: standard2InvertedFlipped().

◆ invertedFlipped2Standard() [4/6]

template<typename T >

template<typename U >

void Ocean::CameraT< T >::invertedFlipped2Standard	(	const HomogenousMatrixT4< U > *	flippedCameras_T_world,
		HomogenousMatrixT4< U > *	world_T_cameras,
		const size_t	number
	)

inlinestatic

Transforms inverted and flipped camera matrices into standard viewing (extrinsic camera) matrices.

Parameters

flippedCameras_T_world	The inverted and flipped camera poses to transform, can be nullptr if number == 0
world_T_cameras	The resulting standard camera poses, can be nullptr if number == 0
number	The number of poses, with range [0, infinity)

Template Parameters

U	The data type of the elements of the matrix

See also: standard2InvertedFlipped().

◆ invertedFlipped2Standard() [5/6]

template<typename T >

template<typename U >

QuaternionT Ocean::CameraT< T >::invertedFlipped2Standard ( const QuaternionT & flippedCamera_Q_world )

inlinestatic

Transforms an inverted and flipped rotation quaternion into a standard viewing rotation quaternion.

Parameters

flippedCamera_Q_world The inverted and flipped rotation quaternion of camera pose to transform

Returns: The rotation quaternion of standard camera pose, world_Q_camera

Template Parameters

U	The data type of the elements of the quaternion

See also: standard2InvertedFlipped().

◆ invertedFlipped2Standard() [6/6]

template<typename T >

template<typename U >

SquareMatrixT3 Ocean::CameraT< T >::invertedFlipped2Standard ( const SquareMatrixT3 & flippedCamera_R_world )

inlinestatic

Transforms an inverted and flipped rotation matrix into a standard viewing rotation matrix.

Parameters

flippedCamera_R_world The inverted and flipped rotation matrix of camera to transform, must be valid

Returns: The rotation matrix of standard camera pose, world_R_camera

Template Parameters

U	The data type of the elements of the matrix

See also: standard2InvertedFlipped().

◆ isObjectPointInFrontIF() [1/2]

template<typename T >

bool Ocean::CameraT< T >::isObjectPointInFrontIF	(	const HomogenousMatrixT4< T > &	flippedCamera_T_world,
		const VectorT3< T > &	objectPoint,
		const T	epsilon = `NumericT<T>::eps()`
	)

inlinestatic

Determines whether a given 3D object point lies in front of a camera while the location of the camera is defined by a 6-DOF pose.

This function actually determined whether (iFlippedPose * objectPoint).z() > epsilon.

Parameters

flippedCamera_T_world	The inverted and flipped pose of the camera, must be valid
objectPoint	The object point to check
epsilon	The minimal distance between camera and object point on the z-axis so that the object point counts as lying in front, with range [0, infinity)

Returns: True, if so

◆ isObjectPointInFrontIF() [2/2]

template<typename T >

bool Ocean::CameraT< T >::isObjectPointInFrontIF	(	const SquareMatrixT3< T > &	flippedCamera_R_world,
		const VectorT3< T > &	objectPoint,
		const T	epsilon = `NumericT<T>::eps()`
	)

inlinestatic

Determines whether a given 3D object point lies in front of a camera while the location of the camera is defined by a 3-DOF orientation.

This function actually determined whether (iFlippedPose * objectPoint).z() > epsilon.

Parameters

flippedCamera_R_world	The inverted and flipped orientation of the camera, must be valid
objectPoint	The object point to check
epsilon	The minimal distance between camera and object point on the z-axis so that the object point counts as lying in front, with range [0, infinity)

Returns: True, if so

◆ objectPoint2normalizedImagePoint()

template<typename T >

VectorT2< T > Ocean::CameraT< T >::objectPoint2normalizedImagePoint	(	const HomogenousMatrixT4< T > &	extrinsic,
		const VectorT3< T > &	objectPoint
	)

inlinestatic

Calculates the normalized image point (the normalized projected object point) for a of given object point with corresponding extrinsic camera matrix.

The extrinsic matrix transforms a 3D point given in camera coordinates into 3D world coordinates.
The viewing direction of the camera is along the negative z-axis.
The extrinsic matrix will be flipped and inverted internally.

Parameters

extrinsic	The extrinsic camera matrix
objectPoint	The 3D object point for that the normalized image point will be calculated

Returns: The resulting normalized image point

See also: objectPoints2normalizedImagePoints().

◆ objectPoint2normalizedImagePointIF()

template<typename T >

VectorT2< T > Ocean::CameraT< T >::objectPoint2normalizedImagePointIF	(	const HomogenousMatrixT4< T > &	iFlippedExtrinsic,
		const VectorT3< T > &	objectPoint
	)

inlinestatic

Calculates the normalized image point (the normalized projected object point) for a given object point with corresponding inverse and flipped extrinsic camera matrix.

The inverse extrinsic matrix transforms a 3D point given in world coordinates into 3D camera coordinates.
The coordinate system of the camera is flipped meaning that the viewing direction is along the positive z-axis.
The flipped coordinate system can be received by a rotation around the x-axis by 180 degree.

Parameters

iFlippedExtrinsic	The inverted and flipped extrinsic camera matrix
objectPoint	The 3D object point for that the normalized image point will be calculated

Returns: The resulting normalized image point

See also: objectPoint2normalizedImagePoint().

◆ objectPoints2normalizedImagePoints()

template<typename T >

void Ocean::CameraT< T >::objectPoints2normalizedImagePoints	(	const HomogenousMatrixT4< T > &	extrinsic,
		const VectorT3< T > *	objectPoints,
		const size_t	numberObjectPoints,
		VectorT2< T > *	normalizedImagePoints
	)

inlinestatic

Calculates the normalized image points (the normalized projected object points) for a set of given object points with corresponding extrinsic camera matrix.

The extrinsic matrix transforms a 3D point given in camera coordinates into 3D world coordinates.
The viewing direction of the camera is along the negative z-axis.
The extrinsic matrix will be flipped and inverted internally.

Parameters

extrinsic	The extrinsic camera matrix
objectPoints	The set of 3D object points for that the normalized image points will be calculated
numberObjectPoints	The number of object points to project
normalizedImagePoints	The resulting normalized image points, make sure that enough memory is provided

See also: objectPoint2normalizedImagePoint(), objectPoints2normalizedImagePointsIF().

◆ objectPoints2normalizedImagePointsIF()

template<typename T >

void Ocean::CameraT< T >::objectPoints2normalizedImagePointsIF	(	const HomogenousMatrixT4< T > &	iFlippedExtrinsic,
		const VectorT3< T > *	objectPoints,
		const size_t	numberObjectPoints,
		VectorT2< T > *	normalizedImagePoints
	)

static

Calculates the normalized image points (the normalized projected object points) for a set of given object points with corresponding inverse and flipped extrinsic camera matrix.

The inverse extrinsic matrix transforms a 3D point given in world coordinates into 3D camera coordinates.
The coordinate system of the camera is flipped meaning that the viewing direction is along the positive z-axis.
The flipped coordinate system can be received by a rotation around the x-axis by 180 degree.

Parameters

iFlippedExtrinsic	The inverted and flipped extrinsic camera matrix
objectPoints	The set of 3D object points for that the normalized image points will be calculated
numberObjectPoints	The number of object points to project
normalizedImagePoints	The resulting normalized image points, make sure that enough memory is provided

See also: objectPoints2normalizedImagePoints().

◆ standard2InvertedFlipped() [1/6]

template<typename T >

template<typename U >

HomogenousMatricesT4 Ocean::CameraT< T >::standard2InvertedFlipped ( const HomogenousMatricesT4 & world_T_cameras )

inlinestatic

Transforms standard homogenous 4x4 viewing (extrinsic camera) matrices into an inverted and flipped camera matrices.

The standard matrix defines a coordinate system with negative Z-axis as viewing direction in relation to the world coordinate system.
The inverted and flipped camera pose defines a coordinate system with positive Z-axis as viewing direction and transforms the world in relation to the camera coordinate system.

Parameters

world_T_cameras The standard camera poses to transform

Returns: The inverted and flipped camera poses, flippedCameras_T_world

Template Parameters

U	The data type of the elements of the matrix

See also: invertedFlipped2Standard().

◆ standard2InvertedFlipped() [2/6]

template<typename T >

template<typename U >

HomogenousMatrixT4 Ocean::CameraT< T >::standard2InvertedFlipped ( const HomogenousMatrixT4 & world_T_camera )

inlinestatic

Transforms a standard homogenous 4x4 viewing (extrinsic camera) matrix into an inverted and flipped camera pose.

The standard matrix defines a coordinate system with negative Z-axis as viewing direction in relation to the world coordinate system.
The inverted and flipped camera pose defines a coordinate system with positive Z-axis as viewing direction and transforms the world in relation to the camera coordinate system.

Parameters

world_T_camera The standard camera pose to transform, must be valid

Returns: The inverted and flipped camera pose, flippedCamera_T_world

Template Parameters

U	The data type of the elements of the matrix

See also: invertedFlipped2Standard().

◆ standard2InvertedFlipped() [3/6]

template<typename T >

template<typename U >

HomogenousMatricesT4< U > Ocean::CameraT< T >::standard2InvertedFlipped	(	const HomogenousMatrixT4< U > *	world_T_cameras,
		const size_t	number
	)

inlinestatic

Transforms standard homogenous 4x4 viewing (extrinsic camera) matrices into an inverted and flipped camera matrices.

The standard matrix defines a coordinate system with negative Z-axis as viewing direction in relation to the world coordinate system.
The inverted and flipped camera pose defines a coordinate system with positive Z-axis as viewing direction and transforms the world in relation to the camera coordinate system.

Parameters

world_T_cameras	The standard camera poses to transform, can be nullptr if number is 0u
number	The number of provided poses, with range [0, infinity)

Returns: The inverted and flipped camera poses, flippedCameras_T_world

Template Parameters

U	The data type of the elements of the matrix

See also: invertedFlipped2Standard().

◆ standard2InvertedFlipped() [4/6]

template<typename T >

template<typename U >

void Ocean::CameraT< T >::standard2InvertedFlipped	(	const HomogenousMatrixT4< U > *	world_T_cameras,
		HomogenousMatrixT4< U > *	flippedCameras_T_world,
		const size_t	number
	)

inlinestatic

Transforms standard homogenous 4x4 viewing (extrinsic camera) matrices into an inverted and flipped camera matrices.

The standard matrix defines a coordinate system with negative Z-axis as viewing direction in relation to the world coordinate system.
The inverted and flipped camera pose defines a coordinate system with positive Z-axis as viewing direction and transforms the world in relation to the camera coordinate system.

Parameters

world_T_cameras	The standard camera poses to transform, can be nullptr if number is 0u
flippedCameras_T_world	The resulting inverted and flipped camera poses
number	The number of provided poses, with range [0, infinity)

Template Parameters

U	The data type of the elements of the matrix

See also: invertedFlipped2Standard().

◆ standard2InvertedFlipped() [5/6]

template<typename T >

template<typename U >

QuaternionT Ocean::CameraT< T >::standard2InvertedFlipped ( const QuaternionT & world_Q_camera )

inlinestatic

Transforms a standard rotation quaternion into an inverted and flipped rotation quaternion.

The standard rotation defines a coordinate system with negative Z-axis as viewing direction in relation to the world coordinate system.
The inverted and flipped rotation quaternion defines a coordinate system with positive Z-axis as viewing direction and transforms the world in relation to the camera coordinate system.

Parameters

world_Q_camera The standard rotation quaternion of the camera pose to transform, must be valid

Returns: The inverted and flipped rotation quaternion of camera pose, flippedCamera_Q_world

Template Parameters

U	The data type of the elements of the quaternion

See also: invertedFlipped2Standard().

◆ standard2InvertedFlipped() [6/6]

template<typename T >

template<typename U >

SquareMatrixT3 Ocean::CameraT< T >::standard2InvertedFlipped ( const SquareMatrixT3 & world_R_camera )

inlinestatic

Transforms a standard 3x3 rotation matrix into an inverted and flipped rotation matrix.

The standard rotation defines a coordinate system with negative Z-axis as viewing direction in relation to the world coordinate system.
The inverted and flipped rotation matrix defines a coordinate system with positive Z-axis as viewing direction and transforms the world in relation to the camera coordinate system.

Parameters

world_R_camera The standard rotation matrix of the camera pose to transform, must be valid

Returns: The inverted and flipped rotation matrix of camera pose, flippedCamera_R_world

Template Parameters

U	The data type of the elements of the matrix

See also: invertedFlipped2Standard().

The documentation for this class was generated from the following file:

Camera.h

Static Public Member Functions

Detailed Description

template<typename T> class Ocean::CameraT< T >

Member Function Documentation

◆ fieldOfViewToFocalLength()

◆ flipMatrix3()

◆ flipMatrix4()

◆ flippedTransformationLeftAndRightSide() [1/3]

◆ flippedTransformationLeftAndRightSide() [2/3]

◆ flippedTransformationLeftAndRightSide() [3/3]

◆ flippedTransformationLeftSide() [1/3]

◆ flippedTransformationLeftSide() [2/3]

◆ flippedTransformationLeftSide() [3/3]

◆ flippedTransformationRightSide() [1/3]

◆ flippedTransformationRightSide() [2/3]

◆ flippedTransformationRightSide() [3/3]

◆ flipQuaternion()

◆ fovX2Y()

◆ fovY2X()

◆ invertedFlipped2Standard() [1/6]

◆ invertedFlipped2Standard() [2/6]

◆ invertedFlipped2Standard() [3/6]

◆ invertedFlipped2Standard() [4/6]

◆ invertedFlipped2Standard() [5/6]

◆ invertedFlipped2Standard() [6/6]

◆ isObjectPointInFrontIF() [1/2]

◆ isObjectPointInFrontIF() [2/2]

◆ objectPoint2normalizedImagePoint()

◆ objectPoint2normalizedImagePointIF()

◆ objectPoints2normalizedImagePoints()

◆ objectPoints2normalizedImagePointsIF()

◆ standard2InvertedFlipped() [1/6]

◆ standard2InvertedFlipped() [2/6]

◆ standard2InvertedFlipped() [3/6]

◆ standard2InvertedFlipped() [4/6]

◆ standard2InvertedFlipped() [5/6]

◆ standard2InvertedFlipped() [6/6]

template<typename T>
class Ocean::CameraT< T >