/src/FreeImage/Source/FreeImage/ConversionType.cpp
C++ | 689 lines | 558 code | 60 blank | 71 comment | 35 complexity | 37ae57f05b425f4652e87bbfb4e35b38 MD5 | raw file
1// ========================================================== 2// Bitmap conversion routines 3// 4// Design and implementation by 5// - Hervé Drolon (drolon@infonie.fr) 6// 7// This file is part of FreeImage 3 8// 9// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY 10// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES 11// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE 12// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED 13// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT 14// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY 15// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL 16// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER 17// THIS DISCLAIMER. 18// 19// Use at your own risk! 20// ========================================================== 21 22#include "FreeImage.h" 23#include "Utilities.h" 24 25// ---------------------------------------------------------- 26 27/** Convert a greyscale image of type Tsrc to type Tdst. 28 Conversion is done using standard C language casting convention. 29*/ 30template<class Tdst, class Tsrc> 31class CONVERT_TYPE 32{ 33public: 34 FIBITMAP* convert(FIBITMAP *src, FREE_IMAGE_TYPE dst_type); 35}; 36 37template<class Tdst, class Tsrc> FIBITMAP* 38CONVERT_TYPE<Tdst, Tsrc>::convert(FIBITMAP *src, FREE_IMAGE_TYPE dst_type) { 39 40 FIBITMAP *dst = NULL; 41 42 unsigned width = FreeImage_GetWidth(src); 43 unsigned height = FreeImage_GetHeight(src); 44 unsigned bpp = FreeImage_GetBPP(src); 45 46 // allocate dst image 47 48 dst = FreeImage_AllocateT(dst_type, width, height, bpp, 49 FreeImage_GetRedMask(src), FreeImage_GetGreenMask(src), FreeImage_GetBlueMask(src)); 50 if(!dst) return NULL; 51 52 // convert from src_type to dst_type 53 54 for(unsigned y = 0; y < height; y++) { 55 const Tsrc *src_bits = reinterpret_cast<Tsrc*>(FreeImage_GetScanLine(src, y)); 56 Tdst *dst_bits = reinterpret_cast<Tdst*>(FreeImage_GetScanLine(dst, y)); 57 58 for(unsigned x = 0; x < width; x++) { 59 *dst_bits++ = static_cast<Tdst>(*src_bits++); 60 } 61 } 62 63 return dst; 64} 65 66 67/** Convert a greyscale image of type Tsrc to a 8-bit grayscale dib. 68 Conversion is done using either a linear scaling from [min, max] to [0, 255] 69 or a rounding from src_pixel to (BYTE) MIN(255, MAX(0, q)) where int q = int(src_pixel + 0.5); 70*/ 71template<class Tsrc> 72class CONVERT_TO_BYTE 73{ 74public: 75 FIBITMAP* convert(FIBITMAP *src, BOOL scale_linear); 76}; 77 78template<class Tsrc> FIBITMAP* 79CONVERT_TO_BYTE<Tsrc>::convert(FIBITMAP *src, BOOL scale_linear) { 80 FIBITMAP *dst = NULL; 81 unsigned x, y; 82 83 unsigned width = FreeImage_GetWidth(src); 84 unsigned height = FreeImage_GetHeight(src); 85 86 // allocate a 8-bit dib 87 88 dst = FreeImage_AllocateT(FIT_BITMAP, width, height, 8, 0, 0, 0); 89 if(!dst) return NULL; 90 91 // build a greyscale palette 92 RGBQUAD *pal = FreeImage_GetPalette(dst); 93 for(int i = 0; i < 256; i++) { 94 pal[i].rgbRed = (BYTE)i; 95 pal[i].rgbGreen = (BYTE)i; 96 pal[i].rgbBlue = (BYTE)i; 97 } 98 99 // convert the src image to dst 100 // (FIBITMAP are stored upside down) 101 if(scale_linear) { 102 Tsrc max, min; 103 double scale; 104 105 // find the min and max value of the image 106 Tsrc l_min, l_max; 107 min = 255, max = 0; 108 for(y = 0; y < height; y++) { 109 Tsrc *bits = reinterpret_cast<Tsrc*>(FreeImage_GetScanLine(src, y)); 110 MAXMIN(bits, width, l_max, l_min); 111 if(l_max > max) max = l_max; 112 if(l_min < min) min = l_min; 113 } 114 if(max == min) { 115 max = 255; min = 0; 116 } 117 118 // compute the scaling factor 119 scale = 255 / (double)(max - min); 120 121 // scale to 8-bit 122 for(y = 0; y < height; y++) { 123 Tsrc *src_bits = reinterpret_cast<Tsrc*>(FreeImage_GetScanLine(src, y)); 124 BYTE *dst_bits = FreeImage_GetScanLine(dst, y); 125 for(x = 0; x < width; x++) { 126 dst_bits[x] = (BYTE)( scale * (src_bits[x] - min) + 0.5); 127 } 128 } 129 } else { 130 for(y = 0; y < height; y++) { 131 Tsrc *src_bits = reinterpret_cast<Tsrc*>(FreeImage_GetScanLine(src, y)); 132 BYTE *dst_bits = FreeImage_GetScanLine(dst, y); 133 for(x = 0; x < width; x++) { 134 // rounding 135 int q = int(src_bits[x] + 0.5); 136 dst_bits[x] = (BYTE) MIN(255, MAX(0, q)); 137 } 138 } 139 } 140 141 return dst; 142} 143 144/** Convert a greyscale image of type Tsrc to a FICOMPLEX dib. 145*/ 146template<class Tsrc> 147class CONVERT_TO_COMPLEX 148{ 149public: 150 FIBITMAP* convert(FIBITMAP *src); 151}; 152 153template<class Tsrc> FIBITMAP* 154CONVERT_TO_COMPLEX<Tsrc>::convert(FIBITMAP *src) { 155 FIBITMAP *dst = NULL; 156 157 unsigned width = FreeImage_GetWidth(src); 158 unsigned height = FreeImage_GetHeight(src); 159 160 // allocate dst image 161 162 dst = FreeImage_AllocateT(FIT_COMPLEX, width, height); 163 if(!dst) return NULL; 164 165 // convert from src_type to FIT_COMPLEX 166 167 for(unsigned y = 0; y < height; y++) { 168 const Tsrc *src_bits = reinterpret_cast<Tsrc*>(FreeImage_GetScanLine(src, y)); 169 FICOMPLEX *dst_bits = (FICOMPLEX *)FreeImage_GetScanLine(dst, y); 170 171 for(unsigned x = 0; x < width; x++) { 172 dst_bits[x].r = (double)src_bits[x]; 173 dst_bits[x].i = 0; 174 } 175 } 176 177 return dst; 178} 179 180// ---------------------------------------------------------- 181 182// Convert from type BYTE to type X 183CONVERT_TYPE<unsigned short, BYTE> convertByteToUShort; 184CONVERT_TYPE<short, BYTE> convertByteToShort; 185CONVERT_TYPE<DWORD, BYTE> convertByteToULong; 186CONVERT_TYPE<LONG, BYTE> convertByteToLong; 187CONVERT_TYPE<float, BYTE> convertByteToFloat; 188CONVERT_TYPE<double, BYTE> convertByteToDouble; 189 190// Convert from type X to type BYTE 191CONVERT_TO_BYTE<unsigned short> convertUShortToByte; 192CONVERT_TO_BYTE<short> convertShortToByte; 193CONVERT_TO_BYTE<DWORD> convertULongToByte; 194CONVERT_TO_BYTE<LONG> convertLongToByte; 195CONVERT_TO_BYTE<float> convertFloatToByte; 196CONVERT_TO_BYTE<double> convertDoubleToByte; 197 198// Convert from type X to type float 199CONVERT_TYPE<float, unsigned short> convertUShortToFloat; 200CONVERT_TYPE<float, short> convertShortToFloat; 201CONVERT_TYPE<float, DWORD> convertULongToFloat; 202CONVERT_TYPE<float, LONG> convertLongToFloat; 203 204// Convert from type X to type double 205CONVERT_TYPE<double, unsigned short> convertUShortToDouble; 206CONVERT_TYPE<double, short> convertShortToDouble; 207CONVERT_TYPE<double, DWORD> convertULongToDouble; 208CONVERT_TYPE<double, LONG> convertLongToDouble; 209CONVERT_TYPE<double, float> convertFloatToDouble; 210 211// Convert from type X to type FICOMPLEX 212CONVERT_TO_COMPLEX<BYTE> convertByteToComplex; 213CONVERT_TO_COMPLEX<unsigned short> convertUShortToComplex; 214CONVERT_TO_COMPLEX<short> convertShortToComplex; 215CONVERT_TO_COMPLEX<DWORD> convertULongToComplex; 216CONVERT_TO_COMPLEX<LONG> convertLongToComplex; 217CONVERT_TO_COMPLEX<float> convertFloatToComplex; 218CONVERT_TO_COMPLEX<double> convertDoubleToComplex; 219 220// ---------------------------------------------------------- 221 222// ---------------------------------------------------------- 223// smart convert X to standard FIBITMAP 224// ---------------------------------------------------------- 225 226/** Convert image of any type to a standard 8-bit greyscale image. 227For standard images, a clone of the input image is returned. 228When the scale_linear parameter is TRUE, conversion is done by scaling linearly 229each pixel to an integer value between [0..255]. When it is FALSE, conversion is done 230by rounding each float pixel to an integer between [0..255]. 231For complex images, the magnitude is extracted as a double image, then converted according to the scale parameter. 232@param image Image to convert 233@param scale_linear Linear scaling / rounding switch 234*/ 235FIBITMAP* DLL_CALLCONV 236FreeImage_ConvertToStandardType(FIBITMAP *src, BOOL scale_linear) { 237 FIBITMAP *dst = NULL; 238 239 if(!src) return NULL; 240 241 // convert from src_type to FIT_BITMAP 242 243 const FREE_IMAGE_TYPE src_type = FreeImage_GetImageType(src); 244 245 switch(src_type) { 246 case FIT_BITMAP: // standard image: 1-, 4-, 8-, 16-, 24-, 32-bit 247 dst = FreeImage_Clone(src); 248 break; 249 case FIT_UINT16: // array of unsigned short: unsigned 16-bit 250 dst = convertUShortToByte.convert(src, scale_linear); 251 break; 252 case FIT_INT16: // array of short: signed 16-bit 253 dst = convertShortToByte.convert(src, scale_linear); 254 break; 255 case FIT_UINT32: // array of unsigned long: unsigned 32-bit 256 dst = convertULongToByte.convert(src, scale_linear); 257 break; 258 case FIT_INT32: // array of long: signed 32-bit 259 dst = convertLongToByte.convert(src, scale_linear); 260 break; 261 case FIT_FLOAT: // array of float: 32-bit 262 dst = convertFloatToByte.convert(src, scale_linear); 263 break; 264 case FIT_DOUBLE: // array of double: 64-bit 265 dst = convertDoubleToByte.convert(src, scale_linear); 266 break; 267 case FIT_COMPLEX: // array of FICOMPLEX: 2 x 64-bit 268 { 269 // Convert to type FIT_DOUBLE 270 FIBITMAP *dib_double = FreeImage_GetComplexChannel(src, FICC_MAG); 271 if(dib_double) { 272 // Convert to a standard bitmap (linear scaling) 273 dst = convertDoubleToByte.convert(dib_double, scale_linear); 274 // Free image of type FIT_DOUBLE 275 FreeImage_Unload(dib_double); 276 } 277 } 278 break; 279 case FIT_RGB16: // 48-bit RGB image: 3 x 16-bit 280 break; 281 case FIT_RGBA16: // 64-bit RGBA image: 4 x 16-bit 282 break; 283 case FIT_RGBF: // 96-bit RGB float image: 3 x 32-bit IEEE floating point 284 break; 285 case FIT_RGBAF: // 128-bit RGBA float image: 4 x 32-bit IEEE floating point 286 break; 287 } 288 289 if(NULL == dst) { 290 FreeImage_OutputMessageProc(FIF_UNKNOWN, "FREE_IMAGE_TYPE: Unable to convert from type %d to type %d.\n No such conversion exists.", src_type, FIT_BITMAP); 291 } else { 292 // copy metadata from src to dst 293 FreeImage_CloneMetadata(dst, src); 294 } 295 296 return dst; 297} 298 299 300 301// ---------------------------------------------------------- 302// smart convert X to Y 303// ---------------------------------------------------------- 304 305FIBITMAP* DLL_CALLCONV 306FreeImage_ConvertToType(FIBITMAP *src, FREE_IMAGE_TYPE dst_type, BOOL scale_linear) { 307 FIBITMAP *dst = NULL; 308 309 if(!FreeImage_HasPixels(src)) return NULL; 310 311 // convert from src_type to dst_type 312 313 const FREE_IMAGE_TYPE src_type = FreeImage_GetImageType(src); 314 315 if(src_type == dst_type) { 316 return FreeImage_Clone(src); 317 } 318 319 const unsigned src_bpp = FreeImage_GetBPP(src); 320 321 switch(src_type) { 322 case FIT_BITMAP: 323 switch(dst_type) { 324 case FIT_UINT16: 325 dst = FreeImage_ConvertToUINT16(src); 326 break; 327 case FIT_INT16: 328 dst = (src_bpp == 8) ? convertByteToShort.convert(src, dst_type) : NULL; 329 break; 330 case FIT_UINT32: 331 dst = (src_bpp == 8) ? convertByteToULong.convert(src, dst_type) : NULL; 332 break; 333 case FIT_INT32: 334 dst = (src_bpp == 8) ? convertByteToLong.convert(src, dst_type) : NULL; 335 break; 336 case FIT_FLOAT: 337 dst = FreeImage_ConvertToFloat(src); 338 break; 339 case FIT_DOUBLE: 340 dst = (src_bpp == 8) ? convertByteToDouble.convert(src, dst_type) : NULL; 341 break; 342 case FIT_COMPLEX: 343 dst = (src_bpp == 8) ? convertByteToComplex.convert(src) : NULL; 344 break; 345 case FIT_RGB16: 346 dst = FreeImage_ConvertToRGB16(src); 347 break; 348 case FIT_RGBA16: 349 break; 350 case FIT_RGBF: 351 dst = FreeImage_ConvertToRGBF(src); 352 break; 353 case FIT_RGBAF: 354 break; 355 } 356 break; 357 case FIT_UINT16: 358 switch(dst_type) { 359 case FIT_BITMAP: 360 dst = FreeImage_ConvertToStandardType(src, scale_linear); 361 break; 362 case FIT_INT16: 363 break; 364 case FIT_UINT32: 365 break; 366 case FIT_INT32: 367 break; 368 case FIT_FLOAT: 369 dst = FreeImage_ConvertToFloat(src); 370 break; 371 case FIT_DOUBLE: 372 dst = convertUShortToDouble.convert(src, dst_type); 373 break; 374 case FIT_COMPLEX: 375 dst = convertUShortToComplex.convert(src); 376 break; 377 case FIT_RGB16: 378 dst = FreeImage_ConvertToRGB16(src); 379 break; 380 case FIT_RGBA16: 381 break; 382 case FIT_RGBF: 383 dst = FreeImage_ConvertToRGBF(src); 384 break; 385 case FIT_RGBAF: 386 break; 387 } 388 break; 389 case FIT_INT16: 390 switch(dst_type) { 391 case FIT_BITMAP: 392 dst = FreeImage_ConvertToStandardType(src, scale_linear); 393 break; 394 case FIT_UINT16: 395 break; 396 case FIT_UINT32: 397 break; 398 case FIT_INT32: 399 break; 400 case FIT_FLOAT: 401 dst = convertShortToFloat.convert(src, dst_type); 402 break; 403 case FIT_DOUBLE: 404 dst = convertShortToDouble.convert(src, dst_type); 405 break; 406 case FIT_COMPLEX: 407 dst = convertShortToComplex.convert(src); 408 break; 409 case FIT_RGB16: 410 break; 411 case FIT_RGBA16: 412 break; 413 case FIT_RGBF: 414 break; 415 case FIT_RGBAF: 416 break; 417 } 418 break; 419 case FIT_UINT32: 420 switch(dst_type) { 421 case FIT_BITMAP: 422 dst = FreeImage_ConvertToStandardType(src, scale_linear); 423 break; 424 case FIT_UINT16: 425 break; 426 case FIT_INT16: 427 break; 428 case FIT_INT32: 429 break; 430 case FIT_FLOAT: 431 dst = convertULongToFloat.convert(src, dst_type); 432 break; 433 case FIT_DOUBLE: 434 dst = convertULongToDouble.convert(src, dst_type); 435 break; 436 case FIT_COMPLEX: 437 dst = convertULongToComplex.convert(src); 438 break; 439 case FIT_RGB16: 440 break; 441 case FIT_RGBA16: 442 break; 443 case FIT_RGBF: 444 break; 445 case FIT_RGBAF: 446 break; 447 } 448 break; 449 case FIT_INT32: 450 switch(dst_type) { 451 case FIT_BITMAP: 452 dst = FreeImage_ConvertToStandardType(src, scale_linear); 453 break; 454 case FIT_UINT16: 455 break; 456 case FIT_INT16: 457 break; 458 case FIT_UINT32: 459 break; 460 case FIT_FLOAT: 461 dst = convertLongToFloat.convert(src, dst_type); 462 break; 463 case FIT_DOUBLE: 464 dst = convertLongToDouble.convert(src, dst_type); 465 break; 466 case FIT_COMPLEX: 467 dst = convertLongToComplex.convert(src); 468 break; 469 case FIT_RGB16: 470 break; 471 case FIT_RGBA16: 472 break; 473 case FIT_RGBF: 474 break; 475 case FIT_RGBAF: 476 break; 477 } 478 break; 479 case FIT_FLOAT: 480 switch(dst_type) { 481 case FIT_BITMAP: 482 dst = FreeImage_ConvertToStandardType(src, scale_linear); 483 break; 484 case FIT_UINT16: 485 break; 486 case FIT_INT16: 487 break; 488 case FIT_UINT32: 489 break; 490 case FIT_INT32: 491 break; 492 case FIT_DOUBLE: 493 dst = convertFloatToDouble.convert(src, dst_type); 494 break; 495 case FIT_COMPLEX: 496 dst = convertFloatToComplex.convert(src); 497 break; 498 case FIT_RGB16: 499 break; 500 case FIT_RGBA16: 501 break; 502 case FIT_RGBF: 503 dst = FreeImage_ConvertToRGBF(src); 504 break; 505 case FIT_RGBAF: 506 break; 507 } 508 break; 509 case FIT_DOUBLE: 510 switch(dst_type) { 511 case FIT_BITMAP: 512 dst = FreeImage_ConvertToStandardType(src, scale_linear); 513 break; 514 case FIT_UINT16: 515 break; 516 case FIT_INT16: 517 break; 518 case FIT_UINT32: 519 break; 520 case FIT_INT32: 521 break; 522 case FIT_FLOAT: 523 break; 524 case FIT_COMPLEX: 525 dst = convertDoubleToComplex.convert(src); 526 break; 527 case FIT_RGB16: 528 break; 529 case FIT_RGBA16: 530 break; 531 case FIT_RGBF: 532 break; 533 case FIT_RGBAF: 534 break; 535 } 536 break; 537 case FIT_COMPLEX: 538 switch(dst_type) { 539 case FIT_BITMAP: 540 break; 541 case FIT_UINT16: 542 break; 543 case FIT_INT16: 544 break; 545 case FIT_UINT32: 546 break; 547 case FIT_INT32: 548 break; 549 case FIT_FLOAT: 550 break; 551 case FIT_DOUBLE: 552 break; 553 case FIT_RGB16: 554 break; 555 case FIT_RGBA16: 556 break; 557 case FIT_RGBF: 558 break; 559 case FIT_RGBAF: 560 break; 561 } 562 break; 563 case FIT_RGB16: 564 switch(dst_type) { 565 case FIT_BITMAP: 566 dst = FreeImage_ConvertTo24Bits(src); 567 break; 568 case FIT_UINT16: 569 dst = FreeImage_ConvertToUINT16(src); 570 break; 571 case FIT_INT16: 572 break; 573 case FIT_UINT32: 574 break; 575 case FIT_INT32: 576 break; 577 case FIT_FLOAT: 578 dst = FreeImage_ConvertToFloat(src); 579 break; 580 case FIT_DOUBLE: 581 break; 582 case FIT_COMPLEX: 583 break; 584 case FIT_RGBA16: 585 break; 586 case FIT_RGBF: 587 dst = FreeImage_ConvertToRGBF(src); 588 break; 589 case FIT_RGBAF: 590 break; 591 } 592 break; 593 case FIT_RGBA16: 594 switch(dst_type) { 595 case FIT_BITMAP: 596 dst = FreeImage_ConvertTo32Bits(src); 597 break; 598 case FIT_UINT16: 599 dst = FreeImage_ConvertToUINT16(src); 600 break; 601 case FIT_INT16: 602 break; 603 case FIT_UINT32: 604 break; 605 case FIT_INT32: 606 break; 607 case FIT_FLOAT: 608 dst = FreeImage_ConvertToFloat(src); 609 break; 610 case FIT_DOUBLE: 611 break; 612 case FIT_COMPLEX: 613 break; 614 case FIT_RGB16: 615 dst = FreeImage_ConvertToRGB16(src); 616 break; 617 case FIT_RGBF: 618 dst = FreeImage_ConvertToRGBF(src); 619 break; 620 case FIT_RGBAF: 621 break; 622 } 623 break; 624 case FIT_RGBF: 625 switch(dst_type) { 626 case FIT_BITMAP: 627 break; 628 case FIT_UINT16: 629 break; 630 case FIT_INT16: 631 break; 632 case FIT_UINT32: 633 break; 634 case FIT_INT32: 635 break; 636 case FIT_FLOAT: 637 dst = FreeImage_ConvertToFloat(src); 638 break; 639 case FIT_DOUBLE: 640 break; 641 case FIT_COMPLEX: 642 break; 643 case FIT_RGB16: 644 break; 645 case FIT_RGBA16: 646 break; 647 case FIT_RGBAF: 648 break; 649 } 650 break; 651 case FIT_RGBAF: 652 switch(dst_type) { 653 case FIT_BITMAP: 654 break; 655 case FIT_UINT16: 656 break; 657 case FIT_INT16: 658 break; 659 case FIT_UINT32: 660 break; 661 case FIT_INT32: 662 break; 663 case FIT_FLOAT: 664 dst = FreeImage_ConvertToFloat(src); 665 break; 666 case FIT_DOUBLE: 667 break; 668 case FIT_COMPLEX: 669 break; 670 case FIT_RGB16: 671 break; 672 case FIT_RGBA16: 673 break; 674 case FIT_RGBF: 675 dst = FreeImage_ConvertToRGBF(src); 676 break; 677 } 678 break; 679 } 680 681 if(NULL == dst) { 682 FreeImage_OutputMessageProc(FIF_UNKNOWN, "FREE_IMAGE_TYPE: Unable to convert from type %d to type %d.\n No such conversion exists.", src_type, dst_type); 683 } else { 684 // copy metadata from src to dst 685 FreeImage_CloneMetadata(dst, src); 686 } 687 688 return dst; 689}