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

imagette.c

Go to the documentation of this file.
00001 /************************************************************************* 00002 * $Id: imagette.c,v 1.1 2005/09/09 08:22:48 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 <math.h> 00037 #include <float.h> 00038 #include <stdio.h> 00039 #include <stdlib.h> 00040 #include "idima.h" 00041 #include "iderr.h" 00042 #include "idprint.h" 00043 00044 static PPIMAGE_DOUBLE imDouble=NULL; 00045 00046 00047 /* FUNCTION DESCRIPTION ************************************************** 00048 * 00049 * IdImaRecadTo8 (fonction) 00050 * 00051 * RESUME: Recadre (Dynamique) une image non COMPLEX ds une image 8 bits 00052 * 00053 * DESCRIPTION: Recadre (Dynamique) une image non COMPLEX ds une image 8 bits 00054 * 00055 * SYNTAXE: PPIMAGE_UCHAR imDest= IdImaRecadTo8 (PPIMAGE imSource, PPIMAGE_UCHAR imDest, double minImpose, double maxImpose); 00056 * 00057 * RETOUR : type : PPIMAGE_UCHAR 00058 * role : ptr sur image recadree. 00059 * 00060 * PARAMETRES: nom : imSource 00061 * type : PPIMAGE 00062 * role : Pointeur vers l'image source 00063 * 00064 * nom : imDest 00065 * type : PPIMAGE_UCHAR 00066 * role : Pointeur vers l' Image destination 00067 * 00068 * nom : minImpose, maxImpose 00069 * type : double 00070 * role : min et max imposes pour le recadrage 00071 * : sans effet si -1.0,-1.0 00072 * 00073 * FICHIER: imagette.c 00074 * 00075 * EXEMPLE: 00076 * 00077 ******************************************************** END DESCRIPTION */ 00078 00079 #define FF1(typeima) \ 00080 \ 00081 if ( (minImpose!=-1.) && (maxImpose!=-1.) ) \ 00082 { \ 00083 mini=minImpose; /* imposes; on les prend */ \ 00084 maxi=maxImpose; \ 00085 \ 00086 MM= maxi-mini; \ 00087 if(MM==0.) \ 00088 { IdErrPrintf (" Min = Max = %g; Impossible recadrer \n",maxi); \ 00089 IdErrno=IDERR_MIN_EQ_MAX; \ 00090 return 0; \ 00091 } \ 00092 \ 00093 for(i=0;i<IdImaDimY(imS);i++) \ 00094 for(j=0;j<IdImaDimX(imS);j++) \ 00095 { \ 00096 pixel = (double)(((typeima)imS)[i][j]); \ 00097 if (pixel>maxi) imD[i][j]=255; \ 00098 else if(pixel<mini) imD[i][j]=0; \ 00099 else { \ 00100 imD[i][j]=(unsigned char) ( (double)( (pixel-mini)*255 ) /MM ); \ 00101 } \ 00102 } \ 00103 } \ 00104 else \ 00105 { \ 00106 maxi= - FLT_MAX; /* non imposes, on les cherche */ \ 00107 mini= FLT_MAX; \ 00108 for(i=0;i<IdImaDimY(imS);i++) \ 00109 for(j=0;j<IdImaDimX(imS);j++) \ 00110 { if((((typeima)imS)[i][j]) > maxi) maxi=(((typeima)imS)[i][j]); \ 00111 if((((typeima)imS)[i][j]) < mini) mini=(((typeima)imS)[i][j]); \ 00112 } \ 00113 \ 00114 /* Recadrage de l'image */ \ 00115 MM=maxi-mini; \ 00116 if(MM==0.) \ 00117 { IdErrPrintf (" Min = Max = %g; Impossible recadrer \n",mini); \ 00118 IdErrno=IDERR_MIN_EQ_MAX; \ 00119 return 0; \ 00120 } \ 00121 \ 00122 for(i=0;i<IdImaDimY(imS);i++) \ 00123 for(j=0;j<IdImaDimX(imS);j++) \ 00124 { \ 00125 imD[i][j]=(unsigned char) ( (double)( ((((typeima)imS)[i][j])-mini)*255 ) /MM ); \ 00126 } \ 00127 } 00128 00129 00130 PPIMAGE_UCHAR IdImaRecadTo8( 00131 PPIMAGE imS, 00132 PPIMAGE_UCHAR imD, 00133 double minImpose, 00134 double maxImpose) 00135 { 00136 double mini,maxi; 00137 double MM; 00138 double pixel; 00139 00140 int i,j; 00141 00142 imD=(PPIMAGE_UCHAR)IdImaCheckSizeAllocType (imS,-1,(PPIMAGE)imD,IMA_UCHAR); 00143 00144 if (!(imD)) 00145 { IdErrPrintf (" IdImaRecadTo8 : echec Alloc Image 8bits \n"); 00146 IdErrno=IDERR_ALLOC_IMA; 00147 return 0; 00148 } 00149 00150 switch(IdImaType(imS)) 00151 { 00152 case IMA_CHAR: FF1(PPIMAGE_CHAR); break; 00153 case IMA_UCHAR: FF1(PPIMAGE_UCHAR); break; 00154 case IMA_SHORT: FF1(PPIMAGE_SHORT); break; 00155 case IMA_USHORT: FF1(PPIMAGE_USHORT); break; 00156 case IMA_LONG: FF1(PPIMAGE_LONG); break; 00157 case IMA_ULONG: FF1(PPIMAGE_ULONG); break; 00158 case IMA_FLOAT: FF1(PPIMAGE_FLOAT); break; 00159 case IMA_DOUBLE: FF1(PPIMAGE_DOUBLE); break; 00160 default: 00161 IdErrPrintf("Type %d non traitable par la fonction IdImaRecadTo8 !\n", IdImaType(imS)); 00162 IdErrno=IDERR_WRONG_LIBTYPE; 00163 return(0); 00164 } 00165 00166 IdSetFileName(imD,IdGetFileName(imS)); 00167 return (imD); 00168 } 00169 00170 /* FUNCTION DESCRIPTION ************************************************** 00171 * 00172 * IdImaRecadTo8DCT (fonction) 00173 * 00174 * RESUME: Recadre (DCT) une image non COMPLEX ds une image 8 bits 00175 * 00176 * DESCRIPTION: Recadre (DCT) une image non COMPLEX ds une image 8 bits 00177 * 00178 * SYNTAXE: PPIMAGE_UCHAR imDest= IdImaRecadTo8DCT (PPIMAGE imSource, PPIMAGE_UCHAR imDest); 00179 * 00180 * RETOUR : type : PPIMAGE_UCHAR 00181 * role : ptr sur image recadree 00182 * 00183 * PARAMETRES: nom : imSource 00184 * type : PPIMAGE 00185 * role : Pointeur vers l'image source 00186 * 00187 * nom : imDest 00188 * type : PPIMAGE_UCHAR 00189 * role : Pointeur vers l'Image destination ou NULL si a creer 00190 * 00191 * FICHIER: imagette.c 00192 * 00193 * EXEMPLE: 00194 * 00195 ******************************************************** END DESCRIPTION */ 00196 00197 #define FF2(typeima) \ 00198 for(i=0;i<IdImaDimY(imS);i++) \ 00199 for(j=0;j<IdImaDimX(imS);j++) \ 00200 imDouble[i][j]=fabs((double)((typeima)imS)[i][j]); 00201 00202 PPIMAGE_UCHAR IdImaRecadTo8DCT( 00203 PPIMAGE imS, 00204 PPIMAGE_UCHAR imD) 00205 { 00206 double mini,maxi; 00207 double MM; 00208 00209 int i,j; 00210 00211 imD=(PPIMAGE_UCHAR)IdImaCheckSizeAllocType (imS,-1,(PPIMAGE)imD,IMA_UCHAR); 00212 00213 if (!(imD)) 00214 { IdErrPrintf ("echec Alloc Image 8bits \n"); 00215 IdErrno=IDERR_ALLOC_IMA; 00216 return (0); 00217 } 00218 00219 imDouble=(PPIMAGE_DOUBLE)IdImaAlloc(IdImaDimX(imS),IdImaDimY(imS),IMA_DOUBLE); 00220 00221 if (!(imDouble)) 00222 { IdErrPrintf (" echec Alloc Image Double\n"); 00223 IdErrno=IDERR_ALLOC_IMA; 00224 return 0; 00225 } 00226 00227 switch(IdImaType(imS)) 00228 { 00229 case IMA_CHAR: FF2(PPIMAGE_CHAR); break; 00230 case IMA_UCHAR: FF2(PPIMAGE_UCHAR); break; 00231 case IMA_SHORT: FF2(PPIMAGE_SHORT); break; 00232 case IMA_USHORT: FF2(PPIMAGE_USHORT); break; 00233 case IMA_LONG: FF2(PPIMAGE_LONG); break; 00234 case IMA_ULONG: FF2(PPIMAGE_ULONG); break; 00235 case IMA_FLOAT: FF2(PPIMAGE_FLOAT); break; 00236 case IMA_DOUBLE: FF2(PPIMAGE_DOUBLE); break; 00237 00238 default: 00239 IdErrPrintf("Type %d non traitable par la fonction IdImaRecadTo8DCT !\n", IdImaType(imS)); 00240 IdErrno=IDERR_WRONG_LIBTYPE; 00241 return(0); 00242 } 00243 00244 imDouble[0][0]=0.; /* On force la valeur DC a 0 */ 00245 00246 for(i=0;i<IdImaDimY(imS);i++) 00247 for(j=0;j<IdImaDimX(imS);j++) 00248 imDouble[i][j]=log(1+imDouble[i][j]); 00249 00250 maxi= - FLT_MAX; 00251 mini= FLT_MAX; 00252 00253 for(i=0;i<IdImaDimY(imS);i++) 00254 for(j=0;j<IdImaDimX(imS);j++) 00255 { if(((imDouble)[i][j]) > maxi) maxi=((imDouble)[i][j]); 00256 if(((imDouble)[i][j]) < mini) mini=((imDouble)[i][j]); 00257 } 00258 00259 /* Recadrage de l'image */ 00260 00261 MM= maxi-mini; 00262 if(MM==0.) 00263 { IdErrPrintf (" Min = Max = %g; Impossible recadrer \n",maxi); 00264 IdErrno=IDERR_MIN_EQ_MAX; 00265 return 0; 00266 } 00267 00268 for(i=0;i<IdImaDimY(imS);i++) 00269 for(j=0;j<IdImaDimX(imS);j++) 00270 { 00271 imD[i][j]=(unsigned char) ( ( (((imDouble)[i][j])-mini)*255 ) /MM ); 00272 } 00273 00274 IdImaFree(imDouble); 00275 00276 return (imD); 00277 } 00278 00279 /* FUNCTION DESCRIPTION ************************************************** 00280 * 00281 * IdImaRecadTo8LOG (fonction) 00282 * 00283 * RESUME: Recadre (LOG) une image non COMPLEX ds une image 8 bits 00284 * 00285 * DESCRIPTION: Recadre (LOG) une image non COMPLEX ds une image 8 bits 00286 * 00287 * SYNTAXE: PPIMAGE_UCHAR imDest= IdImaRecadTo8LOG (PPIMAGE imSource, PPIMAGE_UCHAR imDest); 00288 * 00289 * RETOUR : type : PPIMAGE_UCHAR 00290 * role : Pointeur vers l'image recadree 00291 * 00292 * PARAMETRES: nom : imSource 00293 * type : PPIMAGE 00294 * role : Pointeur vers l'image source 00295 * 00296 * nom : imDest 00297 * type : PPIMAGE_UCHAR 00298 * role : Pointeur vers l'Image destination ou NULL si a creer 00299 * 00300 * FICHIER: IMAGETTE.c 00301 * 00302 * EXEMPLE: 00303 * 00304 ******************************************************** END DESCRIPTION */ 00305 00306 #define FF3(typeima) \ 00307 for(i=0;i<IdImaDimY(imS);i++) \ 00308 for(j=0;j<IdImaDimX(imS);j++) \ 00309 imDouble[i][j]=fabs((double)((typeima)imS)[i][j]); 00310 00311 PPIMAGE_UCHAR IdImaRecadTo8LOG( 00312 PPIMAGE imS, 00313 PPIMAGE_UCHAR imD) 00314 { 00315 double mini,maxi; 00316 double MM; 00317 00318 int i,j; 00319 00320 imD=(PPIMAGE_UCHAR)IdImaCheckSizeAllocType (imS,-1,(PPIMAGE)imD,IMA_UCHAR); 00321 00322 if (!(imD)) 00323 { IdErrPrintf (" echec Alloc Image 8bits \n"); 00324 IdErrno=IDERR_ALLOC_IMA; 00325 return 0; 00326 } 00327 00328 imDouble=(PPIMAGE_DOUBLE)IdImaAlloc(IdImaDimX(imS),IdImaDimY(imS),IMA_DOUBLE); 00329 00330 if (!(imDouble)) 00331 { IdErrPrintf (" echec Alloc Image Double\n"); 00332 IdErrno=IDERR_ALLOC_IMA; 00333 return 0; 00334 } 00335 00336 switch(IdImaType(imS)) 00337 { 00338 case IMA_CHAR: FF3(PPIMAGE_CHAR); break; 00339 case IMA_UCHAR: FF3(PPIMAGE_UCHAR); break; 00340 case IMA_SHORT: FF3(PPIMAGE_SHORT); break; 00341 case IMA_USHORT: FF3(PPIMAGE_USHORT); break; 00342 case IMA_LONG: FF3(PPIMAGE_LONG); break; 00343 case IMA_ULONG: FF3(PPIMAGE_ULONG); break; 00344 case IMA_FLOAT: FF3(PPIMAGE_FLOAT); break; 00345 case IMA_DOUBLE: FF3(PPIMAGE_DOUBLE); break; 00346 00347 default: 00348 IdErrPrintf("Type %d non traitable par la fonction IdImaRecadTo8LOG !\n", IdImaType(imS)); 00349 IdErrno=IDERR_WRONG_LIBTYPE; 00350 return(0); 00351 } 00352 00353 for(i=0;i<IdImaDimY(imS);i++) 00354 for(j=0;j<IdImaDimX(imS);j++) 00355 imDouble[i][j]=log(1.+imDouble[i][j]); 00356 00357 maxi= - FLT_MAX; 00358 mini= FLT_MAX; 00359 00360 for(i=0;i<IdImaDimY(imS);i++) 00361 for(j=0;j<IdImaDimX(imS);j++) 00362 { if(((imDouble)[i][j]) > maxi) maxi=((imDouble)[i][j]); 00363 if(((imDouble)[i][j]) < mini) mini=((imDouble)[i][j]); 00364 } 00365 00366 /* Recadrage de l'image */ 00367 00368 MM= maxi-mini; 00369 if(MM==0.) 00370 { IdErrPrintf (" Min = Max = %g; Impossible recadrer \n",maxi); 00371 IdErrno=IDERR_MIN_EQ_MAX; 00372 return 0; 00373 } 00374 00375 for(i=0;i<IdImaDimY(imS);i++) 00376 for(j=0;j<IdImaDimX(imS);j++) 00377 { 00378 imD[i][j]=(unsigned char) ( ( (((imDouble)[i][j])-mini)*255 ) /MM ); 00379 } 00380 00381 IdImaFree(imDouble); 00382 00383 return (imD); 00384 } 00385 00386 /* FUNCTION DESCRIPTION ************************************************** 00387 * 00388 * IdImaRecadTo8ABS (fonction) 00389 * 00390 * RESUME: Recadre (ABS) une image non COMPLEX ds une image 8 bits 00391 * 00392 * DESCRIPTION: Recadre (ABS) une image non COMPLEX ds une image 8 bits 00393 * 00394 * SYNTAXE: PPIMAGE_UCHAR imDest= IdImaRecadTo8ABS (PPIMAGE imSource, PPIMAGE_UCHAR imDest); 00395 * 00396 * RETOUR : type : PPIMAGE_UCHAR 00397 * role : Pointeur vers l'image destination 00398 * 00399 * PARAMETRES : nom : imSource 00400 * type : PPIMAGE 00401 * role : Pointeur vers l'image source 00402 * 00403 * nom : imDest 00404 * type : PPIMAGE_UCHAR 00405 * role : Pointeur vers l'Image destination ou NULL si a creer 00406 * 00407 * FICHIER: IMAGETTE.c 00408 * 00409 * EXEMPLE: 00410 * 00411 ******************************************************** END DESCRIPTION */ 00412 00413 #define FF4(typeima) \ 00414 for(i=0;i<IdImaDimY(imS);i++) \ 00415 for(j=0;j<IdImaDimX(imS);j++) \ 00416 imDouble[i][j]=fabs((double)((typeima)imS)[i][j]); 00417 00418 00419 PPIMAGE_UCHAR IdImaRecadTo8ABS( 00420 PPIMAGE imS, 00421 PPIMAGE_UCHAR imD) 00422 { 00423 double mini,maxi; 00424 double MM; 00425 00426 int i,j; 00427 00428 imD=(PPIMAGE_UCHAR)IdImaCheckSizeAllocType (imS,-1,(PPIMAGE)imD,IMA_UCHAR); 00429 00430 if (!(imD)) 00431 { IdErrPrintf (" echec Alloc Image 8bits \n"); 00432 IdErrno=IDERR_ALLOC_IMA; 00433 return 0; 00434 } 00435 00436 imDouble=(PPIMAGE_DOUBLE)IdImaAlloc(IdImaDimX(imS),IdImaDimY(imS),IMA_DOUBLE); 00437 00438 if (!(imDouble)) 00439 { IdErrPrintf (" echec Alloc Image Double\n"); 00440 IdErrno=IDERR_ALLOC_IMA; 00441 return 0; 00442 } 00443 00444 switch(IdImaType(imS)) 00445 { 00446 case IMA_CHAR: FF4(PPIMAGE_CHAR); break; 00447 case IMA_UCHAR: FF4(PPIMAGE_UCHAR); break; 00448 case IMA_SHORT: FF4(PPIMAGE_SHORT); break; 00449 case IMA_USHORT: FF4(PPIMAGE_USHORT); break; 00450 case IMA_LONG: FF4(PPIMAGE_LONG); break; 00451 case IMA_ULONG: FF4(PPIMAGE_ULONG); break; 00452 case IMA_FLOAT: FF4(PPIMAGE_FLOAT); break; 00453 case IMA_DOUBLE: FF4(PPIMAGE_DOUBLE); break; 00454 00455 default: 00456 IdErrPrintf("Type %d non traitable par la fonction IdImaRecadTo8ABS !\n", IdImaType(imS)); 00457 IdErrno=IDERR_WRONG_LIBTYPE; 00458 return(0); 00459 } 00460 00461 maxi= - FLT_MAX; 00462 mini= FLT_MAX; 00463 00464 for(i=0;i<IdImaDimY(imS);i++) 00465 for(j=0;j<IdImaDimX(imS);j++) 00466 { if(((imDouble)[i][j]) > maxi) maxi=((imDouble)[i][j]); 00467 if(((imDouble)[i][j]) < mini) mini=((imDouble)[i][j]); 00468 } 00469 00470 /* Recadrage de l'image */ 00471 00472 MM= maxi-mini; 00473 if(MM==0.) 00474 { IdErrPrintf (" Min = Max = %g; Impossible recadrer \n",maxi); 00475 IdErrno=IDERR_MIN_EQ_MAX; 00476 return 0; 00477 } 00478 00479 for(i=0;i<IdImaDimY(imS);i++) 00480 for(j=0;j<IdImaDimX(imS);j++) 00481 { 00482 imD[i][j]=(unsigned char) ( ( (((imDouble)[i][j])-mini)*255 ) /MM ); 00483 } 00484 00485 IdImaFree(imDouble); 00486 00487 return (imD); 00488 } 00489 00490 /* FUNCTION DESCRIPTION ************************************************** 00491 * 00492 * IdImaRecad16To8 (fonction) 00493 * 00494 * RESUME: recadre une image 16 bits ds une image 8 bits 00495 * 00496 * DESCRIPTION: recadre une image 16 bits ds une image 8 bits 00497 * 00498 * SYNTAXE: PPIMAGE_UCHAR im8= IdImaRecad16To8 (PPIMAGE_USHORT im16, int minImpose, int maxImpose); 00499 * 00500 * RETOUR : type : PPIMAGE_UCHAR 00501 * role : Pointeur vers l'image destination 00502 * 00503 * PARAMETRES: nom : im16 00504 * type : PPIMAGE_USHORT 00505 * role : Pointeur vers l'image source 00506 * 00507 * nom : minImpose, maxImpose 00508 * type : int 00509 * role : min et max imposes pour le recadrage 00510 * : sans effet si -1,-1 00511 * 00512 * FICHIER: imagette.c 00513 * 00514 * EXEMPLE: 00515 * 00516 ******************************************************** END DESCRIPTION */ 00517 00518 PPIMAGE_UCHAR IdImaRecad16To8( 00519 PPIMAGE_USHORT im16, 00520 int minImpose, 00521 int maxImpose) 00522 { 00523 PPIMAGE_UCHAR im8; 00524 unsigned short mini,maxi; 00525 float Fmult,MM; 00526 int i,j; 00527 if (!im16) {IdErrPrintf("erreur image 16 bits \n"); return(0);} 00528 00529 im8=(PPIMAGE_UCHAR)IdImaAlloc(IdImaDimX(im16),IdImaDimY(im16),IMA_UCHAR); 00530 if (!(im8)) 00531 { IdErrPrintf (" echec Alloc image 8bits \n"); 00532 return 0; 00533 } 00534 if ( (minImpose!=-1) && (maxImpose!=-1) ) 00535 { 00536 mini=minImpose; /* imposes; on les prend */ 00537 maxi=maxImpose; 00538 00539 for(i=0;i<IdImaDimY(im16);i++) /* on remonte a Min tt ce qui est < Min */ 00540 for(j=0;j<IdImaDimY(im16);j++) /* on descend a Max tt ce qui est > Max */ 00541 { if ((int)im16[i][j]>maxi)im16[i][j]=maxi; 00542 else if((int)im16[i][j]<mini)im16[i][j]=mini; 00543 } 00544 00545 /*IdPrintf (" min max imposes %d %d\n", minImpose,maxImpose);*/ 00546 } 00547 else 00548 { 00549 maxi=0; /* non imposes, on les cherche */ 00550 mini=0xffff; 00551 for(i=0;i<IdImaDimY(im16);i++) 00552 for(j=0;j<IdImaDimX(im16);j++) 00553 { if(im16[i][j] > maxi) maxi=im16[i][j]; 00554 if(im16[i][j] < mini) mini=im16[i][j]; 00555 } 00556 /*IdPrintf (" min max calcules %d %d\n", mini,maxi);*/ 00557 } 00558 /* Recadrage de l'image */ 00559 00560 00561 MM= maxi-mini; 00562 if(MM==0.) 00563 { IdErrPrintf (" Min = Max = %g; Impossible recadrer \n",mini); 00564 IdErrno=IDERR_MIN_EQ_MAX; 00565 return 0; 00566 } 00567 00568 00569 00570 for(i=0;i<IdImaDimY(im16);i++) 00571 for(j=0;j<IdImaDimX(im16);j++) 00572 { Fmult=(float)((im16[i][j]-mini)*255); 00573 im8[i][j]=(unsigned char)(Fmult/MM); 00574 } 00575 00576 IdSetFileName(im8,IdGetFileName(im16)); 00577 00578 return (im8); 00579 } 00580 00581 /* FUNCTION DESCRIPTION ************************************************** 00582 * 00583 * IdImaRecad16To8IgnoreUpper (fonction) 00584 * 00585 * RESUME: recadre une image 16 bits ds une image 8 bits en IGNORANT les pixels > val donnee 00586 * 00587 * DESCRIPTION: recadre une image 16 bits ds une image 8 bits en 00588 * IGNORANT les pixels > val donnee 00589 * Les pixels >= valSup seront mis a 255 lors du recadrage, 00590 * qui se fera sur [min,max] des pixels restants 00591 * 00592 * SYNTAXE: PPIMAGE_UCHAR im8= 00593 * IdImaRecad16To8IgnoreUpper (PPIMAGE_USHORT im16, int minImpose, int maxImpose, int valSup); 00594 * 00595 * RETOUR : type : PPIMAGE_UCHAR 00596 * role : Pointeur vers l'image destination 00597 * 00598 * PARAMETRES: nom : im16 00599 * type : PPIMAGE_USHORT 00600 * role : Pointeur vers l'image source 00601 * 00602 * nom : minImpose, maxImpose 00603 * type : int 00604 * role : min et max imposes pour le recadrage 00605 * : sans effet si -1,-1 00606 * 00607 * nom : valSup 00608 * type : int 00609 * role : les pixels >= valSup seront mis a 255 lors du recadrage, 00610 * qui se fera sur [min,max] des pixels restants 00611 * 00612 * FICHIER: imagette.c 00613 * 00614 * EXEMPLE: 00615 * 00616 ******************************************************** END DESCRIPTION */ 00617 00618 PPIMAGE_UCHAR IdImaRecad16To8IgnoreUpper( 00619 PPIMAGE_USHORT im16, 00620 int minImpose, 00621 int maxImpose, 00622 int valSup) 00623 { 00624 PPIMAGE_UCHAR im8; 00625 unsigned short mini,maxi; 00626 float Fmult,MM; 00627 int i,j; 00628 if (!im16) {IdErrPrintf("erreur image 16 bits \n"); return(0);} 00629 00630 im8=(PPIMAGE_UCHAR)IdImaAlloc(IdImaDimX(im16),IdImaDimY(im16),IMA_UCHAR); 00631 if (!(im8)) 00632 { IdErrPrintf (" echec Alloc image 8bits \n"); 00633 return 0; 00634 } 00635 if ( (minImpose!=-1) && (maxImpose!=-1) ) 00636 { 00637 mini=minImpose; /* imposes; on les prend */ 00638 maxi=maxImpose; 00639 00640 for(i=0;i<IdImaDimY(im16);i++) /* on remonte a Min tt ce qui est < Min */ 00641 for(j=0;j<IdImaDimY(im16);j++) /* on descend a Max tt ce qui est > Max */ 00642 { 00643 if ((int)im16[i][j]>=valSup) continue; 00644 if ((int)im16[i][j]>maxi)im16[i][j]=maxi; 00645 else if((int)im16[i][j]<mini)im16[i][j]=mini; 00646 } 00647 00648 } 00649 else 00650 { 00651 maxi=0; /* non imposes, on les cherche */ 00652 mini=0xffff; 00653 for(i=0;i<IdImaDimY(im16);i++) 00654 for(j=0;j<IdImaDimX(im16);j++) 00655 { 00656 if((int)im16[i][j]>=valSup) continue; 00657 if(im16[i][j] > maxi) maxi=im16[i][j]; 00658 if(im16[i][j] < mini) mini=im16[i][j]; 00659 } 00660 } 00661 /* Recadrage de l'image */ 00662 00663 00664 00665 MM= maxi-mini; 00666 if(MM==0.) 00667 { IdErrPrintf (" Min = Max; Impossible recadrer \n"); 00668 IdErrno=IDERR_MIN_EQ_MAX; 00669 return 0; 00670 } 00671 00672 00673 for(i=0;i<IdImaDimY(im16);i++) 00674 for(j=0;j<IdImaDimX(im16);j++) 00675 { 00676 if((int)im16[i][j]>=valSup) { im8[i][j]=255; continue; } 00677 Fmult=(float)((im16[i][j]-mini)*255); 00678 im8[i][j]=(unsigned char)(Fmult/MM); 00679 } 00680 00681 IdSetFileName(im8,IdGetFileName(im16)); 00682 00683 return (im8); 00684 } 00685 00686 00687 /* FUNCTION DESCRIPTION ************************************************** 00688 * 00689 * IdImaRecad16To16IgnoreUpper (fonction) 00690 * 00691 * RESUME: recadre une image 16 bits ds une image 16 bits en IGNORANT les pixels > val donnee 00692 * 00693 * DESCRIPTION: recadre une image 16 bits ds une image 16 bits (!!!)en 00694 * IGNORANT les pixels > val donnee 00695 * Les pixels >= valSup seront mis a 4095 lors du recadrage, 00696 * qui se fera sur [min,max] des pixels restants 00697 * 00698 * SYNTAXE: PPIMAGE_USHORT imd16= 00699 * IdImaRecad16To16IgnoreUpper (PPIMAGE_USHORT ims16, int minImpose, int maxImpose, int valSup); 00700 * 00701 * RETOUR : type : PPIMAGE_USHORT 00702 * role : Pointeur vers l'image destination 00703 * 00704 * PARAMETRES: nom : ims16 00705 * type : PPIMAGE_USHORT 00706 * role : Pointeur vers l'image source 00707 * 00708 * nom : minImpose, maxImpose 00709 * type : int 00710 * role : min et max imposes pour le recadrage 00711 * : sans effet si -1,-1 00712 * 00713 * nom : valSup 00714 * type : int 00715 * role : les pixels >= valSup seront mis a 4095 lors du recadrage, 00716 * qui se fera sur [min,max] des pixels restants 00717 * 00718 * FICHIER: imagette.c 00719 * 00720 * EXEMPLE: 00721 * 00722 ******************************************************** END DESCRIPTION */ 00723 00724 PPIMAGE_USHORT IdImaRecad16To16IgnoreUpper( 00725 PPIMAGE_USHORT im16, 00726 int minImpose, 00727 int maxImpose, 00728 int valSup) 00729 { 00730 PPIMAGE_USHORT im8; 00731 unsigned short mini,maxi; 00732 float Fmult,MM; 00733 int i,j; 00734 if (!im16) {IdErrPrintf("erreur image 16 bits \n"); return(0);} 00735 00736 /* ATTENTION AUX COMMENTAIRES : im8 est USHORT ... */ 00737 00738 im8=(PPIMAGE_USHORT)IdImaAlloc(IdImaDimX(im16),IdImaDimY(im16),IMA_USHORT); 00739 if (!(im8)) 00740 { IdErrPrintf (" echec Alloc image 16 bits \n"); 00741 return 0; 00742 } 00743 if ( (minImpose!=-1) && (maxImpose!=-1) ) 00744 { 00745 mini=minImpose; /* imposes; on les prend */ 00746 maxi=maxImpose; 00747 00748 for(i=0;i<IdImaDimY(im16);i++) /* on remonte a Min tt ce qui est < Min */ 00749 for(j=0;j<IdImaDimY(im16);j++) /* on descend a Max tt ce qui est > Max */ 00750 { 00751 if ((int)im16[i][j]>=valSup) continue; 00752 if ((int)im16[i][j]>maxi) im16[i][j]=maxi; 00753 else if((int)im16[i][j]<mini) im16[i][j]=mini; 00754 } 00755 00756 } 00757 else 00758 { 00759 maxi=0; /* non imposes, on les cherche */ 00760 mini=0xffff; 00761 for(i=0;i<IdImaDimY(im16);i++) 00762 for(j=0;j<IdImaDimX(im16);j++) 00763 { 00764 if((int)im16[i][j]>=valSup) continue; 00765 if(im16[i][j] > maxi) maxi=im16[i][j]; 00766 if(im16[i][j] < mini) mini=im16[i][j]; 00767 } 00768 } 00769 /* Recadrage de l'image */ 00770 00771 MM= maxi-mini; 00772 if(MM==0.) 00773 { IdErrPrintf (" Min = Max; Impossible recadrer \n"); 00774 IdErrno=IDERR_MIN_EQ_MAX; 00775 return 0; 00776 } 00777 00778 00779 for(i=0;i<IdImaDimY(im16);i++) 00780 for(j=0;j<IdImaDimX(im16);j++) 00781 { 00782 if((int)im16[i][j]>=valSup) { im8[i][j]=4095; continue; } 00783 Fmult=(float)((im16[i][j]-mini)*4095); 00784 im8[i][j]=(unsigned short)(Fmult/MM); 00785 } 00786 00787 IdSetFileName(im8,IdGetFileName(im16)); 00788 00789 return (im8); 00790 } 00791 00792 /* FUNCTION DESCRIPTION ************************************************** 00793 * 00794 * IdImaRecadTo16 (fonction) 00795 * 00796 * RESUME: Recadre (Dynamique) une image non COMPLEX ds une image 16 bits 00797 * 00798 * DESCRIPTION: Recadre (Dynamique) une image non COMPLEX ds une image 16 bits 00799 * 00800 * SYNTAXE: PPIMAGE_USHORT imDest= IdImaRecadTo16 (PPIMAGE imSource, PPIMAGE_USHORT imDest, double minImpose, double maxImpose); 00801 * 00802 * RETOUR : type : PPIMAGE_USHORT 00803 * role : ptr sur image recadree. 00804 * 00805 * PARAMETRES: nom : imSource 00806 * type : PPIMAGE 00807 * role : Pointeur vers l'image source 00808 * 00809 * nom : imDest 00810 * type : PPIMAGE_USHORT 00811 * role : Pointeur vers l' Image destination 00812 * 00813 * nom : minImpose, maxImpose 00814 * type : double 00815 * role : min et max imposes pour le recadrage 00816 * : sans effet si -1.0,-1.0 00817 * 00818 * FICHIER: imagette.c 00819 * 00820 * EXEMPLE: 00821 * 00822 ******************************************************** END DESCRIPTION */ 00823 00824 #define FF6(typeima) \ 00825 \ 00826 if ( (minImpose!=-1.) && (maxImpose!=-1.) ) \ 00827 { \ 00828 mini=minImpose; /* imposes; on les prend */ \ 00829 maxi=maxImpose; \ 00830 \ 00831 MM= maxi-mini; \ 00832 if(MM==0.) \ 00833 { IdErrPrintf (" Min = Max = %g; Impossible recadrer \n",maxi); \ 00834 IdErrno=IDERR_MIN_EQ_MAX; \ 00835 return 0; \ 00836 } \ 00837 \ 00838 for(i=0;i<IdImaDimY(imS);i++) \ 00839 for(j=0;j<IdImaDimX(imS);j++) \ 00840 { \ 00841 pixel = (double)(((typeima)imS)[i][j]); \ 00842 if (pixel>maxi) imD[i][j]=32767; \ 00843 else if(pixel<mini) imD[i][j]=0; \ 00844 else { \ 00845 imD[i][j]=(unsigned short) ( (double)( (pixel-mini)*32767. ) /MM ); \ 00846 } \ 00847 } \ 00848 } \ 00849 else \ 00850 { \ 00851 maxi= - FLT_MAX; /* non imposes, on les cherche */ \ 00852 mini= FLT_MAX; \ 00853 for(i=0;i<IdImaDimY(imS);i++) \ 00854 for(j=0;j<IdImaDimX(imS);j++) \ 00855 { if((((typeima)imS)[i][j]) > maxi) maxi=(((typeima)imS)[i][j]); \ 00856 if((((typeima)imS)[i][j]) < mini) mini=(((typeima)imS)[i][j]); \ 00857 } \ 00858 \ 00859 /* Recadrage de l'image */ \ 00860 MM=maxi-mini; \ 00861 if(MM==0.) \ 00862 { IdErrPrintf (" Min = Max = %g; Impossible recadrer \n",mini); \ 00863 IdErrno=IDERR_MIN_EQ_MAX; \ 00864 return 0; \ 00865 } \ 00866 \ 00867 for(i=0;i<IdImaDimY(imS);i++) \ 00868 for(j=0;j<IdImaDimX(imS);j++) \ 00869 { \ 00870 imD[i][j]=(unsigned short) ( (double)( ((((typeima)imS)[i][j])-mini)*32767. ) /MM ); \ 00871 } \ 00872 } 00873 00874 00875 PPIMAGE_USHORT IdImaRecadTo16( 00876 PPIMAGE imS, 00877 PPIMAGE_USHORT imD, 00878 double minImpose, 00879 double maxImpose) 00880 { 00881 double mini,maxi; 00882 double MM; 00883 double pixel; 00884 00885 int i,j; 00886 00887 imD=(PPIMAGE_USHORT)IdImaCheckSizeAllocType (imS,-1,(PPIMAGE)imD,IMA_USHORT); 00888 00889 if (!(imD)) 00890 { IdErrPrintf (" echec Alloc Image 16bits \n"); 00891 IdErrno=IDERR_ALLOC_IMA; 00892 return 0; 00893 } 00894 00895 switch(IdImaType(imS)) 00896 { 00897 case IMA_CHAR: FF6(PPIMAGE_CHAR); break; 00898 case IMA_UCHAR: FF6(PPIMAGE_UCHAR); break; 00899 case IMA_SHORT: FF6(PPIMAGE_SHORT); break; 00900 case IMA_USHORT: FF6(PPIMAGE_USHORT); break; 00901 case IMA_LONG: FF6(PPIMAGE_LONG); break; 00902 case IMA_ULONG: FF6(PPIMAGE_ULONG); break; 00903 case IMA_FLOAT: FF6(PPIMAGE_FLOAT); break; 00904 case IMA_DOUBLE: FF6(PPIMAGE_DOUBLE); break; 00905 default: 00906 IdErrPrintf("Type %d non traitable par la fonction IdImaRecadTo16 !\n", IdImaType(imS)); 00907 IdErrno=IDERR_WRONG_LIBTYPE; 00908 return(0); 00909 } 00910 00911 IdSetFileName(imD,IdGetFileName(imS)); 00912 return (imD); 00913 } 00914 00915 00916 /* FUNCTION DESCRIPTION ************************************************** 00917 * 00918 * IdImaConcat (fonction) 00919 * 00920 * RESUME: concatenne 2 im. 8 bits ds une image 8 bits SANS duplication de pixels 00921 * 00922 * DESCRIPTION: concatenne 2 im. 8 bits ds une image 8 bits SANS duplication de pixels. 00923 * Si l'une des 2 images est = NULL la fonction retourne un pointeur sur l'autre. 00924 * 00925 * SYNTAXE: PPIMAGE_UCHAR imRes= IdImaConcat (PPIMAGE_UCHAR im1,PPIMAGE_UCHAR im2); 00926 * 00927 * RETOUR : type : PPIMAGE_UCHAR 00928 * role : Pointeur vers les images destination 00929 * 00930 * PARAMETRES: nom : im1, im2 00931 * type : PPIMAGE_UCHAR 00932 * role : Pointeur vers les images source 00933 * 00934 * FICHIER: imagette.c 00935 * 00936 * EXEMPLE: 00937 * 00938 ******************************************************** END DESCRIPTION */ 00939 00940 PPIMAGE_UCHAR IdImaConcat( 00941 PPIMAGE_UCHAR im1, 00942 PPIMAGE_UCHAR im2) 00943 { 00944 int nbLigIm1=0,nbLigIm2=0,nbLigIm3,nbColIm1,nbColIm2; 00945 int j,y,j2; 00946 PRIVATE_IMAGE * si; 00947 PPIMAGE_UCHAR im3=NULL; 00948 if(im1) 00949 { if (( IdLibidoType(im1) != IMA) ) 00950 00951 { IdErrno = IDERR_WRONG_TYPE; 00952 return(PPIMAGE_UCHAR)0; 00953 } 00954 nbLigIm1=IdImaDimY(im1); 00955 nbColIm1=IdImaDimX(im1); 00956 } 00957 else nbColIm1=0; 00958 00959 if(im2) 00960 { if (( IdLibidoType(im2) != IMA) ) 00961 00962 { IdErrno = IDERR_WRONG_TYPE; 00963 return(PPIMAGE_UCHAR)0; 00964 } 00965 nbLigIm2=IdImaDimY(im2); 00966 nbColIm2=IdImaDimX(im2); 00967 00968 } 00969 else nbColIm2=0; 00970 00971 if ( !im1 && !im2 ) return (PPIMAGE_UCHAR)0; 00972 if ( im1 && im2 ) 00973 { 00974 if (nbColIm1!=nbColIm2) 00975 { IdErrPrintf("erreur taille images\n"); 00976 return(PPIMAGE_UCHAR)0; 00977 } 00978 if (IdImaType(im1)!=IdImaType(im2)) 00979 { IdErrPrintf("erreur: types images #\n"); 00980 return(PPIMAGE_UCHAR)0; 00981 } 00982 } 00983 00984 nbLigIm3=nbLigIm1+nbLigIm2; 00985 00986 si=(PRIVATE_IMAGE *)calloc(1, sizeof(PRIVATE_IMAGE) + nbLigIm3*sizeof(void *)); 00987 if(si){ 00988 if(im1) si->DimX=IdImaDimX(im1); else si->DimX=IdImaDimX(im2); 00989 si->DimY=nbLigIm3; 00990 if(im1) si->Type=IdImaType(im1); else si->Type=IdImaType(im2); 00991 im3 = (PPIMAGE_UCHAR)&(si[1]); 00992 00993 if (im1) 00994 { 00995 for ( j=0 ;j<nbLigIm1; j++ ) 00996 im3[j]= im1[j]; 00997 j2=j; 00998 } 00999 else j2=0; 01000 if (im2) 01001 { 01002 for ( y=0, j=j2; y<nbLigIm2; y++, j++ ) 01003 im3[j]= im2[y]; 01004 } 01005 } 01006 else IdErrPrintf("echec alloc im3\n"); 01007 return (im3); 01008 01009 } 01010 01011 /* FUNCTION DESCRIPTION ************************************************** 01012 * 01013 * IdImaCreImagette (fonction) 01014 * 01015 * RESUME: cree une imagette (ligne) a partir d'un tableau de pointeurs sur images 01016 * 01017 * DESCRIPTION: cree une imagette a partir d'un tableau de pointeurs sur images 01018 * 01019 * 01020 * SYNTAXE: PPIMAGE_UCHAR im8= IdImaCreImagette ( PPIMAGE_UCHAR tabImages[], int nbImages,int tailleX , int tailleY); 01021 * 01022 * RETOUR : type : PPIMAGE_UCHAR 01023 * role : Pointeur vers le tableau d'images destination 01024 * 01025 * PARAMETRES: nom : tabImages 01026 * type : PPIMAGE_UCHAR * 01027 * role : Pointeur vers le tableau d'images source 01028 * 01029 * nom : nbImages 01030 * type : int 01031 * role : nb d'images ds le tableau 01032 * 01033 * nom : tailleX 01034 * type : int 01035 * role : taille en X des images sous-echantillonnees 01036 * 01037 * nom : tailleY 01038 * type : int 01039 * role : taille en Y des images sous-echantillonnees 01040 * 01041 * FICHIER: imagette.c 01042 * 01043 * EXEMPLE: 01044 * 01045 ******************************************************** END DESCRIPTION */ 01046 01047 PPIMAGE_UCHAR IdImaCreImagette( 01048 PPIMAGE_UCHAR *TabImage, 01049 int n, 01050 int nx, 01051 int ny) 01052 { 01053 PPIMAGE_UCHAR imgtte; 01054 PPIMAGE_UCHAR imaint; 01055 int i,j,l; 01056 int TAILLE_X = nx; 01057 int TAILLE_Y = ny; 01058 imgtte=(PPIMAGE_UCHAR)IdImaAlloc(TAILLE_X*n,TAILLE_Y,TY_UCHAR); 01059 if(!imgtte) {IdErrPrintf("echec allocation imagette\n"); return (NULL);} 01060 01061 imaint=(PPIMAGE_UCHAR)IdImaAlloc(TAILLE_X,TAILLE_Y,TY_UCHAR); 01062 if(!imaint) {IdErrPrintf("echec allocation image reduite\n"); return (NULL);} 01063 01064 for (l=0;l<n;l++) 01065 { IdImaZoom((PPIMAGE)imaint,(PPIMAGE)(TabImage[l])); 01066 01067 for (i=0;i<IdImaDimY(imaint);i++) 01068 for (j=0;j<IdImaDimX(imaint);j++) 01069 { imgtte[i][l*IdImaDimX(imaint)+j]=imaint[i][j]; 01070 } 01071 } 01072 IdImaFree(imaint); 01073 return(imgtte); 01074 } 01075 01076 /* ------------------------------------------------------------------------*/ 01077 PPIMAGE_UCHAR _IdImaCreImagetteClear( 01078 PPIMAGE_UCHAR *TabImage, 01079 int n, // Number of allocated positions 01080 int neffectif, // Number of images to be stored 01081 int nx, 01082 int ny) 01083 { 01084 PPIMAGE_UCHAR imgtte; 01085 PPIMAGE_UCHAR imaint; 01086 int i,j,l; 01087 int TAILLE_X = nx; 01088 int TAILLE_Y = ny; 01089 imgtte=(PPIMAGE_UCHAR)IdImaAlloc(TAILLE_X*n,TAILLE_Y,TY_UCHAR); 01090 if(!imgtte) {IdErrPrintf("echec allocation imagette\n"); return (NULL);} 01091 IdImaClear((PPIMAGE)imgtte); 01092 01093 imaint=(PPIMAGE_UCHAR)IdImaAlloc(TAILLE_X,TAILLE_Y,TY_UCHAR); 01094 if(!imaint) {IdErrPrintf("echec allocation image reduite\n"); return (NULL);} 01095 01096 for (l=0;l<neffectif;l++) 01097 { IdImaZoom((PPIMAGE)imaint,(PPIMAGE)(TabImage[l])); 01098 01099 01100 for (i=0;i<IdImaDimY(imaint);i++) 01101 for (j=0;j<IdImaDimX(imaint);j++) 01102 { imgtte[i][l*IdImaDimX(imaint)+j]=imaint[i][j]; 01103 } 01104 01105 } 01106 IdImaFree(imaint); 01107 return(imgtte); 01108 } 01109 01110 /* FUNCTION DESCRIPTION ************************************************** 01111 * 01112 * IdImaCreImagetteXY (fonction) 01113 * 01114 * RESUME: cree une imagette(matrice) a partir d'un tableau de pointeurs sur images 01115 * 01116 * DESCRIPTION: cree une imagette a partir d'un tableau de pointeurs sur images 01117 * 01118 * SYNTAXE: PPIMAGE_UCHAR im8= IdImaCreeImagetteXY (PPIMAGE_UCHAR tabImages[] , int nbImages, int nbImLig, int nbImCol, int Xsize, int Ysize); 01119 * 01120 * PARAMETRES: nom : tabImages 01121 * type : PPIMAGE_UCHAR * 01122 * role : Pointeur vers le tableau d'images source 01123 * 01124 * nom : nbImages 01125 * type : int 01126 * role : nb d'images ds le tableau 01127 * 01128 * nom : nbImLig 01129 * type : int 01130 * role : nombre d'imagettes par LIGNE (si -1, on ajuste) 01131 * 01132 * nom : nbImCol 01133 * type : int 01134 * role : nombre d'imagettes par COLONNE (si -1, on ajuste) 01135 * 01136 * nom : Xsize 01137 * type : int 01138 * role : taille en X des images sous-echantillonnees 01139 * 01140 * nom : Ysize 01141 * type : int 01142 * role : taille en Y des images sous-echantillonnees 01143 * 01144 * FICHIER: imagette.c 01145 * 01146 * EXEMPLE: 01147 * 01148 ******************************************************** END DESCRIPTION */ 01149 01150 PPIMAGE_UCHAR IdImaCreImagetteXY ( 01151 PPIMAGE_UCHAR *tabimage, 01152 int nb, // Number of images 01153 int XSIZE, // X-size of reduced images 01154 int YSIZE, // Y-size of reduced images 01155 int nx, // Number of images within each line 01156 int ny) // Number of images within each column 01157 01158 { 01159 PPIMAGE_UCHAR imagettes=0; /* image finale a retourner */ 01160 PPIMAGE_UCHAR ligne_imagettes=0; /* im auxiliaire lignes d'imagettes */ 01161 int m,k,FLAG_COL=0; 01162 01163 if ( (nx!=-1)&&(ny!=-1) ) if (nb>(nx*ny)) nx=(int)sqrt((double)nb); 01164 01165 if ( (nx==-1)&&(ny==-1) ) { nx=nb; ny=1; FLAG_COL=1;} 01166 else if ( (ny==-1)&&(nx!=-1) ) { ny=(int)ceil( ((double)nb/(double)nx) ); } 01167 else if ( (nx==-1)&&(ny!=-1) ) { nx=(int)ceil( ((double)nb/(double)ny) ); } 01168 01169 01170 if(nb<nx) k=nb; else k=nx; 01171 01172 ligne_imagettes =(PPIMAGE_UCHAR) IdImaCreImagette (&tabimage[0], k, XSIZE, YSIZE); 01173 01174 if (FLAG_COL) return(ligne_imagettes); 01175 if (k==nb) return(ligne_imagettes); 01176 01177 imagettes=ligne_imagettes; 01178 01179 FLAG_COL=0; 01180 for (m=nx; m<nb; m+=nx) 01181 { 01182 if ((m+nx)>nb){ FLAG_COL=1; k=nx -(nx*ny-nb) ;break;} 01183 01184 ligne_imagettes =(PPIMAGE_UCHAR) IdImaCreImagette (&tabimage[m], nx, XSIZE, YSIZE); 01185 imagettes=(PPIMAGE_UCHAR)IdImaConcat(imagettes,ligne_imagettes); 01186 01187 } 01188 01189 if (FLAG_COL) 01190 { 01191 ligne_imagettes =(PPIMAGE_UCHAR) _IdImaCreImagetteClear (&tabimage[m], nx,k, XSIZE, YSIZE); 01192 imagettes=(PPIMAGE_UCHAR)IdImaConcat(imagettes,ligne_imagettes); 01193 } 01194 01195 return imagettes; 01196 } 01197 01198 /* FUNCTION DESCRIPTION ************************************************** 01199 * 01200 * IdImaMakeImagetteXYHoriz (fonction) 01201 * 01202 * RESUME: Colle ds une matrice (G->D, H->B) des images les unes a la suite des autres 01203 * 01204 * DESCRIPTION: Cree une imagette (matrice) a partir d'un tableau de pointeurs sur images. 01205 * Les images sont 'rangees' de gauche a droite, puis de haut en bas. 01206 * 01207 * SYNTAXE: PPIMAGE_UCHAR im8= IdImaMakeImagetteXYHoriz (PPIMAGE_UCHAR tabImages[] , int nbImages, int nbImCol, int nbImLig, int Xsize, int Ysize); 01208 * 01209 * PARAMETRES: nom : tabImages 01210 * type : PPIMAGE_UCHAR * 01211 * role : Pointeur vers le tableau d'images source 01212 * 01213 * nom : nbImages 01214 * type : int 01215 * role : nb d'images ds le tableau 01216 * 01217 * nom : nbImCol 01218 * type : int 01219 * role : nombre d'imagettes (en X) par COLONNE (si -1, on ajuste) 01220 * 01221 * nom : nbImLig 01222 * type : int 01223 * role : nombre d'imagettes (en Y) par LIGNE (si -1, on ajuste) 01224 * 01225 * nom : Xsize 01226 * type : int 01227 * role : taille en X des images sous-echantillonnees 01228 * 01229 * nom : Ysize 01230 * type : int 01231 * role : taille en Y des images sous-echantillonnees 01232 * 01233 * FICHIER: imagette.c 01234 * 01235 * EXEMPLE: 01236 * 01237 ******************************************************** END DESCRIPTION */ 01238 01239 PPIMAGE_UCHAR IdImaMakeImagetteXYHoriz ( 01240 PPIMAGE_UCHAR *tabimage, 01241 int nb, // Number of images 01242 int XSIZE, // X-size of reduced images 01243 int YSIZE, // Y-size of reduced images 01244 int nx, // Number of images within each line 01245 int ny) // Number of images within each column 01246 01247 { 01248 PPIMAGE_UCHAR imagettes=NULL; /* image finale a retourner */ 01249 PPIMAGE_UCHAR imin=NULL,imout=NULL; 01250 01251 int k; 01252 int i,j,l; 01253 01254 int nlp; /* Nb de lignes pleines */ 01255 01256 float rapportx, rapporty; 01257 01258 if ( (nx!=-1)&&(ny!=-1) ) if (nb>(nx*ny)) 01259 { nx=ny=(int)ceil(sqrt((double)nb)); 01260 if (nx*(ny-1)>=nb) ny--; 01261 } 01262 01263 if ( (nx==-1)&&(ny==-1) ) { nx=ny=(int)ceil(sqrt((double)nb)); 01264 if (nx*(ny-1)>=nb) ny--; 01265 } 01266 else if ( (ny==-1)&&(nx!=-1) ) { ny=(int)ceil( ((double)nb/(double)nx) ); 01267 } 01268 else if ( (nx==-1)&&(ny!=-1) ) { nx=(int)ceil( ((double)nb/(double)ny) ); 01269 } 01270 01271 if(nb<nx) k=nb; else k=nx; 01272 01273 01274 imagettes= (PPIMAGE_UCHAR)IdImaAlloc(nx*XSIZE, ny*YSIZE, IMA_UCHAR); 01275 01276 if (!imagettes) { IdErrPrintf("Echec Alloc imagettes\n"); 01277 IdErrno=IDERR_ALLOC_IMA; 01278 return (PPIMAGE_UCHAR)NULL; 01279 } 01280 01281 if (nb<(nx*ny)) 01282 { nlp=nb/nx; 01283 imout=(PPIMAGE_UCHAR) IdImaAllocSubImage((PPIMAGE) imagettes, 0,nlp , nx*XSIZE, (nx-nlp)*YSIZE); 01284 IdImaClear((PPIMAGE)imout); 01285 IdImaFreeSubImage(imout); 01286 } 01287 01288 imout=(PPIMAGE_UCHAR) IdImaAllocSubImage((PPIMAGE) imagettes, 0,0 , XSIZE, YSIZE); 01289 01290 if (!imout) { IdErrPrintf("Echec Alloc sous-im\n"); 01291 IdErrno=IDERR_ALLOC_IMA; 01292 return (PPIMAGE_UCHAR)NULL; 01293 } 01294 01295 for (l=0; l<nb; l++) /* pour chaque image de la table */ 01296 { 01297 imin = tabimage[l]; 01298 rapportx=((float)(IdImaDimX(imin)))/XSIZE; 01299 rapporty=((float)(IdImaDimY(imin)))/YSIZE; 01300 01301 imout=(PPIMAGE_UCHAR) IdImaModifSubImage( (PPIMAGE)imagettes, (PPIMAGE)imout, (l%nx)*XSIZE, (l/nx)*YSIZE); 01302 01303 if (!imout) { IdErrPrintf("Echec Modif sous-im\n"); 01304 IdErrno=IDERR_ALLOC_IMA; 01305 return (PPIMAGE_UCHAR)NULL; 01306 } 01307 01308 for (j=0; j<IdImaDimY (imout); j++) 01309 for (i=0; i<IdImaDimX (imout); i++) 01310 { 01311 imout[j][i]=((PPIMAGE_UCHAR)imin)[(int)(j*rapporty)][(int)(i*rapportx)]; 01312 } 01313 } 01314 01315 IdImaFreeSubImage(imout); 01316 return imagettes; 01317 } 01318 01319 /* FUNCTION DESCRIPTION ************************************************** 01320 * 01321 * IdImaMakeImagetteXYVertic (fonction) 01322 * 01323 * RESUME: Colle ds une matrice ( H->B, G->D) des images les unes a la suite des autres 01324 * 01325 * DESCRIPTION: Cree une imagette (matrice) a partir d'un tableau de pointeurs sur images. 01326 * Les images sont 'rangees' de haut en bas , puis de gauche a droite. 01327 * 01328 * SYNTAXE: PPIMAGE_UCHAR im8= IdImaMakeImagetteXYVertic (PPIMAGE_UCHAR tabImages[] , int nbImages, int nbImCol,int nbImLig, int Xsize, int Ysize); 01329 * 01330 * PARAMETRES: nom : tabImages 01331 * type : PPIMAGE_UCHAR * 01332 * role : Pointeur vers le tableau d'images source 01333 * 01334 * nom : nbImages 01335 * type : int 01336 * role : nb d'images ds le tableau 01337 * 01338 * nom : nbImCol 01339 * type : int 01340 * role : nombre d'imagettes (en X) par COLONNE (si -1, on ajuste) 01341 * 01342 * nom : nbImLig 01343 * type : int 01344 * role : nombre d'imagettes (en Y) par LIGNE (si -1, on ajuste) 01345 * 01346 * nom : Xsize 01347 * type : int 01348 * role : taille en X des images sous-echantillonnees 01349 * 01350 * nom : Ysize 01351 * type : int 01352 * role : taille en Y des images sous-echantillonnees 01353 * 01354 * FICHIER: imagette.c 01355 * 01356 * EXEMPLE: 01357 * 01358 ******************************************************** END DESCRIPTION */ 01359 01360 PPIMAGE_UCHAR IdImaMakeImagetteXYVertic ( 01361 PPIMAGE_UCHAR *tabimage, 01362 int nb, // Number of images 01363 int XSIZE, // X-size of reduced images 01364 int YSIZE, // Y-size of reduced images 01365 int nx, // Number of images within each line 01366 int ny) // Number of images within each column 01367 { 01368 PPIMAGE_UCHAR imagettes=NULL; /* image finale a retourner */ 01369 PPIMAGE_UCHAR imin=NULL,imout=NULL; 01370 01371 int k; 01372 int i,j,l; 01373 01374 int nlp; /* Nb de lignes pleines */ 01375 01376 float rapportx, rapporty; 01377 01378 if ( (nx!=-1)&&(ny!=-1) ) if (nb>(nx*ny)) 01379 { nx=ny=(int)ceil(sqrt((double)nb)); 01380 if (nx*(ny-1)>=nb) ny--; 01381 } 01382 01383 if ( (nx==-1)&&(ny==-1) ) { nx=ny=(int)ceil(sqrt((double)nb)); 01384 if (nx*(ny-1)>=nb) ny--; 01385 } 01386 else if ( (ny==-1)&&(nx!=-1) ) { ny=(int)ceil( ((double)nb/(double)nx) ); } 01387 else if ( (nx==-1)&&(ny!=-1) ) { nx=(int)ceil( ((double)nb/(double)ny) ); } 01388 01389 01390 if(nb<nx) k=nb; else k=nx; 01391 01392 imagettes= (PPIMAGE_UCHAR)IdImaAlloc(nx*XSIZE, ny*YSIZE, IMA_UCHAR); 01393 if (!imagettes) { 01394 IdErrPrintf("Echec Alloc Imagettes\n"); 01395 IdErrno=IDERR_ALLOC_IMA; 01396 return (PPIMAGE_UCHAR)NULL; 01397 } 01398 01399 if (nb<(nx*ny)) 01400 { nlp=nb/nx; 01401 imout=(PPIMAGE_UCHAR) IdImaAllocSubImage((PPIMAGE) imagettes, 0,nlp , nx*XSIZE, (nx-nlp)*YSIZE); 01402 IdImaClear((PPIMAGE)imout); 01403 IdImaFreeSubImage(imout); 01404 } 01405 01406 imout=(PPIMAGE_UCHAR) IdImaAllocSubImage( (PPIMAGE)imagettes, 0,0 , XSIZE, YSIZE); 01407 01408 if (!imagettes) { 01409 IdErrPrintf("Echec Alloc sous-im\n"); 01410 IdErrno=IDERR_ALLOC_IMA; 01411 return (PPIMAGE_UCHAR)NULL; 01412 } 01413 01414 for (l=0; l<nb; l++) /* pour chaque image de la table */ 01415 { 01416 imin = tabimage[l]; 01417 rapportx=((float)(IdImaDimX(imin)))/XSIZE; 01418 rapporty=((float)(IdImaDimY(imin)))/YSIZE; 01419 01420 imout=(PPIMAGE_UCHAR) IdImaModifSubImage((PPIMAGE)imagettes, (PPIMAGE)imout, (l/ny)*XSIZE, (l%ny)*YSIZE); 01421 01422 if (!imout) { IdErrPrintf("Echec Modif sous-im\n"); 01423 IdErrno=IDERR_ALLOC_IMA; 01424 return (PPIMAGE_UCHAR)NULL; 01425 } 01426 01427 for (j=0; j<IdImaDimY (imout); j++) 01428 for (i=0; i<IdImaDimX (imout); i++) 01429 { 01430 imout[j][i]=((PPIMAGE_UCHAR)imin)[(int)(j*rapporty)][(int)(i*rapportx)]; 01431 } 01432 } 01433 01434 IdImaFreeSubImage(imout); 01435 return imagettes; 01436 } 01437 01438 01439 /* FUNCTION DESCRIPTION ************************************************** 01440 * 01441 * IdImaScotchImages (fonction) 01442 * 01443 * RESUME: Colle en ligne des images les unes a la suite des autres 01444 * 01445 * DESCRIPTION: Colle en ligne des images (de MEMES DIMENSIONS) les unes a la suite des autres 01446 * 01447 * SYNTAXE: PPIMAGE_USHORT im8= IdImaScotchImages (PPIMAGE_USHORT tabImages[],int nbImages); 01448 * 01449 * PARAMETRES: nom : tabImages 01450 * type : PPIMAGE_USHORT * 01451 * role : Pointeur vers le tableau d'images source 01452 * 01453 * nom : nbImages 01454 * type : int 01455 * role : nb d'images ds le tableau 01456 * 01457 * FICHIER: imagette.c 01458 * 01459 * EXEMPLE: 01460 * 01461 ******************************************************** END DESCRIPTION */ 01462 01463 PPIMAGE_UCHAR IdImaScotchImages( 01464 PPIMAGE_UCHAR *TabImage, 01465 int n) 01466 { 01467 PPIMAGE_UCHAR imagette; 01468 PPIMAGE_UCHAR imaint; 01469 int i,j,l,l1,NX,NY; 01470 01471 NX=IdImaDimX(TabImage[0]); 01472 NY=IdImaDimY(TabImage[0]); 01473 01474 for (l=1;l<n;l++) 01475 { 01476 if(TabImage[l]==0) { IdErrPrintf("erreur images : pointeur NULL\n"); 01477 return (0); 01478 } 01479 if(IdImaDimY(TabImage[l])!=NY) { IdErrPrintf("erreur tailles images\n"); 01480 return (0); 01481 } 01482 } 01483 01484 imagette=(PPIMAGE_UCHAR)IdImaAlloc(NX*n,NY,TY_UCHAR); 01485 if(!imagette) {IdErrPrintf("echec allocation imagette\n"); return (NULL);} 01486 01487 l1=0; 01488 for (l=0;l<n;l++) 01489 { 01490 imaint=TabImage[l]; 01491 for (i=0;i<NY;i++) 01492 { 01493 for (j=0;j<IdImaDimX(imaint);j++) 01494 { 01495 imagette[i][l1+j]=imaint[i][j]; 01496 } 01497 } 01498 l1=l1+IdImaDimX(imaint)*IdSizeOfType(imagette); 01499 } 01500 01501 return(imagette); 01502 } 01503 01504 01505 /* FoNCTION DESCRIPTION ************************************************** 01506 * 01507 * IdImaScotchImagesXYHoriz (fonction) 01508 * 01509 * RESUME: Colle ds une matrice (G->D, H->B) des images les unes a la suite des autres 01510 * 01511 * DESCRIPTION: Colle des images (de MEME TAILLE) dans une matrice 01512 * Les images sont 'rangees' de gauche a droite, puis de haut en bas. 01513 * 01514 * SYNTAXE: im8= IdImaScotchImagesXYHoriz (tabImages,nbImages,nbImCol,nbImLig); 01515 * 01516 * PARAMETRES: nom : tabImages 01517 * type : PPIMAGE_USHORT * 01518 * role : Pointeur vers le tableau d'images source 01519 * 01520 * PARAMETRES: nom : nbImages 01521 * type : int 01522 * role : nb d'images ds le tableau 01523 * 01524 * nom : nbImCol 01525 * type : int 01526 * role : nombre d'imagettes par COLONNE (si -1, on ajuste) 01527 * 01528 * nom : nbImLig 01529 * type : int 01530 * role : nombre d'imagettes par LIGNE (si -1, on ajuste) 01531 * 01532 * FICHIER: imagette.c 01533 * 01534 * EXEMPLE: 01535 * 01536 ******************************************************** END DESCRIPTIoN */ 01537 01538 PPIMAGE_UCHAR IdImaScotchImagesXYHoriz ( 01539 PPIMAGE_UCHAR *tabimage, 01540 int nb, // nb nombres d'images 01541 int nx, // nx nombre d'images par ligne 01542 int ny) // ny nombre d'images par colonne 01543 01544 { 01545 PPIMAGE_UCHAR matImages=NULL; /* image finale a retourner */ 01546 01547 int XSIZE, YSIZE; 01548 01549 int l; 01550 01551 01552 01553 01554 if (!tabimage) { 01555 return 0; 01556 } 01557 01558 if (nb<=0) { 01559 return 0; 01560 } 01561 01562 if (tabimage[0] ==0) { 01563 return 0; 01564 } 01565 01566 XSIZE=IdImaDimX(tabimage[0]); 01567 YSIZE=IdImaDimY(tabimage[0]); 01568 01569 for (l=1;l<nb;l++) 01570 { 01571 if (!IdImaSameSizeAndType(tabimage[0],tabimage[l])) 01572 { 01573 return 0; 01574 } 01575 } 01576 matImages=IdImaMakeImagetteXYHoriz ( tabimage, nb, XSIZE, YSIZE, nx, ny); 01577 return matImages; 01578 } 01579 01580 01581 01582 /* FoNCTION DESCRIPTION ************************************************** 01583 * 01584 * IdImaScotchImagesXYVertic (fonction) 01585 * 01586 * RESUME: Colle ds une matrice (H->B, G->D ) des images les unes a la suite des autres 01587 * 01588 * DESCRIPTION: Colle des images (de MEME TAILLE) dans une matrice 01589 * Les images sont 'rangees' de haut en bas, puis de gauche a droite. 01590 * 01591 * SYNTAXE: im8= IdImaScotchImagesXYVertic (tabImages,nbImages,nbImCol,nbImLig); 01592 * 01593 * PARAMETRES: nom : tabImages 01594 * type : PPIMAGE_USHORT * 01595 * role : Pointeur vers le tableau d'images source 01596 * 01597 * PARAMETRES: nom : nbImages 01598 * type : int 01599 * role : nb d'images ds le tableau 01600 * 01601 * nom : nbImCol 01602 * type : int 01603 * role : nombre d'imagettes par COLONNE (si -1, on ajuste) 01604 * 01605 * nom : nbImLig 01606 * type : int 01607 * role : nombre d'imagettes par LIGNE (si -1, on ajuste) 01608 * 01609 * FICHIER: imagette.c 01610 * 01611 * EXEMPLE: 01612 * 01613 ******************************************************** END DESCRIPTIoN */ 01614 01615 01616 PPIMAGE_UCHAR IdImaScotchImagesXYVertic ( 01617 PPIMAGE_UCHAR *tabimage, 01618 int nb, // nb nombres d'images 01619 int nx, // nx nombre d'images par ligne 01620 int ny) // ny nombre d'images par colonne 01621 01622 { 01623 PPIMAGE_UCHAR matImages=NULL; /* image finale a retourner */ 01624 01625 int XSIZE, YSIZE; 01626 01627 int l; 01628 01629 01630 01631 01632 if (!tabimage) { 01633 return 0; 01634 } 01635 01636 if (nb<=0) { 01637 return 0; 01638 } 01639 01640 if (tabimage[0] ==0) { 01641 return 0; 01642 } 01643 01644 XSIZE=IdImaDimX(tabimage[0]); 01645 YSIZE=IdImaDimY(tabimage[0]); 01646 01647 for (l=1;l<nb;l++) 01648 { 01649 if (!IdImaSameSizeAndType(tabimage[0],tabimage[l])) 01650 { 01651 return 0; 01652 } 01653 } 01654 matImages=IdImaMakeImagetteXYVertic ( tabimage, nb, XSIZE, YSIZE, nx, ny); 01655 return matImages; 01656 }

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