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

sigpalet.c

Go to the documentation of this file.
00001 /* 00002 * Creation de diverses palettes de 128 ou 256 couleurs 00003 */ 00004 #include "idima.h" 00005 #include "iderr.h" 00006 #include "idio.h" 00007 #include "idprint.h" 00008 00009 00010 static RGB tabHotMetal[] = { 00011 {0, 0, 0}, 00012 {0, 0, 0}, 00013 {0, 0, 0}, 00014 {1, 0, 0}, 00015 {2, 0, 0}, 00016 {3, 0, 0}, 00017 {4, 0, 0}, 00018 {5, 0, 0}, 00019 {6, 0, 0}, 00020 {7, 0, 0}, 00021 {8, 0, 0}, 00022 {9, 0, 0}, 00023 {10, 0, 0}, 00024 {11, 0, 0}, 00025 {12, 0, 0}, 00026 {13, 0, 0}, 00027 {14, 0, 0}, 00028 {15, 0, 0}, 00029 {16, 0, 0}, 00030 {17, 0, 0}, 00031 {18, 0, 0}, 00032 {19, 0, 0}, 00033 {20, 0, 0}, 00034 {21, 0, 0}, 00035 {22, 0, 0}, 00036 {23, 0, 0}, 00037 {24, 0, 0}, 00038 {25, 0, 0}, 00039 {26, 0, 0}, 00040 {27, 0, 0}, 00041 {28, 0, 0}, 00042 {29, 0, 0}, 00043 {30, 0, 0}, 00044 {31, 0, 0}, 00045 {32, 0, 0}, 00046 {34, 0, 0}, 00047 {35, 0, 0}, 00048 {36, 0, 0}, 00049 {37, 0, 0}, 00050 {38, 0, 0}, 00051 {39, 0, 0}, 00052 {40, 0, 0}, 00053 {42, 0, 0}, 00054 {43, 0, 0}, 00055 {44, 0, 0}, 00056 {45, 0, 0}, 00057 {46, 0, 0}, 00058 {47, 0, 0}, 00059 {48, 0, 0}, 00060 {50, 0, 0}, 00061 {51, 0, 0}, 00062 {52, 0, 0}, 00063 {53, 0, 0}, 00064 {54, 0, 0}, 00065 {55, 0, 0}, 00066 {56, 0, 0}, 00067 {57, 0, 0}, 00068 {58, 0, 0}, 00069 {60, 0, 0}, 00070 {61, 0, 0}, 00071 {62, 0, 0}, 00072 {63, 0, 0}, 00073 {64, 0, 0}, 00074 {66, 0, 0}, 00075 {69, 0, 0}, 00076 {72, 0, 0}, 00077 {74, 0, 0}, 00078 {77, 0, 0}, 00079 {79, 0, 0}, 00080 {82, 0, 0}, 00081 {83, 0, 0}, 00082 {84, 0, 0}, 00083 {85, 0, 0}, 00084 {87, 0, 0}, 00085 {88, 0, 0}, 00086 {89, 0, 0}, 00087 {90, 0, 0}, 00088 {93, 0, 0}, 00089 {95, 0, 0}, 00090 {96, 0, 0}, 00091 {97, 0, 0}, 00092 {98, 0, 0}, 00093 {101, 0, 0}, 00094 {102, 0, 0}, 00095 {103, 0, 0}, 00096 {106, 0, 0}, 00097 {107, 0, 0}, 00098 {108, 0, 0}, 00099 {109, 0, 0}, 00100 {110, 0, 0}, 00101 {111, 0, 0}, 00102 {112, 0, 0}, 00103 {113, 0, 0}, 00104 {114, 0, 0}, 00105 {117, 0, 0}, 00106 {119, 0, 0}, 00107 {122, 0, 0}, 00108 {125, 0, 0}, 00109 {127, 0, 0}, 00110 {130, 0, 0}, 00111 {133, 0, 0}, 00112 {135, 0, 0}, 00113 {138, 0, 0}, 00114 {141, 0, 0}, 00115 {143, 0, 0}, 00116 {146, 0, 0}, 00117 {149, 0, 0}, 00118 {151, 0, 0}, 00119 {152, 0, 0}, 00120 {153, 2, 0}, 00121 {154, 5, 0}, 00122 {155, 9, 0}, 00123 {157, 12, 0}, 00124 {158, 16, 0}, 00125 {159, 20, 0}, 00126 {161, 23, 0}, 00127 {162, 27, 0}, 00128 {164, 30, 0}, 00129 {165, 34, 0}, 00130 {166, 38, 0}, 00131 {168, 41, 0}, 00132 {169, 45, 0}, 00133 {171, 49, 0}, 00134 {172, 52, 0}, 00135 {173, 56, 0}, 00136 {175, 59, 0}, 00137 {176, 63, 0}, 00138 {178, 67, 0}, 00139 {179, 70, 0}, 00140 {180, 74, 0}, 00141 {182, 77, 0}, 00142 {183, 81, 0}, 00143 {185, 85, 0}, 00144 {186, 88, 0}, 00145 {187, 92, 0}, 00146 {189, 96, 0}, 00147 {190, 99, 0}, 00148 {192, 103, 0}, 00149 {193, 106, 0}, 00150 {194, 110, 0}, 00151 {196, 114, 0}, 00152 {197, 117, 0}, 00153 {199, 121, 0}, 00154 {200, 124, 0}, 00155 {201, 128, 0}, 00156 {203, 132, 0}, 00157 {204, 135, 0}, 00158 {206, 139, 0}, 00159 {207, 143, 0}, 00160 {208, 146, 0}, 00161 {210, 150, 0}, 00162 {211, 153, 0}, 00163 {213, 157, 0}, 00164 {214, 161, 0}, 00165 {215, 164, 0}, 00166 {217, 168, 0}, 00167 {218, 172, 0}, 00168 {220, 175, 0}, 00169 {221, 179, 0}, 00170 {222, 182, 0}, 00171 {224, 186, 0}, 00172 {225, 190, 0}, 00173 {227, 193, 0}, 00174 {228, 197, 0}, 00175 {229, 200, 0}, 00176 {231, 204, 0}, 00177 {232, 208, 0}, 00178 {234, 211, 0}, 00179 {235, 215, 0}, 00180 {236, 219, 0}, 00181 {238, 222, 0}, 00182 {239, 226, 0}, 00183 {241, 229, 0}, 00184 {242, 233, 0}, 00185 {243, 237, 0}, 00186 {245, 240, 0}, 00187 {246, 244, 0}, 00188 {248, 247, 0}, 00189 {255, 255, 7}, 00190 {255, 255, 10}, 00191 {255, 255, 13}, 00192 {255, 255, 16}, 00193 {255, 255, 20}, 00194 {255, 255, 23}, 00195 {255, 255, 26}, 00196 {255, 255, 30}, 00197 {255, 255, 33}, 00198 {255, 255, 36}, 00199 {255, 255, 40}, 00200 {255, 255, 43}, 00201 {255, 255, 46}, 00202 {255, 255, 49}, 00203 {255, 255, 53}, 00204 {255, 255, 56}, 00205 {255, 255, 59}, 00206 {255, 255, 63}, 00207 {255, 255, 66}, 00208 {255, 255, 69}, 00209 {255, 255, 73}, 00210 {255, 255, 76}, 00211 {255, 255, 79}, 00212 {255, 255, 83}, 00213 {255, 255, 86}, 00214 {255, 255, 89}, 00215 {255, 255, 92}, 00216 {255, 255, 96}, 00217 {255, 255, 99}, 00218 {255, 255, 102}, 00219 {255, 255, 106}, 00220 {255, 255, 109}, 00221 {255, 255, 112}, 00222 {255, 255, 116}, 00223 {255, 255, 119}, 00224 {255, 255, 122}, 00225 {255, 255, 126}, 00226 {255, 255, 129}, 00227 {255, 255, 132}, 00228 {255, 255, 135}, 00229 {255, 255, 139}, 00230 {255, 255, 142}, 00231 {255, 255, 145}, 00232 {255, 255, 149}, 00233 {255, 255, 152}, 00234 {255, 255, 155}, 00235 {255, 255, 159}, 00236 {255, 255, 162}, 00237 {255, 255, 165}, 00238 {255, 255, 169}, 00239 {255, 255, 172}, 00240 {255, 255, 175}, 00241 {255, 255, 178}, 00242 {255, 255, 182}, 00243 {255, 255, 185}, 00244 {255, 255, 188}, 00245 {255, 255, 192}, 00246 {255, 255, 195}, 00247 {255, 255, 198}, 00248 {255, 255, 202}, 00249 {255, 255, 205}, 00250 {255, 255, 208}, 00251 {255, 255, 212}, 00252 {255, 255, 215}, 00253 {255, 255, 218}, 00254 {255, 255, 221}, 00255 {255, 255, 225}, 00256 {255, 255, 228}, 00257 {255, 255, 231}, 00258 {255, 255, 235}, 00259 {255, 255, 238}, 00260 {255, 255, 241}, 00261 {255, 255, 245}, 00262 {255, 255, 248}, 00263 {255, 255, 251}, 00264 {255, 255, 255}, 00265 {255, 255, 255}, 00266 {255, 255, 255}, 00267 {255, 255, 255}, 00268 /* ajout */ 00269 {255, 255, 255}, 00270 {255, 255, 255}, 00271 {255, 255, 255}, 00272 {255, 255, 255} 00273 00274 00275 00276 }; 00277 00278 00279 /* FUNCTION DESCRIPTION ************************************************** 00280 * 00281 * IdPalFalsCol (fonction) 00282 * 00283 * RESUME: palette 128 fausses couleurs pour affich. images 8 bits 00284 * 00285 * DESCRIPTION: creation d'une palette de 128 fausses couleurs 00286 * pour l'affichage de donnees 8 bits . 00287 * 00288 * SYNTAXE: PSIGNAL_RGB palette = IdPalFalsCol(); 00289 * 00290 * 00291 * RETOUR: type : PSIGNAL_RGB 00292 * role : PSIGNAL_RGB representant la LUT de 128 couleurs sur 3 00293 * octets permettant d'afficher les images. 00294 * 00295 * PARAMETRES: aucun 00296 * 00297 * FICHIER: idpalett.c 00298 * 00299 * EXEMPLE: 00300 * 00301 * ******************************************************** END DESCRIPTION */ 00302 00303 #define NBCOL 128 00304 #define PAS 21 00305 00306 00307 /* passage graduel en 128 couleurs : 00308 * noir,(0) 00309 * bleu,(21) 00310 * vert,(42) 00311 * jaune,(63) 00312 * orange,(84) 00313 * rouge,(105) 00314 * violet.(126 a 127) 00315 * 00316 * 21 teintes entre deux references. 00317 * 00318 */ 00319 00320 PSIGNAL_RGB IdPalFalsCol(void) 00321 { 00322 00323 PSIGNAL_RGB lut; 00324 int i; 00325 00326 lut = (PSIGNAL_RGB) IdSigAlloc(256, SIG_RGB); 00327 00328 if (!(lut)) { 00329 IdErrPrintf("Erreur d'allocation de memoire palette\n"); 00330 return 0; 00331 } 00332 00333 for (i = 0; i < PAS; i += 2) { 00334 lut[i].r = 0; 00335 lut[i].g = 0; 00336 lut[i].b = 6 * i; 00337 } 00338 00339 00340 for (i = 0; i < PAS; i += 2) { 00341 lut[i + PAS].r = 0; 00342 lut[i + PAS].g = 6 * i; 00343 lut[i + PAS].b = 252; 00344 } 00345 00346 for (i = 0; i < PAS; i += 2) { 00347 lut[i + 2 * PAS].r = 0; 00348 lut[i + 2 * PAS].g = 252; 00349 lut[i + 2 * PAS].b = 252 - 6 * i; 00350 } 00351 00352 for (i = 0; i < PAS; i += 2) { 00353 lut[i + 3 * PAS].r = 6 * i; 00354 lut[i + 3 * PAS].g = 252; 00355 lut[i + 3 * PAS].b = 0; 00356 } 00357 00358 for (i = 0; i < PAS; i += 2) { 00359 lut[i + 4 * PAS].r = 252; 00360 lut[i + 4 * PAS].g = 252 - 6 * i; 00361 lut[i + 4 * PAS].b = 0; 00362 } 00363 00364 for (i = 0; i < PAS; i += 2) { 00365 lut[i + 5 * PAS].r = 252; 00366 lut[i + 5 * PAS].g = 0; 00367 lut[i + 5 * PAS].b = 6 * i; 00368 } 00369 00370 for (i = 126; i < NBCOL; i += 2) { 00371 lut[i + 6 * PAS].r = 252; 00372 lut[i + 6 * PAS].g = 0; 00373 lut[i + 6 * PAS].b = 252; 00374 } 00375 00376 return lut; 00377 00378 } 00379 00380 /* FUNCTION DESCRIPTION ************************************************** 00381 * 00382 * IdPalGreyCol (fonction) 00383 * 00384 * RESUME: palette 128 niveaux de gris pour affich. images 8 bits 00385 * 00386 * DESCRIPTION: creation d'une palette de 128 niveaux de gris 00387 * pour la visualisation des images . 00388 * 00389 * SYNTAXE: PSIGNAL_RGB palette = IdPalGreyCol(); 00390 * 00391 * RETOUR: type : PSIGNAL_RGB 00392 * role : signal 256 representant la LUT de 128 niveaux de gris sur 3 00393 * octets permettant d'afficher les images. 00394 * 00395 * PARAMETRES: aucun 00396 * 00397 * FICHIER: idpalett.c 00398 * 00399 * EXEMPLE: 00400 * 00401 * ******************************************************** END DESCRIPTION */ 00402 00403 /* palette standard en niveaux de gris : 128 valeurs 00404 * du noir (0) 00405 * au blanc (255) 00406 */ 00407 00408 PSIGNAL_RGB IdPalGreyCol(void) 00409 { 00410 00411 PSIGNAL_RGB lut; 00412 int i; 00413 00414 lut = (PSIGNAL_RGB) IdSigAlloc(256, SIG_RGB); 00415 00416 if (!(lut)) { 00417 IdErrPrintf("Erreur d'allocation de memoire palette\n"); 00418 return 0; 00419 } 00420 00421 for (i = 0; i < 256; i += 2) { 00422 lut[i].r = lut[i + 1].r = i; 00423 lut[i].g = lut[i + 1].g = i; 00424 lut[i].b = lut[i + 1].b = i; 00425 } 00426 00427 return lut; 00428 } 00429 00430 00431 /* FUNCTION DESCRIPTION ************************************************** 00432 * 00433 * IdPalGrey64 (fonction) 00434 * 00435 * RESUME: palette 64 niveaux de gris pour affich. images 8 bits 00436 * 00437 * DESCRIPTION: creation d'une palette de 64 niveaux de gris 00438 * pour la visualisation des images. 00439 * ( Utile lorsqu'on a, en + d'une image a niveaux de gris, 00440 * une palette 'riche' en fausses couleurs) 00441 * 00442 * SYNTAXE: PSIGNAL_RGB palette = IdPalGrey64(); 00443 * 00444 * RETOUR: type : PSIGNAL_RGB 00445 * role : signal 256 representant la LUT de 74 niveaux de gris sur 3 00446 * octets permettant d'afficher les images. 00447 * 00448 * PARAMETRES: aucun 00449 * 00450 * FICHIER: idpalett.c 00451 * 00452 * EXEMPLE: 00453 * 00454 * ******************************************************** END DESCRIPTION */ 00455 00456 PSIGNAL_RGB IdPalGrey64(void) 00457 { 00458 00459 PSIGNAL_RGB lut; 00460 int i; 00461 00462 lut = (PSIGNAL_RGB) IdSigAlloc(256, SIG_RGB); 00463 00464 if (!(lut)) { 00465 IdErrPrintf("Erreur d'allocation de memoire palette\n"); 00466 return 0; 00467 } 00468 00469 for (i = 0; i < 256; i += 4) { 00470 lut[i].r = lut[i + 1].r = lut[i + 2].r = lut[i + 3].r = i; 00471 lut[i].g = lut[i + 1].g = lut[i + 2].g = lut[i + 3].g = i; 00472 lut[i].b = lut[i + 1].b = lut[i + 2].b = lut[i + 3].b = i; 00473 } 00474 00475 00476 return lut; 00477 } 00478 00479 00480 /* FUNCTION DESCRIPTION ************************************************** 00481 * 00482 * IdPalGreyRedCol (fonction) 00483 * 00484 * RESUME: Palette 127 niveaux de gris + Rouge pour affich. images 8 bits 00485 * 00486 * DESCRIPTION: creation d'une palette de 127 niveaux de gris + Rouge 00487 * pour la visualisation des images . 00488 * 00489 * SYNTAXE: PSIGNAL_RGB palette = IdPalGreyRedCol(); 00490 * 00491 * RETOUR: type : PSIGNAL_RGB 00492 * role : signal 256 representant la LUT 00493 * de 127 niveaux de gris + Rouge sur 3 00494 * octets permettant d'afficher les images. 00495 * 00496 * PARAMETRES: aucun 00497 * 00498 * FICHIER: idpalett.c 00499 * 00500 * EXEMPLE: 00501 * 00502 * ******************************************************** END DESCRIPTION */ 00503 00504 /* palette standard en niveaux de gris : 128 valeurs 00505 * du noir (0) 00506 * au blanc (127) puis Rouge 00507 */ 00508 00509 PSIGNAL_RGB IdPalGreyRedCol(void) 00510 { 00511 00512 PSIGNAL_RGB lut; 00513 int i; 00514 00515 lut = (PSIGNAL_RGB) IdSigAlloc(256, SIG_RGB); 00516 00517 if (!(lut)) { 00518 IdErrPrintf("Erreur d'allocation de memoire palette\n"); 00519 return 0; 00520 } 00521 00522 for (i = 0; i < 254; i += 2) { 00523 lut[i].r = lut[i + 1].r = i; 00524 lut[i].g = lut[i + 1].g = i; 00525 lut[i].b = lut[i + 1].b = i; 00526 } 00527 00528 lut[254].r = lut[255].r = 255; 00529 lut[254].g = lut[255].g = 0; 00530 lut[254].b = lut[255].b = 0; 00531 00532 return lut; 00533 } 00534 00535 00536 /* FUNCTION DESCRIPTION ************************************************** 00537 * 00538 * IdPalGreyRedToYellowCol (fonction) 00539 * 00540 * RESUME: Palette niveaux de gris-> seuil puis de Rouge a Jaune 00541 * 00542 * DESCRIPTION: palette niveaux de gris-> seuil puis de Rouge a Jaune . 00543 * 00544 * SYNTAXE: PSIGNAL_RGB palette = IdPalGreyRedToYellowCol(int seuil); 00545 * 00546 * RETOUR: type : PSIGNAL_RGB 00547 * role : signal 256 representant la LUT 00548 * niveaux de gris-> seuil puis de Rouge a Jaune 00549 * sur 3 octets permettant d'afficher les images. 00550 * 00551 * PARAMETRES: 00552 * nom : seuil 00553 * type : int 00554 * role : seuil a partir du quel on commence l'echelle Rouge-Jaune 00555 * 00556 * FICHIER: idpalett.c 00557 * 00558 * EXEMPLE: 00559 * 00560 * ******************************************************** END DESCRIPTION */ 00561 00562 PSIGNAL_RGB IdPalGreyRedToYellowCol(int seuil) 00563 { 00564 00565 PSIGNAL_RGB lut; 00566 int i, div; 00567 00568 lut = (PSIGNAL_RGB) IdSigAlloc(256, SIG_RGB); 00569 00570 if (!(lut)) { 00571 IdErrPrintf("Erreur d'allocation de memoire palette\n"); 00572 return 0; 00573 } 00574 00575 for (i = 0; i < seuil - 2; i += 2) { 00576 lut[i].r = lut[i + 1].r = i; 00577 lut[i].g = lut[i + 1].g = i; 00578 lut[i].b = lut[i + 1].b = i; 00579 } 00580 00581 div = 255 - seuil; 00582 00583 for (i = seuil; i < 254; i += 2) { 00584 lut[i].r = lut[i + 1].r = 255; 00585 lut[i].g = lut[i + 1].g = (i - seuil) * 255 / div; 00586 lut[i].b = lut[i + 1].b = 0; 00587 } 00588 00589 lut[254].r = lut[255].r = 255; 00590 lut[254].g = lut[255].g = 255; 00591 lut[254].b = lut[255].b = 0; 00592 00593 00594 return lut; 00595 } 00596 00597 /* FUNCTION DESCRIPTION ************************************************** 00598 * 00599 * IdPalHotMetal (fonction) 00600 * 00601 * RESUME: Palette Hot Metal 256 fausses couleurs pour affich. images 8 bits 00602 * 00603 * DESCRIPTION: creation d'une palette Hot Metal 256 fausse fausses couleurs 00604 * pour l'affichage de donnees 8 bits . 00605 * 00606 * SYNTAXE: PSIGNAL_RGB palette = IdPalHotMetal(); 00607 * 00608 * RETOUR: type : PSIGNAL_RGB 00609 * role : PSIGNAL_RGB representant la LUT de 256 couleurs sur 3 00610 * octets permettant d'afficher les images. 00611 * 00612 * PARAMETRES: aucun 00613 * 00614 * FICHIER: idpalett.c 00615 * 00616 * EXEMPLE: 00617 * 00618 * ******************************************************** END DESCRIPTION */ 00619 PSIGNAL_RGB IdPalHotMetal(void) 00620 { 00621 int i; 00622 00623 PSIGNAL_RGB lut; 00624 00625 lut = (PSIGNAL_RGB) IdSigAlloc(256, SIG_RGB); 00626 00627 if (!(lut)) { 00628 IdErrPrintf("Erreur d'allocation de memoire palette\n"); 00629 return 0; 00630 } 00631 00632 for (i = 0; i < 255; i++) { 00633 lut[i].r = tabHotMetal[i].r; 00634 lut[i].g = tabHotMetal[i].g; 00635 lut[i].b = tabHotMetal[i].b; 00636 } 00637 00638 return lut; 00639 } 00640 00641 00642 /* FUNCTION DESCRIPTION ************************************************** 00643 * 00644 * IdPalHotMetal128 (fonction) 00645 * 00646 * RESUME: Palette Hot Metal 128 fausses couleurs pour affich. images 8 bits 00647 * 00648 * DESCRIPTION: creation d'une palette Hot Metal 128 fausse fausses couleurs 00649 * pour l'affichage de donnees 8 bits . 00650 * 00651 * SYNTAXE: PSIGNAL_RGB palette = IdPalHotMetal128(); 00652 * 00653 * RETOUR: type : PSIGNAL_RGB 00654 * role : PSIGNAL_RGB representant la LUT de 128 couleurs sur 3 00655 * octets permettant d'afficher les images. 00656 * 00657 * PARAMETRES: aucun 00658 * 00659 * FICHIER: idpalett.c 00660 * 00661 * EXEMPLE: 00662 * 00663 * ******************************************************** END DESCRIPTION */ 00664 PSIGNAL_RGB IdPalHotMetal128(void) 00665 { 00666 int i; 00667 00668 PSIGNAL_RGB lut; 00669 00670 lut = (PSIGNAL_RGB) IdSigAlloc(256, SIG_RGB); 00671 00672 if (!(lut)) { 00673 IdErrPrintf("Erreur d'allocation de memoire palette\n"); 00674 return 0; 00675 } 00676 00677 for (i = 0; i < 255; i += 2) { 00678 lut[i].r = lut[i + 1].r = tabHotMetal[i].r; 00679 lut[i].g = lut[i + 1].g = tabHotMetal[i].g; 00680 lut[i].b = lut[i + 1].b = tabHotMetal[i].b; 00681 } 00682 00683 return lut; 00684 } 00685 00686 /* FUNCTION DESCRIPTION ************************************************** 00687 * 00688 * IdPalHotMetal64 (fonction) 00689 * 00690 * RESUME: Palette Hot Metal 64 fausses couleurs pour affich. images 8 bits 00691 * 00692 * DESCRIPTION: creation d'une palette Hot Metal 64 fausse fausses couleurs 00693 * pour l'affichage de donnees 8 bits . 00694 * 00695 * SYNTAXE: PSIGNAL_RGB palette = IdPalHotMetal64(); 00696 * 00697 * RETOUR: type : PSIGNAL_RGB 00698 * role : PSIGNAL_RGB representant la LUT de 64 couleurs sur 3 00699 * octets permettant d'afficher les images. 00700 * 00701 * PARAMETRES: aucun 00702 * 00703 * FICHIER: idpalett.c 00704 * 00705 * EXEMPLE: 00706 * 00707 * ******************************************************** END DESCRIPTION */ 00708 PSIGNAL_RGB IdPalHotMetal64(void) 00709 { 00710 00711 int i; 00712 00713 PSIGNAL_RGB lut; 00714 00715 lut = (PSIGNAL_RGB) IdSigAlloc(256, SIG_RGB); 00716 00717 if (!(lut)) { 00718 IdErrPrintf("Erreur d'allocation de memoire palette\n"); 00719 return 0; 00720 } 00721 00722 for (i = 0; i < 255; i += 4) { 00723 lut[i].r = lut[i + 1].r = lut[i + 2].r = lut[i + 3].r = 00724 tabHotMetal[i].r; 00725 lut[i].g = lut[i + 1].g = lut[i + 2].g = lut[i + 3].g = 00726 tabHotMetal[i].g; 00727 lut[i].b = lut[i + 1].b = lut[i + 2].b = lut[i + 3].b = 00728 tabHotMetal[i].b; 00729 } 00730 00731 return lut; 00732 } 00733 00734 00735 /* FUNCTION DESCRIPTION ************************************************** 00736 * 00737 * IdPalHotMetal32 (fonction) 00738 * 00739 * RESUME: Palette Hot Metal 16 fausses couleurs pour affich. images 8 bits 00740 * 00741 * DESCRIPTION: creation d'une palette Hot Metal 32 fausse fausses couleurs 00742 * pour l'affichage de donnees 8 bits . 00743 * 00744 * SYNTAXE: PSIGNAL_RGB palette = IdPalHotMetal32(); 00745 * 00746 * RETOUR: type : PSIGNAL_RGB 00747 * role : PSIGNAL_RGB representant la LUT de 32 couleurs sur 3 00748 * octets permettant d'afficher les images. 00749 * 00750 * PARAMETRES: aucun 00751 * 00752 * FICHIER: idpalett.c 00753 * 00754 * EXEMPLE: 00755 * 00756 * ******************************************************** END DESCRIPTION */ 00757 PSIGNAL_RGB IdPalHotMetal32(void) 00758 { 00759 00760 int i, j; 00761 00762 PSIGNAL_RGB lut; 00763 00764 lut = (PSIGNAL_RGB) IdSigAlloc(256, SIG_RGB); 00765 00766 if (!(lut)) { 00767 IdErrPrintf("Erreur d'allocation de memoire palette\n"); 00768 return 0; 00769 } 00770 00771 for (i = 0; i < 255; i += 8) { 00772 for (j = 0; j < 8; j++) { 00773 lut[i + j].r = tabHotMetal[i].r; 00774 lut[i + j].g = tabHotMetal[i].g; 00775 lut[i + j].b = tabHotMetal[i].b; 00776 } 00777 } 00778 00779 return lut; 00780 } 00781 00782 00783 00784 /* FUNCTION DESCRIPTION ************************************************** 00785 * 00786 * IdPalHotMetal16 (fonction) 00787 * 00788 * RESUME: Palette Hot Metal 16 fausses couleurs pour affich. images 8 bits 00789 * 00790 * DESCRIPTION: creation d'une palette Hot Metal 16 fausse fausses couleurs 00791 * pour l'affichage de donnees 8 bits . 00792 * 00793 * SYNTAXE: PSIGNAL_RGB palette = IdPalHotMetal16(); 00794 * 00795 * RETOUR: type : PSIGNAL_RGB 00796 * role : PSIGNAL_RGB representant la LUT de 16 couleurs sur 3 00797 * octets permettant d'afficher les images. 00798 * 00799 * PARAMETRES: aucun 00800 * 00801 * FICHIER: idpalett.c 00802 * 00803 * EXEMPLE: 00804 * 00805 * ******************************************************** END DESCRIPTION */ 00806 PSIGNAL_RGB IdPalHotMetal16(void) 00807 { 00808 00809 int i, j; 00810 00811 PSIGNAL_RGB lut; 00812 00813 lut = (PSIGNAL_RGB) IdSigAlloc(256, SIG_RGB); 00814 00815 if (!(lut)) { 00816 IdErrPrintf("Erreur d'allocation de memoire palette\n"); 00817 return 0; 00818 } 00819 00820 for (i = 0; i < 255; i += 16) { 00821 for (j = 0; j < 16; j++) { 00822 lut[i + j].r = tabHotMetal[i].r; 00823 lut[i + j].g = tabHotMetal[i].g; 00824 lut[i + j].b = tabHotMetal[i].b; 00825 } 00826 } 00827 00828 return lut; 00829 } 00830 00831 00832 /* FUNCTION DESCRIPTION ************************************************** 00833 * 00834 * IdPalHotMetal8 (fonction) 00835 * 00836 * RESUME: Palette Hot Metal 8 fausses couleurs pour affich. images 8 bits 00837 * 00838 * DESCRIPTION: creation d'une palette Hot Metal 8 fausse fausses couleurs 00839 * pour l'affichage de donnees 8 bits . 00840 * 00841 * SYNTAXE: PSIGNAL_RGB palette = IdPalHotMetal8(); 00842 * 00843 * RETOUR: type : PSIGNAL_RGB 00844 * role : PSIGNAL_RGB representant la LUT de 8 couleurs sur 3 00845 * octets permettant d'afficher les images. 00846 * 00847 * PARAMETRES: aucun 00848 * 00849 * FICHIER: idpalett.c 00850 * 00851 * EXEMPLE: 00852 * 00853 * ******************************************************** END DESCRIPTION */ 00854 PSIGNAL_RGB IdPalHotMetal8(void) 00855 { 00856 00857 int i, j; 00858 00859 PSIGNAL_RGB lut; 00860 00861 lut = (PSIGNAL_RGB) IdSigAlloc(256, SIG_RGB); 00862 00863 if (!(lut)) { 00864 IdErrPrintf("Erreur d'allocation de memoire palette\n"); 00865 return 0; 00866 } 00867 00868 for (i = 0; i < 255; i += 32) { 00869 for (j = 0; j < 32; j++) { 00870 lut[i + j].r = tabHotMetal[i].r; 00871 lut[i + j].g = tabHotMetal[i].g; 00872 lut[i + j].b = tabHotMetal[i].b; 00873 } 00874 } 00875 00876 return lut; 00877 } 00878 00879 00880 /* FUNCTION DESCRIPTION ************************************************** 00881 * 00882 * IdPalAnalyseStd (fonction) 00883 * 00884 * RESUME: Palette Analyse Standard 256 fausses couleurs pour affich. images 8 bits 00885 * 00886 * DESCRIPTION: creation d'une palette Analyse Standard 256 fausse fausses couleurs (noir -> vert -> jaune -> rouge -> blanc) pour l'affichage de donnees 8 bits . 00887 * 00888 * SYNTAXE: PSIGNAL_RGB palette = IdPalAnalyseStd(); 00889 * 00890 * RETOUR: type : PSIGNAL_RGB 00891 * role : PSIGNAL_RGB representant la LUT de 256 couleurs sur 3 00892 * octets permettant d'afficher les images. 00893 * 00894 * PARAMETRES: aucun 00895 * 00896 * FICHIER: idpalett.c 00897 * 00898 * EXEMPLE: 00899 * 00900 * ******************************************************** END DESCRIPTION */ 00901 PSIGNAL_RGB IdPalAnalyseStd(void) 00902 { 00903 static RGB tabAnalyseStd[] = { {0, 0, 0}, 00904 {1, 0, 1}, 00905 {2, 0, 2}, 00906 {4, 0, 4}, 00907 {6, 0, 6}, 00908 {8, 0, 8}, 00909 {10, 0, 10}, 00910 {12, 0, 12}, 00911 {14, 0, 14}, 00912 {16, 0, 16}, 00913 {17, 0, 17}, 00914 {19, 0, 19}, 00915 {21, 0, 21}, 00916 {23, 0, 23}, 00917 {25, 0, 25}, 00918 {27, 0, 27}, 00919 {29, 0, 29}, 00920 {31, 0, 31}, 00921 {32, 0, 32}, 00922 {34, 0, 34}, 00923 {36, 0, 36}, 00924 {38, 0, 38}, 00925 {40, 0, 40}, 00926 {42, 0, 42}, 00927 {44, 0, 44}, 00928 {46, 0, 46}, 00929 {48, 0, 48}, 00930 {46, 0, 49}, 00931 {44, 0, 50}, 00932 {43, 0, 52}, 00933 {42, 0, 54}, 00934 {40, 0, 56}, 00935 {39, 0, 57}, 00936 {38, 0, 59}, 00937 {36, 0, 61}, 00938 {35, 0, 63}, 00939 {34, 0, 65}, 00940 {32, 0, 67}, 00941 {31, 0, 68}, 00942 {30, 0, 70}, 00943 {28, 0, 72}, 00944 {27, 0, 74}, 00945 {26, 0, 76}, 00946 {24, 0, 77}, 00947 {23, 0, 79}, 00948 {22, 0, 81}, 00949 {21, 0, 83}, 00950 {19, 0, 85}, 00951 {18, 0, 86}, 00952 {17, 0, 88}, 00953 {15, 0, 90}, 00954 {14, 0, 92}, 00955 {13, 0, 94}, 00956 {11, 0, 95}, 00957 {10, 0, 97}, 00958 {9, 0, 99}, 00959 {7, 0, 101}, 00960 {6, 0, 103}, 00961 {5, 0, 104}, 00962 {3, 0, 106}, 00963 {2, 0, 108}, 00964 {1, 0, 110}, 00965 {0, 0, 112}, 00966 {0, 2, 112}, 00967 {0, 4, 112}, 00968 {0, 7, 112}, 00969 {0, 10, 112}, 00970 {0, 13, 112}, 00971 {0, 15, 112}, 00972 {0, 18, 112}, 00973 {0, 21, 112}, 00974 {0, 24, 112}, 00975 {0, 26, 112}, 00976 {0, 29, 112}, 00977 {0, 32, 112}, 00978 {0, 35, 112}, 00979 {0, 37, 112}, 00980 {0, 40, 112}, 00981 {0, 43, 112}, 00982 {0, 46, 112}, 00983 {0, 48, 112}, 00984 {0, 51, 112}, 00985 {0, 54, 112}, 00986 {0, 57, 112}, 00987 {0, 59, 112}, 00988 {0, 62, 112}, 00989 {0, 65, 112}, 00990 {0, 68, 112}, 00991 {0, 70, 112}, 00992 {0, 73, 112}, 00993 {0, 76, 112}, 00994 {0, 79, 112}, 00995 {0, 81, 112}, 00996 {0, 84, 112}, 00997 {0, 87, 112}, 00998 {0, 90, 112}, 00999 {0, 92, 112}, 01000 {0, 95, 112}, 01001 {0, 98, 112}, 01002 {0, 101, 112}, 01003 {0, 103, 112}, 01004 {0, 106, 112}, 01005 {0, 109, 112}, 01006 {0, 112, 112}, 01007 {0, 113, 109}, 01008 {0, 114, 106}, 01009 {0, 116, 103}, 01010 {0, 117, 101}, 01011 {0, 119, 98}, 01012 {0, 120, 95}, 01013 {0, 122, 93}, 01014 {0, 123, 90}, 01015 {0, 125, 87}, 01016 {0, 126, 85}, 01017 {0, 128, 82}, 01018 {0, 129, 79}, 01019 {0, 131, 77}, 01020 {0, 132, 74}, 01021 {0, 134, 71}, 01022 {0, 136, 69}, 01023 {0, 137, 66}, 01024 {0, 139, 63}, 01025 {0, 140, 61}, 01026 {0, 142, 58}, 01027 {0, 143, 55}, 01028 {0, 145, 53}, 01029 {0, 146, 50}, 01030 {0, 148, 47}, 01031 {0, 149, 45}, 01032 {0, 151, 42}, 01033 {0, 152, 39}, 01034 {0, 154, 37}, 01035 {0, 156, 34}, 01036 {0, 157, 31}, 01037 {0, 159, 29}, 01038 {0, 160, 26}, 01039 {0, 162, 23}, 01040 {0, 163, 21}, 01041 {0, 165, 18}, 01042 {0, 166, 15}, 01043 {0, 168, 13}, 01044 {0, 169, 10}, 01045 {0, 171, 7}, 01046 {0, 172, 5}, 01047 {0, 174, 2}, 01048 {0, 176, 0}, 01049 {5, 176, 0}, 01050 {10, 176, 0}, 01051 {15, 177, 0}, 01052 {20, 178, 0}, 01053 {26, 179, 0}, 01054 {31, 180, 0}, 01055 {36, 180, 0}, 01056 {42, 181, 0}, 01057 {47, 182, 0}, 01058 {52, 183, 0}, 01059 {58, 184, 0}, 01060 {63, 184, 0}, 01061 {68, 185, 0}, 01062 {74, 186, 0}, 01063 {79, 187, 0}, 01064 {84, 188, 0}, 01065 {90, 189, 0}, 01066 {95, 189, 0}, 01067 {100, 190, 0}, 01068 {105, 191, 0}, 01069 {111, 192, 0}, 01070 {116, 193, 0}, 01071 {121, 193, 0}, 01072 {127, 194, 0}, 01073 {132, 195, 0}, 01074 {137, 196, 0}, 01075 {143, 197, 0}, 01076 {148, 198, 0}, 01077 {153, 198, 0}, 01078 {159, 199, 0}, 01079 {164, 200, 0}, 01080 {169, 201, 0}, 01081 {175, 202, 0}, 01082 {180, 202, 0}, 01083 {185, 203, 0}, 01084 {191, 204, 0}, 01085 {196, 205, 0}, 01086 {201, 206, 0}, 01087 {207, 207, 0}, 01088 {208, 202, 0}, 01089 {208, 196, 0}, 01090 {209, 191, 0}, 01091 {210, 185, 0}, 01092 {211, 180, 0}, 01093 {212, 174, 0}, 01094 {213, 169, 0}, 01095 {214, 163, 0}, 01096 {214, 158, 0}, 01097 {215, 152, 0}, 01098 {216, 147, 0}, 01099 {217, 141, 0}, 01100 {218, 136, 0}, 01101 {219, 131, 0}, 01102 {220, 125, 0}, 01103 {220, 120, 0}, 01104 {221, 114, 0}, 01105 {222, 109, 0}, 01106 {223, 103, 0}, 01107 {224, 98, 0}, 01108 {225, 92, 0}, 01109 {226, 87, 0}, 01110 {227, 81, 0}, 01111 {227, 76, 0}, 01112 {228, 70, 0}, 01113 {229, 65, 0}, 01114 {230, 60, 0}, 01115 {231, 54, 0}, 01116 {232, 49, 0}, 01117 {233, 43, 0}, 01118 {233, 38, 0}, 01119 {234, 32, 0}, 01120 {235, 27, 0}, 01121 {236, 21, 0}, 01122 {237, 16, 0}, 01123 {238, 10, 0}, 01124 {239, 5, 0}, 01125 {240, 0, 0}, 01126 {240, 8, 8}, 01127 {240, 16, 16}, 01128 {240, 24, 24}, 01129 {240, 32, 32}, 01130 {240, 41, 41}, 01131 {240, 49, 49}, 01132 {240, 57, 57}, 01133 {240, 65, 65}, 01134 {240, 74, 74}, 01135 {240, 82, 82}, 01136 {240, 90, 90}, 01137 {240, 98, 98}, 01138 {240, 107, 107}, 01139 {240, 115, 115}, 01140 {240, 123, 123}, 01141 {240, 131, 131}, 01142 {240, 140, 140}, 01143 {240, 148, 148}, 01144 {240, 156, 156}, 01145 {240, 164, 164}, 01146 {240, 173, 173}, 01147 {240, 181, 181}, 01148 {240, 189, 189}, 01149 {240, 197, 197}, 01150 {240, 206, 206}, 01151 {240, 214, 214}, 01152 {240, 222, 222}, 01153 {240, 231, 231}, 01154 {143, 188, 143}, 01155 {255, 255, 255}, 01156 {0, 0, 255}, 01157 {255, 255, 0}, 01158 {255, 0, 0} 01159 01160 }; 01161 01162 int i; 01163 01164 01165 01166 PSIGNAL_RGB lut; 01167 01168 lut = (PSIGNAL_RGB) IdSigAlloc(256, SIG_RGB); 01169 01170 if (!(lut)) { 01171 IdErrPrintf("Erreur d'allocation de memoire palette\n"); 01172 return 0; 01173 } 01174 01175 for (i = 0; i < 255; i++) { 01176 lut[i].r = tabAnalyseStd[i].r; 01177 lut[i].g = tabAnalyseStd[i].g; 01178 lut[i].b = tabAnalyseStd[i].b; 01179 } 01180 01181 01182 return lut; 01183 } 01184 01185 01186 /* FUNCTION DESCRIPTION ************************************************** 01187 * 01188 * IdPalAnalyseRet (fonction) 01189 * 01190 * RESUME: Palette Analyse Retouchee 256 fausses couleurs pour affich. images 8 bits 01191 * 01192 * DESCRIPTION: creation d'une palette Analyse Retouchee (pour + de luminosite) 256 fausse fausses couleurs (noir -> vert -> jaune -> rouge -> blanc) pour l'affichage de donnees 8 bits . 01193 * 01194 * SYNTAXE: PSIGNAL_RGB palette = IdPalAnalyseRet(); 01195 * 01196 * RETOUR: type : PSIGNAL_RGB 01197 * role : PSIGNAL_RGB representant la LUT de 256 couleurs sur 3 01198 * octets permettant d'afficher les images. 01199 * 01200 * PARAMETRES: aucun 01201 * 01202 * FICHIER: idpalett.c 01203 * 01204 * EXEMPLE: 01205 * 01206 * ******************************************************** END DESCRIPTION */ 01207 PSIGNAL_RGB IdPalAnalyseRet(void) 01208 { 01209 static RGB tabAnalyseRet[] = { 01210 01211 {0, 0, 0}, 01212 {1, 0, 1}, 01213 {46, 0, 49}, 01214 {0, 2, 68}, 01215 {0, 3, 68}, 01216 {0, 5, 69}, 01217 {0, 6, 69}, 01218 {0, 8, 70}, 01219 {0, 9, 71}, 01220 {0, 11, 71}, 01221 {0, 12, 72}, 01222 {0, 14, 72}, 01223 {0, 15, 73}, 01224 {0, 17, 74}, 01225 {0, 19, 74}, 01226 {0, 20, 75}, 01227 {0, 22, 76}, 01228 {0, 23, 76}, 01229 {0, 25, 77}, 01230 {0, 26, 77}, 01231 {0, 28, 78}, 01232 {0, 29, 79}, 01233 {0, 31, 79}, 01234 {0, 32, 80}, 01235 {0, 34, 81}, 01236 {0, 36, 81}, 01237 {0, 37, 82}, 01238 {0, 39, 82}, 01239 {0, 40, 83}, 01240 {0, 42, 84}, 01241 {0, 43, 84}, 01242 {0, 45, 85}, 01243 {0, 46, 85}, 01244 {0, 48, 86}, 01245 {0, 50, 87}, 01246 {0, 51, 87}, 01247 {0, 53, 88}, 01248 {0, 54, 89}, 01249 {0, 56, 89}, 01250 {0, 57, 90}, 01251 {0, 59, 90}, 01252 {0, 60, 91}, 01253 {0, 62, 92}, 01254 {0, 63, 92}, 01255 {0, 65, 93}, 01256 {0, 67, 94}, 01257 {0, 68, 94}, 01258 {0, 70, 95}, 01259 {0, 71, 95}, 01260 {0, 73, 96}, 01261 {0, 74, 97}, 01262 {0, 76, 97}, 01263 {0, 77, 98}, 01264 {0, 79, 98}, 01265 {0, 81, 99}, 01266 {0, 82, 100}, 01267 {0, 84, 100}, 01268 {0, 85, 101}, 01269 {0, 87, 102}, 01270 {0, 88, 102}, 01271 {0, 90, 103}, 01272 {0, 91, 103}, 01273 {0, 93, 104}, 01274 {0, 94, 105}, 01275 {0, 96, 105}, 01276 {0, 98, 106}, 01277 {0, 99, 107}, 01278 {0, 101, 107}, 01279 {0, 102, 108}, 01280 {0, 104, 108}, 01281 {0, 105, 109}, 01282 {0, 107, 110}, 01283 {0, 108, 110}, 01284 {0, 110, 111}, 01285 {0, 111, 112}, 01286 {0, 113, 109}, 01287 {0, 114, 106}, 01288 {0, 116, 103}, 01289 {0, 117, 101}, 01290 {0, 119, 98}, 01291 {0, 120, 95}, 01292 {0, 122, 93}, 01293 {0, 123, 90}, 01294 {0, 125, 87}, 01295 {0, 126, 85}, 01296 {0, 128, 82}, 01297 {0, 129, 79}, 01298 {0, 131, 77}, 01299 {0, 132, 74}, 01300 {0, 134, 71}, 01301 {0, 136, 69}, 01302 {0, 137, 66}, 01303 {0, 139, 63}, 01304 {0, 140, 61}, 01305 {0, 142, 58}, 01306 {0, 143, 55}, 01307 {0, 145, 53}, 01308 {0, 146, 50}, 01309 {0, 148, 47}, 01310 {0, 149, 45}, 01311 {0, 151, 42}, 01312 {0, 152, 39}, 01313 {0, 154, 37}, 01314 {0, 156, 34}, 01315 {0, 157, 31}, 01316 {0, 159, 29}, 01317 {0, 160, 26}, 01318 {0, 162, 23}, 01319 {0, 163, 21}, 01320 {0, 165, 18}, 01321 {0, 166, 15}, 01322 {0, 168, 13}, 01323 {0, 169, 10}, 01324 {0, 171, 7}, 01325 {0, 172, 5}, 01326 {0, 174, 2}, 01327 {0, 176, 0}, 01328 {5, 176, 0}, 01329 {9, 176, 0}, 01330 {13, 177, 0}, 01331 {17, 178, 0}, 01332 {22, 179, 0}, 01333 {26, 180, 0}, 01334 {30, 181, 0}, 01335 {35, 182, 0}, 01336 {39, 183, 0}, 01337 {43, 184, 0}, 01338 {48, 184, 0}, 01339 {52, 185, 0}, 01340 {56, 186, 0}, 01341 {61, 187, 0}, 01342 {65, 188, 0}, 01343 {69, 189, 0}, 01344 {74, 190, 0}, 01345 {78, 191, 0}, 01346 {82, 192, 0}, 01347 {87, 193, 0}, 01348 {91, 193, 0}, 01349 {95, 194, 0}, 01350 {100, 195, 0}, 01351 {104, 196, 0}, 01352 {108, 197, 0}, 01353 {112, 198, 0}, 01354 {117, 199, 0}, 01355 {121, 200, 0}, 01356 {125, 201, 0}, 01357 {130, 202, 0}, 01358 {134, 202, 0}, 01359 {138, 203, 0}, 01360 {143, 204, 0}, 01361 {147, 205, 0}, 01362 {151, 206, 0}, 01363 {156, 207, 0}, 01364 {160, 208, 0}, 01365 {164, 209, 0}, 01366 {169, 210, 0}, 01367 {173, 211, 0}, 01368 {177, 211, 0}, 01369 {182, 212, 0}, 01370 {186, 213, 0}, 01371 {190, 214, 0}, 01372 {195, 215, 0}, 01373 {199, 216, 0}, 01374 {203, 217, 0}, 01375 {208, 218, 0}, 01376 {212, 219, 0}, 01377 {216, 220, 0}, 01378 {221, 220, 0}, 01379 {221, 221, 0}, 01380 {221, 216, 0}, 01381 {221, 212, 0}, 01382 {222, 207, 0}, 01383 {222, 203, 0}, 01384 {222, 198, 0}, 01385 {223, 194, 0}, 01386 {223, 190, 0}, 01387 {224, 185, 0}, 01388 {224, 181, 0}, 01389 {224, 176, 0}, 01390 {225, 172, 0}, 01391 {225, 167, 0}, 01392 {225, 163, 0}, 01393 {226, 159, 0}, 01394 {226, 154, 0}, 01395 {227, 150, 0}, 01396 {227, 145, 0}, 01397 {227, 141, 0}, 01398 {228, 137, 0}, 01399 {228, 132, 0}, 01400 {228, 128, 0}, 01401 {229, 123, 0}, 01402 {229, 119, 0}, 01403 {230, 114, 0}, 01404 {230, 110, 0}, 01405 {230, 106, 0}, 01406 {231, 101, 0}, 01407 {231, 97, 0}, 01408 {232, 92, 0}, 01409 {232, 88, 0}, 01410 {232, 83, 0}, 01411 {233, 79, 0}, 01412 {233, 75, 0}, 01413 {233, 70, 0}, 01414 {234, 66, 0}, 01415 {234, 61, 0}, 01416 {235, 57, 0}, 01417 {235, 53, 0}, 01418 {235, 48, 0}, 01419 {236, 44, 0}, 01420 {236, 39, 0}, 01421 {236, 35, 0}, 01422 {237, 30, 0}, 01423 {237, 26, 0}, 01424 {238, 22, 0}, 01425 {238, 17, 0}, 01426 {238, 13, 0}, 01427 {239, 8, 0}, 01428 {239, 4, 0}, 01429 {240, 0, 0}, 01430 {240, 8, 8}, 01431 {240, 15, 15}, 01432 {240, 22, 22}, 01433 {240, 29, 29}, 01434 {240, 36, 36}, 01435 {240, 43, 43}, 01436 {240, 51, 51}, 01437 {240, 58, 58}, 01438 {240, 65, 65}, 01439 {240, 72, 72}, 01440 {240, 79, 79}, 01441 {240, 87, 87}, 01442 {240, 94, 94}, 01443 {240, 101, 101}, 01444 {240, 108, 108}, 01445 {240, 115, 115}, 01446 {240, 123, 123}, 01447 {240, 130, 130}, 01448 {240, 137, 137}, 01449 {240, 144, 144}, 01450 {240, 151, 151}, 01451 {240, 159, 159}, 01452 {240, 166, 166}, 01453 {240, 173, 173}, 01454 {240, 180, 180}, 01455 {240, 187, 187}, 01456 {240, 195, 195}, 01457 {240, 202, 202}, 01458 {240, 209, 209}, 01459 {240, 216, 216}, 01460 {240, 223, 223}, 01461 {240, 230, 230}, 01462 {143, 188, 143}, 01463 {255, 255, 255}, 01464 {0, 0, 255}, 01465 {255, 255, 0}, 01466 {255, 0, 0} 01467 01468 }; 01469 01470 int i; 01471 01472 PSIGNAL_RGB lut; 01473 01474 lut = (PSIGNAL_RGB) IdSigAlloc(256, SIG_RGB); 01475 01476 if (!(lut)) { 01477 IdErrPrintf("Erreur d'allocation de memoire palette\n"); 01478 return 0; 01479 } 01480 01481 for (i = 0; i < 255; i++) { 01482 lut[i].r = tabAnalyseRet[i].r; 01483 lut[i].g = tabAnalyseRet[i].g; 01484 lut[i].b = tabAnalyseRet[i].b; 01485 } 01486 01487 01488 return lut; 01489 } 01490 01491 01492 /* FUNCTION DESCRIPTION ************************************************** 01493 * 01494 * IdPalReadAsciiFile (fonction) 01495 * 01496 * RESUME: Lit un fichier Ascii Palette { i, r, g, b} 01497 * 01498 * DESCRIPTION: Lit un fichier Ascii Palette { i, r, g, b}. 01499 * le 'i' indique a quelle 'valeur de pixel' va correspondre 01500 * la 'fausse couleur' decrite par r, g, b. 01501 * Les 'valeurs de pixel' superieures a 255 sont ignorees. 01502 * Aucun controle n'est effectue quant a la duplication 01503 * des 'valeurs pixel' (c'est la derniere qui sera retenue) 01504 * ni quant a la presence de valeurs absentes. 01505 * Les eventuelles 'valeurs de pixel' absentes de la liste 01506 * des 'fausses couleurs' fournies sont laissees a leur 01507 * valeur de gris nominale. 01508 * Le SIGNAL retourne a une longueur egale a la 01509 * 'valeur de pixel' maximum fournie dans la liste des 01510 * 'fausses couleurs'. 01511 * 01512 * SYNTAXE: PSIGNAL_RGB palette = IdPalReadAsciiFile(char * nomFich); 01513 * 01514 * RETOUR: type : PSIGNAL_RGB 01515 * 01516 * PARAMETRES: 01517 * nom : nomFich 01518 * type : char * 01519 * acces : I 01520 * role : nom du fichier ... 01521 * 01522 * FICHIER: idpalett.c 01523 * 01524 * EXEMPLE: 01525 * 01526 * ******************************************************** END DESCRIPTION */ 01527 01528 PSIGNAL_RGB IdPalReadAsciiFile(char *nfpal) 01529 { 01530 FILE *fpal; 01531 PSIGNAL_RGB pal; 01532 int i, imax = 0; 01533 int r, g, b; 01534 01535 if (nfpal == NULL) { 01536 IdErrno = IDERR_EMPTY_FILE_NAME; 01537 return (PSIGNAL_RGB) NULL; 01538 } 01539 01540 fpal = fopen(nfpal, ID_RFILE_TEXT); 01541 01542 if (fpal) { 01543 pal = (PSIGNAL_RGB) IdSigAlloc(256, SIG_RGB); 01544 if (!pal) 01545 IdErrPrintf(" echec Alloc Palette\n"); 01546 else { 01547 for (i = 0; i < 255; i++) { 01548 pal[i].r = i; 01549 pal[i].g = i; 01550 pal[i].b = i; 01551 } 01552 01553 while (EOF != 01554 fscanf(fpal, "%d %d %d %d", &i, &r, &g, &b)) { 01555 if (i > 255) 01556 continue; 01557 if (i > imax) 01558 imax = i; 01559 pal[i].r = r; 01560 pal[i].g = g; 01561 pal[i].b = b; 01562 } 01563 if (imax < 255) 01564 pal = 01565 (PSIGNAL_RGB) IdSigModifLongueur(pal, 01566 imax); 01567 } 01568 } else { 01569 IdErrPrintf(" echec Ouverture Fichier Palette\n"); 01570 IdErrno = IDERR_OPEN_FAILED; 01571 return (PSIGNAL_RGB) NULL; 01572 } 01573 return (pal); 01574 } 01575 01576 /* FUNCTION DESCRIPTION ************************************************** 01577 * 01578 * IdPalWriteAsciiFile (fonction) 01579 * 01580 * RESUME: Ecrit un fichier Ascii Palette {i, r, g, b} 01581 * 01582 * DESCRIPTION: Ecrit un fichier Ascii Palette {i, r, g, b}. 01583 * 01584 * SYNTAXE: int retCode = IdPalWriteAsciiFile(char * nomFich, PSIGNAL_RGB pal); 01585 * RETOUR: type : int 01586 * role : code de retour booleen. 01587 * 01588 * 01589 * PARAMETRES: 01590 * nom : nomFich 01591 * type : char * 01592 * role : nom du fichier ds lequel on ecrit 01593 * 01594 * nom : pal 01595 * type : PSIGNAL_RGB 01596 * role : palette 01597 * 01598 * FICHIER: idpalett.c 01599 * 01600 * EXEMPLE: 01601 * 01602 * ******************************************************** END DESCRIPTION */ 01603 01604 int IdPalWriteAsciiFile(char *nfpal, PSIGNAL_RGB pal) 01605 { 01606 FILE *fp; 01607 int i, r, g, b; 01608 01609 if (nfpal == NULL) { 01610 IdErrno = IDERR_EMPTY_FILE_NAME; 01611 return 0; 01612 } 01613 01614 if (pal == NULL) { 01615 IdErrno = IDERR_POINTER_IS_NULL; 01616 return 0; 01617 } 01618 fp = fopen(nfpal, ID_WFILE_TEXT); 01619 if (!fp) { 01620 IdErrno = IDERR_OPEN_FAILED; 01621 return (0); 01622 } 01623 01624 for (i = 0; i < IdSigDimX(pal); i++) { 01625 r = pal[i].r; 01626 g = pal[i].g; 01627 b = pal[i].b; 01628 fprintf(fp, "%d %d %d %d\n", i, r, g, b); 01629 } 01630 return (1); 01631 }

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