This class implements function to calculate the jacobian matrices for geometry functions. More...

Inheritance diagram for Ocean::Geometry::Jacobian:

Static Public Member Functions
template<typename T >
static void	calculateRotationRodriguesDerivative (const ExponentialMapT< T > &rotation, SquareMatrixT3< T > &dwx, SquareMatrixT3< T > &dwy, SquareMatrixT3< T > &dwz)
	This function determines the 3x3 Jacobian of a rotation function rotating a 3D object point by application of an exponential map. More...

template<typename T >
static void	calculateSphericalObjectPointJacobian3x3 (T jx, T jy, T *jz, const ExponentialMapT< T > &sphericalObjectPoint, const T objectPointDistance)
	Calculates the three jacobian rows for a given exponential rotation map representing the location of a 3D object point. More...

template<typename T >
static void	calculateSphericalObjectPointOrientationJacobian2x3IF (T jx, T jy, const AnyCameraT< T > &camera, const SquareMatrixT3< T > &flippedCamera_R_world, const ExponentialMapT< T > &sphericalObjectPoint, const T objectPointDistance)
	Calculates the two jacobian rows for a given exponential rotation map representing the location of a 3D object point projecting into the camera frame with orientational camera pose. More...

template<typename T , typename TRotation >
static OCEAN_FORCE_INLINE void	calculateOrientationalJacobianRodrigues2x3IF (const AnyCameraT< T > &anyCamera, const TRotation &flippedCamera_R_translation, const VectorT3< T > &translation_T_world, const VectorT3< T > &worldObjectPoint, const SquareMatrixT3< T > &dwx, const SquareMatrixT3< T > &dwy, const SquareMatrixT3< T > &dwz, T jx, T jy)
	Calculates the two Jacobian rows for the 3-DOF rotational part of a 6-DOF camera pose and a given 3D object point. More...

template<typename T >
static void	calculateOrientationJacobianRodrigues2nx3IF (T *jacobian, const AnyCameraT< T > &camera, const ExponentialMapT< T > &flippedCamera_R_world, const ConstIndexedAccessor< VectorT3< T >> &objectPoints)
	Calculates all 3-DOF orientational jacobian rows for a given (flexible) camera pose and a set of static 3D object points. More...

static void	calculateOrientationJacobianRodrigues2nx3 (Scalar *jacobian, const PinholeCamera &pinholeCamera, const Pose &flippedCamera_P_world, const ConstIndexedAccessor< Vector3 > &objectPoints, const bool distortImagePoints)
	Deprecated. More...

static void	calculatePoseJacobianRodrigues2x6 (Scalar jx, Scalar jy, const PinholeCamera &pinholeCamera, const Pose &flippedCamera_P_world, const Vector3 &objectPoint, const bool distortImagePoint)
	Calculates the two jacobian rows for a given (flexible) pose and static camera and one static 3D object point. More...

static void	calculatePoseJacobianRodrigues2x6 (Scalar jx, Scalar jy, const PinholeCamera &pinholeCamera, const HomogenousMatrix4 &flippedCamera_P_world, const Vector3 &objectPoint, const bool distortImagePoint, const SquareMatrix3 &dwx, const SquareMatrix3 &dwy, const SquareMatrix3 &dwz)
	Deprecated. More...

static void	calculatePoseJacobianRodrigues2x6 (Scalar jx, Scalar jy, const FisheyeCamera &fisheyeCamera, const HomogenousMatrix4 &flippedCamera_T_world, const Vector3 &worldObjectPoint, const SquareMatrix3 &dwx, const SquareMatrix3 &dwy, const SquareMatrix3 &dwz)
	Deprecated. More...

template<typename T >
static OCEAN_FORCE_INLINE void	calculatePoseJacobianRodrigues2x6IF (const AnyCameraT< T > &anyCamera, const HomogenousMatrixT4< T > &flippedCamera_T_world, const VectorT3< T > &worldObjectPoint, const SquareMatrixT3< T > &dwx, const SquareMatrixT3< T > &dwy, const SquareMatrixT3< T > &dwz, T jx, T jy)
	Calculates the two jacobian rows for a given (flexible) 6-DOF camera pose and one static 3D object point. More...

template<typename T >
static void	calculatePoseJacobianRodrigues2nx6IF (T jacobian, const AnyCameraT< T > &camera, const PoseT< T > &flippedCamera_P_world, const VectorT3< T > objectPoints, const size_t numberObjectPoints)
	Calculates all jacobian rows for a given (flexible) 6-DOF camera pose with a static camera profile and several static 3D object points. More...

static void	calculatePoseJacobianRodrigues2nx6 (Scalar jacobian, const PinholeCamera &pinholeCamera, const Pose &flippedCamera_P_world, const Vector3 objectPoints, const size_t numberObjectPoints, const bool distortImagePoints)
	Deprecated. More...

static void	calculatePoseJacobianRodriguesDampedDistortion2nx6 (Scalar jacobian, const PinholeCamera &pinholeCamera, const Pose &flippedCamera_P_world, const Scalar dampingFactor, const Vector3 objectPoints, const size_t numberObjectPoints, const bool distortImagePoints)
	Calculates all pose jacobian rows for a given (flexible) pose with a static camera profile supporting distortion and a set of static 3D object points. More...

static void	calculatePoseZoomJacobianRodrigues2x7 (Scalar jx, Scalar jy, const PinholeCamera &pinholeCamera, const Pose &flippedCamera_P_world, const Scalar zoom, const Vector3 &objectPoint, const bool distortImagePoints)
	Calculates the two jacobian rows for a given (flexible) pose with (flexible) zoom factor and one static 3D object point. More...

static void	calculatePoseZoomJacobianRodrigues2nx7 (Scalar jacobian, const PinholeCamera &pinholeCamera, const Pose &flippedCamera_P_world, const Scalar zoom, const Vector3 objectPoints, const size_t numberObjectPoints, const bool distortImagePoints)
	Calculates all pose jacobian rows for a given (flexible) pose with (flexible) zoom factor and a set of static 3D object points. More...

static void	calculateObjectTransformation2x6 (Scalar jx, Scalar jy, const PinholeCamera &pinholeCamera, const HomogenousMatrix4 &extrinsicIF, const Pose &objectPose, const Vector3 &objectPoint)
	Calculates the two jacobian rows for a given (flexible) 6-DOF object transformation, and a static 6-DOF camera pose, and a static camera, and one static 3D object point. More...

static void	calculateObjectTransformation2x6 (Scalar jx, Scalar jy, const PinholeCamera &pinholeCamera, const HomogenousMatrix4 &extrinsicIF, const Pose &objectPose, const Vector3 &objectPoint, const SquareMatrix3 &dwx, const SquareMatrix3 &dwy, const SquareMatrix3 &dwz)
	Calculates the two jacobian rows for a given (flexible) 6-DOF object transformation, and a static 6-DOF camera pose, and a static camera, and one static 3D object point. More...

static void	calculateObjectTransformation2nx6 (Scalar jacobian, const PinholeCamera &pinholeCamera, const HomogenousMatrix4 &extrinsicIF, const Pose &objectPose, const Vector3 objectPoints, const size_t numberObjectPoints)
	Calculates all pose jacobian rows for a given (flexible) 6-DOF object transformation, and a static 6-DOF camera pose, and a static camera, and several static 3D object points. More...

static void	calculateObjectTransformation2nx6 (Scalar jacobian, const FisheyeCamera &fisheyeCamera, const HomogenousMatrix4 &flippedCamera_T_world, const Pose &world_T_object, const Vector3 objectPoints, const size_t numberObjectPoints)
	Calculates all pose jacobian rows for a given (flexible) 6-DOF object transformation, and a static 6-DOF camera pose, and a static fisheye camera, and several static 3D object points. More...

static void	calculatePoseJacobianRodrigues2x5 (Scalar jx, Scalar jy, const PinholeCamera &pinholeCamera, const ExponentialMap &rotation, const Vector2 &translation, const Vector3 &objectPoint)
	Calculates the two jacobian rows for a given pose with translation scale ambiguities and static object point. More...

static void	calculatePoseJacobianRodrigues2nx5 (Scalar jacobian, const PinholeCamera &pinholeCamera, const ExponentialMap &rotation, const Vector2 &translation, const Vector3 objectPoints, const size_t numberObjectPoints)
	Calculates all jacobian rows for a given pose with translation scale ambiguities and a set of static object points. More...

static void	calculatePointJacobian2x3 (Scalar jx, Scalar jy, const PinholeCamera &pinholeCamera, const HomogenousMatrix4 &flippedCamera_P_world, const Vector3 &objectPoint, const bool distortImagePoint)
	Calculates the two jacobian rows for a given pose and dynamic object point. More...

static void	calculatePointJacobian2x3 (Scalar jx, Scalar jy, const FisheyeCamera &fisheyeCamera, const HomogenousMatrix4 &flippedCamera_T_world, const Vector3 &worldObjectPoint)
	Calculates the two jacobian rows for a given pose and dynamic object point. More...

template<typename T >
static OCEAN_FORCE_INLINE void	calculatePointJacobian2x3IF (const AnyCameraT< T > &anyCamera, const HomogenousMatrixT4< T > &flippedCamera_T_world, const VectorT3< T > &worldObjectPoint, T jx, T jy)
	Calculates the two jacobian rows for a given pose and dynamic object point. More...

static void	calculatePointJacobian2nx3 (Scalar jacobian, const PinholeCamera &pinholeCamera, const HomogenousMatrix4 &flippedCamera_P_world, const Vector3 objectPoints, const size_t numberObjectPoints, const bool distortImagePoints)
	Calculates the two jacobian rows for a given pose and several dynamic object points. More...

static void	calculateCameraDistortionJacobian2x4 (Scalar jx, Scalar jy, const PinholeCamera &pinholeCamera, const Vector2 &normalizedImagePoint)
	Calculates the two jacobian rows for a given camera and image point. More...

static void	calculateCameraJacobian2x6 (Scalar jx, Scalar jy, const PinholeCamera &pinholeCamera, const Vector2 &normalizedImagePoint)
	Calculates the two jacobian rows for a given camera and image point. More...

