iRoCS Toolbox  1.1.0
BlitzH5Traits.hh
Go to the documentation of this file.
1 /**************************************************************************
2  *
3  * Copyright (C) 2015 Thorsten Falk
4  *
5  * Image Analysis Lab, University of Freiburg, Germany
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software Foundation,
19  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  *
21  **************************************************************************/
22 
23 #ifndef BLITZH5TRAITS_HH
24 #define BLITZH5TRAITS_HH
25 
26 #ifdef HAVE_CONFIG_H
27 #include <config.hh>
28 #endif
29 
30 #include <hdf5.h>
31 #include <blitz/array.h>
32 
33 #include <vector>
34 
35 // Bail out at compile time if no specialization is available
36 template<typename InnerT> struct BlitzH5Traits;
37 
38 template<>
39 struct BlitzH5Traits<unsigned char>
40 {
41  typedef unsigned char DataT;
42  typedef unsigned char BasicT;
43  static std::vector<hsize_t> h5Dims(DataT const &);
44  static hid_t h5Type();
45  static void *data(DataT &array);
46  static void const *data(DataT const &array);
47 };
48 
49 template<>
50 struct BlitzH5Traits<signed char>
51 {
52  typedef signed char DataT;
53  typedef signed char BasicT;
54  static std::vector<hsize_t> h5Dims(DataT const &);
55  static hid_t h5Type();
56  static void *data(DataT &array);
57  static void const *data(DataT const &array);
58 };
59 
60 template<>
61 struct BlitzH5Traits<char>
62 {
63  typedef char DataT;
64  typedef char BasicT;
65  static std::vector<hsize_t> h5Dims(DataT const &);
66  static hid_t h5Type();
67  static void *data(DataT &array);
68  static void const *data(DataT const &array);
69 };
70 
71 template<>
72 struct BlitzH5Traits<unsigned short>
73 {
74  typedef unsigned short DataT;
75  typedef unsigned short BasicT;
76  static std::vector<hsize_t> h5Dims(DataT const &);
77  static hid_t h5Type();
78  static void *data(DataT &array);
79  static void const *data(DataT const &array);
80 };
81 
82 template<>
83 struct BlitzH5Traits<short>
84 {
85  typedef short DataT;
86  typedef short BasicT;
87  static std::vector<hsize_t> h5Dims(DataT const &);
88  static hid_t h5Type();
89  static void *data(DataT &array);
90  static void const *data(DataT const &array);
91 };
92 
93 template<>
94 struct BlitzH5Traits<unsigned int>
95 {
96  typedef unsigned int DataT;
97  typedef unsigned int BasicT;
98  static std::vector<hsize_t> h5Dims(DataT const &);
99  static hid_t h5Type();
100  static void *data(DataT &array);
101  static void const *data(DataT const &array);
102 };
103 
104 template<>
105 struct BlitzH5Traits<int>
106 {
107  typedef int DataT;
108  typedef int BasicT;
109  static std::vector<hsize_t> h5Dims(DataT const &);
110  static hid_t h5Type();
111  static void *data(DataT &array);
112  static void const *data(DataT const &array);
113 };
114 
115 template<>
116 struct BlitzH5Traits<unsigned long>
117 {
118  typedef unsigned long DataT;
119  typedef unsigned long BasicT;
120  static std::vector<hsize_t> h5Dims(DataT const &);
121  static hid_t h5Type();
122  static void *data(DataT &array);
123  static void const *data(DataT const &array);
124 };
125 
126 template<>
127 struct BlitzH5Traits<long>
128 {
129  typedef long DataT;
130  typedef long BasicT;
131  static std::vector<hsize_t> h5Dims(DataT const &);
132  static hid_t h5Type();
133  static void *data(DataT &array);
134  static void const *data(DataT const &array);
135 };
136 
137 template<>
138 struct BlitzH5Traits<unsigned long long>
139 {
140  typedef unsigned long long DataT;
141  typedef unsigned long long BasicT;
142  static std::vector<hsize_t> h5Dims(DataT const &);
143  static hid_t h5Type();
144  static void *data(DataT &array);
145  static void const *data(DataT const &array);
146 };
147 
148 template<>
149 struct BlitzH5Traits<long long>
150 {
151  typedef long long DataT;
152  typedef long long BasicT;
153  static std::vector<hsize_t> h5Dims(DataT const &);
154  static hid_t h5Type();
155  static void *data(DataT &array);
156  static void const *data(DataT const &array);
157 };
158 
159 template<>
160 struct BlitzH5Traits<float>
161 {
162  typedef float DataT;
163  typedef float BasicT;
164  static std::vector<hsize_t> h5Dims(DataT const &);
165  static hid_t h5Type();
166  static void *data(DataT &array);
167  static void const *data(DataT const &array);
168 };
169 
170 template<>
171 struct BlitzH5Traits<double>
172 {
173  typedef double DataT;
174  typedef double BasicT;
175  static std::vector<hsize_t> h5Dims(DataT const &);
176  static hid_t h5Type();
177  static void *data(DataT &array);
178  static void const *data(DataT const &array);
179 };
180 
181 template<>
182 struct BlitzH5Traits<long double>
183 {
184  typedef long double DataT;
185  typedef long double BasicT;
186  static std::vector<hsize_t> h5Dims(DataT const &);
187  static hid_t h5Type();
188  static void *data(DataT &array);
189  static void const *data(DataT const &array);
190 };
191 
192 template<typename InnerT>
193 struct BlitzH5Traits< std::vector<InnerT> >
194 {
195 
196  typedef std::vector<InnerT> DataT;
197  typedef InnerT BasicT;
198 
199  static std::vector<hsize_t> h5Dims(DataT const &array)
200  {
201  std::vector<hsize_t> dims(1);
202  dims[0] = array.size();
203  return dims;
204  }
205 
206  static hid_t h5Type()
207  {
209  }
210 
211  static void *data(DataT &array)
212  {
213  return reinterpret_cast<void*>(&array[0]);
214  }
215 
216  static void const *data(DataT const &array)
217  {
218  return reinterpret_cast<void const*>(&array[0]);
219  }
220 
221 };
222 
223 template<typename InnerT, int Dim>
224 struct BlitzH5Traits< blitz::TinyVector<InnerT,Dim> >
225 {
226 
227  typedef blitz::TinyVector<InnerT,Dim> DataT;
228  typedef InnerT BasicT;
229 
230  static std::vector<hsize_t> h5Dims(DataT const &)
231  {
232  std::vector<hsize_t> dims(1);
233  dims[0] = Dim;
234  return dims;
235  }
236 
237  static hid_t h5Type()
238  {
240  }
241 
242  static void *data(DataT &array)
243  {
244  return reinterpret_cast<void*>(array.data());
245  }
246 
247  static void const *data(DataT const &array)
248  {
249  return reinterpret_cast<void const*>(array.data());
250  }
251 
252 };
253 
254 template<typename InnerT, int NRows, int NCols>
255 struct BlitzH5Traits< blitz::TinyMatrix<InnerT,NRows,NCols> >
256 {
257 
258  typedef blitz::TinyMatrix<InnerT,NRows,NCols> DataT;
259  typedef InnerT BasicT;
260 
261  static std::vector<hsize_t> h5Dims(DataT const &)
262  {
263  std::vector<hsize_t> dims(2);
264  dims[0] = NRows;
265  dims[1] = NCols;
266  return dims;
267  }
268 
269  static hid_t h5Type()
270  {
272  }
273 
274  static void *data(DataT &array)
275  {
276  return reinterpret_cast<void*>(array.data());
277  }
278 
279  static void const *data(DataT const &array)
280  {
281  return reinterpret_cast<void const*>(array.data());
282  }
283 
284 };
285 
286 template<typename InnerT>
287 struct BlitzH5Traits< std::complex<InnerT> >
288 {
289 
290  typedef std::complex<InnerT> DataT;
291  typedef InnerT BasicT;
292 
293  static std::vector<hsize_t> h5Dims(DataT const &)
294  {
295  std::vector<hsize_t> dims(1);
296  dims[0] = 2;
297  return dims;
298  }
299 
300  static hid_t h5Type()
301  {
303  }
304 
305  static void *data(DataT &array)
306  {
307  return reinterpret_cast<void*>(array.data());
308  }
309 
310  static void const *data(DataT const &array)
311  {
312  return reinterpret_cast<void const*>(array.data());
313  }
314 
315 };
316 
317 template<typename InnerT, int Dim>
318 struct BlitzH5Traits< blitz::Array<InnerT,Dim> >
319 {
320 
321  typedef blitz::Array<InnerT,Dim> DataT;
322  typedef InnerT BasicT;
323 
324  static std::vector<hsize_t> h5Dims(DataT const &array)
325  {
326  std::vector<hsize_t> dims(Dim);
327  for (int d = 0; d < Dim; ++d) dims[d] = array.extent(d);
328  return dims;
329  }
330 
331  static hid_t h5Type()
332  {
334  }
335 
336  static void *data(DataT &array)
337  {
338  return reinterpret_cast<void*>(array.data());
339  }
340 
341  static void const *data(DataT const &array)
342  {
343  return reinterpret_cast<void const*>(array.data());
344  }
345 
346 };
347 
348 template<typename InnerT, int Dim>
350  blitz::Array<std::complex<InnerT>,Dim> >
351 {
352 
353  typedef blitz::Array<std::complex<InnerT>,Dim> DataT;
354  typedef InnerT BasicT;
355 
356  static std::vector<hsize_t> h5Dims(DataT const &array)
357  {
358  std::vector<hsize_t> dims(Dim + 1);
359  for (int d = 0; d < Dim; ++d) dims[d] = array.extent(d);
360  dims[Dim] = 2;
361  return dims;
362  }
363 
364  static hid_t h5Type()
365  {
367  }
368 
369  static void *data(DataT &array)
370  {
371  return reinterpret_cast<void*>(array.data());
372  }
373 
374  static void const *data(DataT const &array)
375  {
376  return reinterpret_cast<void const*>(array.data());
377  }
378 };
379 
380 template<typename InnerT, int InnerDim, int OuterDim>
382  blitz::Array<blitz::TinyVector<InnerT,InnerDim>,OuterDim> >
383 {
384 
385  typedef blitz::Array<blitz::TinyVector<InnerT,InnerDim>,OuterDim> DataT;
386  typedef InnerT BasicT;
387 
388  static std::vector<hsize_t> h5Dims(DataT const &array)
389  {
390  std::vector<hsize_t> dims(OuterDim + 1);
391  for (int d = 0; d < OuterDim; ++d) dims[d] = array.extent(d);
392  dims[OuterDim] = InnerDim;
393  return dims;
394  }
395 
396  static hid_t h5Type()
397  {
399  }
400 
401  static void *data(DataT &array)
402  {
403  return reinterpret_cast<void*>(array.data());
404  }
405 
406  static void const *data(DataT const &array)
407  {
408  return reinterpret_cast<void const*>(array.data());
409  }
410 };
411 
412 template<typename InnerT, int InnerDim1, int InnerDim2, int OuterDim>
414  blitz::Array<blitz::TinyMatrix<InnerT,InnerDim1,InnerDim2>,OuterDim> >
415 {
416 
417  typedef blitz::Array<blitz::TinyMatrix<InnerT,InnerDim1,InnerDim2>,OuterDim>
419  typedef InnerT BasicT;
420 
421  static std::vector<hsize_t> h5Dims(DataT const &array)
422  {
423  std::vector<hsize_t> dims(OuterDim + 1);
424  for (int d = 0; d < OuterDim; ++d) dims[d] = array.extent(d);
425  dims[OuterDim] = InnerDim1 * InnerDim2;
426  return dims;
427  }
428 
429  static hid_t h5Type()
430  {
432  }
433 
434  static void *data(DataT &array)
435  {
436  return reinterpret_cast<void*>(array.data());
437  }
438 
439  static void const *data(DataT const &array)
440  {
441  return reinterpret_cast<void const*>(array.data());
442  }
443 };
444 
445 template<>
446 struct BlitzH5Traits<std::string>
447 {
448 
449  typedef std::string DataT;
450  typedef std::string BasicT;
451 
452  static std::vector<hsize_t> h5Dims(DataT const &array);
453  static hid_t h5Type();
454  static void *data(DataT &array);
455  static void const *data(DataT const &array);
456 
457 };
458 
459 #endif
static std::vector< hsize_t > h5Dims(DataT const &)
static void * data(DataT &array)
static std::vector< hsize_t > h5Dims(DataT const &array)
STL namespace.
static std::vector< hsize_t > h5Dims(DataT const &array)
static std::vector< hsize_t > h5Dims(DataT const &)
static void const * data(DataT const &array)
blitz::Array< blitz::TinyVector< InnerT, InnerDim >, OuterDim > DataT
static void const * data(DataT const &array)
static std::vector< hsize_t > h5Dims(DataT const &array)
static void const * data(DataT const &array)
blitz::TinyMatrix< InnerT, NRows, NCols > DataT
blitz::Array< std::complex< InnerT >, Dim > DataT
static void const * data(DataT const &array)
static void * data(DataT &array)
static std::vector< hsize_t > h5Dims(DataT const &)
static void const * data(DataT const &array)
blitz::Array< blitz::TinyMatrix< InnerT, InnerDim1, InnerDim2 >, OuterDim > DataT