libtpcimgio.c
Go to the documentation of this file.
00001 
00042 /*****************************************************************************/
00043 
00045 #define LIB_NAME "libtpcimgio"
00046 
00048 #define IMG_IO 1
00049 #define POLARMAP_IO 2
00050 #define MODULE 3
00051 
00052 /*****************************************************************************/
00053 #include <stdio.h>
00054 #include <stdlib.h>
00055 #include <math.h>
00056 #include <time.h>
00057 #include <string.h>
00058 #include <ctype.h>
00059 /*****************************************************************************/
00060 #include "libtpcmisc.h"
00061 #include "include/imgio.h"
00062 /*****************************************************************************/
00063 
00064 #define MAXVAL 100000;
00065 /*****************************************************************************/
00066 
00067 /* Test function declarations: */
00068 int test_create_img(IMG *img, int dim_x, int dim_y, int dim_z, int dim_t);
00069 int test_create_polarmap(IMG *img, int num_rings, int *sectors_per_ring, float *ring_position, short int *ring_angle, short int start_angle);
00070 int test_img_io(IMG *img);
00071 int test_polarmap_io(IMG *img);
00072 int test_modules(IMG *img);
00073 void print_usage();
00074 
00075 /* Verbose mode switch: */
00076 int VERBOSE = 0;
00077 
00085 int main (int argc, char *argv[ ]) {
00086     int c;
00087     int errflg=0, functionflag=0, exit_code=0;
00088     extern char *optarg;
00089     extern int optind, optopt;
00090     IMG img, polarmap;
00091 
00092     while ((c = getopt(argc, argv, "vVbBrRhHf:F:")) != -1) {
00093       switch (c) {
00094 
00095       case 'V':
00096       case 'v':
00097   /* Set verbose flag on: */
00098   VERBOSE = 1;
00099   break;
00100 
00101       case 'B':
00102       case 'b':
00103   /* Print out the build information: */
00104   libtpcimgio_print_build(stdout);
00105   return(0);
00106 
00107       case 'r':
00108   /* Print out the Readme message: */
00109   libtpcimgio_print_readme(stdout);
00110   return(0);
00111       case 'R':
00112   /* Print out the Readme message with Doxygen tags: */
00113   libtpcimgio_print_dreadme(stdout);
00114   return(0);
00115 
00116       case 'h':
00117   /* Print out the History message: */
00118   libtpcimgio_print_history(stdout);
00119   return(0);
00120       case 'H':
00121   /* Print out the History message with Doxygen tags: */
00122   libtpcimgio_print_dhistory(stdout);
00123   return(0);
00124 
00125       case 'f':
00126       case 'F':
00127   /* Set function serial number to be tested: */
00128   functionflag = atoi(optarg);
00129   break;
00130 
00131       case ':': /* -f or -z without argument */
00132   fprintf(stderr,"Option -%c requires an argument\n", optopt);
00133   errflg++;
00134   break;
00135       case '?':
00136   fprintf(stderr,"Unrecognised option: -%c\n", optopt);
00137   errflg++;
00138       }
00139     }/* End parsing command line options... */
00140 
00141     if (errflg) {
00142       print_usage();
00143       return(2);
00144     }
00145 
00146     if(!functionflag){
00147       print_usage();
00148       return(0);
00149     }
00150 
00151     libtpcimgio_print_build(stdout);
00152 
00153     /* Make a test IMG */
00154     imgInit(&img);
00155     if(test_create_img(&img, 3, 4, 2, 5)) {
00156       printf("cannot create test data.\n");
00157       return(1);
00158     }
00159 
00160 
00161     /* Choose function(s) to test: */
00162     switch(functionflag){
00163     case IMG_IO:
00164       exit_code = test_img_io(&img);
00165       break;
00166     case POLARMAP_IO:
00167       {
00168       int num_rings=4;
00169       int sectors_per_ring[]={6,6,4,1};
00170       float ring_position[]={0,0.2,0.4,0.6};
00171       short int ring_angle[]={90,90,45,0};
00172       short int start_angle=0;
00173       imgInit(&polarmap);
00174       if(test_create_polarmap(&polarmap, num_rings, sectors_per_ring, ring_position, ring_angle, start_angle)) {
00175         printf("cannot create test data.\n");
00176         return(1);
00177       }
00178       exit_code = test_polarmap_io(&polarmap);
00179       }
00180       imgEmpty(&polarmap);
00181       break;
00182     case MODULE:
00183       exit_code = test_modules(&img);
00184       break;
00185     default:
00186       fprintf(stdout,"\n    NO TEST FUNCTION IMPLEMENTATIONS!\n");
00187       break;
00188     }
00189     imgEmpty(&img);
00190     printf("\n exit_code := %d\n", exit_code);
00191     exit(exit_code);
00192 }
00193 /******************************************************************************/
00194 
00195 /******************************************************************************/
00206 int test_create_img(IMG *img, int dim_x, int dim_y, int dim_z, int dim_t) {
00207   int zi, xi, yi, fi;
00208   float f=-100.0;
00209 
00210   if(img==NULL || img->status!=IMG_STATUS_INITIALIZED) return(1);
00211   if(imgAllocate(img, dim_z, dim_y, dim_x, dim_t)){
00212     printf("    \nError in image allocation: imgAllocate() @ img.c\n");
00213     return(1);
00214   }
00215   img->dimt=dim_t; img->dimx=dim_x; img->dimy=dim_y; img->dimz=dim_z;
00216   for(zi=0; zi<img->dimz; zi++) img->planeNumber[zi]=zi+1;
00217   img->type = IMG_TYPE_IMAGE;
00218   for(fi=0; fi<dim_t; fi++) {
00219     if(fi==0) img->start[fi]=0.0; else img->start[fi]=img->end[fi-1];
00220     img->end[fi]=(fi+1)*60.0;
00221     img->mid[fi]=0.5*(img->start[fi]+img->end[fi]);
00222     img->decayCorrFactor[fi]=1.0;
00223   }
00224   for(zi=0; zi<dim_z; zi++) {
00225     f+=(float)(1000*zi);
00226     for(yi=0; yi<dim_y; yi++) {
00227       f+=(float)(10*yi);
00228       for(xi=0; xi<dim_x; xi++) {
00229         f+=(float)(xi);
00230         for(fi=0; fi<dim_t; fi++) {
00231           img->m[zi][yi][xi][fi]=f*(float)(1+fi);
00232         }
00233       }
00234     }
00235   }
00236   img->unit=IMGUNIT_KBQ_PER_ML;
00237 
00238   return(0);
00239 }
00240 /******************************************************************************/
00252 int test_create_polarmap(IMG *img, int num_rings, int *sectors_per_ring, float *ring_position,
00253        short int *ring_angle, short int start_angle) {
00254   int si, fi, xi, dim_x, dim_t=1;
00255   float f=1.0;
00256 
00257   if(img==NULL || img->status!=IMG_STATUS_INITIALIZED) return(1);
00258   for(si=dim_x=0; si<num_rings; si++) dim_x+=sectors_per_ring[si];
00259   if(imgAllocate(img, 1, 1, dim_x, dim_t)){
00260     printf("    \nError in image allocation: imgAllocate() @ img.c\n");
00261     return(1);
00262   }
00263   img->dimt=dim_t; img->dimx=dim_x; img->dimy=1; img->dimz=1;
00264   img->type = IMG_TYPE_POLARMAP;
00265   for(fi=0; fi<dim_t; fi++) {
00266     if(fi==0) img->start[fi]=0.0; else img->start[fi]=img->end[fi-1];
00267     img->end[fi]=(fi+1)*60.0;
00268     img->mid[fi]=0.5*(img->start[fi]+img->end[fi]);
00269   }
00270   for(xi=0; xi<dim_x; xi++) {
00271     f+=(float)(xi);
00272     for(fi=0; fi<dim_t; fi++) {
00273       img->m[0][0][xi][fi]=f*(float)(1+fi);
00274     }
00275   }
00276   img->unit=IMGUNIT_KBQ_PER_ML;
00277   img->polarmap_num_rings=num_rings;
00278   for(si=0; si<num_rings; si++) {
00279     img->polarmap_sectors_per_ring[si]=sectors_per_ring[si];
00280     img->polarmap_ring_position[si]=ring_position[si];
00281     img->polarmap_ring_angle[si]=ring_angle[si];
00282   }
00283   img->polarmap_start_angle=start_angle;
00284 
00285   return(0);
00286 }
00287 /******************************************************************************/
00288 
00313 int test_img_io(IMG *img) {
00314   char *fname="test_img_io", temp[FILENAME_MAX];
00315   int ret;
00316   IMG img2;
00317   float minvalue = 0.0f;
00318   float maxvalue = 0.0f;
00319   float maxvalue_old = 0.0f;
00320   float maxvalue_abs_old = 0.0f;
00321   float minvalue_old = 0.0f;
00322   float minvalue_frame_old = 0.0f;
00323   float maxvalue_frame_old = 0.0f;
00324 
00325   printf("\n Testing IMG I/O functions\n");
00326   img->type=IMG_TYPE_IMAGE;
00327   /*IMG_TEST=2;*/
00328   imgInit(&img2);
00329   printf("\tfname := %s\n", fname);
00330 
00331   if(imgMax(img, &maxvalue_old)) return(110);
00332   if(imgAbsMax(img, &maxvalue_abs_old)) return(111);
00333   if(imgMinMax(img, &minvalue_old, &maxvalue)) return(112);
00334   if(imgFrameMinMax(img, 1, &minvalue_frame_old, &maxvalue_frame_old)) return(113);
00335 
00336   /* ECAT7 image write and read */
00337   img->_fileFormat=IMG_E7;
00338   ret=imgWrite(fname, img); if(ret) return(11);
00339   ret=imgRead(fname, &img2);
00340   if(ret) return(12);
00341   remove(fname); imgEmpty(&img2);
00342   img->_fileFormat=IMG_E7_2D;
00343   ret=imgWrite(fname, img); if(ret) return(13);
00344   ret=imgRead(fname, &img2); if(ret) return(14);
00345   remove(fname); imgEmpty(&img2);
00346 
00347   /* ECAT7 image values write and read testing */
00348   if(imgMax(img, &maxvalue)) return(110);
00349   if(maxvalue != maxvalue_old) return(110);
00350   if(imgAbsMax(img, &maxvalue)) return(111);
00351   if(maxvalue != maxvalue_abs_old) return(111);
00352   if(imgMinMax(img, &minvalue, &maxvalue)) return(112);
00353   if(minvalue != minvalue_old) return(112);
00354   if(imgFrameMinMax(img, 1, &minvalue, &maxvalue)) return(113);
00355   if(minvalue != minvalue_frame_old) return(113);
00356   if(maxvalue != maxvalue_frame_old) return(113);
00357 
00358   /* ECAT6 image volume write and read */
00359   img->_fileFormat=IMG_E63;
00360   ret=imgWrite(fname, img); if(ret) return(21);
00361   ret=imgRead(fname, &img2); if(ret) return(22);
00362   remove(fname); imgEmpty(&img2);
00363 
00364   /* Analyze image volume write and read */
00365   img->_fileFormat=IMG_ANA; /*ANALYZE_TEST=IMG_TEST=4;*/
00366   ret=imgWrite(fname, img); if(ret) return(31);
00367   ret=imgRead(fname, &img2); if(ret) return(32);
00368   sprintf(temp, "%s.hdr", fname); remove(temp);
00369   sprintf(temp, "%s.img", fname); remove(temp);
00370   imgEmpty(&img2);
00371   img->_fileFormat=IMG_ANA_L;
00372   ret=imgWrite(fname, img); if(ret) return(33);
00373   ret=imgRead(fname, &img2); if(ret) return(34);
00374   sprintf(temp, "%s.hdr", fname); remove(temp);
00375   sprintf(temp, "%s.img", fname); remove(temp);
00376   imgEmpty(&img2);
00377   return(0);
00378 }
00379 /******************************************************************************/
00380 
00387 int test_polarmap_io(IMG *img) {
00388   char *fname="test_polarmap_io";
00389   int ret;
00390   IMG img2;
00391 
00392   printf("\n Testing POLARMAP IMG I/O functions\n");
00393   img->type=IMG_TYPE_POLARMAP;
00394   /*IMG_TEST=2;*/
00395   imgInit(&img2);
00396   printf("\tfname := %s\n", fname); 
00397 
00398   /* ECAT7 image write and read */
00399   img->_fileFormat=IMG_POLARMAP;
00400   ret=imgWrite(fname, img); if(ret) return(11);
00401   ret=imgRead(fname, &img2); if(ret) return(12);
00402   remove(fname); imgEmpty(&img2);
00403 
00404   return(0);
00405 }
00406 
00407 /******************************************************************************/
00408 
00415 int test_modules(IMG *img) {
00416     char test_str[256] = {0};
00417   int i = 0;
00418 #ifndef __STRICT_ANSI__
00419         ECAT7_mainheader h;
00420     struct tm *st;
00421   time_t lt;
00422 #endif
00423 
00424   /* testing because of change into ANSI */
00425   #define TEST_WITH_FILENAME(filename,desired_length,error_value) \
00426   sprintf(test_str,filename); \
00427   anaRemoveFNameExtension(test_str); \
00428   i = 0; \
00429   while(test_str[i] != 0) i++; \
00430   if(i != desired_length) return(error_value); \
00431   memset(test_str,0,256); \
00432   \
00433 
00434         TEST_WITH_FILENAME("filename.img",8,1)
00435   TEST_WITH_FILENAME("filename.hdr",8,2)
00436   TEST_WITH_FILENAME("filename.sif",8,3)
00437   TEST_WITH_FILENAME("filename.img.sif",12,4)
00438   TEST_WITH_FILENAME("filename.img.hdr",12,5)
00439   TEST_WITH_FILENAME("filename.dat",8,6)
00440   TEST_WITH_FILENAME("filename",8,7)
00441         TEST_WITH_FILENAME("filename.IMG",8,8)
00442   TEST_WITH_FILENAME("filename.HDR",8,9)
00443   TEST_WITH_FILENAME("filename.SIF",8,10)
00444   TEST_WITH_FILENAME("filename.IMG.SIF",12,11)
00445   TEST_WITH_FILENAME("filename.IMG.HDR",12,12)
00446   TEST_WITH_FILENAME("filename.DAT",8,13)
00447   TEST_WITH_FILENAME("filename",8,14)
00448   TEST_WITH_FILENAME("filename.",8,15)
00449 
00450   #define TEST_WITH_FORMAT(filename,desired_format,error_value) \
00451   img->_fileFormat = IMG_UNKNOWN; \
00452         sprintf(test_str,filename); \
00453   imgFormatFromFName(img, test_str); \
00454   if(img->_fileFormat != desired_format) return(error_value); \
00455   memset(test_str,0,256); \
00456   \
00457 
00458   TEST_WITH_FORMAT("filename.img",IMG_E63,16)
00459   TEST_WITH_FORMAT("filename.scn",IMG_E63,17)
00460   TEST_WITH_FORMAT("filename.nrm",IMG_E63,18)
00461   TEST_WITH_FORMAT("filename.atn",IMG_E63,19)
00462   TEST_WITH_FORMAT("filename.hdr",IMG_ANA,20)
00463   TEST_WITH_FORMAT("filename.img.hdr",IMG_ANA,21)
00464   TEST_WITH_FORMAT("filename.polmap",IMG_POLARMAP,22)
00465   TEST_WITH_FORMAT("filename.img.polmap",IMG_POLARMAP,23)
00466   TEST_WITH_FORMAT("filename",IMG_ANA,24)
00467   TEST_WITH_FORMAT("filename.v",IMG_E7,25)
00468   TEST_WITH_FORMAT("filename.dat",IMG_E7,26)
00469   img->_fileFormat = -1;
00470   sprintf(test_str,"filename.dat"); \
00471         imgFormatFromFName(img, test_str);
00472         if(img->_fileFormat != IMG_E7) return(27);
00473 
00474 #ifndef __STRICT_ANSI__
00475   /* test that time converts properly should be 1.1.1970 00:00:00
00476    *
00477    * This test should be run with different timezone settings at
00478    * operating system
00479    */
00480   h.scan_start_time = 0;
00481   imgGetEcat7MHeader(img, &h);
00482         lt = (time_t)img->scanStart;
00483         st = localtime(&lt);
00484   if(st->tm_hour != 0) {
00485     printf("hour:%d\n",st->tm_hour);
00486     return(28);
00487   }
00488   /* test that value is 1.2.1999 12:23:35 stays as it was */
00489         st->tm_year = 99;
00490   st->tm_mon = 2;
00491   st->tm_mday = 1;
00492   st->tm_hour = 12;
00493   st->tm_min = 23;
00494   st->tm_sec = 35;
00495   lt = mktime(st);
00496   h.scan_start_time = lt;
00497         imgGetEcat7MHeader(img, &h);
00498         lt = (time_t)img->scanStart;
00499         st = localtime(&lt);
00500   if(st->tm_year != 99 || st->tm_mon  !=  2 ||
00501      st->tm_mday !=  1 || st->tm_hour != 12 ||
00502      st->tm_min  != 23 || st->tm_sec  != 35) {
00503     return(29);
00504   }
00505 #endif
00506     return 0;
00507 }
00508 
00509 /******************************************************************************/
00513 void print_usage(){
00514 
00515   libtpcimgio_print_build(stdout);
00516 
00517   puts("\n"
00518        "   Methods for testing functions in the library "LIB_NAME"\n"
00519        "   and for printing out associated information, such as Readme,\n"
00520        "   History and build information. \n"
00521        "\n"
00522        "   Usage: "LIB_NAME" [-Options]\n"
00523        "\n"
00524        "   Options:\n"
00525        "   -h | H \n"
00526        "       Print out the "LIB_NAME" History message. Include Doxygen style tags\n"
00527        "       by using option '-H'.\n"
00528        "   -r | R \n"
00529        "       Print out the "LIB_NAME" Readme message. Include Doxygen style tags\n"
00530        "       by using option '-R'.\n"
00531        "   -b\n");
00532   puts("       Print out the "LIB_NAME" build information.\n"
00533        "   -f <function serial number>\n"
00534        "       Runs test procedures for the functions corresponding to given\n"
00535        "       'function serial number'. Serial numbers are defined in file\n"
00536        "       libtpcimgio.c.\n"
00537        "   -v\n"
00538        "       Run in verbose mode.\n"
00539        "\n"
00540        "   E.g.: "LIB_NAME" -h\n"
00541        "         "LIB_NAME" -v -f 1 \n"
00542        "         "LIB_NAME" -v -f ${IMGTRANSFORM} -z 4 \n"
00543        "\n");
00544 
00545   fflush(stdout);
00546 }