Main Page | Modules | Alphabetical List | Data Structures | File List | Data Fields | Globals

imamax.c

Go to the documentation of this file.
00001 /************************************************************************* 00002 * $Id: imamax.c,v 1.1 2005/09/09 08:22:49 bellet Exp $ 00003 ************************************************************************** 00004 This software is governed by the CeCILL license under French law and 00005 abiding by the rules of distribution of free software. You can use, 00006 modify and/ or redistribute the software under the terms of the CeCILL 00007 license as circulated by CEA, CNRS and INRIA at the following URL 00008 "http://www.cecill.info". 00009 00010 As a counterpart to the access to the source code and rights to copy, 00011 modify and redistribute granted by the license, users are provided only 00012 with a limited warranty and the software's author, the holder of the 00013 economic rights, and the successive licensors have only limited 00014 liability. 00015 00016 In this respect, the user's attention is drawn to the risks associated 00017 with loading, using, modifying and/or developing or reproducing the 00018 software by the user in light of its specific status of free software, 00019 that may mean that it is complicated to manipulate, and that also 00020 therefore means that it is reserved for developers and experienced 00021 professionals having in-depth computer knowledge. Users are therefore 00022 encouraged to load and test the software's suitability as regards their 00023 requirements in conditions enabling the security of their systems and/or 00024 data to be ensured and, more generally, to use and operate it in the 00025 same conditions as regards security. 00026 00027 The fact that you are presently reading this means that you have had 00028 knowledge of the CeCILL license and that you accept its terms. 00029 00030 Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de 00031 l'Image). All rights reserved. See License.txt for details. 00032 00033 Version 1.0 05/09/2005 00034 *************************************************************************/ 00035 00036 /************************************************************************* 00037 * 00038 * Description : Calcule le maxima d'une image non COMPLEX 00039 * 00040 **************************************************************************/ 00041 #include <math.h> 00042 #include <stdio.h> 00043 #include "idima.h" 00044 #include "iderr.h" 00045 #include "idprint.h" 00046 00047 /* FUNCTION DESCRIPTION ************************************************** 00048 * 00049 * IdImaMinima (fonction) 00050 * 00051 * RESUME: Calcule le Minimum d'une image non COMPLEX 00052 * 00053 * DESCRIPTION: Calcule le Minimum d'une image non COMPLEX 00054 * 00055 * SYNTAXE: double min = IdImaMinima(PPIMAGE image); 00056 * 00057 * RETOUR: type : Double 00058 * role : valeur min de l'image. 00059 * 00060 * PARAMETRES: nom : ima 00061 * type : PPIMAGE 00062 * role : Pointeur vers l'image source 00063 * 00064 * FICHIER: IMAMAX.c 00065 * 00066 * EXEMPLE: 00067 * 00068 ******************************************************** END DESCRIPTION */ 00069 00070 #define CCMIN(t1) \ 00071 mini = (double) ((t1)ima)[0][0]; \ 00072 for (i=0;i<Y;i++) for (j=0;j<X;j++) \ 00073 { \ 00074 if (((t1)ima)[i][j]<mini) \ 00075 mini = (double) ((t1)ima)[i][j]; \ 00076 } 00077 00078 double IdImaMinima (PPIMAGE ima) 00079 { 00080 double mini=0.0; /* FB 24-01-2000 */ 00081 int i,j,X,Y; 00082 00083 X=IdImaDimX(ima); 00084 Y=IdImaDimY(ima); 00085 switch(IdImaType(ima)) 00086 { 00087 case IMA_UCHAR: CCMIN(PPIMAGE_UCHAR); break; 00088 case IMA_CHAR: CCMIN(PPIMAGE_CHAR); break; 00089 case IMA_USHORT: CCMIN(PPIMAGE_USHORT); break; 00090 case IMA_SHORT: CCMIN(PPIMAGE_SHORT); break; 00091 case IMA_LONG: CCMIN(PPIMAGE_LONG); break; 00092 case IMA_ULONG: CCMIN(PPIMAGE_ULONG); break; 00093 case IMA_FLOAT: CCMIN(PPIMAGE_FLOAT); break; 00094 case IMA_DOUBLE: CCMIN(PPIMAGE_DOUBLE); break; 00095 default: 00096 { 00097 IdPrintf("Type %d non traitable par la fonction IdImaMinima !\n",IdImaType(ima)); 00098 IdExit(0); 00099 } 00100 } /* Fin du switch */ 00101 00102 return(mini); 00103 } 00104 00105 00106 /* FUNCTION DESCRIPTION ************************************************** 00107 * 00108 * IdImaMaxima (fonction) 00109 * 00110 * RESUME: Calcule le Maximum d'une image non COMPLEX 00111 * 00112 * DESCRIPTION: Calcule le Maximum d'une image non COMPLEX 00113 * 00114 * SYNTAXE: double max = IdImaMaxima (PPIMAGE image); 00115 * 00116 * RETOUR: type : double 00117 * role : valeur max de l'image. 00118 * 00119 * PARAMETRES: nom : ima 00120 * type : PPIMAGE 00121 * role : Pointeur vers l'image source 00122 * 00123 * FICHIER: IMAMAX.c 00124 * 00125 * EXEMPLE: 00126 * 00127 ******************************************************** END DESCRIPTION */ 00128 #include <stdio.h> 00129 #include "idima.h" 00130 00131 #define CC(t1) maxi = (double) ((t1)ima)[0][0]; \ 00132 for (i=0;i<Y;i++) for (j=0;j<X;j++) \ 00133 { \ 00134 if (((t1)ima)[i][j]>maxi) \ 00135 maxi = (double) ((t1)ima)[i][j]; \ 00136 } 00137 00138 00139 00140 double IdImaMaxima(PPIMAGE ima) 00141 { 00142 double maxi; 00143 int i,j,X,Y; 00144 00145 X=IdImaDimX(ima); 00146 Y=IdImaDimY(ima); 00147 switch(IdImaType(ima)) 00148 { 00149 case IMA_UCHAR: CC(PPIMAGE_UCHAR); break; 00150 case IMA_CHAR: CC(PPIMAGE_CHAR); break; 00151 case IMA_USHORT: CC(PPIMAGE_USHORT); break; 00152 case IMA_SHORT: CC(PPIMAGE_SHORT); break; 00153 case IMA_LONG: CC(PPIMAGE_LONG); break; 00154 case IMA_ULONG: CC(PPIMAGE_ULONG); break; 00155 case IMA_FLOAT: CC(PPIMAGE_FLOAT); break; 00156 case IMA_DOUBLE: CC(PPIMAGE_DOUBLE); break; 00157 default: 00158 IdPrintf("Type %d non traitable par la fonction IdImaMaxima !\n",IdImaType(ima)); 00159 IdErrno=IDERR_WRONG_LIBTYPE; 00160 return(0); 00161 } /* Fin du switch */ 00162 00163 return(maxi); 00164 } 00165 00166 00167 /* FUNCTION DESCRIPTION ************************************************** 00168 * 00169 * IdImaMinMax (fonction) 00170 * 00171 * RESUME: Calcule le Min et le Maximum d'une image non COMPLEX 00172 * 00173 * DESCRIPTION: Calcule le Min et le Maximum d'une image non COMPLEX 00174 * 00175 * SYNTAXE: void IdImaMinMax (PPIMAGE image, double *min, double *max); 00176 * 00177 * RETOUR: type : Double 00178 * role : valeur max de l'image. 00179 * 00180 * PARAMETRES: nom : ima 00181 * type : PPIMAGE 00182 * role : Pointeur vers l'image source 00183 * 00184 * FICHIER: IMAMAX.c 00185 * 00186 * EXEMPLE: 00187 * 00188 ******************************************************** END DESCRIPTION */ 00189 00190 00200 #define CCMM(t1) \ 00201 *maxi = *mini = (double) ((t1)ima)[0][0]; \ 00202 for (i=0;i<Y;i++) for (j=0;j<X;j++) \ 00203 { \ 00204 if (((t1)ima)[i][j]>*maxi) \ 00205 { *maxi = (double) ((t1)ima)[i][j]; } \ 00206 else if (((t1)ima)[i][j]<*mini) \ 00207 { *mini = (double) ((t1)ima)[i][j]; } \ 00208 } 00209 00210 int IdImaMinMax ( 00211 PPIMAGE ima, 00212 double *mini, 00213 double *maxi) 00214 00215 { 00216 int i,j,X,Y; 00217 00218 X=IdImaDimX(ima); 00219 Y=IdImaDimY(ima); 00220 00221 00222 switch(IdImaType(ima)) 00223 { 00224 case IMA_UCHAR: CCMM(PPIMAGE_UCHAR); break; 00225 case IMA_CHAR: CCMM(PPIMAGE_CHAR); break; 00226 case IMA_USHORT: CCMM(PPIMAGE_USHORT); break; 00227 case IMA_SHORT: CCMM(PPIMAGE_SHORT); break; 00228 case IMA_LONG: CCMM(PPIMAGE_LONG); break; 00229 case IMA_ULONG: CCMM(PPIMAGE_ULONG); break; 00230 case IMA_FLOAT: CCMM(PPIMAGE_FLOAT); break; 00231 case IMA_DOUBLE: CCMM(PPIMAGE_DOUBLE); break; 00232 default: 00233 IdPrintf("Type %d non traitable par la fonction IdImaMinMax !\n",IdImaType(ima)); 00234 IdErrno=IDERR_WRONG_LIBTYPE; 00235 return(0); 00236 } /* Fin du switch */ 00237 return(1); 00238 } 00239 00240 #define CCMOY(t1) for (i=0;i<Y;i++) for (j=0;j<X;j++) \ 00241 { \ 00242 moy += (double) ((t1)ima)[i][j]; \ 00243 } 00244 00251 double IdImaMoyenne (PPIMAGE ima) 00252 { 00253 double moy; 00254 int i,j,X,Y; 00255 00256 X=IdImaDimX(ima); 00257 Y=IdImaDimY(ima); 00258 moy = 0.0; 00259 switch(IdImaType(ima)) 00260 { 00261 case IMA_UCHAR: CCMOY(PPIMAGE_UCHAR); break; 00262 case IMA_CHAR: CCMOY(PPIMAGE_CHAR); break; 00263 case IMA_USHORT: CCMOY(PPIMAGE_USHORT); break; 00264 case IMA_SHORT: CCMOY(PPIMAGE_SHORT); break; 00265 case IMA_LONG: CCMOY(PPIMAGE_LONG); break; 00266 case IMA_ULONG: CCMOY(PPIMAGE_ULONG); break; 00267 case IMA_FLOAT: CCMOY(PPIMAGE_FLOAT); break; 00268 case IMA_DOUBLE: CCMOY(PPIMAGE_DOUBLE); break; 00269 default: 00270 IdPrintf("Type %d non traitable par la fonction IdImaMoyenne !\n",IdImaType(ima)); 00271 IdErrno=IDERR_WRONG_LIBTYPE; 00272 return(0); 00273 } /* Fin du switch */ 00274 00275 moy = moy /((double)X*(double)Y); 00276 00277 return moy; 00278 } 00279 00280 /* FUNCTION DESCRIPTION ************************************************** 00281 * 00282 * IdImaVariance (fonction) 00283 * 00284 * RESUME: Calcule la Variance d'une image non COMPLEX 00285 * 00286 * DESCRIPTION: Calcule la Variance d'une image non COMPLEX 00287 * 00288 * SYNTAXE: double var = IdImaVariance (PPIMAGE image); 00289 * 00290 * RETOUR: type : Double 00291 * role : variance de l'image. 00292 * 00293 * PARAMETRES: nom : ima 00294 * type : PPIMAGE 00295 * role : Pointeur vers l'image source 00296 * 00297 * FICHIER: IMAMAX.c 00298 * 00299 * EXEMPLE: 00300 * 00301 ******************************************************** END DESCRIPTION */ 00302 00303 #define CCVAR(t1) for (i=0;i<Y;i++) for (j=0;j<X;j++) \ 00304 { \ 00305 var += pow((moy -(double) ( ((t1)ima)[i][j])),2.0 ); \ 00306 } 00307 00308 00309 double IdImaVariance( PPIMAGE ima) 00310 { 00311 double moy,var; 00312 int i,j,X,Y; 00313 00314 X = IdImaDimX(ima); 00315 Y = IdImaDimY(ima); 00316 moy = IdImaMoyenne(ima); 00317 var = 0.0; 00318 00319 switch(IdImaType(ima)) 00320 { 00321 case IMA_UCHAR: CCVAR(PPIMAGE_UCHAR); break; 00322 case IMA_CHAR: CCVAR(PPIMAGE_CHAR); break; 00323 case IMA_USHORT: CCVAR(PPIMAGE_USHORT); break; 00324 case IMA_SHORT: CCVAR(PPIMAGE_SHORT); break; 00325 case IMA_LONG: CCVAR(PPIMAGE_LONG); break; 00326 case IMA_ULONG: CCVAR(PPIMAGE_ULONG); break; 00327 case IMA_FLOAT: CCVAR(PPIMAGE_FLOAT); break; 00328 case IMA_DOUBLE: CCVAR(PPIMAGE_DOUBLE); break; 00329 default: 00330 IdPrintf("Type %d non traitable par la fonction IdImaVariance !\n",IdImaType(ima)); 00331 IdErrno=IDERR_WRONG_LIBTYPE; 00332 return(0); 00333 } /* Fin du switch */ 00334 00335 var = var /((double)X*(double)Y); 00336 00337 return(var); 00338 } 00339 00340 /* FUNCTION DESCRIPTION ************************************************** 00341 * 00342 * IdImaMoyVar (fonction) 00343 * 00344 * RESUME: Calcule la Moyenne et la Variance d'une image non COMPLEX 00345 * 00346 * DESCRIPTION: Calcule la Moyenne et la Variance d'une image non COMPLEX 00347 * 00348 * SYNTAXE: int retCode = IdImaMoyVar (PPIMAGE image, double *moy, double *var); 00349 * 00350 * RETOUR: type : int 00351 * role : code retour (1:OK 0:echec) 00352 * 00353 * PARAMETRES: nom : ima 00354 * type : PPIMAGE 00355 * role : Pointeur vers l'image source 00356 * 00357 * nom : moy 00358 * type : double * 00359 * role : Pointeur vers la Moy 00360 * 00361 * nom : var 00362 * type : double * 00363 * role : Pointeur vers la Var 00364 * * 00365 * EXEMPLE: 00366 * 00367 ******************************************************** END DESCRIPTION */ 00368 00378 #define CCMV(t1) for (i=0;i<Y;i++) for (j=0;j<X;j++) \ 00379 *moy += (double) ((t1)ima)[i][j]; \ 00380 *moy = *moy /((double)X*(double)Y); \ 00381 for (i=0;i<Y;i++) for (j=0;j<X;j++) \ 00382 *var += pow((*moy - ((t1)ima)[i][j]),2.0); 00383 00384 int IdImaMoyVar ( 00385 PPIMAGE ima, 00386 double *moy, 00387 double *var) 00388 { 00389 int i,j,X,Y; 00390 X=IdImaDimX(ima); 00391 Y=IdImaDimY(ima); 00392 00393 *moy = 0.0; 00394 *var = 0.0; 00395 switch(IdImaType(ima)) 00396 { 00397 case IMA_UCHAR: CCMV(PPIMAGE_UCHAR); break; 00398 case IMA_CHAR: CCMV(PPIMAGE_CHAR); break; 00399 case IMA_USHORT: CCMV(PPIMAGE_USHORT); break; 00400 case IMA_SHORT: CCMV(PPIMAGE_SHORT); break; 00401 case IMA_LONG: CCMV(PPIMAGE_LONG); break; 00402 case IMA_ULONG: CCMV(PPIMAGE_ULONG); break; 00403 case IMA_FLOAT: CCMV(PPIMAGE_FLOAT); break; 00404 case IMA_DOUBLE: CCMV(PPIMAGE_DOUBLE); break; 00405 default: 00406 IdPrintf("Type %d non traitable par la fonction IdImaMoyVar !\n",IdImaType(ima)); 00407 IdErrno=IDERR_WRONG_LIBTYPE; 00408 return(0); 00409 } /* Fin du switch */ 00410 00411 *var = *var /((double)X*(double)Y); 00412 return(1); 00413 00414 } 00415 00416 00417 00418 /* FUNCTION DESCRIPTION ************************************************** 00419 * 00420 * IdImaDyn (fonction) 00421 * 00422 * RESUME: Calcule la dynamique d'une image non COMPLEX (reel) 00423 * 00424 * DESCRIPTION: Calcule la dynamique d'une image non COMPLEX (reel) 00425 * 00426 * SYNTAXE: double dyn = IdImaDyn (PPIMAGE image); 00427 * 00428 * RETOUR: type : double 00429 * role : Dynamique de l'image. 00430 * 00431 * PARAMETRES: nom : ima 00432 * type : PPIMAGE 00433 * role : Pointeur vers l'image source 00434 * 00435 * FICHIER: IMAMAX.c 00436 * 00437 * EXEMPLE: 00438 * 00439 ******************************************************** END DESCRIPTION */ 00440 00441 00449 double IdImaDyn (PPIMAGE ima) 00450 { 00451 double dyn; 00452 00453 dyn = (double)IdImaMaxima(ima) -(double)IdImaMinima(ima); 00454 return(dyn); 00455 }

Generated on Wed Oct 19 09:28:34 2005 for SIMRI3D by doxygen 1.3.7