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

volmax.c

Go to the documentation of this file.
00001 /************************************************************************* 00002 * $Id: volmax.c,v 1.1 2005/09/09 08:22:56 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 #include <stdio.h> 00037 #include <math.h> 00038 #include "idvol.h" 00039 #include "iderr.h" 00040 #include "idprint.h" 00041 /************************************************************************* 00042 * 00043 * Description : Calcule le maxima d'un plan d'un volume non COMPLEXE 00044 * 00045 **************************************************************************/ 00046 00047 00048 /* 00049 * FUNCTION DESCRIPTION ************************************************** 00050 * 00051 * IdVolMaxPlanX (fonction) 00052 * 00053 * RESUME: Calcule le Maximum d'un plan X d'un Vol non COMPLEX 00054 * 00055 * DESCRIPTION: Calcule le Maximum d'un plan X d'un Vol non COMPLEX 00056 * 00057 * SYNTAXE: double max = IdVolMaxX (PPPVOLUME volume,int numPlanX); 00058 * 00059 * RETOUR: type : Double 00060 * acces : O 00061 * role : valeur max du plan. 00062 * 00063 * PARAMETRES: nom : vol 00064 * type : PPPVOLUME 00065 * acces : I, N 00066 * role : Pointeur vers le Volume source 00067 * 00068 * nom : x 00069 * type: entier 00070 * acces: I 00071 * role :numero du plan en X dont on calcule le max 00072 * 00073 * VERSION: V1.00 00074 * 00075 * FICHIER: maxvol.c 00076 * 00077 * EXEMPLE: 00078 * 00079 * ******************************************************** END DESCRIPTION 00080 */ 00081 00082 #define CC(t1) maxi = (double) ((t1)vol)[0][0][X]; \ 00083 for (i=0;i<Z;i++) for (j=0;j<Y;j++) \ 00084 { \ 00085 if (((t1)vol)[i][j][X]>maxi) \ 00086 maxi = (double) ((t1)vol)[i][j][X]; \ 00087 } 00088 00089 double IdVolMaxPlanX(PPPVOLUME vol, int X) 00090 { 00091 double maxi; 00092 int i, j, Y, Z; 00093 00094 Z = IdVolDimZ(vol); 00095 Y = IdVolDimY(vol); 00096 switch (IdVolType(vol)) { 00097 case VOL_CHAR: 00098 CC(PPPVOLUME_CHAR); 00099 break; 00100 case VOL_UCHAR: 00101 CC(PPPVOLUME_UCHAR); 00102 break; 00103 case VOL_SHORT: 00104 CC(PPPVOLUME_SHORT); 00105 break; 00106 case VOL_USHORT: 00107 CC(PPPVOLUME_USHORT); 00108 break; 00109 case VOL_LONG: 00110 CC(PPPVOLUME_LONG); 00111 break; 00112 case VOL_FLOAT: 00113 CC(PPPVOLUME_FLOAT); 00114 break; 00115 case VOL_DOUBLE: 00116 CC(PPPVOLUME_DOUBLE); 00117 break; 00118 default: 00119 IdErrPrintf 00120 ("Type %d non traitable par la fonction IdVolMaxPlanX !\n", 00121 IdVolType(vol)); 00122 00123 return (0); 00124 } // switch 00125 00126 return (maxi); 00127 } 00128 00129 /* 00130 * FUNCTION DESCRIPTION ************************************************** 00131 * 00132 * IdVolMaxPlanY (fonction) 00133 * 00134 * RESUME: Calcule le Maximum d'un plan Y d'un Volume non COMPLEX 00135 * 00136 * DESCRIPTION: Calcule le Maximum d'un plan Y d'un Volume non COMPLEX 00137 * 00138 * SYNTAXE: double maxi = IdVolMaxY (PPPVOLUME volume,int numPlanY); 00139 * 00140 * RETOUR: type : Double 00141 * acces : O 00142 * role : valeur max du plan. 00143 * 00144 * PARAMETRES: nom : vol 00145 * type : PPPVOLUME 00146 * acces : I, N 00147 * role : Pointeur vers le Volume source 00148 * 00149 * nom : y 00150 * type: entier 00151 * acces: I 00152 * role :numero du plan en Y dont on calcule le max 00153 * 00154 * VERSION: V1.00 00155 * 00156 * FICHIER: maxvol.c 00157 * 00158 * EXEMPLE: 00159 * 00160 * ******************************************************** END DESCRIPTION 00161 */ 00162 00163 #define DD(t1) maxi = (double) ((t1)vol)[0][Y][0]; \ 00164 for (i=0;i<Z;i++) for (k=0;k<X;k++) \ 00165 { \ 00166 if (((t1)vol)[i][Y][k]>maxi) \ 00167 maxi = (double) ((t1)vol)[i][Y][k]; \ 00168 } 00169 00170 double IdVolMaxPlanY(PPPVOLUME vol, int Y) 00171 { 00172 double maxi; 00173 int i, k, X, Z; 00174 00175 X = IdVolDimX(vol); 00176 Z = IdVolDimZ(vol); 00177 switch (IdVolType(vol)) { 00178 case VOL_CHAR: 00179 DD(PPPVOLUME_CHAR); 00180 break; 00181 case VOL_UCHAR: 00182 DD(PPPVOLUME_UCHAR); 00183 break; 00184 case VOL_SHORT: 00185 DD(PPPVOLUME_SHORT); 00186 break; 00187 case VOL_USHORT: 00188 DD(PPPVOLUME_USHORT); 00189 break; 00190 case VOL_LONG: 00191 DD(PPPVOLUME_LONG); 00192 break; 00193 case VOL_FLOAT: 00194 DD(PPPVOLUME_FLOAT); 00195 break; 00196 case VOL_DOUBLE: 00197 DD(PPPVOLUME_DOUBLE); 00198 break; 00199 default: 00200 IdErrPrintf 00201 ("Type %d non traitable par la fonction IdVolMaxPlanY !\n", 00202 IdVolType(vol)); 00203 IdErrno = IDERR_WRONG_LIBTYPE; 00204 return (0); 00205 } // switch 00206 00207 return (maxi); 00208 } 00209 00210 /* 00211 * FUNCTION DESCRIPTION ************************************************** 00212 * 00213 * IdVolMaxPlanZ (fonction) 00214 * 00215 * RESUME: Calcule le Maximum d'un plan Z d'un Volume non COMPLEX 00216 * 00217 * DESCRIPTION: Calcule le Maximum d'un plan Z d'un Volume non COMPLEX 00218 * 00219 * SYNTAXE: double max = IdVolMaxZ (PPPVOLUME volume,int numPlanZ); 00220 * 00221 * RETOUR: type : Double 00222 * acces : O 00223 * role : valeur max du plan. 00224 * 00225 * PARAMETRES: nom : vol 00226 * type : PPPVOLUME 00227 * acces : I, N 00228 * role : Pointeur vers le Volume source 00229 * 00230 * nom : y 00231 * type: entier 00232 * acces: I 00233 * role :numero du plan en Z dont on calcule le max 00234 * 00235 * VERSION: V1.00 00236 * 00237 * FICHIER: maxvol.c 00238 * 00239 * EXEMPLE: 00240 * 00241 * ******************************************************** END DESCRIPTION 00242 */ 00243 00244 #define EE(t1) maxi = (double) ((t1)vol)[Z][0][0]; \ 00245 for (j=0;j<Y;j++) for (k=0;k<X;k++) \ 00246 { \ 00247 if (((t1)vol)[Z][j][k]>maxi) \ 00248 maxi = (double) ((t1)vol)[Z][j][k]; \ 00249 } 00250 00251 double IdVolMaxPlanZ(PPPVOLUME vol, int Z) 00252 { 00253 double maxi; 00254 int j, k, X, Y; 00255 00256 X = IdVolDimX(vol); 00257 Y = IdVolDimY(vol); 00258 switch (IdVolType(vol)) { 00259 case VOL_CHAR: 00260 EE(PPPVOLUME_CHAR); 00261 break; 00262 case VOL_UCHAR: 00263 EE(PPPVOLUME_UCHAR); 00264 break; 00265 case VOL_SHORT: 00266 EE(PPPVOLUME_SHORT); 00267 break; 00268 case VOL_USHORT: 00269 EE(PPPVOLUME_USHORT); 00270 break; 00271 case VOL_LONG: 00272 EE(PPPVOLUME_LONG); 00273 break; 00274 case VOL_FLOAT: 00275 EE(PPPVOLUME_FLOAT); 00276 break; 00277 case VOL_DOUBLE: 00278 EE(PPPVOLUME_DOUBLE); 00279 break; 00280 default: 00281 IdErrPrintf 00282 ("Type %d non traitable par la fonction IdVolMaxPlanZ !\n", 00283 IdVolType(vol)); 00284 IdErrno = IDERR_WRONG_LIBTYPE; 00285 return (0); 00286 } /* 00287 * Fin du switch 00288 */ 00289 00290 return (maxi); 00291 } 00292 00293 00294 00295 /* 00296 * FUNCTION DESCRIPTION ************************************************** 00297 * 00298 * IdVolMaxima (fonction) 00299 * 00300 * RESUME: Calcule le Maximum d'un volume non COMPLEX 00301 * 00302 * DESCRIPTION: Calcule le Maximum d'un volume non COMPLEX 00303 * 00304 * SYNTAXE: double maxi = IdVolMaxima (PPPVOLUME volume); 00305 * 00306 * RETOUR: type : Double 00307 * acces : O 00308 * role : valeur max du volume. 00309 * 00310 * PARAMETRES: nom : vol 00311 * type : PPPVOLUME 00312 * acces : I, N 00313 * role : Pointeur vers le volume source 00314 * 00315 * VERSION: V1.00 00316 * 00317 * FICHIER: maxvol.c 00318 * 00319 * EXEMPLE: 00320 * 00321 * ******************************************************** END DESCRIPTION 00322 */ 00323 00324 #define FF(t1) maxi = (double) ((t1)vol)[0][0][0]; \ 00325 for (t=0;t<Z;t++) for (i=0;i<Y;i++) for (j=0;j<X;j++) \ 00326 { \ 00327 if (((t1)vol)[t][i][j]>maxi) \ 00328 maxi = (double) ((t1)vol)[t][i][j]; \ 00329 } 00330 00331 00332 double IdVolMaxima(PPPVOLUME vol) 00333 { 00334 double maxi; 00335 int i, j, t, X, Y, Z; 00336 00337 X = IdVolDimX(vol); 00338 Y = IdVolDimY(vol); 00339 Z = IdVolDimZ(vol); 00340 switch (IdVolType(vol)) { 00341 case VOL_CHAR: 00342 FF(PPPVOLUME_CHAR); 00343 break; 00344 case VOL_UCHAR: 00345 FF(PPPVOLUME_UCHAR); 00346 break; 00347 case VOL_SHORT: 00348 FF(PPPVOLUME_SHORT); 00349 break; 00350 case VOL_USHORT: 00351 FF(PPPVOLUME_USHORT); 00352 break; 00353 case VOL_LONG: 00354 FF(PPPVOLUME_LONG); 00355 break; 00356 case VOL_FLOAT: 00357 FF(PPPVOLUME_FLOAT); 00358 break; 00359 case VOL_DOUBLE: 00360 FF(PPPVOLUME_DOUBLE); 00361 break; 00362 default: 00363 IdErrPrintf 00364 ("Type %d non traitable par la fonction IdVolMaxima !\n", 00365 IdVolType(vol)); 00366 IdErrno = IDERR_WRONG_LIBTYPE; 00367 return (0); 00368 } // switch 00369 00370 return (maxi); 00371 } 00372 00373 /* 00374 * FUNCTION DESCRIPTION ************************************************** 00375 * 00376 * IdVolMoyenne (fonction) 00377 * 00378 * RESUME: Calcule la Moyenne d'un volume non COMPLEX 00379 * 00380 * DESCRIPTION: Calcule la Moyenne d'un volume non COMPLEX 00381 * 00382 * SYNTAXE: double moy = IdVolMoyenne(PPPVOLUME volume); 00383 * 00384 * RETOUR: type : Double 00385 * acces : O 00386 * role : valeur moyenne du volume. 00387 * 00388 * PARAMETRES: nom : vol 00389 * type : PPPVOLUME 00390 * acces : I, N 00391 * role : Pointeur vers le volume source 00392 * 00393 * VERSION: V1.00 00394 * 00395 * FICHIER: maxvol.c 00396 * 00397 * EXEMPLE: 00398 * 00399 * ******************************************************** END DESCRIPTION 00400 */ 00401 00402 #define HH(t1) for (t=0;t<Z;t++) for (i=0;i<Y;i++) for (j=0;j<X;j++) \ 00403 { \ 00404 moy += (double) ((t1)vol)[t][i][j]; \ 00405 } 00406 00407 00408 double IdVolMoyenne(PPPVOLUME vol) 00409 { 00410 double moy; 00411 int i, j, t, X, Y, Z; 00412 00413 X = IdVolDimX(vol); 00414 Y = IdVolDimY(vol); 00415 Z = IdVolDimZ(vol); 00416 00417 moy = 0.0; 00418 00419 switch (IdVolType(vol)) { 00420 case VOL_CHAR: 00421 HH(PPPVOLUME_CHAR); 00422 break; 00423 case VOL_UCHAR: 00424 HH(PPPVOLUME_UCHAR); 00425 break; 00426 case VOL_SHORT: 00427 HH(PPPVOLUME_SHORT); 00428 break; 00429 case VOL_USHORT: 00430 HH(PPPVOLUME_USHORT); 00431 break; 00432 case VOL_LONG: 00433 HH(PPPVOLUME_LONG); 00434 break; 00435 case VOL_FLOAT: 00436 HH(PPPVOLUME_FLOAT); 00437 break; 00438 case VOL_DOUBLE: 00439 HH(PPPVOLUME_DOUBLE); 00440 break; 00441 default: 00442 IdErrPrintf 00443 ("Type %d non traitable par la fonction IdVolMoyenne !\n", 00444 IdVolType(vol)); 00445 IdErrno = IDERR_WRONG_LIBTYPE; 00446 return (0); 00447 } // switch 00448 00449 moy = moy / ((double) X * (double) Y * (double) Z); 00450 00451 return (moy); 00452 } 00453 00454 /* 00455 * FUNCTION DESCRIPTION ************************************************** 00456 * 00457 * IdVolVariance (fonction) 00458 * 00459 * RESUME: Calcule la Variance d'un volume non COMPLEX 00460 * 00461 * DESCRIPTION: Calcule la Variance d'un volume non COMPLEXe 00462 * 00463 * SYNTAXE: double var = IdVolVariance (PPPVOLUME volume); 00464 * 00465 * RETOUR: type : Double 00466 * acces : O 00467 * role : variance du volume. 00468 * 00469 * PARAMETRES: nom : vol 00470 * type : PPPVOLUME 00471 * acces : I, N 00472 * role : Pointeur vers le volume source 00473 * 00474 * VERSION: V1.00 00475 * 00476 * FICHIER: maxvol.c 00477 * 00478 * EXEMPLE: 00479 * 00480 * ******************************************************** END DESCRIPTION 00481 */ 00482 00483 #define II(t1) \ 00484 for (t=0;t<Z;t++) for (i=0;i<Y;i++) for (j=0;j<X;j++) \ 00485 var += pow((moy - ((t1)vol)[t][i][j]),2.0); 00486 00487 00488 double IdVolVariance(PPPVOLUME vol) 00489 { 00490 double moy, var; 00491 int i, j, t, X, Y, Z; 00492 00493 X = IdVolDimX(vol); 00494 Y = IdVolDimY(vol); 00495 Z = IdVolDimZ(vol); 00496 00497 moy = IdVolMoyenne(vol); 00498 var = 0.0; 00499 00500 switch (IdVolType(vol)) { 00501 case VOL_CHAR: 00502 II(PPPVOLUME_CHAR); 00503 break; 00504 case VOL_UCHAR: 00505 II(PPPVOLUME_UCHAR); 00506 break; 00507 case VOL_SHORT: 00508 II(PPPVOLUME_SHORT); 00509 break; 00510 case VOL_USHORT: 00511 II(PPPVOLUME_USHORT); 00512 break; 00513 case VOL_LONG: 00514 II(PPPVOLUME_LONG); 00515 break; 00516 case VOL_FLOAT: 00517 II(PPPVOLUME_FLOAT); 00518 break; 00519 case VOL_DOUBLE: 00520 II(PPPVOLUME_DOUBLE); 00521 break; 00522 default: 00523 IdErrPrintf 00524 ("Type %d non traitable par la fonction IdVolVariance !\n", 00525 IdVolType(vol)); 00526 IdErrno = IDERR_WRONG_LIBTYPE; 00527 return (0); 00528 } // switch 00529 00530 var = var / ((double) X * (double) Y * (double) Z); 00531 00532 return (var); 00533 } 00534 00535 00536 /* 00537 * FUNCTION DESCRIPTION ************************************************** 00538 * 00539 * IdVolMoyVar (fonction) 00540 * 00541 * RESUME: Renvoie la Moyenne et la Variance d'un volume non COMPLEX 00542 * 00543 * DESCRIPTION: Renvoie la Moyenne et la Variance d'un volume non COMPLEX 00544 * 00545 * SYNTAXE: int retCode = IdVolMoyVar (PPPVOLUME volume, double * Moy, double * Var); 00546 * 00547 * RETOUR: type : int 00548 * acces : O 00549 * role : 0: echec 1 : OK 00550 * 00551 * PARAMETRES: nom : vol 00552 * type : PPPVOLUME 00553 * acces : I, N 00554 * role : Pointeur vers le volume source 00555 * 00556 * nom : moy 00557 * type : double * 00558 * acces : I, N 00559 * role : Pointeur vers la Moy 00560 * 00561 * nom : var 00562 * type : double * 00563 * acces : I, N 00564 * role : Pointeur vers la Var 00565 * 00566 * VERSION: V1.00 00567 * 00568 * FICHIER: maxvol.c 00569 * 00570 * EXEMPLE: 00571 * 00572 * ******************************************************** END DESCRIPTION 00573 */ 00574 00575 #define JJ(t1) for (t=0;t<Z;t++) for (i=0;i<Y;i++) for (j=0;j<X;j++) \ 00576 *moy += (double) ((t1)vol)[t][i][j]; \ 00577 *moy = *moy /((double)X*(double)Y*(double)Z); \ 00578 for (t=0;t<Z;t++) for (i=0;i<Y;i++) for (j=0;j<X;j++) \ 00579 *var += pow((*moy - ((t1)vol)[t][i][j]),2.0); 00580 00581 00582 int IdVolMoyVar(PPPVOLUME vol, double *moy, double *var) 00583 { 00584 int i, j, t, X, Y, Z; 00585 00586 X = IdVolDimX(vol); 00587 Y = IdVolDimY(vol); 00588 Z = IdVolDimZ(vol); 00589 00590 *moy = 0.0; 00591 *var = 0.0; 00592 00593 switch (IdVolType(vol)) { 00594 case VOL_CHAR: 00595 JJ(PPPVOLUME_CHAR); 00596 break; 00597 case VOL_UCHAR: 00598 JJ(PPPVOLUME_UCHAR); 00599 break; 00600 case VOL_SHORT: 00601 JJ(PPPVOLUME_SHORT); 00602 break; 00603 case VOL_USHORT: 00604 JJ(PPPVOLUME_USHORT); 00605 break; 00606 case VOL_LONG: 00607 JJ(PPPVOLUME_LONG); 00608 break; 00609 case VOL_FLOAT: 00610 JJ(PPPVOLUME_FLOAT); 00611 break; 00612 case VOL_DOUBLE: 00613 JJ(PPPVOLUME_DOUBLE); 00614 break; 00615 default: 00616 IdErrPrintf 00617 ("Type %d non traitable par la fonction IdVolMoyVar !\n", 00618 IdVolType(vol)); 00619 IdErrno = IDERR_WRONG_LIBTYPE; 00620 return (0); 00621 } // switch 00622 00623 *var = *var / ((double) X * (double) Y * (double) Z); 00624 00625 return (1); 00626 } 00627 00636 int IdVolMinMax(PPPVOLUME vol, double *mini, double *maxi) 00637 { 00638 #define GG(t1) *mini = *maxi = (double) ((t1)vol)[0][0][0]; \ 00639 for (t=0;t<Z;t++) for (i=0;i<Y;i++) for (j=0;j<X;j++) \ 00640 { \ 00641 if (((t1)vol)[t][i][j]>*maxi) \ 00642 *maxi = (double) ((t1)vol)[t][i][j]; \ 00643 if (((t1)vol)[t][i][j]<*mini) \ 00644 *mini = (double) ((t1)vol)[t][i][j]; \ 00645 } 00646 00647 int i, j, t, X, Y, Z; 00648 00649 X = IdVolDimX(vol); 00650 Y = IdVolDimY(vol); 00651 Z = IdVolDimZ(vol); 00652 00653 switch (IdVolType(vol)) { 00654 case VOL_CHAR: 00655 GG(PPPVOLUME_CHAR); 00656 break; 00657 case VOL_UCHAR: 00658 GG(PPPVOLUME_UCHAR); 00659 break; 00660 case VOL_SHORT: 00661 GG(PPPVOLUME_SHORT); 00662 break; 00663 case VOL_USHORT: 00664 GG(PPPVOLUME_USHORT); 00665 break; 00666 case VOL_LONG: 00667 GG(PPPVOLUME_LONG); 00668 break; 00669 case VOL_FLOAT: 00670 GG(PPPVOLUME_FLOAT); 00671 break; 00672 case VOL_DOUBLE: 00673 GG(PPPVOLUME_DOUBLE); 00674 break; 00675 default: 00676 IdErrPrintf 00677 ("Type %d non traitable par la fonction IdVolMinMax !\n", 00678 IdVolType(vol)); 00679 IdErrno = IDERR_WRONG_LIBTYPE; 00680 return (0); 00681 } // switch 00682 00683 return (1); 00684 }

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