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