static void	calculateCameraJacobian2x7 (Scalar jx, Scalar jy, const PinholeCamera &pinholeCamera, const Vector2 &normalizedImagePoint)
	Calculates the two jacobian rows for a given camera and image point. More...

static void	calculateCameraJacobian2x8 (Scalar jx, Scalar jy, const PinholeCamera &pinholeCamera, const Vector2 &normalizedImagePoint)
	Calculates the two jacobian rows for a given camera and image point. More...

static void	calculateOrientationCameraJacobianRodrigues2x11 (Scalar jx, Scalar jy, const PinholeCamera &pinholeCamera, const Pose &flippedCamera_P_world, const Vector3 &objectPoint)
	Calculates the two jacobian rows for a given (orientational pose) and a camera and a static object point. More...

static void	calculateOrientationCameraJacobianRodrigues2nx11 (Scalar *jacobian, const PinholeCamera &pinholeCamera, const Pose &flippedCamera_P_world, const ConstIndexedAccessor< Vector3 > &objectPoints)
	Calculates the two jacobian rows for a given (orientational pose) and a camera and a set of static object points. More...

static void	calculateJacobianCameraPoseRodrigues2x12 (Scalar jx, Scalar jy, const PinholeCamera &pinholeCamera, const HomogenousMatrix4 &flippedCamera_T_world, const Vector3 &objectPoint)
	Calculates the entire jacobian matrix for an object point to image point transformation covering a flexible 6-DOF camera pose, the four intrinsic camera parameters and two parameters for radial distortion. More...

static void	calculateJacobianCameraPoseRodrigues2x12 (Scalar jx, Scalar jy, const PinholeCamera &pinholeCamera, const HomogenousMatrix4 &flippedCamera_T_world, const Pose &flippedCamera_P_world, const Vector3 &objectPoint, const SquareMatrix3 &dwx, const SquareMatrix3 &dwy, const SquareMatrix3 &dwz)
	Calculates the entire jacobian matrix for an object point to image point transformation covering a flexible 6-DOF camera pose, the four intrinsic camera parameters and two parameters for radial distortion. More...

static void	calculateJacobianCameraPoseRodrigues2x14 (Scalar jx, Scalar jy, const PinholeCamera &pinholeCamera, const HomogenousMatrix4 &flippedCamera_T_world, const Vector3 &objectPoint)
	Calculates the entire jacobian matrix for an object point to image point transformation covering a flexible 6-DOF camera pose, the four intrinsic camera parameters and four parameters for radial and tangential distortion. More...

static void	calculateJacobianCameraPoseRodrigues2x14 (Scalar jx, Scalar jy, const PinholeCamera &pinholeCamera, const HomogenousMatrix4 &flippedCamera_T_world, const Pose &flippedCamera_P_world, const Vector3 &objectPoint, const SquareMatrix3 &dwx, const SquareMatrix3 &dwy, const SquareMatrix3 &dwz)
	Calculates the entire jacobian matrix for an object point to image point transformation covering a flexible 6-DOF camera pose, the four intrinsic camera parameters and four parameters for radial and tangential distortion. More...

static void	calculateJacobianCameraPoseRodrigues2nx14 (Scalar *jacobian, const PinholeCamera &pinholeCamera, const Pose &flippedCamera_P_world, const ConstIndexedAccessor< Vector3 > &objectPoints)
	Calculates the two jacobian rows for a given (6-DOF pose) and a camera and a set of static object points. More...

static void	calculateHomographyJacobian2x8 (Scalar jx, Scalar jy, const Scalar x, const Scalar y, const SquareMatrix3 &homography)
	Determines the 2x8 Jacobian of a homography function that transforms a 2D coordinate (interpreted as a 3D vector with homogeneous extension) to a 2D coordinate (the de-homogenization is included). More...

static void	calculateHomographyJacobian2x9 (Scalar jx, Scalar jy, const Scalar x, const Scalar y, const SquareMatrix3 &homography)
	Determines the 2x9 Jacobian of a homography function that transforms a 2D coordinate (interpreted as a 3D vector with homogeneous extension) to a 2D coordinate (the de-homogenization is included). More...

static void	calculateIdentityHomographyJacobian2x8 (Scalar jx, Scalar jy, const Scalar x, const Scalar y)
	Determines the 2x8 Jacobian of the identity homography function that transforms a 2D coordinate (interpreted as a 3D vector with homogeneous extension) to a 2D coordinate (the de-homogenization is included). More...

static void	calculateIdentityHomographyJacobian2x9 (Scalar jx, Scalar jy, const Scalar x, const Scalar y)
	Determines the 2x9 Jacobian of the identity homography function that transforms a 2D coordinate (interpreted as a 3D vector with homogeneous extension) to a 2D coordinate (the de-homogenization is included). More...

static void	calculateSimilarityJacobian2x4 (Scalar jx, Scalar jy, const Scalar x, const Scalar y, const SquareMatrix3 &similarity)
	Determines the 2x4 Jacobian of a similarity transformation that transforms a 2D coordinate (interpreted as a 3D vector with homogeneous extension) to a 2D coordinate (the de-homogenization is included). More...

template<typename T >
static void	calculateFisheyeDistortNormalized2x2 (T jx, T jy, const T x, const T y, const T radialDistortion, const T tangentialDistortion)
	Determines the 2x2 Jacobian of distorting a normalized image point in a fisheye camera with radial and tangential distortion. More...

Detailed Description

This class implements function to calculate the jacobian matrices for geometry functions.

Member Function Documentation

◆ calculateCameraDistortionJacobian2x4()

static void Ocean::Geometry::Jacobian::calculateCameraDistortionJacobian2x4	(	Scalar *	jx,
		Scalar *	jy,
		const PinholeCamera &	pinholeCamera,
		const Vector2 &	normalizedImagePoint
	)

static

Calculates the two jacobian rows for a given camera and image point.

The jacobian is determined for the radial and tangential distortion parameters.
The resulting jacobian has the following form:

| dfx / dk1, dfx / dk2, dfx / dp1, dfx / dp2 |
| dfy / dk1, dfy / dk2, dfy / dp1, dfy / dp2 |

Parameters

jx	First row of the jacobian, with 4 column entries
jy	Second row of the jacobian, with 4 column entries
pinholeCamera	The pinhole camera to determine the jacobian values for
normalizedImagePoint	Normalized 2D image point to determine the jacobian for

◆ calculateCameraJacobian2x6()

static void Ocean::Geometry::Jacobian::calculateCameraJacobian2x6	(	Scalar *	jx,
		Scalar *	jy,
		const PinholeCamera &	pinholeCamera,
		const Vector2 &	normalizedImagePoint
	)

static

Calculates the two jacobian rows for a given camera and image point.

The jacobian is determined for the focal length, the principal point and the radial distortion parameters.
The resulting jacobian has the following form:

| dfx / dk1, dfx / dk2, dfx / dFx, dfx / dFy, dfx / dmx, dfx / dmy |
| dfy / dk1, dfy / dk2, dfy / dFx, dfy / dFy, dfy / dmx, dfy / dmy |

Parameters

jx	First row of the jacobian, with 6 column entries
jy	Second row of the jacobian, with 6 column entries
pinholeCamera	The pinhole camera to determine the jacobian values for
normalizedImagePoint	Normalized 2D image point to determine the jacobian for

◆ calculateCameraJacobian2x7()

static void Ocean::Geometry::Jacobian::calculateCameraJacobian2x7	(	Scalar *	jx,
		Scalar *	jy,
		const PinholeCamera &	pinholeCamera,
		const Vector2 &	normalizedImagePoint
	)

static

Calculates the two jacobian rows for a given camera and image point.

The jacobian is determined for the focal length (same for horizontal and vertical axis), the principal point and the radial and tangential distortion parameters.
The resulting jacobian has the following form:

| dfx / dk1, dfx / dk2, dfx / dp1, dfx / dp2, dfx / dF, dfx / dmx, dfx / dmy |
| dfy / dk1, dfy / dk2, dfy / dp1, dfy / dp2, dfy / dF, dfy / dmx, dfy / dmy |

Parameters

jx	First row of the jacobian, with 7 column entries
jy	Second row of the jacobian, with 7 column entries
pinholeCamera	The pinhole camera to determine the jacobian values for
normalizedImagePoint	Normalized 2D image point to determine the jacobian for

◆ calculateCameraJacobian2x8()

static void Ocean::Geometry::Jacobian::calculateCameraJacobian2x8	(	Scalar *	jx,
		Scalar *	jy,
		const PinholeCamera &	pinholeCamera,
		const Vector2 &	normalizedImagePoint
	)

static

Calculates the two jacobian rows for a given camera and image point.

The jacobian is determined for the focal length, the principal point and the radial and tangential distortion parameters.
The resulting jacobian has the following form:

| dfx / dk1, dfx / dk2, dfx / dp1, dfx / dp2, dfx / dFx, dfx / dFy, dfx / dmx, dfx / dmy |
| dfy / dk1, dfy / dk2, dfy / dp1, dfy / dp2, dfy / dFx, dfy / dFy, dfy / dmx, dfy / dmy |

Parameters

jx	First row of the jacobian, with 8 column entries
jy	Second row of the jacobian, with 8 column entries
pinholeCamera	The pinhole camera to determine the jacobian values for
normalizedImagePoint	Normalized 2D image point to determine the jacobian for

◆ calculateFisheyeDistortNormalized2x2()

template<typename T >

void Ocean::Geometry::Jacobian::calculateFisheyeDistortNormalized2x2	(	T *	jx,
		T *	jy,
		const T	x,
		const T	y,
		const T *	radialDistortion,
		const T *	tangentialDistortion
	)

static

Determines the 2x2 Jacobian of distorting a normalized image point in a fisheye camera with radial and tangential distortion.

The resulting jacobian has the following form:

| dfx / dx, dfx / dy |
| dfy / dx, dfy / dy |

Parameters

jx	First row of the jacobian, with 2 column entries, must be valid
jy	Second row of the jacobian, with 2 column entries, must be valid
x	The horizontal coordinate of the normalized image point to be distorted
y	The vertical coordinate of the normalized image point to be distorted
radialDistortion	The six radial distortion parameters, must be valid
tangentialDistortion	The two radial distortion parameters, must be valid

Template Parameters

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

