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

idvol.h

Go to the documentation of this file.
00001 /************************************************************************* 00002 * $Id: idvol.h,v 1.1 2005/09/09 08:22:43 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 #ifndef __IDVOL_H__ 00037 #define __IDVOL_H__ 00038 /* 00039 * Headers for the VOLUME Ido "object". 00040 */ 00041 #include "idgen.h" 00042 #include "idima.h" 00043 #include "idpoint.h" 00044 00045 /* Types de volume 3d */ 00046 00047 #define VOL_CHAR (VOL | TY_CHAR) 00048 #define VOL_UCHAR (VOL | TY_UCHAR) 00049 #define VOL_SHORT (VOL | TY_SHORT) 00050 #define VOL_USHORT (VOL | TY_USHORT) 00051 #define VOL_LONG (VOL | TY_LONG) 00052 #define VOL_ULONG (VOL | TY_ULONG) 00053 #define VOL_FLOAT (VOL | TY_FLOAT) 00054 #define VOL_DOUBLE (VOL | TY_DOUBLE) 00055 #define VOL_COMPLEX (VOL | TY_COMPLEX) 00056 #define VOL_RGB (VOL | TY_RGB) 00057 #define VOL_COMPLEX_DOUBLE (VOL | TY_COMPLEX_DOUBLE) 00058 #define VOL_COMPLEX_FLOAT (VOL | TY_COMPLEX_FLOAT ) 00059 #define VOL_COMPLEX_CHAR (VOL | TY_COMPLEX_CHAR ) 00060 #define VOL_COMPLEX_UCHAR (VOL | TY_COMPLEX_UCHAR ) 00061 #define VOL_COMPLEX_SHORT (VOL | TY_COMPLEX_SHORT ) 00062 #define VOL_COMPLEX_USHORT (VOL | TY_COMPLEX_USHORT) 00063 #define VOL_COMPLEX_LONG (VOL | TY_COMPLEX_LONG ) 00064 #define VOL_COMPLEX_ULONG (VOL | TY_COMPLEX_ULONG ) 00065 #define VOL_BIT (VOL | TY_BIT ) 00066 #define VOL_POINTER (VOL | TY_POINTER ) 00067 00068 /***************************************************************/ 00069 typedef void *** PPPVOLUME; 00070 typedef char *** PPPVOLUME_CHAR; 00071 typedef unsigned char *** PPPVOLUME_UCHAR; 00072 typedef float *** PPPVOLUME_FLOAT; 00073 typedef double *** PPPVOLUME_DOUBLE; 00074 typedef COMPLEX *** PPPVOLUME_COMPLEX; 00075 typedef RGB *** PPPVOLUME_RGB; 00076 typedef short *** PPPVOLUME_SHORT; 00077 typedef unsigned short *** PPPVOLUME_USHORT; 00078 typedef long *** PPPVOLUME_LONG; 00079 typedef unsigned long *** PPPVOLUME_ULONG; 00080 typedef COMPLEX_DOUBLE *** PPPVOLUME_COMPLEX_DOUBLE; 00081 typedef COMPLEX_FLOAT *** PPPVOLUME_COMPLEX_FLOAT; 00082 typedef COMPLEX_CHAR *** PPPVOLUME_COMPLEX_CHAR; 00083 typedef COMPLEX_UCHAR *** PPPVOLUME_COMPLEX_UCHAR; 00084 typedef COMPLEX_SHORT *** PPPVOLUME_COMPLEX_SHORT; 00085 typedef COMPLEX_USHORT *** PPPVOLUME_COMPLEX_USHORT; 00086 typedef COMPLEX_LONG *** PPPVOLUME_COMPLEX_LONG; 00087 typedef COMPLEX_ULONG *** PPPVOLUME_COMPLEX_ULONG; 00088 typedef PPPVOLUME_UCHAR PPPVOLUME_BIT; 00089 typedef void **** PPPVOLUME_POINTER; 00090 00091 /* structure VOLUME */ 00092 00093 typedef struct 00094 { 00095 int UsedNbZ; 00096 int UsedNbY; 00097 int UsedNbX; 00098 int subObject; 00099 int DimZ; 00100 int DimY; 00101 int DimX; 00102 int Numero; 00103 char *_message,*_fichier; 00104 int BitsPerPixel; /* nombre de bits reellement utilises */ 00105 int Type; /* IMPERATIVEMENT DERNIER DE LA STRUCTURE */ 00106 00107 } PRIVATE_VOLUME; 00108 00109 #define _IdVolPrivate(vol) ( ((PRIVATE_VOLUME*)(vol) )-1 ) 00110 00111 #include "idvol-restricted.h" 00112 00113 00114 #ifdef SWIG 00115 int IdVolGetBit(PPPVOLUME_UCHAR,int,int,int); 00116 void IdVolPutBit(PPPVOLUME_UCHAR,int,int,int,int); 00117 #else 00118 #define IdVolGetBit(vol,x,y,z) (((vol)[z][y][(x)>>3]>>((x)&7) )&1) 00119 #define IdVolPutBit(vol,x,y,z,n) \ 00120 ( (n) \ 00121 ? ( ((vol)[z][y][x>>3])|= (1<<((x)&7) ) ) \ 00122 : ( ((vol)[z][y][x>>3])&=~(1<<((x)&7) ) ) ) 00123 #endif 00124 00125 /* 00126 utilisation: 00127 00128 #include <idvol.h> 00129 PPPVOLUME_UCHAR vouser; 00130 vouser=(PPPVOLUME_UCHAR)IdVolAlloc(...); 00131 .../... 00132 vouser[i][j] 00133 IdVolDimX(vouser) 00134 .../... 00135 IdVolFree(vouser); 00136 */ 00137 00138 /* Allocation d'un volume identique a un autre */ 00139 #ifndef SWIG 00140 00141 #define IdVolAllocLikeVolume(vo) ((!(vo) ) ? 0 \ 00142 : IdVolAlloc(IdVolDimX(vo), IdVolDimY(vo), \ 00143 IdVolDimZ(vo), IdVolType(vo) ) ) 00144 00145 /* Test d'egalite des dimensions et du type de deux volumes */ 00146 00147 #define IdVolSameSizeAndType(vo1,vo2) ((IdVolDimX(vo1)==IdVolDimX(vo2) ) && \ 00148 (IdVolDimY(vo1)==IdVolDimY(vo2) ) && \ 00149 (IdVolDimZ(vo1)==IdVolDimZ(vo2) ) && \ 00150 (IdVolType(vo1)==IdVolType(vo2) ) ) 00151 00152 /* Test d'egalite des dimensions de deux volumes */ 00153 00154 #define IdVolSameSize(vo1,vo2) ((IdVolDimX(vo1)==IdVolDimX(vo2) ) && \ 00155 (IdVolDimY(vo1)==IdVolDimY(vo2) ) && \ 00156 (IdVolDimZ(vo1)==IdVolDimZ(vo2) )) 00157 00158 /* Test d'egalite du type de deux volumes */ 00159 00160 #define IdVolSameType(vo1,vo2) ((IdVolDimX(vo1)==IdVolDimX(vo2) ) && \ 00161 (IdVolType(vo1)==IdVolType(vo2) ) ) 00162 #define IdVolType(volume_) ( (_IdVolPrivate(volume_) )->Type) 00163 #endif 00164 00165 #ifndef SWIG 00166 #define IdVolDimX(volume_) ( (_IdVolPrivate(volume_) )->DimX) 00167 #define IdVolDimY(volume_) ( (_IdVolPrivate(volume_) )->DimY) 00168 #define IdVolDimZ(volume_) ( (_IdVolPrivate(volume_) )->DimZ) 00169 00170 #define IdVolUsedNbX(volume_) ( (_IdVolPrivate(volume_) )->UsedNbX) 00171 #define IdVolUsedNbY(volume_) ( (_IdVolPrivate(volume_) )->UsedNbY) 00172 #define IdVolUsedNbZ(volume_) ( (_IdVolPrivate(volume_) )->UsedNbZ) 00173 00174 #define IdVolSetUsedNbX(vol_,nb) ( _IdVolPrivate(vol_)->UsedNbX=(nb) ) 00175 #define IdVolGetUsedNbX(vol_) ( _IdVolPrivate(vol_)->UsedNbX) 00176 #define IdVolSetUsedNbY(vol_,nb) ( _IdVolPrivate(vol_)->UsedNbY=(nb) ) 00177 #define IdVolGetUsedNbY(vol_) ( _IdVolPrivate(vol_)->UsedNbY) 00178 #define IdVolSetUsedNbZ(vol_,nb) ( _IdVolPrivate(vol_)->UsedNbZ=(nb) ) 00179 #define IdVolGetUsedNbZ(vol_) ( _IdVolPrivate(vol_)->UsedNbZ) 00180 00181 #else 00182 int IdVolDimX(PPPVOLUME); 00183 int IdVolDimY(PPPVOLUME); 00184 int IdVolDimZ(PPPVOLUME); 00185 00186 int IdVolUsedNbX(PPPVOLUME); 00187 int IdVolUsedNbY(PPPVOLUME); 00188 int IdVolUsedNbZ(PPPVOLUME); 00189 00190 int IdVolGetUsedNbX(PPPVOLUME); 00191 int IdVolGetUsedNbY(PPPVOLUME); 00192 int IdVolGetUsedNbZ(PPPVOLUME); 00193 00194 void IdVolSetUsedNbX(PPPVOLUME,int); 00195 void IdVolSetUsedNbY(PPPVOLUME,int); 00196 void IdVolSetUsedNbZ(PPPVOLUME,int); 00197 #endif // SWIG 00198 00199 #ifdef SWIG 00200 PPPVOLUME IdVolAllocLikeVolume(PPPVOLUME); 00201 00202 int IdVolSameSizeAndType(PPPVOLUME,PPPVOLUME); 00203 int IdVolSameSize(PPPVOLUME,PPPVOLUME); 00204 int IdVolSameType(PPPVOLUME,PPPVOLUME); 00205 int IdVolType(PPPVOLUME); 00206 00207 #endif // SWIG 00208 00209 /************************************************************************/ 00210 /* fonctions VOLUME */ 00211 00212 PPPVOLUME IdVolAlloc (int, int, int, int); 00213 PPPVOLUME IdVolVecteurToVolume ( void *, int, int, int, int ); 00214 00215 int IdVolReadRawFileToVol (char*, PPPVOLUME); 00216 PPPVOLUME IdVolReadRawFile (char*, int, int, int, int); 00217 int IdVolWriteRawFile (char*, PPPVOLUME); 00218 PPPVOLUME IdVolReadRawFileWithOffset (char*, int, int, int, int,int); 00219 PPPVOLUME IdVolClear (PPPVOLUME); 00220 PPPVOLUME_UCHAR 00221 IdVolSetValue (PPPVOLUME_UCHAR, int); 00222 void IdVolArrondi (PPPVOLUME); 00223 double IdVolMaxima (PPPVOLUME); 00224 double IdVolMinima (PPPVOLUME); 00225 int IdVolMinMax (PPPVOLUME, double *OUTPUT, 00226 double *OUTPUT); 00227 00228 double IdVolDyn (PPPVOLUME); 00229 double IdVolMoyenne (PPPVOLUME); 00230 double IdVolVariance (PPPVOLUME); 00231 int IdVolMoyVar (PPPVOLUME, double *, double *); 00232 double IdVolEntropie (PPPVOLUME); 00233 PSIGNAL_FLOAT IdVolHisto (PPPVOLUME); 00234 double IdVolMaxPlanX (PPPVOLUME,int); 00235 double IdVolMaxPlanY (PPPVOLUME,int); 00236 double IdVolMaxPlanZ (PPPVOLUME,int); 00237 PPPVOLUME IdVolCutVolume (PPPVOLUME,double); 00238 PPPVOLUME IdVolCopy (PPPVOLUME,PPPVOLUME); 00239 PPPVOLUME IdVolCast (PPPVOLUME,PPPVOLUME); 00240 PPPVOLUME IdVolCastReal (PPPVOLUME,PPPVOLUME); 00241 PPPVOLUME IdVolCastRealSigne (PPPVOLUME,PPPVOLUME); 00242 PPPVOLUME IdVolCastComplex (PPPVOLUME,PPPVOLUME); 00243 PPPVOLUME IdVolAllocSubVolume (PPPVOLUME, int, int, int, int, 00244 int, int); 00245 PPPVOLUME IdVolModifSubVolume (PPPVOLUME, PPPVOLUME, int, int, int); 00246 PPPVOLUME IdVolExtractSubVolume (PPPVOLUME, PPPVOLUME, int, int, 00247 int, int, int, int); 00248 void IdVolSwap (PPPVOLUME, int); 00249 00251 int IdVolDericheSmoothX (PPPVOLUME_FLOAT, double [], PPPVOLUME_FLOAT); 00252 int IdVolDericheSmoothY (PPPVOLUME_FLOAT, double [], PPPVOLUME_FLOAT); 00253 int IdVolDericheSmoothZ (PPPVOLUME_FLOAT, double [], PPPVOLUME_FLOAT); 00254 int IdVolDericheDeriveX (PPPVOLUME_FLOAT, double [], PPPVOLUME_FLOAT); 00255 int IdVolDericheDeriveY (PPPVOLUME_FLOAT, double [], PPPVOLUME_FLOAT); 00256 int IdVolDericheDeriveZ (PPPVOLUME_FLOAT, double [], PPPVOLUME_FLOAT); 00257 PPPVOLUME_FLOAT IdVolDericheGradX (PPPVOLUME_FLOAT, double); 00258 PPPVOLUME_FLOAT IdVolDericheGradY (PPPVOLUME_FLOAT, double); 00259 PPPVOLUME_FLOAT IdVolDericheGradZ (PPPVOLUME_FLOAT, double); 00260 PPPVOLUME_UCHAR IdVolDericheGradMagn (PPPVOLUME_FLOAT, 00261 PPPVOLUME_FLOAT, 00262 PPPVOLUME_FLOAT); 00263 00264 //CLEAN ME PPPVOLUME_UCHAR IdVolGradMagn (PPPVOLUME_FLOAT, 00265 //CLEAN ME PPPVOLUME_FLOAT, PPPVOLUME_FLOAT); 00266 00267 00268 PPPVOLUME_UCHAR IdVolBool (PPPVOLUME_UCHAR, PPPVOLUME_UCHAR, int); 00269 PPPVOLUME_UCHAR IdVolDilate (PPPVOLUME_UCHAR, PPPVOLUME_UCHAR, int,int); 00270 PPPVOLUME_UCHAR IdVolNDilate (PPPVOLUME_UCHAR, PPPVOLUME_UCHAR, int, int, 00271 int); 00272 PPPVOLUME_UCHAR IdVolErode (PPPVOLUME_UCHAR, PPPVOLUME_UCHAR, int,int); 00273 PPPVOLUME_UCHAR IdVolNErode (PPPVOLUME_UCHAR, PPPVOLUME_UCHAR, int, 00274 int, int); 00275 PPPVOLUME_UCHAR IdVolDericheProcess(char *, int, double, int *, VOID_FUNCTION_CHARP_INT_POINTER ); 00276 PPPVOLUME_UCHAR IdVolExtremSearch (PPPVOLUME_UCHAR, PPPVOLUME_SHORT *, int); 00277 PPPVOLUME_UCHAR IdVolGetGradientMagnitude 00278 (PPPVOLUME_SHORT, PPPVOLUME_SHORT, 00279 PPPVOLUME_SHORT); 00280 int IdVolStatFloat (PPPVOLUME_FLOAT, float *); 00281 PPPVOLUME_UCHAR IdVolGradientHyster(PPPVOLUME_UCHAR *, PPPVOLUME_SHORT *, 00282 double, int*); 00283 PPPVOLUME_UCHAR IdVolUcharAd (PPPVOLUME_UCHAR,int,int,int,int, 00284 int,int,int); 00285 PPPVOLUME_FLOAT IdVolFloatAd (PPPVOLUME_FLOAT,double,int,int,int, 00286 int,int,int); 00287 double IdVolSnrFloat (PPPVOLUME_FLOAT,PPPVOLUME_FLOAT); 00288 double IdVolSnrDyn255Float 00289 (PPPVOLUME_FLOAT, PPPVOLUME_FLOAT); 00290 00291 double IdVolDistorsionFloat 00292 (PPPVOLUME_FLOAT,PPPVOLUME_FLOAT); 00293 double IdVolNorm2 (PPPVOLUME); 00294 double IdVolNorm1 (PPPVOLUME); 00295 PPPVOLUME_DOUBLE IdVolDoubleDCT (PPPVOLUME_DOUBLE); 00296 PPPVOLUME_DOUBLE IdVolUcharDCT (PPPVOLUME_UCHAR); 00297 PPPVOLUME_DOUBLE IdVolDoubleIDCT (PPPVOLUME_DOUBLE); 00298 PPPVOLUME_DOUBLE IdVolDoubleDCTJP (PPPVOLUME_DOUBLE); 00299 PPPVOLUME_DOUBLE IdVolUcharDCTJP (PPPVOLUME_UCHAR); 00300 PPPVOLUME_DOUBLE IdVolDoubleIDCTJP (PPPVOLUME_DOUBLE); 00301 00302 PPPVOLUME_UCHAR IdVolRecad16To8 (PPPVOLUME_USHORT,int,int); 00303 PPPVOLUME_UCHAR IdVolRecadTo8 (PPPVOLUME,PPPVOLUME_UCHAR,double,double); 00304 00305 PPPVOLUME IdVolCheckTypeSizeAlloc (PPPVOLUME,int,PPPVOLUME); 00306 PPPVOLUME IdVolCheckSizeAlloc (PPPVOLUME,int,PPPVOLUME); 00307 PPPVOLUME IdVolCheckTypeAlloc (PPPVOLUME,int,PPPVOLUME); 00308 PPPVOLUME IdVolCheckSizeAllocType (PPPVOLUME,int,PPPVOLUME,int); 00309 PPPVOLUME IdVolCheckTypeAllocSize (PPPVOLUME,int,PPPVOLUME,int,int,int); 00310 00311 00312 int IdVolCalcNbPlanInterp (PPPVOLUME_UCHAR, double, double, double, 00313 double, double, double, int*, int*, int*); 00314 PPPVOLUME_UCHAR IdVolInsertPlan (PPPVOLUME_UCHAR, int, int, int); 00315 int IdVolNearestNeighborInterpolation 00316 (PPPVOLUME_UCHAR, int, int, int); 00317 int IdVolLinearInterpolation (PPPVOLUME_UCHAR, int, int, int); 00318 int IdVolTriLinearInterpolation (PPPVOLUME_UCHAR, int, int, int); 00319 00320 PPPVOLUME IdVolAddBord (PPPVOLUME,double,int,int,int,int,int,int); 00321 PPPVOLUME IdVolObjToVolume (void *,PPPVOLUME); 00322 PPPVOLUME_FLOAT IdVolWanYu (PPPVOLUME_UCHAR, PPPVOLUME_FLOAT, int, 00323 int, int, int, int, int, int, int, int, 00324 double); 00325 int IdVolGradFloatToShort (char *,PPPVOLUME_SHORT *,VOID_FUNCTION_CHARP_INT_POINTER); 00326 00327 PPPVOLUME IdVolSeuil (PPPVOLUME, PPPVOLUME, double, double, double); 00328 PPPVOLUME IdVolStrechHisto (PPPVOLUME, PPPVOLUME, double, double); 00329 PPPVOLUME IdVolStrechHistoGene (PPPVOLUME, PPPVOLUME, double, double, 00330 double,double); 00331 00332 PPPVOLUME IdVolStrechHistoGeneBin(PPPVOLUME, PPPVOLUME, double, double, double, 00333 double,double); 00334 00335 00336 #ifdef SWIG 00337 #define IdVolSubImageFromPlan(a,b,c,d,e) \ 00338 IdVolSubImageXYFromPlan((a),(b),(c),(d),(e) ) 00339 #define IdVolModifSubImage(a,b,c,d,e) \ 00340 IdVolModifSubImageXY ((a),(b),(c),(d),(e) ) 00341 #endif 00342 00343 int IdVolSkelRempTrous (PPPVOLUME_UCHAR, PPPVOLUME_UCHAR, 00344 PPPVOLUME_UCHAR, int *OUTPUT, int *OUTPUT, 00345 int *OUTPUT, float *OUTPUT, float *OUTPUT); 00346 int IdVolSkel (PPPVOLUME_UCHAR,PSIGNAL_FLOAT * OUTPUT); 00347 int IdVolSkelBarb (PPPVOLUME_UCHAR,PSIGNAL_FLOAT * OUTPUT); 00348 00349 PPPVOLUME_UCHAR IdVolRecadTo8DCT(PPPVOLUME,PPPVOLUME_UCHAR); 00350 PPPVOLUME_UCHAR IdVolRecadTo8LOG(PPPVOLUME,PPPVOLUME_UCHAR); 00351 PPPVOLUME_UCHAR IdVolRecadTo8ABS(PPPVOLUME,PPPVOLUME_UCHAR); 00352 00353 PPPVOLUME_COMPLEX IdVolFFT (PPPVOLUME); 00354 PPPVOLUME_COMPLEX IdVolIFFT (PPPVOLUME_COMPLEX); 00355 00356 PPPVOLUME_UCHAR IdVolAutoThresholdChow (PPPVOLUME , int); 00357 00358 #define IdVolVolumeToTabIma(v) IdVolVolumeToTabImaXY(v) 00359 00360 PPPVOLUME IdVolSubstract (PPPVOLUME, PPPVOLUME, PPPVOLUME, double, double); 00361 PPPVOLUME IdVolSousEch (PPPVOLUME, int, int, int); 00362 00363 int IdVolMinMaxSubVolNoLoad (char *, int, int, int, int, int, int, 00364 int, int, int, int, int, long int, 00365 double * OUTPUT, double * OUTPUT); 00366 int IdVolMinMaxNoLoad (char *, int, int, int, int, int, long int, 00367 double * OUTPUT, double * OUTPUT); 00368 PPPVOLUME IdVolSubArrayToVolume (void ***, int, int, int, int, int, int, 00369 int, int, int, int); 00370 PPPVOLUME IdVolArrayToVolume (void ***, int, int, int, int); 00371 00372 00373 PPIMAGE IdVolGetPlane (PPPVOLUME, int, int); 00374 int IdVolSetPlane (PPPVOLUME,int,int,PPIMAGE); 00375 PPPVOLUME IdVolTabImaToVolume(PPIMAGE *, int); 00376 PPIMAGE IdVolMipEasy (PPPVOLUME, int); 00377 PPIMAGE IdVolMipEasySubVol(PPPVOLUME, int, int, int, int, int, 00378 int, int); 00379 PPIMAGE IdVolSubImageXYFromPlan (PPPVOLUME, int, int, int, int, int); 00380 PPIMAGE IdVolModifSubImageXY (PPPVOLUME, PPIMAGE, int, int, int); 00381 PPIMAGE IdVolSubImageXZFromPlan (PPPVOLUME, int, int, int, int, int); 00382 PPIMAGE IdVolModifSubImageXZ (PPPVOLUME, PPIMAGE, int, int, int); 00383 PPIMAGE * IdVolVolumeToTabImaXY (PPPVOLUME); 00384 PPIMAGE * IdVolVolumeToTabImaXZ (PPPVOLUME); 00385 PPPVOLUME_UCHAR IdVolImageACM (PPIMAGE_UCHAR); 00386 PPIMAGE_UCHAR IdVolImageACMCreeGraphe(PPIMAGE_UCHAR, PPPVOLUME_UCHAR); 00387 PPIMAGE_UCHAR IdVolImageCheminMinimal(PPPVOLUME_UCHAR, int, int, int, int); 00388 00389 double IdVolMinPlanX(PPPVOLUME vol, int X); 00390 double IdVolMinPlanY(PPPVOLUME vol, int Y); 00391 double IdVolMinPlanZ(PPPVOLUME vol, int Y); 00392 00393 PPPVOLUME IdVolRotate90(PPPVOLUME); 00394 PPPVOLUME_UCHAR IdVolUcharSup(PPPVOLUME_UCHAR, int, int, int, int, int, int); 00395 PPPVOLUME_FLOAT IdVolFloatSup(PPPVOLUME_FLOAT, int, int, int, int, int, int); 00396 00397 00398 /*######################################################################*/ 00399 00400 /* Fonctions internes */ 00401 00402 #ifndef SWIG 00403 #define IdVolFree(pi) _IdVolFree((PPPVOLUME*)&(pi)) 00404 #define IdVolFreeSubVolume(pi) _IdVolFreeSubVolume((PPPVOLUME*)&(pi)) 00405 #else 00406 void IdVolFree (PPPVOLUME); 00407 void IdVolFreeSubVolume (PPPVOLUME); 00408 #endif 00409 00410 /************************************************************************/ 00411 00412 #endif 00413 00414 00415 /* FUNCTION DESCRIPTION ************************************************** 00416 00417 IdVolDimX (macro) 00418 00419 RESUME: Donne la taille sur l'axe X du Volume LibIDO considere. 00420 00421 DESCRIPTION: Donne la taille sur l'axe X du Volume LibIDO considere. 00422 00423 SYNTAXE: int dimx = IdVolDimX ( PPPVOLUME vol); 00424 00425 RETOUR: type : int 00426 role : taille en X du volume. 00427 00428 PARAMETRES: nom : vol 00429 type : objet volume LibIDO 00430 role : volume LibIDO a scruter 00431 00432 FICHIER: IDVOL.H 00433 00434 ******************************************************** END DESCRIPTION */ 00435 00436 00437 /* FUNCTION DESCRIPTION ************************************************** 00438 00439 IdVolDimY (macro) 00440 00441 RESUME: Donne la taille sur l'axe Y du Volume LibIDO considere. 00442 00443 DESCRIPTION: Donne la taille sur l'axe Y du Volume LibIDO considere. 00444 00445 SYNTAXE: int dimY= IdVolDimY ( PPPVOLUME vol); 00446 00447 RETOUR: type : int 00448 role : taille en Y du volume. 00449 00450 PARAMETRES: nom : vol 00451 type : objet volume LibIDO 00452 role : volume LibIDO a scruter 00453 00454 FICHIER: IDVOL.H 00455 00456 ******************************************************** END DESCRIPTION */ 00457 00458 00459 /* FUNCTION DESCRIPTION ************************************************** 00460 00461 IdVolDimZ (macro) 00462 00463 RESUME: Donne la taille sur l'axe Z du Volume LibIDO considere. 00464 00465 DESCRIPTION: Donne la taille sur l'axe Z du Volume LibIDO considere. 00466 00467 SYNTAXE: int dimz= IdVolDimZ ( PPPVOLUME vol); 00468 00469 RETOUR: type : int 00470 role : taille en Z du volume. 00471 00472 PARAMETRES: nom : vol 00473 type : objet volume LibIDO 00474 role : volume LibIDO a scruter 00475 00476 FICHIER: IDVOL.H 00477 00478 ******************************************************** END DESCRIPTION */ 00479 00480 00481 /* FUNCTION DESCRIPTION ************************************************** 00482 00483 IdVolType (macro) 00484 00485 RESUME: Donne le type d'un volume LibIDO 00486 00487 DESCRIPTION: Donne le type d'un volume LibIDO 00488 00489 SYNTAXE: int typ_vol = IdVolType (PPPVOLUME vol); 00490 00491 RETOUR: type : int 00492 role : Type du Volume LibIDO. #defini par le tableau suivant : 00493 00494 #define VOL_CHAR (VOL | TY_CHAR) 00495 #define VOL_UCHAR (VOL | TY_UCHAR) 00496 #define VOL_SHORT (VOL | TY_SHORT) 00497 #define VOL_USHORT (VOL | TY_USHORT) 00498 #define VOL_LONG (VOL | TY_LONG) 00499 #define VOL_FLOAT (VOL | TY_FLOAT) 00500 #define VOL_DOUBLE (VOL | TY_DOUBLE) 00501 #define VOL_COMPLEX (VOL | TY_COMPLEX) 00502 #define VOL_RGB (VOL | TY_RGB) 00503 #define VOL_COMPLEX_DOUBLE (VOL | TY_COMPLEX_DOUBLE) 00504 #define VOL_COMPLEX_FLOAT (VOL | TY_COMPLEX_FLOAT ) 00505 #define VOL_COMPLEX_CHAR (VOL | TY_COMPLEX_CHAR ) 00506 #define VOL_COMPLEX_UCHAR (VOL | TY_COMPLEX_UCHAR ) 00507 #define VOL_COMPLEX_SHORT (VOL | TY_COMPLEX_SHORT ) 00508 #define VOL_COMPLEX_USHORT (VOL | TY_COMPLEX_USHORT) 00509 #define VOL_COMPLEX_LONG (VOL | TY_COMPLEX_LONG ) 00510 #define VOL_BIT (VOL | TY_BIT ) 00511 00512 PARAMETRES: nom : vol 00513 type : Objet volume LibIDO 00514 role : Volume LibIDO a scruter. 00515 00516 FICHIER: IDVOL.H 00517 00518 ******************************************************** END DESCRIPTION */ 00519 00520 00521 /* DEFINITION DESCRIPTION ************************************************** 00522 00523 idvol.h (constantes) 00524 00525 RESUME: constantes VOL_??? pour definir le type de voxel des volumes a allouer 00526 00527 DESCRIPTION : constantes VOL_??? utilisees dans les fonctions d'allocation 00528 de volumes permettant de definir le type des voxels. 00529 00530 : IdVolAlloc, IdVolType, IdLibidoDataType. 00531 00532 : VOL_CHAR : VOL_DOUBLE : VOL_COMPLEX_UCHAR : 00533 : VOL_UCHAR : VOL_COMPLEX : VOL_COMPLEX_SHORT : 00534 : VOL_SHORT : VOL_RGB : VOL_COMPLEX_USHORT : 00535 : VOL_USHORT : VOL_COMPLEX_DOUBLE : VOL_COMPLEX_LONG : 00536 : VOL_LONG : VOL_COMPLEX_FLOAT : VOL_BIT : 00537 : VOL_FLOAT : VOL_COMPLEX_CHAR : 00538 00539 Chaque type (ie UCHAR) est decrit dans : IdLibidoDataType 00540 00541 00542 ******************************************************** END DESCRIPTION */ 00543 00544 00545 /* DEFINITION DESCRIPTION ************************************************** 00546 00547 idvol.h (types) 00548 00549 RESUME: types predefinis des volumes (associes a IdLibidoDataType) 00550 00551 DEFINITION : types predefinis pour l'allocation des volumes, associes aux types 00552 predefinis par IdLibidoDataType. 00553 00554 : IdVolAlloc, IdLibidoDataType. 00555 00556 : PPPVOLUME : PPPVOLUME_RGB : PPPVOLUME_COMPLEX_CHAR : 00557 : PPPVOLUME_CHAR : PPPVOLUME_SHORT : PPPVOLUME_COMPLEX_UCHAR : 00558 : PPPVOLUME_UCHAR : PPPVOLUME_USHORT : PPPVOLUME_COMPLEX_SHORT : 00559 : PPPVOLUME_FLOAT : PPPVOLUME_LONG : PPPVOLUME_COMPLEX_USHORT : 00560 : PPPVOLUME_DOUBLE : PPPVOLUME_COMPLEX_DOUBLE : PPPVOLUME_COMPLEX_LONG : 00561 : PPPVOLUME_COMPLEX : PPPVOLUME_COMPLEX_FLOAT : PPPVOLUME_BIT : 00562 00563 PPPVOLUME seul est de type void. 00564 00565 ******************************************************** END DESCRIPTION */ 00566 00567 00568 /* FUNCTION DESCRIPTION ************************************************** 00569 00570 IdVolGetBit (macro) 00571 00572 RESUME: Retourne la valeur du voxel de coordonnees x,y,z. 00573 00574 DESCRIPTION: Retourne la valeur du voxel de coordonnees x,y,z. 00575 00576 SYNTAXE: int val = IdVolGetBit(PPVOLUME_BIT vol,int x, int y, int z); 00577 00578 RETOUR: type : int 00579 role : 0 ou 1, selon la valeur du bit du volume. 00580 00581 PARAMETRES: 00582 nom : vol 00583 type : PPVOLUME_BIT 00584 role : Volume de bit. 00585 00586 nom : x, y, z 00587 type : int 00588 role : Coordonnees x, y et z du volume. 00589 00590 FICHIER: idvol.h 00591 00592 ******************************************************** END DESCRIPTION */ 00593 00594 00595 /* FUNCTION DESCRIPTION ************************************************** 00596 00597 IdVolPutBit (macro) 00598 00599 RESUME: Fixe la valeur d'un voxel d'un volume binaire (PPVOLUME_BIT). 00600 00601 DESCRIPTION: Fixe la valeur d'un voxel d'un volume binaire (PPVOLUME_BIT). 00602 00603 SYNTAXE: void IdVolPutBit(PPVOLUME_BIT vol, int x, int y, int z, int valBit); 00604 00605 RETOUR: type : void 00606 role : non defini. 00607 00608 PARAMETRES: 00609 nom : vol 00610 type : PPVOLUME_BIT 00611 role : Volume de bit. 00612 00613 nom : x, y, z 00614 type : int 00615 role : Coordonnees x, y et z du volume. 00616 00617 nom : n 00618 type : int 00619 role : Imperativement 0 ou 1, pour regler la valeur du bit. 00620 00621 FICHIER: idvol.h 00622 00623 ******************************************************** END DESCRIPTION */ 00624 00625 /* FUNCTION DESCRIPTION ************************************************** 00626 00627 IdVolAllocLikeVolume (macro) 00628 00629 RESUME: Alloc. d'1 volume de memes dimensions et type qu'1 autre 00630 00631 DESCRIPTION: Allocation d'un volume de memes dimensions et meme type 00632 qu'une autre. 00633 00634 SYNTAXE: PPPVOLUME vol2 = IdVolAllocLikeVolume (PPPVOLUME vol1); 00635 00636 00637 RETOUR: type : PPPVOLUME 00638 role : Pointeur vers le volume alloue (a convertir en un type 00639 valide : PPPVOLUME_UCHAR par exemple ). 00640 00641 00642 PARAMETRES: nom : vol1 00643 type : PPPVOLUME, ou PPPVOLUME_??? 00644 role : Pointeur vers le volume 'modele'. 00645 00646 FICHIER: idvol.h 00647 00648 ******************************************************** END DESCRIPTION */ 00649 00650 /* FUNCTION DESCRIPTION ************************************************** 00651 00652 IdVolSameSizeAndType (macro) 00653 00654 RESUME: Comparaison du type et des dimensions de deux volumes. 00655 00656 DESCRIPTION: Comparaison du type et des dimensions de deux volumes. 00657 00658 SYNTAXE: int Booleen = IdVolSameSizeAndType(PPPVOLUME vol1, PPPVOLUME vol2); 00659 00660 RETOUR: type : int 00661 role : Vrai si les deux volumes ont la meme dimension et 00662 le meme type. 00663 00664 PARAMETRES: nom : vol1, vol2 00665 type : PPPVOLUME, ou PPPVOLUME_??? 00666 role : Pointeurs vers les volumes a comparer. 00667 00668 FICHIER : idvol.h 00669 00670 ******************************************************** END DESCRIPTION */ 00671 00672 /* FUNCTION DESCRIPTION ************************************************** 00673 00674 IdVolSameSize (macro) 00675 00676 RESUME: Comparaison des dimensions de deux volumes. 00677 00678 DESCRIPTION: Comparaison des dimensions de deux volumes. 00679 00680 SYNTAXE: int Booleen = IdVolSameSize(PPPVOLUME vol1, PPPVOLUME vol2); 00681 00682 RETOUR: type : int 00683 role : Vrai si les deux volumes ont les memes dimensions 00684 00685 PARAMETRES: nom : vol1, vol2 00686 type : PPPVOLUME, ou PPPVOLUME_??? 00687 role : Pointeurs vers les volumes a comparer. 00688 00689 FICHIER : idvol.h 00690 00691 ******************************************************** END DESCRIPTION */ 00692 00693 00694 00695 /* FUNCTION DESCRIPTION ************************************************** 00696 00697 IdVolSameType (macro) 00698 00699 RESUME: Comparaison des types de deux volumes. 00700 00701 DESCRIPTION: Comparaison des types de deux volumes. 00702 00703 SYNTAXE: int Booleen = IdVolSameType(PPPVOLUME vol1, PPPVOLUME vol2); 00704 00705 RETOUR: type : int 00706 role : Vrai si les deux volumes ont le meme type 00707 00708 PARAMETRES: nom : vol1, vol2 00709 type : PPPVOLUME, ou PPPVOLUME_??? 00710 role : Pointeurs vers les volumes a comparer. 00711 00712 FICHIER : idvol.h 00713 00714 ******************************************************** END DESCRIPTION */

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