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: */
68int test_create_img(IMG *img, int dim_x, int dim_y, int dim_z, int dim_t);
69int test_create_polarmap(IMG *img, int num_rings, int *sectors_per_ring, float *ring_position, short int *ring_angle, short int start_angle);
70int test_img_io(IMG *img);
71int test_polarmap_io(IMG *img);
72int test_modules(IMG *img);
73void print_usage();
74
75/* Verbose mode switch: */
76int VERBOSE = 0;
77
85int 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: */
105 return(0);
106
107 case 'r':
108 /* Print out the Readme message: */
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
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/******************************************************************************/
206int 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/******************************************************************************/
252int 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
313int 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);
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);
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");
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
415int 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/******************************************************************************/
514
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)
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)
int test_create_polarmap(IMG *img, int num_rings, int *sectors_per_ring, float *ring_position, short int *ring_angle, short int start_angle)
int test_modules(IMG *img)
#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)
int VERBOSE
Definition libtpcimgio.c:76
void print_usage()
void libtpcimgio_print_build(FILE *fp)
void libtpcimgio_print_readme(FILE *fp)
void libtpcimgio_print_dhistory(FILE *fp)
void libtpcimgio_print_history(FILE *fp)
void libtpcimgio_print_dreadme(FILE *fp)
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