TypeMapping.cpp
Go to the documentation of this file.
1 /*
2  * This file is part of ArmarX.
3  *
4  * Copyright (C) 2011-2016, High Performance Humanoid Technologies (H2T), Karlsruhe Institute of Technology (KIT), all rights reserved.
5  *
6  * ArmarX is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation.
9  *
10  * ArmarX is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program. If not, see <http://www.gnu.org/licenses/>.
17  *
18  * @package VisionX::Tools
19  * @author Jan Issac (jan dot issac at gmx dot net)
20  * @date 2011
21  * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
22  * GNU General Public License
23  */
24 
25 #include "TypeMapping.h"
26 
27 #include <ArmarXCore/core/exceptions/local/ExpressionException.h>
28 
29 // SLT
30 #include <map>
31 #include <vector>
32 
33 // IVT
34 #include <Calibration/Calibration.h>
35 #include <Calibration/StereoCalibration.h>
36 #include <Image/ByteImage.h>
37 #include <Math/Math2d.h>
38 #include <Math/Math3d.h>
39 #include <Structs/Structs.h>
40 
41 visionx::ImageType
42 visionx::tools::typeNameToImageType(const std::string& imageTypeName)
43 {
44  static std::map<std::string, visionx::ImageType> nameToTypeMap;
45 
46  // initialize image type name to image type integer mapping
47  if (nameToTypeMap.empty())
48  {
49  nameToTypeMap["bayer-pattern"] = visionx::eBayerPattern;
50  nameToTypeMap["gray-scale"] = visionx::eGrayScale;
51  nameToTypeMap["rgb"] = visionx::eRgb;
52  nameToTypeMap["float-1-channel"] = visionx::eFloat1Channel;
53  nameToTypeMap["float-3-channels"] = visionx::eFloat3Channels;
54  }
55 
56  std::string lowerCaseTypeName = imageTypeName;
57  std::transform(
58  lowerCaseTypeName.begin(), lowerCaseTypeName.end(), lowerCaseTypeName.begin(), ::tolower);
59 
60  std::map<std::string, visionx::ImageType>::iterator nameToTypeIter =
61  nameToTypeMap.find(lowerCaseTypeName);
62 
63  if (nameToTypeIter == nameToTypeMap.end())
64  {
65  throw visionx::exceptions::local::InvalidImageTypeNameException(imageTypeName);
66  }
67 
68  return nameToTypeIter->second;
69 }
70 
71 std::string
72 visionx::tools::imageTypeToTypeName(const ImageType imageType)
73 {
74  switch (imageType)
75  {
76  case visionx::eBayerPattern:
77  return "bayer-pattern";
78 
79  case visionx::eGrayScale:
80  return "gray-scale";
81 
82  case visionx::eRgb:
83  return "rgb";
84 
85  case visionx::eFloat1Channel:
86  return "float-1-channel";
87 
88  case visionx::eFloat3Channels:
89  return "float-3-channel";
90 
91  default:
92  return "unknown";
93  }
94 }
95 
96 CByteImage::ImageType
97 visionx::tools::convert(const ImageType visionxImageType)
98 {
99  static std::map<visionx::ImageType, CByteImage::ImageType> visionxTypeToIvtTypeMap;
100 
101  // initialize VisionX image type to ByteImage image type mapping
102  if (visionxTypeToIvtTypeMap.empty())
103  {
104  visionxTypeToIvtTypeMap[visionx::eRgb] = CByteImage::eRGB24;
105  visionxTypeToIvtTypeMap[visionx::eGrayScale] = CByteImage::eGrayScale;
106  visionxTypeToIvtTypeMap[visionx::eBayerPattern] = CByteImage::eGrayScale;
107  }
108 
109  std::map<visionx::ImageType, CByteImage::ImageType>::iterator visionxTypeToIvtTypeIter =
110  visionxTypeToIvtTypeMap.find(visionxImageType);
111 
112  if (visionxTypeToIvtTypeIter == visionxTypeToIvtTypeMap.end())
113  {
114  throw visionx::exceptions::local::UnsupportedImageTypeException(
115  visionx::tools::imageTypeToTypeName(visionxImageType));
116  }
117 
118  return visionxTypeToIvtTypeIter->second;
119 }
120 
121 ImageProcessor::BayerPatternType
122 visionx::tools::convert(const BayerPatternType visionxBayerPatternType)
123 {
124  switch (visionxBayerPatternType)
125  {
126  case visionx::eBayerPatternBg:
127  return ::ImageProcessor::eBayerBG;
128 
129  case visionx::eBayerPatternGb:
130  return ::ImageProcessor::eBayerGB;
131 
132  case visionx::eBayerPatternGr:
133  return ::ImageProcessor::eBayerGR;
134 
135  case visionx::eBayerPatternRg:
136  return ::ImageProcessor::eBayerRG;
137  }
138 
139  // default value (this is never reached since there are only 4 Bayer Pattern
140  // types which are already handled by the switch above)
141  return ::ImageProcessor::eBayerRG;
142 }
143 
144 CVideoCaptureInterface::VideoMode
145 visionx::tools::convert(const ImageDimension& imageDimension)
146 {
147  // since the width or the height of each available dimension is unique, we use only
148  // the width to identify the dimension
149  switch (imageDimension.width)
150  {
151  case 0:
152  return CVideoCaptureInterface::eNone;
153 
154  case 320:
155  return CVideoCaptureInterface::e320x240;
156 
157  case 640:
158  return CVideoCaptureInterface::e640x480;
159 
160  case 800:
161  return CVideoCaptureInterface::e800x600;
162 
163  case 768:
164  return CVideoCaptureInterface::e768x576;
165 
166  case 1024:
167  return CVideoCaptureInterface::e1024x768;
168 
169  case 1280:
170  return CVideoCaptureInterface::e1280x960;
171 
172  case 1600:
173  return CVideoCaptureInterface::e1600x1200;
174  }
175 
176  return CVideoCaptureInterface::eNone;
177 }
178 
179 CVideoCaptureInterface::FrameRate
180 visionx::tools::convert(const float frameRate)
181 {
182  using FrameRateRange = std::pair<float, float>;
183 
184  static std::map<FrameRateRange, CVideoCaptureInterface::FrameRate> frameRateMap;
185 
186  using FrameRateMapIter = std::map<FrameRateRange, CVideoCaptureInterface::FrameRate>::iterator;
187 
188  if (frameRateMap.empty())
189  {
190  frameRateMap[FrameRateRange(0.f, 1.875f + 1.875f / 2)] = CVideoCaptureInterface::e1_875fps;
191  frameRateMap[FrameRateRange(1.875f + 1.875f / 2, 3.75f + 1.875f)] =
192  CVideoCaptureInterface::e3_75fps;
193  frameRateMap[FrameRateRange(3.75f + 1.875f, 7.5f + 3.75f)] =
194  CVideoCaptureInterface::e7_5fps;
195  frameRateMap[FrameRateRange(7.5f + 3.75f, 15.f + 7.5f)] = CVideoCaptureInterface::e15fps;
196  frameRateMap[FrameRateRange(15.f + 7.5f, 30.f + 15.f)] = CVideoCaptureInterface::e30fps;
197  frameRateMap[FrameRateRange(30.f + 15.f, 1024.f)] = CVideoCaptureInterface::e60fps;
198  }
199 
200  FrameRateMapIter iter = frameRateMap.begin();
201 
202  while (iter != frameRateMap.end())
203  {
204  if (frameRate >= iter->first.first && frameRate < iter->first.second)
205  {
206  return iter->second;
207  }
208 
209  iter++;
210  }
211 
212  throw visionx::exceptions::local::InvalidFrameRateException(frameRate);
213 }
214 
215 Vec2d
216 visionx::tools::convert(const visionx::types::Vec* pVec)
217 {
218  Vec2d vec2d;
219  vec2d.x = (*pVec)[0];
220  vec2d.y = (*pVec)[1];
221 
222  return vec2d;
223 }
224 
225 Vec3d
226 visionx::tools::convert(const visionx::types::Vec& vec)
227 {
228  Vec3d vec3d;
229  vec3d.x = vec[0];
230  vec3d.y = vec[1];
231  vec3d.z = vec[2];
232 
233  return vec3d;
234 }
235 
236 Mat3d
237 visionx::tools::convert(const visionx::types::Mat& mat)
238 {
239  Mat3d ivtMat3d;
240  ARMARX_CHECK_EQUAL(mat.size(), 3);
241  ARMARX_CHECK_EQUAL(mat[0].size(), 3);
242  ARMARX_CHECK_EQUAL(mat[1].size(), 3);
243  ARMARX_CHECK_EQUAL(mat[2].size(), 3);
244 
245 
246  ivtMat3d.r1 = mat[0][0];
247  ivtMat3d.r2 = mat[0][1];
248  ivtMat3d.r3 = mat[0][2];
249  ivtMat3d.r4 = mat[1][0];
250  ivtMat3d.r5 = mat[1][1];
251  ivtMat3d.r6 = mat[1][2];
252  ivtMat3d.r7 = mat[2][0];
253  ivtMat3d.r8 = mat[2][1];
254  ivtMat3d.r9 = mat[2][2];
255 
256  return ivtMat3d;
257 }
258 
259 visionx::types::Vec
260 visionx::tools::convert(const Vec2d& ivtVec2d)
261 {
262  std::vector<float> vec(2);
263  vec[0] = ivtVec2d.x;
264  vec[1] = ivtVec2d.y;
265 
266  return vec;
267 }
268 
269 visionx::types::Vec
270 visionx::tools::convert(const Vec3d& ivtVec3d)
271 {
272  std::vector<float> vec(3);
273  vec[0] = ivtVec3d.x;
274  vec[1] = ivtVec3d.y;
275  vec[2] = ivtVec3d.z;
276 
277  return vec;
278 }
279 
280 visionx::types::Mat
281 visionx::tools::convert(const Mat3d& ivtMat3d)
282 {
283  std::vector<std::vector<float>> mat(3);
284  std::vector<float> rowVec(3);
285 
286  rowVec[0] = ivtMat3d.r1;
287  rowVec[1] = ivtMat3d.r2;
288  rowVec[2] = ivtMat3d.r3;
289  mat[0] = rowVec;
290 
291  rowVec = std::vector<float>(3);
292  rowVec[0] = ivtMat3d.r4;
293  rowVec[1] = ivtMat3d.r5;
294  rowVec[2] = ivtMat3d.r6;
295  mat[1] = rowVec;
296 
297  rowVec = std::vector<float>(3);
298  rowVec[0] = ivtMat3d.r7;
299  rowVec[1] = ivtMat3d.r8;
300  rowVec[2] = ivtMat3d.r9;
301  mat[2] = rowVec;
302 
303  return mat;
304 }
305 
306 CStereoCalibration*
307 visionx::tools::convert(const visionx::StereoCalibration& stereoCalibration)
308 {
309  CStereoCalibration* ivtStereoCalibration = new CStereoCalibration();
310 
311  CCalibration ivtCalibrationLeft;
312  CCalibration ivtCalibrationRight;
313 
314  const visionx::CameraParameters& cameraParamLeft =
315  stereoCalibration.calibrationLeft.cameraParam;
316  const visionx::CameraParameters& cameraParamRight =
317  stereoCalibration.calibrationRight.cameraParam;
318 
319  Mat3d R = convert(cameraParamLeft.rotation);
320  Vec3d t = convert(cameraParamLeft.translation);
321  ARMARX_CHECK_EQUAL(cameraParamLeft.focalLength.size(), 2);
322  ARMARX_CHECK_EQUAL(cameraParamLeft.principalPoint.size(), 2);
323  ARMARX_CHECK_EQUAL(cameraParamLeft.distortion.size(), 4);
324  ivtCalibrationLeft.SetCameraParameters(cameraParamLeft.focalLength[0],
325  cameraParamLeft.focalLength[1],
326  cameraParamLeft.principalPoint[0],
327  cameraParamLeft.principalPoint[1],
328  cameraParamLeft.distortion[0],
329  cameraParamLeft.distortion[1],
330  cameraParamLeft.distortion[2],
331  cameraParamLeft.distortion[3],
332  R,
333  t,
334  cameraParamLeft.width,
335  cameraParamLeft.height);
336 
337  R = convert(cameraParamRight.rotation);
338  t = convert(cameraParamRight.translation);
339  ARMARX_CHECK_EQUAL(cameraParamRight.focalLength.size(), 2);
340  ARMARX_CHECK_EQUAL(cameraParamRight.principalPoint.size(), 2);
341  ARMARX_CHECK_EQUAL(cameraParamRight.distortion.size(), 4);
342 
343  ivtCalibrationRight.SetCameraParameters(cameraParamRight.focalLength[0],
344  cameraParamRight.focalLength[1],
345  cameraParamRight.principalPoint[0],
346  cameraParamRight.principalPoint[1],
347  cameraParamRight.distortion[0],
348  cameraParamRight.distortion[1],
349  cameraParamRight.distortion[2],
350  cameraParamRight.distortion[3],
351  R,
352  t,
353  cameraParamRight.width,
354  cameraParamRight.height);
355 
356  ivtStereoCalibration->SetSingleCalibrations(ivtCalibrationLeft, ivtCalibrationRight);
357 
358  ivtStereoCalibration->rectificationHomographyLeft =
359  convert(stereoCalibration.rectificationHomographyLeft);
360  ivtStereoCalibration->rectificationHomographyRight =
361  convert(stereoCalibration.rectificationHomographyRight);
362 
363  return ivtStereoCalibration;
364 }
365 
366 CCalibration*
367 visionx::tools::convert(const visionx::MonocularCalibration& calibration)
368 {
369  CCalibration* ivtCalibration = new CCalibration();
370 
371  const visionx::CameraParameters& cameraParam = calibration.cameraParam;
372 
373  Mat3d R = convert(cameraParam.rotation);
374  Vec3d t = convert(cameraParam.translation);
375 
376  ivtCalibration->SetCameraParameters(cameraParam.focalLength[0],
377  cameraParam.focalLength[1],
378  cameraParam.principalPoint[0],
379  cameraParam.principalPoint[1],
380  cameraParam.distortion[0],
381  cameraParam.distortion[1],
382  cameraParam.distortion[2],
383  cameraParam.distortion[3],
384  R,
385  t,
386  cameraParam.width,
387  cameraParam.height);
388 
389  return ivtCalibration;
390 }
391 
392 visionx::StereoCalibration
393 visionx::tools::convert(const CStereoCalibration& ivtStereoCalibration)
394 {
395  visionx::StereoCalibration stereoCalibration;
396 
397  const CCalibration::CCameraParameters& ivtCalibParamLeft =
398  ivtStereoCalibration.GetLeftCalibration()->GetCameraParameters();
399  const CCalibration::CCameraParameters& ivtCalibParamRight =
400  ivtStereoCalibration.GetRightCalibration()->GetCameraParameters();
401 
402  visionx::CameraParameters& cameraParamLeft = stereoCalibration.calibrationLeft.cameraParam;
403  visionx::CameraParameters& cameraParamRight = stereoCalibration.calibrationRight.cameraParam;
404 
405  // Left camera parameters
406  cameraParamLeft.width = ivtCalibParamLeft.width;
407  cameraParamLeft.height = ivtCalibParamLeft.height;
408 
409  cameraParamLeft.principalPoint = convert(ivtCalibParamLeft.principalPoint);
410  cameraParamLeft.focalLength = convert(ivtCalibParamLeft.focalLength);
411  cameraParamLeft.rotation = convert(ivtCalibParamLeft.rotation);
412  cameraParamLeft.translation = convert(ivtCalibParamLeft.translation);
413 
414  cameraParamLeft.distortion.push_back(ivtCalibParamLeft.distortion[0]);
415  cameraParamLeft.distortion.push_back(ivtCalibParamLeft.distortion[1]);
416  cameraParamLeft.distortion.push_back(ivtCalibParamLeft.distortion[2]);
417  cameraParamLeft.distortion.push_back(ivtCalibParamLeft.distortion[3]);
418 
419  // right camera parameters
420  cameraParamRight.width = ivtCalibParamRight.width;
421  cameraParamRight.height = ivtCalibParamRight.height;
422 
423  cameraParamRight.principalPoint = convert(ivtCalibParamRight.principalPoint);
424  cameraParamRight.focalLength = convert(ivtCalibParamRight.focalLength);
425  cameraParamRight.rotation = convert(ivtCalibParamRight.rotation);
426  cameraParamRight.translation = convert(ivtCalibParamRight.translation);
427 
428  cameraParamRight.distortion.push_back(ivtCalibParamRight.distortion[0]);
429  cameraParamRight.distortion.push_back(ivtCalibParamRight.distortion[1]);
430  cameraParamRight.distortion.push_back(ivtCalibParamRight.distortion[2]);
431  cameraParamRight.distortion.push_back(ivtCalibParamRight.distortion[3]);
432 
433  stereoCalibration.rectificationHomographyLeft =
434  convert(ivtStereoCalibration.rectificationHomographyLeft);
435  stereoCalibration.rectificationHomographyRight =
436  convert(ivtStereoCalibration.rectificationHomographyRight);
437 
438  return stereoCalibration;
439 }
440 
441 visionx::MonocularCalibration
442 visionx::tools::convert(const CCalibration& ivtCalibration)
443 {
444  visionx::MonocularCalibration calibration;
445  const CCalibration::CCameraParameters& ivtCalibParam = ivtCalibration.GetCameraParameters();
446 
447  calibration.cameraParam.width = ivtCalibParam.width;
448  calibration.cameraParam.height = ivtCalibParam.height;
449 
450  calibration.cameraParam.principalPoint = convert(ivtCalibParam.principalPoint);
451  calibration.cameraParam.focalLength = convert(ivtCalibParam.focalLength);
452  calibration.cameraParam.rotation = convert(ivtCalibParam.rotation);
453  calibration.cameraParam.translation = convert(ivtCalibParam.translation);
454 
455  calibration.cameraParam.distortion.push_back(ivtCalibParam.distortion[0]);
456  calibration.cameraParam.distortion.push_back(ivtCalibParam.distortion[1]);
457  calibration.cameraParam.distortion.push_back(ivtCalibParam.distortion[2]);
458  calibration.cameraParam.distortion.push_back(ivtCalibParam.distortion[3]);
459 
460  return calibration;
461 }
462 
463 visionx::types::Region
464 visionx::tools::convert(const MyRegion& ivtRegion)
465 {
466  visionx::types::Region region;
467 
468  visionx::tools::arrayToVector(ivtRegion.pPixels, ivtRegion.nPixels, region.pixels);
469  region.nPixels = ivtRegion.nPixels;
470 
471  region.minX = ivtRegion.min_x;
472  region.maxX = ivtRegion.max_x;
473  region.minY = ivtRegion.min_y;
474  region.maxY = ivtRegion.max_y;
475 
476  region.ratio = ivtRegion.ratio;
477 
478  region.centroid = visionx::tools::convert(ivtRegion.centroid);
479 
480  return region;
481 }
482 
483 MyRegion
484 visionx::tools::convert(const visionx::types::Region& region)
485 {
486  MyRegion ivtRegion;
487 
488  ivtRegion.pPixels = visionx::tools::vectorToArray(region.pixels);
489  ivtRegion.nPixels = region.nPixels;
490 
491  ivtRegion.min_x = region.minX;
492  ivtRegion.max_x = region.maxX;
493  ivtRegion.min_y = region.minY;
494  ivtRegion.max_y = region.maxY;
495 
496  ivtRegion.ratio = region.ratio;
497 
498  ivtRegion.centroid = visionx::tools::convert(&region.centroid);
499 
500  return ivtRegion;
501 }
502 
503 visionx::types::ObjectColor
504 visionx::tools::convert(const ObjectColor& ivtObjectColor)
505 {
506  return (visionx::types::ObjectColor)ivtObjectColor;
507 }
508 
509 ObjectColor
510 visionx::tools::convert(const visionx::types::ObjectColor& objectColor)
511 {
512  return (ObjectColor)objectColor;
513 }
514 
515 visionx::types::ObjectType
516 visionx::tools::convert(const ObjectType& ivtObjectType)
517 {
518  return (visionx::types::ObjectType)ivtObjectType;
519 }
520 
521 ObjectType
522 visionx::tools::convert(const visionx::types::ObjectType& objectType)
523 {
524  return (ObjectType)objectType;
525 }
526 
527 visionx::types::Transformation3d
528 visionx::tools::convert(const Transformation3d& ivtTransformation3d)
529 {
530  visionx::types::Transformation3d transformation3d;
531 
532  transformation3d.translation = visionx::tools::convert(ivtTransformation3d.translation);
533  transformation3d.rotation = visionx::tools::convert(ivtTransformation3d.rotation);
534 
535  return transformation3d;
536 }
537 
538 Transformation3d
539 visionx::tools::convert(const visionx::types::Transformation3d& transformation3d)
540 {
541  Transformation3d ivtTransformation3d;
542 
543  ivtTransformation3d.translation = visionx::tools::convert(transformation3d.translation);
544  ivtTransformation3d.rotation = visionx::tools::convert(transformation3d.rotation);
545 
546  return ivtTransformation3d;
547 }
548 
549 Object3DEntry
550 visionx::tools::convert(const visionx::types::Object3DEntry& object3DEntry)
551 {
552  Object3DEntry ivtObject3DEntry;
553 
554  ivtObject3DEntry.region_left = convert(object3DEntry.regionLeft);
555  ivtObject3DEntry.region_right = convert(object3DEntry.regionRight);
556  ivtObject3DEntry.region_id_left = object3DEntry.regionIdLeft;
557  ivtObject3DEntry.region_id_right = object3DEntry.regionIdRight;
558  ivtObject3DEntry.type = convert(object3DEntry.type);
559  ivtObject3DEntry.color = convert(object3DEntry.color);
560  ivtObject3DEntry.pose = convert(object3DEntry.pose);
561  ivtObject3DEntry.world_point = convert(object3DEntry.worldPoint);
562  ivtObject3DEntry.orientation = convert(object3DEntry.orientation);
563  ivtObject3DEntry.sName = "";
564  ivtObject3DEntry.sName += object3DEntry.name;
565  ivtObject3DEntry.sOivFilePath = "";
566  // ivtObject3DEntry.sOivFilePath += objectEntry.oivFilePath;
567  ivtObject3DEntry.data = nullptr;
568  ivtObject3DEntry.class_id = object3DEntry.classId;
569  ivtObject3DEntry.quality = object3DEntry.quality;
570  ivtObject3DEntry.quality2 = object3DEntry.quality2;
571 
572  return ivtObject3DEntry;
573 }
574 
575 visionx::types::Object3DEntry
576 visionx::tools::convert(const Object3DEntry& ivtObject3DEntry)
577 {
578  visionx::types::Object3DEntry object3DEntry;
579 
580  object3DEntry.regionLeft = convert(ivtObject3DEntry.region_left);
581  object3DEntry.regionRight = convert(ivtObject3DEntry.region_right);
582  object3DEntry.regionIdLeft = ivtObject3DEntry.region_id_left;
583  object3DEntry.regionIdRight = ivtObject3DEntry.region_id_right;
584  object3DEntry.type = convert(ivtObject3DEntry.type);
585  object3DEntry.color = convert(ivtObject3DEntry.color);
586  object3DEntry.pose = convert(ivtObject3DEntry.pose);
587  object3DEntry.worldPoint = convert(ivtObject3DEntry.world_point);
588  object3DEntry.orientation = convert(ivtObject3DEntry.orientation);
589  object3DEntry.name = "";
590  object3DEntry.name += ivtObject3DEntry.sName;
591  //objectEntry.sOivFilePath = "";
592  // ivtObject3DEntry.sOivFilePath += objectEntry.oivFilePath;
593  object3DEntry.classId = ivtObject3DEntry.class_id;
594  object3DEntry.quality = ivtObject3DEntry.quality;
595  object3DEntry.quality2 = ivtObject3DEntry.quality2;
596 
597  return object3DEntry;
598 }
599 
600 Object3DList
601 visionx::tools::convert(const visionx::types::Object3DList& object3DList)
602 {
603  Object3DList ivtObject3DList(object3DList.size());
604 
605  visionx::types::Object3DList::const_iterator iter = object3DList.begin();
606 
607  int i = 0;
608 
609  while (iter != object3DList.end())
610  {
611  ivtObject3DList[i] = convert(*iter);
612 
613  iter++;
614  }
615 
616  return ivtObject3DList;
617 }
618 
619 visionx::types::Object3DList
620 visionx::tools::convert(const Object3DList& ivtObject3DList)
621 {
622  visionx::types::Object3DList object3DList(ivtObject3DList.size());
623 
624  Object3DList::const_iterator iter = ivtObject3DList.begin();
625 
626  int i = 0;
627 
628  while (iter != ivtObject3DList.end())
629  {
630  object3DList[i] = convert(*iter);
631 
632  iter++;
633  }
634 
635  return object3DList;
636 }
637 
638 Eigen::Matrix3f
639 visionx::tools::convertIVTtoEigen(const Mat3d m)
640 {
641  Eigen::Matrix3f result;
642  result(0, 0) = m.r1;
643  result(0, 1) = m.r2;
644  result(0, 2) = m.r3;
645  result(1, 0) = m.r4;
646  result(1, 1) = m.r5;
647  result(1, 2) = m.r6;
648  result(2, 0) = m.r7;
649  result(2, 1) = m.r8;
650  result(2, 2) = m.r9;
651  return result;
652 }
653 
654 Eigen::Vector3f
655 visionx::tools::convertIVTtoEigen(const Vec3d v)
656 {
657  Eigen::Vector3f result(v.x, v.y, v.z);
658  return result;
659 }
660 
661 visionx::types::Vec
662 visionx::tools::convertEigenVecToVisionX(Eigen::VectorXf v)
663 {
664  visionx::types::Vec res;
665  res.resize(v.rows());
666  for (int i = 0; i < v.rows(); i++)
667  {
668  res[i] = v[i];
669  }
670  return res;
671 }
672 
673 Eigen::VectorXf
674 visionx::tools::convertVisionXVecToEigen(visionx::types::Vec v)
675 {
676  Eigen::VectorXf res;
677  res.resize(v.size());
678  for (int i = 0; i < v.size(); i++)
679  {
680  res[i] = v[i];
681  }
682  return res;
683 }
684 
685 visionx::types::Mat
686 visionx::tools::convertEigenMatToVisionX(Eigen::MatrixXf m)
687 {
688  visionx::types::Mat res;
689  res.resize(m.cols());
690  for (int i = 0; i < m.cols(); i++)
691  {
692  visionx::types::Vec v;
693  Eigen::VectorXf vec = m.block(0, i, m.rows(), 1);
694  v = convertEigenVecToVisionX(vec);
695  res[i] = v;
696  }
697  return res;
698 }
699 
700 Eigen::MatrixXf
701 visionx::tools::convertVisionXMatToEigen(visionx::types::Mat m)
702 {
703  if (m.empty())
704  {
705  return Eigen::MatrixXf();
706  }
707  const size_t rows = m[0].size();
708  const size_t cols = m.size();
709 
710  Eigen::MatrixXf res(rows, cols);
711 
712  for (size_t col = 0; col < cols; ++col)
713  {
714  visionx::types::Vec v = m[col];
715  Eigen::VectorXf vec = convertVisionXVecToEigen(v);
716  res.col(col) = vec;
717  }
718 
719  return res;
720 }
visionx::tools::convertIVTtoEigen
Eigen::Matrix3f convertIVTtoEigen(const Mat3d m)
Definition: TypeMapping.cpp:639
GfxTL::Vec3d
VectorXD< 3, double > Vec3d
Definition: VectorXD.h:737
visionx::tools::vectorToArray
T * vectorToArray(const std::vector< T > &dataVector)
Definition: TypeMapping.h:61
visionx::tools::arrayToVector
void arrayToVector(const T *dataArray, const int size, std::vector< T > &vec)
Definition: TypeMapping.h:78
visionx::tools::convertVisionXMatToEigen
Eigen::MatrixXf convertVisionXMatToEigen(visionx::types::Mat m)
Definition: TypeMapping.cpp:701
convert
void convert(const std::filesystem::path &in, const std::filesystem::path &out, bool print_progress)
Performs the actual conversion.
Definition: main.cpp:170
visionx::exceptions::local::InvalidFrameRateException
Definition: InvalidFrameRateException.h:31
visionx::tools::convert
CByteImage::ImageType convert(const ImageType visionxImageType)
Converts a VisionX image type into an image type of IVT's ByteImage.
Definition: TypeMapping.cpp:97
visionx::tools::convertEigenVecToVisionX
visionx::types::Vec convertEigenVecToVisionX(Eigen::VectorXf v)
Definition: TypeMapping.cpp:662
visionx::exceptions::local::InvalidImageTypeNameException
Definition: InvalidImageTypeNameException.h:31
visionx::tools::imageTypeToTypeName
std::string imageTypeToTypeName(const ImageType imageType)
Converts an image type into a string integer.
Definition: TypeMapping.cpp:72
GfxTL::Vec2d
VectorXD< 2, double > Vec2d
Definition: VectorXD.h:736
armarx::transform
auto transform(const Container< InputT, Alloc > &in, OutputT(*func)(InputT const &)) -> Container< OutputT, typename std::allocator_traits< Alloc >::template rebind_alloc< OutputT >>
Convenience function (with less typing) to transform a container of type InputT into the same contain...
Definition: algorithm.h:351
ExpressionException.h
armarx::ctrlutil::v
double v(double t, double v0, double a0, double j)
Definition: CtrlUtil.h:39
visionx::tools::convertVisionXVecToEigen
Eigen::VectorXf convertVisionXVecToEigen(visionx::types::Vec v)
Definition: TypeMapping.cpp:674
visionx::tools::convertEigenMatToVisionX
visionx::types::Mat convertEigenMatToVisionX(Eigen::MatrixXf m)
Definition: TypeMapping.cpp:686
visionx::tools::typeNameToImageType
ImageType typeNameToImageType(const std::string &imageTypeName)
Converts an image type name as string into an ImageType integer.
Definition: TypeMapping.cpp:42
TypeMapping.h
GfxTL::Matrix3f
MatrixXX< 3, 3, float > Matrix3f
Definition: MatrixXX.h:649
ARMARX_CHECK_EQUAL
#define ARMARX_CHECK_EQUAL(lhs, rhs)
This macro evaluates whether lhs is equal (==) rhs and if it turns out to be false it will throw an E...
Definition: ExpressionException.h:130
visionx::exceptions::local::UnsupportedImageTypeException
Definition: UnsupportedImageTypeException.h:31