diff options
Diffstat (limited to 'conversion/test')
| -rw-r--r-- | conversion/test/Makefile | 142 | ||||
| -rw-r--r-- | conversion/test/test_bmp.cc | 83 | ||||
| -rw-r--r-- | conversion/test/test_convertor.cc | 276 | ||||
| -rw-r--r-- | conversion/test/test_hdf.cc | 309 | ||||
| -rw-r--r-- | conversion/test/test_jpeg.cc | 295 | ||||
| -rw-r--r-- | conversion/test/test_png.cc | 237 | ||||
| -rw-r--r-- | conversion/test/test_vff.cc | 169 |
7 files changed, 1511 insertions, 0 deletions
diff --git a/conversion/test/Makefile b/conversion/test/Makefile new file mode 100644 index 0000000..410e1c4 --- /dev/null +++ b/conversion/test/Makefile @@ -0,0 +1,142 @@ +# -*-Makefile-*- +# +# This file is part of rasdaman community. +# +# Rasdaman community is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# Rasdaman community is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with rasdaman community. If not, see <http://www.gnu.org/licenses/>. +# +# Copyright 2003, 2004, 2005, 2006, 2007, 2008, 2009 Peter Baumann / +# rasdaman GmbH. +# +# For more information please see <http://www.rasdaman.org> +# or contact Peter Baumann via <baumann@rasdaman.com>. # Top Level makefile. This points to the various modules that have to be build +# and/or deployed +# +# MAKEFILE FOR: +# test programs of module conversion +# +# COMMENTS: +# +################################################################## +# +# This is just an example Makefile for a test program. +# The dependency of the test program on the lib of the +# corresponding module is in the Makefile of the module. +# + +######################### Definitions ############################ + +# standard include with general options +include $(RMANBASE)/Makefile.inc + +# all test programs +ifeq ($(OSTYPE),linux-gnu) +ALLTESTS = test_convertor test_png test_jpeg test_bmp test_vff +else +ALLTESTS = test_convertor test_hdf test_png test_jpeg test_bmp test_vff +endif + +# For the time being: HDF includes / libs +HDFBASE = $(SUPPORT_BASE) +HDFINC = -I$(HDFBASE)/include +HDFLIB = -L$(HDFBASE)/lib -ldf -ljpeg -lz -lmfhdf -lnsl + +ifeq ($(OSTYPE),linux-gnu) + LINKLIBS=$(CONVERSION) $(CLIENTCOMM) $(COMPRESSION) $(RASLIB) $(RASODMG) + CLIENTLDFLAGS += -lz +else + ifdef RMANGCC + LINKLIBS=$(CONVERSION) $(CLIENTCOMM) $(COMPRESSION) $(RASLIB) $(RASODMG) + CLIENTLDFLAGS += -lsocket -lnsl -lz + else + LINKLIBS=$(CONVERSION) $(RASLIB) + endif +endif + +########################### Targets ############################## + +# test target for convertors like r_TIFF +.PHONY : convertor +convertor: test_module $(ALLTESTS) + +.PHONY : test_module +test_module: + cd $(RMANBASE)/conversion; $(MAKE) + +.PHONY : tiff +tiff: test_module test_convertor + +.PHONY : hdf +hdf: test_module test_hdf + +.PHONY : png +png: test_module test_png + +.PHONY : jpeg +jpeg: test_module test_jpeg + +.PHONY : bmp +bmp: test_module test_bmp + +.PHONY : vff +vff: test_module test_vff + + +test_convertor: test_convertor.o $(LINKLIBS) + $(PURIFY) $(CXX) $(CLIENTLDFLAGS) -o $@ $^ -L$(SUPPORT_BASE)/lib -ltiff -ljpeg -lz -lcrypto + +test_hdf: test_hdf.o $(LINKLIBS) + $(PURIFY) $(CXX) $(CLIENTLDFLAGS) -o $@ $^ -L$(SUPPORT_BASE)/lib -lcrypto -lz $(HDFLIB) + +test_png: test_png.o $(LINKLIBS) + $(PURIFY) $(CXX) $(CLIENTLDFLAGS) -o $@ $^ -L$(SUPPORT_BASE)/lib -lpng -lz -lcrypto + +test_jpeg: test_jpeg.o $(LINKLIBS) + $(PURIFY) $(CXX) $(CLIENTLDFLAGS) -o $@ $^ -L$(SUPPORT_BASE)/lib -ljpeg -lz -lcrypto + +test_bmp: test_bmp.o $(LINKLIBS) + $(PURIFY) $(CXX) $(CLIENTLDFLAGS) -o $@ $^ -L$(SUPPORT_BASE)/lib -lcrypto -lz + +test_vff: test_vff.o $(LINKLIBS) + $(PURIFY) $(CXX) $(CLIENTLDFLAGS) -o $@ $^ -L$(SUPPORT_BASE)/lib -lcrypto -lz + + +.PHONY : clean +clean: + -rm $(ALLTESTS) + -rm *.o + +# deletes all non modified, but checked out files +.PHONY : rcsclean +rcsclean: + -rcsclean + +######################## Dependencies ############################ + +test_convertor.o: test_convertor.cc + $(CXX) test_convertor.cc -c -o $@ $(CLIENTCXXFLAGS) + +test_hdf.o: test_hdf.cc + $(CXX) test_hdf.cc -c -o $@ $(HDFINC) $(CLIENTCXXFLAGS) + +test_png.o: test_png.cc + $(CXX) test_png.cc -c -o $@ $(CLIENTCXXFLAGS) + +test_jpeg.o: test_jpeg.cc + $(CXX) test_jpeg.cc -c -o $@ $(CLIENTCXXFLAGS) + +test_bmp.o: test_bmp.cc + $(CXX) test_bmp.cc -c -o $@ $(CLIENTCXXFLAGS) + +test_vff.o: test_vff.cc + $(CXX) test_vff.cc -c -o $@ $(CLIENTCXXFLAGS) diff --git a/conversion/test/test_bmp.cc b/conversion/test/test_bmp.cc new file mode 100644 index 0000000..c98712e --- /dev/null +++ b/conversion/test/test_bmp.cc @@ -0,0 +1,83 @@ +#include <stdlib.h> +#include <stdio.h> +#include <iostream> +#include <string.h> + + +#include "conversion/convertor.hh" +#include "conversion/bmp.hh" + +#ifdef EARLY_TEMPLATE +#define __EXECUTABLE__ +#include "raslib/template_inst.hh" +#endif + +int main(int argc, char *argv[]) +{ + char filename[256] = "Somewhere.bmp"; + long fsize=0; + FILE *fp=NULL; + char *data=NULL; + r_Minterval interv(1); + r_Minterval imgInterv; + r_Conv_BMP *bmp=NULL; + r_convDesc desc; + r_Type *baseType=NULL; + char *imgData=NULL; + + if (argc > 1) + strcpy(filename, argv[1]); + + fp = fopen(filename, "rb"); + if (fp == NULL) + { + cerr << "Unable to open file " << filename << endl; + exit(-1); + } + + fseek(fp, 0, SEEK_END); + fsize = ftell(fp); + fseek(fp, 0, SEEK_SET); + + data = new char[fsize]; + fread(data, 1, fsize, fp); + fclose(fp); + + interv << r_Sinterval((r_Range)0, (r_Range)fsize-1); + + cout << "Convert from BMP..." << endl; + bmp = new r_Conv_BMP(data, interv, r_Convertor::ctype_char); + desc = bmp->convertFrom(); + baseType = desc.destType; + imgData = desc.dest; + imgInterv = desc.destInterv; + delete [] data; + data=NULL; + delete bmp; + bmp=NULL; + + cout << "Convert to BMP..." << endl; + bmp = new r_Conv_BMP(imgData, imgInterv, baseType); + desc = bmp->convertTo("compress=1"); + fsize = desc.destInterv[0].high() - desc.destInterv[0].low() + 1; + + fp = fopen("result.bmp", "wb"); + fwrite(desc.dest, 1, fsize, fp); + fclose(fp); + + free(desc.dest); + desc.dest=NULL; + delete desc.destType; + desc.destType=NULL; + delete bmp; + bmp=NULL; + + cout << "Clean up..." << endl; + + delete baseType; + baseType=NULL; + free(imgData); + imgData=NULL; + + return 0; +} diff --git a/conversion/test/test_convertor.cc b/conversion/test/test_convertor.cc new file mode 100644 index 0000000..9305278 --- /dev/null +++ b/conversion/test/test_convertor.cc @@ -0,0 +1,276 @@ +#include <iostream> +#include <stdio.h> +#include <string.h> +#include "conversion/convertor.hh" +#include "conversion/tiff.hh" +#include "raslib/rminit.hh" +#include "rasodmg/gmarray.hh" + +#ifdef EARLY_TEMPLATE +#define __EXECUTABLE__ +#include "raslib/template_inst.hh" +#endif + +// define if you want to use r_Type variables to set the +// array type. +//#define TEST_CONV_USE_RTYPES + + +void ConvertToTIFFCore(r_Conv_TIFF *tiff, const char *save, const char *params) +{ + r_convDesc desc; + FILE *tfile; + long size; + + try + { + // desc will become invalid when the TIFF object is deleted. + // The same applies to all data allocated by the TIFF object, + // e.g. the buffer holding the resulting TIFF. + desc = tiff->convertTo(params); + + size = (long)(desc.destInterv[0].high() - desc.destInterv[0].low() + 1); + if ((tfile = fopen(save, "wb")) == NULL) + { + cerr << "Error opening file " << save << endl; + } + else + { + fwrite((void*)(desc.dest), (size_t)1, (size_t)size, tfile); + fclose(tfile); + } + cout << "test_convertor: r_Conv_TIFF::convertTo successful. " + << "size = " << size << ", type = "; + desc.destType->print_status(cout); cout << endl; + // This is the job of the client! + free(desc.dest); + delete desc.destType; + } + catch (r_Error &err) + { + cout << "An error occurred: " << err.what() << endl; + } +} + + +void ConvertToTIFF(char *data, r_Minterval &iv, r_Type *type, const char *save, const char *params) +{ + r_Conv_TIFF *tiff; + + cout << "test_convertor (r_Type): "; + if (type) + { + cout << "Base Type is "; type->print_status(cout); cout << endl; + } + else + { + cout << "Base type not defined!" << endl; + } + + tiff = new r_Conv_TIFF(data, iv, type); + ConvertToTIFFCore(tiff, save, params); + delete tiff; +} + + +void ConvertToTIFF(char *data, r_Minterval &iv, int type, const char *save, const char *params) +{ + r_Conv_TIFF *tiff; + + cout << "test_convertor (int):" << endl; + + tiff = new r_Conv_TIFF(data, iv, type); + ConvertToTIFFCore(tiff, save, params); + delete tiff; +} + + +void ConvertFromTIFF(char *name, const char *params, const char *save_as = NULL) +{ + FILE *fp; + long size; + r_convDesc desc; + r_Conv_TIFF *tiff; + char *data; + r_Minterval iv; + + fp = fopen(name, "r"); + fseek(fp, 0, SEEK_END); + size = ftell(fp); + data = new char[size]; + fseek(fp, 0, SEEK_SET); + fread((void*)data, (size_t)1, (size_t)size, fp); + fclose(fp); + + // Set interval + iv = r_Minterval(1); iv << r_Sinterval(r_Range(0), r_Range(size - 1)); + + // Base type is coded in TIFF + tiff = new r_Conv_TIFF(data, iv, (int)0); + + desc = tiff->convertFrom(); + + cout << "test_convertor: r_Conv_TIFF::convertFrom successful." + << " domain = " << desc.destInterv << ", type = "; + desc.destType->print_status(cout); cout << endl; + + delete [] data; + + // save file again as TIFF to check convertFrom validity? + if (save_as != NULL) + { + cout << "test_convertor: Saving data again as <" << save_as << ">..." << endl; + ConvertToTIFF(desc.dest, desc.destInterv, desc.baseType, save_as, params); + } + + // The order in which objects are deleted is important! + free(desc.dest); + delete desc.destType; + + // Delete this last. From then on desc is invalid. + delete tiff; +} + + + +// Flag bits for main() +#define CONVERTOR_WRITE_BACK 1 + + +// Calling convention: test_convertor [-x # -y # -c <compression> -v -h] +// Where -x: width, -y: height, -c: compression, -v: write again as TIFF after reading +// -h: Help on usage +// width, height default to 200, 100 +int main (int argc, char *argv[]) +{ + r_GMarray dummyArray; // need this for linking on Linux, don't know why + char *data, *lineBase, *line; + int width = 200, height = 100; + unsigned int flags = 0; + int i, j; + char params[256]; + const char *paramptr = NULL; +#ifdef TEST_CONV_USE_RTYPES + r_Type *type; +#endif + struct nametable {char *write, *verify;} tiffnames[] = { + {"grey.tif", "grey2.tif"}, + {"bool.tif", "bool2.tif"}, + {"rgb.tif", "rgb2.tif"} + }; + + i = 1; + while (i < argc) + { + if (argv[i][0] == '-') + { + switch (argv[i][1]) + { + case 'x': width = atoi(argv[++i]); break; + case 'y': height = atoi(argv[++i]); break; + case 'c': + sprintf(params, "comptype=%s", argv[++i]); + paramptr = params; + break; + case 'v': flags |= CONVERTOR_WRITE_BACK; break; + case 'h': + cout << "Usage: " << argv[0] << "[-w # -h # -c <string> -v -h]" << endl; + cout << "\t-x #: width" << endl; + cout << "\t-y #: height" << endl; + cout << "\t-c <string>: compression (see r_Conv_TIFF::compNames)" << endl; + cout << "\t-v: write the TIFF files just read back as TIFF files for verifying" << endl; + cout << "\t-h: this help" << endl; + exit(0); + default: cout << "Bad switch -" << argv[i][1] << endl; break; + } + } + i++; + } + + cout << "test_convertor: use images of size " << width << " * " << height + << ", compression: "; + + // Allocate enough room for _all_ types of data. + if ((data = new char[3*width*height]) == NULL) + { + cout << "Out of memory error!" << endl; exit(0); + } + + r_Minterval iv(2); + iv << r_Sinterval(r_Range(0), r_Range(width - 1)) + << r_Sinterval(r_Range(0), r_Range(height - 1)); + + // Take into account that MDD arrays are transposed compared to + // images! + cout << "Greyscale:" << endl; + lineBase = data; + for (j=0; j<height; j++, lineBase++) + { + line = lineBase; + for (i=0; i<width; i++, line += height) + { + *line = (char)((i+j) & 0xff); + } + } + +#ifdef TEST_CONV_USE_RTYPES + type = r_Type::get_base_type("char"); + ConvertToTIFF(data, iv, type, tiffnames[0].write, paramptr); + delete type; +#else + ConvertToTIFF(data, iv, (int)(r_Convertor::ctype_char), tiffnames[0].write, paramptr); +#endif + + cout << "Bitmap:" << endl; + lineBase = data; + for (j=0; j<height; j++, lineBase++) + { + line = lineBase; + for (i=0; i<width; i++, line += height) + { + *line = (char)((i + j) & 1); + } + } + +#ifdef TEST_CONV_USE_RTYPES + type = r_Type::get_base_type("boolean"); + ConvertToTIFF(data, iv, type, tiffnames[1].write, paramptr); + delete type; +#else + ConvertToTIFF(data, iv, (int)(r_Convertor::ctype_bool), tiffnames[1].write, paramptr); +#endif + + cout << "RGB:" << endl; + lineBase = data; + for (j=0; j<height; j++, lineBase += 3) + { + line = lineBase; + for (i=0; i<width; i++, line += 3*height) + { + line[0] = ((i+j) & 0xff); line [1] = ((0xff - (i+j)) & 0xff); + line[2] = (((i+j) >> 1) & 0xff); + } + } + +#ifdef TEST_CONV_USE_RTYPES + type = r_Type::get_base_type("struct{ char red, char green, char blue }"); + ConvertToTIFF(data, iv, type, tiffnames[2].write, paramptr); + delete type; +#else + ConvertToTIFF(data, iv, (int)(r_Convertor::ctype_rgb), tiffnames[2].write, paramptr); +#endif + + delete [] data; + + // Try the other way around: convert from TIFF + ConvertFromTIFF("rgb.tif", paramptr, + ((flags & CONVERTOR_WRITE_BACK) != 0) ? tiffnames[2].verify : NULL); + + ConvertFromTIFF("bool.tif", paramptr, + ((flags & CONVERTOR_WRITE_BACK) != 0) ? tiffnames[1].verify : NULL); + + ConvertFromTIFF("grey.tif", paramptr, + ((flags & CONVERTOR_WRITE_BACK) != 0) ? tiffnames[0].verify : NULL); + + return 0; +} 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; +} diff --git a/conversion/test/test_jpeg.cc b/conversion/test/test_jpeg.cc new file mode 100644 index 0000000..e56a3d4 --- /dev/null +++ b/conversion/test/test_jpeg.cc @@ -0,0 +1,295 @@ +#include <stdlib.h> +#include <stdio.h> +#include <iostream> +#include <string.h> +#include <math.h> + + +#include "conversion/convertor.hh" +#include "conversion/jpeg.hh" + +#ifdef EARLY_TEMPLATE +#define __EXECUTABLE__ +#include "raslib/template_inst.hh" +#endif + +static int init_identity(int offset) +{ + return offset; +} + +static int init_square(int offset) +{ + return offset * offset; +} + +static int SinTabOK = 0; +static int SinusTable[512]; + +static int init_sine(int offset) +{ + if (SinTabOK == 0) + { + int i; + + for (i=0; i<512; i++) + { + SinusTable[i] = (int)(255*sin(M_PI * offset / 512.0)); + } + SinTabOK = 1; + } + return SinusTable[offset & 511]; +} + +static int JpegErrorFileNumber; + +int test_picture(int width, int height, int bpp, const char *params, int (*init)(int)) +{ + char *data; + r_Minterval interv(2); + int datasize; + int baseType; + int bytespp; + int i; + + switch (bpp) + { + case 1: baseType = r_Convertor::ctype_bool; bytespp = 1; break; + case 8: baseType = r_Convertor::ctype_char; bytespp = 1; break; + case 24: baseType = r_Convertor::ctype_rgb; bytespp = 3; break; + default: + cerr << "Unknown bpp value " << bpp << endl; + return -1; + } + + interv << r_Sinterval((r_Range)0, (r_Range)width-1) + << r_Sinterval((r_Range)0, (r_Range)height-1); + + datasize = (width * bytespp * height); + data = new char[datasize]; + + cout << "Test: bpp = " << bpp << ", domain = " << interv << ", params = " << ((params == NULL) ? "" : params) << ", size = " << datasize << endl; + + if (bpp > 1) + { + for (i=0; i<datasize; i++) data[i] = (char)init(i); + } + else + { + int j, count; + + for (i=0; i<datasize; i+=8) + { + count = datasize - i; if (count > 8) count = 8; + for (j=0; j<count; j++) data[i+j] = ((init(i>>3) & (1<<j)) == 0) ? 0 : 1; + } + } + + r_Conv_JPEG *jpeg = NULL; + char *dest = NULL; + + try + { + r_convDesc desc; + int destsize; + int status = 0; + + jpeg = new r_Conv_JPEG(data, interv, baseType); + desc = jpeg->convertTo(params); + destsize = desc.destInterv[0].high() - desc.destInterv[0].low() + 1; + cout << "\tConverted to JPEG, domain " << desc.destInterv << endl; + dest = desc.dest; + r_Minterval destInterv(desc.destInterv); + delete desc.destType; + delete jpeg; + jpeg = new r_Conv_JPEG(dest, destInterv, r_Convertor::ctype_char); + desc = jpeg->convertFrom(); + cout << "\tConverted from JPEG, domain " << desc.destInterv << endl; + + if (interv == desc.destInterv) + { + unsigned char *b, *d; + double totalError; + unsigned char maxError; + int i; + + // Bitmaps get expanded to greyscale... + if (baseType == r_Convertor::ctype_bool) + { + for (i=0; i<datasize; i++) + { + if (data[i] != 0) data[i] = 0xff; + } + } + + b = (unsigned char*)data; d = (unsigned char*)desc.dest; + totalError = 0.0; maxError = abs(*b - *d); + for (i=0; i<datasize; i++) + { + b[i] = abs(b[i] - d[i]); + if (b[i] > maxError) maxError = b[i]; + totalError += (double)(b[i]); + } + + r_Conv_JPEG *errpeg; + r_convDesc cdsc; + char errfile[256]; + FILE *fp; + int errType; + + errType = (baseType == r_Convertor::ctype_bool) ? r_Convertor::ctype_char : baseType; + sprintf(errfile, "jerror%d.jpg", JpegErrorFileNumber++); + cout << "\tCreating error file <" << errfile << "> ..." << endl; + cout << "\t(max error = " << (int)maxError << ", avg error = " + << totalError / (double)datasize << ")" << endl; + + errpeg = new r_Conv_JPEG(data, interv, errType); + cdsc = errpeg->convertTo("quality=90"); + i = (int)(cdsc.destInterv[0].high() - cdsc.destInterv[0].low() + 1); + if ((fp = fopen(errfile, "wb")) == NULL) + { + cerr << "\tUnable to open output file!" << endl; + } + else + { + fwrite(cdsc.dest, 1, i, fp); + fclose(fp); + } + delete cdsc.destType; + free(cdsc.dest); + delete errpeg; + } + else + { + cout << "\t Domain differs!!!" << endl; + status = -1; + } + + delete jpeg; + delete [] data; + free(dest); + free(desc.dest); + delete desc.destType; + + return status; + } + catch (r_Error &err) + { + cerr << "Error: " << err.what() << endl; + + delete [] data; + if (dest != NULL) delete [] dest; + if (jpeg != NULL) delete jpeg; + + return -1; + } +} + +int main(int argc, char *argv[]) +{ + int i; + char jpegfile[256] = ""; + char params[256]; + const char *paramptr = NULL; + + i = 1; + while (i < argc) + { + if (strcmp(argv[i], "-file") == 0) + { + strcpy(jpegfile, argv[++i]); + } + else if (strcmp(argv[i], "-quality") == 0) + { + sprintf(params, "quality=%s", argv[++i]); + paramptr = params; + } + i++; + } + + if (jpegfile[0] == '\0') + { + JpegErrorFileNumber = 0; + test_picture(400, 300, 1, paramptr, init_identity); + test_picture(400, 300, 8, paramptr, init_identity); + test_picture(400, 300, 24, paramptr, init_identity); + test_picture(701, 333, 1, paramptr, init_square); + test_picture(701, 333, 8, paramptr, init_square); + test_picture(701, 333, 24, paramptr, init_square); + test_picture(3007, 3999, 1, paramptr, init_sine); + test_picture(3007, 3999, 8, paramptr, init_sine); + test_picture(3007, 3999, 24, paramptr, init_sine); + } + else + { + FILE *fp; + long fileSize; + char *data = NULL; + char *cdata = NULL; + r_convDesc desc; + r_Type *baseType; + r_Conv_JPEG *jpeg; + + if ((fp = fopen(jpegfile, "rb")) == NULL) + { + cerr << "Unable to open input file" << endl; + return -1; + } + fseek(fp, 0, SEEK_END); fileSize = ftell(fp); fseek(fp, 0, SEEK_SET); + data = new char[fileSize]; + fread(data, 1, fileSize, fp); + fclose(fp); + + jpeg = NULL; baseType = NULL; + try + { + r_Minterval interv(1); + interv << r_Sinterval((r_Range)0, (r_Range)fileSize-1); + + jpeg = new r_Conv_JPEG(data, interv, 0); + cout << "Converting file <" << jpegfile << "> to MDD..." << endl; + desc = jpeg->convertFrom(); + + r_Minterval imgInterv(desc.destInterv); + delete [] data; data = NULL; + cdata = desc.dest; + baseType = desc.destType; + delete jpeg; + + cout << "Resulting domain " << imgInterv << ", "; + baseType->print_status(); + cout << endl; + + jpeg = new r_Conv_JPEG(cdata, imgInterv, baseType); + cout << "Converting MDD back to JPEG..." << endl; + desc = jpeg->convertTo(paramptr); + free(cdata); + cdata = desc.dest; + + cout << "Resulting domain " << desc.destInterv << ", "; + desc.destType->print_status(); + cout << endl; + + fp = fopen("result.jpg", "wb"); + fileSize = desc.destInterv[0].high() - desc.destInterv[0].low() + 1; + fwrite(cdata, 1, fileSize, fp); + fclose(fp); + + delete baseType; + free(cdata); + + delete desc.destType; + delete jpeg; + } + catch (r_Error &err) + { + cerr << "Conversion failed: " << err.what() << endl; + if (baseType != NULL) delete baseType; + if (cdata != NULL) delete [] cdata; + if (jpeg != NULL) delete jpeg; + } + if (data != NULL) + delete [] data; + } + return 0; +} diff --git a/conversion/test/test_png.cc b/conversion/test/test_png.cc new file mode 100644 index 0000000..bc481fc --- /dev/null +++ b/conversion/test/test_png.cc @@ -0,0 +1,237 @@ +#include <stdlib.h> +#include <stdio.h> +#include <iostream> +#include <string.h> +#include <math.h> + + +#include "conversion/convertor.hh" +#include "conversion/png.hh" + +#ifdef EARLY_TEMPLATE +#define __EXECUTABLE__ +#include "raslib/template_inst.hh" +#endif + +static int init_identity(int offset) +{ + return offset; +} + +static int init_square(int offset) +{ + return offset * offset; +} + +static int SinTabOK = 0; +static int SinusTable[512]; + +static int init_sine(int offset) +{ + if (SinTabOK == 0) + { + int i; + + for (i=0; i<512; i++) + { + SinusTable[i] = (int)(255*sin(M_PI * offset / 512.0)); + } + SinTabOK = 1; + } + return SinusTable[offset & 511]; +} + +int test_picture(int width, int height, int bpp, int (*init)(int)) +{ + char *data; + r_Minterval interv(2); + int datasize; + int baseType; + int bytespp; + int i; + + switch (bpp) + { + case 1: baseType = r_Convertor::ctype_bool; bytespp = 1; break; + case 8: baseType = r_Convertor::ctype_char; bytespp = 1; break; + case 24: baseType = r_Convertor::ctype_rgb; bytespp = 3; break; + default: + cerr << "Unknown bpp value " << bpp << endl; + return -1; + } + + interv << r_Sinterval((r_Range)0, (r_Range)width-1) + << r_Sinterval((r_Range)0, (r_Range)height-1); + + datasize = (width * bytespp * height); + data = new char[datasize]; + + cout << "Test: bpp = " << bpp << ", domain = " << interv << ", size = " << datasize << endl; + + if (bpp > 1) + { + for (i=0; i<datasize; i++) data[i] = (char)init(i); + } + else + { + int j, count; + + for (i=0; i<datasize; i+=8) + { + count = datasize - i; if (count > 8) count = 8; + for (j=0; j<count; j++) data[i+j] = ((init(i>>3) & (1<<j)) == 0) ? 0 : 1; + //for (j=0; j<count; j++) cout << (char)(data[i+j] + '0'); cout << endl; + } + } + + r_Conv_PNG *png = NULL; + char *dest = NULL; + + try + { + r_convDesc desc; + int destsize; + int status = -1; + + png = new r_Conv_PNG(data, interv, baseType); + desc = png->convertTo(); + destsize = desc.destInterv[0].high() - desc.destInterv[0].low() + 1; + cout << "\tConverted to PNG, domain " << desc.destInterv << endl; + dest = desc.dest; + r_Minterval destInterv(desc.destInterv); + delete desc.destType; + delete png; + png = new r_Conv_PNG(dest, destInterv, r_Convertor::ctype_char); + desc = png->convertFrom(); + cout << "\tConverted from PNG, domain " << desc.destInterv << endl; + + if (interv == desc.destInterv) + status = memcmp(data, desc.dest, datasize); + + delete png; + delete [] data; + free(dest); + free(desc.dest); + delete desc.destType; + + if (status != 0) + { + cout << "\t!!! Data not identical !!!" << endl; + } + + return 0; + } + catch (r_Error &err) + { + cerr << "Error: " << err.what() << endl; + + delete [] data; + if (dest != NULL) free(dest); + if (png != NULL) delete png; + + return -1; + } +} + +int main(int argc, char *argv[]) +{ + int i; + char pngfile[256] = ""; + + i = 1; + while (i < argc) + { + if (strcmp(argv[i], "-file") == 0) + { + strcpy(pngfile, argv[++i]); + } + i++; + } + + if (pngfile[0] == '\0') + { + // No PNG-file given, standard test-suite + test_picture(400, 300, 1, init_identity); + test_picture(400, 300, 8, init_identity); + test_picture(400, 300, 24, init_identity); + test_picture(701, 333, 1, init_square); + test_picture(701, 333, 8, init_square); + test_picture(701, 333, 24, init_square); + test_picture(3007, 3999, 1, init_sine); + test_picture(3007, 3999, 8, init_sine); + test_picture(3007, 3999, 24, init_sine); + } + else + { + // Work on this file + FILE *fp; + size_t fsize; + char *data; + r_convDesc desc; + r_Conv_PNG *png; + r_Type *baseType; + + if ((fp = fopen(pngfile, "rb")) == NULL) + { + cerr << "Unable to open input file" << endl; + return -1; + } + fseek(fp, 0, SEEK_END); fsize = ftell(fp); fseek(fp, 0, SEEK_SET); + + data = new char[fsize]; + fread(data, 1, fsize, fp); + fclose(fp); + + png = NULL; baseType = NULL; + try + { + r_Minterval interv(1); + interv << r_Sinterval((r_Range)0, (r_Range)fsize-1); + + png = new r_Conv_PNG(data, interv, r_Convertor::ctype_char); + cout << "Converting file <" << pngfile << "> to MDD..." << endl; + desc = png->convertFrom(); + + cout << "Resulting domain " << desc.destInterv << ", "; + desc.destType->print_status(); + cout << endl; + + interv = r_Minterval(desc.destInterv); + + delete [] data; + data = desc.dest; + baseType = desc.destType; + delete png; + + fsize = (interv[0].high() - interv[0].low() + 1) * (interv[1].high() - interv[1].low() + 1); + + png = new r_Conv_PNG(data, interv, baseType); + cout << "Converting MDD back to PNG..." << endl; + desc = png->convertTo(); + + cout << "Resulting domain " << desc.destInterv << ", "; + desc.destType->print_status(); + cout << endl; + + fp = fopen("result.png", "wb"); + fwrite(desc.dest, 1, (desc.destInterv[0].high() - desc.destInterv[0].low() + 1), fp); + fclose(fp); + + delete baseType; + + free(data); + free(desc.dest); + delete desc.destType; + delete png; + } + catch (r_Error &err) + { + cerr << "Conversion failed: " << err.what() << endl; + if (baseType != NULL) delete baseType; + if (data != NULL) delete [] data; + if (png != NULL) delete png; + } + } + + return 0; +} diff --git a/conversion/test/test_vff.cc b/conversion/test/test_vff.cc new file mode 100644 index 0000000..e3d6016 --- /dev/null +++ b/conversion/test/test_vff.cc @@ -0,0 +1,169 @@ +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include <iostream> + +#ifdef EARLY_TEMPLATE +#define __EXECUTABLE__ +#endif + +#include "conversion/vff.hh" +#include "raslib/rminit.hh" +#include "raslib/basetype.hh" + +#ifdef __GNUG__ +#include "rasodmg/transaction.hh" +#include "raslib/template_inst.hh" +#else +RMINITGLOBALS('C') +#endif + + + +static void PrintUsage(const char *name) +{ + cout << "Usage: " << name << " [-o <vffoutfile> -p <params> -h] <vffinfile>" << endl; +} + + +int main(int argc, char *argv[]) +{ + const char *infile=NULL; + const char *outfile=NULL; + const char *params=NULL; + int i; + + i=1; + while (i<argc) + { + if (argv[i][0] == '-') + { + switch (argv[i][1]) + { + case 'o': + outfile = argv[++i]; break; + case 'p': + params = argv[++i]; break; + case 'h': + PrintUsage(argv[0]); exit(0); + default: + cerr << "Unknown switch " << argv[i] << endl; + break; + } + } + else + { + if (infile != NULL) + cerr << "More than one input file, ignored" << endl; + else + infile = argv[i]; + } + i++; + } + + if (infile == NULL) + { + PrintUsage(argv[0]); + exit(-1); + } + + FILE *fp; + if ((fp = fopen(infile, "rb")) == NULL) + { + cerr << "Unable to open input file " << infile << endl; + return -1; + } + + size_t fsize; + char *data; + + fseek(fp, 0, SEEK_END); + fsize = ftell(fp); + + if ((data = new char[fsize]) == NULL) + { + cerr << "Unable to claim memory for file" << endl; + fclose(fp); + return -1; + } + fseek(fp, 0, SEEK_SET); + fread(data, 1, fsize, fp); + fclose(fp); + + r_Minterval interv(1); + interv << r_Sinterval((r_Range)0, (r_Range)fsize-1); + r_Conv_VFF conv(data, interv, r_Convertor::ctype_char); + r_convDesc desc; + + cout << "Convert from VFF... " << flush; + try + { + desc = conv.convertFrom(params); + cout << "OK" << endl; + + r_Conv_VFF convb(desc.dest, desc.destInterv, desc.destType); + r_convDesc descb; + + cout << "Convert back to VFF... " << flush; + try + { + descb = convb.convertTo(params); + cout << "OK" << endl; + + if (outfile != NULL) + { + if ((fp = fopen(outfile, "wb")) == NULL) + { + cerr << "Unable to write to file " << outfile << endl; + } + else + { + fsize = (size_t)(descb.destInterv[0].high() - descb.destInterv[0].low() + 1); + fwrite(descb.dest, 1, fsize, fp); + fclose(fp); + } + } + + // endianness-safe comparison of binary data: + // convert the just created VFF data back to an MDD and compare the + // result with the first MDD thus converted. + r_Conv_VFF convc(descb.dest, descb.destInterv, descb.destType); + r_convDesc descc; + + cout << "Compare binary data... " << flush; + try + { + descc = convc.convertFrom(params); + if (memcmp(descc.dest, desc.dest, desc.destInterv.cell_count() * ((r_Base_Type*)desc.destType)->size()) == 0) + cout << "identical" << endl; + else + cout << "differs!!!" << endl; + + delete descc.destType; + free(descc.dest); + } + catch (r_Error &err) + { + cerr << "failed: " << err.what() << endl; + } + + delete descb.destType; + free(descb.dest); + } + catch (r_Error &err) + { + cerr << "failed: " << err.what() << endl; + } + delete desc.destType; + free(desc.dest); + } + catch (r_Error &err) + { + cerr << "failed: " << err.what() << endl; + } + + delete [] data; + + return 0; +} |