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
41visionx::ImageType
42visionx::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
71std::string
72visionx::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
96CByteImage::ImageType
97visionx::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
121ImageProcessor::BayerPatternType
122visionx::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
144CVideoCaptureInterface::VideoMode
145visionx::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
179CVideoCaptureInterface::FrameRate
180visionx::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
215Vec2d
216visionx::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
225Vec3d
226visionx::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
236Mat3d
237visionx::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
259visionx::types::Vec
260visionx::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
269visionx::types::Vec
270visionx::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
280visionx::types::Mat
281visionx::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
306CStereoCalibration*
307visionx::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
366CCalibration*
367visionx::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
392visionx::StereoCalibration
393visionx::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
441visionx::MonocularCalibration
442visionx::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
463visionx::types::Region
464visionx::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
483MyRegion
484visionx::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
503visionx::types::ObjectColor
504visionx::tools::convert(const ObjectColor& ivtObjectColor)
505{
506 return (visionx::types::ObjectColor)ivtObjectColor;
507}
508
509ObjectColor
510visionx::tools::convert(const visionx::types::ObjectColor& objectColor)
511{
512 return (ObjectColor)objectColor;
513}
514
515visionx::types::ObjectType
516visionx::tools::convert(const ObjectType& ivtObjectType)
517{
518 return (visionx::types::ObjectType)ivtObjectType;
519}
520
521ObjectType
522visionx::tools::convert(const visionx::types::ObjectType& objectType)
523{
524 return (ObjectType)objectType;
525}
526
527visionx::types::Transformation3d
528visionx::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
538Transformation3d
539visionx::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
549Object3DEntry
550visionx::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
575visionx::types::Object3DEntry
576visionx::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
600Object3DList
601visionx::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
619visionx::types::Object3DList
620visionx::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
638Eigen::Matrix3f
639visionx::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
654Eigen::Vector3f
655visionx::tools::convertIVTtoEigen(const Vec3d& v)
656{
657 Eigen::Vector3f result(v.x, v.y, v.z);
658 return result;
659}
660
661visionx::types::Vec
662visionx::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
673Eigen::VectorXf
674visionx::tools::convertVisionXVecToEigen(visionx::types::Vec v)
675{
676 Eigen::VectorXf res;
677 res.resize(v.size());
678 for (std::size_t i = 0; i < v.size(); i++)
679 {
680 res[i] = v[i];
681 }
682 return res;
683}
684
685visionx::types::Mat
686visionx::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
700Eigen::MatrixXf
701visionx::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}
convert
void convert(const std::filesystem::path &in, const std::filesystem::path &out, bool print_progress)
Performs the actual conversion.
Definition main.cpp:170
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::tools::arrayToVector
void arrayToVector(const T *dataArray, const int size, std::vector< T > &vec)
Definition TypeMapping.h:79
visionx::tools::convertIVTtoEigen
Eigen::Matrix3f convertIVTtoEigen(const Mat3d &m)
Definition TypeMapping.cpp:639
visionx::tools::typeNameToImageType
ImageType typeNameToImageType(const std::string &imageTypeName)
Converts an image type name as string into an ImageType integer.
Definition TypeMapping.cpp:42
visionx::tools::convertVisionXMatToEigen
Eigen::MatrixXf convertVisionXMatToEigen(visionx::types::Mat m)
Definition TypeMapping.cpp:701
visionx::tools::convertEigenVecToVisionX
visionx::types::Vec convertEigenVecToVisionX(Eigen::VectorXf v)
Definition TypeMapping.cpp:662
visionx::tools::vectorToArray
T * vectorToArray(const std::vector< T > &dataVector)
Definition TypeMapping.h:62
visionx::tools::imageTypeToTypeName
std::string imageTypeToTypeName(const ImageType imageType)
Converts an image type into a string integer.
Definition TypeMapping.cpp:72
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::convert
CByteImage::ImageType convert(const ImageType visionxImageType)
Converts a VisionX image type into an image type of IVT's ByteImage.
Definition TypeMapping.cpp:97