imgmax.c
Go to the documentation of this file.
00001 /******************************************************************************
00002 
00003   Copyright (c) 2007,2009 Turku PET Centre
00004 
00005   Library:      imgmax
00006   Description:  Functions for searching min and max in IMG data.
00007 
00008   This library is free software; you can redistribute it and/or
00009   modify it under the terms of the GNU Lesser General Public
00010   License as published by the Free Software Foundation; either
00011   version 2.1 of the License, or (at your option) any later version.
00012 
00013   This library is distributed in the hope that it will be useful,
00014   but WITHOUT ANY WARRANTY; without even the implied warranty of
00015   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
00016   See the GNU Lesser General Public License for more details:
00017   http://www.gnu.org/copyleft/lesser.html
00018 
00019   You should have received a copy of the GNU Lesser General Public License
00020   along with this library/program; if not, write to the Free Software
00021   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
00022 
00023   Turku PET Centre, Turku, Finland, http://www.turkupetcentre.fi
00024 
00025   Modification history:
00026   2007-01-24 Vesa Oikonen
00027     First created this file in libtpcimgio 1.2.0.
00028     Functions not changed, but just moved from libtpcimgp 1.3.1.
00029   2007-03-25 VO
00030     Added function imgReadMinMax().
00031   2009-12-01 VO
00032     Added function imgSmoothMax().
00033 
00034 
00035 ******************************************************************************/
00036 #include <stdio.h>
00037 #include <stdlib.h>
00038 #include <math.h>
00039 #include <time.h>
00040 #include <string.h>
00041 #include <ctype.h>
00042 /*****************************************************************************/
00043 #include "include/img.h"
00044 #include "include/imgfile.h"
00045 #include "include/imgmax.h"
00046 /*****************************************************************************/
00047 
00048 /*****************************************************************************/
00057 int imgMax(IMG *img, float *maxvalue) {
00058   int pi, yi, xi, fi;
00059   float f;
00060 
00061   if(img->status<IMG_STATUS_OCCUPIED) return(1);
00062   if(maxvalue==NULL) return(2); else *maxvalue=0.0;
00063   if(img->dimt<1 || img->dimz<1 || img->dimy<1 || img->dimx<1) return(3);
00064   f=img->m[0][0][0][0];
00065   for(pi=0; pi<img->dimz; pi++)
00066     for(yi=0; yi<img->dimy; yi++)
00067       for(xi=0; xi<img->dimx; xi++)
00068         for(fi=0; fi<img->dimt; fi++) {
00069           if(img->m[pi][yi][xi][fi]>f) f=img->m[pi][yi][xi][fi];
00070         }
00071   *maxvalue=f;
00072   return(0);
00073 }
00074 /*****************************************************************************/
00075 
00076 /*****************************************************************************/
00086 int imgAbsMax(IMG *img, float *maxvalue) {
00087   int pi, yi, xi, fi;
00088   float f;
00089 
00090   if(img->status<IMG_STATUS_OCCUPIED) return(1);
00091   if(maxvalue==NULL) return(2); else *maxvalue=0.0;
00092   if(img->dimt<1 || img->dimz<1 || img->dimy<1 || img->dimx<1) return(3);
00093   f=img->m[0][0][0][0];
00094   for(pi=0; pi<img->dimz; pi++)
00095     for(yi=0; yi<img->dimy; yi++)
00096       for(xi=0; xi<img->dimx; xi++)
00097         for(fi=0; fi<img->dimt; fi++) {
00098           if(fabs(img->m[pi][yi][xi][fi])>fabs(f)) f=img->m[pi][yi][xi][fi];
00099         }
00100   *maxvalue=f;
00101   return(0);
00102 }
00103 /*****************************************************************************/
00104 
00105 /*****************************************************************************/
00115 int imgMinMax(IMG *img, float *minvalue, float *maxvalue) {
00116   int pi, yi, xi, fi;
00117   float mi, ma;
00118   
00119   if(img->status<IMG_STATUS_OCCUPIED) return(1);
00120   if(minvalue==NULL || maxvalue==NULL) return(2);
00121   *minvalue=*maxvalue=0.0;
00122   if(img->dimt<1 || img->dimz<1 || img->dimy<1 || img->dimx<1) return(3);
00123   mi=ma=img->m[0][0][0][0];
00124   for(pi=0; pi<img->dimz; pi++)
00125     for(yi=0; yi<img->dimy; yi++)
00126       for(xi=0; xi<img->dimx; xi++)
00127         for(fi=0; fi<img->dimt; fi++) {
00128           if(img->m[pi][yi][xi][fi]>ma) ma=img->m[pi][yi][xi][fi];
00129           else if(img->m[pi][yi][xi][fi]<mi) mi=img->m[pi][yi][xi][fi];
00130         }
00131   *minvalue=mi; *maxvalue=ma;
00132   return(0);
00133 }
00134 /*****************************************************************************/
00135 
00136 /*****************************************************************************/
00147 int imgFrameMinMax(IMG *img, int frame, float *minvalue, float *maxvalue) {
00148   int pi, yi, xi, fi;
00149   float mi, ma;
00150 
00151   if(img->status<IMG_STATUS_OCCUPIED) return(1);
00152   if(minvalue==NULL || maxvalue==NULL) return(2);
00153   *minvalue=*maxvalue=0.0; fi=frame-1;
00154   if(img->dimt<frame || img->dimz<1 || img->dimy<1 || img->dimx<1) return(3);
00155   if(frame<1) return(4);
00156   mi=ma=img->m[0][0][0][fi];
00157   for(pi=0; pi<img->dimz; pi++)
00158     for(yi=0; yi<img->dimy; yi++)
00159       for(xi=0; xi<img->dimx; xi++) {
00160         if(img->m[pi][yi][xi][fi]>ma) ma=img->m[pi][yi][xi][fi];
00161         else if(img->m[pi][yi][xi][fi]<mi) mi=img->m[pi][yi][xi][fi];
00162       }
00163   *minvalue=mi; *maxvalue=ma;
00164   return(0);
00165 }
00166 /*****************************************************************************/
00167 
00168 /*****************************************************************************/
00180 int imgReadMinMax(const char *fname, float *fmin, float *fmax) {
00181   int fi=0, ret;
00182   IMG img;
00183   float frmin, frmax;
00184 
00185   if(IMG_TEST) printf("imgReadMinMax(%s, *fmin, *fmax)\n", fname);
00186   imgInit(&img);
00187   while((ret=imgReadFrame(fname, fi+1, &img, 0)) == 0) {
00188     if(imgMinMax(&img, &frmin, &frmax)!=0) {imgEmpty(&img); return STATUS_FAULT;}
00189     if(fi==0) {
00190       if(fmin!=NULL) *fmin=frmin; if(fmin!=NULL) *fmax=frmax;
00191     } else {
00192       if(fmin!=NULL && *fmin>frmin) *fmin=frmin;
00193       if(fmax!=NULL && *fmax<frmax) *fmax=frmax;
00194     }
00195     fi++;
00196   } /* next frame */
00197   imgEmpty(&img);
00198   if(ret==STATUS_NOMATRIX && fi>0) return STATUS_OK;
00199   else return ret;
00200 }
00201 /*****************************************************************************/
00202 
00203 /*****************************************************************************/
00212 int imgSmoothMax(IMG *img, float *maxvalue) {
00213   int pi, yi, xi, fi;
00214   float f, v;
00215 
00216   if(img->status<IMG_STATUS_OCCUPIED) return(1);
00217   if(maxvalue==NULL) return(2); else *maxvalue=0.0;
00218   if(img->dimt<1 || img->dimz<1 || img->dimy<3 || img->dimx<3) return(3);
00219   f=-1.0E20;
00220   for(pi=0; pi<img->dimz; pi++)
00221     for(yi=1; yi<img->dimy-1; yi++)
00222       for(xi=1; xi<img->dimx-1; xi++)
00223         for(fi=0; fi<img->dimt; fi++) {
00224           v=img->m[pi][yi-1][xi-1][fi]+
00225             img->m[pi][yi-1][xi  ][fi]+
00226             img->m[pi][yi-1][xi+1][fi]+
00227             img->m[pi][yi  ][xi-1][fi]+
00228             img->m[pi][yi  ][xi  ][fi]*2.0+
00229             img->m[pi][yi  ][xi+1][fi]+
00230             img->m[pi][yi+1][xi-1][fi]+
00231             img->m[pi][yi+1][xi  ][fi]+
00232             img->m[pi][yi+1][xi+1][fi];
00233           v*=0.1; if(v>f) f=v;
00234         }
00235   *maxvalue=f;
00236   return(0);
00237 }
00238 /******************************************************************************/
00239 
00240 /******************************************************************************/