matio-cpp v0.3.0
A C++ wrapper of the matio library, with memory ownership handling, to read and write .mat files.
Loading...
Searching...
No Matches
ConversionUtilities.cpp
Go to the documentation of this file.
1/*
2 * Copyright (C) 2020 Fondazione Istituto Italiano di Tecnologia
3 *
4 * This software may be modified and distributed under the terms of the
5 * BSD-2-Clause license (https://opensource.org/licenses/BSD-2-Clause).
6 */
7
8#include <matioCpp/ConversionUtilities.h>
9
10bool matioCpp::get_matio_types(const matioCpp::VariableType &inputVariableType, const matioCpp::ValueType &inputValueType, matio_classes &outputMatioClasses, matio_types &outputMatioType)
11{
12 if (inputVariableType == VariableType::Element ||
13 inputVariableType == VariableType::Vector ||
14 inputVariableType == VariableType::MultiDimensionalArray)
15 {
16 switch (inputValueType)
17 {
18 case matioCpp::ValueType::INT8:
19 outputMatioClasses = matio_classes::MAT_C_INT8;
20 outputMatioType = matio_types::MAT_T_INT8;
21 break;
22 case matioCpp::ValueType::UINT8:
23 case matioCpp::ValueType::LOGICAL:
24 outputMatioClasses = matio_classes::MAT_C_UINT8;
25 outputMatioType = matio_types::MAT_T_UINT8;
26 break;
27 case matioCpp::ValueType::INT16:
28 outputMatioClasses = matio_classes::MAT_C_INT16;
29 outputMatioType = matio_types::MAT_T_INT16;
30 break;
31 case matioCpp::ValueType::UINT16:
32 outputMatioClasses = matio_classes::MAT_C_UINT16;
33 outputMatioType = matio_types::MAT_T_UINT16;
34 break;
35 case matioCpp::ValueType::INT32:
36 outputMatioClasses = matio_classes::MAT_C_INT32;
37 outputMatioType = matio_types::MAT_T_INT32;
38 break;
39 case matioCpp::ValueType::UINT32:
40 outputMatioClasses = matio_classes::MAT_C_UINT32;
41 outputMatioType = matio_types::MAT_T_UINT32;
42 break;
43 case matioCpp::ValueType::SINGLE:
44 outputMatioClasses = matio_classes::MAT_C_SINGLE;
45 outputMatioType = matio_types::MAT_T_SINGLE;
46 break;
47 case matioCpp::ValueType::DOUBLE:
48 outputMatioClasses = matio_classes::MAT_C_DOUBLE;
49 outputMatioType = matio_types::MAT_T_DOUBLE;
50 break;
51 case matioCpp::ValueType::INT64:
52 outputMatioClasses = matio_classes::MAT_C_INT64;
53 outputMatioType = matio_types::MAT_T_INT64;
54 break;
55 case matioCpp::ValueType::UINT64:
56 outputMatioClasses = matio_classes::MAT_C_UINT64;
57 outputMatioType = matio_types::MAT_T_UINT64;
58 break;
59 case matioCpp::ValueType::UTF8:
60 outputMatioClasses = matio_classes::MAT_C_CHAR;
61 outputMatioType = matio_types::MAT_T_UTF8;
62 break;
63 case matioCpp::ValueType::UTF16:
64 outputMatioClasses = matio_classes::MAT_C_CHAR;
65 outputMatioType = matio_types::MAT_T_UTF16;
66 break;
67 case matioCpp::ValueType::UTF32:
68 outputMatioClasses = matio_classes::MAT_C_CHAR;
69 outputMatioType = matio_types::MAT_T_UTF32;
70 break;
71 case matioCpp::ValueType::STRING:
72 outputMatioClasses = matio_classes::MAT_C_CHAR;
73 outputMatioType = matio_types::MAT_T_STRING;
74 break;
75 default:
76 return false;
77 }
78 }
79 else if (inputVariableType == VariableType::Struct || inputVariableType == VariableType::StructArray)
80 {
81 outputMatioClasses = matio_classes::MAT_C_STRUCT;
82 outputMatioType = matio_types::MAT_T_STRUCT;
83 }
84 else if (inputVariableType == VariableType::CellArray)
85 {
86 outputMatioClasses = matio_classes::MAT_C_CELL;
87 outputMatioType = MAT_T_CELL;
88 }
89 else
90 {
91 return false;
92 }
93
94 return true;
95}
96
97bool matioCpp::get_types_from_matvart(const matvar_t *input, matioCpp::VariableType &outputVariableType, matioCpp::ValueType &outputValueType)
98{
99 if (!input)
100 {
101 return false;
102 }
103
104 switch (input->data_type)
105 {
106 case matio_types::MAT_T_INT8:
107 outputValueType = matioCpp::ValueType::INT8;
108 break;
109 case matio_types::MAT_T_UINT8:
110 outputValueType = matioCpp::ValueType::UINT8;
111 break;
112 case matio_types::MAT_T_INT16:
113 outputValueType = matioCpp::ValueType::INT16;
114 break;
115 case matio_types::MAT_T_UINT16:
116 outputValueType = matioCpp::ValueType::UINT16;
117 break;
118 case matio_types::MAT_T_INT32:
119 outputValueType = matioCpp::ValueType::INT32;
120 break;
121 case matio_types::MAT_T_UINT32:
122 outputValueType = matioCpp::ValueType::UINT32;
123 break;
124 case matio_types::MAT_T_SINGLE:
125 outputValueType = matioCpp::ValueType::SINGLE;
126 break;
127 case matio_types::MAT_T_DOUBLE:
128 outputValueType = matioCpp::ValueType::DOUBLE;
129 break;
130 case matio_types::MAT_T_INT64:
131 outputValueType = matioCpp::ValueType::INT64;
132 break;
133 case matio_types::MAT_T_UINT64:
134 outputValueType = matioCpp::ValueType::UINT64;
135 break;
136 case matio_types::MAT_T_UTF8:
137 outputValueType = matioCpp::ValueType::UTF8;
138 break;
139 case matio_types::MAT_T_UTF16:
140 outputValueType = matioCpp::ValueType::UTF16;
141 break;
142 case matio_types::MAT_T_UTF32:
143 outputValueType = matioCpp::ValueType::UTF32;
144 break;
145 case matio_types::MAT_T_STRING:
146 outputValueType = matioCpp::ValueType::STRING;
147 break;
148 case matio_types::MAT_T_CELL:
149 case matio_types::MAT_T_STRUCT:
150 case matio_types::MAT_T_ARRAY:
151 case matio_types::MAT_T_MATRIX:
152 outputValueType = matioCpp::ValueType::VARIABLE;
153 break;
154 case matio_types::MAT_T_COMPRESSED:
155 case matio_types::MAT_T_FUNCTION:
156 case matio_types::MAT_T_UNKNOWN:
157 outputValueType = matioCpp::ValueType::UNSUPPORTED;
158 break;
159 }
160
161 if (input->isLogical)
162 {
163 if (outputValueType == matioCpp::ValueType::UINT8)
164 {
165 outputValueType = matioCpp::ValueType::LOGICAL;
166 }
167 }
168
169 if ((input->class_type == matio_classes::MAT_C_OBJECT) ||
170 (input->class_type == matio_classes::MAT_C_SPARSE) ||
171 (input->class_type == matio_classes::MAT_C_FUNCTION) ||
172 (input->class_type == matio_classes::MAT_C_OPAQUE) ||
173 (outputValueType == matioCpp::ValueType::UNSUPPORTED) ||
174 (input->rank < 2)) //Matio requires the rank to be at least 2
175 {
176 outputVariableType = matioCpp::VariableType::Unsupported;
177 return true;
178 }
179
180 size_t dimensionsProduct = 1;
181 for (int i = 0; i < input->rank; ++i)
182 {
183 dimensionsProduct *= input->dims[i];
184 }
185
186 if (input->class_type == matio_classes::MAT_C_CELL || input->data_type == matio_types::MAT_T_CELL)
187 {
188 outputVariableType = matioCpp::VariableType::CellArray;
189 }
190 else if (dimensionsProduct == 1)
191 {
192 if (input->data_type == matio_types::MAT_T_STRUCT)
193 {
194 outputVariableType = matioCpp::VariableType::Struct;
195 }
196 else if ((input->data_type == MAT_T_ARRAY) || (input->data_type == MAT_T_MATRIX)) //This would be a weird case where the variable has dimension 1x1, it is not a cell nor a struct, yet it contains an array
197 {
198 outputVariableType = matioCpp::VariableType::Unsupported;
199 }
200 else
201 {
202 outputVariableType = matioCpp::VariableType::Element;
203 }
204 }
205 else
206 {
207 if (input->data_type == matio_types::MAT_T_STRUCT)
208 {
209 outputVariableType = matioCpp::VariableType::StructArray;
210 }
211 else if ((input->data_type == MAT_T_ARRAY) || (input->data_type == MAT_T_MATRIX))
212 {
213 outputVariableType = matioCpp::VariableType::Unsupported;
214 }
215 else if ((input->rank == 2) && ((input->dims[0] == 1) || (input->dims[1] == 1)))
216 {
217 outputVariableType = matioCpp::VariableType::Vector;
218 }
219 else
220 {
221 outputVariableType = matioCpp::VariableType::MultiDimensionalArray;
222 }
223 }
224
225 return true;
226}
227
228bool matioCpp::get_types_names_from_matvart(const matvar_t *input, std::string &classType, std::string &dataType)
229{
230 if (!input)
231 {
232 return false;
233 }
234
235 switch (input->data_type)
236 {
237 case matio_types::MAT_T_INT8:
238 dataType = "INT8";
239 break;
240 case matio_types::MAT_T_UINT8:
241 dataType = "UINT8";
242 break;
243 case matio_types::MAT_T_INT16:
244 dataType = "INT16";
245 break;
246 case matio_types::MAT_T_UINT16:
247 dataType = "UINT16";
248 break;
249 case matio_types::MAT_T_INT32:
250 dataType = "INT32";
251 break;
252 case matio_types::MAT_T_UINT32:
253 dataType = "UINT32";
254 break;
255 case matio_types::MAT_T_SINGLE:
256 dataType = "SINGLE";
257 break;
258 case matio_types::MAT_T_DOUBLE:
259 dataType = "DOUBLE";
260 break;
261 case matio_types::MAT_T_INT64:
262 dataType = "INT64";
263 break;
264 case matio_types::MAT_T_UINT64:
265 dataType = "UINT64";
266 break;
267 case matio_types::MAT_T_UTF8:
268 dataType = "UTF8";
269 break;
270 case matio_types::MAT_T_UTF16:
271 dataType = "UTF16";
272 break;
273 case matio_types::MAT_T_UTF32:
274 dataType = "UTF32";
275 break;
276 case matio_types::MAT_T_STRING:
277 dataType = "STRING";
278 break;
279 case matio_types::MAT_T_CELL:
280 dataType = "CELL";
281 break;
282 case matio_types::MAT_T_STRUCT:
283 dataType = "STRUCT";
284 break;
285 case matio_types::MAT_T_ARRAY:
286 dataType = "ARRAY";
287 break;
288 case matio_types::MAT_T_MATRIX:
289 dataType = "MATRIX";
290 break;
291 case matio_types::MAT_T_COMPRESSED:
292 dataType = "COMPRESSED";
293 break;
294 case matio_types::MAT_T_FUNCTION:
295 dataType = "FUNCTION";
296 break;
297 case matio_types::MAT_T_UNKNOWN:
298 dataType = "UNKNOWN";
299 break;
300 }
301
302 if (input->isLogical)
303 {
304 dataType = dataType + " (Logical)";
305 }
306
307 switch (input->class_type)
308 {
309 case MAT_C_EMPTY:
310 classType = "EMPTY";
311 break;
312 case MAT_C_CELL:
313 classType = "CELL";
314 break;
315 case MAT_C_STRUCT:
316 classType = "STRUCT";
317 break;
318 case MAT_C_OBJECT:
319 classType = "OBJECT";
320 break;
321 case MAT_C_CHAR:
322 classType = "CHAR";
323 break;
324 case MAT_C_SPARSE:
325 classType = "SPARSE";
326 break;
327 case MAT_C_DOUBLE:
328 classType = "DOUBLE";
329 break;
330 case MAT_C_SINGLE:
331 classType = "SINGLE";
332 break;
333 case MAT_C_INT8:
334 classType = "INT8";
335 break;
336 case MAT_C_UINT8:
337 classType = "UINT8";
338 break;
339 case MAT_C_INT16:
340 classType = "INT16";
341 break;
342 case MAT_C_UINT16:
343 classType = "UINT16";
344 break;
345 case MAT_C_INT32:
346 classType = "INT32";
347 break;
348 case MAT_C_UINT32:
349 classType = "UINT32";
350 break;
351 case MAT_C_INT64:
352 classType = "INT64";
353 break;
354 case MAT_C_UINT64:
355 classType = "UINT64";
356 break;
357 case MAT_C_FUNCTION:
358 classType = "FUNCTION";
359 break;
360 case MAT_C_OPAQUE:
361 classType = "OPAQUE";
362 break;
363 }
364
365 return true;
366}
matioCpp::MultiDimensionalArray
MultiDimensionalArray is a particular type of Variable specialized for multidimensional arrays of a g...
Definition MultiDimensionalArray.h:22
matioCpp::get_matio_types
bool get_matio_types(const VariableType &inputVariableType, const ValueType &inputValueType, matio_classes &outputMatioClasses, matio_types &outputMatioType)
Get both the matio type and class from the input VariableType and ValueType.
Definition ConversionUtilities.cpp:10
matioCpp::VariableType
VariableType
Define the type of variable.
Definition ForwardDeclarations.h:89
matioCpp::get_types_from_matvart
bool get_types_from_matvart(const matvar_t *input, VariableType &outputVariableType, ValueType &outputValueType)
Get the VariableType and the ValueType from a matvar_t pointer.
Definition ConversionUtilities.cpp:97
matioCpp::ValueType
ValueType
The list of types for an element of a certain variable type.
Definition ForwardDeclarations.h:103
matioCpp::get_types_names_from_matvart
bool get_types_names_from_matvart(const matvar_t *input, std::string &classType, std::string &dataType)
Get the type names from the input pointer.
Definition ConversionUtilities.cpp:228