Ocean
Loading...
Searching...
No Matches
TestJacobian.h
Go to the documentation of this file.
1/*
2 * Copyright (c) Meta Platforms, Inc. and affiliates.
3 *
4 * This source code is licensed under the MIT license found in the
5 * LICENSE file in the root directory of this source tree.
6 */
7
8#ifndef META_OCEAN_TEST_TESTGEOMETRY_TEST_JACOBIAN_H
9#define META_OCEAN_TEST_TESTGEOMETRY_TEST_JACOBIAN_H
10
12
14
17
18namespace Ocean
19{
20
21namespace Test
22{
23
24namespace TestGeometry
25{
26
27/**
28 * This class implements Jacobian tests.
29 * @ingroup testgeometry
30 */
31class OCEAN_TEST_GEOMETRY_EXPORT TestJacobian : protected Geometry::Jacobian
32{
33 public:
34
35 /**
36 * Tests the entire Jacobian functionality.
37 * @param testDuration Number of seconds for each test, with range (0, infinity)
38 * @return True, if succeeded
39 */
40 static bool test(const double testDuration);
41
42 /**
43 * Tests the Jacobian for the rotational part of extrinsic camera parameters.
44 * @param testDuration Number of seconds for each test, with range (0, infinity)
45 * @return True, if succeeded
46 * @tparam T the data type of the scalar to be used, either 'float' or 'double'
47 */
48 template <typename T>
49 static bool testOrientationalJacobian2x3(const double testDuration);
50
51 /**
52 * Tests the Jacobian for the orientation of a camera.
53 * @param testDuration Number of seconds for each test, with range (0, infinity)
54 * @return True, if succeeded
55 * @tparam T the data type of the scalar to be used, either 'float' or 'double'
56 */
57 template <typename T>
58 static bool testOrientationJacobian2nx3(const double testDuration);
59
60 /**
61 * Deprecated.
62 *
63 * Tests the Jacobian for the extrinsic camera parameters and a pinhole camera.
64 * @param testDuration Number of seconds for each test, with range (0, infinity)
65 * @return True, if succeeded
66 */
67 static bool testPinholeCameraPoseJacobian2nx6(const double testDuration);
68
69 /**
70 * Deprecated.
71 *
72 * Tests the Jacobian for the extrinsic camera parameters and fisheye camera.
73 * @param testDuration Number of seconds for each test, with range (0, infinity)
74 * @return True, if succeeded
75 */
76 static bool testFisheyeCameraPoseJacobian2x6(const double testDuration);
77
78 /**
79 * Tests the Jacobian for the extrinsic camera parameters and any camera.
80 * @param testDuration Number of seconds for each test, with range (0, infinity)
81 * @return True, if succeeded
82 * @tparam T the data type of the scalar to be used, either 'float' or 'double'
83 */
84 template <typename T>
85 static bool testAnyCameraPoseJacobian2nx6(const double testDuration);
86
87 /**
88 * Tests the Jacobian for the extrinsic camera parameters using a damped distortion.
89 * @param testDuration Number of seconds for each test, with range (0, infinity)
90 * @return True, if succeeded
91 */
92 static bool testPoseJacobianDampedDistortion2nx6(const double testDuration);
93
94 /**
95 * Tests the Jacobian for the extrinsic camera parameters (including the zoom parameter).
96 * @param testDuration Number of seconds for each test, with range (0, infinity)
97 * @return True, if succeeded
98 */
99 static bool testPoseZoomJacobian2nx7(const double testDuration);
100
101 /**
102 * Tests the 2x6 Jacobian for a 6-DOF transformation with fixed camera pose.
103 * @param testDuration Number of seconds for each test, with range (0, infinity)
104 * @return True, if succeeded
105 */
106 static bool testPinholeCameraObjectTransformation2nx6(const double testDuration);
107
108 /**
109 * Tests the 2x6 Jacobian for a 6-DOF transformation with fixed camera pose.
110 * @param testDuration Number of seconds for each test, with range (0, infinity)
111 * @return True, if succeeded
112 */
113 static bool testFisheyeCameraObjectTransformation2nx6(const double testDuration);
114
115 /**
116 * Tests the Jacobian for an 2D image point projection in relation to an object point using a pinhole camera.
117 * @param testDuration Number of seconds for each test, with range (0, infinity)
118 * @return True, if succeeded
119 */
120 static bool testPinholeCameraPointJacobian2nx3(const double testDuration);
121
122 /**
123 * Tests the Jacobian for an 2D image point projection in relation to an object point using a fisheye camera.
124 * @param testDuration Number of seconds for each test, with range (0, infinity)
125 * @return True, if succeeded
126 */
127 static bool testFisheyeCameraPointJacobian2x3(const double testDuration);
128
129 /**
130 * Tests the Jacobian for an 2D image point projection in relation to an object point using any camera.
131 * @param testDuration Number of seconds for each test, with range (0, infinity)
132 * @return True, if succeeded
133 */
134 static bool testAnyCameraPointJacobian2x3(const double testDuration);
135
136 /**
137 * Tests the Jacobian for two 6DOF poses and a set of 3D object points.
138 * @param testDuration Number of seconds for each test, with range (0, infinity)
139 * @return True, if succeeded
140 */
141 static bool testPosesPointsJacobian2nx12(const double testDuration);
142
143 /**
144 * Tests the Jacobian for an exponential map representing a 3D object point.
145 * @param testDuration Number of seconds for each test, with range (0, infinity)
146 * @return True, if succeeded
147 */
148 static bool testSphericalObjectPoint3x3(const double testDuration);
149
150 /**
151 * Tests the Jacobian for an exponential map representing a 3D object point which is projected into the camera frame.
152 * @param testDuration Number of seconds for each test, with range (0, infinity)
153 * @return True, if succeeded
154 * @tparam T the data type of the scalar to be used, either 'float' or 'double'
155 */
156 template <typename T>
157 static bool testSphericalObjectPointOrientation2x3IF(const double testDuration);
158
159 /**
160 * Tests the Jacobian for the radial and tangential distortion camera parameters.
161 * @param testDuration Number of seconds for each test, with range (0, infinity)
162 * @return True, if succeeded
163 */
164 static bool testPinholeCameraDistortionJacobian2x4(const double testDuration);
165
166 /**
167 * Tests the Jacobian for the intrinsic and radial distortion of pinhole camera parameters.
168 * @param testDuration Number of seconds for each test, with range (0, infinity)
169 * @return True, if succeeded
170 */
171 static bool testPinholeCameraJacobian2x6(const double testDuration);
172
173 /**
174 * Tests the Jacobian for the intrinsic and radial and tangential distortion of pinhole camera parameters.
175 * @param testDuration Number of seconds for each test, with range (0, infinity)
176 * @return True, if succeeded
177 */
178 static bool testPinholeCameraJacobian2x7(const double testDuration);
179
180 /**
181 * Tests the Jacobian for the intrinsic, radial and tangential distortion of pinhole camera parameters.
182 * @param testDuration Number of seconds for each test, with range (0, infinity)
183 * @return True, if succeeded
184 * @tparam T the data type of the scalar to be used, either 'float' or 'double'
185 */
186 template <typename T>
187 static bool testPinholeCameraJacobian2x8(const double testDuration);
188
189 /**
190 * Tests the Jacobian for the intrinsic, radial and tangential distortion of fisheye camera parameters.
191 * @param testDuration Number of seconds for each test, with range (0, infinity)
192 * @return True, if succeeded
193 * @tparam T the data type of the scalar to be used, either 'float' or 'double'
194 */
195 template <typename T>
196 static bool testFisheyeCameraJacobian2x12(const double testDuration);
197
198 /**
199 * Tests the Jacobian for the rotational part of the extrinsic camera matrix, intrinsic and radial and tangential camera parameters.
200 * @param testDuration Number of seconds for each test, with range (0, infinity)
201 * @return True, if succeeded
202 */
203 static bool testOrientationPinholeCameraJacobian2x11(const double testDuration);
204
205 /**
206 * Tests the Jacobian for the extrinsic, intrinsic and radial camera parameters for a pinhole camera.
207 * @param testDuration Number of seconds for each test, with range (0, infinity)
208 * @return True, if succeeded
209 */
210 static bool testPosePinholeCameraJacobian2x12(const double testDuration);
211
212 /**
213 * Tests the Jacobian for the extrinsic, intrinsic and radial and tangential distortion camera parameters for a pinhole camera.
214 * @param testDuration Number of seconds for each test, with range (0, infinity)
215 * @return True, if succeeded
216 * @tparam T the data type of the scalar to be used, either 'float' or 'double'
217 */
218 template <typename T>
219 static bool testPosePinholeCameraJacobian2x14(const double testDuration);
220
221 /**
222 * Tests the Jacobian for the extrinsic, intrinsic and radial camera parameters and distortion parameters for a fisheye camera.
223 * @param testDuration Number of seconds for each test, with range (0, infinity)
224 * @return True, if succeeded
225 */
226 template <typename T>
227 static bool testPoseFisheyeCameraJacobian2x18(const double testDuration);
228
229 /**
230 * Tests the 2x8 Jacobian for the homography.
231 * @param testDuration Number of seconds for each test, with range (0, infinity)
232 * @return True, if succeeded
233 */
234 static bool testHomography2x8(const double testDuration);
235
236 /**
237 * Tests the 2x9 Jacobian for the homography.
238 * @param testDuration Number of seconds for each test, with range (0, infinity)
239 * @return True, if succeeded
240 */
241 static bool testHomography2x9(const double testDuration);
242
243 /**
244 * Tests the 2x8 Jacobian for the identity homography.
245 * @param testDuration Number of seconds for each test, with range (0, infinity)
246 * @return True, if succeeded
247 */
248 static bool testIdentityHomography2x8(const double testDuration);
249
250 /**
251 * Tests the 2x9 Jacobian for the identity homography.
252 * @param testDuration Number of seconds for each test, with range (0, infinity)
253 * @return True, if succeeded
254 */
255 static bool testIdentityHomography2x9(const double testDuration);
256
257 /**
258 * Tests the 2x4 Jacobian of a similarity transformation.
259 * @param testDuration Number of seconds for each test, with range (0, infinity)
260 * @return True, if succeeded
261 */
262 static bool testSimilarity2x4(const double testDuration);
263
264 /**
265 * Tests the 2x2 Jacobian of the distortion of a normalized image point for a fisheye camera.
266 * @param testDuration Number of seconds for each test, with range (0, infinity)
267 * @return True, if succeeded
268 * @tparam T the data type of the scalar to be used, 'float', or 'double'
269 */
270 template <typename T>
271 static bool testCalculateFisheyeDistortNormalized2x2(const double testDuration);
272
273 private:
274
275 /**
276 * Determines the derivative for a given 2D position and compares the accuracy with the precise derivatives.
277 * @param original The original 2D position
278 * @param offset The offset position (result of the epsilon offset)
279 * @param eps The epsilon which was used to create the offset position, with range (0, infinity)
280 * @param derivativeX The precise derivative in x-direction to verify
281 * @param derivativeY The precise derivative in y-direction to verify
282 * @return True, if so
283 * @tparam T The data type of the scalar to be used, 'float' or 'double'
284 * @tparam TDerivative The data type of the derivative, `float` or `double`
285 */
286 template <typename T, typename TDerivative>
287 static inline bool checkAccuracy(const VectorT2<T>& original, const VectorT2<T>& offset, const T eps, const TDerivative derivativeX, const TDerivative derivativeY);
288
289 /**
290 * Determines the derivative for a given 3D position and compares the accuracy with the precise derivatives.
291 * @param original The original 2D position
292 * @param offset The offset position (result of the epsilon offset)
293 * @param eps The epsilon which was used to create the offset position, with range (0, infinity)
294 * @param derivativeX The precise derivative in x-direction to verify
295 * @param derivativeY The precise derivative in y-direction to verify
296 * @param derivativeZ The precise derivative in z-direction to verify
297 * @return True, if so
298 * @tparam T The data type of the scalar to be used, 'float' or 'double'
299 */
300 template <typename T, typename TDerivative>
301 static inline bool checkAccuracy(const VectorT3<T>& original, const VectorT3<T>& offset, const T eps, const TDerivative derivativeX, const TDerivative derivativeY, const TDerivative derivativeZ);
302
303 /**
304 * Calculates the two Jacobian rows for a given pose and dynamic object point.
305 * The derivatives are calculated for the 3D object point only.<br>
306 * The resulting Jacobian rows have the following form:<br>
307 * | dfx / dX, dfx / dY, dfx / dZ |<br>
308 * | dfy / dX, dfy / dY, dfy / dZ |<br>
309 * @param jx First row position of the jacobian, with 3 column entries receiving the point derivatives
310 * @param jy Second row position of the jacobian, with 3 column entries receiving the point derivatives
311 * @param pinholeCamera The pinhole camera to determine the Jacobian values for
312 * @param flippedCamera_T_world Pose to determine the Jacobian for (inverted and flipped)
313 * @param objectPoint 3D object point to determine the Jacobian for
314 * @param distortImagePoint True, to force the distortion of the image point using the distortion parameters of this camera object
315 * @tparam tUseBorderDistortionIfOutside True, to apply the distortion from the nearest point lying on the frame border if the point lies outside the visible camera area; False to apply the distortion from the given position
316 */
317 template <bool tUseBorderDistortionIfOutside>
318 static void calculatePointJacobian2x3(Scalar* jx, Scalar* jy, const PinholeCamera& pinholeCamera, const HomogenousMatrix4& flippedCamera_T_world, const Vector3& objectPoint, const bool distortImagePoint);
319
320 /**
321 * Returns the minimal threshold necessary to succeed a verification.
322 * @return The necessary success rate, in percent, with range [0, 1]
323 */
324 static constexpr double successThreshold();
325};
326
327template <typename T, typename TDerivative>
328bool TestJacobian::checkAccuracy(const VectorT2<T>& original, const VectorT2<T>& offset, const T eps, const TDerivative derivativeX, const TDerivative derivativeY)
329{
330 static_assert(sizeof(TDerivative) <= sizeof(T), "The derivative should not have more precision than epsilon");
331
332 ocean_assert(eps > NumericT<T>::eps());
333
334 // approximation of the derivative:
335 // f'(x) = [f(x + e) - f(x)] / e
336
337 const T calculatedDerivativeX = (offset.x() - original.x()) / eps;
338 const T calculatedDerivativeY = (offset.y() - original.y()) / eps;
339
340 const T maxX = max(NumericT<T>::abs(T(derivativeX)), NumericT<T>::abs(calculatedDerivativeX));
341 const T maxY = max(NumericT<T>::abs(T(derivativeY)), NumericT<T>::abs(calculatedDerivativeY));
342
343 const T diffX = NumericT<T>::abs(T(derivativeX) - calculatedDerivativeX);
344 const T diffY = NumericT<T>::abs(T(derivativeY) - calculatedDerivativeY);
345
346 if (NumericT<TDerivative>::isEqualEps(derivativeX) || NumericT<T>::isEqualEps(calculatedDerivativeX))
347 {
348 if (NumericT<T>::abs(diffX) > T(0.001))
349 {
350 return false;
351 }
352 }
353 else
354 {
355 if (NumericT<T>::isNotEqualEps(maxX) && diffX / maxX > T(0.05))
356 {
357 return false;
358 }
359 }
360
361 if (NumericT<TDerivative>::isEqualEps(derivativeY) || NumericT<T>::isEqualEps(calculatedDerivativeY))
362 {
363 if (NumericT<T>::abs(diffY) > T(0.001))
364 {
365 return false;
366 }
367 }
368 else
369 {
370 if (NumericT<T>::isNotEqualEps(maxY) && diffY / maxY > T(0.05))
371 {
372 return false;
373 }
374 }
375
376 return true;
377}
378
379template <typename T, typename TDerivative>
380inline bool TestJacobian::checkAccuracy(const VectorT3<T>& original, const VectorT3<T>& offset, const T eps, const TDerivative derivativeX, const TDerivative derivativeY, const TDerivative derivativeZ)
381{
382 static_assert(sizeof(TDerivative) <= sizeof(T), "The derivative should not have more precision than epsilon");
383
384 ocean_assert(eps > NumericT<T>::eps());
385
386 // approximation of the derivative:
387 // f'(x) = [f(x + e) - f(x)] / e
388
389 const T calculatedDerivativeX = (offset.x() - original.x()) / eps;
390 const T calculatedDerivativeY = (offset.y() - original.y()) / eps;
391 const T calculatedDerivativeZ = (offset.z() - original.z()) / eps;
392
393 const T maxX = max(NumericT<T>::abs(T(derivativeX)), NumericT<T>::abs(calculatedDerivativeX));
394 const T maxY = max(NumericT<T>::abs(T(derivativeY)), NumericT<T>::abs(calculatedDerivativeY));
395 const T maxZ = max(NumericT<T>::abs(T(derivativeZ)), NumericT<T>::abs(calculatedDerivativeZ));
396
397 const T diffX = NumericT<T>::abs(T(derivativeX) - calculatedDerivativeX);
398 const T diffY = NumericT<T>::abs(T(derivativeY) - calculatedDerivativeY);
399 const T diffZ = NumericT<T>::abs(T(derivativeZ) - calculatedDerivativeZ);
400
401 if (NumericT<TDerivative>::isEqualEps(derivativeX) || NumericT<T>::isEqualEps(calculatedDerivativeX))
402 {
403 if (NumericT<T>::abs(diffX) > T(0.001))
404 {
405 return false;
406 }
407 }
408 else
409 {
410 if (NumericT<T>::isNotEqualEps(maxX) && diffX / maxX > T(0.05))
411 {
412 return false;
413 }
414 }
415
416 if (NumericT<TDerivative>::isEqualEps(derivativeY) || NumericT<T>::isEqualEps(calculatedDerivativeY))
417 {
418 if (NumericT<T>::abs(diffY) > T(0.001))
419 {
420 return false;
421 }
422 }
423 else
424 {
425 if (NumericT<T>::isNotEqualEps(maxY) && diffY / maxY > T(0.05))
426 {
427 return false;
428 }
429 }
430
431 if (NumericT<TDerivative>::isEqualEps(derivativeZ) || NumericT<T>::isEqualEps(calculatedDerivativeZ))
432 {
433 if (NumericT<T>::abs(diffZ) > T(0.001))
434 {
435 return false;
436 }
437 }
438 else
439 {
440 if (NumericT<T>::isNotEqualEps(maxZ) && diffZ / maxZ > T(0.05))
441 {
442 return false;
443 }
444 }
445
446 return true;
447}
448
449template <bool tUseBorderDistortionIfOutside>
450void TestJacobian::calculatePointJacobian2x3(Scalar* jx, Scalar* jy, const PinholeCamera& pinholeCamera, const HomogenousMatrix4& flippedCamera_T_world, const Vector3& objectPoint, const bool distortImagePoint)
451{
452 ocean_assert(jx != nullptr && jy != nullptr);
453 ocean_assert(flippedCamera_T_world.isValid());
454
455 /**
456 * | dfx / dX, dfx / dY, dfx / dZ |<br>
457 * | dfy / dX, dfy / dY, dfy / dZ |<br>
458 */
459
460 const Scalar eps = Numeric::weakEps();
461
462 const Vector2 imagePoint(pinholeCamera.projectToImageIF<tUseBorderDistortionIfOutside>(flippedCamera_T_world, objectPoint, distortImagePoint));
463
464 for (unsigned int n = 0u; n < 3u; ++n)
465 {
466 Vector3 dObjectPoint(objectPoint);
467
468 dObjectPoint[n] += eps;
469
470 const Vector2 dImagePoint(pinholeCamera.projectToImageIF<tUseBorderDistortionIfOutside>(flippedCamera_T_world, dObjectPoint, distortImagePoint));
471
472 const Scalar dx = (dImagePoint.x() - imagePoint.x()) / eps;
473 const Scalar dy = (dImagePoint.y() - imagePoint.y()) / eps;
474
475 jx[n] = dx;
476 jy[n] = dy;
477 }
478}
479
481{
482 return 0.99;
483}
484
485}
486
487}
488
489}
490
491#endif // META_OCEAN_TEST_TESTGEOMETRY_TEST_JACOBIAN_H
This class implements function to calculate the jacobian matrices for geometry functions.
Definition Jacobian.h:37
bool isValid() const
Returns whether this matrix is a valid homogeneous transformation.
Definition HomogenousMatrix4.h:1806
This class provides basic numeric functionalities.
Definition Numeric.h:57
static constexpr T weakEps()
Returns a weak epsilon.
static T abs(const T value)
Returns the absolute value of a given value.
Definition Numeric.h:1220
VectorT2< T > projectToImageIF(const HomogenousMatrixT4< T > &flippedCamera_T_world, const VectorT3< T > &objectPoint, const bool distortImagePoint, const T zoom=T(1)) const
Projects a 3D object point to the 2D image plane of the camera by a given inverse camera pose.
Definition PinholeCamera.h:2006
This class implements Jacobian tests.
Definition TestJacobian.h:32
static bool testIdentityHomography2x8(const double testDuration)
Tests the 2x8 Jacobian for the identity homography.
static bool testOrientationPinholeCameraJacobian2x11(const double testDuration)
Tests the Jacobian for the rotational part of the extrinsic camera matrix, intrinsic and radial and t...
static bool testSphericalObjectPointOrientation2x3IF(const double testDuration)
Tests the Jacobian for an exponential map representing a 3D object point which is projected into the ...
static bool checkAccuracy(const VectorT2< T > &original, const VectorT2< T > &offset, const T eps, const TDerivative derivativeX, const TDerivative derivativeY)
Determines the derivative for a given 2D position and compares the accuracy with the precise derivati...
Definition TestJacobian.h:328
static bool testPinholeCameraObjectTransformation2nx6(const double testDuration)
Tests the 2x6 Jacobian for a 6-DOF transformation with fixed camera pose.
static void calculatePointJacobian2x3(Scalar *jx, Scalar *jy, const PinholeCamera &pinholeCamera, const HomogenousMatrix4 &flippedCamera_T_world, const Vector3 &objectPoint, const bool distortImagePoint)
Calculates the two Jacobian rows for a given pose and dynamic object point.
Definition TestJacobian.h:450
static bool testPosePinholeCameraJacobian2x14(const double testDuration)
Tests the Jacobian for the extrinsic, intrinsic and radial and tangential distortion camera parameter...
static bool testPosesPointsJacobian2nx12(const double testDuration)
Tests the Jacobian for two 6DOF poses and a set of 3D object points.
static bool testAnyCameraPoseJacobian2nx6(const double testDuration)
Tests the Jacobian for the extrinsic camera parameters and any camera.
static bool testFisheyeCameraPointJacobian2x3(const double testDuration)
Tests the Jacobian for an 2D image point projection in relation to an object point using a fisheye ca...
static bool testCalculateFisheyeDistortNormalized2x2(const double testDuration)
Tests the 2x2 Jacobian of the distortion of a normalized image point for a fisheye camera.
static bool testHomography2x9(const double testDuration)
Tests the 2x9 Jacobian for the homography.
static bool testPoseZoomJacobian2nx7(const double testDuration)
Tests the Jacobian for the extrinsic camera parameters (including the zoom parameter).
static bool testSphericalObjectPoint3x3(const double testDuration)
Tests the Jacobian for an exponential map representing a 3D object point.
static bool testHomography2x8(const double testDuration)
Tests the 2x8 Jacobian for the homography.
static bool testAnyCameraPointJacobian2x3(const double testDuration)
Tests the Jacobian for an 2D image point projection in relation to an object point using any camera.
static bool testSimilarity2x4(const double testDuration)
Tests the 2x4 Jacobian of a similarity transformation.
static bool test(const double testDuration)
Tests the entire Jacobian functionality.
static bool testPoseFisheyeCameraJacobian2x18(const double testDuration)
Tests the Jacobian for the extrinsic, intrinsic and radial camera parameters and distortion parameter...
static bool testPinholeCameraDistortionJacobian2x4(const double testDuration)
Tests the Jacobian for the radial and tangential distortion camera parameters.
static bool testFisheyeCameraJacobian2x12(const double testDuration)
Tests the Jacobian for the intrinsic, radial and tangential distortion of fisheye camera parameters.
static bool testPinholeCameraJacobian2x7(const double testDuration)
Tests the Jacobian for the intrinsic and radial and tangential distortion of pinhole camera parameter...
static bool testPosePinholeCameraJacobian2x12(const double testDuration)
Tests the Jacobian for the extrinsic, intrinsic and radial camera parameters for a pinhole camera.
static bool testFisheyeCameraObjectTransformation2nx6(const double testDuration)
Tests the 2x6 Jacobian for a 6-DOF transformation with fixed camera pose.
static bool testOrientationJacobian2nx3(const double testDuration)
Tests the Jacobian for the orientation of a camera.
static bool testPinholeCameraJacobian2x6(const double testDuration)
Tests the Jacobian for the intrinsic and radial distortion of pinhole camera parameters.
static bool testPinholeCameraJacobian2x8(const double testDuration)
Tests the Jacobian for the intrinsic, radial and tangential distortion of pinhole camera parameters.
static bool testPinholeCameraPointJacobian2nx3(const double testDuration)
Tests the Jacobian for an 2D image point projection in relation to an object point using a pinhole ca...
static bool testIdentityHomography2x9(const double testDuration)
Tests the 2x9 Jacobian for the identity homography.
static bool testFisheyeCameraPoseJacobian2x6(const double testDuration)
Deprecated.
static bool testOrientationalJacobian2x3(const double testDuration)
Tests the Jacobian for the rotational part of extrinsic camera parameters.
static bool testPinholeCameraPoseJacobian2nx6(const double testDuration)
Deprecated.
static constexpr double successThreshold()
Returns the minimal threshold necessary to succeed a verification.
Definition TestJacobian.h:480
static bool testPoseJacobianDampedDistortion2nx6(const double testDuration)
Tests the Jacobian for the extrinsic camera parameters using a damped distortion.
This class implements a vector with two elements.
Definition Vector2.h:96
const T & x() const noexcept
Returns the x value.
Definition Vector2.h:710
const T & y() const noexcept
Returns the y value.
Definition Vector2.h:722
This class implements a vector with three elements.
Definition Vector3.h:97
const T & y() const noexcept
Returns the y value.
Definition Vector3.h:824
const T & x() const noexcept
Returns the x value.
Definition Vector3.h:812
const T & z() const noexcept
Returns the z value.
Definition Vector3.h:836
float Scalar
Definition of a scalar type.
Definition Math.h:129
The namespace covering the entire Ocean framework.
Definition Accessor.h:15