My Project
imgmax.c
Go to the documentation of this file.
1/******************************************************************************
2
3 Copyright (c) 2007,2009 Turku PET Centre
4
5 Library: imgmax
6 Description: Functions for searching min and max in IMG data.
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 2007-01-24 Vesa Oikonen
27 First created this file in libtpcimgio 1.2.0.
28 Functions not changed, but just moved from libtpcimgp 1.3.1.
29 2007-03-25 VO
30 Added function imgReadMinMax().
31 2009-12-01 VO
32 Added function imgSmoothMax().
33
34
35******************************************************************************/
36#include <stdio.h>
37#include <stdlib.h>
38#include <math.h>
39#include <time.h>
40#include <string.h>
41#include <ctype.h>
42/*****************************************************************************/
43#include "include/img.h"
44#include "include/imgfile.h"
45#include "include/imgmax.h"
46/*****************************************************************************/
47
48/*****************************************************************************/
57int imgMax(IMG *img, float *maxvalue) {
58 int pi, yi, xi, fi;
59 float f;
60
61 if(img->status<IMG_STATUS_OCCUPIED) return(1);
62 if(maxvalue==NULL) return(2); else *maxvalue=0.0;
63 if(img->dimt<1 || img->dimz<1 || img->dimy<1 || img->dimx<1) return(3);
64 f=img->m[0][0][0][0];
65 for(pi=0; pi<img->dimz; pi++)
66 for(yi=0; yi<img->dimy; yi++)
67 for(xi=0; xi<img->dimx; xi++)
68 for(fi=0; fi<img->dimt; fi++) {
69 if(img->m[pi][yi][xi][fi]>f) f=img->m[pi][yi][xi][fi];
70 }
71 *maxvalue=f;
72 return(0);
73}
74/*****************************************************************************/
75
76/*****************************************************************************/
86int imgAbsMax(IMG *img, float *maxvalue) {
87 int pi, yi, xi, fi;
88 float f;
89
90 if(img->status<IMG_STATUS_OCCUPIED) return(1);
91 if(maxvalue==NULL) return(2); else *maxvalue=0.0;
92 if(img->dimt<1 || img->dimz<1 || img->dimy<1 || img->dimx<1) return(3);
93 f=img->m[0][0][0][0];
94 for(pi=0; pi<img->dimz; pi++)
95 for(yi=0; yi<img->dimy; yi++)
96 for(xi=0; xi<img->dimx; xi++)
97 for(fi=0; fi<img->dimt; fi++) {
98 if(fabs(img->m[pi][yi][xi][fi])>fabs(f)) f=img->m[pi][yi][xi][fi];
99 }
100 *maxvalue=f;
101 return(0);
102}
103/*****************************************************************************/
104
105/*****************************************************************************/
115int imgMinMax(IMG *img, float *minvalue, float *maxvalue) {
116 int pi, yi, xi, fi;
117 float mi, ma;
118
119 if(img->status<IMG_STATUS_OCCUPIED) return(1);
120 if(minvalue==NULL || maxvalue==NULL) return(2);
121 *minvalue=*maxvalue=0.0;
122 if(img->dimt<1 || img->dimz<1 || img->dimy<1 || img->dimx<1) return(3);
123 mi=ma=img->m[0][0][0][0];
124 for(pi=0; pi<img->dimz; pi++)
125 for(yi=0; yi<img->dimy; yi++)
126 for(xi=0; xi<img->dimx; xi++)
127 for(fi=0; fi<img->dimt; fi++) {
128 if(img->m[pi][yi][xi][fi]>ma) ma=img->m[pi][yi][xi][fi];
129 else if(img->m[pi][yi][xi][fi]<mi) mi=img->m[pi][yi][xi][fi];
130 }
131 *minvalue=mi; *maxvalue=ma;
132 return(0);
133}
134/*****************************************************************************/
135
136/*****************************************************************************/
147int imgFrameMinMax(IMG *img, int frame, float *minvalue, float *maxvalue) {
148 int pi, yi, xi, fi;
149 float mi, ma;
150
151 if(img->status<IMG_STATUS_OCCUPIED) return(1);
152 if(minvalue==NULL || maxvalue==NULL) return(2);
153 *minvalue=*maxvalue=0.0; fi=frame-1;
154 if(img->dimt<frame || img->dimz<1 || img->dimy<1 || img->dimx<1) return(3);
155 if(frame<1) return(4);
156 mi=ma=img->m[0][0][0][fi];
157 for(pi=0; pi<img->dimz; pi++)
158 for(yi=0; yi<img->dimy; yi++)
159 for(xi=0; xi<img->dimx; xi++) {
160 if(img->m[pi][yi][xi][fi]>ma) ma=img->m[pi][yi][xi][fi];
161 else if(img->m[pi][yi][xi][fi]<mi) mi=img->m[pi][yi][xi][fi];
162 }
163 *minvalue=mi; *maxvalue=ma;
164 return(0);
165}
166/*****************************************************************************/
167
168/*****************************************************************************/
180int imgReadMinMax(const char *fname, float *fmin, float *fmax) {
181 int fi=0, ret;
182 IMG img;
183 float frmin, frmax;
184
185 if(IMG_TEST) printf("imgReadMinMax(%s, *fmin, *fmax)\n", fname);
186 imgInit(&img);
187 while((ret=imgReadFrame(fname, fi+1, &img, 0)) == 0) {
188 if(imgMinMax(&img, &frmin, &frmax)!=0) {imgEmpty(&img); return STATUS_FAULT;}
189 if(fi==0) {
190 if(fmin!=NULL) *fmin=frmin; if(fmin!=NULL) *fmax=frmax;
191 } else {
192 if(fmin!=NULL && *fmin>frmin) *fmin=frmin;
193 if(fmax!=NULL && *fmax<frmax) *fmax=frmax;
194 }
195 fi++;
196 } /* next frame */
197 imgEmpty(&img);
198 if(ret==STATUS_NOMATRIX && fi>0) return STATUS_OK;
199 else return ret;
200}
201/*****************************************************************************/
202
203/*****************************************************************************/
212int imgSmoothMax(IMG *img, float *maxvalue) {
213 int pi, yi, xi, fi;
214 float f, v;
215
216 if(img->status<IMG_STATUS_OCCUPIED) return(1);
217 if(maxvalue==NULL) return(2); else *maxvalue=0.0;
218 if(img->dimt<1 || img->dimz<1 || img->dimy<3 || img->dimx<3) return(3);
219 f=-1.0E20;
220 for(pi=0; pi<img->dimz; pi++)
221 for(yi=1; yi<img->dimy-1; yi++)
222 for(xi=1; xi<img->dimx-1; xi++)
223 for(fi=0; fi<img->dimt; fi++) {
224 v=img->m[pi][yi-1][xi-1][fi]+
225 img->m[pi][yi-1][xi ][fi]+
226 img->m[pi][yi-1][xi+1][fi]+
227 img->m[pi][yi ][xi-1][fi]+
228 img->m[pi][yi ][xi ][fi]*2.0+
229 img->m[pi][yi ][xi+1][fi]+
230 img->m[pi][yi+1][xi-1][fi]+
231 img->m[pi][yi+1][xi ][fi]+
232 img->m[pi][yi+1][xi+1][fi];
233 v*=0.1; if(v>f) f=v;
234 }
235 *maxvalue=f;
236 return(0);
237}
238/******************************************************************************/
239
240/******************************************************************************/
void imgEmpty(IMG *image)
Definition: img.c:216
void imgInit(IMG *image)
Definition: img.c:163
@ STATUS_OK
Definition: img.h:118
@ STATUS_NOMATRIX
Definition: img.h:121
@ STATUS_FAULT
Definition: img.h:118
int IMG_TEST
Definition: img.h:128
#define IMG_STATUS_OCCUPIED
Definition: img.h:73
int imgReadFrame(const char *fname, int frame_to_read, IMG *img, int frame_index)
Definition: imgfile.c:389
int imgSmoothMax(IMG *img, float *maxvalue)
Definition: imgmax.c:212
int imgReadMinMax(const char *fname, float *fmin, float *fmax)
Definition: imgmax.c:180
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
Definition: img.h:156
unsigned short int dimx
Definition: img.h:261
float **** m
Definition: img.h:274
char status
Definition: img.h:164
unsigned short int dimt
Definition: img.h:259
unsigned short int dimz
Definition: img.h:265
unsigned short int dimy
Definition: img.h:263