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 /*****************************************************************************/
57 int 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 /*****************************************************************************/
86 int 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 /*****************************************************************************/
115 int 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 /*****************************************************************************/
147 int 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 /*****************************************************************************/
180 int 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 /*****************************************************************************/
212 int 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 /******************************************************************************/