00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
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
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079 #define FF1(typeima) \
00080
\
00081
if ( (minImpose!=-1.) && (maxImpose!=-1.) ) \
00082
{ \
00083
mini=minImpose; \
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; \
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 \
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
00171
00172
00173
00174
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194
00195
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.;
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
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
00280
00281
00282
00283
00284
00285
00286
00287
00288
00289
00290
00291
00292
00293
00294
00295
00296
00297
00298
00299
00300
00301
00302
00303
00304
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
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
00387
00388
00389
00390
00391
00392
00393
00394
00395
00396
00397
00398
00399
00400
00401
00402
00403
00404
00405
00406
00407
00408
00409
00410
00411
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
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
00491
00492
00493
00494
00495
00496
00497
00498
00499
00500
00501
00502
00503
00504
00505
00506
00507
00508
00509
00510
00511
00512
00513
00514
00515
00516
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;
00537 maxi=maxImpose;
00538
00539
for(i=0;i<
IdImaDimY(im16);i++)
00540
for(j=0;j<
IdImaDimY(im16);j++)
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
00546 }
00547
else
00548 {
00549 maxi=0;
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
00557 }
00558
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
00582
00583
00584
00585
00586
00587
00588
00589
00590
00591
00592
00593
00594
00595
00596
00597
00598
00599
00600
00601
00602
00603
00604
00605
00606
00607
00608
00609
00610
00611
00612
00613
00614
00615
00616
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;
00638 maxi=maxImpose;
00639
00640
for(i=0;i<
IdImaDimY(im16);i++)
00641
for(j=0;j<
IdImaDimY(im16);j++)
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;
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
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
00688
00689
00690
00691
00692
00693
00694
00695
00696
00697
00698
00699
00700
00701
00702
00703
00704
00705
00706
00707
00708
00709
00710
00711
00712
00713
00714
00715
00716
00717
00718
00719
00720
00721
00722
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
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;
00746 maxi=maxImpose;
00747
00748
for(i=0;i<
IdImaDimY(im16);i++)
00749
for(j=0;j<
IdImaDimY(im16);j++)
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;
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
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
00793
00794
00795
00796
00797
00798
00799
00800
00801
00802
00803
00804
00805
00806
00807
00808
00809
00810
00811
00812
00813
00814
00815
00816
00817
00818
00819
00820
00821
00822
00823
00824 #define FF6(typeima) \
00825
\
00826
if ( (minImpose!=-1.) && (maxImpose!=-1.) ) \
00827
{ \
00828
mini=minImpose; \
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; \
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 \
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
00917
00918
00919
00920
00921
00922
00923
00924
00925
00926
00927
00928
00929
00930
00931
00932
00933
00934
00935
00936
00937
00938
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
01012
01013
01014
01015
01016
01017
01018
01019
01020
01021
01022
01023
01024
01025
01026
01027
01028
01029
01030
01031
01032
01033
01034
01035
01036
01037
01038
01039
01040
01041
01042
01043
01044
01045
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,
01080
int neffectif,
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
01111
01112
01113
01114
01115
01116
01117
01118
01119
01120
01121
01122
01123
01124
01125
01126
01127
01128
01129
01130
01131
01132
01133
01134
01135
01136
01137
01138
01139
01140
01141
01142
01143
01144
01145
01146
01147
01148
01149
01150 PPIMAGE_UCHAR IdImaCreImagetteXY (
01151 PPIMAGE_UCHAR *tabimage,
01152
int nb,
01153
int XSIZE,
01154
int YSIZE,
01155
int nx,
01156
int ny)
01157
01158 {
01159
PPIMAGE_UCHAR imagettes=0;
01160
PPIMAGE_UCHAR ligne_imagettes=0;
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
01199
01200
01201
01202
01203
01204
01205
01206
01207
01208
01209
01210
01211
01212
01213
01214
01215
01216
01217
01218
01219
01220
01221
01222
01223
01224
01225
01226
01227
01228
01229
01230
01231
01232
01233
01234
01235
01236
01237
01238
01239 PPIMAGE_UCHAR IdImaMakeImagetteXYHoriz (
01240 PPIMAGE_UCHAR *tabimage,
01241
int nb,
01242
int XSIZE,
01243
int YSIZE,
01244
int nx,
01245
int ny)
01246
01247 {
01248
PPIMAGE_UCHAR imagettes=NULL;
01249
PPIMAGE_UCHAR imin=NULL,imout=NULL;
01250
01251
int k;
01252
int i,j,l;
01253
01254
int nlp;
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++)
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
01320
01321
01322
01323
01324
01325
01326
01327
01328
01329
01330
01331
01332
01333
01334
01335
01336
01337
01338
01339
01340
01341
01342
01343
01344
01345
01346
01347
01348
01349
01350
01351
01352
01353
01354
01355
01356
01357
01358
01359
01360 PPIMAGE_UCHAR IdImaMakeImagetteXYVertic (
01361 PPIMAGE_UCHAR *tabimage,
01362
int nb,
01363
int XSIZE,
01364
int YSIZE,
01365
int nx,
01366
int ny)
01367 {
01368
PPIMAGE_UCHAR imagettes=NULL;
01369
PPIMAGE_UCHAR imin=NULL,imout=NULL;
01370
01371
int k;
01372
int i,j,l;
01373
01374
int nlp;
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++)
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
01440
01441
01442
01443
01444
01445
01446
01447
01448
01449
01450
01451
01452
01453
01454
01455
01456
01457
01458
01459
01460
01461
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
01506
01507
01508
01509
01510
01511
01512
01513
01514
01515
01516
01517
01518
01519
01520
01521
01522
01523
01524
01525
01526
01527
01528
01529
01530
01531
01532
01533
01534
01535
01536
01537
01538 PPIMAGE_UCHAR IdImaScotchImagesXYHoriz (
01539 PPIMAGE_UCHAR *tabimage,
01540
int nb,
01541
int nx,
01542
int ny)
01543
01544 {
01545
PPIMAGE_UCHAR matImages=NULL;
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
01583
01584
01585
01586
01587
01588
01589
01590
01591
01592
01593
01594
01595
01596
01597
01598
01599
01600
01601
01602
01603
01604
01605
01606
01607
01608
01609
01610
01611
01612
01613
01614
01615
01616 PPIMAGE_UCHAR IdImaScotchImagesXYVertic (
01617 PPIMAGE_UCHAR *tabimage,
01618
int nb,
01619
int nx,
01620
int ny)
01621
01622 {
01623
PPIMAGE_UCHAR matImages=NULL;
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 }