diff options
Diffstat (limited to 'conversion/test/test_hdf.cc')
-rw-r--r-- | conversion/test/test_hdf.cc | 309 |
1 files changed, 309 insertions, 0 deletions
diff --git a/conversion/test/test_hdf.cc b/conversion/test/test_hdf.cc new file mode 100644 index 0000000..a11b98a --- /dev/null +++ b/conversion/test/test_hdf.cc @@ -0,0 +1,309 @@ +#include "conversion/convertor.hh" +#include "conversion/hdf.hh" +#include "raslib/minterval.hh" +#include "raslib/primitivetype.hh" + + +#ifdef EARLY_TEMPLATE +#define __EXECUTABLE__ +#include "raslib/template_inst.hh" +#endif + +char *TypeIDToName(int tpid) +{ + switch (tpid) + { + case r_Primitive_Type::BOOL: return "bool"; break; + case r_Primitive_Type::CHAR: return "char"; break; + case r_Primitive_Type::OCTET: return "octet"; break; + case r_Primitive_Type::SHORT: return "short"; break; + case r_Primitive_Type::USHORT: return "ushort"; break; + case r_Primitive_Type::LONG: return "long"; break; + case r_Primitive_Type::ULONG: return "ulong"; break; + case r_Primitive_Type::FLOAT: return "float"; break; + case r_Primitive_Type::DOUBLE: return "double"; break; + default: return"?"; break; + } +} + + +int TestHDF(r_Minterval &domain, r_Type *tp, const char *params=NULL) +{ + r_Primitive_Type *prim; + char *src, *dest; + r_Minterval destInterv; + r_Conv_HDF *hdf; + r_Type *destType; + r_convDesc desc; + int i, j, k; + int rank, array_size, datasize; + int *dimsizes, *dimsteps, *dimidx; + char **srcPtrs; + int ptid, retid; + + if (tp->isStructType()) + { + cerr << "No structured types allowed!" << endl; + return -1; + } + prim = (r_Primitive_Type*)tp; + ptid = prim->type_id(); + cout << "Source domain = " << domain << ", type = " << TypeIDToName(ptid) << endl; + + switch (ptid) + { + case r_Primitive_Type::BOOL: + case r_Primitive_Type::CHAR: + case r_Primitive_Type::OCTET: + datasize = 1; break; + case r_Primitive_Type::SHORT: + case r_Primitive_Type::USHORT: + datasize = 2; break; + case r_Primitive_Type::LONG: + case r_Primitive_Type::ULONG: + case r_Primitive_Type::FLOAT: + datasize = 4; break; + case r_Primitive_Type::DOUBLE: + datasize = 8; break; + default: + cerr << "Unrecognized base type" << endl; + return -1; + } + + rank = domain.dimension(); + dimsizes = new int[rank]; dimsteps = new int[rank]; dimidx = new int[rank]; + srcPtrs = new char*[rank]; + for (i=0; i<rank; i++) + { + dimsizes[i] = domain[i].high() - domain[i].low() + 1; + dimidx[i] = 0; + } + array_size = datasize; + for (i=rank-1; i>=0; i--) + { + dimsteps[i] = array_size; array_size *= dimsizes[i]; + } + src = new char[array_size]; + + for (i=0; i<rank; i++) srcPtrs[i] = src; + + k = 0; + do + { + //cout << (int)(srcPtrs[0] - src) << endl; + + // A bit inefficient, but customized code for the entire loop for each type + // would result in way too much code for testing purposes only. + switch (ptid) + { + case r_Primitive_Type::BOOL: + case r_Primitive_Type::CHAR: + case r_Primitive_Type::OCTET: + *((char*)srcPtrs[0]) = (char)k; + break; + case r_Primitive_Type::SHORT: + case r_Primitive_Type::USHORT: + *((short*)srcPtrs[0]) = (short)k; + break; + case r_Primitive_Type::LONG: + case r_Primitive_Type::ULONG: + *((long*)srcPtrs[0]) = (long)k; + break; + case r_Primitive_Type::FLOAT: + *((float*)srcPtrs[0]) = (float)k; + break; + case r_Primitive_Type::DOUBLE: + *((double*)srcPtrs[0]) = (double)k; + break; + default: break; + } + k++; i = 0; + do + { + dimidx[i]++; + if (dimidx[i] < dimsizes[i]) break; + dimidx[i] = 0; i++; + } + while (i < rank); + if (i < rank) + { + srcPtrs[i] += dimsteps[i]; + if (i > 0) + { + // Init the array with the value x_0 + x_1 + ... + x_(n-1) + k = dimidx[0]; + for (j=1; j<rank; j++) k += dimidx[j]; + for (j=i; j>0; j--) {srcPtrs[j-1] = srcPtrs[j];;} + } + } + } + while (i < rank); + + hdf = new r_Conv_HDF(src, domain, tp); + + dest = NULL; + + try + { + desc = hdf->convertTo(params); + dest = desc.dest; + destInterv = desc.destInterv; + destType = desc.destType; + } + catch(r_Error &err) + { + cerr << "Exception! " << err.what() << endl; + } + + cout << "Encoded interval " << desc.destInterv << endl; + + delete hdf; + + if (dest != NULL) + { + try + { + hdf = new r_Conv_HDF(dest, destInterv, destType); + + desc = hdf->convertFrom(); + + cout << "retrieved type = "; desc.destType->print_status(); + retid = ((r_Primitive_Type*)(desc.destType))->type_id(); + cout << ", (" << ((retid == ptid) ? "OK" : "Differs") << ')' << endl; + cout << "retrieved domain " << desc.destInterv << ' '; + i = 0; + if (desc.destInterv.dimension() == rank) + { + for (i=0; i<rank; i++) + { + if (desc.destInterv[i].high() - desc.destInterv[i].low() != domain[i].high() - domain[i].low()) + break; + } + } + if (i < rank) + { + cout << "Incompatible!" << endl; + return -1; + } + cout << "(OK)" << endl; + + for (i=0; i<array_size; i++) + { + if (src[i] != desc.dest[i]) break; + } + if (i == array_size) + { + cout << "Data identical" << endl; + } + else + { + cout << "Data differs at " << i << endl; + } + + cout << endl; + + delete destType; + delete desc.destType; + + free(desc.dest); // HDF^-1 ( HDF (X) ) + } + catch(r_Error &err) + { + cerr << "Exception! " << err.what() << endl; + } + } + + delete hdf; + + if (dest != NULL) + free(dest); // HDF (X) + + delete [] src; // X + + delete [] dimsizes; delete [] dimsteps; delete [] dimidx; delete [] srcPtrs; + + // Delete the base type passed from the caller too + delete tp; + + return 0; +} + + + + + +int main(int argc, char *argv[]) +{ + r_Minterval interv; + r_Type *tp; + + // 3D data set over char + interv = r_Minterval(3); + interv << r_Sinterval(r_Range(0), r_Range(19)) + << r_Sinterval(r_Range(0), r_Range(29)) + << r_Sinterval(r_Range(0), r_Range(39)); + tp = r_Type::get_any_type("char"); + TestHDF(interv, tp); + + // 2D data set over short + interv = r_Minterval(2); + interv << r_Sinterval(r_Range(0), r_Range(100)) + << r_Sinterval(r_Range(0), r_Range(200)); + tp = r_Type::get_any_type("short"); + TestHDF(interv, tp); + + // 1D data set over long + interv = r_Minterval(1); + interv << r_Sinterval(r_Range(0), r_Range(400)); + tp = r_Type::get_any_type("long"); + TestHDF(interv, tp); + + // 2D data set over float + interv = r_Minterval(2); + interv << r_Sinterval(r_Range(0), r_Range(200)) + << r_Sinterval(r_Range(0), r_Range(300)); + tp = r_Type::get_any_type("float"); + TestHDF(interv, tp); + + // 2D data set over double + interv = r_Minterval(2); + interv << r_Sinterval(r_Range(100), r_Range(300)) + << r_Sinterval(r_Range(100), r_Range(400)); + tp = r_Type::get_any_type("double"); + TestHDF(interv, tp); + + // 1D data set over octet + interv = r_Minterval(1); + interv << r_Sinterval(r_Range(0), r_Range(200)); + tp = r_Type::get_any_type("octet"); + TestHDF(interv, tp); + + // 1D data set over bool + interv = r_Minterval(1); + interv << r_Sinterval(r_Range(0), r_Range(200)); + tp = r_Type::get_any_type("boolean"); + TestHDF(interv, tp); + + // 1D data set over unsigned short + interv = r_Minterval(1); + interv << r_Sinterval(r_Range(0), r_Range(200)); + tp = r_Type::get_any_type("ushort"); + TestHDF(interv, tp); + + // 1D data set over unsigned long + interv = r_Minterval(1); + interv << r_Sinterval(r_Range(0), r_Range(200)); + tp = r_Type::get_any_type("ulong"); + TestHDF(interv, tp); + + // 4D data set over char + interv = r_Minterval(4); + interv << r_Sinterval(r_Range(100), r_Range(149)) + << r_Sinterval(r_Range(110), r_Range(184)) + << r_Sinterval(r_Range(120), r_Range(219)) + << r_Sinterval(r_Range(130), r_Range(204)); + tp = r_Type::get_any_type("char"); + TestHDF(interv, tp); + + return 0; +} |