My Project
libtpcimgio.c
Go to the documentation of this file.
1 
42 /*****************************************************************************/
43 
45 #define LIB_NAME "libtpcimgio"
46 
48 #define IMG_IO 1
49 #define POLARMAP_IO 2
50 #define MODULE 3
51 
52 /*****************************************************************************/
53 #include <stdio.h>
54 #include <stdlib.h>
55 #include <math.h>
56 #include <time.h>
57 #include <string.h>
58 #include <ctype.h>
59 /*****************************************************************************/
60 #include "libtpcmisc.h"
61 #include "include/imgio.h"
62 /*****************************************************************************/
63 
64 #define MAXVAL 100000;
65 /*****************************************************************************/
66 
67 /* Test function declarations: */
68 int test_create_img(IMG *img, int dim_x, int dim_y, int dim_z, int dim_t);
69 int test_create_polarmap(IMG *img, int num_rings, int *sectors_per_ring, float *ring_position, short int *ring_angle, short int start_angle);
70 int test_img_io(IMG *img);
71 int test_polarmap_io(IMG *img);
72 int test_modules(IMG *img);
73 void print_usage();
74 
75 /* Verbose mode switch: */
76 int VERBOSE = 0;
77 
85 int main (int argc, char *argv[ ]) {
86  int c;
87  int errflg=0, functionflag=0, exit_code=0;
88  extern char *optarg;
89  extern int optind, optopt;
90  IMG img, polarmap;
91 
92  while ((c = getopt(argc, argv, "vVbBrRhHf:F:")) != -1) {
93  switch (c) {
94 
95  case 'V':
96  case 'v':
97  /* Set verbose flag on: */
98  VERBOSE = 1;
99  break;
100 
101  case 'B':
102  case 'b':
103  /* Print out the build information: */
104  libtpcimgio_print_build(stdout);
105  return(0);
106 
107  case 'r':
108  /* Print out the Readme message: */
109  libtpcimgio_print_readme(stdout);
110  return(0);
111  case 'R':
112  /* Print out the Readme message with Doxygen tags: */
114  return(0);
115 
116  case 'h':
117  /* Print out the History message: */
119  return(0);
120  case 'H':
121  /* Print out the History message with Doxygen tags: */
123  return(0);
124 
125  case 'f':
126  case 'F':
127  /* Set function serial number to be tested: */
128  functionflag = atoi(optarg);
129  break;
130 
131  case ':': /* -f or -z without argument */
132  fprintf(stderr,"Option -%c requires an argument\n", optopt);
133  errflg++;
134  break;
135  case '?':
136  fprintf(stderr,"Unrecognised option: -%c\n", optopt);
137  errflg++;
138  }
139  }/* End parsing command line options... */
140 
141  if (errflg) {
142  print_usage();
143  return(2);
144  }
145 
146  if(!functionflag){
147  print_usage();
148  return(0);
149  }
150 
151  libtpcimgio_print_build(stdout);
152 
153  /* Make a test IMG */
154  imgInit(&img);
155  if(test_create_img(&img, 3, 4, 2, 5)) {
156  printf("cannot create test data.\n");
157  return(1);
158  }
159 
160 
161  /* Choose function(s) to test: */
162  switch(functionflag){
163  case IMG_IO:
164  exit_code = test_img_io(&img);
165  break;
166  case POLARMAP_IO:
167  {
168  int num_rings=4;
169  int sectors_per_ring[]={6,6,4,1};
170  float ring_position[]={0,0.2,0.4,0.6};
171  short int ring_angle[]={90,90,45,0};
172  short int start_angle=0;
173  imgInit(&polarmap);
174  if(test_create_polarmap(&polarmap, num_rings, sectors_per_ring, ring_position, ring_angle, start_angle)) {
175  printf("cannot create test data.\n");
176  return(1);
177  }
178  exit_code = test_polarmap_io(&polarmap);
179  }
180  imgEmpty(&polarmap);
181  break;
182  case MODULE:
183  exit_code = test_modules(&img);
184  break;
185  default:
186  fprintf(stdout,"\n NO TEST FUNCTION IMPLEMENTATIONS!\n");
187  break;
188  }
189  imgEmpty(&img);
190  printf("\n exit_code := %d\n", exit_code);
191  exit(exit_code);
192 }
193 /******************************************************************************/
194 
195 /******************************************************************************/
206 int test_create_img(IMG *img, int dim_x, int dim_y, int dim_z, int dim_t) {
207  int zi, xi, yi, fi;
208  float f=-100.0;
209 
210  if(img==NULL || img->status!=IMG_STATUS_INITIALIZED) return(1);
211  if(imgAllocate(img, dim_z, dim_y, dim_x, dim_t)){
212  printf(" \nError in image allocation: imgAllocate() @ img.c\n");
213  return(1);
214  }
215  img->dimt=dim_t; img->dimx=dim_x; img->dimy=dim_y; img->dimz=dim_z;
216  for(zi=0; zi<img->dimz; zi++) img->planeNumber[zi]=zi+1;
217  img->type = IMG_TYPE_IMAGE;
218  for(fi=0; fi<dim_t; fi++) {
219  if(fi==0) img->start[fi]=0.0; else img->start[fi]=img->end[fi-1];
220  img->end[fi]=(fi+1)*60.0;
221  img->mid[fi]=0.5*(img->start[fi]+img->end[fi]);
222  img->decayCorrFactor[fi]=1.0;
223  }
224  for(zi=0; zi<dim_z; zi++) {
225  f+=(float)(1000*zi);
226  for(yi=0; yi<dim_y; yi++) {
227  f+=(float)(10*yi);
228  for(xi=0; xi<dim_x; xi++) {
229  f+=(float)(xi);
230  for(fi=0; fi<dim_t; fi++) {
231  img->m[zi][yi][xi][fi]=f*(float)(1+fi);
232  }
233  }
234  }
235  }
237 
238  return(0);
239 }
240 /******************************************************************************/
252 int test_create_polarmap(IMG *img, int num_rings, int *sectors_per_ring, float *ring_position,
253  short int *ring_angle, short int start_angle) {
254  int si, fi, xi, dim_x, dim_t=1;
255  float f=1.0;
256 
257  if(img==NULL || img->status!=IMG_STATUS_INITIALIZED) return(1);
258  for(si=dim_x=0; si<num_rings; si++) dim_x+=sectors_per_ring[si];
259  if(imgAllocate(img, 1, 1, dim_x, dim_t)){
260  printf(" \nError in image allocation: imgAllocate() @ img.c\n");
261  return(1);
262  }
263  img->dimt=dim_t; img->dimx=dim_x; img->dimy=1; img->dimz=1;
264  img->type = IMG_TYPE_POLARMAP;
265  for(fi=0; fi<dim_t; fi++) {
266  if(fi==0) img->start[fi]=0.0; else img->start[fi]=img->end[fi-1];
267  img->end[fi]=(fi+1)*60.0;
268  img->mid[fi]=0.5*(img->start[fi]+img->end[fi]);
269  }
270  for(xi=0; xi<dim_x; xi++) {
271  f+=(float)(xi);
272  for(fi=0; fi<dim_t; fi++) {
273  img->m[0][0][xi][fi]=f*(float)(1+fi);
274  }
275  }
277  img->polarmap_num_rings=num_rings;
278  for(si=0; si<num_rings; si++) {
279  img->polarmap_sectors_per_ring[si]=sectors_per_ring[si];
280  img->polarmap_ring_position[si]=ring_position[si];
281  img->polarmap_ring_angle[si]=ring_angle[si];
282  }
283  img->polarmap_start_angle=start_angle;
284 
285  return(0);
286 }
287 /******************************************************************************/
288 
313 int test_img_io(IMG *img) {
314  char *fname="test_img_io", temp[FILENAME_MAX];
315  int ret;
316  IMG img2;
317  float minvalue = 0.0f;
318  float maxvalue = 0.0f;
319  float maxvalue_old = 0.0f;
320  float maxvalue_abs_old = 0.0f;
321  float minvalue_old = 0.0f;
322  float minvalue_frame_old = 0.0f;
323  float maxvalue_frame_old = 0.0f;
324 
325  printf("\n Testing IMG I/O functions\n");
326  img->type=IMG_TYPE_IMAGE;
327  /*IMG_TEST=2;*/
328  imgInit(&img2);
329  printf("\tfname := %s\n", fname);
330 
331  if(imgMax(img, &maxvalue_old)) return(110);
332  if(imgAbsMax(img, &maxvalue_abs_old)) return(111);
333  if(imgMinMax(img, &minvalue_old, &maxvalue)) return(112);
334  if(imgFrameMinMax(img, 1, &minvalue_frame_old, &maxvalue_frame_old)) return(113);
335 
336  /* ECAT7 image write and read */
337  img->_fileFormat=IMG_E7;
338  ret=imgWrite(fname, img); if(ret) return(11);
339  ret=imgRead(fname, &img2);
340  if(ret) return(12);
341  remove(fname); imgEmpty(&img2);
342  img->_fileFormat=IMG_E7_2D;
343  ret=imgWrite(fname, img); if(ret) return(13);
344  ret=imgRead(fname, &img2); if(ret) return(14);
345  remove(fname); imgEmpty(&img2);
346 
347  /* ECAT7 image values write and read testing */
348  if(imgMax(img, &maxvalue)) return(110);
349  if(maxvalue != maxvalue_old) return(110);
350  if(imgAbsMax(img, &maxvalue)) return(111);
351  if(maxvalue != maxvalue_abs_old) return(111);
352  if(imgMinMax(img, &minvalue, &maxvalue)) return(112);
353  if(minvalue != minvalue_old) return(112);
354  if(imgFrameMinMax(img, 1, &minvalue, &maxvalue)) return(113);
355  if(minvalue != minvalue_frame_old) return(113);
356  if(maxvalue != maxvalue_frame_old) return(113);
357 
358  /* ECAT6 image volume write and read */
359  img->_fileFormat=IMG_E63;
360  ret=imgWrite(fname, img); if(ret) return(21);
361  ret=imgRead(fname, &img2); if(ret) return(22);
362  remove(fname); imgEmpty(&img2);
363 
364  /* Analyze image volume write and read */
365  img->_fileFormat=IMG_ANA; /*ANALYZE_TEST=IMG_TEST=4;*/
366  ret=imgWrite(fname, img); if(ret) return(31);
367  ret=imgRead(fname, &img2); if(ret) return(32);
368  sprintf(temp, "%s.hdr", fname); remove(temp);
369  sprintf(temp, "%s.img", fname); remove(temp);
370  imgEmpty(&img2);
371  img->_fileFormat=IMG_ANA_L;
372  ret=imgWrite(fname, img); if(ret) return(33);
373  ret=imgRead(fname, &img2); if(ret) return(34);
374  sprintf(temp, "%s.hdr", fname); remove(temp);
375  sprintf(temp, "%s.img", fname); remove(temp);
376  imgEmpty(&img2);
377  return(0);
378 }
379 /******************************************************************************/
380 
388  char *fname="test_polarmap_io";
389  int ret;
390  IMG img2;
391 
392  printf("\n Testing POLARMAP IMG I/O functions\n");
393  img->type=IMG_TYPE_POLARMAP;
394  /*IMG_TEST=2;*/
395  imgInit(&img2);
396  printf("\tfname := %s\n", fname);
397 
398  /* ECAT7 image write and read */
400  ret=imgWrite(fname, img); if(ret) return(11);
401  ret=imgRead(fname, &img2); if(ret) return(12);
402  remove(fname); imgEmpty(&img2);
403 
404  return(0);
405 }
406 
407 /******************************************************************************/
408 
415 int test_modules(IMG *img) {
416  char test_str[256] = {0};
417  int i = 0;
418 #ifndef __STRICT_ANSI__
420  struct tm *st;
421  time_t lt;
422 #endif
423 
424  /* testing because of change into ANSI */
425  #define TEST_WITH_FILENAME(filename,desired_length,error_value) \
426  sprintf(test_str,filename); \
427  anaRemoveFNameExtension(test_str); \
428  i = 0; \
429  while(test_str[i] != 0) i++; \
430  if(i != desired_length) return(error_value); \
431  memset(test_str,0,256); \
432  \
433 
434  TEST_WITH_FILENAME("filename.img",8,1)
435  TEST_WITH_FILENAME("filename.hdr",8,2)
436  TEST_WITH_FILENAME("filename.sif",8,3)
437  TEST_WITH_FILENAME("filename.img.sif",12,4)
438  TEST_WITH_FILENAME("filename.img.hdr",12,5)
439  TEST_WITH_FILENAME("filename.dat",8,6)
440  TEST_WITH_FILENAME("filename",8,7)
441  TEST_WITH_FILENAME("filename.IMG",8,8)
442  TEST_WITH_FILENAME("filename.HDR",8,9)
443  TEST_WITH_FILENAME("filename.SIF",8,10)
444  TEST_WITH_FILENAME("filename.IMG.SIF",12,11)
445  TEST_WITH_FILENAME("filename.IMG.HDR",12,12)
446  TEST_WITH_FILENAME("filename.DAT",8,13)
447  TEST_WITH_FILENAME("filename",8,14)
448  TEST_WITH_FILENAME("filename.",8,15)
449 
450  #define TEST_WITH_FORMAT(filename,desired_format,error_value) \
451  img->_fileFormat = IMG_UNKNOWN; \
452  sprintf(test_str,filename); \
453  imgFormatFromFName(img, test_str); \
454  if(img->_fileFormat != desired_format) return(error_value); \
455  memset(test_str,0,256); \
456  \
457 
458  TEST_WITH_FORMAT("filename.img",IMG_E63,16)
459  TEST_WITH_FORMAT("filename.scn",IMG_E63,17)
460  TEST_WITH_FORMAT("filename.nrm",IMG_E63,18)
461  TEST_WITH_FORMAT("filename.atn",IMG_E63,19)
462  TEST_WITH_FORMAT("filename.hdr",IMG_ANA,20)
463  TEST_WITH_FORMAT("filename.img.hdr",IMG_ANA,21)
464  TEST_WITH_FORMAT("filename.polmap",IMG_POLARMAP,22)
465  TEST_WITH_FORMAT("filename.img.polmap",IMG_POLARMAP,23)
466  TEST_WITH_FORMAT("filename",IMG_ANA,24)
467  TEST_WITH_FORMAT("filename.v",IMG_E7,25)
468  TEST_WITH_FORMAT("filename.dat",IMG_E7,26)
469  img->_fileFormat = -1;
470  sprintf(test_str,"filename.dat"); \
471  imgFormatFromFName(img, test_str);
472  if(img->_fileFormat != IMG_E7) return(27);
473 
474 #ifndef __STRICT_ANSI__
475  /* test that time converts properly should be 1.1.1970 00:00:00
476  *
477  * This test should be run with different timezone settings at
478  * operating system
479  */
480  h.scan_start_time = 0;
481  imgGetEcat7MHeader(img, &h);
482  lt = (time_t)img->scanStart;
483  st = localtime(&lt);
484  if(st->tm_hour != 0) {
485  printf("hour:%d\n",st->tm_hour);
486  return(28);
487  }
488  /* test that value is 1.2.1999 12:23:35 stays as it was */
489  st->tm_year = 99;
490  st->tm_mon = 2;
491  st->tm_mday = 1;
492  st->tm_hour = 12;
493  st->tm_min = 23;
494  st->tm_sec = 35;
495  lt = mktime(st);
496  h.scan_start_time = lt;
497  imgGetEcat7MHeader(img, &h);
498  lt = (time_t)img->scanStart;
499  st = localtime(&lt);
500  if(st->tm_year != 99 || st->tm_mon != 2 ||
501  st->tm_mday != 1 || st->tm_hour != 12 ||
502  st->tm_min != 23 || st->tm_sec != 35) {
503  return(29);
504  }
505 #endif
506  return 0;
507 }
508 
509 /******************************************************************************/
513 void print_usage(){
514 
515  libtpcimgio_print_build(stdout);
516 
517  puts("\n"
518  " Methods for testing functions in the library "LIB_NAME"\n"
519  " and for printing out associated information, such as Readme,\n"
520  " History and build information. \n"
521  "\n"
522  " Usage: "LIB_NAME" [-Options]\n"
523  "\n"
524  " Options:\n"
525  " -h | H \n"
526  " Print out the "LIB_NAME" History message. Include Doxygen style tags\n"
527  " by using option '-H'.\n"
528  " -r | R \n"
529  " Print out the "LIB_NAME" Readme message. Include Doxygen style tags\n"
530  " by using option '-R'.\n"
531  " -b\n");
532  puts(" Print out the "LIB_NAME" build information.\n"
533  " -f <function serial number>\n"
534  " Runs test procedures for the functions corresponding to given\n"
535  " 'function serial number'. Serial numbers are defined in file\n"
536  " libtpcimgio.c.\n"
537  " -v\n"
538  " Run in verbose mode.\n"
539  "\n"
540  " E.g.: "LIB_NAME" -h\n"
541  " "LIB_NAME" -v -f 1 \n"
542  " "LIB_NAME" -v -f ${IMGTRANSFORM} -z 4 \n"
543  "\n");
544 
545  fflush(stdout);
546 }
int imgAllocate(IMG *image, int planes, int rows, int columns, int frames)
Definition: img.c:285
void imgEmpty(IMG *image)
Definition: img.c:216
void imgInit(IMG *image)
Definition: img.c:163
#define IMG_E7
Definition: img.h:86
#define IMG_ANA_L
Definition: img.h:90
#define IMG_E7_2D
Definition: img.h:87
#define IMG_TYPE_POLARMAP
Definition: img.h:82
#define IMG_STATUS_INITIALIZED
Definition: img.h:72
#define IMG_E63
Definition: img.h:85
#define IMG_ANA
Definition: img.h:89
#define IMG_POLARMAP
Definition: img.h:88
#define IMG_TYPE_IMAGE
Definition: img.h:80
void imgGetEcat7MHeader(IMG *img, ECAT7_mainheader *h)
Definition: img_e7.c:681
int imgRead(const char *fname, IMG *img)
Definition: imgfile.c:190
int imgWrite(const char *fname, IMG *img)
Definition: imgfile.c:277
int imgFrameMinMax(IMG *img, int frame, float *minvalue, float *maxvalue)
Definition: imgmax.c:147
int imgAbsMax(IMG *img, float *maxvalue)
Definition: imgmax.c:86
int imgMinMax(IMG *img, float *minvalue, float *maxvalue)
Definition: imgmax.c:115
int imgMax(IMG *img, float *maxvalue)
Definition: imgmax.c:57
@ IMGUNIT_KBQ_PER_ML
Definition: imgunit.h:22
int test_img_io(IMG *img)
Definition: libtpcimgio.c:313
int main(int argc, char *argv[])
Definition: libtpcimgio.c:85
#define TEST_WITH_FORMAT(filename, desired_format, error_value)
#define MODULE
Definition: libtpcimgio.c:50
#define IMG_IO
Definition: libtpcimgio.c:48
int test_polarmap_io(IMG *img)
Definition: libtpcimgio.c:387
int test_create_polarmap(IMG *img, int num_rings, int *sectors_per_ring, float *ring_position, short int *ring_angle, short int start_angle)
Definition: libtpcimgio.c:252
int test_modules(IMG *img)
Definition: libtpcimgio.c:415
#define LIB_NAME
Definition: libtpcimgio.c:45
#define POLARMAP_IO
Definition: libtpcimgio.c:49
#define TEST_WITH_FILENAME(filename, desired_length, error_value)
int test_create_img(IMG *img, int dim_x, int dim_y, int dim_z, int dim_t)
Definition: libtpcimgio.c:206
int VERBOSE
Definition: libtpcimgio.c:76
void print_usage()
Definition: libtpcimgio.c:513
void libtpcimgio_print_build(FILE *fp)
Definition: libtpcimgiov.c:442
void libtpcimgio_print_readme(FILE *fp)
Definition: libtpcimgiov.c:135
void libtpcimgio_print_dhistory(FILE *fp)
Definition: libtpcimgiov.c:431
void libtpcimgio_print_history(FILE *fp)
Definition: libtpcimgiov.c:242
void libtpcimgio_print_dreadme(FILE *fp)
Definition: libtpcimgiov.c:419
Definition: img.h:156
int polarmap_num_rings
Definition: img.h:239
unsigned short int dimx
Definition: img.h:261
char type
Definition: img.h:198
short int polarmap_start_angle
Definition: img.h:252
float **** m
Definition: img.h:274
char unit
Definition: img.h:172
char status
Definition: img.h:164
time_t scanStart
Definition: img.h:186
int _fileFormat
Definition: img.h:229
unsigned short int dimt
Definition: img.h:259
int * planeNumber
Definition: img.h:284
float * start
Definition: img.h:290
unsigned short int dimz
Definition: img.h:265
int polarmap_sectors_per_ring[MAX_POLARMAP_NUM_RINGS]
Definition: img.h:244
unsigned short int dimy
Definition: img.h:263
float * end
Definition: img.h:292
float * decayCorrFactor
Definition: img.h:314
short int polarmap_ring_angle[MAX_POLARMAP_NUM_RINGS]
Definition: img.h:250
float * mid
Definition: img.h:294
float polarmap_ring_position[MAX_POLARMAP_NUM_RINGS]
Definition: img.h:247
int scan_start_time
Definition: ecat7.h:117