MRPT  1.9.9
CDUO3DCamera.cpp
Go to the documentation of this file.
1 /* +------------------------------------------------------------------------+
2  | Mobile Robot Programming Toolkit (MRPT) |
3  | https://www.mrpt.org/ |
4  | |
5  | Copyright (c) 2005-2019, Individual contributors, see AUTHORS file |
6  | See: https://www.mrpt.org/Authors - All rights reserved. |
7  | Released under BSD License. See: https://www.mrpt.org/License |
8  +------------------------------------------------------------------------+ */
9 
10 #include "hwdrivers-precomp.h" // Precompiled headers
11 
13 #include <mrpt/system/filesystem.h>
14 #include <mrpt/system/os.h>
15 
16 #include <mrpt/3rdparty/do_opencv_includes.h>
17 
18 #include <map>
19 
20 // We must define & store OpenCV-specific data like this in the .cpp, we don't
21 // want to force users to need opencv headers:
22 struct TDUOParams
23 {
24 #if MRPT_HAS_OPENCV
29 #endif
30 };
31 std::map<const mrpt::hwdrivers::TCaptureOptions_DUO3D*, TDUOParams> duo_params;
32 
33 // duo3d header files
34 #if MRPT_HAS_DUO3D
35 #include <DUOLib.h>
36 #endif
37 
38 // m_duo: Opaque pointer to DUO3D's "DUOInstance":
39 #define M_DUO_PTR (reinterpret_cast<DUOInstance*>(m_duo))
40 #define M_DUO_VALUE (*M_DUO_PTR)
41 
42 using namespace std;
43 using namespace mrpt;
44 using namespace mrpt::math;
45 using namespace mrpt::poses;
46 using namespace mrpt::img;
47 using namespace mrpt::obs;
48 using namespace mrpt::hwdrivers;
49 
50 // opencv header files and namespaces
51 #if MRPT_HAS_OPENCV
52 using namespace cv;
53 #endif
54 
55 TCaptureOptions_DUO3D::TCaptureOptions_DUO3D()
56  : m_rectify_map_filename(""),
57  m_intrinsic_filename(""),
58  m_extrinsic_filename(""),
59  m_stereo_camera(TStereoCamera())
60 {
61  duo_params[this]; // Create
62 }
63 
65 {
66  duo_params.erase(this); // Remove entry
67 }
68 
71 {
72 #if MRPT_HAS_OPENCV
73  const string file_name =
74  _file_name.empty() ? m_rectify_map_filename : _file_name;
75 
76  TDUOParams& dp = duo_params[this];
77 
78  string aux = mrpt::system::extractFileName(file_name);
79  const size_t found = aux.find(
80  mrpt::format("_R%dx%d_", this->m_img_width, this->m_img_height));
81  if (found == std::string::npos)
82  {
84  dp.m_rectify_map_right_x = dp.m_rectify_map_right_y = cv::Mat();
86  }
87  // read file
88  FileStorage fs(file_name, FileStorage::READ);
89  fs["R0X"] >> dp.m_rectify_map_left_x;
90  fs["R0Y"] >> dp.m_rectify_map_left_y;
91  fs["R1X"] >> dp.m_rectify_map_right_x;
92  fs["R1Y"] >> dp.m_rectify_map_right_y;
93 
94  if (dp.m_rectify_map_left_x.size() == Size(0, 0) ||
95  dp.m_rectify_map_left_y.size() == Size(0, 0) ||
96  dp.m_rectify_map_right_x.size() == Size(0, 0) ||
97  dp.m_rectify_map_right_y.size() == Size(0, 0))
98  return yrr_EMPTY;
99 
100  return yrr_OK;
101 #else
102  THROW_EXCEPTION("This function requires building with OpenCV support");
103 #endif
104 }
105 
108  const string& _file_name)
109 {
110 #if MRPT_HAS_OPENCV
111  const string file_name =
112  _file_name.empty() ? m_extrinsic_filename : _file_name;
113 
114  // this will look for R and t matrixes
115  cv::Mat aux_mat;
116  bool empty = false;
117  string aux = mrpt::system::extractFileName(file_name);
118  const size_t found = aux.find(
119  mrpt::format("_R%dx%d_", this->m_img_width, this->m_img_height));
120  if (found == std::string::npos)
121  {
122  m_stereo_camera.rightCameraPose = TPose3DQuat(0, 0, 0, 1.0, 0, 0, 0);
124  }
125  // read file
126  FileStorage fs(file_name, FileStorage::READ);
127  CMatrixDouble33 M;
129  CMatrixDouble44 M2;
130 
131  // rotation matrix
132  fs["R"] >> aux_mat;
133  if (aux_mat.size() == Size(3, 3))
134  {
135  for (size_t k1 = 0; k1 < 3; ++k1)
136  for (size_t k2 = 0; k2 < 3; ++k2)
137  M(k1, k2) = aux_mat.at<double>(k1, k2);
138  }
139  else
140  {
141  empty = true;
142  m_stereo_camera.rightCameraPose = TPose3DQuat(0, 0, 0, 1, 0, 0, 0);
143  }
144 
145  // translation
146  fs["T"] >> aux_mat;
147  if (aux_mat.size() == Size(1, 3))
148  {
149  t(0, 0) = aux_mat.at<double>(0, 0) / 1000.0;
150  t(0, 1) = aux_mat.at<double>(1, 0) / 1000.0;
151  t(0, 2) = aux_mat.at<double>(2, 0) / 1000.0;
152  }
153  else
154  {
155  empty = true;
156  m_stereo_camera.rightCameraPose = TPose3DQuat(0, 0, 0, 1, 0, 0, 0);
157  }
158 
159  if (empty) return yrr_EMPTY;
160 
162  return yrr_OK;
163 #else
164  THROW_EXCEPTION("This function requires building with OpenCV support");
165 #endif
166 }
167 
170  const string& _file_name)
171 {
172 #if MRPT_HAS_OPENCV
173  const string file_name =
174  _file_name.empty() ? m_intrinsic_filename : _file_name;
175 
176  // this will look for M1, D1, M2 and D2 matrixes
177  cv::Mat aux_mat;
178  bool empty = false;
179  string aux = mrpt::system::extractFileName(file_name);
180  const size_t found = aux.find(
181  mrpt::format("_R%dx%d_", this->m_img_width, this->m_img_height));
182  if (found == std::string::npos)
183  {
188 
190  }
191  // read file
192  FileStorage fs(file_name, FileStorage::READ);
193 
194  // left camera
195  fs["M1"] >> aux_mat;
196  if (aux_mat.size() == Size(0, 0))
197  {
198  empty = true;
200  }
202  aux_mat.at<double>(0, 0), aux_mat.at<double>(1, 1),
203  aux_mat.at<double>(0, 2), aux_mat.at<double>(1, 2));
204 
205  fs["D1"] >> aux_mat;
206  if (aux_mat.size() == Size(0, 0))
207  {
208  empty = true;
210  }
212  aux_mat.at<double>(0, 0), aux_mat.at<double>(0, 1),
213  aux_mat.at<double>(0, 2), aux_mat.at<double>(0, 3),
214  aux_mat.at<double>(0, 4));
215 
216  fs["M2"] >> aux_mat;
217  if (aux_mat.size() == Size(0, 0))
218  {
219  empty = true;
221  }
223  aux_mat.at<double>(0, 0), aux_mat.at<double>(1, 1),
224  aux_mat.at<double>(0, 2), aux_mat.at<double>(1, 2));
225 
226  fs["D2"] >> aux_mat;
227  if (aux_mat.size() == Size(0, 0))
228  {
229  empty = true;
231  }
233  aux_mat.at<double>(0, 0), aux_mat.at<double>(0, 1),
234  aux_mat.at<double>(0, 2), aux_mat.at<double>(0, 3),
235  aux_mat.at<double>(0, 4));
236 
237  return empty ? yrr_EMPTY : yrr_OK;
238 #else
239  THROW_EXCEPTION("This function requires building with OpenCV support");
240 #endif
241 }
242 
244  const mrpt::config::CConfigFileBase& configSource,
245  const std::string& iniSection, const std::string& prefix)
246 {
247  m_img_width = configSource.read_int(iniSection, "image_width", m_img_width);
248  m_img_height =
249  configSource.read_int(iniSection, "image_height", m_img_height);
250 
251  m_fps = configSource.read_float(iniSection, "fps", m_fps);
252  m_exposure = configSource.read_float(iniSection, "exposure", m_exposure);
253  m_led = configSource.read_float(iniSection, "led", m_led);
254  m_gain = configSource.read_float(iniSection, "gain", m_gain);
255 
256  m_capture_rectified = configSource.read_bool(
257  iniSection, "capture_rectified", m_capture_rectified);
258  m_capture_imu =
259  configSource.read_bool(iniSection, "capture_imu", m_capture_imu);
260  m_calibration_from_file = configSource.read_bool(
261  iniSection, "calibration_from_file", m_calibration_from_file);
262 
264  {
265  m_intrinsic_filename = configSource.read_string(
266  iniSection, "intrinsic_filename", m_intrinsic_filename);
267  m_extrinsic_filename = configSource.read_string(
268  iniSection, "extrinsic_filename", m_extrinsic_filename);
270  m_img_width;
272  m_img_height;
273  }
274  else
275  m_stereo_camera.loadFromConfigFile("DUO3D", configSource);
276 
278  {
279  m_rectify_map_filename = configSource.read_string(
280  iniSection, "rectify_map_filename", m_rectify_map_filename);
281  } // end-capture-rectified
282 }
283 
284 #if MRPT_HAS_DUO3D
285 static void CALLBACK DUOCallback(const PDUOFrame pFrameData, void* pUserData)
286 {
287  CDUO3DCamera* obj = static_cast<CDUO3DCamera*>(pUserData);
288  obj->setDataFrame(reinterpret_cast<void*>(pFrameData));
289  SetEvent(reinterpret_cast<HANDLE>(obj->getEvent()));
290 }
291 #endif
292 
293 /** Default constructor. */
295 {
296 #if MRPT_HAS_DUO3D
297  m_duo = new DUOInstance[1];
298  M_DUO_VALUE = nullptr; // m_duo = nullptr;
299 
300  m_pframe_data = nullptr;
301  m_evFrame = CreateEvent(nullptr, FALSE, FALSE, nullptr);
302 #else
304  "MRPT has been compiled with 'MRPT_BUILD_DUO3D'=OFF, so this class "
305  "cannot be used.");
306 #endif
307 } // end-constructor
308 
309 /** Custom initialization and start grabbing constructor. */
311  : m_duo(nullptr)
312 {
313 #if MRPT_HAS_DUO3D
314  m_duo = new DUOInstance[1];
315  M_DUO_VALUE = nullptr; // m_duo = nullptr;
316 
317  m_pframe_data = nullptr;
318  m_evFrame = CreateEvent(nullptr, FALSE, FALSE, nullptr);
319  this->open(options);
320 #else
322  "MRPT has been compiled with 'MRPT_BUILD_DUO3D'=OFF, so this class "
323  "cannot be used.");
324 #endif
325 } // end-constructor
326 
327 /** Destructor */
329 {
330 #if MRPT_HAS_DUO3D
331  this->close();
332  if (m_duo)
333  {
334  delete[] M_DUO_PTR;
335  m_duo = nullptr;
336  }
337 #endif
338 } // end-destructor
339 
340 /** Tries to open the camera with the given options. Raises an exception on
341  * error. \sa close() */
343  const TCaptureOptions_DUO3D& options, const bool startCapture)
344 {
345 #if MRPT_HAS_DUO3D
346  if (M_DUO_VALUE) this->close();
347  this->m_options = options;
348 
350  {
351  // get intrinsic parameters
355  cout << "[CDUO3DCamera] Warning: Some of the intrinsic params "
356  "could not be read (size=0). Check file content."
357  << endl;
359  cout << "[CDUO3DCamera] Warning: Intrinsic params filename is not "
360  "consistent with image size. Are you using the correct "
361  "calibration?. All params set to zero."
362  << endl;
363 
364  // get extrinsic parameters
367  cout << "[CDUO3DCamera] Warning: Some of the extrinsic params "
368  "could not be read (size!=3x3). Check file content."
369  << endl;
371  cout << "[CDUO3DCamera] Warning: Extrinsic params filename is not "
372  "consistent with image size. Are you using the correct "
373  "calibration?. All params set to zero."
374  << endl;
375 
376  if (this->m_options.m_capture_rectified)
377  {
378  if (!this->m_options.m_rectify_map_filename.empty())
379  {
380  // read "rectify_map"
381  res = this->m_options.m_rectify_map_from_yml();
383  cout << "[CDUO3DCamera] Warning: Rectification map could "
384  "not be read (size==0). Check file content."
385  << endl;
387  cout << "[CDUO3DCamera] Warning: Rectification map "
388  "filename is not consistent with image size. Are "
389  "you using the correct calibration?. Rectification "
390  "map set to zero."
391  << endl;
392 
395 
396  // const size_t area =
397  // this->m_options.dp.m_rectify_map_left_x.size().area();
398  TDUOParams& dp = duo_params[&(this->m_options)];
399  const size_t area = dp.m_rectify_map_left_x.size().area();
400  vector<int16_t> v_left_x(area), v_right_x(area);
401  vector<uint16_t> v_left_y(area), v_right_y(area);
402 
403  for (size_t k = 0; k < area; ++k)
404  {
405  v_left_x[k] = dp.m_rectify_map_left_x.at<int16_t>(k);
406  v_left_y[k] = dp.m_rectify_map_left_y.at<uint16_t>(k);
407  v_right_x[k] = dp.m_rectify_map_right_x.at<int16_t>(k);
408  v_right_y[k] = dp.m_rectify_map_right_y.at<uint16_t>(k);
409 
410  // v_left_x[k] =
411  // this->m_options.dp.m_rectify_map_left_x.at<int16_t>(k);
412  // v_left_y[k] =
413  // this->m_options.dp.m_rectify_map_left_y.at<uint16_t>(k);
414  // v_right_x[k] =
415  // this->m_options.dp.m_rectify_map_right_x.at<int16_t>(k);
416  // v_right_y[k] =
417  // this->m_options.dp.m_rectify_map_right_y.at<uint16_t>(k);
418  }
420  // m_rectify_map.setRectifyMaps( v_left_x, v_left_y, v_right_x,
421  // v_right_y );
422  }
423  else
424  {
425  cout << "[CDUO3DCamera] Warning: Calibration information is "
426  "set to be read from a file, but the file was not "
427  "specified. Unrectified images will be grabbed."
428  << endl;
429  }
430  } // end-if
431  } // end-if
432  else if (this->m_options.m_capture_rectified)
433  {
435  }
436 
437  // Find optimal binning parameters for given (width, height)
438  // This maximizes sensor imaging area for given resolution
439  int binning = DUO_BIN_NONE;
440  if (this->m_options.m_img_width <= 752 / 2) binning += DUO_BIN_HORIZONTAL2;
441  if (this->m_options.m_img_height <= 480 / 4)
442  binning += DUO_BIN_VERTICAL4;
443  else if (this->m_options.m_img_height <= 480 / 2)
444  binning += DUO_BIN_VERTICAL2;
445 
446  // Check if we support given resolution (width, height, binning, fps)
447  DUOResolutionInfo ri;
448  if (!EnumerateResolutions(
449  &ri, 1, this->m_options.m_img_width, this->m_options.m_img_height,
450  binning, this->m_options.m_fps))
451  THROW_EXCEPTION("[CDUO3DCamera] Error: Resolution not supported.");
452 
453  if (!OpenDUO(&M_DUO_VALUE)) // was: m_duo
454  THROW_EXCEPTION("[CDUO3DCamera] Error: Camera could not be opened.");
455 
456  // Get and print some DUO parameter values
457  char name[260], version[260];
458  GetDUODeviceName(M_DUO_VALUE, name);
459  GetDUOFirmwareVersion(M_DUO_VALUE, version);
460  cout << "[CDUO3DCamera::open] DUO3DCamera name: " << name << " (v"
461  << version << ")" << endl;
462 
463  // Set selected resolution
464  SetDUOResolutionInfo(M_DUO_VALUE, ri);
465 
466  // Set selected camera settings
467  SetDUOExposure(M_DUO_VALUE, m_options.m_exposure);
468  SetDUOGain(M_DUO_VALUE, m_options.m_gain);
469  SetDUOLedPWM(M_DUO_VALUE, m_options.m_led);
470 
471  // Start capture
472  if (startCapture)
473  {
474  if (!StartDUO(M_DUO_VALUE, DUOCallback, reinterpret_cast<void*>(this)))
476  "[CDUO3DCamera] Error: Camera could not be started.")
477  }
478 
479 #endif
480 } // end-open
481 
482 /*-------------------------------------------------------------
483  getObservations
484 -------------------------------------------------------------*/
486  CObservationStereoImages& outObservation_img,
487  CObservationIMU& outObservation_imu, bool& there_is_img, bool& there_is_imu)
488 {
489 #if MRPT_HAS_DUO3D
490  there_is_img = false;
491  there_is_imu = false;
492 
494  if (!m_pframe_data) return;
495 
496  // -----------------------------------------------
497  // Extract the observation:
498  // -----------------------------------------------
499  outObservation_img.timestamp = outObservation_imu.timestamp =
501 
502  outObservation_img.setStereoCameraParams(m_options.m_stereo_camera);
503  outObservation_img.imageLeft.loadFromMemoryBuffer(
505  (unsigned char*)reinterpret_cast<PDUOFrame>(m_pframe_data)->leftData);
506 
507  outObservation_img.imageRight.loadFromMemoryBuffer(
509  (unsigned char*)reinterpret_cast<PDUOFrame>(m_pframe_data)->rightData);
510 
511  if (this->m_options.m_capture_rectified)
512  m_rectify_map.rectify(outObservation_img);
513 
514  there_is_img = true;
515 
516  if (this->m_options.m_capture_imu)
517  {
518  if (!reinterpret_cast<PDUOFrame>(m_pframe_data)->accelerometerPresent)
519  {
520  cout << "[CDUO3DCamera] Warning: This device does not provide IMU "
521  "data. No IMU observations will be created."
522  << endl;
523  this->m_options.m_capture_imu = false;
524  }
525  else
526  {
527  // Accelerometer data
528  for (size_t k = 0; k < 3; ++k)
529  {
530  outObservation_imu.rawMeasurements[k] =
531  reinterpret_cast<PDUOFrame>(m_pframe_data)->accelData[k];
532  outObservation_imu.dataIsPresent[k] = true;
533  }
534 
535  // Gyroscopes data
536  for (size_t k = 0; k < 3; ++k)
537  {
538  outObservation_imu.rawMeasurements[k + 3] =
539  reinterpret_cast<PDUOFrame>(m_pframe_data)->gyroData[k];
540  outObservation_imu.dataIsPresent[k + 3] = true;
541  }
542  there_is_imu = true;
543  } // end else
544  } // end-imu-info
545 #endif
546 }
547 
548 /** Closes DUO camera */
550 {
551 #if MRPT_HAS_DUO3D
552  if (!M_DUO_VALUE) return;
553  StopDUO(M_DUO_VALUE);
554  CloseDUO(M_DUO_VALUE);
555  M_DUO_VALUE = nullptr;
556 #endif
557 } // end-close
558 
559 // Waits until the new DUO frame is ready and returns it
561 {
562 #if MRPT_HAS_DUO3D
563  if (M_DUO_VALUE == nullptr) return 0;
564  if (WaitForSingleObject(m_evFrame, 1000) == WAIT_OBJECT_0)
565  return m_pframe_data;
566  else
567  return nullptr;
568 #else
569  return nullptr; // return something to silent compiler warnings.
570 #endif
571 }
572 
574 {
575 #if MRPT_HAS_DUO3D
576  if (M_DUO_VALUE == nullptr) return;
577  SetDUOExposure(M_DUO_VALUE, value);
578 #endif
579 }
580 
582 {
583 #if MRPT_HAS_DUO3D
584  if (M_DUO_VALUE == nullptr) return;
585  SetDUOGain(M_DUO_VALUE, value);
586 #endif
587 }
588 
590 {
591 #if MRPT_HAS_DUO3D
592  if (M_DUO_VALUE == nullptr) return;
593  SetDUOLedPWM(M_DUO_VALUE, value);
594 #endif
595 }
596 
597 /** Queries the DUO3D Camera firmware version */
598 bool CDUO3DCamera::queryVersion(std::string version, bool printOutVersion)
599 {
600 #if MRPT_HAS_DUO3D
601  version = std::string(GetLibVersion());
602  if (printOutVersion)
603  std::cout << "DUO3D Camera library version: " << version << std::endl;
604  return true;
605 #else
606  return false;
607 #endif
608 }
#define FALSE
uint32_t nrows
Definition: TCamera.h:39
bool queryVersion(std::string version, bool printOutVersion=false)
Queries the DUO3D Camera firmware version.
float m_fps
(Default = 30) Frames per second <= 30.
Definition: CDUO3DCamera.h:39
GLdouble GLdouble t
Definition: glext.h:3695
std::string m_intrinsic_filename
Intrinsic parameters file provided by DUO3D Calibration App (YML format).
Definition: CDUO3DCamera.h:67
std::vector< bool > dataIsPresent
Each entry in this vector is true if the corresponding data index contains valid data (the IMU unit s...
std::string read_string(const std::string &section, const std::string &name, const std::string &defaultValue, bool failIfNotFound=false) const
mrpt::img::CImage imageLeft
Image from the left camera (this image will be ALWAYS present)
cv::Mat m_rectify_map_left_y
This "software driver" implements the communication protocol for interfacing a DUO3D Stereo Camera...
Definition: CDUO3DCamera.h:153
std::vector< double > rawMeasurements
The accelerometer and/or gyroscope measurements taken by the IMU at the given timestamp.
#define THROW_EXCEPTION(msg)
Definition: exceptions.h:67
void * m_get_duo_frame()
Gets a stereo frame from the DUO3D Camera (void* to be reinterpreted as PDUOFrame) ...
std::string std::string format(std::string_view fmt, ARGS &&... args)
Definition: format.h:26
void setDistortionParamsFromValues(double k1, double k2, double p1, double p2, double k3=0)
Set the vector of distortion params of the camera from the individual values of the distortion coeffi...
Definition: TCamera.h:159
void m_set_exposure(float value)
Sets DUO3D camera Exposure setting.
#define CALLBACK
Definition: glew.h:110
float m_exposure
(Default = 50) Exposure value.
Definition: CDUO3DCamera.h:41
bool m_calibration_from_file
(Default = true) Get calibration information from files provided by DUO3D Calibration App...
Definition: CDUO3DCamera.h:57
bool m_capture_imu
(Default = false) Capture IMU data.
Definition: CDUO3DCamera.h:51
void * m_pframe_data
Pointer, to be reinterpreted as "PDUOFrame".
Definition: CDUO3DCamera.h:166
mrpt::system::TTimeStamp now()
A shortcut for system::getCurrentTime.
Definition: datetime.h:86
Contains classes for various device interfaces.
mrpt::math::TPose3DQuat asTPose() const
void setFromCamParams(const mrpt::img::TStereoCamera &params)
Prepares the mapping from the intrinsic, distortion and relative pose parameters of a stereo camera...
float read_float(const std::string &section, const std::string &name, float defaultValue, bool failIfNotFound=false) const
std::string m_rectify_map_filename
Rectification map file provided by DUO3D Calibration App (YML format).
Definition: CDUO3DCamera.h:64
STL namespace.
int m_img_width
(Default = 640) Width of the captured image.
Definition: CDUO3DCamera.h:35
This class stores measurements from an Inertial Measurement Unit (IMU) (attitude estimation, raw gyroscope and accelerometer values), altimeters or magnetometers.
mrpt::img::TStereoCamera m_stereo_camera
Definition: CDUO3DCamera.h:75
TYMLReadResult m_camera_ext_params_from_yml(const std::string &_file_name=std::string())
Definition: img/CImage.h:22
GLsizei GLsizei GLuint * obj
Definition: glext.h:4085
std::map< const mrpt::hwdrivers::TCaptureOptions_DUO3D *, TDUOParams > duo_params
int read_int(const std::string &section, const std::string &name, int defaultValue, bool failIfNotFound=false) const
void m_set_gain(float value)
Sets DUO3D camera Gain setting.
cv::Mat m_rectify_map_right_y
mrpt::math::CMatrixDouble33 intrinsicParams
Matrix of intrinsic parameters (containing the focal length and principal point coordinates): ...
Definition: TCamera.h:49
float m_led
(Default = 25) Led intensity (some device models).
Definition: CDUO3DCamera.h:43
void open(const TCaptureOptions_DUO3D &options, const bool startCapture=true)
Tries to open the camera with the given options, and starts capturing.
This class allows loading and storing values and vectors of different types from a configuration text...
This base provides a set of functions for maths stuff.
int m_img_height
(Default = 480) Height of the captured image.
Definition: CDUO3DCamera.h:37
void rectify(const mrpt::img::CImage &in_left_image, const mrpt::img::CImage &in_right_image, mrpt::img::CImage &out_left_image, mrpt::img::CImage &out_right_image) const
Rectify the input image pair and save the result in a different output images - setFromCamParams() mu...
TYMLReadResult m_rectify_map_from_yml(const std::string &_file_name=std::string())
Observation class for either a pair of left+right or left+disparity images from a stereo camera...
float m_gain
(Default = 10) Camera gain.
Definition: CDUO3DCamera.h:45
This namespace contains representation of robot actions and observations.
void getObservations(mrpt::obs::CObservationStereoImages &outObservation_img, mrpt::obs::CObservationIMU &outObservation_imu, bool &there_is_img, bool &there_is_imu)
Specific laser scanner "software drivers" must process here new data from the I/O stream...
void loadFromConfigFile(const std::string &section, const mrpt::config::CConfigFileBase &cfg)
Load all the params from a config source, in the same format that used in saveToConfigFile().
void loadOptionsFrom(const mrpt::config::CConfigFileBase &configSource, const std::string &sectionName, const std::string &prefix=std::string())
Loads all the options from a config file.
A class used to store a 3D pose as a translation (x,y,z) and a quaternion (qr,qx,qy,qz).
Definition: CPose3DQuat.h:45
Options used when creating a camera capture object of type CImageGrabber_FlyCapture2.
Definition: CDUO3DCamera.h:20
void * m_evFrame
DUO&#39;s HANDLE.
Definition: CDUO3DCamera.h:168
GLsizei const GLchar ** string
Definition: glext.h:4116
Classes for 2D/3D geometry representation, both of single values and probability density distribution...
std::array< double, 8 > dist
[k1 k2 t1 t2 k3 k4 k5 k6] -> k_i: parameters of radial distortion, t_i: parameters of tangential dist...
Definition: TCamera.h:52
bool empty() const
Definition: ts_hash_map.h:191
Lightweight 3D pose (three spatial coordinates, plus a quaternion ).
Definition: TPose3DQuat.h:19
void setStereoCameraParams(const mrpt::img::TStereoCamera &in_params)
Sets leftCamera, rightCamera and rightCameraPose from a TStereoCamera structure.
TCaptureOptions_DUO3D m_options
Definition: CDUO3DCamera.h:158
#define M_DUO_PTR
void * m_duo
Opaque pointer to DUO&#39;s DUOInstance.
Definition: CDUO3DCamera.h:164
This is the global namespace for all Mobile Robot Programming Toolkit (MRPT) libraries.
mrpt::system::TTimeStamp timestamp
The associated UTC time-stamp.
Definition: CObservation.h:60
A class used to store a 3D pose (a 3D translation + a rotation in 3D).
Definition: CPose3D.h:85
bool read_bool(const std::string &section, const std::string &name, bool defaultValue, bool failIfNotFound=false) const
void startCapture()
Start the actual data capture of the camera.
TCamera leftCamera
Intrinsic and distortion parameters of the left and right cameras.
Definition: TStereoCamera.h:28
GLuint const GLchar * name
Definition: glext.h:4068
mrpt::math::TPose3DQuat rightCameraPose
Pose of the right camera with respect to the coordinate origin of the left camera.
Definition: TStereoCamera.h:31
cv::Mat m_rectify_map_right_x
std::string m_extrinsic_filename
Extrinsic parameters file provided by DUO3D Calibration App (YML format).
Definition: CDUO3DCamera.h:70
GLsizei const GLfloat * value
Definition: glext.h:4134
void m_set_led(float value)
Sets DUO3D camera LED setting.
GLuint res
Definition: glext.h:7385
void setIntrinsicParamsFromValues(double fx, double fy, double cx, double cy)
Set the matrix of intrinsic params of the camera from the individual values of focal length and princ...
Definition: TCamera.h:110
std::string extractFileName(const std::string &filePath)
Extract just the name (without extension) of a filename from a complete path plus name plus extension...
Definition: filesystem.cpp:62
CDUO3DCamera()
Default Constructor (does not open the camera)
TYMLReadResult m_camera_int_params_from_yml(const std::string &_file_name=std::string())
mrpt::vision::CStereoRectifyMap m_rectify_map
Definition: CDUO3DCamera.h:161
uint32_t ncols
Camera resolution.
Definition: TCamera.h:39
void setDataFrame(void *frame)
frame is a reinterpreted PDUOFrame
Definition: CDUO3DCamera.h:223
Structure to hold the parameters of a pinhole stereo camera model.
Definition: TStereoCamera.h:23
bool m_capture_rectified
(Default = true) Rectify images.
Definition: CDUO3DCamera.h:54
void close()
Stop capture and closes the opened camera, if any.
mrpt::img::CImage imageRight
Image from the right camera, only contains a valid image if hasImageRight == true.
cv::Mat m_rectify_map_left_x
void loadFromMemoryBuffer(unsigned int width, unsigned int height, bool color, unsigned char *rawpixels, bool swapRedBlue=false)
Reads the image from raw pixels buffer in memory.
Definition: CImage.cpp:372
virtual ~CDUO3DCamera()
Destructor.
#define M_DUO_VALUE



Page generated by Doxygen 1.8.14 for MRPT 1.9.9 Git: ce444d842 Fri Dec 6 19:35:10 2019 +0100 at vie dic 6 19:45:12 CET 2019