◆ calculateHomographyJacobian2x8()

static void Ocean::Geometry::Jacobian::calculateHomographyJacobian2x8	(	Scalar *	jx,
		Scalar *	jy,
		const Scalar	x,
		const Scalar	y,
		const SquareMatrix3 &	homography
	)

static

Determines the 2x8 Jacobian of a homography function that transforms a 2D coordinate (interpreted as a 3D vector with homogeneous extension) to a 2D coordinate (the de-homogenization is included).

This Jacobian can be used e.g., for additive image alignment.
The resulting jacobian has the following form:

| dfx / dh0, dfx / dh1, dfx / dh2, dfx / dh3, dfx / dh4, dfx / dh5, dfx / dh6, dfx / dh7 |
| dfy / dh0, dfy / dh1, dfy / dh2, dfy / dh3, dfy / dh4, dfy / dh5, dfy / dh6, dfy / dh7 |

Parameters

jx	First row of the jacobian, with 8 column entries
jy	Second row of the jacobian, with 8 column entries
x	The horizontal coordinate to be used
y	The vertical coordinate to be used
homography	The homography for which the Jacobian will be determined, must have 1 in the lower right corner

See also: calculateHomographyJacobian2x9(), calculateIdentityHomographyJacobian2x8().

◆ calculateHomographyJacobian2x9()

static void Ocean::Geometry::Jacobian::calculateHomographyJacobian2x9	(	Scalar *	jx,
		Scalar *	jy,
		const Scalar	x,
		const Scalar	y,
		const SquareMatrix3 &	homography
	)

static

Determines the 2x9 Jacobian of a homography function that transforms a 2D coordinate (interpreted as a 3D vector with homogeneous extension) to a 2D coordinate (the de-homogenization is included).

This Jacobian can be used e.g., for additive image alignment.
The resulting jacobian has the following form:

| dfx / dh0, dfx / dh1, dfx / dh2, dfx / dh3, dfx / dh4, dfx / dh5, dfx / dh6, dfx / dh7, dfx / dh8 |
| dfy / dh0, dfy / dh1, dfy / dh2, dfy / dh3, dfy / dh4, dfy / dh5, dfy / dh6, dfy / dh7, dfx / dh8 |

Parameters

jx	First row of the jacobian, with 9 column entries
jy	Second row of the jacobian, with 9 column entries
x	The horizontal coordinate to be used
y	The vertical coordinate to be used
homography	The homography for which the Jacobian will be determined, must have 1 in the lower right corner

See also: calculateHomographyJacobian2x8(), calculateIdentityHomographyJacobian2x9().

◆ calculateIdentityHomographyJacobian2x8()

static void Ocean::Geometry::Jacobian::calculateIdentityHomographyJacobian2x8	(	Scalar *	jx,
		Scalar *	jy,
		const Scalar	x,
		const Scalar	y
	)

static

Determines the 2x8 Jacobian of the identity homography function that transforms a 2D coordinate (interpreted as a 3D vector with homogeneous extension) to a 2D coordinate (the de-homogenization is included).

This Jacobian can be used e.g., for inverse compositional image alignment..
The resulting jacobian has the following form:

| dfx / dh0, dfx / dh1, dfx / dh2, dfx / dh3, dfx / dh4, dfx / dh5, dfx / dh6, dfx / dh7 |
| dfy / dh0, dfy / dh1, dfy / dh2, dfy / dh3, dfy / dh4, dfy / dh5, dfy / dh6, dfy / dh7 |

Parameters

jx	First row of the jacobian, with 8 column entries
jy	Second row of the jacobian, with 8 column entries
x	The horizontal coordinate to be used
y	The vertical coordinate to be used

See also: calculateIdentityHomographyJacobian2x9(), calculateHomographyJacobian2x8().

◆ calculateIdentityHomographyJacobian2x9()

static void Ocean::Geometry::Jacobian::calculateIdentityHomographyJacobian2x9	(	Scalar *	jx,
		Scalar *	jy,
		const Scalar	x,
		const Scalar	y
	)

static

Determines the 2x9 Jacobian of the identity homography function that transforms a 2D coordinate (interpreted as a 3D vector with homogeneous extension) to a 2D coordinate (the de-homogenization is included).

This Jacobian can be used e.g., for inverse compositional image alignment.
The resulting jacobian has the following form:

| dfx / dh0, dfx / dh1, dfx / dh2, dfx / dh3, dfx / dh4, dfx / dh5, dfx / dh6, dfx / dh7, dfx / dh8 |
| dfy / dh0, dfy / dh1, dfy / dh2, dfy / dh3, dfy / dh4, dfy / dh5, dfy / dh6, dfy / dh7, dfx / dh8 |

Parameters

jx	First row of the jacobian, with 9 column entries
jy	Second row of the jacobian, with 9 column entries
x	The horizontal coordinate to be used
y	The vertical coordinate to be used

See also: calculateIdentityHomographyJacobian2x8(), calculateHomographyJacobian2x9().

◆ calculateJacobianCameraPoseRodrigues2nx14()

static void Ocean::Geometry::Jacobian::calculateJacobianCameraPoseRodrigues2nx14	(	Scalar *	jacobian,
		const PinholeCamera &	pinholeCamera,
		const Pose &	flippedCamera_P_world,
		const ConstIndexedAccessor< Vector3 > &	objectPoints
	)

static

Calculates the two jacobian rows for a given (6-DOF pose) and a camera and a set of static object points.

The resulting jacobian has the following form:

| dfx / dk1, dfx / dk2, dfx / dp1, dfx / dp2, dfx / dFx, dfx / dFy, dfx / dmx, dfx / dmy, dfx / dwx, dfx / dwy, dfx / dwz, dfx / dtx, dfx / dty, dfx / dtz |
| dfy / dk1, dfy / dk2, dfy / dp1, dfy / dp2, dfy / dFx, dfy / dFy, dfy / dmx, dfy / dmy, dfy / dwx, dfy / dwy, dfy / dwz, dfy / dtx, dfy / dty, dfy / dtz |

Parameters

jacobian	First element in the first row of the entire row aligned jacobian matrix, with 2 * numberObjectPoints rows and 14 columns
pinholeCamera	The pinhole camera to determine the jacobian values for
flippedCamera_P_world	Inverted and flipped pose (rotation and translation) to determine the jacobian for
objectPoints	The accessor providing the 3D object points to determine the jacobian for

◆ calculateJacobianCameraPoseRodrigues2x12() [1/2]

static void Ocean::Geometry::Jacobian::calculateJacobianCameraPoseRodrigues2x12	(	Scalar *	jx,
		Scalar *	jy,
		const PinholeCamera &	pinholeCamera,
		const HomogenousMatrix4 &	flippedCamera_T_world,
		const Pose &	flippedCamera_P_world,
		const Vector3 &	objectPoint,
		const SquareMatrix3 &	dwx,
		const SquareMatrix3 &	dwy,
		const SquareMatrix3 &	dwz
	)

static

Calculates the entire jacobian matrix for an object point to image point transformation covering a flexible 6-DOF camera pose, the four intrinsic camera parameters and two parameters for radial distortion.

The resulting jacobian has the following form:

| dfx / dk1, dfx / dk2, dfx / dFx, dfx / dFy, dfx / dmx, dfx / dmy, dfx / dwx, dfx / dwy, dfx / dwz, dfx / dtx, dfx / dty, dfx / dtz |
| dfy / dk1, dfy / dk2, dfy / dFx, dfy / dFy, dfy / dmx, dfy / dmy, dfy / dwx, dfy / dwy, dfy / dwz, dfy / dtx, dfy / dty, dfy / dtz |

Parameters

jx	First row of the jacobian, with 12 column entries
jy	Second row of the jacobian, with 12 column entries
pinholeCamera	The pinhole camera to determine the jacobian values for
flippedCamera_T_world	Inverted and flipped pose (rotation and translation) to determine the jacobian for
flippedCamera_P_world	Inverted and flipped pose identical to 'flippedCamera_T_world'
dwx	Rotation matrix derived to wx, as determined by calculateRotationRodriguesDerivative()
dwy	Rotation matrix derived to wy, as determined by calculateRotationRodriguesDerivative()
dwz	Rotation matrix derived to wz, as determined by calculateRotationRodriguesDerivative()
objectPoint	3D object point to determine the jacobian for

◆ calculateJacobianCameraPoseRodrigues2x12() [2/2]

static void Ocean::Geometry::Jacobian::calculateJacobianCameraPoseRodrigues2x12	(	Scalar *	jx,
		Scalar *	jy,
		const PinholeCamera &	pinholeCamera,
		const HomogenousMatrix4 &	flippedCamera_T_world,
		const Vector3 &	objectPoint
	)

static

Calculates the entire jacobian matrix for an object point to image point transformation covering a flexible 6-DOF camera pose, the four intrinsic camera parameters and two parameters for radial distortion.

The resulting jacobian has the following form:

| dfx / dk1, dfx / dk2, dfx / dFx, dfx / dFy, dfx / dmx, dfx / dmy, dfx / dwx, dfx / dwy, dfx / dwz, dfx / dtx, dfx / dty, dfx / dtz |
| dfy / dk1, dfy / dk2, dfy / dFx, dfy / dFy, dfy / dmx, dfy / dmy, dfy / dwx, dfy / dwy, dfy / dwz, dfy / dtx, dfy / dty, dfy / dtz |

Parameters

jx	First row of the jacobian, with 12 column entries
jy	Second row of the jacobian, with 12 column entries
pinholeCamera	The pinhole camera to determine the jacobian values for
flippedCamera_T_world	Inverted and flipped pose (rotation and translation) to determine the jacobian for
objectPoint	3D object point to determine the jacobian for

◆ calculateJacobianCameraPoseRodrigues2x14() [1/2]

static void Ocean::Geometry::Jacobian::calculateJacobianCameraPoseRodrigues2x14	(	Scalar *	jx,
		Scalar *	jy,
		const PinholeCamera &	pinholeCamera,
		const HomogenousMatrix4 &	flippedCamera_T_world,
		const Pose &	flippedCamera_P_world,
		const Vector3 &	objectPoint,
		const SquareMatrix3 &	dwx,
		const SquareMatrix3 &	dwy,
		const SquareMatrix3 &	dwz
	)

