44 #include "MIPFieldIO.h"
48 using namespace boost;
66 const int MIPFieldIO::k_versionNumber (1);
67 const std::string MIPFieldIO::k_versionAttrName (
"version");
68 const std::string MIPFieldIO::k_extentsStr (
"extents");
69 const std::string MIPFieldIO::k_extentsMinStr (
"extents_min");
70 const std::string MIPFieldIO::k_extentsMaxStr (
"extents_max");
71 const std::string MIPFieldIO::k_dataWindowStr (
"data_window");
72 const std::string MIPFieldIO::k_dataWindowMinStr (
"data_window_min");
73 const std::string MIPFieldIO::k_dataWindowMaxStr (
"data_window_max");
74 const std::string MIPFieldIO::k_componentsStr (
"components");
75 const std::string MIPFieldIO::k_bitsPerComponentStr(
"bits_per_component");
76 const std::string MIPFieldIO::k_mipGroupStr (
"mip_levels");
77 const std::string MIPFieldIO::k_levelGroupStr (
"level");
78 const std::string MIPFieldIO::k_levelsStr (
"levels");
79 const std::string MIPFieldIO::k_baseTypeStr (
"base_type");
80 const std::string MIPFieldIO::k_dummyDataStr (
"dummy_data");
87 MIPFieldIO::read(hid_t layerGroup,
const std::string &filename,
88 const std::string &layerPath,
95 throw BadHdf5IdException(
"Bad layer group in MIPFieldIO::read");
98 if (!
readAttribute(layerGroup, k_versionAttrName, 1, version))
99 throw MissingAttributeException(
"Couldn't find attribute " +
102 if (version != k_versionNumber)
103 throw UnsupportedVersionException(
"MIPField version not supported: " +
104 lexical_cast<std::string>(version));
106 if (!
readAttribute(layerGroup, k_componentsStr, 1, components))
107 throw MissingAttributeException(
"Couldn't find attribute " +
113 if (!
readAttribute(layerGroup, k_bitsPerComponentStr, 1, bits))
114 throw MissingAttributeException(
"Couldn't find attribute: " +
115 k_bitsPerComponentStr);
117 std::string baseType;
119 throw MissingAttributeException(
"Couldn't find attribute: " +
124 bool isFloat =
false;
125 bool isDouble =
false;
139 bool isSparse =
false;
140 bool isDense =
false;
142 if (baseType ==
"SparseField") {
144 }
else if (baseType ==
"DenseField") {
152 if (isDense && isHalf && components == 1 && typeEnum ==
DataTypeHalf)
153 result = readInternal<DenseField, half>(layerGroup, filename,
154 layerPath, typeEnum);
155 if (isDense && isFloat && components == 1 && typeEnum ==
DataTypeFloat)
156 result = readInternal<DenseField, float>(layerGroup, filename,
157 layerPath, typeEnum);
158 if (isDense && isDouble && components == 1 && typeEnum ==
DataTypeDouble)
159 result = readInternal<DenseField, double>(layerGroup, filename,
160 layerPath, typeEnum);
161 if (isDense && isHalf && components == 3 && typeEnum ==
DataTypeVecHalf)
162 result = readInternal<DenseField, V3h>(layerGroup, filename,
163 layerPath, typeEnum);
165 result = readInternal<DenseField, V3f>(layerGroup, filename,
166 layerPath, typeEnum);
168 result = readInternal<DenseField, V3d>(layerGroup, filename,
169 layerPath, typeEnum);
170 if (isSparse && isHalf && components == 1 && typeEnum ==
DataTypeHalf)
171 result = readInternal<SparseField, half>(layerGroup, filename,
172 layerPath, typeEnum);
173 if (isSparse && isFloat && components == 1 && typeEnum ==
DataTypeFloat)
174 result = readInternal<SparseField, float>(layerGroup, filename,
175 layerPath, typeEnum);
176 if (isSparse && isDouble && components == 1 && typeEnum ==
DataTypeDouble)
177 result = readInternal<SparseField, double>(layerGroup, filename,
178 layerPath, typeEnum);
179 if (isSparse && isHalf && components == 3 && typeEnum ==
DataTypeVecHalf)
180 result = readInternal<SparseField, V3h>(layerGroup, filename,
181 layerPath, typeEnum);
183 result = readInternal<SparseField, V3f>(layerGroup, filename,
184 layerPath, typeEnum);
186 result = readInternal<SparseField, V3d>(layerGroup, filename,
187 layerPath, typeEnum);
195 MIPFieldIO::read(
const OgIGroup &layerGroup,
const std::string &filename,
196 const std::string &layerPath,
OgDataType typeEnum)
198 Box3i extents, dataW;
200 if (!layerGroup.isValid()) {
202 "MIPFieldIO::read(ogawa).");
209 layerGroup.findAttribute<
int>(k_versionAttrName);
210 if (!versionAttr.isValid()) {
211 throw MissingAttributeException(
"Couldn't find attribute: " +
214 const int version = versionAttr.value();
216 if (version != k_versionNumber) {
217 throw UnsupportedVersionException(
"MIPField version not supported: " +
218 lexical_cast<std::string>(version));
224 layerGroup.findAttribute<uint8_t>(k_componentsStr);
225 if (!numComponentsAttr.isValid()) {
226 throw MissingAttributeException(
"Couldn't find attribute " +
233 layerGroup.findAttribute<std::string>(k_baseTypeStr);
234 if (!baseTypeAttr.isValid()) {
235 throw MissingAttributeException(
"Couldn't find attribute " +
239 bool isSparse =
false;
240 bool isDense =
false;
242 if (baseTypeAttr.value() ==
"SparseField") {
244 }
else if (baseTypeAttr.value() ==
"DenseField") {
250 OgDataType typeOnDisk = layerGroup.datasetType(k_dummyDataStr);
254 if (typeEnum == typeOnDisk) {
257 result = readInternal<DenseField, float16_t>(layerGroup, filename,
258 layerPath, typeEnum);
260 result = readInternal<DenseField, float32_t>(layerGroup, filename,
261 layerPath, typeEnum);
263 result = readInternal<DenseField, float64_t>(layerGroup, filename,
264 layerPath, typeEnum);
266 result = readInternal<DenseField, vec16_t>(layerGroup, filename,
267 layerPath, typeEnum);
269 result = readInternal<DenseField, vec32_t>(layerGroup, filename,
270 layerPath, typeEnum);
272 result = readInternal<DenseField, vec64_t>(layerGroup, filename,
273 layerPath, typeEnum);
275 }
else if (isSparse) {
277 result = readInternal<SparseField, float16_t>(layerGroup, filename,
278 layerPath, typeEnum);
280 result = readInternal<SparseField, float32_t>(layerGroup, filename,
281 layerPath, typeEnum);
283 result = readInternal<SparseField, float64_t>(layerGroup, filename,
284 layerPath, typeEnum);
286 result = readInternal<SparseField, vec16_t>(layerGroup, filename,
287 layerPath, typeEnum);
289 result = readInternal<SparseField, vec32_t>(layerGroup, filename,
290 layerPath, typeEnum);
292 result = readInternal<SparseField, vec64_t>(layerGroup, filename,
293 layerPath, typeEnum);
306 if (layerGroup == -1) {
307 throw BadHdf5IdException(
"Bad layer group in MIPFieldIO::write");
312 1, k_versionNumber)) {
313 throw WriteAttributeException(
"Couldn't write attribute " +
318 field_dynamic_cast<MIPField<DenseField<half> > >(field);
320 field_dynamic_cast<MIPField<DenseField<float> > >(field);
322 field_dynamic_cast<MIPField<DenseField<double> > >(field);
324 field_dynamic_cast<MIPField<DenseField<V3h> > >(field);
326 field_dynamic_cast<MIPField<DenseField<V3f> > >(field);
328 field_dynamic_cast<MIPField<DenseField<V3d> > >(field);
330 field_dynamic_cast<MIPField<SparseField<half> > >(field);
332 field_dynamic_cast<MIPField<SparseField<float> > >(field);
334 field_dynamic_cast<MIPField<SparseField<double> > >(field);
336 field_dynamic_cast<MIPField<SparseField<V3h> > >(field);
338 field_dynamic_cast<MIPField<SparseField<V3f> > >(field);
340 field_dynamic_cast<MIPField<SparseField<V3d> > >(field);
344 if (floatDenseField) {
345 success = writeInternal<DenseField, float>(layerGroup, floatDenseField);
347 else if (halfDenseField) {
348 success = writeInternal<DenseField, half>(layerGroup, halfDenseField);
350 else if (doubleDenseField) {
351 success = writeInternal<DenseField, double>(layerGroup, doubleDenseField);
353 else if (vecFloatDenseField) {
354 success = writeInternal<DenseField, V3f>(layerGroup, vecFloatDenseField);
356 else if (vecHalfDenseField) {
357 success = writeInternal<DenseField, V3h>(layerGroup, vecHalfDenseField);
359 else if (vecDoubleDenseField) {
360 success = writeInternal<DenseField, V3d>(layerGroup, vecDoubleDenseField);
362 else if (floatSparseField) {
363 success = writeInternal<SparseField, float>(layerGroup, floatSparseField);
365 else if (halfSparseField) {
366 success = writeInternal<SparseField, half>(layerGroup, halfSparseField);
368 else if (doubleSparseField) {
369 success = writeInternal<SparseField, double>(layerGroup, doubleSparseField);
371 else if (vecFloatSparseField) {
372 success = writeInternal<SparseField, V3f>(layerGroup, vecFloatSparseField);
374 else if (vecHalfSparseField) {
375 success = writeInternal<SparseField, V3h>(layerGroup, vecHalfSparseField);
377 else if (vecDoubleSparseField) {
378 success = writeInternal<SparseField, V3d>(layerGroup, vecDoubleSparseField);
381 throw WriteLayerException(
"MIPFieldIO does not support the given "
382 "MIPField template parameter");
397 field_dynamic_cast<MIPField<DenseField<half> > >(field);
399 field_dynamic_cast<MIPField<DenseField<float> > >(field);
401 field_dynamic_cast<MIPField<DenseField<double> > >(field);
403 field_dynamic_cast<MIPField<DenseField<V3h> > >(field);
405 field_dynamic_cast<MIPField<DenseField<V3f> > >(field);
407 field_dynamic_cast<MIPField<DenseField<V3d> > >(field);
409 field_dynamic_cast<MIPField<SparseField<half> > >(field);
411 field_dynamic_cast<MIPField<SparseField<float> > >(field);
413 field_dynamic_cast<MIPField<SparseField<double> > >(field);
415 field_dynamic_cast<MIPField<SparseField<V3h> > >(field);
417 field_dynamic_cast<MIPField<SparseField<V3f> > >(field);
419 field_dynamic_cast<MIPField<SparseField<V3d> > >(field);
423 if (floatDenseField) {
424 success = writeInternal<DenseField, float>(layerGroup, floatDenseField);
426 else if (halfDenseField) {
427 success = writeInternal<DenseField, half>(layerGroup, halfDenseField);
429 else if (doubleDenseField) {
430 success = writeInternal<DenseField, double>(layerGroup, doubleDenseField);
432 else if (vecFloatDenseField) {
433 success = writeInternal<DenseField, V3f>(layerGroup, vecFloatDenseField);
435 else if (vecHalfDenseField) {
436 success = writeInternal<DenseField, V3h>(layerGroup, vecHalfDenseField);
438 else if (vecDoubleDenseField) {
439 success = writeInternal<DenseField, V3d>(layerGroup, vecDoubleDenseField);
441 else if (floatSparseField) {
442 success = writeInternal<SparseField, float>(layerGroup, floatSparseField);
444 else if (halfSparseField) {
445 success = writeInternal<SparseField, half>(layerGroup, halfSparseField);
447 else if (doubleSparseField) {
448 success = writeInternal<SparseField, double>(layerGroup, doubleSparseField);
450 else if (vecFloatSparseField) {
451 success = writeInternal<SparseField, V3f>(layerGroup, vecFloatSparseField);
453 else if (vecHalfSparseField) {
454 success = writeInternal<SparseField, V3h>(layerGroup, vecHalfSparseField);
456 else if (vecDoubleSparseField) {
457 success = writeInternal<SparseField, V3d>(layerGroup, vecDoubleSparseField);
460 throw WriteLayerException(
"MIPFieldIO does not support the given "
461 "MIPField template parameter");