Visual Servoing Platform  version 3.6.1 under development (2024-05-27)
vpCalibration.cpp
1 /*
2  * ViSP, open source Visual Servoing Platform software.
3  * Copyright (C) 2005 - 2023 by Inria. All rights reserved.
4  *
5  * This software is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  * See the file LICENSE.txt at the root directory of this source
10  * distribution for additional information about the GNU GPL.
11  *
12  * For using ViSP with software that can not be combined with the GNU
13  * GPL, please contact Inria about acquiring a ViSP Professional
14  * Edition License.
15  *
16  * See https://visp.inria.fr for more information.
17  *
18  * This software was developed at:
19  * Inria Rennes - Bretagne Atlantique
20  * Campus Universitaire de Beaulieu
21  * 35042 Rennes Cedex
22  * France
23  *
24  * If you have questions regarding the use of this file, please contact
25  * Inria at visp@inria.fr
26  *
27  * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
28  * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
29  *
30  * Description:
31  * Camera calibration.
32  */
33 
39 #include <visp3/core/vpDebug.h>
40 #include <visp3/core/vpPixelMeterConversion.h>
41 #include <visp3/vision/vpCalibration.h>
42 #include <visp3/vision/vpPose.h>
43 
44 double vpCalibration::m_threshold = 1e-10f;
45 unsigned int vpCalibration::m_nbIterMax = 4000;
46 double vpCalibration::m_gain = 0.25;
47 
49 {
50  m_npt = 0;
51 
52  m_residual = m_residual_dist = 1000.;
53 
54  m_LoX.clear();
55  m_LoY.clear();
56  m_LoZ.clear();
57  m_Lip.clear();
58 
59  return 0;
60 }
61 
63  : cMo(), cMo_dist(), cam(), cam_dist(), rMe(), eMc(), eMc_dist(), m_aspect_ratio(-1), m_npt(0),
64  m_LoX(), m_LoY(), m_LoZ(), m_Lip(), m_residual(1000.), m_residual_dist(1000.)
65 
66 {
67  init();
68 }
69 
71  : cMo(), cMo_dist(), cam(), cam_dist(), rMe(), eMc(), eMc_dist(), m_aspect_ratio(-1), m_npt(0),
72  m_LoX(), m_LoY(), m_LoZ(), m_Lip(), m_residual(1000.), m_residual_dist(1000.)
73 {
74  (*this) = c;
75 }
76 
78 
80 {
81  m_npt = twinCalibration.m_npt;
82  m_LoX = twinCalibration.m_LoX;
83  m_LoY = twinCalibration.m_LoY;
84  m_LoZ = twinCalibration.m_LoZ;
85  m_Lip = twinCalibration.m_Lip;
86 
87  m_residual = twinCalibration.m_residual;
88  cMo = twinCalibration.cMo;
89  m_residual_dist = twinCalibration.m_residual_dist;
90  cMo_dist = twinCalibration.cMo_dist;
91 
92  cam = twinCalibration.cam;
93  cam_dist = twinCalibration.cam_dist;
94 
95  rMe = twinCalibration.rMe;
96 
97  eMc = twinCalibration.eMc;
98  eMc_dist = twinCalibration.eMc_dist;
99 
100  m_aspect_ratio = twinCalibration.m_aspect_ratio;
101 
102  return (*this);
103 }
104 
106 {
107  m_LoX.clear();
108  m_LoY.clear();
109  m_LoZ.clear();
110  m_Lip.clear();
111  m_npt = 0;
112 
113  return 0;
114 }
115 
116 int vpCalibration::addPoint(double X, double Y, double Z, vpImagePoint &ip)
117 {
118  m_LoX.push_back(X);
119  m_LoY.push_back(Y);
120  m_LoZ.push_back(Z);
121 
122  m_Lip.push_back(ip);
123 
124  m_npt++;
125 
126  return 0;
127 }
128 
134 void vpCalibration::computePose(const vpCameraParameters &camera, vpHomogeneousMatrix &cMo_est)
135 {
136  // The vpPose class mainly contents a list of vpPoint (that is (X,Y,Z, x, y)
137  // )
138  vpPose pose;
139  // the list of point is cleared (if that's not done before)
140  pose.clearPoint();
141  // we set the 3D points coordinates (in meter !) in the object/world frame
142  std::list<double>::const_iterator it_LoX = m_LoX.begin();
143  std::list<double>::const_iterator it_LoY = m_LoY.begin();
144  std::list<double>::const_iterator it_LoZ = m_LoZ.begin();
145  std::list<vpImagePoint>::const_iterator it_Lip = m_Lip.begin();
146 
147  for (unsigned int i = 0; i < m_npt; i++) {
148  vpPoint P(*it_LoX, *it_LoY, *it_LoZ);
149  double x = 0, y = 0;
150  vpPixelMeterConversion::convertPoint(camera, *it_Lip, x, y);
151  P.set_x(x);
152  P.set_y(y);
153 
154  pose.addPoint(P);
155  ++it_LoX;
156  ++it_LoY;
157  ++it_LoZ;
158  ++it_Lip;
159  }
160 
161  // the pose is now refined using the virtual visual servoing approach
162  // Warning: cMo needs to be initialized otherwise it may diverge
164 }
165 
167 {
168  m_residual = 0;
169 
170  std::list<double>::const_iterator it_LoX = m_LoX.begin();
171  std::list<double>::const_iterator it_LoY = m_LoY.begin();
172  std::list<double>::const_iterator it_LoZ = m_LoZ.begin();
173  std::list<vpImagePoint>::const_iterator it_Lip = m_Lip.begin();
174 
175  double u0 = camera.get_u0();
176  double v0 = camera.get_v0();
177  double px = camera.get_px();
178  double py = camera.get_py();
179  vpImagePoint ip;
180 
181  for (unsigned int i = 0; i < m_npt; i++) {
182  double oX = *it_LoX;
183  double oY = *it_LoY;
184  double oZ = *it_LoZ;
185 
186  double cX = oX * cMo_est[0][0] + oY * cMo_est[0][1] + oZ * cMo_est[0][2] + cMo_est[0][3];
187  double cY = oX * cMo_est[1][0] + oY * cMo_est[1][1] + oZ * cMo_est[1][2] + cMo_est[1][3];
188  double cZ = oX * cMo_est[2][0] + oY * cMo_est[2][1] + oZ * cMo_est[2][2] + cMo_est[2][3];
189 
190  double x = cX / cZ;
191  double y = cY / cZ;
192 
193  ip = *it_Lip;
194  double u = ip.get_u();
195  double v = ip.get_v();
196 
197  double xp = u0 + x * px;
198  double yp = v0 + y * py;
199 
200  m_residual += (vpMath::sqr(xp - u) + vpMath::sqr(yp - v));
201 
202  ++it_LoX;
203  ++it_LoY;
204  ++it_LoZ;
205  ++it_Lip;
206  }
207  return sqrt(m_residual / m_npt);
208 }
209 
211 {
212  m_residual_dist = 0;
213 
214  std::list<double>::const_iterator it_LoX = m_LoX.begin();
215  std::list<double>::const_iterator it_LoY = m_LoY.begin();
216  std::list<double>::const_iterator it_LoZ = m_LoZ.begin();
217  std::list<vpImagePoint>::const_iterator it_Lip = m_Lip.begin();
218 
219  double u0 = camera.get_u0();
220  double v0 = camera.get_v0();
221  double px = camera.get_px();
222  double py = camera.get_py();
223  double kud = camera.get_kud();
224  double kdu = camera.get_kdu();
225 
226  double inv_px = 1 / px;
227  double inv_py = 1 / px;
228  vpImagePoint ip;
229 
230  for (unsigned int i = 0; i < m_npt; i++) {
231  double oX = *it_LoX;
232  double oY = *it_LoY;
233  double oZ = *it_LoZ;
234 
235  double cX = oX * cMo_est[0][0] + oY * cMo_est[0][1] + oZ * cMo_est[0][2] + cMo_est[0][3];
236  double cY = oX * cMo_est[1][0] + oY * cMo_est[1][1] + oZ * cMo_est[1][2] + cMo_est[1][3];
237  double cZ = oX * cMo_est[2][0] + oY * cMo_est[2][1] + oZ * cMo_est[2][2] + cMo_est[2][3];
238 
239  double x = cX / cZ;
240  double y = cY / cZ;
241 
242  ip = *it_Lip;
243  double u = ip.get_u();
244  double v = ip.get_v();
245 
246  double r2ud = 1 + kud * (vpMath::sqr(x) + vpMath::sqr(y));
247 
248  double xp = u0 + x * px * r2ud;
249  double yp = v0 + y * py * r2ud;
250 
251  m_residual_dist += (vpMath::sqr(xp - u) + vpMath::sqr(yp - v));
252 
253  double r2du = (vpMath::sqr((u - u0) * inv_px) + vpMath::sqr((v - v0) * inv_py));
254 
255  xp = u0 + x * px - kdu * (u - u0) * r2du;
256  yp = v0 + y * py - kdu * (v - v0) * r2du;
257 
258  m_residual_dist += (vpMath::sqr(xp - u) + vpMath::sqr(yp - v));
259  ++it_LoX;
260  ++it_LoY;
261  ++it_LoZ;
262  ++it_Lip;
263  }
264  m_residual_dist /= 2;
265 
266  return sqrt(m_residual_dist / m_npt);
267 }
268 
269 void vpCalibration::computeStdDeviation(double &deviation, double &deviation_dist)
270 {
271  deviation = computeStdDeviation(cMo, cam);
272  deviation_dist = computeStdDeviation_dist(cMo_dist, cam_dist);
273 }
274 
276  vpCameraParameters &cam_est, bool verbose)
277 {
278  try {
279  computePose(cam_est, cMo_est);
280  switch (method) {
281  case CALIB_LAGRANGE:
283  calibLagrange(cam_est, cMo_est);
284  } break;
285  case CALIB_VIRTUAL_VS:
288  default:
289  break;
290  }
291 
292  switch (method) {
293  case CALIB_VIRTUAL_VS:
297  if (verbose) {
298  std::cout << "start calibration without distortion" << std::endl;
299  }
300  calibVVS(cam_est, cMo_est, verbose);
301  } break;
302  case CALIB_LAGRANGE:
303  default:
304  break;
305  }
306  this->cMo = cMo_est;
307  this->cMo_dist = cMo_est;
308 
309  // Print camera parameters
310  if (verbose) {
311  // std::cout << "Camera parameters without distortion :" <<
312  // std::endl;
313  cam_est.printParameters();
314  }
315 
316  this->cam = cam_est;
317 
318  switch (method) {
321  if (verbose) {
322  std::cout << "start calibration with distortion" << std::endl;
323  }
324  calibVVSWithDistortion(cam_est, cMo_est, verbose);
325  } break;
326  case CALIB_LAGRANGE:
327  case CALIB_VIRTUAL_VS:
329  default:
330  break;
331  }
332  // Print camera parameters
333  if (verbose) {
334  // std::cout << "Camera parameters without distortion :" <<
335  // std::endl;
336  this->cam.printParameters();
337  // std::cout << "Camera parameters with distortion :" <<
338  // std::endl;
339  cam_est.printParameters();
340  }
341 
342  this->cam_dist = cam_est;
343 
344  this->cMo_dist = cMo_est;
345 
346  if (cam_est.get_px() < 0 || cam_est.get_py() < 0 || cam_est.get_u0() < 0 || cam_est.get_v0() < 0) {
347  if (verbose) {
348  std::cout << "Unable to calibrate the camera. Estimated parameters are negative." << std::endl;
349  }
350  return EXIT_FAILURE;
351  }
352 
353  return EXIT_SUCCESS;
354  }
355  catch (...) {
356  throw;
357  }
358 }
359 
360 int vpCalibration::computeCalibrationMulti(vpCalibrationMethodType method, std::vector<vpCalibration> &table_cal,
361  vpCameraParameters &cam_est, double &globalReprojectionError, bool verbose)
362 {
363  try {
364  unsigned int nbPose = (unsigned int)table_cal.size();
365  for (unsigned int i = 0; i < nbPose; i++) {
366  if (table_cal[i].get_npt() > 3)
367  table_cal[i].computePose(cam_est, table_cal[i].cMo);
368  }
369  switch (method) {
370  case CALIB_LAGRANGE: {
371  if (nbPose > 1) {
372  std::cout << "this calibration method is not available in" << std::endl
373  << "vpCalibration::computeCalibrationMulti()" << std::endl;
374  return -1;
375  }
376  else {
377  table_cal[0].calibLagrange(cam_est, table_cal[0].cMo);
378  table_cal[0].cam = cam_est;
379  table_cal[0].cam_dist = cam_est;
380  table_cal[0].cMo_dist = table_cal[0].cMo;
381  }
382  break;
383  }
386  if (nbPose > 1) {
387  std::cout << "this calibration method is not available in" << std::endl
388  << "vpCalibration::computeCalibrationMulti()" << std::endl
389  << "with several images." << std::endl;
390  return -1;
391  }
392  else {
393  table_cal[0].calibLagrange(cam_est, table_cal[0].cMo);
394  table_cal[0].cam = cam_est;
395  table_cal[0].cam_dist = cam_est;
396  table_cal[0].cMo_dist = table_cal[0].cMo;
397  }
398  calibVVSMulti(table_cal, cam_est, globalReprojectionError, verbose, table_cal[0].m_aspect_ratio);
399  break;
400  }
401  case CALIB_VIRTUAL_VS:
402  case CALIB_VIRTUAL_VS_DIST: {
403  calibVVSMulti(table_cal, cam_est, globalReprojectionError, verbose, table_cal[0].m_aspect_ratio);
404  break;
405  }
406  }
407  // Print camera parameters
408  if (verbose) {
409  // std::cout << "Camera parameters without distortion :" <<
410  // std::endl;
411  cam_est.printParameters();
412  }
413 
414  switch (method) {
415  case CALIB_LAGRANGE:
417  case CALIB_VIRTUAL_VS:
418  verbose = false;
419  break;
421  case CALIB_VIRTUAL_VS_DIST: {
422  if (verbose)
423  std::cout << "Compute camera parameters with distortion" << std::endl;
424 
425  calibVVSWithDistortionMulti(table_cal, cam_est, globalReprojectionError, verbose, table_cal[0].m_aspect_ratio);
426  } break;
427  }
428  // Print camera parameters
429  if (verbose) {
430  // std::cout << "Camera parameters without distortion :" <<
431  // std::endl;
432  table_cal[0].cam.printParameters();
433  // std::cout << "Camera parameters with distortion:" << std::endl;
434  cam_est.printParameters();
435  std::cout << std::endl;
436  }
437 
438  if (cam_est.get_px() < 0 || cam_est.get_py() < 0 || cam_est.get_u0() < 0 || cam_est.get_v0() < 0) {
439  if (verbose) {
440  std::cout << "Unable to calibrate the camera. Estimated parameters are negative." << std::endl;
441  }
442  return EXIT_FAILURE;
443  }
444 
445  return EXIT_SUCCESS;
446  }
447  catch (...) {
448  throw;
449  }
450 }
451 
452 int vpCalibration::writeData(const std::string &filename)
453 {
454  std::ofstream f(filename.c_str());
455  vpImagePoint ip;
456 
457  std::list<double>::const_iterator it_LoX = m_LoX.begin();
458  std::list<double>::const_iterator it_LoY = m_LoY.begin();
459  std::list<double>::const_iterator it_LoZ = m_LoZ.begin();
460  std::list<vpImagePoint>::const_iterator it_Lip = m_Lip.begin();
461 
462  f.precision(10);
463  f.setf(std::ios::fixed, std::ios::floatfield);
464  f << m_LoX.size() << std::endl;
465 
466  for (unsigned int i = 0; i < m_LoX.size(); ++i) {
467 
468  double oX = *it_LoX;
469  double oY = *it_LoY;
470  double oZ = *it_LoZ;
471 
472  ip = *it_Lip;
473  double u = ip.get_u();
474  double v = ip.get_v();
475 
476  f << oX << " " << oY << " " << oZ << " " << u << " " << v << std::endl;
477 
478  ++it_LoX;
479  ++it_LoY;
480  ++it_LoZ;
481  ++it_Lip;
482  }
483 
484  f.close();
485  return 0;
486 }
487 
488 int vpCalibration::readData(const std::string &filename)
489 {
490  vpImagePoint ip;
491  std::ifstream f;
492  f.open(filename.c_str());
493  if (!f.fail()) {
494  unsigned int n;
495  f >> n;
496  std::cout << "There are " << n << " point on the calibration grid " << std::endl;
497 
498  clearPoint();
499 
500  if (n > 100000)
501  throw(vpException(vpException::badValue, "Bad number of point in the calibration grid"));
502 
503  for (unsigned int i = 0; i < n; i++) {
504  double x, y, z, u, v;
505  f >> x >> y >> z >> u >> v;
506  std::cout << x << " " << y << " " << z << " " << u << " " << v << std::endl;
507  ip.set_u(u);
508  ip.set_v(v);
509  addPoint(x, y, z, ip);
510  }
511 
512  f.close();
513  return 0;
514  }
515  else {
516  return -1;
517  }
518 }
519 
520 int vpCalibration::readGrid(const std::string &filename, unsigned int &n, std::list<double> &oX, std::list<double> &oY,
521  std::list<double> &oZ, bool verbose)
522 {
523  try {
524  std::ifstream f;
525  f.open(filename.c_str());
526  if (!f.fail()) {
527 
528  f >> n;
529  if (verbose)
530  std::cout << "There are " << n << " points on the calibration grid " << std::endl;
531  int no_pt;
532  double x, y, z;
533 
534  // clear the list
535  oX.clear();
536  oY.clear();
537  oZ.clear();
538 
539  if (n > 100000)
540  throw(vpException(vpException::badValue, "Bad number of point in the calibration grid"));
541 
542  for (unsigned int i = 0; i < n; i++) {
543  f >> no_pt >> x >> y >> z;
544  if (verbose) {
545  std::cout << no_pt << std::endl;
546  std::cout << x << " " << y << " " << z << std::endl;
547  }
548  oX.push_back(x);
549  oY.push_back(y);
550  oZ.push_back(z);
551  }
552 
553  f.close();
554  }
555  else {
556  return -1;
557  }
558  }
559  catch (...) {
560  return -1;
561  }
562  return 0;
563 }
564 
565 int vpCalibration::displayData(vpImage<unsigned char> &I, vpColor color, unsigned int thickness, int subsampling_factor)
566 {
567 
568  for (std::list<vpImagePoint>::const_iterator it = m_Lip.begin(); it != m_Lip.end(); ++it) {
569  vpImagePoint ip = *it;
570  if (subsampling_factor > 1.) {
571  ip.set_u(ip.get_u() / subsampling_factor);
572  ip.set_v(ip.get_v() / subsampling_factor);
573  }
574  vpDisplay::displayCross(I, ip, 12, color, thickness);
575  }
576  return 0;
577 }
578 
579 int vpCalibration::displayGrid(vpImage<unsigned char> &I, vpColor color, unsigned int thickness, int subsampling_factor)
580 {
581  double u0_dist = cam_dist.get_u0() / subsampling_factor;
582  double v0_dist = cam_dist.get_v0() / subsampling_factor;
583  double px_dist = cam_dist.get_px() / subsampling_factor;
584  double py_dist = cam_dist.get_py() / subsampling_factor;
585  double kud_dist = cam_dist.get_kud();
586  // double kdu_dist = cam_dist.get_kdu() ;
587 
588  // double u0 = cam.get_u0() ;
589  // double v0 = cam.get_v0() ;
590  // double px = cam.get_px() ;
591  // double py = cam.get_py() ;
592 
593  std::list<double>::const_iterator it_LoX = m_LoX.begin();
594  std::list<double>::const_iterator it_LoY = m_LoY.begin();
595  std::list<double>::const_iterator it_LoZ = m_LoZ.begin();
596 
597  for (unsigned int i = 0; i < m_npt; i++) {
598  double oX = *it_LoX;
599  double oY = *it_LoY;
600  double oZ = *it_LoZ;
601 
602  double cX = oX * cMo_dist[0][0] + oY * cMo_dist[0][1] + oZ * cMo_dist[0][2] + cMo_dist[0][3];
603  double cY = oX * cMo_dist[1][0] + oY * cMo_dist[1][1] + oZ * cMo_dist[1][2] + cMo_dist[1][3];
604  double cZ = oX * cMo_dist[2][0] + oY * cMo_dist[2][1] + oZ * cMo_dist[2][2] + cMo_dist[2][3];
605 
606  double x = cX / cZ;
607  double y = cY / cZ;
608 
609  double r2 = 1 + kud_dist * (vpMath::sqr(x) + vpMath::sqr(y));
610 
611  vpImagePoint ip;
612  ip.set_u(u0_dist + x * px_dist * r2);
613  ip.set_v(v0_dist + y * py_dist * r2);
614 
615  vpDisplay::displayCross(I, ip, 6, color, thickness);
617 
618  // std::cout << oX << " " << oY << " " <<oZ << std::endl ;
619  // I.getClick() ;
620  ++it_LoX;
621  ++it_LoY;
622  ++it_LoZ;
623  }
624  return 0;
625 }
626 
627 void vpCalibration::setAspectRatio(double aspect_ratio)
628 {
629  if (aspect_ratio > 0.) {
630  m_aspect_ratio = aspect_ratio;
631  }
632 }
Tools for perspective camera calibration.
Definition: vpCalibration.h:61
void computeStdDeviation(double &deviation, double &deviation_dist)
int displayData(vpImage< unsigned char > &I, vpColor color=vpColor::red, unsigned int thickness=1, int subsampling_factor=1)
unsigned int get_npt() const
double m_aspect_ratio
int computeCalibration(vpCalibrationMethodType method, vpHomogeneousMatrix &cMo_est, vpCameraParameters &cam_est, bool verbose=false)
int addPoint(double X, double Y, double Z, vpImagePoint &ip)
vpHomogeneousMatrix eMc_dist
vpHomogeneousMatrix rMe
int writeData(const std::string &filename)
vpCalibration & operator=(const vpCalibration &twinCalibration)
vpHomogeneousMatrix cMo
Definition: vpCalibration.h:86
double computeStdDeviation_dist(const vpHomogeneousMatrix &cMo_est, const vpCameraParameters &camera)
static int computeCalibrationMulti(vpCalibrationMethodType method, std::vector< vpCalibration > &table_cal, vpCameraParameters &cam_est, double &globalReprojectionError, bool verbose=false)
vpCameraParameters cam_dist
Definition: vpCalibration.h:99
static int readGrid(const std::string &filename, unsigned int &n, std::list< double > &oX, std::list< double > &oY, std::list< double > &oZ, bool verbose=false)
void setAspectRatio(double aspect_ratio)
vpHomogeneousMatrix eMc
vpHomogeneousMatrix cMo_dist
Definition: vpCalibration.h:91
virtual ~vpCalibration()
int displayGrid(vpImage< unsigned char > &I, vpColor color=vpColor::yellow, unsigned int thickness=1, int subsampling_factor=1)
@ CALIB_LAGRANGE_VIRTUAL_VS
Definition: vpCalibration.h:75
@ CALIB_LAGRANGE_VIRTUAL_VS_DIST
Definition: vpCalibration.h:78
int readData(const std::string &filename)
vpCameraParameters cam
Definition: vpCalibration.h:95
Generic class defining intrinsic camera parameters.
double get_kdu() const
double get_kud() const
Class to define RGB colors available for display functionalities.
Definition: vpColor.h:152
static void displayCross(const vpImage< unsigned char > &I, const vpImagePoint &ip, unsigned int size, const vpColor &color, unsigned int thickness=1)
error that can be emitted by ViSP classes.
Definition: vpException.h:59
@ badValue
Used to indicate that a value is not in the allowed range.
Definition: vpException.h:72
Implementation of an homogeneous matrix and operations on such kind of matrices.
Class that defines a 2D point in an image. This class is useful for image processing and stores only ...
Definition: vpImagePoint.h:82
double get_u() const
Definition: vpImagePoint.h:136
void set_u(double u)
Definition: vpImagePoint.h:331
void set_v(double v)
Definition: vpImagePoint.h:342
double get_v() const
Definition: vpImagePoint.h:147
static double sqr(double x)
Definition: vpMath.h:201
static void convertPoint(const vpCameraParameters &cam, const double &u, const double &v, double &x, double &y)
Class that defines a 3D point in the object frame and allows forward projection of a 3D point in the ...
Definition: vpPoint.h:77
Class used for pose computation from N points (pose from point only). Some of the algorithms implemen...
Definition: vpPose.h:78
void addPoint(const vpPoint &P)
Definition: vpPose.cpp:93
@ DEMENTHON_LAGRANGE_VIRTUAL_VS
Definition: vpPose.h:99
void clearPoint()
Definition: vpPose.cpp:86
bool computePose(vpPoseMethodType method, vpHomogeneousMatrix &cMo, bool(*func)(const vpHomogeneousMatrix &)=nullptr)
Definition: vpPose.cpp:341