static

Calculates the entire jacobian matrix for an object point to image point transformation covering a flexible 6-DOF camera pose, the four intrinsic camera parameters and four parameters for radial and tangential distortion.

The resulting jacobian has the following form:

| dfx / dk1, dfx / dk2, dfx / dp1, dfx / dp2, dfx / dFx, dfx / dFy, dfx / dmx, dfx / dmy, dfx / dwx, dfx / dwy, dfx / dwz, dfx / dtx, dfx / dty, dfx / dtz |
| dfy / dk1, dfy / dk2, dfy / dp1, dfy / dp2, dfy / dFx, dfy / dFy, dfy / dmx, dfy / dmy, dfy / dwx, dfy / dwy, dfy / dwz, dfy / dtx, dfy / dty, dfy / dtz |

Parameters

jx	First row of the jacobian, with 14 column entries
jy	Second row of the jacobian, with 14 column entries
pinholeCamera	The pinhole camera to determine the jacobian values for
flippedCamera_T_world	Inverted and flipped pose (rotation and translation) to determine the jacobian for
flippedCamera_P_world	Inverted and flipped pose identical to 'flippedCamera_T_world'
objectPoint	3D object point to determine the jacobian for
dwx	Rotation matrix derived to wx, as determined by calculateRotationRodriguesDerivative()
dwy	Rotation matrix derived to wy, as determined by calculateRotationRodriguesDerivative()
dwz	Rotation matrix derived to wz, as determined by calculateRotationRodriguesDerivative()

See also: calculateRotationRodriguesDerivative().

◆ calculateJacobianCameraPoseRodrigues2x14() [2/2]

static void Ocean::Geometry::Jacobian::calculateJacobianCameraPoseRodrigues2x14	(	Scalar *	jx,
		Scalar *	jy,
		const PinholeCamera &	pinholeCamera,
		const HomogenousMatrix4 &	flippedCamera_T_world,
		const Vector3 &	objectPoint
	)

static

Calculates the entire jacobian matrix for an object point to image point transformation covering a flexible 6-DOF camera pose, the four intrinsic camera parameters and four parameters for radial and tangential distortion.

The resulting jacobian has the following form:

| dfx / dk1, dfx / dk2, dfx / dp1, dfx / dp2, dfx / dFx, dfx / dFy, dfx / dmx, dfx / dmy, dfx / dwx, dfx / dwy, dfx / dwz, dfx / dtx, dfx / dty, dfx / dtz |
| dfy / dk1, dfy / dk2, dfy / dp1, dfy / dp2, dfy / dFx, dfy / dFy, dfy / dmx, dfy / dmy, dfy / dwx, dfy / dwy, dfy / dwz, dfy / dtx, dfy / dty, dfy / dtz |

Parameters

jx	First row of the jacobian, with 14 column entries
jy	Second row of the jacobian, with 14 column entries
pinholeCamera	The pinhole camera to determine the jacobian values for
flippedCamera_T_world	Inverted and flipped pose (rotation and translation) to determine the jacobian for
objectPoint	3D object point to determine the jacobian for

◆ calculateObjectTransformation2nx6() [1/2]

static void Ocean::Geometry::Jacobian::calculateObjectTransformation2nx6	(	Scalar *	jacobian,
		const FisheyeCamera &	fisheyeCamera,
		const HomogenousMatrix4 &	flippedCamera_T_world,
		const Pose &	world_T_object,
		const Vector3 *	objectPoints,
		const size_t	numberObjectPoints
	)

static

Calculates all pose jacobian rows for a given (flexible) 6-DOF object transformation, and a static 6-DOF camera pose, and a static fisheye camera, and several static 3D object points.

The 6 derivatives are calculated for the entire 6DOF pose.
The resulting jacobian rows have the following form:

|                               ...                                |
| dfx / dwx, dfx / dwy, dfx / dwz, dfx / dtx, dfx / dty, dfx / dtz |
| dfy / dwx, dfy / dwy, dfy / dwz, dfy / dtx, dfy / dty, dfy / dtz |
|                               ...                                |

With transformation function f = (fx, fy), exponential map w = (wx, wy, wz) and translation t = (tx, ty, tz).
The jacobian calculation uses the Rodrigues rotation formula to determine the rotation derivatives.

Parameters

jacobian	First element in the first row of the entire row aligned jacobian matrix, with `2 * numberObjectPoints` rows and 6 columns, must be valid
fisheyeCamera	The fisheye camera profile defining the projection, must be valid
flippedCamera_T_world	Inverted and flipped camera pose, must be valid
world_T_object	The 6-DOF object point transformation (rotation and translation) to determine the jacobian for
objectPoints	3D object points to determine the jacobian for, must be valid
numberObjectPoints	Number of given object points, with range [1, infinity)

See also: calculateObjectTransformation2x6().

◆ calculateObjectTransformation2nx6() [2/2]

static void Ocean::Geometry::Jacobian::calculateObjectTransformation2nx6	(	Scalar *	jacobian,
		const PinholeCamera &	pinholeCamera,
		const HomogenousMatrix4 &	extrinsicIF,
		const Pose &	objectPose,
		const Vector3 *	objectPoints,
		const size_t	numberObjectPoints
	)

static

Calculates all pose jacobian rows for a given (flexible) 6-DOF object transformation, and a static 6-DOF camera pose, and a static camera, and several static 3D object points.

The 6 derivatives are calculated for the entire 6DOF pose.
The resulting jacobian rows have the following form:

|                               ...                                |
| dfx / dwx, dfx / dwy, dfx / dwz, dfx / dtx, dfx / dty, dfx / dtz |
| dfy / dwx, dfy / dwy, dfy / dwz, dfy / dtx, dfy / dty, dfy / dtz |
|                               ...                                |

With transformation function f = (fx, fy), exponential map w = (wx, wy, wz) and translation t = (tx, ty, tz).
The jacobian calculation uses the Rodrigues rotation formula to determine the rotation derivatives.

Parameters

jacobian	First element in the first row of the entire row aligned jacobian matrix, with `2 * numberObjectPoints` rows and 6 columns, must be valid
pinholeCamera	The pinhole camera profile defining the projection, must be valid
extrinsicIF	Inverted and flipped camera pose, must be valid
objectPose	The 6-DOF object point transformation (rotation and translation) to determine the jacobian for
objectPoints	3D object points to determine the jacobian for, must be valid
numberObjectPoints	Number of given object points, with range [1, infinity)

See also: calculateObjectTransformation2x6().

◆ calculateObjectTransformation2x6() [1/2]

void Ocean::Geometry::Jacobian::calculateObjectTransformation2x6	(	Scalar *	jx,
		Scalar *	jy,
		const PinholeCamera &	pinholeCamera,
		const HomogenousMatrix4 &	extrinsicIF,
		const Pose &	objectPose,
		const Vector3 &	objectPoint
	)

inlinestatic

Calculates the two jacobian rows for a given (flexible) 6-DOF object transformation, and a static 6-DOF camera pose, and a static camera, and one static 3D object point.

The 6 derivatives are calculated for the 6-DOF object transformation.
The resulting jacobian rows have the following form:

| dfx / dwx, dfx / dwy, dfx / dwz, dfx / dtx, dfx / dty, dfx / dtz |
| dfy / dwx, dfy / dwy, dfy / dwz, dfy / dtx, dfy / dty, dfy / dtz |

With transformation function f = (fx, fy), exponential map w = (wx, wy, wz) and translation t = (tx, ty, tz).
The jacobian calculation uses the Rodrigues rotation formula to determine the rotation derivatives.

Parameters

jx	First row of the jacobian, with 6 column entries
jy	Second row of the jacobian, with 6 column entries
pinholeCamera	The pinhole camera profile defining the projection, must be valid
extrinsicIF	Inverted and flipped camera pose, must be valid
objectPose	The 6-DOF object point transformation (rotation and translation) to determine the jacobian for
objectPoint	3D object point to determine the jacobian for

See also: calculateObjectTransformation2nx6().

◆ calculateObjectTransformation2x6() [2/2]

static void Ocean::Geometry::Jacobian::calculateObjectTransformation2x6	(	Scalar *	jx,
		Scalar *	jy,
		const PinholeCamera &	pinholeCamera,
		const HomogenousMatrix4 &	extrinsicIF,
		const Pose &	objectPose,
		const Vector3 &	objectPoint,
		const SquareMatrix3 &	dwx,
		const SquareMatrix3 &	dwy,
		const SquareMatrix3 &	dwz
	)

static

Calculates the two jacobian rows for a given (flexible) 6-DOF object transformation, and a static 6-DOF camera pose, and a static camera, and one static 3D object point.

This function uses the pre-calculated 3x3 Jacobian matrix of the object transformation's orientation provided by three separated 3x3 matrices.
The 6 derivatives are calculated for the 6-DOF object transformation.
The resulting jacobian rows have the following form:

| dfx / dwx, dfx / dwy, dfx / dwz, dfx / dtx, dfx / dty, dfx / dtz |
| dfy / dwx, dfy / dwy, dfy / dwz, dfy / dtx, dfy / dty, dfy / dtz |

With transformation function f = (fx, fy), exponential map w = (wx, wy, wz) and translation t = (tx, ty, tz).
The jacobian calculation uses the Rodrigues rotation formula to determine the rotation derivatives.

Parameters

jx	First row of the jacobian, with 6 column entries
jy	Second row of the jacobian, with 6 column entries
pinholeCamera	The pinhole camera profile defining the projection, must be valid
extrinsicIF	Inverted and flipped camera pose, must be valid
objectPose	The 6-DOF object point transformation (rotation and translation) to determine the jacobian for
objectPoint	3D object point to determine the jacobian for
dwx	Rotation matrix derived to wx, as determined by calculateRotationRodriguesDerivative()
dwy	Rotation matrix derived to wy, as determined by calculateRotationRodriguesDerivative()
dwz	Rotation matrix derived to wz, as determined by calculateRotationRodriguesDerivative()

See also: calculateObjectTransformation2nx6().

◆ calculateOrientationalJacobianRodrigues2x3IF()

template<typename T , typename TRotation >

