src/gdcmPixelReadConvert.cxx

   1 /*=========================================================================
   2
   3   Program:   gdcm
   4   Module:    $RCSfile: gdcmPixelReadConvert.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2005/05/21 18:43:53 $
   7   Version:   $Revision: 1.56 $
   8
   9   Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
  10   l'Image). All rights reserved. See Doc/License.txt or
  11   http://www.creatis.insa-lyon.fr/Public/Gdcm/License.html for details.
  12
  13      This software is distributed WITHOUT ANY WARRANTY; without even
  14      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15      PURPOSE.  See the above copyright notices for more information.
  16
  17 =========================================================================*/
  18
  19 #include "gdcmDebug.h"
  20 #include "gdcmFile.h"
  21 #include "gdcmGlobal.h"
  22 #include "gdcmTS.h"
  23 #include "gdcmPixelReadConvert.h"
  24 #include "gdcmDocEntry.h"
  25 #include "gdcmRLEFramesInfo.h"
  26 #include "gdcmJPEGFragmentsInfo.h"
  27
  28 #include <fstream>
  29 #include <stdio.h> //for sscanf
  30
  31 namespace gdcm
  32 {
  33
  34 extern bool ReadMPEGFile (std::ifstream *fp, void *image_buffer);
  35 //-----------------------------------------------------------------------------
  36 #define str2num(str, typeNum) *((typeNum *)(str))
  37
  38 //-----------------------------------------------------------------------------
  39 // Constructor / Destructor
  40 /// Constructor
  41 PixelReadConvert::PixelReadConvert()
  42 {
  43    RGB          = 0;
  44    RGBSize      = 0;
  45    Raw          = 0;
  46    RawSize      = 0;
  47    LutRGBA      = 0;
  48    LutRedData   = 0;
  49    LutGreenData = 0;
  50    LutBlueData  = 0;
  51 }
  52
  53 /// Canonical Destructor
  54 PixelReadConvert::~PixelReadConvert()
  55 {
  56    Squeeze();
  57 }
  58
  59 //-----------------------------------------------------------------------------
  60 // Public
  61 /**
  62  * \brief Predicate to know whether the image[s] (once Raw) is RGB.
  63  * \note See comments of \ref ConvertHandleColor
  64  */
  65 bool PixelReadConvert::IsRawRGB()
  66 {
  67    if (   IsMonochrome
  68        || PlanarConfiguration == 2
  69        || IsPaletteColor )
  70    {
  71       return false;
  72    }
  73    return true;
  74 }
  75 /**
  76  * \brief Gets various usefull informations from the file header
  77  * @param file gdcm::File pointer
  78  */
  79 void PixelReadConvert::GrabInformationsFromFile( File *file )
  80 {
  81    // Number of Bits Allocated for storing a Pixel is defaulted to 16
  82    // when absent from the file.
  83    BitsAllocated = file->GetBitsAllocated();
  84    if ( BitsAllocated == 0 )
  85    {
  86       BitsAllocated = 16;
  87    }
  88
  89    // Number of "Bits Stored", defaulted to number of "Bits Allocated"
  90    // when absent from the file.
  91    BitsStored = file->GetBitsStored();
  92    if ( BitsStored == 0 )
  93    {
  94       BitsStored = BitsAllocated;
  95    }
  96
  97    // High Bit Position, defaulted to "Bits Allocated" - 1
  98    HighBitPosition = file->GetHighBitPosition();
  99    if ( HighBitPosition == 0 )
 100    {
 101       HighBitPosition = BitsAllocated - 1;
 102    }
 103
 104    XSize           = file->GetXSize();
 105    YSize           = file->GetYSize();
 106    ZSize           = file->GetZSize();
 107    SamplesPerPixel = file->GetSamplesPerPixel();
 108    PixelSize       = file->GetPixelSize();
 109    PixelSign       = file->IsSignedPixelData();
 110    SwapCode        = file->GetSwapCode();
 111    std::string ts  = file->GetTransferSyntax();
 112    IsRaw =
 113         ( ! file->IsDicomV3() )
 114      || Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ImplicitVRLittleEndian
 115      || Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ImplicitVRLittleEndianDLXGE
 116      || Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ExplicitVRLittleEndian
 117      || Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ExplicitVRBigEndian
 118      || Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::DeflatedExplicitVRLittleEndian;
 119
 120    IsMPEG          = Global::GetTS()->IsMPEG(ts);
 121    IsJPEG2000      = Global::GetTS()->IsJPEG2000(ts);
 122    IsJPEGLS        = Global::GetTS()->IsJPEGLS(ts);
 123    IsJPEGLossy     = Global::GetTS()->IsJPEGLossy(ts);
 124    IsJPEGLossless  = Global::GetTS()->IsJPEGLossless(ts);
 125    IsRLELossless   = Global::GetTS()->IsRLELossless(ts);
 126
 127    PixelOffset     = file->GetPixelOffset();
 128    PixelDataLength = file->GetPixelAreaLength();
 129    RLEInfo         = file->GetRLEInfo();
 130    JPEGInfo        = file->GetJPEGInfo();
 131
 132    IsMonochrome    = file->IsMonochrome();
 133    IsMonochrome1   = file->IsMonochrome1();
 134    IsPaletteColor  = file->IsPaletteColor();
 135    IsYBRFull       = file->IsYBRFull();
 136
 137    PlanarConfiguration = file->GetPlanarConfiguration();
 138
 139    /////////////////////////////////////////////////////////////////
 140    // LUT section:
 141    HasLUT = file->HasLUT();
 142    if ( HasLUT )
 143    {
 144       // Just in case some access to a File element requires disk access.
 145       LutRedDescriptor   = file->GetEntryValue( 0x0028, 0x1101 );
 146       LutGreenDescriptor = file->GetEntryValue( 0x0028, 0x1102 );
 147       LutBlueDescriptor  = file->GetEntryValue( 0x0028, 0x1103 );
 148
 149       // Depending on the value of Document::MAX_SIZE_LOAD_ELEMENT_VALUE
 150       // [ refer to invocation of Document::SetMaxSizeLoadEntry() in
 151       // Document::Document() ], the loading of the value (content) of a
 152       // [Bin|Val]Entry occurence migth have been hindered (read simply NOT
 153       // loaded). Hence, we first try to obtain the LUTs data from the file
 154       // and when this fails we read the LUTs data directly from disk.
 155       // \TODO Reading a [Bin|Val]Entry directly from disk is a kludge.
 156       //       We should NOT bypass the [Bin|Val]Entry class. Instead
 157       //       an access to an UNLOADED content of a [Bin|Val]Entry occurence
 158       //       (e.g. BinEntry::GetBinArea()) should force disk access from
 159       //       within the [Bin|Val]Entry class itself. The only problem
 160       //       is that the [Bin|Val]Entry is unaware of the FILE* is was
 161       //       parsed from. Fix that. FIXME.
 162
 163       // //// Red round
 164       file->LoadEntryBinArea(0x0028, 0x1201);
 165       LutRedData = (uint8_t*)file->GetEntryBinArea( 0x0028, 0x1201 );
 166       if ( ! LutRedData )
 167       {
 168          gdcmWarningMacro( "Unable to read Red LUT data" );
 169       }
 170
 171       // //// Green round:
 172       file->LoadEntryBinArea(0x0028, 0x1202);
 173       LutGreenData = (uint8_t*)file->GetEntryBinArea(0x0028, 0x1202 );
 174       if ( ! LutGreenData)
 175       {
 176          gdcmWarningMacro( "Unable to read Green LUT data" );
 177       }
 178
 179       // //// Blue round:
 180       file->LoadEntryBinArea(0x0028, 0x1203);
 181       LutBlueData = (uint8_t*)file->GetEntryBinArea( 0x0028, 0x1203 );
 182       if ( ! LutBlueData )
 183       {
 184          gdcmWarningMacro( "Unable to read Blue LUT data" );
 185       }
 186    }
 187
 188    ComputeRawAndRGBSizes();
 189 }
 190
 191 /// \brief Reads from disk and decompresses Pixels
 192 bool PixelReadConvert::ReadAndDecompressPixelData( std::ifstream *fp )
 193 {
 194    // ComputeRawAndRGBSizes is already made by
 195    // ::GrabInformationsFromfile. So, the structure sizes are
 196    // correct
 197    Squeeze();
 198
 199    //////////////////////////////////////////////////
 200    //// First stage: get our hands on the Pixel Data.
 201    if ( !fp )
 202    {
 203       gdcmWarningMacro( "Unavailable file pointer." );
 204       return false;
 205    }
 206
 207    fp->seekg( PixelOffset, std::ios::beg );
 208    if( fp->fail() || fp->eof())
 209    {
 210       gdcmWarningMacro( "Unable to find PixelOffset in file." );
 211       return false;
 212    }
 213
 214    AllocateRaw();
 215
 216    //////////////////////////////////////////////////
 217    //// Second stage: read from disk dans decompress.
 218    if ( BitsAllocated == 12 )
 219    {
 220       ReadAndDecompress12BitsTo16Bits( fp);
 221    }
 222    else if ( IsRaw )
 223    {
 224       // This problem can be found when some obvious informations are found
 225       // after the field containing the image data. In this case, these
 226       // bad data are added to the size of the image (in the PixelDataLength
 227       // variable). But RawSize is the right size of the image !
 228       if( PixelDataLength != RawSize)
 229       {
 230          gdcmWarningMacro( "Mismatch between PixelReadConvert : "
 231                             << PixelDataLength << " and RawSize : " << RawSize );
 232       }
 233       if( PixelDataLength > RawSize)
 234       {
 235          fp->read( (char*)Raw, RawSize);
 236       }
 237       else
 238       {
 239          fp->read( (char*)Raw, PixelDataLength);
 240       }
 241
 242       if ( fp->fail() || fp->eof())
 243       {
 244          gdcmWarningMacro( "Reading of Raw pixel data failed." );
 245          return false;
 246       }
 247    }
 248    else if ( IsRLELossless )
 249    {
 250       if ( ! RLEInfo->DecompressRLEFile( fp, Raw, XSize, YSize, ZSize, BitsAllocated ) )
 251       {
 252          gdcmWarningMacro( "RLE decompressor failed." );
 253          return false;
 254       }
 255    }
 256    else if ( IsMPEG )
 257    {
 258       //gdcmWarningMacro( "Sorry, MPEG not yet taken into account" );
 259       //return false;
 260       ReadMPEGFile(fp, Raw); // fp has already been seek to start of mpeg
 261       return true;
 262    }
 263    else
 264    {
 265       // Default case concerns JPEG family
 266       if ( ! ReadAndDecompressJPEGFile( fp ) )
 267       {
 268          gdcmWarningMacro( "JPEG decompressor failed." );
 269          return false;
 270       }
 271    }
 272
 273    ////////////////////////////////////////////
 274    //// Third stage: twigle the bytes and bits.
 275    ConvertReorderEndianity();
 276    ConvertReArrangeBits();
 277    ConvertFixGreyLevels();
 278    ConvertHandleColor();
 279
 280    return true;
 281 }
 282
 283 /// Deletes Pixels Area
 284 void PixelReadConvert::Squeeze()
 285 {
 286    if ( RGB )
 287       delete [] RGB;
 288    RGB = 0;
 289
 290    if ( Raw )
 291       delete [] Raw;
 292    Raw = 0;
 293
 294    if ( LutRGBA )
 295       delete [] LutRGBA;
 296    LutRGBA = 0;
 297 }
 298
 299 /**
 300  * \brief Build the RGB image from the Raw imagage and the LUTs.
 301  */
 302 bool PixelReadConvert::BuildRGBImage()
 303 {
 304    if ( RGB )
 305    {
 306       // The job is already done.
 307       return true;
 308    }
 309
 310    if ( ! Raw )
 311    {
 312       // The job can't be done
 313       return false;
 314    }
 315
 316    BuildLUTRGBA();
 317    if ( ! LutRGBA )
 318    {
 319       // The job can't be done
 320       return false;
 321    }
 322
 323    // Build RGB Pixels
 324    AllocateRGB();
 325    uint8_t *localRGB = RGB;
 326    for (size_t i = 0; i < RawSize; ++i )
 327    {
 328       int j  = Raw[i] * 4;
 329       *localRGB++ = LutRGBA[j];
 330       *localRGB++ = LutRGBA[j+1];
 331       *localRGB++ = LutRGBA[j+2];
 332    }
 333    return true;
 334 }
 335
 336 //-----------------------------------------------------------------------------
 337 // Protected
 338
 339 //-----------------------------------------------------------------------------
 340 // Private
 341 /**
 342  * \brief Read from file a 12 bits per pixel image and decompress it
 343  *        into a 16 bits per pixel image.
 344  */
 345 void PixelReadConvert::ReadAndDecompress12BitsTo16Bits( std::ifstream *fp )
 346                throw ( FormatError )
 347 {
 348    int nbPixels = XSize * YSize;
 349    uint16_t *localDecompres = (uint16_t*)Raw;
 350
 351    for( int p = 0; p < nbPixels; p += 2 )
 352    {
 353       uint8_t b0, b1, b2;
 354
 355       fp->read( (char*)&b0, 1);
 356       if ( fp->fail() || fp->eof() )
 357       {
 358          throw FormatError( "PixelReadConvert::ReadAndDecompress12BitsTo16Bits()",
 359                                 "Unfound first block" );
 360       }
 361
 362       fp->read( (char*)&b1, 1 );
 363       if ( fp->fail() || fp->eof())
 364       {
 365          throw FormatError( "PixelReadConvert::ReadAndDecompress12BitsTo16Bits()",
 366                                 "Unfound second block" );
 367       }
 368
 369       fp->read( (char*)&b2, 1 );
 370       if ( fp->fail() || fp->eof())
 371       {
 372          throw FormatError( "PixelReadConvert::ReadAndDecompress12BitsTo16Bits()",
 373                                 "Unfound second block" );
 374       }
 375
 376       // Two steps are necessary to please VC++
 377       //
 378       // 2 pixels 12bit =     [0xABCDEF]
 379       // 2 pixels 16bit = [0x0ABD] + [0x0FCE]
 380       //                        A                     B                 D
 381       *localDecompres++ =  ((b0 >> 4) << 8) + ((b0 & 0x0f) << 4) + (b1 & 0x0f);
 382       //                        F                     C                 E
 383       *localDecompres++ =  ((b2 & 0x0f) << 8) + ((b1 >> 4) << 4) + (b2 >> 4);
 384
 385       /// \todo JPR Troubles expected on Big-Endian processors ?
 386    }
 387 }
 388
 389 /**
 390  * \brief     Reads from disk the Pixel Data of JPEG Dicom encapsulated
 391  *            file and decompress it.
 392  * @param     fp File Pointer
 393  * @return    Boolean
 394  */
 395 bool PixelReadConvert::ReadAndDecompressJPEGFile( std::ifstream *fp )
 396 {
 397    if ( IsJPEG2000 )
 398    {
 399       gdcmWarningMacro( "Sorry, JPEG2000 not yet taken into account" );
 400       fp->seekg( JPEGInfo->GetFirstFragment()->GetOffset(), std::ios::beg);
 401 //    if ( ! gdcm_read_JPEG2000_file( fp,Raw ) )
 402           return false;
 403    }
 404
 405    if ( IsJPEGLS )
 406    {
 407       gdcmWarningMacro( "Sorry, JPEG-LS not yet taken into account" );
 408       fp->seekg( JPEGInfo->GetFirstFragment()->GetOffset(), std::ios::beg);
 409 //    if ( ! gdcm_read_JPEGLS_file( fp,Raw ) )
 410          return false;
 411    }
 412
 413    // else ??
 414    // Precompute the offset localRaw will be shifted with
 415    int length = XSize * YSize * SamplesPerPixel;
 416    int numberBytes = BitsAllocated / 8;
 417
 418    JPEGInfo->DecompressFromFile(fp, Raw, BitsStored, numberBytes, length );
 419    return true;
 420 }
 421
 422 /**
 423  * \brief Build Red/Green/Blue/Alpha LUT from File
 424  *         when (0028,0004),Photometric Interpretation = [PALETTE COLOR ]
 425  *          and (0028,1101),(0028,1102),(0028,1102)
 426  *            - xxx Palette Color Lookup Table Descriptor - are found
 427  *          and (0028,1201),(0028,1202),(0028,1202)
 428  *            - xxx Palette Color Lookup Table Data - are found
 429  * \warning does NOT deal with :
 430  *   0028 1100 Gray Lookup Table Descriptor (Retired)
 431  *   0028 1221 Segmented Red Palette Color Lookup Table Data
 432  *   0028 1222 Segmented Green Palette Color Lookup Table Data
 433  *   0028 1223 Segmented Blue Palette Color Lookup Table Data
 434  *   no known Dicom reader deals with them :-(
 435  * @return a RGBA Lookup Table
 436  */
 437 void PixelReadConvert::BuildLUTRGBA()
 438 {
 439    if ( LutRGBA )
 440    {
 441       return;
 442    }
 443    // Not so easy : see
 444    // http://www.barre.nom.fr/medical/dicom2/limitations.html#Color%20Lookup%20Tables
 445
 446    if ( ! IsPaletteColor )
 447    {
 448       return;
 449    }
 450
 451    if (   LutRedDescriptor   == GDCM_UNFOUND
 452        || LutGreenDescriptor == GDCM_UNFOUND
 453        || LutBlueDescriptor  == GDCM_UNFOUND )
 454    {
 455       return;
 456    }
 457
 458    ////////////////////////////////////////////
 459    // Extract the info from the LUT descriptors
 460    int lengthR;   // Red LUT length in Bytes
 461    int debR;      // Subscript of the first Lut Value
 462    int nbitsR;    // Lut item size (in Bits)
 463    int nbRead = sscanf( LutRedDescriptor.c_str(),
 464                         "%d\\%d\\%d",
 465                         &lengthR, &debR, &nbitsR );
 466    if( nbRead != 3 )
 467    {
 468       gdcmWarningMacro( "Wrong Red LUT descriptor" );
 469    }
 470
 471    int lengthG;  // Green LUT length in Bytes
 472    int debG;     // Subscript of the first Lut Value
 473    int nbitsG;   // Lut item size (in Bits)
 474    nbRead = sscanf( LutGreenDescriptor.c_str(),
 475                     "%d\\%d\\%d",
 476                     &lengthG, &debG, &nbitsG );
 477    if( nbRead != 3 )
 478    {
 479       gdcmWarningMacro( "Wrong Green LUT descriptor" );
 480    }
 481
 482    int lengthB;  // Blue LUT length in Bytes
 483    int debB;     // Subscript of the first Lut Value
 484    int nbitsB;   // Lut item size (in Bits)
 485    nbRead = sscanf( LutRedDescriptor.c_str(),
 486                     "%d\\%d\\%d",
 487                     &lengthB, &debB, &nbitsB );
 488    if( nbRead != 3 )
 489    {
 490       gdcmWarningMacro( "Wrong Blue LUT descriptor" );
 491    }
 492
 493    ////////////////////////////////////////////////////////
 494    if ( ( ! LutRedData ) || ( ! LutGreenData ) || ( ! LutBlueData ) )
 495    {
 496       return;
 497    }
 498
 499    ////////////////////////////////////////////////
 500    // forge the 4 * 8 Bits Red/Green/Blue/Alpha LUT
 501    LutRGBA = new uint8_t[ 1024 ]; // 256 * 4 (R, G, B, Alpha)
 502    if ( !LutRGBA )
 503       return;
 504
 505    memset( LutRGBA, 0, 1024 );
 506
 507    int mult;
 508    if ( ( nbitsR == 16 ) && ( BitsAllocated == 8 ) )
 509    {
 510       // when LUT item size is different than pixel size
 511       mult = 2; // high byte must be = low byte
 512    }
 513    else
 514    {
 515       // See PS 3.3-2003 C.11.1.1.2 p 619
 516       mult = 1;
 517    }
 518
 519    // if we get a black image, let's just remove the '+1'
 520    // from 'i*mult+1' and check again
 521    // if it works, we shall have to check the 3 Palettes
 522    // to see which byte is ==0 (first one, or second one)
 523    // and fix the code
 524    // We give up the checking to avoid some (useless ?) overhead
 525    // (optimistic asumption)
 526    int i;
 527    uint8_t *a = LutRGBA + 0;
 528    for( i=0; i < lengthR; ++i )
 529    {
 530       *a = LutRedData[i*mult+1];
 531       a += 4;
 532    }
 533
 534    a = LutRGBA + 1;
 535    for( i=0; i < lengthG; ++i)
 536    {
 537       *a = LutGreenData[i*mult+1];
 538       a += 4;
 539    }
 540
 541    a = LutRGBA + 2;
 542    for(i=0; i < lengthB; ++i)
 543    {
 544       *a = LutBlueData[i*mult+1];
 545       a += 4;
 546    }
 547
 548    a = LutRGBA + 3;
 549    for(i=0; i < 256; ++i)
 550    {
 551       *a = 1; // Alpha component
 552       a += 4;
 553    }
 554 }
 555
 556 /**
 557  * \brief Swap the bytes, according to \ref SwapCode.
 558  */
 559 void PixelReadConvert::ConvertSwapZone()
 560 {
 561    unsigned int i;
 562
 563    if( BitsAllocated == 16 )
 564    {
 565       uint16_t *im16 = (uint16_t*)Raw;
 566       switch( SwapCode )
 567       {
 568          case 1234:
 569             break;
 570          case 3412:
 571          case 2143:
 572          case 4321:
 573             for( i = 0; i < RawSize / 2; i++ )
 574             {
 575                im16[i]= (im16[i] >> 8) | (im16[i] << 8 );
 576             }
 577             break;
 578          default:
 579             gdcmWarningMacro("SwapCode value (16 bits) not allowed.");
 580       }
 581    }
 582    else if( BitsAllocated == 32 )
 583    {
 584       uint32_t s32;
 585       uint16_t high;
 586       uint16_t low;
 587       uint32_t *im32 = (uint32_t*)Raw;
 588       switch ( SwapCode )
 589       {
 590          case 1234:
 591             break;
 592          case 4321:
 593             for( i = 0; i < RawSize / 4; i++ )
 594             {
 595                low     = im32[i] & 0x0000ffff;  // 4321
 596                high    = im32[i] >> 16;
 597                high    = ( high >> 8 ) | ( high << 8 );
 598                low     = ( low  >> 8 ) | ( low  << 8 );
 599                s32     = low;
 600                im32[i] = ( s32 << 16 ) | high;
 601             }
 602             break;
 603          case 2143:
 604             for( i = 0; i < RawSize / 4; i++ )
 605             {
 606                low     = im32[i] & 0x0000ffff;   // 2143
 607                high    = im32[i] >> 16;
 608                high    = ( high >> 8 ) | ( high << 8 );
 609                low     = ( low  >> 8 ) | ( low  << 8 );
 610                s32     = high;
 611                im32[i] = ( s32 << 16 ) | low;
 612             }
 613             break;
 614          case 3412:
 615             for( i = 0; i < RawSize / 4; i++ )
 616             {
 617                low     = im32[i] & 0x0000ffff; // 3412
 618                high    = im32[i] >> 16;
 619                s32     = low;
 620                im32[i] = ( s32 << 16 ) | high;
 621             }
 622             break;
 623          default:
 624             gdcmWarningMacro("SwapCode value (32 bits) not allowed." );
 625       }
 626    }
 627 }
 628
 629 /**
 630  * \brief Deal with endianness i.e. re-arange bytes inside the integer
 631  */
 632 void PixelReadConvert::ConvertReorderEndianity()
 633 {
 634    if ( BitsAllocated != 8 )
 635    {
 636       ConvertSwapZone();
 637    }
 638
 639    // Special kludge in order to deal with xmedcon broken images:
 640    if ( BitsAllocated == 16
 641      && BitsStored < BitsAllocated
 642      && !PixelSign )
 643    {
 644       int l = (int)( RawSize / ( BitsAllocated / 8 ) );
 645       uint16_t *deb = (uint16_t *)Raw;
 646       for(int i = 0; i<l; i++)
 647       {
 648          if( *deb == 0xffff )
 649          {
 650            *deb = 0;
 651          }
 652          deb++;
 653       }
 654    }
 655 }
 656
 657 /**
 658  * \brief Deal with Grey levels i.e. re-arange them
 659  *        to have low values = dark, high values = bright
 660  */
 661 void PixelReadConvert::ConvertFixGreyLevels()
 662 {
 663    if (!IsMonochrome1)
 664       return;
 665
 666    uint32_t i; // to please M$VC6
 667    int16_t j;
 668
 669    if (!PixelSign)
 670    {
 671       if ( BitsAllocated == 8 )
 672       {
 673          uint8_t *deb = (uint8_t *)Raw;
 674          for (i=0; i<RawSize; i++)
 675          {
 676             *deb = 255 - *deb;
 677             deb++;
 678          }
 679          return;
 680       }
 681
 682       if ( BitsAllocated == 16 )
 683       {
 684          uint16_t mask =1;
 685          for (j=0; j<BitsStored-1; j++)
 686          {
 687             mask = (mask << 1) +1; // will be fff when BitsStored=12
 688          }
 689
 690          uint16_t *deb = (uint16_t *)Raw;
 691          for (i=0; i<RawSize/2; i++)
 692          {
 693             *deb = mask - *deb;
 694             deb++;
 695          }
 696          return;
 697        }
 698    }
 699    else
 700    {
 701       if ( BitsAllocated == 8 )
 702       {
 703          uint8_t smask8 = 255;
 704          uint8_t *deb = (uint8_t *)Raw;
 705          for (i=0; i<RawSize; i++)
 706          {
 707             *deb = smask8 - *deb;
 708             deb++;
 709          }
 710          return;
 711       }
 712       if ( BitsAllocated == 16 )
 713       {
 714          uint16_t smask16 = 65535;
 715          uint16_t *deb = (uint16_t *)Raw;
 716          for (i=0; i<RawSize/2; i++)
 717          {
 718             *deb = smask16 - *deb;
 719             deb++;
 720          }
 721          return;
 722       }
 723    }
 724 }
 725
 726 /**
 727  * \brief  Re-arrange the bits within the bytes.
 728  * @return Boolean always true
 729  */
 730 bool PixelReadConvert::ConvertReArrangeBits() throw ( FormatError )
 731 {
 732    if ( BitsStored != BitsAllocated )
 733    {
 734       int l = (int)( RawSize / ( BitsAllocated / 8 ) );
 735       if ( BitsAllocated == 16 )
 736       {
 737          uint16_t mask = 0xffff;
 738          mask = mask >> ( BitsAllocated - BitsStored );
 739          uint16_t *deb = (uint16_t*)Raw;
 740          for(int i = 0; i<l; i++)
 741          {
 742             *deb = (*deb >> (BitsStored - HighBitPosition - 1)) & mask;
 743             deb++;
 744          }
 745       }
 746       else if ( BitsAllocated == 32 )
 747       {
 748          uint32_t mask = 0xffffffff;
 749          mask = mask >> ( BitsAllocated - BitsStored );
 750          uint32_t *deb = (uint32_t*)Raw;
 751          for(int i = 0; i<l; i++)
 752          {
 753             *deb = (*deb >> (BitsStored - HighBitPosition - 1)) & mask;
 754             deb++;
 755          }
 756       }
 757       else
 758       {
 759          gdcmWarningMacro("Weird image");
 760          throw FormatError( "Weird image !?" );
 761       }
 762    }
 763    return true;
 764 }
 765
 766 /**
 767  * \brief   Convert (Red plane, Green plane, Blue plane) to RGB pixels
 768  * \warning Works on all the frames at a time
 769  */
 770 void PixelReadConvert::ConvertRGBPlanesToRGBPixels()
 771 {
 772    uint8_t *localRaw = Raw;
 773    uint8_t *copyRaw = new uint8_t[ RawSize ];
 774    memmove( copyRaw, localRaw, RawSize );
 775
 776    int l = XSize * YSize * ZSize;
 777
 778    uint8_t *a = copyRaw;
 779    uint8_t *b = copyRaw + l;
 780    uint8_t *c = copyRaw + l + l;
 781
 782    for (int j = 0; j < l; j++)
 783    {
 784       *(localRaw++) = *(a++);
 785       *(localRaw++) = *(b++);
 786       *(localRaw++) = *(c++);
 787    }
 788    delete[] copyRaw;
 789 }
 790
 791 /**
 792  * \brief   Convert (cY plane, cB plane, cR plane) to RGB pixels
 793  * \warning Works on all the frames at a time
 794  */
 795 void PixelReadConvert::ConvertYcBcRPlanesToRGBPixels()
 796 {
 797    uint8_t *localRaw = Raw;
 798    uint8_t *copyRaw = new uint8_t[ RawSize ];
 799    memmove( copyRaw, localRaw, RawSize );
 800
 801    // to see the tricks about YBR_FULL, YBR_FULL_422,
 802    // YBR_PARTIAL_422, YBR_ICT, YBR_RCT have a look at :
 803    // ftp://medical.nema.org/medical/dicom/final/sup61_ft.pdf
 804    // and be *very* affraid
 805    //
 806    int l        = XSize * YSize;
 807    int nbFrames = ZSize;
 808
 809    uint8_t *a = copyRaw + 0;
 810    uint8_t *b = copyRaw + l;
 811    uint8_t *c = copyRaw + l+ l;
 812    int32_t R, G, B;
 813
 814    /// \todo : Replace by the 'well known' integer computation
 815    ///         counterpart. Refer to
 816    ///            http://lestourtereaux.free.fr/papers/data/yuvrgb.pdf
 817    ///         for code optimisation.
 818
 819    for ( int i = 0; i < nbFrames; i++ )
 820    {
 821       for ( int j = 0; j < l; j++ )
 822       {
 823          R = 38142 *(*a-16) + 52298 *(*c -128);
 824          G = 38142 *(*a-16) - 26640 *(*c -128) - 12845 *(*b -128);
 825          B = 38142 *(*a-16) + 66093 *(*b -128);
 826
 827          R = (R+16384)>>15;
 828          G = (G+16384)>>15;
 829          B = (B+16384)>>15;
 830
 831          if (R < 0)   R = 0;
 832          if (G < 0)   G = 0;
 833          if (B < 0)   B = 0;
 834          if (R > 255) R = 255;
 835          if (G > 255) G = 255;
 836          if (B > 255) B = 255;
 837
 838          *(localRaw++) = (uint8_t)R;
 839          *(localRaw++) = (uint8_t)G;
 840          *(localRaw++) = (uint8_t)B;
 841          a++;
 842          b++;
 843          c++;
 844       }
 845    }
 846    delete[] copyRaw;
 847 }
 848
 849 /// \brief Deals with the color decoding i.e. handle:
 850 ///   - R, G, B planes (as opposed to RGB pixels)
 851 ///   - YBR (various) encodings.
 852 ///   - LUT[s] (or "PALETTE COLOR").
 853
 854 void PixelReadConvert::ConvertHandleColor()
 855 {
 856    //////////////////////////////////
 857    // Deal with the color decoding i.e. handle:
 858    //   - R, G, B planes (as opposed to RGB pixels)
 859    //   - YBR (various) encodings.
 860    //   - LUT[s] (or "PALETTE COLOR").
 861    //
 862    // The classification in the color decoding schema is based on the blending
 863    // of two Dicom tags values:
 864    // * "Photometric Interpretation" for which we have the cases:
 865    //  - [Photo A] MONOCHROME[1|2] pictures,
 866    //  - [Photo B] RGB or YBR_FULL_422 (which acts as RGB),
 867    //  - [Photo C] YBR_* (with the above exception of YBR_FULL_422)
 868    //  - [Photo D] "PALETTE COLOR" which indicates the presence of LUT[s].
 869    // * "Planar Configuration" for which we have the cases:
 870    //  - [Planar 0] 0 then Pixels are already RGB
 871    //  - [Planar 1] 1 then we have 3 planes : R, G, B,
 872    //  - [Planar 2] 2 then we have 1 gray Plane and 3 LUTs
 873    //
 874    // Now in theory, one could expect some coherence when blending the above
 875    // cases. For example we should not encounter files belonging at the
 876    // time to case [Planar 0] and case [Photo D].
 877    // Alas, this was only theory ! Because in practice some odd (read ill
 878    // formated Dicom) files (e.g. gdcmData/US-PAL-8-10x-echo.dcm) we encounter:
 879    //     - "Planar Configuration" = 0,
 880    //     - "Photometric Interpretation" = "PALETTE COLOR".
 881    // Hence gdcm will use the folowing "heuristic" in order to be tolerant
 882    // towards Dicom-non-conformance files:
 883    //   << whatever the "Planar Configuration" value might be, a
 884    //      "Photometric Interpretation" set to "PALETTE COLOR" forces
 885    //      a LUT intervention >>
 886    //
 887    // Now we are left with the following handling of the cases:
 888    // - [Planar 0] OR  [Photo A] no color decoding (since respectively
 889    //       Pixels are already RGB and monochrome pictures have no color :),
 890    // - [Planar 1] AND [Photo B] handled with ConvertRGBPlanesToRGBPixels()
 891    // - [Planar 1] AND [Photo C] handled with ConvertYcBcRPlanesToRGBPixels()
 892    // - [Planar 2] OR  [Photo D] requires LUT intervention.
 893
 894    if ( ! IsRawRGB() )
 895    {
 896       // [Planar 2] OR  [Photo D]: LUT intervention done outside
 897       return;
 898    }
 899
 900    if ( PlanarConfiguration == 1 )
 901    {
 902       if ( IsYBRFull )
 903       {
 904          // [Planar 1] AND [Photo C] (remember YBR_FULL_422 acts as RGB)
 905          ConvertYcBcRPlanesToRGBPixels();
 906       }
 907       else
 908       {
 909          // [Planar 1] AND [Photo C]
 910          ConvertRGBPlanesToRGBPixels();
 911       }
 912       return;
 913    }
 914
 915    // When planarConf is 0, and RLELossless (forbidden by Dicom norm)
 916    // pixels need to be RGB-fied anyway
 917    if (IsRLELossless)
 918    {
 919      ConvertRGBPlanesToRGBPixels();
 920    }
 921    // In *normal *case, when planarConf is 0, pixels are already in RGB
 922 }
 923
 924 /// Computes the Pixels Size
 925 void PixelReadConvert::ComputeRawAndRGBSizes()
 926 {
 927    int bitsAllocated = BitsAllocated;
 928    // Number of "Bits Allocated" is fixed to 16 when it's 12, since
 929    // in this case we will expand the image to 16 bits (see
 930    //    \ref ReadAndDecompress12BitsTo16Bits() )
 931    if (  BitsAllocated == 12 )
 932    {
 933       bitsAllocated = 16;
 934    }
 935
 936    RawSize =  XSize * YSize * ZSize
 937                      * ( bitsAllocated / 8 )
 938                      * SamplesPerPixel;
 939    if ( HasLUT )
 940    {
 941       RGBSize = 3 * RawSize;
 942    }
 943    else
 944    {
 945       RGBSize = RawSize;
 946    }
 947 }
 948
 949 /// Allocates room for RGB Pixels
 950 void PixelReadConvert::AllocateRGB()
 951 {
 952   if ( RGB )
 953      delete [] RGB;
 954   RGB = new uint8_t[RGBSize];
 955 }
 956
 957 /// Allocates room for RAW Pixels
 958 void PixelReadConvert::AllocateRaw()
 959 {
 960   if ( Raw )
 961      delete [] Raw;
 962   Raw = new uint8_t[RawSize];
 963 }
 964
 965 //-----------------------------------------------------------------------------
 966 // Print
 967 /**
 968  * \brief        Print self.
 969  * @param indent Indentation string to be prepended during printing.
 970  * @param os     Stream to print to.
 971  */
 972 void PixelReadConvert::Print( std::ostream &os, std::string const &indent )
 973 {
 974    os << indent
 975       << "--- Pixel information -------------------------"
 976       << std::endl;
 977    os << indent
 978       << "Pixel Data: offset " << PixelOffset
 979       << " x(" << std::hex << PixelOffset << std::dec
 980       << ")   length " << PixelDataLength
 981       << " x(" << std::hex << PixelDataLength << std::dec
 982       << ")" << std::endl;
 983
 984    if ( IsRLELossless )
 985    {
 986       if ( RLEInfo )
 987       {
 988          RLEInfo->Print( os, indent );
 989       }
 990       else
 991       {
 992          gdcmWarningMacro("Set as RLE file but NO RLEinfo present.");
 993       }
 994    }
 995
 996    if ( IsJPEG2000 || IsJPEGLossless || IsJPEGLossy || IsJPEGLS )
 997    {
 998       if ( JPEGInfo )
 999       {
1000          JPEGInfo->Print( os, indent );
1001       }
1002       else
1003       {
1004          gdcmWarningMacro("Set as JPEG file but NO JPEGinfo present.");
1005       }
1006    }
1007 }
1008
1009 //-----------------------------------------------------------------------------
1010 } // end namespace gdcm
1011
1012 // NOTES on File internal calls
1013 // User
1014 // ---> GetImageData
1015 //     ---> GetImageDataIntoVector
1016 //        |---> GetImageDataIntoVectorRaw
1017 //        | lut intervention
1018 // User
1019 // ---> GetImageDataRaw
1020 //     ---> GetImageDataIntoVectorRaw
1021