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 /*****************************************************************************/
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 /******************************************************************************/
IMG::dimt
unsigned short int dimt
Definition: img.h:259
IMG_TEST
int IMG_TEST
Definition: img.h:128
STATUS_FAULT
@ STATUS_FAULT
Definition: img.h:118
imgFrameMinMax
int imgFrameMinMax(IMG *img, int frame, float *minvalue, float *maxvalue)
Definition: imgmax.c:147
imgSmoothMax
int imgSmoothMax(IMG *img, float *maxvalue)
Definition: imgmax.c:212
IMG::dimz
unsigned short int dimz
Definition: img.h:265
imgEmpty
void imgEmpty(IMG *image)
Definition: img.c:216
imgmax.h
IMG::m
float **** m
Definition: img.h:274
imgMax
int imgMax(IMG *img, float *maxvalue)
Definition: imgmax.c:57
IMG
Definition: img.h:156
imgAbsMax
int imgAbsMax(IMG *img, float *maxvalue)
Definition: imgmax.c:86
IMG::dimx
unsigned short int dimx
Definition: img.h:261
STATUS_OK
@ STATUS_OK
Definition: img.h:118
imgfile.h
IMG::status
char status
Definition: img.h:164
imgReadFrame
int imgReadFrame(const char *fname, int frame_to_read, IMG *img, int frame_index)
Definition: imgfile.c:389
imgInit
void imgInit(IMG *image)
Definition: img.c:163
imgMinMax
int imgMinMax(IMG *img, float *minvalue, float *maxvalue)
Definition: imgmax.c:115
STATUS_NOMATRIX
@ STATUS_NOMATRIX
Definition: img.h:121
imgReadMinMax
int imgReadMinMax(const char *fname, float *fmin, float *fmax)
Definition: imgmax.c:180
IMG_STATUS_OCCUPIED
#define IMG_STATUS_OCCUPIED
Definition: img.h:73
IMG::dimy
unsigned short int dimy
Definition: img.h:263
img.h