OCEAN_FORCE_INLINE void Ocean::Geometry::Jacobian::calculateOrientationalJacobianRodrigues2x3IF	(	const AnyCameraT< T > &	anyCamera,
		const TRotation &	flippedCamera_R_translation,
		const VectorT3< T > &	translation_T_world,
		const VectorT3< T > &	worldObjectPoint,
		const SquareMatrixT3< T > &	dwx,
		const SquareMatrixT3< T > &	dwy,
		const SquareMatrixT3< T > &	dwz,
		T *	jx,
		T *	jy
	)

static

Calculates the two Jacobian rows for the 3-DOF rotational part of a 6-DOF camera pose and a given 3D object point.

The 6-DOF camera pose is separated into a (fixed) translational part and a (flexible) rotational part.
This function uses the pre-calculated 3x3 Jacobian matrix of the camera's orientation provided by three separated 3x3 matrices.
The 3 derivatives are calculated for the 3-DOF orientation.
The resulting jacobian rows have the following form:

| dfx / dwx, dfx / dwy, dfx / dwz |
| dfy / dwx, dfy / dwy, dfy / dwz |

With transformation function f = (fx, fy) and exponential map w = (wx, wy, wz).
The jacobian calculation uses the Rodrigues rotation formula to determine the rotation derivatives. In the following, how to separate a common (inverted flipped) 6-DOF camera pose into a translational and rotational part.

world_T_camera:     translational part   rotational part
| R | t |           | I | t |            | R | 0 |
| 0 | 1 |         = | 0 | 1 |      *     | 0 | 1 |

flippedCamera_T_world:   rotational part   translational part
| R | t |                | R | 0 |         | I | R^-1 t |
| 0 | 1 |              = | 0 | 1 |    *    | 0 |    1   |

Parameters

anyCamera	The camera profile to determine the jacobian values for, must be valid
flippedCamera_R_translation	The rotation between the translational part of the camera and the flipped camera pose, with default flipped camera pointing towards the positive z-space with y-axis downwards, must be valid
translation_T_world	The translation between the world and the translational part of the camera pose
worldObjectPoint	The 3D object point to determine the jacobian for, defined in world
dwx	Rotation matrix derived to wx, as determined by calculateRotationRodriguesDerivative()
dwy	Rotation matrix derived to wy, as determined by calculateRotationRodriguesDerivative()
dwz	Rotation matrix derived to wz, as determined by calculateRotationRodriguesDerivative()
jx	The resulting first row of the jacobian, with 3 column entries, must be valid
jy	The resulting second row of the jacobian, with 3 column entries, must be valid

See also: calculateRotationRodriguesDerivative().

Template Parameters

T	The scalar data type, either 'float' or 'double'
TRotation	The data type of the provided rotation, either 'QuaternionT<T>' or 'SquareMatrixT3<T>'

