ice_conversions.cpp
Go to the documentation of this file.
1 #include "ice_conversions.h"
2 
3 #include <ArmarXCore/core/exceptions/local/ExpressionException.h>
4 
5 namespace armarx::core::eigen
6 {
7  // COL MAJOR
8 
9  void
10  fromIce(Eigen::Vector2f& e, const Ice::FloatSeq& ice)
11  {
12  ARMARX_CHECK(ice.size() >= 2);
13  e << ice[0], ice[1];
14  }
15 
16  void
17  toIce(const Eigen::Vector2f& e, Ice::FloatSeq& ice)
18  {
19  ice = std::vector<float>({e(0, 0), e(1, 0)});
20  }
21 
22  void
23  fromIce(Eigen::Vector2d& e, const Ice::DoubleSeq& ice)
24  {
25  ARMARX_CHECK(ice.size() >= 2);
26  e << ice[0], ice[1];
27  }
28 
29  void
30  toIce(const Eigen::Vector2d& e, Ice::DoubleSeq& ice)
31  {
32  ice = std::vector<double>({e(0, 0), e(1, 0)});
33  }
34 
35  void
36  fromIce(Eigen::Vector3f& e, const Ice::FloatSeq& ice)
37  {
38  ARMARX_CHECK(ice.size() >= 3);
39  e << ice[0], ice[1], ice[2];
40  }
41 
42  void
43  toIce(const Eigen::Vector3f& e, Ice::FloatSeq& ice)
44  {
45  ice = std::vector<float>({e(0, 0), e(1, 0), e(2, 0)});
46  }
47 
48  void
49  fromIce(Eigen::Vector3d& e, const Ice::DoubleSeq& ice)
50  {
51  ARMARX_CHECK(ice.size() >= 3);
52  e << ice[0], ice[1], ice[2];
53  }
54 
55  void
56  toIce(const Eigen::Vector3d& e, Ice::DoubleSeq& ice)
57  {
58  ice = std::vector<double>({e(0, 0), e(1, 0), e(2, 0)});
59  }
60 
61  void
62  fromIce(Eigen::Vector4f& e, const Ice::FloatSeq& ice)
63  {
64  ARMARX_CHECK(ice.size() >= 4);
65  e << ice[0], ice[1], ice[2], ice[3];
66  }
67 
68  void
69  toIce(const Eigen::Vector4f& e, Ice::FloatSeq& ice)
70  {
71  ice = std::vector<float>({e(0, 0), e(1, 0), e(2, 0), e(3, 0)});
72  }
73 
74  void
75  fromIce(Eigen::Vector4d& e, const Ice::DoubleSeq& ice)
76  {
77  ARMARX_CHECK(ice.size() >= 4);
78  e << ice[0], ice[1], ice[2], ice[3];
79  }
80 
81  void
82  toIce(const Eigen::Vector4d& e, Ice::DoubleSeq& ice)
83  {
84  ice = std::vector<double>({e(0, 0), e(1, 0), e(2, 0), e(3, 0)});
85  }
86 
87  void
88  fromIce(Eigen::Matrix2f& e, const armarx::FloatSeqSeq& ice)
89  {
90  ARMARX_CHECK(ice.size() >= 2);
91  for (const auto& x : ice)
92  {
93  ARMARX_CHECK(x.size() >= 2);
94  }
95 
96  e << ice[0][0], ice[0][1], ice[1][0], ice[1][1], ice[2][0], ice[2][1];
97  }
98 
99  void
100  toIce(const Eigen::Matrix2f& e, armarx::FloatSeqSeq& ice)
101  {
102  ice = std::vector<std::vector<float>>(
103  {{e(0, 0), e(0, 1)}, {e(1, 0), e(1, 1)}, {e(2, 0), e(2, 1)}});
104  }
105 
106  void
107  fromIce(Eigen::Matrix2d& e, const armarx::DoubleSeqSeq& ice)
108  {
109  ARMARX_CHECK(ice.size() >= 2);
110  for (const auto& x : ice)
111  {
112  ARMARX_CHECK(x.size() >= 2);
113  }
114 
115  e << ice[0][0], ice[0][1], ice[1][0], ice[1][1], ice[2][0], ice[2][1];
116  }
117 
118  void
119  toIce(const Eigen::Matrix2d& e, armarx::DoubleSeqSeq& ice)
120  {
121  ice = std::vector<std::vector<double>>(
122  {{e(0, 0), e(0, 1)}, {e(1, 0), e(1, 1)}, {e(2, 0), e(2, 1)}});
123  }
124 
125  void
126  fromIce(Eigen::Matrix3f& e, const armarx::FloatSeqSeq& ice)
127  {
128  ARMARX_CHECK(ice.size() >= 3);
129  for (const auto& x : ice)
130  {
131  ARMARX_CHECK(x.size() >= 3);
132  }
133 
134  e << ice[0][0], ice[0][1], ice[0][2], ice[1][0], ice[1][1], ice[1][2], ice[2][0], ice[2][1],
135  ice[2][2];
136  }
137 
138  void
139  toIce(const Eigen::Matrix3f& e, armarx::FloatSeqSeq& ice)
140  {
141  ice = std::vector<std::vector<float>>({{e(0, 0), e(0, 1), e(0, 2)},
142  {e(1, 0), e(1, 1), e(1, 2)},
143  {e(2, 0), e(2, 1), e(2, 2)}});
144  }
145 
146  void
147  fromIce(Eigen::Matrix3d& e, const armarx::DoubleSeqSeq& ice)
148  {
149  ARMARX_CHECK(ice.size() >= 3);
150  for (const auto& x : ice)
151  {
152  ARMARX_CHECK(x.size() >= 3);
153  }
154 
155  e << ice[0][0], ice[0][1], ice[0][2], ice[1][0], ice[1][1], ice[1][2], ice[2][0], ice[2][1],
156  ice[2][2];
157  }
158 
159  void
160  toIce(const Eigen::Matrix3d& e, armarx::DoubleSeqSeq& ice)
161  {
162  ice = std::vector<std::vector<double>>({{e(0, 0), e(0, 1), e(0, 2)},
163  {e(1, 0), e(1, 1), e(1, 2)},
164  {e(2, 0), e(2, 1), e(2, 2)}});
165  }
166 
167  void
168  fromIce(Eigen::Matrix4f& e, const armarx::FloatSeqSeq& ice)
169  {
170  ARMARX_CHECK(ice.size() >= 4);
171  for (const auto& x : ice)
172  {
173  ARMARX_CHECK(x.size() >= 4);
174  }
175  e << ice[0][0], ice[0][1], ice[0][2], ice[0][3], ice[1][0], ice[1][1], ice[1][2], ice[1][3],
176  ice[2][0], ice[2][1], ice[2][2], ice[2][3], ice[3][0], ice[3][1], ice[3][2], ice[3][3];
177  }
178 
179  void
180  toIce(const Eigen::Matrix4f& e, armarx::FloatSeqSeq& ice)
181  {
182  ice = std::vector<std::vector<float>>({{e(0, 0), e(0, 1), e(0, 2), e(0, 3)},
183  {e(1, 0), e(1, 1), e(1, 2), e(1, 3)},
184  {e(2, 0), e(2, 1), e(2, 2), e(2, 3)},
185  {e(3, 0), e(3, 1), e(3, 2), e(3, 3)}});
186  }
187 
188  void
189  fromIce(Eigen::Matrix4d& e, const armarx::DoubleSeqSeq& ice)
190  {
191  ARMARX_CHECK(ice.size() >= 4);
192  for (const auto& x : ice)
193  {
194  ARMARX_CHECK(x.size() >= 4);
195  }
196  e << ice[0][0], ice[0][1], ice[0][2], ice[0][3], ice[1][0], ice[1][1], ice[1][2], ice[1][3],
197  ice[2][0], ice[2][1], ice[2][2], ice[2][3], ice[3][0], ice[3][1], ice[3][2], ice[3][3];
198  }
199 
200  void
201  toIce(const Eigen::Matrix4d& e, armarx::DoubleSeqSeq& ice)
202  {
203  ice = std::vector<std::vector<double>>({{e(0, 0), e(0, 1), e(0, 2), e(0, 3)},
204  {e(1, 0), e(1, 1), e(1, 2), e(1, 3)},
205  {e(2, 0), e(2, 1), e(2, 2), e(2, 3)},
206  {e(3, 0), e(3, 1), e(3, 2), e(3, 3)}});
207  }
208 
209  // ROW MAJOR
210 
211  void
212  fromIce(Eigen::Matrix<float, 2, 2, Eigen::RowMajor>& e, const armarx::FloatSeqSeq& ice)
213  {
214  ARMARX_CHECK(ice.size() >= 2);
215  for (const auto& x : ice)
216  {
217  ARMARX_CHECK(x.size() >= 2);
218  }
219 
220  e << ice[0][0], ice[0][1], ice[1][0], ice[1][1], ice[2][0], ice[2][1];
221  }
222 
223  void
224  toIce(const Eigen::Matrix<float, 2, 2, Eigen::RowMajor>& e, armarx::FloatSeqSeq& ice)
225  {
226  ice = std::vector<std::vector<float>>(
227  {{e(0, 0), e(0, 1)}, {e(1, 0), e(1, 1)}, {e(2, 0), e(2, 1)}});
228  }
229 
230  void
231  fromIce(Eigen::Matrix<double, 2, 2, Eigen::RowMajor>& e, const armarx::DoubleSeqSeq& ice)
232  {
233  ARMARX_CHECK(ice.size() >= 2);
234  for (const auto& x : ice)
235  {
236  ARMARX_CHECK(x.size() >= 2);
237  }
238 
239  e << ice[0][0], ice[0][1], ice[1][0], ice[1][1], ice[2][0], ice[2][1];
240  }
241 
242  void
243  toIce(const Eigen::Matrix<double, 2, 2, Eigen::RowMajor>& e, armarx::DoubleSeqSeq& ice)
244  {
245  ice = std::vector<std::vector<double>>(
246  {{e(0, 0), e(0, 1)}, {e(1, 0), e(1, 1)}, {e(2, 0), e(2, 1)}});
247  }
248 
249  void
250  fromIce(Eigen::Matrix<float, 3, 3, Eigen::RowMajor>& e, const armarx::FloatSeqSeq& ice)
251  {
252  ARMARX_CHECK(ice.size() >= 3);
253  for (const auto& x : ice)
254  {
255  ARMARX_CHECK(x.size() >= 3);
256  }
257 
258  e << ice[0][0], ice[0][1], ice[0][2], ice[1][0], ice[1][1], ice[1][2], ice[2][0], ice[2][1],
259  ice[2][2];
260  }
261 
262  void
263  toIce(const Eigen::Matrix<float, 3, 3, Eigen::RowMajor>& e, armarx::FloatSeqSeq& ice)
264  {
265  ice = std::vector<std::vector<float>>({{e(0, 0), e(0, 1), e(0, 2)},
266  {e(1, 0), e(1, 1), e(1, 2)},
267  {e(2, 0), e(2, 1), e(2, 2)}});
268  }
269 
270  void
271  fromIce(Eigen::Matrix<double, 3, 3, Eigen::RowMajor>& e, const armarx::DoubleSeqSeq& ice)
272  {
273  ARMARX_CHECK(ice.size() >= 3);
274  for (const auto& x : ice)
275  {
276  ARMARX_CHECK(x.size() >= 3);
277  }
278 
279  e << ice[0][0], ice[0][1], ice[0][2], ice[1][0], ice[1][1], ice[1][2], ice[2][0], ice[2][1],
280  ice[2][2];
281  }
282 
283  void
284  toIce(const Eigen::Matrix<double, 3, 3, Eigen::RowMajor>& e, armarx::DoubleSeqSeq& ice)
285  {
286  ice = std::vector<std::vector<double>>({{e(0, 0), e(0, 1), e(0, 2)},
287  {e(1, 0), e(1, 1), e(1, 2)},
288  {e(2, 0), e(2, 1), e(2, 2)}});
289  }
290 
291  void
292  fromIce(Eigen::Matrix<float, 4, 4, Eigen::RowMajor>& e, const armarx::FloatSeqSeq& ice)
293  {
294  ARMARX_CHECK(ice.size() >= 4);
295  for (const auto& x : ice)
296  {
297  ARMARX_CHECK(x.size() >= 4);
298  }
299  e << ice[0][0], ice[0][1], ice[0][2], ice[0][3], ice[1][0], ice[1][1], ice[1][2], ice[1][3],
300  ice[2][0], ice[2][1], ice[2][2], ice[2][3], ice[3][0], ice[3][1], ice[3][2], ice[3][3];
301  }
302 
303  void
304  toIce(const Eigen::Matrix<float, 4, 4, Eigen::RowMajor>& e, armarx::FloatSeqSeq& ice)
305  {
306  ice = std::vector<std::vector<float>>({{e(0, 0), e(0, 1), e(0, 2), e(0, 3)},
307  {e(1, 0), e(1, 1), e(1, 2), e(1, 3)},
308  {e(2, 0), e(2, 1), e(2, 2), e(2, 3)},
309  {e(3, 0), e(3, 1), e(3, 2), e(3, 3)}});
310  }
311 
312  void
313  fromIce(Eigen::Matrix<double, 4, 4, Eigen::RowMajor>& e, const armarx::DoubleSeqSeq& ice)
314  {
315  ARMARX_CHECK(ice.size() >= 4);
316  for (const auto& x : ice)
317  {
318  ARMARX_CHECK(x.size() >= 4);
319  }
320  e << ice[0][0], ice[0][1], ice[0][2], ice[0][3], ice[1][0], ice[1][1], ice[1][2], ice[1][3],
321  ice[2][0], ice[2][1], ice[2][2], ice[2][3], ice[3][0], ice[3][1], ice[3][2], ice[3][3];
322  }
323 
324  void
325  toIce(const Eigen::Matrix<double, 4, 4, Eigen::RowMajor>& e, armarx::DoubleSeqSeq& ice)
326  {
327  ice = std::vector<std::vector<double>>({{e(0, 0), e(0, 1), e(0, 2), e(0, 3)},
328  {e(1, 0), e(1, 1), e(1, 2), e(1, 3)},
329  {e(2, 0), e(2, 1), e(2, 2), e(2, 3)},
330  {e(3, 0), e(3, 1), e(3, 2), e(3, 3)}});
331  }
332 
333 
334 } // namespace armarx::core::eigen
armarx::core::eigen
Definition: conversions.cpp:3
ice_conversions.h
ARMARX_CHECK
#define ARMARX_CHECK(expression)
Shortcut for ARMARX_CHECK_EXPRESSION.
Definition: ExpressionException.h:82
GfxTL::Matrix2f
MatrixXX< 2, 2, float > Matrix2f
Definition: MatrixXX.h:599
armarx::core::eigen::fromIce
void fromIce(Eigen::Vector2f &e, const Ice::FloatSeq &ice)
Definition: ice_conversions.cpp:10
armarx::core::eigen::toIce
void toIce(const Eigen::Vector2f &e, Ice::FloatSeq &ice)
Definition: ice_conversions.cpp:17
ExpressionException.h
GfxTL::Matrix3f
MatrixXX< 3, 3, float > Matrix3f
Definition: MatrixXX.h:600
GfxTL::Matrix4f
MatrixXX< 4, 4, float > Matrix4f
Definition: MatrixXX.h:601
Eigen::Matrix
Definition: EigenForwardDeclarations.h:27