1 /*=========================================================================
4 Module: $RCSfile: gdcmFile.cxx,v $
6 Date: $Date: 2005/01/06 14:49:16 $
7 Version: $Revision: 1.181 $
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.
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.
17 =========================================================================*/
20 #include "gdcmDocument.h"
21 #include "gdcmDebug.h"
23 #include "gdcmBinEntry.h"
24 #include "gdcmHeader.h"
25 #include "gdcmPixelReadConvert.h"
26 #include "gdcmPixelWriteConvert.h"
27 #include "gdcmDocEntryArchive.h"
33 typedef std::pair<TagDocEntryHT::iterator,TagDocEntryHT::iterator> IterHT;
35 //-------------------------------------------------------------------------
36 // Constructor / Destructor
38 * \brief Constructor dedicated to deal with the *pixels* area of a ACR/DICOMV3
39 * file (Header only deals with the ... header)
40 * Opens (in read only and when possible) an existing file and checks
41 * for DICOM compliance. Returns NULL on failure.
42 * It will be up to the user to load the pixels into memory
43 * (see GetImageData, GetImageDataRaw)
44 * \note the in-memory representation of all available tags found in
45 * the DICOM header is post-poned to first header information access.
46 * This avoid a double parsing of public part of the header when
47 * one sets an a posteriori shadow dictionary (efficiency can be
48 * seen as a side effect).
52 HeaderInternal = new Header( );
58 * \brief Constructor dedicated to deal with the *pixels* area of a ACR/DICOMV3
59 * file (Header only deals with the ... header)
60 * Opens (in read only and when possible) an existing file and checks
61 * for DICOM compliance. Returns NULL on failure.
62 * It will be up to the user to load the pixels into memory
63 * (see GetImageData, GetImageDataRaw)
64 * \note the in-memory representation of all available tags found in
65 * the DICOM header is post-poned to first header information access.
66 * This avoid a double parsing of public part of the header when
67 * user sets an a posteriori shadow dictionary (efficiency can be
68 * seen as a side effect).
69 * @param header already built Header
71 File::File(Header *header)
73 HeaderInternal = header;
79 * \brief Constructor dedicated to deal with the *pixels* area of a ACR/DICOMV3
80 * file (Header only deals with the ... header)
81 * Opens (in read only and when possible) an existing file and checks
82 * for DICOM compliance. Returns NULL on failure.
83 * It will be up to the user to load the pixels into memory
84 * (see GetImageData, GetImageDataRaw)
85 * \note the in-memory representation of all available tags found in
86 * the DICOM header is post-poned to first header information access.
87 * This avoid a double parsing of public part of the header when
88 * one sets an a posteriori shadow dictionary (efficiency can be
89 * seen as a side effect).
90 * @param filename file to be opened for parsing
92 File::File(std::string const & filename )
94 HeaderInternal = new Header( filename );
100 * \brief canonical destructor
101 * \note If the Header was created by the File constructor,
102 * it is destroyed by the File
106 if( PixelReadConverter )
108 delete PixelReadConverter;
110 if( PixelWriteConverter )
112 delete PixelWriteConverter;
121 delete HeaderInternal;
126 //-----------------------------------------------------------------------------
128 void File::Print(std::ostream &os)
130 HeaderInternal->SetPrintLevel(PrintLevel);
131 HeaderInternal->Print(os);
133 PixelReadConverter->SetPrintLevel(PrintLevel);
134 PixelReadConverter->Print(os);
137 //-----------------------------------------------------------------------------
140 * \brief Get the size of the image data
142 * If the image can be RGB (with a lut or by default), the size
143 * corresponds to the RGB image
144 * @return The image size
146 size_t File::GetImageDataSize()
148 if ( PixelWriteConverter->GetUserData() )
150 return PixelWriteConverter->GetUserDataSize();
153 return PixelReadConverter->GetRGBSize();
157 * \brief Get the size of the image data
159 * If the image can be RGB by transformation in a LUT, this
160 * transformation isn't considered
161 * @return The raw image size
163 size_t File::GetImageDataRawSize()
165 if ( PixelWriteConverter->GetUserData() )
167 return PixelWriteConverter->GetUserDataSize();
170 return PixelReadConverter->GetRawSize();
174 * \brief - Allocates necessary memory,
175 * - Reads the pixels from disk (uncompress if necessary),
176 * - Transforms YBR pixels, if any, into RGB pixels
177 * - Transforms 3 planes R, G, B, if any, into a single RGB Plane
178 * - Transforms single Grey plane + 3 Palettes into a RGB Plane
179 * - Copies the pixel data (image[s]/volume[s]) to newly allocated zone.
180 * @return Pointer to newly allocated pixel data.
181 * NULL if alloc fails
183 uint8_t* File::GetImageData()
185 if ( PixelWriteConverter->GetUserData() )
187 return PixelWriteConverter->GetUserData();
192 // If the decompression failed nothing can be done.
196 if ( HeaderInternal->HasLUT() && PixelReadConverter->BuildRGBImage() )
198 return PixelReadConverter->GetRGB();
202 // When no LUT or LUT conversion fails, return the Raw
203 return PixelReadConverter->GetRaw();
208 * \brief Allocates necessary memory,
209 * Transforms YBR pixels (if any) into RGB pixels
210 * Transforms 3 planes R, G, B (if any) into a single RGB Plane
211 * Copies the pixel data (image[s]/volume[s]) to newly allocated zone.
212 * DOES NOT transform Grey plane + 3 Palettes into a RGB Plane
213 * @return Pointer to newly allocated pixel data.
214 * \ NULL if alloc fails
216 uint8_t* File::GetImageDataRaw ()
223 * Read the pixels from disk (uncompress if necessary),
224 * Transforms YBR pixels, if any, into RGB pixels
225 * Transforms 3 planes R, G, B, if any, into a single RGB Plane
226 * Transforms single Grey plane + 3 Palettes into a RGB Plane
227 * Copies at most MaxSize bytes of pixel data to caller allocated
229 * \warning This function allows people that want to build a volume
230 * from an image stack *not to* have, first to get the image pixels,
231 * and then move them to the volume area.
232 * It's absolutely useless for any VTK user since vtk chooses
233 * to invert the lines of an image, that is the last line comes first
234 * (for some axis related reasons?). Hence he will have
235 * to load the image line by line, starting from the end.
236 * VTK users have to call GetImageData
238 * @param destination Address (in caller's memory space) at which the
239 * pixel data should be copied
240 * @param maxSize Maximum number of bytes to be copied. When MaxSize
241 * is not sufficient to hold the pixel data the copy is not
242 * executed (i.e. no partial copy).
243 * @return On success, the number of bytes actually copied. Zero on
244 * failure e.g. MaxSize is lower than necessary.
246 size_t File::GetImageDataIntoVector (void* destination, size_t maxSize)
250 // If the decompression failed nothing can be done.
254 if ( HeaderInternal->HasLUT() && PixelReadConverter->BuildRGBImage() )
256 if ( PixelReadConverter->GetRGBSize() > maxSize )
258 dbg.Verbose(0, "File::GetImageDataIntoVector: pixel data bigger"
259 "than caller's expected MaxSize");
263 (void*)PixelReadConverter->GetRGB(),
264 PixelReadConverter->GetRGBSize() );
265 return PixelReadConverter->GetRGBSize();
268 // Either no LUT conversion necessary or LUT conversion failed
269 if ( PixelReadConverter->GetRawSize() > maxSize )
271 dbg.Verbose(0, "File::GetImageDataIntoVector: pixel data bigger"
272 "than caller's expected MaxSize");
276 (void*)PixelReadConverter->GetRaw(),
277 PixelReadConverter->GetRawSize() );
278 return PixelReadConverter->GetRawSize();
282 * \brief Points the internal pointer to the callers inData
283 * image representation, BUT WITHOUT COPYING THE DATA.
284 * 'image' Pixels are presented as C-like 2D arrays : line per line.
285 * 'volume'Pixels are presented as C-like 3D arrays : plane per plane
286 * \warning Since the pixels are not copied, it is the caller's responsability
287 * not to deallocate it's data before gdcm uses them (e.g. with
288 * the Write() method.
289 * @param inData user supplied pixel area
290 * @param expectedSize total image size, in Bytes
294 void File::SetImageData(uint8_t* inData, size_t expectedSize)
296 SetUserData(inData,expectedSize);
300 * \brief Set the image datas defined by the user
301 * \warning When writting the file, this datas are get as default datas to write
303 void File::SetUserData(uint8_t* data, size_t expectedSize)
305 PixelWriteConverter->SetUserData(data,expectedSize);
309 * \brief Get the image datas defined by the user
310 * \warning When writting the file, this datas are get as default datas to write
312 uint8_t* File::GetUserData()
314 return PixelWriteConverter->GetUserData();
318 * \brief Get the image data size defined by the user
319 * \warning When writting the file, this datas are get as default datas to write
321 size_t File::GetUserDataSize()
323 return PixelWriteConverter->GetUserDataSize();
327 * \brief Get the image datas from the file.
328 * If a LUT is found, the datas are expanded to be RGB
330 uint8_t* File::GetRGBData()
332 return PixelReadConverter->GetRGB();
336 * \brief Get the image data size from the file.
337 * If a LUT is found, the datas are expanded to be RGB
339 size_t File::GetRGBDataSize()
341 return PixelReadConverter->GetRGBSize();
345 * \brief Get the image datas from the file.
346 * If a LUT is found, the datas are not expanded !
348 uint8_t* File::GetRawData()
350 return PixelReadConverter->GetRaw();
354 * \brief Get the image data size from the file.
355 * If a LUT is found, the datas are not expanded !
357 size_t File::GetRawDataSize()
359 return PixelReadConverter->GetRawSize();
363 * \brief Writes on disk A SINGLE Dicom file
364 * NO test is performed on processor "Endiannity".
365 * It's up to the user to call his Reader properly
366 * @param fileName name of the file to be created
367 * (any already existing file is over written)
368 * @return false if write fails
371 bool File::WriteRawData(std::string const & fileName)
373 std::ofstream fp1(fileName.c_str(), std::ios::out | std::ios::binary );
376 dbg.Verbose(2, "Fail to open (write) file:", fileName.c_str());
380 if(PixelWriteConverter->GetUserData())
381 fp1.write((char*)PixelWriteConverter->GetUserData(), PixelWriteConverter->GetUserDataSize());
382 else if(PixelReadConverter->GetRGB())
383 fp1.write((char*)PixelReadConverter->GetRGB(), PixelReadConverter->GetRGBSize());
384 else if(PixelReadConverter->GetRaw())
385 fp1.write((char*)PixelReadConverter->GetRaw(), PixelReadConverter->GetRawSize());
393 * \brief Writes on disk A SINGLE Dicom file,
394 * using the Implicit Value Representation convention
395 * NO test is performed on processor "Endiannity".
396 * @param fileName name of the file to be created
397 * (any already existing file is overwritten)
398 * @return false if write fails
401 bool File::WriteDcmImplVR (std::string const & fileName)
403 SetWriteTypeToDcmImplVR();
404 return Write(fileName);
408 * \brief Writes on disk A SINGLE Dicom file,
409 * using the Explicit Value Representation convention
410 * NO test is performed on processor "Endiannity".
411 * @param fileName name of the file to be created
412 * (any already existing file is overwritten)
413 * @return false if write fails
416 bool File::WriteDcmExplVR (std::string const & fileName)
418 SetWriteTypeToDcmExplVR();
419 return Write(fileName);
423 * \brief Writes on disk A SINGLE Dicom file,
424 * using the ACR-NEMA convention
425 * NO test is performed on processor "Endiannity".
426 * (a l'attention des logiciels cliniques
427 * qui ne prennent en entrée QUE des images ACR ...
428 * \warning if a DICOM_V3 header is supplied,
429 * groups < 0x0008 and shadow groups are ignored
430 * \warning NO TEST is performed on processor "Endiannity".
431 * @param fileName name of the file to be created
432 * (any already existing file is overwritten)
433 * @return false if write fails
436 bool File::WriteAcr (std::string const & fileName)
439 return Write(fileName);
443 * \brief Writes on disk A SINGLE Dicom file,
444 * @param fileName name of the file to be created
445 * (any already existing file is overwritten)
446 * @return false if write fails
448 bool File::Write(std::string const& fileName)
453 SetWriteFileTypeToImplicitVR();
456 SetWriteFileTypeToExplicitVR();
460 SetWriteFileTypeToACR();
463 SetWriteFileTypeToExplicitVR();
466 // --------------------------------------------------------------
467 // Special Patch to allow gdcm to re-write ACR-LibIDO formated images
469 // if recognition code tells us we dealt with a LibIDO image
470 // we reproduce on disk the switch between lineNumber and columnNumber
471 // just before writting ...
472 /// \todo the best trick would be *change* the recognition code
473 /// but pb expected if user deals with, e.g. COMPLEX images
474 if( WriteType == ACR_LIBIDO )
480 SetWriteToNoLibido();
482 // ----------------- End of Special Patch ----------------
494 bool check = CheckWriteIntegrity();
497 check = HeaderInternal->Write(fileName,WriteType);
501 RestoreWriteFileType();
503 // --------------------------------------------------------------
504 // Special Patch to allow gdcm to re-write ACR-LibIDO formated images
506 // ...and we restore the Header to be Dicom Compliant again
507 // just after writting
508 RestoreWriteOfLibido();
509 // ----------------- End of Special Patch ----------------
515 * \brief Accesses an existing DocEntry (i.e. a Dicom Element)
516 * through it's (group, element) and modifies it's content with
518 * @param content new value (string) to substitute with
519 * @param group group number of the Dicom Element to modify
520 * @param element element number of the Dicom Element to modify
522 bool File::SetEntryByNumber(std::string const& content,
523 uint16_t group, uint16_t element)
525 return HeaderInternal->SetEntryByNumber(content,group,element);
530 * \brief Accesses an existing DocEntry (i.e. a Dicom Element)
531 * through it's (group, element) and modifies it's content with
533 * @param content new value (void* -> uint8_t*) to substitute with
534 * @param lgth new value length
535 * @param group group number of the Dicom Element to modify
536 * @param element element number of the Dicom Element to modify
538 bool File::SetEntryByNumber(uint8_t* content, int lgth,
539 uint16_t group, uint16_t element)
541 return HeaderInternal->SetEntryByNumber(content,lgth,group,element);
545 * \brief Modifies the value of a given Doc Entry (Dicom Element)
546 * when it exists. Create it with the given value when unexistant.
547 * @param value (string) Value to be set
548 * @param group Group number of the Entry
549 * @param elem Element number of the Entry
550 * \return pointer to the modified/created Header Entry (NULL when creation
553 bool File::ReplaceOrCreateByNumber(std::string const& content,
554 uint16_t group, uint16_t element)
556 return HeaderInternal->ReplaceOrCreateByNumber(content,group,element) != NULL;
560 * \brief Modifies the value of a given Header Entry (Dicom Element)
561 * when it exists. Create it with the given value when unexistant.
562 * A copy of the binArea is made to be kept in the Document.
563 * @param binArea (binary) value to be set
564 * @param Group Group number of the Entry
565 * @param Elem Element number of the Entry
566 * \return pointer to the modified/created Header Entry (NULL when creation
569 bool File::ReplaceOrCreateByNumber(uint8_t* binArea, int lgth,
570 uint16_t group, uint16_t element)
572 return HeaderInternal->ReplaceOrCreateByNumber(binArea,lgth,group,element) != NULL;
576 * \brief Access to the underlying \ref PixelReadConverter RGBA LUT
578 uint8_t* File::GetLutRGBA()
580 return PixelReadConverter->GetLutRGBA();
583 //-----------------------------------------------------------------------------
587 * \brief Check the write integrity
589 * The tests made are :
590 * - verify the size of the image to write with the possible write
591 * when the user set an image data
592 * @return true if the check successfulls
594 bool File::CheckWriteIntegrity()
596 if(PixelWriteConverter->GetUserData())
598 int numberBitsAllocated = HeaderInternal->GetBitsAllocated();
599 if ( numberBitsAllocated == 0 || numberBitsAllocated == 12 )
601 numberBitsAllocated = 16;
604 size_t decSize = HeaderInternal->GetXSize()
605 * HeaderInternal->GetYSize()
606 * HeaderInternal->GetZSize()
607 * ( numberBitsAllocated / 8 )
608 * HeaderInternal->GetSamplesPerPixel();
609 size_t rgbSize = decSize;
610 if( HeaderInternal->HasLUT() )
611 rgbSize = decSize * 3;
616 if( decSize!=PixelWriteConverter->GetUserDataSize() )
618 dbg.Verbose(0, "File::CheckWriteIntegrity: Data size is incorrect (Raw)");
619 //std::cerr << "File::CheckWriteIntegrity: Data size is incorrect (Raw)\n"
620 // << decSize << " / " << PixelWriteConverter->GetUserDataSize() << "\n";
625 if( rgbSize!=PixelWriteConverter->GetUserDataSize() )
627 dbg.Verbose(0, "File::CheckWriteIntegrity: Data size is incorrect (RGB)");
628 //std::cerr << "File::CheckWriteIntegrity: Data size is incorrect (RGB)\n"
629 // << decSize << " / " << PixelWriteConverter->GetUserDataSize() << "\n";
639 void File::SetWriteToRaw()
641 if(HeaderInternal->GetNumberOfScalarComponents()==3 && !HeaderInternal->HasLUT())
647 ValEntry* photInt = CopyValEntry(0x0028,0x0004);
648 if(HeaderInternal->HasLUT())
650 photInt->SetValue("PALETTE COLOR ");
654 photInt->SetValue("MONOCHROME1 ");
657 PixelWriteConverter->SetReadData(PixelReadConverter->GetRaw(),
658 PixelReadConverter->GetRawSize());
660 BinEntry* pixel = CopyBinEntry(GetHeader()->GetGrPixel(),GetHeader()->GetNumPixel());
661 pixel->SetValue(GDCM_BINLOADED);
662 pixel->SetBinArea(PixelWriteConverter->GetData(),false);
663 pixel->SetLength(PixelWriteConverter->GetDataSize());
665 Archive->Push(photInt);
666 Archive->Push(pixel);
670 void File::SetWriteToRGB()
672 if(HeaderInternal->GetNumberOfScalarComponents()==3)
674 PixelReadConverter->BuildRGBImage();
676 ValEntry* spp = CopyValEntry(0x0028,0x0002);
679 ValEntry* planConfig = CopyValEntry(0x0028,0x0006);
680 planConfig->SetValue("0 ");
682 ValEntry* photInt = CopyValEntry(0x0028,0x0004);
683 photInt->SetValue("RGB ");
685 if(PixelReadConverter->GetRGB())
687 PixelWriteConverter->SetReadData(PixelReadConverter->GetRGB(),
688 PixelReadConverter->GetRGBSize());
692 PixelWriteConverter->SetReadData(PixelReadConverter->GetRaw(),
693 PixelReadConverter->GetRawSize());
696 BinEntry* pixel = CopyBinEntry(GetHeader()->GetGrPixel(),GetHeader()->GetNumPixel());
697 pixel->SetValue(GDCM_BINLOADED);
698 pixel->SetBinArea(PixelWriteConverter->GetData(),false);
699 pixel->SetLength(PixelWriteConverter->GetDataSize());
702 Archive->Push(planConfig);
703 Archive->Push(photInt);
704 Archive->Push(pixel);
707 Archive->Push(0x0028,0x1101);
708 Archive->Push(0x0028,0x1102);
709 Archive->Push(0x0028,0x1103);
710 Archive->Push(0x0028,0x1201);
711 Archive->Push(0x0028,0x1202);
712 Archive->Push(0x0028,0x1203);
715 // Thus, we have a RGB image and the bits allocated = 24 and
716 // samples per pixels = 1 (in the read file)
717 if(HeaderInternal->GetBitsAllocated()==24)
719 ValEntry* bitsAlloc = CopyValEntry(0x0028,0x0100);
720 bitsAlloc->SetValue("8 ");
722 ValEntry* bitsStored = CopyValEntry(0x0028,0x0101);
723 bitsStored->SetValue("8 ");
725 ValEntry* highBit = CopyValEntry(0x0028,0x0102);
726 highBit->SetValue("7 ");
728 Archive->Push(bitsAlloc);
729 Archive->Push(bitsStored);
730 Archive->Push(highBit);
739 void File::RestoreWrite()
741 Archive->Restore(0x0028,0x0002);
742 Archive->Restore(0x0028,0x0004);
743 Archive->Restore(0x0028,0x0006);
744 Archive->Restore(GetHeader()->GetGrPixel(),GetHeader()->GetNumPixel());
746 // For old ACR-NEMA (24 bits problem)
747 Archive->Restore(0x0028,0x0100);
748 Archive->Restore(0x0028,0x0101);
749 Archive->Restore(0x0028,0x0102);
752 Archive->Restore(0x0028,0x1101);
753 Archive->Restore(0x0028,0x1102);
754 Archive->Restore(0x0028,0x1103);
755 Archive->Restore(0x0028,0x1201);
756 Archive->Restore(0x0028,0x1202);
757 Archive->Restore(0x0028,0x1203);
760 void File::SetWriteFileTypeToACR()
762 Archive->Push(0x0002,0x0010);
765 void File::SetWriteFileTypeToExplicitVR()
767 std::string ts = Util::DicomString(
768 Document::GetTransferSyntaxValue(ExplicitVRLittleEndian).c_str() );
770 ValEntry* tss = CopyValEntry(0x0002,0x0010);
776 void File::SetWriteFileTypeToImplicitVR()
778 std::string ts = Util::DicomString(
779 Document::GetTransferSyntaxValue(ImplicitVRLittleEndian).c_str() );
781 ValEntry* tss = CopyValEntry(0x0002,0x0010);
787 void File::RestoreWriteFileType()
789 Archive->Restore(0x0002,0x0010);
792 void File::SetWriteToLibido()
794 ValEntry *oldRow = dynamic_cast<ValEntry *>
795 (HeaderInternal->GetDocEntryByNumber(0x0028, 0x0010));
796 ValEntry *oldCol = dynamic_cast<ValEntry *>
797 (HeaderInternal->GetDocEntryByNumber(0x0028, 0x0011));
799 if( oldRow && oldCol )
801 std::string rows, columns;
803 ValEntry *newRow=new ValEntry(oldRow->GetDictEntry());
804 ValEntry *newCol=new ValEntry(oldCol->GetDictEntry());
806 newRow->Copy(oldCol);
807 newCol->Copy(oldRow);
809 newRow->SetValue(oldCol->GetValue());
810 newCol->SetValue(oldRow->GetValue());
812 Archive->Push(newRow);
813 Archive->Push(newCol);
816 ValEntry *libidoCode = CopyValEntry(0x0008,0x0010);
817 libidoCode->SetValue("ACRNEMA_LIBIDO_1.1");
818 Archive->Push(libidoCode);
821 void File::SetWriteToNoLibido()
823 ValEntry *recCode = dynamic_cast<ValEntry *>
824 (HeaderInternal->GetDocEntryByNumber(0x0008,0x0010));
827 if( recCode->GetValue() == "ACRNEMA_LIBIDO_1.1" )
829 ValEntry *libidoCode = CopyValEntry(0x0008,0x0010);
830 libidoCode->SetValue("");
831 Archive->Push(libidoCode);
836 void File::RestoreWriteOfLibido()
838 Archive->Restore(0x0028,0x0010);
839 Archive->Restore(0x0028,0x0011);
840 Archive->Restore(0x0008,0x0010);
843 ValEntry* File::CopyValEntry(uint16_t group,uint16_t element)
845 DocEntry* oldE = HeaderInternal->GetDocEntryByNumber(group, element);
850 newE = new ValEntry(oldE->GetDictEntry());
855 newE = GetHeader()->NewValEntryByNumber(group,element);
861 BinEntry* File::CopyBinEntry(uint16_t group,uint16_t element)
863 DocEntry* oldE = HeaderInternal->GetDocEntryByNumber(group, element);
868 newE = new BinEntry(oldE->GetDictEntry());
873 newE = GetHeader()->NewBinEntryByNumber(group,element);
879 //-----------------------------------------------------------------------------
882 * \brief Factorization for various forms of constructors.
884 void File::Initialise()
886 WriteMode = WMODE_RAW;
887 WriteType = ExplicitVR;
889 PixelReadConverter = new PixelReadConvert;
890 PixelWriteConverter = new PixelWriteConvert;
891 Archive = new DocEntryArchive( HeaderInternal );
893 if ( HeaderInternal->IsReadable() )
895 PixelReadConverter->GrabInformationsFromHeader( HeaderInternal );
899 uint8_t* File::GetRaw()
901 uint8_t* raw = PixelReadConverter->GetRaw();
904 // The Raw image migth not be loaded yet:
905 std::ifstream* fp = HeaderInternal->OpenFile();
906 PixelReadConverter->ReadAndDecompressPixelData( fp );
908 HeaderInternal->CloseFile();
910 raw = PixelReadConverter->GetRaw();
913 dbg.Verbose(0, "File::GetRaw: read/decompress of "
914 "pixel data apparently went wrong.");
922 //-----------------------------------------------------------------------------
925 //-----------------------------------------------------------------------------
926 } // end namespace gdcm