f = fC(fR(fT(X))

with fC camera function, fR object point rotation function, fT object point translation function

fR(fT(X)) = R(X + t)

◆ calculateOrientationCameraJacobianRodrigues2nx11()

static void Ocean::Geometry::Jacobian::calculateOrientationCameraJacobianRodrigues2nx11	(	Scalar *	jacobian,
		const PinholeCamera &	pinholeCamera,
		const Pose &	flippedCamera_P_world,
		const ConstIndexedAccessor< Vector3 > &	objectPoints
	)

static

Calculates the two jacobian rows for a given (orientational pose) and a camera and a set of static object points.

The jacobian is determined for the three rotational angle of the pose, the radial and tangential distortion of the camera and the intrinsic parameters of the camera.
The resulting jacobian has the following form:

| dfx / dwx, dfx / dwy, dfx / dwz, dfx / dk1, dfx / dk2, dfx / dp1, dfx / dp2, dfx / dFx, dfx / dFy, dfx / dmx, dfx / dmy |
| dfy / dwx, dfy / dwy, dfy / dwz, dfy / dk1, dfy / dk2, dfy / dp1, dfy / dp2, dfy / dFx, dfy / dFy, dfy / dmx, dfy / dmy |

With transformation function f = (fx, fy), exponential map w = (wx, wy, wz) and radial distortion k1, k2, tangential distortion p1, p2, focal parameters Fx, Fy and principal point (mx, my).
The jacobian calculation uses the Rodrigues rotation formula to determine the rotation derivatives.

Parameters

jacobian	First element in the first row of the entire row aligned jacobian matrix, with 2 * numberObjectPoints rows and 11 columns
pinholeCamera	The pinhole camera to determine the jacobian values for
flippedCamera_P_world	Inverted and flipped pose (rotation and translation) to determine the jacobian for
objectPoints	The accessor providing the 3D object points to determine the jacobian for

◆ calculateOrientationCameraJacobianRodrigues2x11()

static void Ocean::Geometry::Jacobian::calculateOrientationCameraJacobianRodrigues2x11	(	Scalar *	jx,
		Scalar *	jy,
		const PinholeCamera &	pinholeCamera,
		const Pose &	flippedCamera_P_world,
		const Vector3 &	objectPoint
	)

static

Calculates the two jacobian rows for a given (orientational pose) and a camera and a static object point.

The jacobian is determined for the three rotational angle of the pose, the radial and tangential distortion of the camera and the intrinsic parameters of the camera.
The resulting jacobian has the following form:

| dfx / dwx, dfx / dwy, dfx / dwz, dfx / dk1, dfx / dk2, dfx / dp1, dfx / dp2, dfx / dFx, dfx / dFy, dfx / dmx, dfx / dmy |
| dfy / dwx, dfy / dwy, dfy / dwz, dfy / dk1, dfy / dk2, dfy / dp1, dfy / dp2, dfy / dFx, dfy / dFy, dfy / dmx, dfy / dmy |

With transformation function f = (fx, fy), exponential map w = (wx, wy, wz) and radial distortion k1, k2, tangential distortion p1, p2, focal parameters Fx, Fy and principal point (mx, my).
The jacobian calculation uses the Rodrigues rotation formula to determine the rotation derivatives.

Parameters

jx	First row of the jacobian, with 11 column entries
jy	Second row of the jacobian, with 11 column entries
pinholeCamera	The pinhole camera to determine the jacobian values for
flippedCamera_P_world	Inverted and flipped pose (rotation and translation) to determine the jacobian for
objectPoint	3D object point to determine the jacobian for

◆ calculateOrientationJacobianRodrigues2nx3()

static void Ocean::Geometry::Jacobian::calculateOrientationJacobianRodrigues2nx3	(	Scalar *	jacobian,
		const PinholeCamera &	pinholeCamera,
		const Pose &	flippedCamera_P_world,
		const ConstIndexedAccessor< Vector3 > &	objectPoints,
		const bool	distortImagePoints
	)

static

Deprecated.

Calculates all 3-DOF orientational jacobian rows for a given (flexible) pose and a set of static 3D object points. The 3 derivatives are calculated for the orientation part of the 6DOF pose.
The resulting jacobian rows have the following form:

| dfx / dwx, dfx / dwy, dfx / dwz |
| dfy / dwx, dfy / dwy, dfy / dwz |

With transformation function f = (fx, fy), exponential map w = (wx, wy, wz).
The jacobian calculation uses the Rodrigues rotation formula to determine the rotation derivatives.

Parameters

jacobian	First element in the first row of the entire row aligned jacobian matrix, with 2 * objectPoints.size() rows and 6 columns
pinholeCamera	The pinhole camera to determine the jacobian values for
flippedCamera_P_world	Inverted and flipped pose (rotation and translation) to determine the jacobian for, while the rotational part is use only
objectPoints	The accessor providing the 3D object points to determine the jacobian for
distortImagePoints	True, to force the distortion of the image points using the distortion parameters of this camera object

See also: calculateOrientationJacobianRodrigues2x3().

◆ calculateOrientationJacobianRodrigues2nx3IF()

template<typename T >

static void Ocean::Geometry::Jacobian::calculateOrientationJacobianRodrigues2nx3IF	(	T *	jacobian,
		const AnyCameraT< T > &	camera,
		const ExponentialMapT< T > &	flippedCamera_R_world,
		const ConstIndexedAccessor< VectorT3< T >> &	objectPoints
	)

static

Calculates all 3-DOF orientational jacobian rows for a given (flexible) camera pose and a set of static 3D object points.

The 3 derivatives are calculated for the orientation part of the 6-DOF pose.
The resulting jacobian rows have the following form:

| dfx / dwx, dfx / dwy, dfx / dwz |
| dfy / dwx, dfy / dwy, dfy / dwz |

With transformation function f = (fx, fy), exponential map w = (wx, wy, wz).
The jacobian calculation uses the Rodrigues rotation formula to determine the rotation derivatives.

Parameters

jacobian	First element in the first row of the entire row aligned jacobian matrix, with 2 * objectPoints.size() rows and 6 columns
camera	The camera profile defining the projection, must be valid
flippedCamera_R_world	Inverted and flipped camera pose to determine the jacobian for
objectPoints	The accessor providing the 3D object points to determine the jacobian for

Template Parameters

T	The scalar data type, either 'float' or 'double'

See also: calculateOrientationJacobianRodrigues2x3().

◆ calculatePointJacobian2nx3()

static void Ocean::Geometry::Jacobian::calculatePointJacobian2nx3	(	Scalar *	jacobian,
		const PinholeCamera &	pinholeCamera,
		const HomogenousMatrix4 &	flippedCamera_P_world,
		const Vector3 *	objectPoints,
		const size_t	numberObjectPoints,
		const bool	distortImagePoints
	)

static

Calculates the two jacobian rows for a given pose and several dynamic object points.

The derivatives are calculated for the 3D object point only.
The resulting jacobian rows have the following form:

| dfx / dX0, dfx / dY0, dfx / dZ0 |
| dfy / dX0, dfy / dY0, dfy / dZ0 |
| dfx / dX1, dfx / dY1, dfx / dZ1 |
| dfx / dX1, dfx / dY1, dfx / dZ1 |
| ............................... |
| ............................... |

Parameters

jacobian	First element in the first row of the entire row aligned jacobian matrix, with 2 * numberObjectPoints rows and 3 columns
pinholeCamera	The pinhole camera to determine the jacobian values for
flippedCamera_P_world	Pose to determine the jacobian for (inverted and flipped)
objectPoints	3D objects point to determine the jacobian for
numberObjectPoints	Number of 3D object points
distortImagePoints	True, to force the distortion of the image points using the distortion parameters of this camera object

◆ calculatePointJacobian2x3() [1/2]

static void Ocean::Geometry::Jacobian::calculatePointJacobian2x3	(	Scalar *	jx,
		Scalar *	jy,
		const FisheyeCamera &	fisheyeCamera,
		const HomogenousMatrix4 &	flippedCamera_T_world,
		const Vector3 &	worldObjectPoint
	)

static

Calculates the two jacobian rows for a given pose and dynamic object point.

The derivatives are calculated for the 3D object point only.
The resulting jacobian rows have the following form:

| dfx / dX, dfx / dY, dfx / dZ |
| dfy / dX, dfy / dY, dfy / dZ |

Parameters

jx	First row of the jacobian, with 3 column entries receiving the point derivatives
jy	Second row of the jacobian, with 3 column entries receiving the point derivatives
fisheyeCamera	Fisheye camera profile defining the projection, must be valid
flippedCamera_T_world	Flipped and inverted pose of the camera, must be valid
worldObjectPoint	The 3D object point, defined in world

◆ calculatePointJacobian2x3() [2/2]

static void Ocean::Geometry::Jacobian::calculatePointJacobian2x3	(	Scalar *	jx,
		Scalar *	jy,
		const PinholeCamera &	pinholeCamera,
		const HomogenousMatrix4 &	flippedCamera_P_world,
		const Vector3 &	objectPoint,
		const bool	distortImagePoint
	)

static

Calculates the two jacobian rows for a given pose and dynamic object point.

The derivatives are calculated for the 3D object point only.
The resulting jacobian rows have the following form:

| dfx / dX, dfx / dY, dfx / dZ |
| dfy / dX, dfy / dY, dfy / dZ |

Parameters

jx	First row of the jacobian, with 3 column entries receiving the point derivatives
jy	Second row of the jacobian, with 3 column entries receiving the point derivatives
pinholeCamera	The pinhole camera to determine the jacobian values for
flippedCamera_P_world	Pose to determine the jacobian for (inverted and flipped)
objectPoint	3D object point to determine the jacobian for
distortImagePoint	True, to force the distortion of the image point using the distortion parameters of this camera object

◆ calculatePointJacobian2x3IF()

template<typename T >

OCEAN_FORCE_INLINE void Ocean::Geometry::Jacobian::calculatePointJacobian2x3IF	(	const AnyCameraT< T > &	anyCamera,
		const HomogenousMatrixT4< T > &	flippedCamera_T_world,
		const VectorT3< T > &	worldObjectPoint,
		T *	jx,
		T *	jy
	)

static

Calculates the two jacobian rows for a given pose and dynamic object point.

The derivatives are calculated for the 3D object point only.
The resulting jacobian rows have the following form:

| dfx / dX, dfx / dY, dfx / dZ |
| dfy / dX, dfy / dY, dfy / dZ |

Parameters

anyCamera	The camera profile defining the projection, must be valid
flippedCamera_T_world	Flipped and inverted pose of the camera, must be valid
worldObjectPoint	The 3D object point, defined in world
jx	The resulting first row of the jacobian, with 3 column entries receiving the point derivatives, must be valid
jy	The resulting second row of the jacobian, with 3 column entries receiving the point derivatives, must be valid

Template Parameters

T	The scalar data type

◆ calculatePoseJacobianRodrigues2nx5()

static void Ocean::Geometry::Jacobian::calculatePoseJacobianRodrigues2nx5	(	Scalar *	jacobian,
		const PinholeCamera &	pinholeCamera,
		const ExponentialMap &	rotation,
		const Vector2 &	translation,
		const Vector3 *	objectPoints,
		const size_t	numberObjectPoints
	)

static

Calculates all jacobian rows for a given pose with translation scale ambiguities and a set of static object points.

The 5 derivatives are calculated for the 5DOF pose.
The resulting jacobian rows have the following form:

| dfx / dwx, dfx / dwy, dfx / dwz, dfx / dtu, dfx / dtv |
| dfy / dwx, dfy / dwy, dfy / dwz, dfy / dtu, dfy / dtv |

With transformation function f = (fx, fy), exponential map w = (wx, wy, wz) and translation t = (tu, tv, sqrt(1 - tu*tu - tv*tv)).
The jacobian calculation uses the Rodrigues rotation formula to determine the rotation derivatives.

Parameters

jacobian	First row of the entire row aligned jacobian matrix, with 2 * numberObjectPoints rows and 5 columns
pinholeCamera	The pinhole camera to determine the jacobian values for
rotation	Exponential map defining the rotation to determine the jacobian for
translation	Translation with scale ambiguities to determine the jacobian for, with range txtx + tyty < 1
objectPoints	3D object points to determine the jacobian for
numberObjectPoints	Number of given object points

◆ calculatePoseJacobianRodrigues2nx6()

static void Ocean::Geometry::Jacobian::calculatePoseJacobianRodrigues2nx6	(	Scalar *	jacobian,
		const PinholeCamera &	pinholeCamera,
		const Pose &	flippedCamera_P_world,
		const Vector3 *	objectPoints,
		const size_t	numberObjectPoints,
		const bool	distortImagePoints
	)

static

Deprecated.

Calculates all pose jacobian rows for a given (flexible) pose with a static camera profile supporting distortion and a set of static 3D object points. The 6 derivatives are calculated for the entire 6DOF pose.
The resulting jacobian rows have the following form:

| dfx / dwx, dfx / dwy, dfx / dwz, dfx / dtx, dfx / dty, dfx / dtz |
| dfy / dwx, dfy / dwy, dfy / dwz, dfy / dtx, dfy / dty, dfy / dtz |

With transformation function f = (fx, fy), exponential map w = (wx, wy, wz) and translation t = (tx, ty, tz).
The jacobian calculation uses the Rodrigues rotation formula to determine the rotation derivatives.

Parameters

jacobian	First element in the first row of the entire row aligned jacobian matrix, with 2 * numberObjectPoints rows and 6 columns
pinholeCamera	The pinhole camera to determine the jacobian values for
flippedCamera_P_world	Inverted and flipped pose (rotation and translation) to determine the jacobian for
objectPoints	3D object points to determine the jacobian for
numberObjectPoints	Number of given object points
distortImagePoints	True, to force the distortion of the image points using the distortion parameters of this camera object

See also: calculatePoseJacobianRodrigues2x6().

◆ calculatePoseJacobianRodrigues2nx6IF()

template<typename T >

static void Ocean::Geometry::Jacobian::calculatePoseJacobianRodrigues2nx6IF	(	T *	jacobian,
		const AnyCameraT< T > &	camera,
		const PoseT< T > &	flippedCamera_P_world,
		const VectorT3< T > *	objectPoints,
		const size_t	numberObjectPoints
	)

static

Calculates all jacobian rows for a given (flexible) 6-DOF camera pose with a static camera profile and several static 3D object points.

The 6 derivatives are calculated for the entire 6DOF pose.
The resulting jacobian rows have the following form:

| dfx / dwx, dfx / dwy, dfx / dwz, dfx / dtx, dfx / dty, dfx / dtz |
| dfy / dwx, dfy / dwy, dfy / dwz, dfy / dtx, dfy / dty, dfy / dtz |

With transformation function f = (fx, fy), exponential map w = (wx, wy, wz) and translation t = (tx, ty, tz).
The jacobian calculation uses the Rodrigues rotation formula to determine the rotation derivatives.

Parameters

jacobian	First element in the first row of the (row major aligned) jacobian matrix, with 2 * numberObjectPoints rows and 6 columns
camera	The camera profile defining the projection, must be valid
flippedCamera_P_world	The inverted and flipped pose to determine the jacobian for, with default flipped camera pointing towards the positive z-space with y-axis downwards, must be valid
objectPoints	The 3D object points to determine the jacobian for, must be valid
numberObjectPoints	The number of given object points, with range [1, infinity)

See also: calculatePoseJacobianRodrigues2x6IF().

◆ calculatePoseJacobianRodrigues2x5()

static void Ocean::Geometry::Jacobian::calculatePoseJacobianRodrigues2x5	(	Scalar *	jx,
		Scalar *	jy,
		const PinholeCamera &	pinholeCamera,
		const ExponentialMap &	rotation,
		const Vector2 &	translation,
		const Vector3 &	objectPoint
	)

static

Calculates the two jacobian rows for a given pose with translation scale ambiguities and static object point.

The 5 derivatives are calculated for the 5DOF pose.
The resulting jacobian rows have the following form:

| dfx / dwx, dfx / dwy, dfx / dwz, dfx / dtu, dfx / dtv |
| dfy / dwx, dfy / dwy, dfy / dwz, dfy / dtu, dfy / dtv |

With transformation function f = (fx, fy), exponential map w = (wx, wy, wz) and translation t = (tu, tv, sqrt(1 - tu*tu - tv*tv)).
The jacobian calculation uses the Rodrigues rotation formula to determine the rotation derivatives.

Parameters

jx	First row of the jacobian, with 5 column entries
jy	Second row of the jacobian, with 5 column entries
pinholeCamera	The pinhole camera to determine the jacobian values for
rotation	Exponential map defining the rotation to determine the jacobian for
translation	Translation with scale ambiguities to determine the jacobian for, with range txtx + tyty < 1
objectPoint	3D object point to determine the jacobian for

◆ calculatePoseJacobianRodrigues2x6() [1/3]

static void Ocean::Geometry::Jacobian::calculatePoseJacobianRodrigues2x6	(	Scalar *	jx,
		Scalar *	jy,
		const FisheyeCamera &	fisheyeCamera,
		const HomogenousMatrix4 &	flippedCamera_T_world,
		const Vector3 &	worldObjectPoint,
		const SquareMatrix3 &	dwx,
		const SquareMatrix3 &	dwy,
		const SquareMatrix3 &	dwz
	)

static

Deprecated.

Calculates the two jacobian rows for a given (flexible) pose and one static 3D object point. This function uses the pre-calculated 3x3 Jacobian matrix of the camera's orientation provided by three separated 3x3 matrices.
The 6 derivatives are calculated for the 6DOF pose.
The resulting jacobian rows have the following form:

| dfx / dwx, dfx / dwy, dfx / dwz, dfx / dtx, dfx / dty, dfx / dtz |
| dfy / dwx, dfy / dwy, dfy / dwz, dfy / dtx, dfy / dty, dfy / dtz |

With transformation function f = (fx, fy), exponential map w = (wx, wy, wz) and translation t = (tx, ty, tz).
The jacobian calculation uses the Rodrigues rotation formula to determine the rotation derivatives.

Parameters

jx	First row of the jacobian, with 6 column entries
jy	Second row of the jacobian, with 6 column entries
fisheyeCamera	Fisheye camera to determine the jacobian values for, must be valid
flippedCamera_T_world	Inverted and flipped pose (rotation and translation) to determine the jacobian for
worldObjectPoint	3D object point to determine the jacobian for, in world coordinate system
dwx	Rotation matrix derived to wx, as determined by calculateRotationRodriguesDerivative()
dwy	Rotation matrix derived to wy, as determined by calculateRotationRodriguesDerivative()
dwz	Rotation matrix derived to wz, as determined by calculateRotationRodriguesDerivative()

See also: calculateRotationRodriguesDerivative().

◆ calculatePoseJacobianRodrigues2x6() [2/3]

static void Ocean::Geometry::Jacobian::calculatePoseJacobianRodrigues2x6	(	Scalar *	jx,
		Scalar *	jy,
		const PinholeCamera &	pinholeCamera,
		const HomogenousMatrix4 &	flippedCamera_P_world,
		const Vector3 &	objectPoint,
		const bool	distortImagePoint,
		const SquareMatrix3 &	dwx,
		const SquareMatrix3 &	dwy,
		const SquareMatrix3 &	dwz
	)

static

Deprecated.

Calculates the two jacobian rows for a given (flexible) pose and one static 3D object point. This function uses the pre-calculated 3x3 Jacobian matrix of the camera's orientation provided by three separated 3x3 matrices.
The 6 derivatives are calculated for the 6DOF pose.
The resulting jacobian rows have the following form:

| dfx / dwx, dfx / dwy, dfx / dwz, dfx / dtx, dfx / dty, dfx / dtz |
| dfy / dwx, dfy / dwy, dfy / dwz, dfy / dtx, dfy / dty, dfy / dtz |

With transformation function f = (fx, fy), exponential map w = (wx, wy, wz) and translation t = (tx, ty, tz).
The jacobian calculation uses the Rodrigues rotation formula to determine the rotation derivatives.

Parameters

jx	First row of the jacobian, with 6 column entries
jy	Second row of the jacobian, with 6 column entries
pinholeCamera	The pinhole camera to determine the jacobian values for
flippedCamera_P_world	Inverted and flipped pose (rotation and translation) to determine the jacobian for
objectPoint	3D object point to determine the jacobian for
distortImagePoint	True, to force the distortion of the image point using the distortion parameters of this camera object
dwx	Rotation matrix derived to wx, as determined by calculateRotationRodriguesDerivative()
dwy	Rotation matrix derived to wy, as determined by calculateRotationRodriguesDerivative()
dwz	Rotation matrix derived to wz, as determined by calculateRotationRodriguesDerivative()

See also: calculateRotationRodriguesDerivative().

◆ calculatePoseJacobianRodrigues2x6() [3/3]

void Ocean::Geometry::Jacobian::calculatePoseJacobianRodrigues2x6	(	Scalar *	jx,
		Scalar *	jy,
		const PinholeCamera &	pinholeCamera,
		const Pose &	flippedCamera_P_world,
		const Vector3 &	objectPoint,
		const bool	distortImagePoint
	)

inlinestatic

Calculates the two jacobian rows for a given (flexible) pose and static camera and one static 3D object point.

The 6 derivatives are calculated for the 6DOF pose.
The resulting jacobian rows have the following form:

| dfx / dwx, dfx / dwy, dfx / dwz, dfx / dtx, dfx / dty, dfx / dtz |
| dfy / dwx, dfy / dwy, dfy / dwz, dfy / dtx, dfy / dty, dfy / dtz |

With transformation function f = (fx, fy), exponential map w = (wx, wy, wz) and translation t = (tx, ty, tz).
The jacobian calculation uses the Rodrigues rotation formula to determine the rotation derivatives.

Parameters

jx	First row of the jacobian, with 6 column entries
jy	Second row of the jacobian, with 6 column entries
pinholeCamera	The pinhole camera to determine the jacobian values for
flippedCamera_P_world	Inverted and flipped pose (rotation and translation) to determine the jacobian for
objectPoint	3D object point to determine the jacobian for
distortImagePoint	True, to force the distortion of the image point using the distortion parameters of this camera object

See also: calculatePoseJacobianRodrigues2nx6().

◆ calculatePoseJacobianRodrigues2x6IF()

template<typename T >

OCEAN_FORCE_INLINE void Ocean::Geometry::Jacobian::calculatePoseJacobianRodrigues2x6IF	(	const AnyCameraT< T > &	anyCamera,
		const HomogenousMatrixT4< T > &	flippedCamera_T_world,
		const VectorT3< T > &	worldObjectPoint,
		const SquareMatrixT3< T > &	dwx,
		const SquareMatrixT3< T > &	dwy,
		const SquareMatrixT3< T > &	dwz,
		T *	jx,
		T *	jy
	)

static

Calculates the two jacobian rows for a given (flexible) 6-DOF camera pose and one static 3D object point.

This function uses the pre-calculated 3x3 Jacobian matrix of the camera's orientation provided by three separated 3x3 matrices.
The 6 derivatives are calculated for the 6DOF pose.
The resulting jacobian rows have the following form:

| dfx / dwx, dfx / dwy, dfx / dwz, dfx / dtx, dfx / dty, dfx / dtz |
| dfy / dwx, dfy / dwy, dfy / dwz, dfy / dtx, dfy / dty, dfy / dtz |

With transformation function f = (fx, fy), exponential map w = (wx, wy, wz) and translation t = (tx, ty, tz).
The jacobian calculation uses the Rodrigues rotation formula to determine the rotation derivatives.

Parameters

anyCamera	The camera profile to determine the jacobian values for, must be valid
flippedCamera_T_world	The inverted and flipped camera pose to determine the jacobian for, with default flipped camera pointing towards the positive z-space with y-axis downwards, must be valid
worldObjectPoint	3D object point to determine the jacobian for, in world coordinate system
dwx	Rotation matrix derived to wx, as determined by calculateRotationRodriguesDerivative()
dwy	Rotation matrix derived to wy, as determined by calculateRotationRodriguesDerivative()
dwz	Rotation matrix derived to wz, as determined by calculateRotationRodriguesDerivative()
jx	The resulting first row of the jacobian, with 6 column entries, must be valid
jy	The resulting second row of the jacobian, with 6 column entries, must be valid

See also: calculateRotationRodriguesDerivative().

Template Parameters

T	The scalar data type

◆ calculatePoseJacobianRodriguesDampedDistortion2nx6()

static void Ocean::Geometry::Jacobian::calculatePoseJacobianRodriguesDampedDistortion2nx6	(	Scalar *	jacobian,
		const PinholeCamera &	pinholeCamera,
		const Pose &	flippedCamera_P_world,
		const Scalar	dampingFactor,
		const Vector3 *	objectPoints,
		const size_t	numberObjectPoints,
		const bool	distortImagePoints
	)

static

Calculates all pose jacobian rows for a given (flexible) pose with a static camera profile supporting distortion and a set of static 3D object points.

The distortion is damped for 3D object points not projecting into the camera frame but outside the camera frame.
The 6 derivatives are calculated for the entire 6DOF pose.
The resulting jacobian rows have the following form:

| dfx / dwx, dfx / dwy, dfx / dwz, dfx / dtx, dfx / dty, dfx / dtz |
| dfy / dwx, dfy / dwy, dfy / dwz, dfy / dtx, dfy / dty, dfy / dtz |

With transformation function f = (fx, fy), exponential map w = (wx, wy, wz) and translation t = (tx, ty, tz).
The jacobian calculation uses the Rodrigues rotation formula to determine the rotation derivatives.

Parameters

jacobian	First element in the first row of the entire row aligned jacobian matrix, with 2 * numberObjectPoints rows and 6 columns
pinholeCamera	The pinhole camera to determine the jacobian values for
flippedCamera_P_world	Inverted and flipped pose (rotation and translation) to determine the jacobian for
dampingFactor	The factor defining the boundary of the asymptotic damping behavior for normalized coordinates, with range [0, infinity)
objectPoints	3D object points to determine the jacobian for
numberObjectPoints	Number of given object points
distortImagePoints	True, to force the distortion of the image points using the distortion parameters of this camera object

See also: calculatePoseJacobianRodrigues2x6().

◆ calculatePoseZoomJacobianRodrigues2nx7()

static void Ocean::Geometry::Jacobian::calculatePoseZoomJacobianRodrigues2nx7	(	Scalar *	jacobian,
		const PinholeCamera &	pinholeCamera,
		const Pose &	flippedCamera_P_world,
		const Scalar	zoom,
		const Vector3 *	objectPoints,
		const size_t	numberObjectPoints,
		const bool	distortImagePoints
	)

static

Calculates all pose jacobian rows for a given (flexible) pose with (flexible) zoom factor and a set of static 3D object points.

The 7 derivatives are calculated for the entire 6DOF pose including the zoom factor.
The resulting jacobian rows have the following form:

| dfx / dwx, dfx / dwy, dfx / dwz, dfx / dtx, dfx / dty, dfx / dtz, dfx / dts |
| dfy / dwx, dfy / dwy, dfy / dwz, dfy / dtx, dfy / dty, dfy / dtz, dfy / dts |

With transformation function f = (fx, fy), exponential map w = (wx, wy, wz), translation t = (tx, ty, tz) and zoom factor s.
The jacobian calculation uses the Rodrigues rotation formula to determine the rotation derivatives.

Parameters

jacobian	First element in the first row of the entire row aligned jacobian matrix, with 2 * numberObjectPoints rows and 7 columns
pinholeCamera	The pinhole camera to determine the jacobian values for
flippedCamera_P_world	Inverted and flipped pose (rotation and translation) to determine the jacobian for
zoom	The zoom factor of the pose, with range (0, infinity)
objectPoints	3D object points to determine the jacobian for
numberObjectPoints	Number of given object points
distortImagePoints	True, to force the distortion of the image points using the distortion parameters of this camera object

◆ calculatePoseZoomJacobianRodrigues2x7()

static void Ocean::Geometry::Jacobian::calculatePoseZoomJacobianRodrigues2x7	(	Scalar *	jx,
		Scalar *	jy,
		const PinholeCamera &	pinholeCamera,
		const Pose &	flippedCamera_P_world,
		const Scalar	zoom,
		const Vector3 &	objectPoint,
		const bool	distortImagePoints
	)

static

Calculates the two jacobian rows for a given (flexible) pose with (flexible) zoom factor and one static 3D object point.

The 7 derivatives are calculated for the entire 6DOF pose including the zoom factor.
The resulting jacobian rows have the following form:

| dfx / dwx, dfx / dwy, dfx / dwz, dfx / dtx, dfx / dty, dfx / dtz, dfx / dts |
| dfy / dwx, dfy / dwy, dfy / dwz, dfy / dtx, dfy / dty, dfy / dtz, dfy / dts |

With transformation function f = (fx, fy), exponential map w = (wx, wy, wz), translation t = (tx, ty, tz) and zoom factor s.
The jacobian calculation uses the Rodrigues rotation formula to determine the rotation derivatives.

Parameters

jx	First row of the jacobian, with 7 column entries
jy	Second row of the jacobian, with 7 column entries
pinholeCamera	The pinhole camera to determine the jacobian values for
flippedCamera_P_world	Inverted and flipped pose (rotation and translation) to determine the jacobian for
zoom	The zoom factor of the pose, with range (0, infinity)
objectPoint	3D object point to determine the jacobian for
distortImagePoints	True, to force the distortion of the image points using the distortion parameters of this camera object

◆ calculateRotationRodriguesDerivative()

template<typename T >

static void Ocean::Geometry::Jacobian::calculateRotationRodriguesDerivative	(	const ExponentialMapT< T > &	rotation,
		SquareMatrixT3< T > &	dwx,
		SquareMatrixT3< T > &	dwy,
		SquareMatrixT3< T > &	dwz
	)

static

This function determines the 3x3 Jacobian of a rotation function rotating a 3D object point by application of an exponential map.

The given exponential map stores the rotation as the rotation axis with a vector length equal to the rotation angle.
The Jacobian is determined by application of the Rodrigues formula for the specified exponential map.
The resulting 3x3 Jacobian depends on the three rotation parameters and on the 3D object point.
However, we can separate the dependency allowing to calculate the major parts of the Jacobian for the rotation parameters first.
Therefore, we calculate three 3x3 matrices depending only on the rotation parameters.
Each of the matrix can be used to calculate one column of the final 3x3 Jacobian by multiplication with the 3D object point.
Thus, we can reuse the three 3x3 matrices if we have several 3D object points which can improve the performance significantly.
The final 3x3 Jacobian for the provided exponential map and an object point O is defined by the following three vectors:
[dwx * O | dwy * O | dwz * O]

Parameters

rotation	The rotation for which the three derivative rotations will be determined
dwx	The resulting rotation matrix derived to wx
dwy	The resulting rotation matrix derived to wy
dwz	The resulting rotation matrix derived to wz

Template Parameters

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

◆ calculateSimilarityJacobian2x4()

void Ocean::Geometry::Jacobian::calculateSimilarityJacobian2x4	(	Scalar *	jx,
		Scalar *	jy,
		const Scalar	x,
		const Scalar	y,
		const SquareMatrix3 &	similarity
	)

inlinestatic

Determines the 2x4 Jacobian of a similarity transformation that transforms a 2D coordinate (interpreted as a 3D vector with homogeneous extension) to a 2D coordinate (the de-homogenization is included).

This Jacobian can be used e.g., for additive image alignment.
The resulting jacobian has the following form:

| dfx / ds0, dfx / ds1, dfx / ds2, dfx / ds3 |
| dfy / ds0, dfy / ds1, dfy / ds2, dfy / ds3 |

Parameters

jx	First row of the jacobian, with 4 column entries
jy	Second row of the jacobian, with 4 column entries
x	The horizontal coordinate to be used
y	The vertical coordinate to be used
similarity	The similarity for which the Jacobian will be determined, must have 1 in the lower right corner

◆ calculateSphericalObjectPointJacobian3x3()

template<typename T >

static void Ocean::Geometry::Jacobian::calculateSphericalObjectPointJacobian3x3	(	T *	jx,
		T *	jy,
		T *	jz,
		const ExponentialMapT< T > &	sphericalObjectPoint,
		const T	objectPointDistance
	)

static

Calculates the three jacobian rows for a given exponential rotation map representing the location of a 3D object point.

The rotation map defines the rotation of the vector [0, 0, -objectPointDistance].
The corresponding function f, which transforms the 3D object point defined in coordinates into a 3D object point defined in the Cartesian coordinate system, is given as follows:
f(w, r) = f(wx, wy, wz, r) = R(wx, wy, wz) * [0, 0, -r] = [ox, oy, oz]
The resulting 3x3 jacobian has the following form:

| dfx / dwx, dfx / dwy, dfx / dwz |
| dfy / dwx, dfy / dwy, dfy / dwz |
| dfz / dwx, dfz / dwy, dfz / dwz |

Parameters

jx	First row of the resulting jacobian, with 3 column entries
jy	Second row of the resulting jacobian, with 3 column entries
jz	Third row of the resulting jacobian, with 3 column entries
sphericalObjectPoint	The rotation defining the 3D object point for which the derivatives will be determined
objectPointDistance	The distance of the 3D object point, which is the distance to the origin, with range (0, infinity)

Template Parameters

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

◆ calculateSphericalObjectPointOrientationJacobian2x3IF()

template<typename T >

static void Ocean::Geometry::Jacobian::calculateSphericalObjectPointOrientationJacobian2x3IF	(	T *	jx,
		T *	jy,
		const AnyCameraT< T > &	camera,
		const SquareMatrixT3< T > &	flippedCamera_R_world,
		const ExponentialMapT< T > &	sphericalObjectPoint,
		const T	objectPointDistance
	)

static

Calculates the two jacobian rows for a given exponential rotation map representing the location of a 3D object point projecting into the camera frame with orientational camera pose.

The rotation map defines the rotation of the vector [0, 0, -objectPointDistance].
The corresponding function f is given as follows:
f(w, r) = fproj(fori(fobj(wx, wy, wz, r))) = [x, y]
Where fobj translates the location of the 3D object point defined in spherical coordinates into a 3D object point defined in the Cartesian coordinate system. fproj defines the function which projects (and optional distorts) a 3D object point into the camera,
and fori defines the function which applies the orientation (rotational pose) of the camera.
The resulting 2x3 jacobian has the following form:

| dfx / dwx, dfx / dwy, dfx / dwz |
| dfy / dwx, dfy / dwy, dfy / dwz |

Parameters

jx	First row of the resulting jacobian, with 3 column entries
jy	Second row of the resulting jacobian, with 3 column entries
camera	The camera profile defining the projection, must be valid
flippedCamera_R_world	The inverted and flipped orientation of the camera, transforming the world to the flipped camera, with default flipped camera pointing towards the positive z-space with y-axis downwards, must be valid
sphericalObjectPoint	The rotation defining the 3D object point for which the derivatives will be determined
objectPointDistance	The distance of the 3D object point, which is the distance to the origin, with range (0, infinity)

Template Parameters

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

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

Jacobian.h

Static Public Member Functions

Detailed Description

Member Function Documentation

◆ calculateCameraDistortionJacobian2x4()

◆ calculateCameraJacobian2x6()

◆ calculateCameraJacobian2x7()

◆ calculateCameraJacobian2x8()

◆ calculateFisheyeDistortNormalized2x2()

◆ calculateHomographyJacobian2x8()

◆ calculateHomographyJacobian2x9()

◆ calculateIdentityHomographyJacobian2x8()

◆ calculateIdentityHomographyJacobian2x9()

◆ calculateJacobianCameraPoseRodrigues2nx14()

◆ calculateJacobianCameraPoseRodrigues2x12() [1/2]

◆ calculateJacobianCameraPoseRodrigues2x12() [2/2]

◆ calculateJacobianCameraPoseRodrigues2x14() [1/2]

◆ calculateJacobianCameraPoseRodrigues2x14() [2/2]

◆ calculateObjectTransformation2nx6() [1/2]

◆ calculateObjectTransformation2nx6() [2/2]

◆ calculateObjectTransformation2x6() [1/2]

◆ calculateObjectTransformation2x6() [2/2]

◆ calculateOrientationalJacobianRodrigues2x3IF()

◆ calculateOrientationCameraJacobianRodrigues2nx11()

◆ calculateOrientationCameraJacobianRodrigues2x11()

◆ calculateOrientationJacobianRodrigues2nx3()

◆ calculateOrientationJacobianRodrigues2nx3IF()

◆ calculatePointJacobian2nx3()

◆ calculatePointJacobian2x3() [1/2]

◆ calculatePointJacobian2x3() [2/2]

◆ calculatePointJacobian2x3IF()

◆ calculatePoseJacobianRodrigues2nx5()

◆ calculatePoseJacobianRodrigues2nx6()

◆ calculatePoseJacobianRodrigues2nx6IF()

◆ calculatePoseJacobianRodrigues2x5()

◆ calculatePoseJacobianRodrigues2x6() [1/3]

◆ calculatePoseJacobianRodrigues2x6() [2/3]

◆ calculatePoseJacobianRodrigues2x6() [3/3]

◆ calculatePoseJacobianRodrigues2x6IF()

◆ calculatePoseJacobianRodriguesDampedDistortion2nx6()

◆ calculatePoseZoomJacobianRodrigues2nx7()

◆ calculatePoseZoomJacobianRodrigues2x7()

◆ calculateRotationRodriguesDerivative()

◆ calculateSimilarityJacobian2x4()

◆ calculateSphericalObjectPointJacobian3x3()

◆ calculateSphericalObjectPointOrientationJacobian2x3IF()