00001 /************************************************************************* 00002 * $Id: idsig-calc.h,v 1.1 2005/09/09 08:22:40 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 __IDSIG_CALC_H__ 00037 #define __IDSIG_CALC_H__ 00038 00039 /* 00040 * Description : SIGNAL related functions 00041 */ 00042 #include "idgen.h" 00043 #include "idswig.h" 00044 00045 #include "idsig-ido.h" 00046 00047 00048 /* 00049 #define _IdSigPrivate(sig) (((PRIVATE_SIGNAL*)(sig) )-1) 00050 00051 #define IdSigDimX(sig_) ( _IdSigPrivate(sig_)->DimX) 00052 #define IdSigUsedNbX(sig_) ( _IdSigPrivate(sig_)->UsedNbX) 00053 00054 #define IdSigSetUsedNbX(sig_,nb) ( _IdSigPrivate(sig_)->UsedNbX=(nb) ) 00055 #define IdSigGetUsedNbX(sig_) ( _IdSigPrivate(sig_)->UsedNbX) 00056 00057 #define IdSigType(sig_) ( _IdSigPrivate(sig_)->Type) 00058 00059 #ifdef SWIG 00060 int IdSigDimX(PSIGNAL); 00061 int IdSigUsedNbX(PSIGNAL); 00062 int IdSigGetUsedNbX(PSIGNAL); 00063 int IdSigSetUsedNbX(PSIGNAL,int); 00064 #endif 00065 00066 00067 */ 00068 00069 00070 /************************************************************************/ 00071 /* fonctions SIGNAL */ 00072 void _IdSigFree (PSIGNAL *); 00073 00074 #define IdSigFree(si) _IdSigFree((PSIGNAL *)&(si) ) /* Anne Chretien */ 00075 00076 #ifdef SWIG 00077 void IdSigFree(PSIGNAL); 00078 #endif 00079 00080 /* PSIGNAL IdSigAllocSubSignal (int, int); IMPOSSIBLE */ 00081 /* PSIGNAL IdSigFreesSubSignal (int, int); INUTILE */ 00082 00083 PSIGNAL IdSigAlloc (int, int); 00084 void IdSigFFT (PSIGNAL_COMPLEX , int); 00085 PSIGNAL_FLOAT IdSigFloatDct1D (PSIGNAL_FLOAT,int,int); 00086 PSIGNAL_DOUBLE IdSigDoubleDct1D (PSIGNAL_DOUBLE,int,int); 00087 00088 PSIGNAL IdSigReadAscFile (char *, int ,int); 00089 int IdSigReadAscFileToSig (char *, PSIGNAL); 00090 int IdSigReadAscFileToSigWithOffset (char *, PSIGNAL, int, int); 00091 PSIGNAL IdSigReadAscFileWithOffset (char *, int, int, int, int); 00092 00093 PSIGNAL IdSigReadRawFile (char *,int ,int); 00094 int IdSigReadRawFileToSig (char *,PSIGNAL); 00095 PSIGNAL IdSigReadRawFileWithOffset (char *,int ,int ,int); 00096 int IdSigReadRawFileToSigWithOffset (char *,PSIGNAL, int); 00097 int IdSigWriteRawFile (char *,PSIGNAL); 00098 int IdPalWriteAsciiFile (char *, PSIGNAL_RGB); 00099 00100 double IdSigMax (PSIGNAL); 00101 double IdSigMin (PSIGNAL); 00102 int IdSigMinMax (PSIGNAL, double * OUTPUT, double * OUTPUT); 00103 int IdSigMinMaxInterv (PSIGNAL, int, int, double * OUTPUT, double * OUTPUT); 00104 PSIGNAL IdSigClear (PSIGNAL); 00105 00106 int IdSigGetRawFileLength (char *,int); 00107 int IdSigGetAscFileLength (char * ,int ,int); 00108 void IdSigSwap (PSIGNAL,int); 00109 PSIGNAL IdSigVecteurToSignal (void *, int, int, int ); 00110 PSIGNAL IdSigModifLongueur (PSIGNAL,int ); 00111 00112 PSIGNAL IdSigCopy (PSIGNAL,PSIGNAL); 00113 PSIGNAL IdSigCastComplex (PSIGNAL,PSIGNAL); 00114 PSIGNAL IdSigCastReal (PSIGNAL,PSIGNAL); 00115 PSIGNAL IdSigCast (PSIGNAL,PSIGNAL); 00116 00117 PSIGNAL_RGB IdPalGreyCol (void); 00118 PSIGNAL_RGB IdPalGrey64 (void); 00119 PSIGNAL_RGB IdPalFalsCol (void); 00120 PSIGNAL_RGB IdPalGreyRedCol (void); 00121 PSIGNAL_RGB IdPalHotMetal (void); 00122 PSIGNAL_RGB IdPalHotMetal128 (void); 00123 PSIGNAL_RGB IdPalHotMetal64 (void); 00124 PSIGNAL_RGB IdPalHotMetal32 (void); 00125 PSIGNAL_RGB IdPalHotMetal16 (void); 00126 PSIGNAL_RGB IdPalHotMetal8 (void); 00127 PSIGNAL_RGB IdPalAnalyseStd (void); 00128 PSIGNAL_RGB IdPalAnalyseRet (void); 00129 PSIGNAL_RGB IdPalGreyRedToYellowCol (int); 00130 00131 #ifndef SWIG 00132 #define IdPalFalseCol IdPalFalsCol 00133 #endif 00134 00135 long int IdSigHistogram (PSIGNAL_UCHAR, long int *, int, int); 00136 00137 PSIGNAL_UCHAR IdSigMedian (PSIGNAL_UCHAR, PSIGNAL_UCHAR, int); 00138 PSIGNAL_UCHAR IdSigConvolve (PSIGNAL_UCHAR,PSIGNAL_FLOAT,PSIGNAL_UCHAR, 00139 double,double); 00140 00141 PSIGNAL IdSigCheckTypeSizeAlloc (PSIGNAL,int,PSIGNAL); 00142 PSIGNAL IdSigCheckSizeAlloc (PSIGNAL,int,PSIGNAL); 00143 PSIGNAL IdSigCheckTypeAlloc (PSIGNAL,int,PSIGNAL); 00144 PSIGNAL IdSigCheckSizeAllocType (PSIGNAL,int,PSIGNAL,int); 00145 PSIGNAL IdSigCheckTypeAllocSize (PSIGNAL,int,PSIGNAL,int); 00146 00147 PSIGNAL_RGB IdPalReadAsciiFile (char *); 00148 int IdPalWriteAsciiFile (char *, PSIGNAL_RGB); 00149 PSIGNAL IdSigMedianGene (PSIGNAL, PSIGNAL, int); 00150 PSIGNAL_USHORT IdSigLutRMNWL (PSIGNAL_USHORT,int,int); 00151 PSIGNAL_USHORT IdSigLutRMNMinMax(PSIGNAL_USHORT,int,int); 00152 PSIGNAL_UCHAR IdSigLut8WL (PSIGNAL_UCHAR, int,int); 00153 PSIGNAL_UCHAR IdSigLut8MinMax (PSIGNAL_UCHAR, int,int); 00154 00155 void IdSigGammaFit (double*, double*, double*, double*, 00156 short int*, double* OUTPUT, double**); 00157 00158 /*************************************************************************/ 00159 00160 /* fonctions internes */ 00161 00162 00163 00164 #define IdSigSameSizeAndType(i1,i2) ( (i1)&&(i2) \ 00165 && (IdSigDimX(i1)==IdSigDimX(i2) ) \ 00166 && (IdSigType(i1)==IdSigType(i2) ) ) 00167 #ifdef SWIG 00168 int IdSigSameSizeAndType(PSIGNAL,PSIGNAL); 00169 #endif 00170 00171 00172 #define IdSigSameSize(i1,i2) ( (i1)&&(i2) \ 00173 && (IdSigDimX(i1)==IdSigDimX(i2) ) ) 00174 #ifdef SWIG 00175 int IdSigSameSize(PSIGNAL,PSIGNAL); 00176 #endif 00177 00178 #define IdSigSameType(i1,i2) ( (i1)&&(i2) \ 00179 && (IdSigType(i1)==IdSigType(i2) ) ) 00180 00181 #ifdef SWIG 00182 int IdSigSameType(PSIGNAL,PSIGNAL); 00183 #endif 00184 00185 00186 #define IdSigAllocLikeSignal(im) ((!(im)) ? 0 \ 00187 : IdSigAlloc ( IdSigDimX(im), \ 00188 IdSigType(im) ) ) 00189 #ifdef SWIG 00190 PSIGNAL IdSigAllocLikeSignal(PSIGNAL); 00191 #endif 00192 00193 00194 00195 /* FUNCTION DESCRIPTION ************************************************** 00196 00197 IdSigDimX (macro) 00198 00199 RESUME: donne la taille d'un objet signal LibIDO (nombre d'echantillons) 00200 00201 DESCRIPTION: donne la taille d'un objet signal LibIDO (nombre d'echantillons) 00202 00203 SYNTAXE: int taille = IdSigDimX (SIGNAL sig); 00204 00205 RETOUR: type : int 00206 role : taille du signal. 00207 00208 PARAMETRES: nom : sig 00209 type : objet signal LibIDO 00210 role : Signal LibIDO a scruter. 00211 00212 ******************************************************** END DESCRIPTION */ 00213 00214 00215 /* FUNCTION DESCRIPTION ************************************************** 00216 00217 IdSigType (macro) 00218 00219 RESUME: Donne le type d'un signal LibIDO. 00220 00221 DESCRIPTION: Donne le type d'un signal LibIDO. 00222 00223 SYNTAXE: int typ_sig = IdSigType (SIGNAL sig); 00224 00225 RETOUR: type : int 00226 role : Type du signal LibIDO. #defini par le tableau suivant : 00227 00228 #define SIG_CHAR (SIG | TY_CHAR) 00229 #define SIG_UCHAR (SIG | TY_UCHAR) 00230 #define SIG_SHORT (SIG | TY_SHORT) 00231 #define SIG_USHORT (SIG | TY_USHORT) 00232 #define SIG_ULONG (SIG | TY_ULONG) 00233 #define SIG_LONG (SIG | TY_LONG) 00234 #define SIG_FLOAT (SIG | TY_FLOAT) 00235 #define SIG_DOUBLE (SIG | TY_DOUBLE) 00236 #define SIG_COMPLEX (SIG | TY_COMPLEX) 00237 #define SIG_RGB (SIG | TY_RGB) 00238 #define SIG_COMPLEX_DOUBLE (SIG | TY_COMPLEX_DOUBLE) 00239 #define SIG_COMPLEX_FLOAT (SIG | TY_COMPLEX_FLOAT ) 00240 #define SIG_COMPLEX_CHAR (SIG | TY_COMPLEX_CHAR ) 00241 #define SIG_COMPLEX_UCHAR (SIG | TY_COMPLEX_UCHAR ) 00242 #define SIG_COMPLEX_SHORT (SIG | TY_COMPLEX_SHORT ) 00243 #define SIG_COMPLEX_USHORT (SIG | TY_COMPLEX_USHORT) 00244 #define SIG_COMPLEX_LONG (SIG | TY_COMPLEX_LONG ) 00245 #define SIG_COMPLEX_ULONG (SIG | TY_COMPLEX_ULONG ) 00246 #define SIG_POINTER (SIG | TY_POINTER ) 00247 PARAMETRES: nom : sig 00248 type : Objet Signal LibIDO 00249 role : Signal a scruter 00250 00251 ******************************************************** END DESCRIPTION */ 00252 00253 00254 /* DEFINITION DESCRIPTION ************************************************** 00255 00256 RESUME: constantes SIG_??? utilisees pour allouer des signaux 00257 00258 DESCRIPTION : constantes SIG_??? utilisees dans les fonctions d'allocation 00259 de signaux permettant de definir le type des echantillons. 00260 00261 : IdSigAlloc, IdSigType, IdLibidoDataType. 00262 00263 : SIG_CHAR : SIG_DOUBLE : SIG_COMPLEX_CHAR : 00264 : SIG_UCHAR : SIG_COMPLEX : SIG_COMPLEX_UCHAR : 00265 : SIG_SHORT : SIG_RGB : SIG_COMPLEX_SHORT : 00266 : SIG_USHORT : SIG_COMPLEX_DOUBLE : SIG_COMPLEX_USHORT : 00267 : SIG_LONG : SIG_COMPLEX_FLOAT : SIG_COMPLEX_LONG : 00268 : SIG_FLOAT : SIG_POINTER 00269 00270 Chaque type (ie UCHAR) est decrit dans : IdLibidoDataType 00271 00272 ******************************************************** END DESCRIPTION */ 00273 00274 00275 /* DEFINITION DESCRIPTION ************************************************** 00276 00277 00278 RESUME: types predefinis pour les signaux (associes a IdLibIdoDataType) 00279 00280 DESCRIPTION : types predefinis pour l'allocation des signaux, associes aux 00281 types predefinis par IdLibIdoDataType. 00282 00283 : IdSigAlloc, IdLibidoDataType. 00284 00285 : PSIGNAL : PSIGNAL_RGB : PSIGNAL_COMPLEX_CHAR : 00286 : PSIGNAL_CHAR : PSIGNAL_SHORT : PSIGNAL_COMPLEX_UCHAR : 00287 : PSIGNAL_UCHAR : PSIGNAL_USHORT : PSIGNAL_COMPLEX_SHORT : 00288 : PSIGNAL_FLOAT : PSIGNAL_LONG : PSIGNAL_COMPLEX_USHORT : 00289 : PSIGNAL_DOUBLE : PSIGNAL_COMPLEX_DOUBLE : PSIGNAL_COMPLEX_LONG : 00290 : PSIGNAL_COMPLEX : PSIGNAL_COMPLEX_FLOAT : PSIGNAL_POINTER 00291 00292 PSIGNAL seul est de type void. 00293 00294 ******************************************************** END DESCRIPTION */ 00295 00296 /* FUNCTION DESCRIPTION ************************************************** 00297 00298 IdSigSameSizeAndType (macro) 00299 00300 RESUME: Comparaison du type et des dimensions de deux signaux. 00301 00302 DESCRIPTION: Comparaison du type et des dimensions de deux signaux. 00303 00304 SYNTAXE: int retCode = IdSigSameSizeAndType(PSIGNAL signal1, PSIGNAL signal2); 00305 00306 RETOUR: type : int 00307 role : Vrai si les deux signaux ont la meme dimension le meme type. 00308 00309 PARAMETRES: nom : signal1, signal2 00310 type : PSIGNAL, ou PSIGNAL_??? 00311 role : Pointeurs vers les signaux a comparer. 00312 00313 ******************************************************** END DESCRIPTION */ 00314 00315 00316 /* FUNCTION DESCRIPTION ************************************************** 00317 00318 IdSigSameSize (macro) 00319 00320 RESUME: Comparaison des dimensions de deux signaux. 00321 00322 DESCRIPTION: Comparaison des dimensions de deux signaux. 00323 00324 SYNTAXE: int retCode = IdSigSameSize(PSIGNAL signal1, PSIGNAL signal2); 00325 00326 RETOUR: type : int 00327 role : Vrai si les deux signaux ont les memes dimensions 00328 00329 PARAMETRES: nom : signal1, signal2 00330 type : PSIGNAL, ou PSIGNAL_??? 00331 role : Pointeurs vers les signaux a comparer. 00332 00333 FICHIER : .h 00334 00335 ******************************************************** END DESCRIPTION */ 00336 00337 /* FUNCTION DESCRIPTION ************************************************** 00338 00339 IdSigSameType (macro) 00340 00341 RESUME: Comparaison du type de deux signaux. 00342 00343 DESCRIPTION: Comparaison du type de deux signaux. 00344 00345 SYNTAXE: int retCode = IdSigSameType(PSIGNAL signal1, PSIGNAL signal2); 00346 00347 RETOUR: type : int 00348 role : Vrai si les deux signaux ont le meme type. 00349 00350 PARAMETRES: nom : signal1, signal2 00351 type : PSIGNAL, ou PSIGNAL_??? 00352 role : Pointeurs vers les signaux a comparer. 00353 00354 ******************************************************** END DESCRIPTION */ 00355 00356 /* FUNCTION DESCRIPTION ************************************************** 00357 00358 IdSigAllocLikeSignal (macro) 00359 00360 RESUME: Alloc. d'1 signal de memes dimensions et type qu'1 autre 00361 00362 DESCRIPTION: Allocation d'un signal de memes dimensions et meme type qu'un autre. 00363 00364 SYNTAXE: PSIGNAL imDest = IdSigAllocLikeSignal (PSIGNAL imSource); 00365 00366 RETOUR: type : PSIGNAL 00367 role : Pointeur vers le signal alloue (a convertir en un type valide : PSIGNAL_UCHAR par exemple ). 00368 00369 PARAMETRES: nom : signal1 00370 type : PSIGNAL, ou PSIGNAL_??? 00371 role : Pointeur vers le signal 'modele'. 00372 00373 ******************************************************** END DESCRIPTION */ 00374 00375 00376 #endif