1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
2 * filename: m-fancy.c *
3 * *
4 * UTIL C-source: Medical Image Conversion Utility *
5 * *
6 * purpose : Nice output, edit strings & print defaults *
7 * *
8 * project : (X)MedCon by Erik Nolf *
9 * *
10 * Functions : MdcPrintLine() - Print a full or half line *
11 * MdcPrintChar() - Print a char *
12 * MdcPrintStr() - Print a string *
13 * MdcPrintBoxLine() - Print horizontal line of a box *
14 * MdcPrintYesNo() - Print Yes, No or Unknown *
15 * MdcPrintImageLayout() - Print layout of a raw image *
16 * MdcPrintValue() - Print numeric value *
17 * MdcLowStr() - Make string lower case *
18 * MdcUpStr() - Make string upper case *
19 * MdcKillSpaces() - Remove first/last spaces *
20 * MdcRemoveAllSpaces() - Remove all spaces from string *
21 * MdcRemoveEnter() - Remove <enter> from string *
22 * MdcGetStrLine() - Get string skipping comment *
23 * MdcGetStrInput() - Get string from input with '\n'*
24 * MdcGetSubStr() - Get substr between separators *
25 * MdcGetSafeString() - Copy & add terminating char *
26 * MdcPutDefault() - Get (default) answer *
27 * MdcGetRange() - Get a range from the a list *
28 * MdcHandleEcatList() - Get a list in ecat style *
29 * MdcHandleNormList() - Get a list in normal style *
30 * MdcHandlePixelList() - Get a list of pixels *
31 * MdcGetStrAcquisition() - Get string for acquisition type*
32 * MdcGetStrRawConv() - Get string of raw type *
33 * MdcGetStrEndian() - Get string of endian type *
34 * MdcGetStrCompression() - Get string of compression type *
35 * MdcGetStrPixelType() - Get string of pixel type *
36 * MdcGetStrColorMap() - Get string of colormap *
37 * MdcGetStrYesNo() - Get string "yes" or "no" *
38 * MdcGetStrSlProjection() - Get string slice projection *
39 * MdcGetStrPatSlOrient() - Get string patient/slice orient*
40 * MdcGetStrPatPos() - Get string patient position *
41 * MdcGetStrPatOrient() - Get string patient orientation *
42 * MdcGetStrSliceOrient() - Get string slice orientation *
43 * MdcGetStrRotation() - Get string rotation direction *
44 * MdcGetStrMotion() - Get string detector motion *
45 * MdcGetStrModality() - Get string modality *
46 * MdcGetStrGSpectNesting()- Get string GSPECT nesting *
47 * MdcGetStrHHMMSS() - Get string hrs:mins:secs *
48 * MdcGetIntModality() - Get int modality type *
49 * MdcGetIntSliceOrient() - Get int slice orientation *
50 * MdcGetLibLongVersion() - Get string of library version *
51 * MdcGetLibShortVersion() - Get string of short version *
52 * MdcCheckStrSize() - Check if we can add a string *
53 * MdcMakeScanInfoStr() - Make string with scan info *
54 * MdcIsDigit() - Test if char is a digit *
55 * MdcWaitForEnter() - Wait until <enter> key press *
56 * MdcGetSelectionType() - Get select type (norm,ecat,...)*
57 * MdcFlushInput() - Flush the input stream *
58 * MdcWhichDecompress() - Give supported decompression *
59 * MdcWhichCompression() - Give compression type of file *
60 * MdcAddCompressionExt() - Add compression extension *
61 * *
62 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
63 /*
64 */
65
66 /*
67 Copyright (C) 1997-2021 by Erik Nolf
68
69 This program is free software; you can redistribute it and/or modify it
70 under the terms of the GNU General Public License as published by the
71 Free Software Foundation; either version 2, or (at your option) any later
72 version.
73
74 This program is distributed in the hope that it will be useful, but
75 WITHOUT ANY WARRANTY; without even the implied warranty of
76 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
77 Public License for more details.
78
79 You should have received a copy of the GNU General Public License along
80 with this program; if not, write to the Free Software Foundation, Inc.,
81 59 Place - Suite 330, Boston, MA 02111-1307, USA. */
82
83 /****************************************************************************
84 H E A D E R S
85 ****************************************************************************/
86
87 #include "m-depend.h"
88
89 #include <stdio.h>
90 #include <ctype.h>
91 #ifdef HAVE_STDLIB_H
92 #include <stdlib.h>
93 #endif
94 #ifdef HAVE_STRING_H
95 #include <string.h>
96 #endif
97 #ifdef HAVE_STRINGS_H
98 #ifndef _WIN32
99 #include <strings.h>
100 #endif
101 #endif
102
103
104 #include "m-fancy.h"
105
106 /****************************************************************************
107 F U N C T I O N S
108 ****************************************************************************/
109
MdcPrintLine(char c,int length)110 void MdcPrintLine(char c, int length)
111 {
112 int i;
113
114 for (i=0; i<length; i++) MdcPrntScrn("%c",c);
115 MdcPrntScrn("\n");
116
117 }
118
MdcPrintChar(int c)119 void MdcPrintChar(int c)
120 {
121 if (c == '\0') MdcPrntScrn("<null>");
122 else if (c==9 || c==13 || c==10) putchar(c);
123 else if (c >= 32) putchar(c);
124 else if (c==EOF) MdcPrntScrn("<EOF>");
125 else MdcPrntScrn("<%u>",c);
126 }
127
MdcPrintStr(char * str)128 void MdcPrintStr(char *str)
129 {
130 int t=strlen(str);
131
132 if ( t == 0 ) MdcPrntScrn("<null>");
133 else MdcPrntScrn("%s",str);
134
135 MdcPrntScrn("\n");
136
137 }
138
MdcPrintBoxLine(char c,int t)139 void MdcPrintBoxLine(char c, int t)
140 {
141 int i;
142
143 MdcPrntScrn("\t\t#");
144 for (i=-1;i<=t;i++) MdcPrntScrn("%c",c);
145 MdcPrntScrn("#\n");
146
147 }
148
MdcPrintYesNo(int value)149 void MdcPrintYesNo(int value )
150 {
151 switch ( value ) {
152 case MDC_NO : MdcPrntScrn("(= No)\n"); break;
153 case MDC_YES: MdcPrntScrn("(= Yes)\n"); break;
154 default : MdcPrntScrn("(= Unknown)\n"); break;
155 }
156 }
157
MdcPrintImageLayout(FILEINFO * fi,Uint32 gen,Uint32 img,int repeat)158 void MdcPrintImageLayout(FILEINFO *fi, Uint32 gen, Uint32 img, int repeat)
159 {
160 IMG_DATA *id;
161 Uint32 i;
162
163 MdcPrintLine('-',MDC_FULL_LENGTH);
164 MdcPrntScrn("\t\t\tSUMMARY OF IMAGE FILE LAYOUT\n");
165 MdcPrintLine('-',MDC_FULL_LENGTH);
166
167 if ((gen==0) && (img==0)) MdcPrintBoxLine('-',MDC_BOX_SIZE);
168 if (gen!=0) {
169 MdcPrintBoxLine('-',MDC_BOX_SIZE);
170 MdcPrntScrn("\t\t| General Header | \t(%u)\n",gen);
171 MdcPrintBoxLine('-',MDC_BOX_SIZE);
172 }
173 for (i=0; i<fi->number; i++) {
174 id = &fi->image[i];
175 if ( ((i==0) && (img>0)) || (repeat) ) {
176 if ( ! ((i==0) && (gen>0)) )MdcPrintBoxLine('-',MDC_BOX_SIZE);
177 MdcPrntScrn("\t\t| Image Header | \t(%u)\n",img);
178 MdcPrintBoxLine('-',MDC_BOX_SIZE);
179 }
180 MdcPrntScrn("\t\t! Image #%-4u ",i+1);
181 if (fi->endian != MDC_HOST_ENDIAN) MdcPrntScrn("swap !");
182 else MdcPrntScrn(" !");
183 MdcPrntScrn("\t(%ux%ux%u)",id->width,id->height,MdcType2Bytes(id->type));
184 if (id->load_location != 0) {
185 MdcPrntScrn("\tOFFSET: %u",(Uint32)id->load_location);
186 }
187 MdcPrntScrn("\n");
188
189 }
190 MdcPrintBoxLine('-',MDC_BOX_SIZE);
191 }
192
MdcPrintValue(FILE * fp,Uint8 * pvalue,Uint16 type)193 int MdcPrintValue(FILE *fp, Uint8 *pvalue, Uint16 type)
194 {
195
196 switch (type) {
197 case BIT8_S:
198 {
199 Int8 *val = (Int8 *) pvalue;
200 fprintf(fp,"%hhd",val[0]);
201 }
202 break;
203 case BIT8_U:
204 {
205 Uint8 *val = (Uint8 *) pvalue;
206 fprintf(fp,"%hhu",val[0]);
207 }
208 break;
209 case BIT16_S:
210 {
211 Int16 *val = (Int16 *) pvalue;
212 fprintf(fp,"%hd",val[0]);
213 }
214 break;
215 case BIT16_U:
216 {
217 Uint16 *val = (Uint16 *) pvalue;
218 fprintf(fp,"%hu",val[0]);
219 }
220 break;
221 case BIT32_S:
222 {
223 Int32 *val = (Int32 *) pvalue;
224 fprintf(fp,"%d",val[0]);
225 }
226 break;
227 case BIT32_U:
228 {
229 Uint32 *val = (Uint32 *) pvalue;
230 fprintf(fp,"%d",val[0]);
231 }
232 break;
233 case BIT64_S:
234 {
235 Int64 *val = (Int64 *) pvalue;
236 fprintf(fp,"%ld",val[0]);
237 }
238 break;
239 case BIT64_U:
240 {
241 Uint64 *val = (Uint64 *) pvalue;
242 fprintf(fp,"%lu",val[0]);
243 }
244 break;
245 case FLT32:
246 {
247 float *val = (float *) pvalue;
248 fprintf(fp,"%+e",val[0]);
249 }
250 break;
251 case FLT64:
252 {
253 double *val = (double *) pvalue;
254 fprintf(fp,"%+e",val[0]);
255 }
256 break;
257 }
258
259 return(ferror(fp));
260 }
261
MdcLowStr(char * str)262 void MdcLowStr(char *str)
263 {
264 char *c;
265
266 c=str;
267
268 while(*c) { *c=tolower((int)*c); c++; }
269
270 }
271
MdcUpStr(char * str)272 void MdcUpStr(char *str)
273 {
274 char *c;
275
276 c=str;
277
278 while(*c) { *c=toupper((int)*c); c++; }
279
280 }
281
MdcKillSpaces(char string[])282 void MdcKillSpaces(char string[]) /* kill first and last spaces */
283 {
284 int i=0, shift=0, length;
285
286 length = strlen(string);
287
288 if (length > 0) {
289 /* kill the first spaces */
290 while (isspace((int)string[i])) {
291 if (i < length) {
292 i+=1; shift+=1;
293 }else break;
294 }
295 if (shift) for (i=0; i<=length; i++) string[i] = string[i+shift];
296
297 /* kill the last spaces */
298 length = strlen(string);
299 if (length > 0) {
300 i = length - 1;
301 while (isspace((int)string[i])) {
302 if (i > 0 ) {
303 string[i] = '\0'; i-=1;
304 }else break;
305 }
306 }
307 }
308 }
309
MdcRemoveAllSpaces(char string[])310 void MdcRemoveAllSpaces(char string[]) /* remove all spaces */
311 {
312 int i=0, j=0, length;
313
314 length = strlen(string);
315
316 while (i < length) {
317 if (isspace((int)string[i])) {
318 i+=1;
319 }else{
320 string[j++] = string[i++];
321 }
322 }
323
324 string[j]='\0';
325
326 }
327
328
MdcRemoveEnter(char string[])329 void MdcRemoveEnter(char string[])
330 {
331 char *p;
332
333 p = strchr(string,'\r'); if (p != NULL) p[0] = '\0';
334 p = strchr(string,'\n'); if (p != NULL) p[0] = '\0';
335
336 }
337
MdcGetStrLine(char string[],int maxchars,FILE * fp)338 void MdcGetStrLine(char string[], int maxchars, FILE *fp)
339 {
340 /* skip comment lines beginning with '#' */
341 do {
342 if (fgets(string,maxchars,fp) == NULL) return;
343 }while (string[0] == '#');
344 }
345
MdcGetStrInput(char string[],int maxchars)346 void MdcGetStrInput(char string[], int maxchars)
347 {
348 MdcGetStrLine(string,maxchars,stdin);
349 }
350
MdcGetSubStr(char * dest,char * src,int dmax,char sep,int n)351 int MdcGetSubStr(char *dest, char *src, int dmax, char sep, int n)
352 {
353 Uint32 i, b, cnt=1, length, sublength=0;
354
355 length = strlen(src);
356
357 if (length == 0) return(MDC_NO);
358
359 /* get begin substr */
360 for (b=0; b<length; b++) {
361 if (src[b] == sep) cnt+=1;
362 if (cnt == n) break;
363 }
364
365 /* n-th substr not found */
366 if (cnt != n) return(MDC_NO);
367
368 /* get length substr */
369 b+=1;
370 for (i=b; i<length; i++) {
371 if (src[i] == sep) break;
372 sublength+=1;
373 }
374
375 if ((sublength == 0) || (sublength >= dmax)) return(MDC_NO);
376
377 strncpy(dest,&src[b],sublength);
378
379 dest[sublength] = '\0';
380
381 MdcKillSpaces(dest);
382
383 return(MDC_YES);
384 }
385
MdcGetSafeString(char * dest,char * src,Uint32 length,Uint32 maximum)386 void MdcGetSafeString(char *dest, char *src, Uint32 length, Uint32 maximum)
387 {
388 Uint32 MAX = maximum - 1; /* let's be really safe */
389
390 if (length < MAX) {
391 memcpy(dest,src,length);
392 dest[length]='\0';
393 }else{
394 memcpy(dest,src,MAX);
395 dest[MAX]='\0';
396 }
397 }
398
MdcUseDefault(const char string[])399 int MdcUseDefault(const char string[])
400 {
401 /* <enter> = default */
402 if (string[0] == '\n' || string[0] == '\r') return(1);
403 return(0);
404 }
405 /* string[] = MDC_2KB_OFFSET */
MdcPutDefault(char string[])406 int MdcPutDefault(char string[]) /* 1=default or 0=no default */
407 {
408 MdcGetStrLine(string,MDC_2KB_OFFSET-1,stdin);
409 if (MdcUseDefault(string)) return(1);
410 MdcKillSpaces(string);
411 return(0);
412
413 }
414
MdcGetRange(const char * item,Uint32 * from,Uint32 * to,Uint32 * step)415 int MdcGetRange(const char *item, Uint32 *from, Uint32 *to, Uint32 *step)
416 {
417 Uint32 a1=0, a2=0, t=1;
418
419 /* read range values */
420 if (strchr(item,':') != 0 ) {
421 /* interval */
422 sscanf(item,"%u:%u:%u",&a1,&t,&a2);
423 }else if ( strstr(item,"...") != 0 ) {
424 /* range v1 */
425 sscanf(item,"%u...%u",&a1,&a2); t=1;
426 }else if ( strstr(item,"-") != 0 ) {
427 /* range v2 */
428 sscanf(item,"%u-%u",&a1,&a2); t=1;
429 }else{
430 /* single item */
431 sscanf(item,"%u",&a1); a2 = a1;
432 }
433
434 /* some sanity checks */
435 if (t == 0) t = 1;
436
437 *from = a1; *to = a2; *step = t;
438
439 return(MDC_OK);
440 }
441
MdcHandleEcatList(char * list,Uint32 ** dims,Uint32 max)442 char *MdcHandleEcatList(char *list, Uint32 **dims, Uint32 max)
443 {
444 int ITEM_FOUND=MDC_NO, REVERSED, HANDLE;
445 Uint32 a1, a2, t, i, l, length;
446 char *p, *item;
447
448 length = strlen(list);
449
450 /* <enter> default = all */
451 if (MdcUseDefault(list)) {
452 for (i=1; i<=max; i++) (*dims)[i]=MDC_YES;
453 (*dims)[0]=max;
454 return(NULL);
455 }
456
457 /* loop through string with entire list */
458 for (p=list, item=list, l=0; l<=length; l++) {
459
460 /* separate items: begins at digit, ends at space (or \t, \n, ...) */
461
462 if (ITEM_FOUND == MDC_NO) {
463
464 if (isdigit((int)p[l])) { item=&p[l]; ITEM_FOUND=MDC_YES; }
465
466 }else if (isspace((int)p[l]) || p[l]=='\0') {
467
468 p[l]='\0';
469
470 if (MdcGetRange(item,&a1,&a2,&t) != MDC_OK)
471 return("Error reading range item");
472
473 if (a1 > max) a1 = max;
474 if (a2 > max) a2 = max;
475
476 if ( (a1==0) || (a2==0) ) {
477 for (i=1; i<=max; i++) (*dims)[i]=MDC_YES;
478 (*dims)[0]=max;
479 break;
480 }
481
482 /* reversed range ? */
483 REVERSED = (a1 > a2) ? MDC_YES : MDC_NO;
484
485 /* initialize and get image numbers */
486 i = a1; HANDLE = MDC_YES;
487 do {
488
489 /* include image number */
490 if ((*dims)[i] == MDC_NO) {
491 (*dims)[i] = MDC_YES;
492 (*dims)[0] += 1;
493 }
494
495 if ((REVERSED == MDC_YES) && (i < t)) break;
496
497 /* set next image number in range */
498 i = (REVERSED == MDC_YES) ? (i-t) : (i+t);
499
500 /* check end of range */
501 if (REVERSED == MDC_YES) {
502 if (i < a2) HANDLE = MDC_NO;
503 }else{
504 if (i > a2) HANDLE = MDC_NO;
505 }
506
507 }while(HANDLE == MDC_YES);
508
509 ITEM_FOUND = MDC_NO;
510
511 }
512 }
513
514 return(NULL);
515
516 }
517
MdcHandleNormList(char * list,Uint32 ** inrs,Uint32 * it,Uint32 * bt,Uint32 max)518 char *MdcHandleNormList(char *list,Uint32 **inrs,Uint32 *it
519 ,Uint32 *bt,Uint32 max)
520 {
521 int ITEM_FOUND=MDC_NO, HANDLE, REVERSED;
522 Uint32 a1, a2, t, i, l, length;
523 char *p, *item;
524
525 length = strlen(list);
526
527 /* <enter> = default: all */
528 if (MdcUseDefault(list)) {
529 (*inrs)[1] = 0; *it = 2; return(NULL);
530 }
531
532 /* loop through string with entire list */
533 for (p=list, item=list, l=0; l<=length; l++) {
534
535 /* separate items: begins at digit, ends at space (or \t, \n, ...) */
536
537 if (ITEM_FOUND == MDC_NO) {
538
539 if (isdigit((int)p[l])) { item=&p[l]; ITEM_FOUND=MDC_YES; }
540
541 }else if (isspace((int)p[l]) || p[l]=='\0') {
542
543 p[l]='\0';
544
545 if (MdcGetRange(item,&a1,&a2,&t) != MDC_OK)
546 return("Error reading range item");
547
548 if (a1 > max) a1 = max;
549 if (a2 > max) a2 = max;
550
551 if ( (a1==0) || (a2==0) ) {
552 (*inrs)[1] = 0;
553 *it = 2;
554 return(NULL);
555 }
556
557 /* reversed range ? */
558 REVERSED = (a1 > a2) ? MDC_YES : MDC_NO;
559
560 /* initialize and get image numbers */
561 i = a1; HANDLE = MDC_YES;
562 do {
563
564 /* store image number */
565 (*inrs)[*it] = i;
566 *it += 1;
567 if ( (*it % MDC_BUF_ITMS) == 0 ) {
568 if (((*inrs)=(Uint32 *)MdcRealloc((*inrs),
569 (*bt)*MDC_BUF_ITMS*sizeof(Uint32)))==NULL){
570 return("Couldn't realloc images number buffer");
571 }
572 *bt += 1;
573 }
574
575 if ((REVERSED == MDC_YES) && (i < t)) break;
576
577 /* set next image number in range */
578 i = (REVERSED == MDC_YES) ? (i-t) : (i+t);
579
580 /* check end of range */
581 if (REVERSED == MDC_YES) {
582 if (i < a2) HANDLE = MDC_NO;
583 }else{
584 if (i > a2) HANDLE = MDC_NO;
585 }
586
587 }while (HANDLE == MDC_YES);
588
589 ITEM_FOUND = MDC_NO;
590
591 }
592
593 }
594
595 return(NULL);
596
597 }
598
MdcHandlePixelList(char * list,Uint32 ** cols,Uint32 ** rows,Uint32 * it,Uint32 * bt)599 char *MdcHandlePixelList(char *list, Uint32 **cols, Uint32 **rows,
600 Uint32 *it, Uint32 *bt)
601 {
602 int ITEM_FOUND=MDC_NO;
603 Uint32 r_from, r_to, r_step, c_from, c_to, c_step;
604 Uint32 r, c, l, length, tmp;
605 char *col, *row;
606 char *p, *item;
607
608 length = strlen(list);
609
610 /* <enter> default = all */
611 if (MdcUseDefault(list)) {
612 (*cols)[*it] = 0;
613 (*rows)[*it] = 0;
614 *it+=1;
615 return(NULL);
616 }
617
618 /* loop through string with entire list */
619 for (p=list, item=list, l=0; l<=length; l++) {
620
621 /* separate items: begins at digit, ends at space (or \t, \n, ...) */
622
623 if (ITEM_FOUND == MDC_NO) {
624
625 if (isdigit((int)p[l])) { item=&p[l]; ITEM_FOUND=MDC_YES; }
626
627 }else if (isspace((int)p[l]) || p[l]=='\0') {
628
629 p[l]='\0';
630
631 col=item;
632 row=strchr(item,',');
633
634 if ( row == NULL) return("Wrong input!");
635
636 *row = '\0'; row += 1;
637
638 if (MdcGetRange(col,&c_from,&c_to,&c_step) != MDC_OK)
639 return("Error reading column range");
640
641 /* some checks */
642 if (c_from == 0 || c_to == 0) {
643 c_from = 0; c_to = 0;
644 }else if (c_from > c_to) {
645 tmp = c_from; c_from = c_to; c_to = tmp;
646 }
647
648 if (MdcGetRange(row,&r_from,&r_to,&r_step) != MDC_OK)
649 return("Error reading row range");
650
651 /* some checks */
652 if (r_from == 0 || r_to == 0) {
653 r_from = 0; r_to = 0;
654 }else if (r_from > r_to) {
655 tmp = r_from; r_from = r_to; r_to = tmp;
656 }
657
658 for (r=r_from; r<=r_to; r+=r_step)
659 for (c=c_from; c<=c_to; c+=c_step) {
660 (*cols)[*it] = c;
661 (*rows)[*it] = r;
662 *it+=1;
663 if ( (*it % MDC_BUF_ITMS) == 0 ) {
664 if ( ((*cols)=(Uint32 *)MdcRealloc((*cols),
665 (*bt)*MDC_BUF_ITMS*sizeof(Uint32))) == NULL) {
666 return("Couldn't realloc pixels column buffer");
667 }
668 if (((*rows)=(Uint32 *)MdcRealloc((*rows),
669 (*bt)*MDC_BUF_ITMS*sizeof(Uint32))) == NULL) {
670 return("Couldn't realloc pixels row buffer");
671 }
672 }
673 *bt+=1;
674 }
675
676 ITEM_FOUND = MDC_NO;
677
678 }
679 }
680
681 return(NULL);
682
683 }
684
MdcGetStrAcquisition(int acq_type)685 char *MdcGetStrAcquisition(int acq_type)
686 {
687 switch (acq_type) {
688 case MDC_ACQUISITION_STATIC : return("Static");
689 break;
690 case MDC_ACQUISITION_DYNAMIC: return("Dynamic");
691 break;
692 case MDC_ACQUISITION_TOMO : return("Tomographic");
693 break;
694 case MDC_ACQUISITION_GATED : return("Gated");
695 break;
696 case MDC_ACQUISITION_GSPECT : return("GSPECT");
697 break;
698 default : return("Unknown");
699 }
700 }
701
MdcGetStrRawConv(int rawconv)702 char *MdcGetStrRawConv(int rawconv)
703 {
704 switch (rawconv) {
705 case MDC_NO : return("No"); break;
706 case MDC_FRMT_RAW : return("Binary"); break;
707 case MDC_FRMT_ASCII : return("Ascii"); break;
708 default : return("Unknown");
709 }
710 }
711
MdcGetStrEndian(int endian)712 char *MdcGetStrEndian(int endian)
713 {
714 switch (endian) {
715 case MDC_BIG_ENDIAN : return("Big"); break;
716 case MDC_LITTLE_ENDIAN: return("Little"); break;
717 default : return("Unknown");
718 }
719 }
720
MdcGetStrCompression(int compression)721 char *MdcGetStrCompression(int compression)
722 {
723 switch (compression) {
724 case MDC_NO : return("None"); break;
725 case MDC_COMPRESS : return("Compress"); break;
726 case MDC_GZIP : return("Gzipped"); break;
727 default : return("Unknown");
728 }
729 }
730
MdcGetStrPixelType(int type)731 char *MdcGetStrPixelType(int type)
732 {
733 switch (type) {
734 case BIT1: return("1-bit"); break;
735 case BIT8_S: return("Int8"); break;
736 case BIT8_U: return("Uint8"); break;
737 case BIT16_S: return("Int16"); break;
738 case BIT16_U: return("Uint16"); break;
739 case BIT32_S: return("Int32"); break;
740 case BIT32_U: return("Uint32"); break;
741 case BIT64_S: return("Int64"); break;
742 case BIT64_U: return("Uint64"); break;
743 case FLT32: return("IEEE float"); break;
744 case FLT64: return("IEEE double"); break;
745 case ASCII: return("ASCII"); break;
746 case VAXFL32: return("VAX float"); break;
747 case COLRGB: return("RGB24 triplets"); break;
748 default : return("Unknown");
749 }
750 }
751
MdcGetStrColorMap(int map)752 char *MdcGetStrColorMap(int map)
753 {
754 switch (map) {
755 case MDC_MAP_PRESENT : return("present"); break;
756 case MDC_MAP_GRAY : return("gray normal"); break;
757 case MDC_MAP_INVERTED: return("gray invers"); break;
758 case MDC_MAP_RAINBOW : return("rainbow"); break;
759 case MDC_MAP_COMBINED: return("combined"); break;
760 case MDC_MAP_HOTMETAL: return("hotmetal"); break;
761 case MDC_MAP_LOADED : return("loaded LUT"); break;
762 default : return("Unknown");
763 }
764 }
765
MdcGetStrYesNo(int boolean)766 char *MdcGetStrYesNo(int boolean)
767 {
768 switch (boolean) {
769 case MDC_NO : return("No"); break;
770 case MDC_YES: return("Yes"); break;
771 default : return("Unknown");
772 }
773 }
774
MdcGetStrSlProjection(int slice_projection)775 char *MdcGetStrSlProjection(int slice_projection)
776 {
777 switch (slice_projection) {
778
779 case MDC_TRANSAXIAL: strcpy(mdcbufr,"XY - Transaxial");
780 break;
781 case MDC_SAGITTAL : strcpy(mdcbufr,"YZ - Sagittal");
782 break;
783 case MDC_CORONAL : strcpy(mdcbufr,"XZ - Coronal");
784 break;
785 default: strcpy(mdcbufr,"Unknown");
786 }
787
788 return(mdcbufr);
789 }
790
MdcGetStrPatSlOrient(int patient_slice_orient)791 char *MdcGetStrPatSlOrient(int patient_slice_orient)
792 {
793 switch (patient_slice_orient) {
794
795 case MDC_SUPINE_HEADFIRST_TRANSAXIAL:
796 strcpy(mdcbufr,"Supine;HeadFirst;Transverse"); break;
797 case MDC_SUPINE_HEADFIRST_SAGITTAL :
798 strcpy(mdcbufr,"Supine;HeadFirst;Sagittal"); break;
799 case MDC_SUPINE_HEADFIRST_CORONAL :
800 strcpy(mdcbufr,"Supine;HeadFirst;Coronal"); break;
801 case MDC_SUPINE_FEETFIRST_TRANSAXIAL:
802 strcpy(mdcbufr,"Supine;FeetFirst;Transverse"); break;
803 case MDC_SUPINE_FEETFIRST_SAGITTAL :
804 strcpy(mdcbufr,"Supine;FeetFirst;Sagittal"); break;
805 case MDC_SUPINE_FEETFIRST_CORONAL :
806 strcpy(mdcbufr,"Supine;FeetFirst;Coronal"); break;
807 case MDC_PRONE_HEADFIRST_TRANSAXIAL :
808 strcpy(mdcbufr,"Prone;HeadFirst;Transverse"); break;
809 case MDC_PRONE_HEADFIRST_SAGITTAL :
810 strcpy(mdcbufr,"Prone;HeadFirst;Sagittal"); break;
811 case MDC_PRONE_HEADFIRST_CORONAL :
812 strcpy(mdcbufr,"Prone;HeadFirst;Coronal"); break;
813 case MDC_PRONE_FEETFIRST_TRANSAXIAL :
814 strcpy(mdcbufr,"Prone;FeetFirst;Transverse"); break;
815 case MDC_PRONE_FEETFIRST_SAGITTAL :
816 strcpy(mdcbufr,"Prone;FeetFirst;Sagittal"); break;
817 case MDC_PRONE_FEETFIRST_CORONAL :
818 strcpy(mdcbufr,"Prone;FeetFirst;Coronal"); break;
819 case MDC_DECUBITUS_RIGHT_HEADFIRST_TRANSAXIAL:
820 strcpy(mdcbufr,"DecubitusRight;HeadFirst;Transverse"); break;
821 case MDC_DECUBITUS_RIGHT_HEADFIRST_SAGITTAL :
822 strcpy(mdcbufr,"DecubitusRight;HeadFirst;Sagittal"); break;
823 case MDC_DECUBITUS_RIGHT_HEADFIRST_CORONAL :
824 strcpy(mdcbufr,"DecubitusRight;HeadFirst;Coronal"); break;
825 case MDC_DECUBITUS_RIGHT_FEETFIRST_TRANSAXIAL:
826 strcpy(mdcbufr,"DecubitusRight;FeetFirst;Transverse"); break;
827 case MDC_DECUBITUS_RIGHT_FEETFIRST_SAGITTAL :
828 strcpy(mdcbufr,"DecubitusRight;FeetFirst;Sagittal"); break;
829 case MDC_DECUBITUS_RIGHT_FEETFIRST_CORONAL :
830 strcpy(mdcbufr,"DecubitusRight;FeetFirst;Coronal"); break;
831 case MDC_DECUBITUS_LEFT_HEADFIRST_TRANSAXIAL :
832 strcpy(mdcbufr,"DecubitusLeft;HeadFirst;Transverse"); break;
833 case MDC_DECUBITUS_LEFT_HEADFIRST_SAGITTAL :
834 strcpy(mdcbufr,"DecubitusLeft;HeadFirst;Sagittal"); break;
835 case MDC_DECUBITUS_LEFT_HEADFIRST_CORONAL :
836 strcpy(mdcbufr,"DecubitusLeft;HeadFirst;Coronal"); break;
837 case MDC_DECUBITUS_LEFT_FEETFIRST_TRANSAXIAL :
838 strcpy(mdcbufr,"DecubitusLeft;FeetFirst;Transverse"); break;
839 case MDC_DECUBITUS_LEFT_FEETFIRST_SAGITTAL :
840 strcpy(mdcbufr,"DecubitusLeft;FeetFirst;Sagittal"); break;
841 case MDC_DECUBITUS_LEFT_FEETFIRST_CORONAL :
842 strcpy(mdcbufr,"DecubitusLeft;FeetFirst;Coronal"); break;
843 default :
844 strcpy(mdcbufr,"Unknown");
845
846 }
847
848 return(mdcbufr);
849 }
850
MdcGetStrPatPos(int patient_slice_orient)851 char *MdcGetStrPatPos(int patient_slice_orient)
852 {
853 switch (patient_slice_orient) {
854 case MDC_SUPINE_HEADFIRST_TRANSAXIAL:
855 case MDC_SUPINE_HEADFIRST_SAGITTAL :
856 case MDC_SUPINE_HEADFIRST_CORONAL :
857 strcpy(mdcbufr,"HFS"); break;
858 case MDC_SUPINE_FEETFIRST_TRANSAXIAL:
859 case MDC_SUPINE_FEETFIRST_SAGITTAL :
860 case MDC_SUPINE_FEETFIRST_CORONAL :
861 strcpy(mdcbufr,"FFS"); break;
862 case MDC_PRONE_HEADFIRST_TRANSAXIAL :
863 case MDC_PRONE_HEADFIRST_SAGITTAL :
864 case MDC_PRONE_HEADFIRST_CORONAL :
865 strcpy(mdcbufr,"HFP"); break;
866 case MDC_PRONE_FEETFIRST_TRANSAXIAL :
867 case MDC_PRONE_FEETFIRST_SAGITTAL :
868 case MDC_PRONE_FEETFIRST_CORONAL :
869 strcpy(mdcbufr,"FFP"); break;
870 case MDC_DECUBITUS_RIGHT_HEADFIRST_TRANSAXIAL:
871 case MDC_DECUBITUS_RIGHT_HEADFIRST_SAGITTAL :
872 case MDC_DECUBITUS_RIGHT_HEADFIRST_CORONAL :
873 strcpy(mdcbufr,"HFDR"); break;
874 case MDC_DECUBITUS_RIGHT_FEETFIRST_TRANSAXIAL:
875 case MDC_DECUBITUS_RIGHT_FEETFIRST_SAGITTAL :
876 case MDC_DECUBITUS_RIGHT_FEETFIRST_CORONAL :
877 strcpy(mdcbufr,"FFDR"); break;
878 case MDC_DECUBITUS_LEFT_HEADFIRST_TRANSAXIAL :
879 case MDC_DECUBITUS_LEFT_HEADFIRST_SAGITTAL :
880 case MDC_DECUBITUS_LEFT_HEADFIRST_CORONAL :
881 strcpy(mdcbufr,"HFDL"); break;
882 case MDC_DECUBITUS_LEFT_FEETFIRST_TRANSAXIAL :
883 case MDC_DECUBITUS_LEFT_FEETFIRST_SAGITTAL :
884 case MDC_DECUBITUS_LEFT_FEETFIRST_CORONAL :
885 strcpy(mdcbufr,"FFDL"); break;
886 default :
887 strcpy(mdcbufr,"Unknown");
888 }
889
890 return(mdcbufr);
891
892 }
893
MdcGetStrPatOrient(int patient_slice_orient)894 char *MdcGetStrPatOrient(int patient_slice_orient)
895 {
896 switch (patient_slice_orient) {
897 case MDC_SUPINE_HEADFIRST_TRANSAXIAL: strcpy(mdcbufr,"L\\P"); break;
898 case MDC_SUPINE_HEADFIRST_SAGITTAL : strcpy(mdcbufr,"P\\F"); break;
899 case MDC_SUPINE_HEADFIRST_CORONAL : strcpy(mdcbufr,"L\\F"); break;
900 case MDC_SUPINE_FEETFIRST_TRANSAXIAL: strcpy(mdcbufr,"R\\P"); break;
901 case MDC_SUPINE_FEETFIRST_SAGITTAL : strcpy(mdcbufr,"P\\H"); break;
902 case MDC_SUPINE_FEETFIRST_CORONAL : strcpy(mdcbufr,"R\\H"); break;
903 case MDC_PRONE_HEADFIRST_TRANSAXIAL : strcpy(mdcbufr,"R\\A"); break;
904 case MDC_PRONE_HEADFIRST_SAGITTAL : strcpy(mdcbufr,"A\\F"); break;
905 case MDC_PRONE_HEADFIRST_CORONAL : strcpy(mdcbufr,"R\\F"); break;
906 case MDC_PRONE_FEETFIRST_TRANSAXIAL : strcpy(mdcbufr,"L\\A"); break;
907 case MDC_PRONE_FEETFIRST_SAGITTAL : strcpy(mdcbufr,"A\\H"); break;
908 case MDC_PRONE_FEETFIRST_CORONAL : strcpy(mdcbufr,"L\\H"); break;
909 case MDC_DECUBITUS_RIGHT_HEADFIRST_TRANSAXIAL: strcpy(mdcbufr,"P\\R");break;
910 case MDC_DECUBITUS_RIGHT_HEADFIRST_SAGITTAL : strcpy(mdcbufr,"L\\F");break;
911 case MDC_DECUBITUS_RIGHT_HEADFIRST_CORONAL : strcpy(mdcbufr,"P\\F");break;
912 case MDC_DECUBITUS_RIGHT_FEETFIRST_TRANSAXIAL: strcpy(mdcbufr,"A\\R");break;
913 case MDC_DECUBITUS_RIGHT_FEETFIRST_SAGITTAL : strcpy(mdcbufr,"L\\H");break;
914 case MDC_DECUBITUS_RIGHT_FEETFIRST_CORONAL : strcpy(mdcbufr,"A\\H");break;
915 case MDC_DECUBITUS_LEFT_HEADFIRST_TRANSAXIAL : strcpy(mdcbufr,"A\\L");break;
916 case MDC_DECUBITUS_LEFT_HEADFIRST_SAGITTAL : strcpy(mdcbufr,"R\\F");break;
917 case MDC_DECUBITUS_LEFT_HEADFIRST_CORONAL : strcpy(mdcbufr,"A\\F");break;
918 case MDC_DECUBITUS_LEFT_FEETFIRST_TRANSAXIAL : strcpy(mdcbufr,"P\\L");break;
919 case MDC_DECUBITUS_LEFT_FEETFIRST_SAGITTAL : strcpy(mdcbufr,"R\\H");break;
920 case MDC_DECUBITUS_LEFT_FEETFIRST_CORONAL : strcpy(mdcbufr,"P\\H");break;
921 default : strcpy(mdcbufr,"Unknown");
922 }
923
924 return(mdcbufr);
925 }
926
MdcGetStrSliceOrient(int patient_slice_orient)927 char *MdcGetStrSliceOrient(int patient_slice_orient)
928 {
929 switch (patient_slice_orient) {
930 case MDC_SUPINE_HEADFIRST_TRANSAXIAL :
931 case MDC_PRONE_HEADFIRST_TRANSAXIAL :
932 case MDC_DECUBITUS_RIGHT_HEADFIRST_TRANSAXIAL:
933 case MDC_DECUBITUS_LEFT_HEADFIRST_TRANSAXIAL :
934 case MDC_SUPINE_FEETFIRST_TRANSAXIAL :
935 case MDC_PRONE_FEETFIRST_TRANSAXIAL :
936 case MDC_DECUBITUS_RIGHT_FEETFIRST_TRANSAXIAL:
937 case MDC_DECUBITUS_LEFT_FEETFIRST_TRANSAXIAL :
938 strcpy(mdcbufr,"Transverse"); break;
939 case MDC_SUPINE_HEADFIRST_SAGITTAL :
940 case MDC_PRONE_HEADFIRST_SAGITTAL :
941 case MDC_DECUBITUS_RIGHT_HEADFIRST_SAGITTAL:
942 case MDC_DECUBITUS_LEFT_HEADFIRST_SAGITTAL :
943 case MDC_SUPINE_FEETFIRST_SAGITTAL :
944 case MDC_PRONE_FEETFIRST_SAGITTAL :
945 case MDC_DECUBITUS_RIGHT_FEETFIRST_SAGITTAL:
946 case MDC_DECUBITUS_LEFT_FEETFIRST_SAGITTAL :
947 strcpy(mdcbufr,"Sagittal"); break;
948 case MDC_SUPINE_HEADFIRST_CORONAL :
949 case MDC_PRONE_HEADFIRST_CORONAL :
950 case MDC_DECUBITUS_RIGHT_HEADFIRST_CORONAL:
951 case MDC_DECUBITUS_LEFT_HEADFIRST_CORONAL :
952 case MDC_SUPINE_FEETFIRST_CORONAL :
953 case MDC_PRONE_FEETFIRST_CORONAL :
954 case MDC_DECUBITUS_RIGHT_FEETFIRST_CORONAL:
955 case MDC_DECUBITUS_LEFT_FEETFIRST_CORONAL :
956 strcpy(mdcbufr,"Coronal"); break;
957 default :
958 strcpy(mdcbufr,"unknown");
959 }
960
961 return(mdcbufr);
962 }
963
MdcGetStrRotation(int rotation)964 char *MdcGetStrRotation(int rotation)
965 {
966 switch (rotation) {
967 case MDC_ROTATION_CW: strcpy(mdcbufr,"clockwise"); break;
968 case MDC_ROTATION_CC: strcpy(mdcbufr,"counter-clockwise"); break;
969 default : strcpy(mdcbufr,"unknown");
970 }
971
972 return(mdcbufr);
973 }
974
MdcGetStrMotion(int motion)975 char *MdcGetStrMotion(int motion)
976 {
977 switch (motion) {
978 case MDC_MOTION_STEP: strcpy(mdcbufr,"step and shoot"); break;
979 case MDC_MOTION_CONT: strcpy(mdcbufr,"continuous"); break;
980 case MDC_MOTION_DRNG: strcpy(mdcbufr,"during step"); break;
981 default : strcpy(mdcbufr,"unknown");
982 }
983
984 return(mdcbufr);
985 }
986
MdcGetStrModality(int modint)987 char *MdcGetStrModality(int modint)
988 {
989 char *pmod;
990 Uint16 umod16;
991
992 umod16 = (Uint16)modint;
993
994 pmod = (char *)&umod16;
995
996 if (MdcHostBig()) {
997 mdcbufr[0] = pmod[0];
998 mdcbufr[1] = pmod[1];
999 }else{
1000 mdcbufr[0] = pmod[1];
1001 mdcbufr[1] = pmod[0];
1002 }
1003 mdcbufr[2]='\0';
1004
1005 return(mdcbufr);
1006 }
1007
MdcGetStrGSpectNesting(int nesting)1008 char *MdcGetStrGSpectNesting(int nesting)
1009 {
1010 switch (nesting) {
1011 case MDC_GSPECT_NESTING_SPECT: return("SPECT");
1012 case MDC_GSPECT_NESTING_GATED: return("Gated");
1013 default : return("unknown");
1014 }
1015 }
1016
MdcGetStrHHMMSS(float msecs)1017 char *MdcGetStrHHMMSS(float msecs)
1018 {
1019 unsigned int s, ms, hrs, mins, secs;
1020
1021 s = (unsigned int)(msecs / 1000.);
1022
1023 ms = (unsigned int)(msecs - (s * 1000.));
1024
1025 hrs = s / 3600; s -= hrs * 3600;
1026
1027 mins = s / 60; s -= mins * 60.;
1028
1029 secs = s;
1030
1031 if (hrs > 0) {
1032 sprintf(mdcbufr,"%02uh%02um%02u",hrs,mins,secs);
1033 }else if (mins > 0) {
1034 sprintf(mdcbufr,"%02um%02u",mins,secs);
1035 }else{
1036 sprintf(mdcbufr,"%02us%03u",secs,ms);
1037 }
1038
1039 return(mdcbufr);
1040 }
1041
MdcGetIntModality(char * modstr)1042 int MdcGetIntModality(char *modstr)
1043 {
1044 int modint;
1045
1046 modint = (modstr[0]<<8)|modstr[1];
1047
1048 return(modint);
1049 }
1050
MdcGetIntSliceOrient(int patient_slice_orient)1051 int MdcGetIntSliceOrient(int patient_slice_orient)
1052 {
1053 int slice_orient;
1054
1055 switch (patient_slice_orient) {
1056 case MDC_SUPINE_HEADFIRST_TRANSAXIAL :
1057 case MDC_PRONE_HEADFIRST_TRANSAXIAL :
1058 case MDC_DECUBITUS_RIGHT_HEADFIRST_TRANSAXIAL:
1059 case MDC_DECUBITUS_LEFT_HEADFIRST_TRANSAXIAL :
1060 case MDC_SUPINE_FEETFIRST_TRANSAXIAL :
1061 case MDC_PRONE_FEETFIRST_TRANSAXIAL :
1062 case MDC_DECUBITUS_RIGHT_FEETFIRST_TRANSAXIAL:
1063 case MDC_DECUBITUS_LEFT_FEETFIRST_TRANSAXIAL :
1064 slice_orient = MDC_TRANSAXIAL;
1065 break;
1066 case MDC_SUPINE_HEADFIRST_SAGITTAL :
1067 case MDC_PRONE_HEADFIRST_SAGITTAL :
1068 case MDC_DECUBITUS_RIGHT_HEADFIRST_SAGITTAL:
1069 case MDC_DECUBITUS_LEFT_HEADFIRST_SAGITTAL :
1070 case MDC_SUPINE_FEETFIRST_SAGITTAL :
1071 case MDC_PRONE_FEETFIRST_SAGITTAL :
1072 case MDC_DECUBITUS_RIGHT_FEETFIRST_SAGITTAL:
1073 case MDC_DECUBITUS_LEFT_FEETFIRST_SAGITTAL :
1074 slice_orient = MDC_SAGITTAL;
1075 break;
1076 case MDC_SUPINE_HEADFIRST_CORONAL :
1077 case MDC_PRONE_HEADFIRST_CORONAL :
1078 case MDC_DECUBITUS_RIGHT_HEADFIRST_CORONAL:
1079 case MDC_DECUBITUS_LEFT_HEADFIRST_CORONAL :
1080 case MDC_SUPINE_FEETFIRST_CORONAL :
1081 case MDC_PRONE_FEETFIRST_CORONAL :
1082 case MDC_DECUBITUS_RIGHT_FEETFIRST_CORONAL:
1083 case MDC_DECUBITUS_LEFT_FEETFIRST_CORONAL :
1084 slice_orient = MDC_CORONAL;
1085 break;
1086 default :
1087 slice_orient = MDC_TRANSAXIAL;
1088 }
1089
1090 return(slice_orient);
1091
1092 }
1093
MdcGetLibLongVersion(void)1094 const char *MdcGetLibLongVersion(void)
1095 {
1096 return(MDC_LIBVERS);
1097 }
1098
MdcGetLibShortVersion(void)1099 const char *MdcGetLibShortVersion(void)
1100 {
1101 return(MDC_VERSION);
1102 }
1103
1104 /* returns the new stringsize value or 0 in case of error to add */
MdcCheckStrSize(char * str_to_add,Uint32 current_size,Uint32 max)1105 Uint32 MdcCheckStrSize(char *str_to_add, Uint32 current_size, Uint32 max)
1106 {
1107 Uint32 max_value = MDC_2KB_OFFSET;
1108 Uint32 new_size;
1109
1110 if (max != 0) max_value = max;
1111
1112 new_size = current_size + (Uint32)strlen(str_to_add);
1113
1114 if ( new_size >= max_value ) {
1115 MdcPrntWarn("Internal Problem -- Information string too small");
1116 return(0);
1117 }
1118
1119 return(new_size);
1120 }
1121
1122 /* print to global `mdcbufr' array */
MdcMakeScanInfoStr(FILEINFO * fi)1123 int MdcMakeScanInfoStr(FILEINFO *fi)
1124 {
1125 char strbuf[100];
1126 Uint32 size=0;
1127
1128 sprintf(mdcbufr,"\n\n\
1129 ******************************\n\
1130 Short Patient/Scan Information\n\
1131 ******************************\n");
1132 size = (Uint32)strlen(mdcbufr);
1133 sprintf(strbuf,"Patient Name : %s\n",fi->patient_name);
1134 if ((size=MdcCheckStrSize(strbuf,size,0))) strcat(mdcbufr,strbuf);
1135 else return MDC_NO;
1136 sprintf(strbuf,"Patient Sex : %s\n",fi->patient_sex);
1137 if ((size=MdcCheckStrSize(strbuf,size,0))) strcat(mdcbufr,strbuf);
1138 else return MDC_NO;
1139 sprintf(strbuf,"Patient ID : %s\n",fi->patient_id);
1140 if ((size=MdcCheckStrSize(strbuf,size,0))) strcat(mdcbufr,strbuf);
1141 else return MDC_NO;
1142 sprintf(strbuf,"Patient DOB : %s\n",fi->patient_dob);
1143 if ((size=MdcCheckStrSize(strbuf,size,0))) strcat(mdcbufr,strbuf);
1144 else return MDC_NO;
1145 sprintf(strbuf,"Patient Weight: %.2f\n",fi->patient_weight);
1146 if ((size=MdcCheckStrSize(strbuf,size,0))) strcat(mdcbufr,strbuf);
1147 else return MDC_NO;
1148 sprintf(strbuf,"Study Date : %02d/%02d/%04d\n",fi->study_date_day
1149 ,fi->study_date_month
1150 ,fi->study_date_year);
1151 if ((size=MdcCheckStrSize(strbuf,size,0))) strcat(mdcbufr,strbuf);
1152 else return MDC_NO;
1153 sprintf(strbuf,"Study Time : %02d:%02d:%02d\n",fi->study_time_hour
1154 ,fi->study_time_minute
1155 ,fi->study_time_second);
1156 if ((size=MdcCheckStrSize(strbuf,size,0))) strcat(mdcbufr,strbuf);
1157 else return MDC_NO;
1158 sprintf(strbuf,"Study ID : %s\n",fi->study_id);
1159 if ((size=MdcCheckStrSize(strbuf,size,0))) strcat(mdcbufr,strbuf);
1160 else return MDC_NO;
1161 sprintf(strbuf,"Study Descr : %s\n",fi->study_descr);
1162 if ((size=MdcCheckStrSize(strbuf,size,0))) strcat(mdcbufr,strbuf);
1163 else return MDC_NO;
1164 sprintf(strbuf,"Acquisition Type : %s\n",
1165 MdcGetStrAcquisition(fi->acquisition_type));
1166 if ((size=MdcCheckStrSize(strbuf,size,0))) strcat(mdcbufr,strbuf);
1167 else return MDC_NO;
1168 sprintf(strbuf,"Reconstructed : %s\n",
1169 MdcGetStrYesNo(fi->reconstructed));
1170 if ((size=MdcCheckStrSize(strbuf,size,0))) strcat(mdcbufr,strbuf);
1171 else return MDC_NO;
1172
1173 if (fi->reconstructed == MDC_YES) {
1174 sprintf(strbuf,"Reconstruction Method: %s\n",fi->recon_method);
1175 if ((size=MdcCheckStrSize(strbuf,size,0))) strcat(mdcbufr,strbuf);
1176 else return MDC_NO;
1177 sprintf(strbuf,"Filter Type : %s\n",fi->filter_type);
1178 if ((size=MdcCheckStrSize(strbuf,size,0))) strcat(mdcbufr,strbuf);
1179 else return MDC_NO;
1180 sprintf(strbuf,"Decay Corrected : %s\n",
1181 MdcGetStrYesNo(fi->decay_corrected));
1182 if ((size=MdcCheckStrSize(strbuf,size,0))) strcat(mdcbufr,strbuf);
1183 else return MDC_NO;
1184 sprintf(strbuf,"Flood Corrected : %s\n",
1185 MdcGetStrYesNo(fi->flood_corrected));
1186 if ((size=MdcCheckStrSize(strbuf,size,0))) strcat(mdcbufr,strbuf);
1187 else return MDC_NO;
1188 sprintf(strbuf,"Series Description : %s\n",fi->series_descr);
1189 if ((size=MdcCheckStrSize(strbuf,size,0))) strcat(mdcbufr,strbuf);
1190 else return MDC_NO;
1191 sprintf(strbuf,"Radiopharmaceutical : %s\n",fi->radiopharma);
1192 if ((size=MdcCheckStrSize(strbuf,size,0))) strcat(mdcbufr,strbuf);
1193 else return MDC_NO;
1194 }
1195 sprintf(strbuf,"Isotope Code : %s\n",fi->isotope_code);
1196 if ((size=MdcCheckStrSize(strbuf,size,0))) strcat(mdcbufr,strbuf);
1197 else return MDC_NO;
1198 sprintf(strbuf,"Isotope Halflife : %+e [sec]\n",
1199 fi->isotope_halflife);
1200 if ((size=MdcCheckStrSize(strbuf,size,0))) strcat(mdcbufr,strbuf);
1201 else return MDC_NO;
1202 sprintf(strbuf,"Injected Dose : %+e [MBq]\n",
1203 fi->injected_dose);
1204 if ((size=MdcCheckStrSize(strbuf,size,0))) strcat(mdcbufr,strbuf);
1205 else return MDC_NO;
1206 sprintf(strbuf,"Gantry Tilt : %+e degrees\n",
1207 fi->gantry_tilt);
1208 if ((size=MdcCheckStrSize(strbuf,size,0))) strcat(mdcbufr,strbuf);
1209 else return MDC_NO;
1210
1211 return(MDC_YES);
1212
1213 }
1214
MdcIsDigit(char c)1215 int MdcIsDigit(char c)
1216 {
1217 if (c >= '0' && c <= '9') return MDC_YES;
1218
1219 return(MDC_NO);
1220 }
1221
MdcWaitForEnter(int page)1222 void MdcWaitForEnter(int page)
1223 {
1224 if (page > 0) {
1225 MdcPrntScrn("\t\t*********** Press <enter> for page #%d **********",page);
1226 }
1227 if (page == 0) {
1228 MdcPrntScrn("\t\t********** Press <enter> for next page **********");
1229 }
1230 if (page < 0 ) {
1231 MdcPrntScrn("Press <enter> to continue ...");
1232 }
1233 while ( fgetc(stdin) != '\n' ) { /* wait until <enter> key pressed */ }
1234 }
1235
MdcGetSelectionType(void)1236 Int32 MdcGetSelectionType(void)
1237 {
1238 Int32 type=-1;
1239
1240 MdcPrntScrn("\n\tSelection Type:\n");
1241 MdcPrntScrn("\n\ttype %d -> normal",MDC_INPUT_NORM_STYLE);
1242 MdcPrntScrn("\n\t %d -> ecat\n",MDC_INPUT_ECAT_STYLE);
1243 MdcPrntScrn("\n\tYour choice [%d]? ",MDC_INPUT_NORM_STYLE);
1244 MdcGetStrLine(mdcbufr,MDC_2KB_OFFSET-1,stdin);
1245
1246 type=(Int32)atol(mdcbufr);
1247
1248 if (type != MDC_INPUT_ECAT_STYLE) type = MDC_INPUT_NORM_STYLE;
1249
1250 return(type);
1251 }
1252
MdcFlushInput(void)1253 void MdcFlushInput(void)
1254 {
1255 while( fgetc(stdin) != '\n' ) { }
1256 }
1257
MdcWhichDecompress(void)1258 int MdcWhichDecompress(void)
1259 {
1260 if (strcmp(MDC_DECOMPRESS,"gunzip") == 0) return(MDC_GZIP);
1261 if (strcmp(MDC_DECOMPRESS,"uncompress") == 0) return(MDC_COMPRESS);
1262
1263 return(MDC_NO);
1264 }
1265
MdcWhichCompression(const char * fname)1266 int MdcWhichCompression(const char *fname)
1267 {
1268 char *ext=NULL;
1269 int compression = MDC_NO;
1270
1271 /* get filename extension */
1272 if (fname != NULL) ext = strrchr(fname,'.');
1273 if (ext != NULL) {
1274 /* check for supported compression */
1275 switch (MdcWhichDecompress()) {
1276
1277 case MDC_COMPRESS: if (strcmp(ext,".Z") == 0 ) /* only .Z files */
1278 compression = MDC_COMPRESS;
1279 break;
1280 case MDC_GZIP : if (strcmp(ext,".gz") == 0 ) {
1281 compression = MDC_GZIP;
1282 }else if (strcmp(ext,".Z") == 0 ) {
1283 compression = MDC_COMPRESS;
1284 }
1285 break;
1286 }
1287 }
1288
1289 return(compression);
1290
1291 }
1292
MdcAddCompressionExt(int ctype,char * fname)1293 void MdcAddCompressionExt(int ctype, char *fname)
1294 {
1295 switch (ctype) {
1296 case MDC_COMPRESS: strcat(fname,".Z"); break;
1297
1298 case MDC_GZIP : strcat(fname,".gz"); break;
1299 }
1300 }
1301