My Project
imgunit.c
Go to the documentation of this file.
1/******************************************************************************
2
3 Copyright (c) 2006-2011 Turku PET Centre
4
5 Library: imgunit
6 Description: Functions for setting image calibration unit.
7
8 This library is free software; you can redistribute it and/or
9 modify it under the terms of the GNU Lesser General Public
10 License as published by the Free Software Foundation; either
11 version 2.1 of the License, or (at your option) any later version.
12
13 This library is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
16 See the GNU Lesser General Public License for more details:
17 http://www.gnu.org/copyleft/lesser.html
18
19 You should have received a copy of the GNU Lesser General Public License
20 along with this library/program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22
23 Turku PET Centre, Turku, Finland, http://www.turkupetcentre.fi
24
25 Modification history:
26 2006-10-30 Vesa Oikonen
27 First created.
28 2007-02-02 VO
29 imgUnitId() identifies more unit strings.
30 Added more IMG units.
31 Functions imgUnitFromEcat7() and imgUnit() rewritten.
32 2007-17-07 Harri Merisaari
33 Modified for optional ANSi compatibility
34 2008-07-24 VO
35 Added function imgSetUnit().
36 2010-05-11 VO
37 Function imgUnitFromEcat7() tries to identify unit with imgUnitId()
38 always when ECAT 7 calibration_units is 2; previosly in these cases
39 unit was assumed to be unknown.
40 2011-02-04 VO
41 imgUnitToEcat7() writes label "unitless" in the header, previosly header
42 was marked to contain no data_units label.
43
44
45******************************************************************************/
46#include <stdio.h>
47#include <stdlib.h>
48#include <math.h>
49#include <time.h>
50#include <string.h>
51#include <strings.h>
52#include <ctype.h>
53#include <float.h>
54/*****************************************************************************/
55#include "img.h"
56#include "substitutions.h"
57/*****************************************************************************/
58#include "include/imgunit.h"
59/*****************************************************************************/
61static char *img_unit_string[] = {
62 /* 0 */ "unknown",
63 /* 1 */ "cnts/sec",
64 /* 2 */ "counts",
65 /* 3 */ "kBq/mL",
66 /* 4 */ "sec*kBq/mL",
67 /* 5 */ "1/sec",
68 /* 6 */ "1/min",
69 /* 7 */ "mL/mL",
70 /* 8 */ "mL/dL",
71 /* 9 */ "mL/(mL*min)",
72 /* 10 */ "mL/(dL*min)",
73 /* 11 */ "unitless",
74 /* 12 */ "nCi/mL",
75 /* 13 */ "MBq/mL",
76 /* 14 */ "Bq/cc",
77 /* 15 */ "uCi/cc",
78 /* 16 */ "umol/(100g*min)",
79 /* 17 */ "mg/(100g*min)",
80 0
81};
82/*****************************************************************************/
83
84/*****************************************************************************/
91int imgUnitId(char *unit) {
92 if(unit==NULL) return(-1);
93 if(strlen(unit)==0) return IMGUNIT_UNKNOWN;
94 else if(strcasecmp(unit, "unknown")==0) return IMGUNIT_UNKNOWN;
95 else if(strcasecmp(unit, "cnts/sec")==0) return IMGUNIT_CPS;
96 else if(strcasecmp(unit, "counts/sec")==0) return IMGUNIT_CPS;
97 else if(strcasecmp(unit, "ECAT counts/sec")==0) return IMGUNIT_CPS;
98 else if(strcasecmp(unit, "cps")==0) return IMGUNIT_CPS;
99 else if(strcasecmp(unit, "counts")==0) return IMGUNIT_COUNTS;
100 else if(strcasecmp(unit, "cnts")==0) return IMGUNIT_COUNTS;
101 else if(strcasecmp(unit, "kBq/cc")==0) return IMGUNIT_KBQ_PER_ML;
102 else if(strcasecmp(unit, "kBq/mL")==0) return IMGUNIT_KBQ_PER_ML;
103 else if(strcasecmp(unit, "sec*kBq/cc")==0) return IMGUNIT_SEC_KBQ_PER_ML;
104 else if(strcasecmp(unit, "sec*kBq/mL")==0) return IMGUNIT_SEC_KBQ_PER_ML;
105 else if(strcasecmp(unit, "integral")==0) return IMGUNIT_SEC_KBQ_PER_ML;
106 else if(strcasecmp(unit, "1/sec")==0) return IMGUNIT_PER_SEC;
107 else if(strcasecmp(unit, "1/s")==0) return IMGUNIT_PER_SEC;
108 else if(strcasecmp(unit, "s-1")==0) return IMGUNIT_PER_SEC;
109 else if(strcasecmp(unit, "1/min")==0) return IMGUNIT_PER_MIN;
110 else if(strcasecmp(unit, "min-1")==0) return IMGUNIT_PER_MIN;
111 else if(strcasecmp(unit, "mL/mL")==0) return IMGUNIT_ML_PER_ML;
112 else if(strcasecmp(unit, "mL/cc")==0) return IMGUNIT_ML_PER_ML;
113 else if(strcasecmp(unit, "mL/dL")==0) return IMGUNIT_ML_PER_DL;
114 else if(strcasecmp(unit, "mL/100mL")==0) return IMGUNIT_ML_PER_DL;
115 else if(strcasecmp(unit, "mL/(mL*min)")==0) return IMGUNIT_ML_PER_ML_PER_MIN;
116 else if(strcasecmp(unit, "mL/(min*mL)")==0) return IMGUNIT_ML_PER_ML_PER_MIN;
117 else if(strcasecmp(unit, "mL/(cc*min)")==0) return IMGUNIT_ML_PER_ML_PER_MIN;
118 else if(strcasecmp(unit, "mL/(min*cc)")==0) return IMGUNIT_ML_PER_ML_PER_MIN;
119 else if(strcasecmp(unit, "mL/mL/min")==0) return IMGUNIT_ML_PER_ML_PER_MIN;
120 else if(strcasecmp(unit, "mL/min/mL")==0) return IMGUNIT_ML_PER_ML_PER_MIN;
121 else if(strcasecmp(unit, "mL/cc/min")==0) return IMGUNIT_ML_PER_ML_PER_MIN;
122 else if(strcasecmp(unit, "mL/min/cc")==0) return IMGUNIT_ML_PER_ML_PER_MIN;
123 else if(strcasecmp(unit, "mL/(dL*min)")==0) return IMGUNIT_ML_PER_DL_PER_MIN;
124 else if(strcasecmp(unit, "mL/(min*dL)")==0) return IMGUNIT_ML_PER_DL_PER_MIN;
125 else if(strcasecmp(unit, "mL/(100mL*min)")==0) return IMGUNIT_ML_PER_DL_PER_MIN;
126 else if(strcasecmp(unit, "mL/(min*100mL)")==0) return IMGUNIT_ML_PER_DL_PER_MIN;
127 else if(strcasecmp(unit, "mL/dL/min")==0) return IMGUNIT_ML_PER_DL_PER_MIN;
128 else if(strcasecmp(unit, "mL/min/dL")==0) return IMGUNIT_ML_PER_DL_PER_MIN;
129 else if(strcasecmp(unit, "mL/100mL/min")==0) return IMGUNIT_ML_PER_DL_PER_MIN;
130 else if(strcasecmp(unit, "mL/min/100mL")==0) return IMGUNIT_ML_PER_DL_PER_MIN;
131 else if(strcasecmp(unit, "unitless")==0) return IMGUNIT_UNITLESS;
132 else if(strcasecmp(unit, "nCi/cc")==0) return IMGUNIT_NCI_PER_ML;
133 else if(strcasecmp(unit, "nCi/mL")==0) return IMGUNIT_NCI_PER_ML;
134 else if(strcasecmp(unit, "MBq/cc")==0) return IMGUNIT_MBQ_PER_ML;
135 else if(strcasecmp(unit, "MBq/mL")==0) return IMGUNIT_MBQ_PER_ML;
136 else if(strcasecmp(unit, "Bq/cc")==0) return IMGUNIT_BQ_PER_ML;
137 else if(strcasecmp(unit, "Bq/mL")==0) return IMGUNIT_BQ_PER_ML;
138 else if(strcasecmp(unit, "uCi/cc")==0) return IMGUNIT_UCI_PER_ML;
139 else if(strcasecmp(unit, "uCi/mL")==0) return IMGUNIT_UCI_PER_ML;
140 else if(strcasecmp(unit, "umol/(100g*min)")==0) return IMGUNIT_UMOL_PER_MIN_PER_100G;
141 else if(strcasecmp(unit, "umol/(min*100g)")==0) return IMGUNIT_UMOL_PER_MIN_PER_100G;
142 else if(strcasecmp(unit, "umol/100g/min")==0) return IMGUNIT_UMOL_PER_MIN_PER_100G;
143 else if(strcasecmp(unit, "umol/min/100g")==0) return IMGUNIT_UMOL_PER_MIN_PER_100G;
144 else if(strcasecmp(unit, "mg/(100g*min)")==0) return IMGUNIT_MG_PER_MIN_PER_100G;
145 else if(strcasecmp(unit, "mg/(min*100g)")==0) return IMGUNIT_MG_PER_MIN_PER_100G;
146 else if(strcasecmp(unit, "mg/100g/min")==0) return IMGUNIT_MG_PER_MIN_PER_100G;
147 else if(strcasecmp(unit, "mg/min/100g")==0) return IMGUNIT_MG_PER_MIN_PER_100G;
148
149 return(-3);
150}
151/*****************************************************************************/
152
153/*****************************************************************************/
160void imgUnitFromEcat(IMG *img, int ecat_unit) {
161 switch(ecat_unit) {
162 case 0: /* Unknown */
163 img->unit=IMGUNIT_UNKNOWN; break;
164 case 1: /* MBq/mL */
165 img->unit=IMGUNIT_MBQ_PER_ML; break;
166 case 2: /* ECAT counts */
167 img->unit=IMGUNIT_COUNTS; break;
168 case 3: /* uCi/ml */
169 img->unit=IMGUNIT_UCI_PER_ML; break;
170 case 4: /* LMRGlu */
171 img->unit=IMGUNIT_UNKNOWN; break;
172 case 5: /* LMRUGlu umol/min/100g */
174 case 6: /* LMRUGlu mg/min/100g */
176 case 7: /* nCi/mL */
177 img->unit=IMGUNIT_NCI_PER_ML; break;
178 case 8: /* Well counts */
179 img->unit=IMGUNIT_CPS; break;
180 case 9: /* Becquerels */
181 img->unit=IMGUNIT_BQ_PER_ML; break;
182 case 10: /* kBq/mL */
183 img->unit=IMGUNIT_KBQ_PER_ML; break;
184 case 11: /* 1/min */
185 img->unit=IMGUNIT_PER_MIN; break;
186 case 12: /* mL/min/100g */
188 case 13: /* sec*kBq/mL */
189 img->unit=IMGUNIT_SEC_KBQ_PER_ML; break;
190 case 14: /* sec*nCi/mL */
191 img->unit=IMGUNIT_UNKNOWN; break;
192 case 15: /* 1/sec */
193 img->unit=IMGUNIT_PER_SEC; break;
194 case 16: /* Unitless */
195 img->unit=IMGUNIT_UNITLESS; break;
196 case 17: /* Unknown */
197 default:
198 img->unit=IMGUNIT_UNKNOWN; break;
199 }
200}
201/*****************************************************************************/
202
203/*****************************************************************************/
211 if(h->calibration_units==0) { /* Not calibrated */
212 img->unit=1;
213 } else if(h->calibration_units==1) {
216 else
217 img->unit=imgUnitId(h->data_units);
218 } else if(h->calibration_units==2) {
219 img->unit=imgUnitId(h->data_units);
220 } else {
222 }
223}
224/*****************************************************************************/
225
226/*****************************************************************************/
234 int ecat_unit;
235 switch(img->unit) {
236 case IMGUNIT_CPS: ecat_unit=9; break;
237 case IMGUNIT_COUNTS: ecat_unit=2; break;
238 case IMGUNIT_KBQ_PER_ML: ecat_unit=10; break;
239 case IMGUNIT_SEC_KBQ_PER_ML: ecat_unit=13; break;
240 case IMGUNIT_PER_SEC: ecat_unit=15; break;
241 case IMGUNIT_PER_MIN: ecat_unit=11; break;
242 case IMGUNIT_ML_PER_ML: ecat_unit=16; break;
243 case IMGUNIT_ML_PER_DL: ecat_unit=16; break;
244 case IMGUNIT_ML_PER_ML_PER_MIN: ecat_unit=11; break;
245 case IMGUNIT_ML_PER_DL_PER_MIN: ecat_unit=12; break;
246 case IMGUNIT_UNITLESS: ecat_unit=16; break;
247 case IMGUNIT_NCI_PER_ML: ecat_unit=7; break;
248 case IMGUNIT_MBQ_PER_ML: ecat_unit=1; break;
249 case IMGUNIT_BQ_PER_ML: ecat_unit=9; break;
250 case IMGUNIT_UCI_PER_ML: ecat_unit=3; break;
251 case IMGUNIT_UMOL_PER_MIN_PER_100G: ecat_unit=5; break;
252 case IMGUNIT_MG_PER_MIN_PER_100G: ecat_unit=6; break;
253 default: ecat_unit=0; break;
254 }
255 return(ecat_unit);
256}
257/*****************************************************************************/
258
259/*****************************************************************************/
267 switch(img->unit) {
268 case IMGUNIT_CPS:
269 case IMGUNIT_COUNTS:
272 strcpy(h->data_units, "ECAT counts/sec");
273 break;
277 strcpy(h->data_units, "kBq/cc");
278 break;
282 strcpy(h->data_units, "sec*kBq/mL");
283 break;
284 case IMGUNIT_PER_SEC:
287 strcpy(h->data_units, "1/sec");
288 break;
289 case IMGUNIT_PER_MIN:
292 strcpy(h->data_units, "1/min");
293 break;
297 strcpy(h->data_units, "mL/mL");
298 break;
302 strcpy(h->data_units, "mL/dL");
303 break;
307 strcpy(h->data_units, "mL/(mL*min)");
308 break;
312 strcpy(h->data_units, "mL/(dL*min)");
313 break;
314 case IMGUNIT_UNITLESS:
317 strcpy(h->data_units, "unitless");
318 break;
322 strcpy(h->data_units, "nCi/cc");
323 break;
327 strcpy(h->data_units, "MBq/cc");
328 break;
332 strcpy(h->data_units, "Bq/cc");
333 break;
337 strcpy(h->data_units, "uCi/cc");
338 break;
342 strcpy(h->data_units, "umol/min/100g");
343 break;
347 strcpy(h->data_units, "mg/min/100g");
348 break;
349 default:
352 strcpy(h->data_units, "");
353 break;
354 }
355}
356/*****************************************************************************/
357
358/*****************************************************************************/
365char *imgUnit(int dunit) {
366 int n=0;
367 while(img_unit_string[n]!=0) n++;
368 if(dunit<0 || dunit>n-1) return(img_unit_string[IMGUNIT_UNKNOWN]);
369 else return(img_unit_string[dunit]);
370}
371/*****************************************************************************/
372
373/*****************************************************************************/
377int imgSetUnit(IMG *img, char *unit)
378{
379 int new_unit;
380
381 if(img==NULL || unit==NULL) return(1);
382 new_unit=imgUnitId(unit); if(new_unit<0) return(1-new_unit);
383 img->unit=new_unit;
384 return(0);
385}
386/*****************************************************************************/
387
388/*****************************************************************************/
389
int imgUnitToEcat6(IMG *img)
Definition imgunit.c:233
int imgSetUnit(IMG *img, char *unit)
Definition imgunit.c:377
char * imgUnit(int dunit)
Definition imgunit.c:365
int imgUnitId(char *unit)
Definition imgunit.c:91
void imgUnitFromEcat(IMG *img, int ecat_unit)
Definition imgunit.c:160
static char * img_unit_string[]
Definition imgunit.c:61
void imgUnitToEcat7(IMG *img, ECAT7_mainheader *h)
Definition imgunit.c:266
void imgUnitFromEcat7(IMG *img, ECAT7_mainheader *h)
Definition imgunit.c:210
@ IMGUNIT_MG_PER_MIN_PER_100G
Definition imgunit.h:36
@ IMGUNIT_ML_PER_ML_PER_MIN
Definition imgunit.h:28
@ IMGUNIT_KBQ_PER_ML
Definition imgunit.h:22
@ IMGUNIT_ML_PER_ML
Definition imgunit.h:26
@ IMGUNIT_PER_SEC
Definition imgunit.h:24
@ IMGUNIT_UMOL_PER_MIN_PER_100G
Definition imgunit.h:35
@ IMGUNIT_ML_PER_DL_PER_MIN
Definition imgunit.h:29
@ IMGUNIT_UNKNOWN
Definition imgunit.h:19
@ IMGUNIT_BQ_PER_ML
Definition imgunit.h:33
@ IMGUNIT_UNITLESS
Definition imgunit.h:30
@ IMGUNIT_NCI_PER_ML
Definition imgunit.h:31
@ IMGUNIT_SEC_KBQ_PER_ML
Definition imgunit.h:23
@ IMGUNIT_UCI_PER_ML
Definition imgunit.h:34
@ IMGUNIT_CPS
Definition imgunit.h:20
@ IMGUNIT_ML_PER_DL
Definition imgunit.h:27
@ IMGUNIT_COUNTS
Definition imgunit.h:21
@ IMGUNIT_MBQ_PER_ML
Definition imgunit.h:32
@ IMGUNIT_PER_MIN
Definition imgunit.h:25
Definition img.h:156
char unit
Definition img.h:172
short int calibration_units
Definition ecat7.h:148
short int calibration_units_label
Definition ecat7.h:150
char data_units[32]
Definition ecat7.h:221