X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=src%2FgdcmFile.cxx;h=18e2d7d07d68ff56b23200cf9e0b0766850d0728;hb=3a48fced2f0a527db189889c98892903e159e7bf;hp=c4672b6e9d3f9a021fa9817936a9e575aec2de40;hpb=4c8c80589b3770976ea27fc03b290b97db5da3e6;p=gdcm.git diff --git a/src/gdcmFile.cxx b/src/gdcmFile.cxx index c4672b6e..18e2d7d0 100644 --- a/src/gdcmFile.cxx +++ b/src/gdcmFile.cxx @@ -1,10 +1,10 @@ -/*========================================================================= + /*========================================================================= Program: gdcm Module: $RCSfile: gdcmFile.cxx,v $ Language: C++ - Date: $Date: 2004/07/30 11:40:13 $ - Version: $Revision: 1.117 $ + Date: $Date: 2004/09/20 18:14:23 $ + Version: $Revision: 1.126 $ Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de l'Image). All rights reserved. See Doc/License.txt or @@ -22,81 +22,252 @@ typedef std::pair IterHT; -//----------------------------------------------------------------------------- +//------------------------------------------------------------------------- // Constructor / Destructor /** * \ingroup gdcmFile - * \brief Constructor dedicated to writing a new DICOMV3 part10 compliant - * file (see SetFileName, SetDcmTag and Write) + * \brief Constructor dedicated to deal with the *pixels* area of a ACR/DICOMV3 + * file (gdcmHeader only deals with the ... header) * Opens (in read only and when possible) an existing file and checks * for DICOM compliance. Returns NULL on failure. + * It will be up to the user to load the pixels into memory + * (see GetImageData, GetImageDataRaw) * \note the in-memory representation of all available tags found in * the DICOM header is post-poned to first header information access. * This avoid a double parsing of public part of the header when - * one sets an a posteriori shadow dictionary (efficiency can be + * user sets an a posteriori shadow dictionary (efficiency can be * seen as a side effect). - * @param header file to be opened for reading datas - * @return + * @param header already built gdcmHeader */ gdcmFile::gdcmFile(gdcmHeader *header) { Header = header; SelfHeader = false; - PixelRead = -1; // no ImageData read yet. - - if (Header->IsReadable()) - { - SetPixelDataSizeFromHeader(); - } + SaveInitialValues(); } /** * \ingroup gdcmFile - * \brief Constructor dedicated to writing a new DICOMV3 part10 compliant - * file (see SetFileName, SetDcmTag and Write) + * \brief Constructor dedicated to deal with the *pixels* area of a ACR/DICOMV3 + * file (gdcmHeader only deals with the ... header) * Opens (in read only and when possible) an existing file and checks * for DICOM compliance. Returns NULL on failure. + * It will be up to the user to load the pixels into memory + * (see GetImageData, GetImageDataRaw) * \note the in-memory representation of all available tags found in * the DICOM header is post-poned to first header information access. * This avoid a double parsing of public part of the header when * one sets an a posteriori shadow dictionary (efficiency can be * seen as a side effect). * @param filename file to be opened for parsing - * @param exception_on_error whether we throw an exception or not - * @param ignore_shadow to allow skipping the shadow elements, - * to save memory space. */ -gdcmFile::gdcmFile(std::string const & filename, - bool exception_on_error, - bool ignore_shadow) +gdcmFile::gdcmFile(std::string const & filename ) { - Header = new gdcmHeader( filename, - exception_on_error, - ignore_shadow ); + Header = new gdcmHeader( filename ); SelfHeader = true; - PixelRead = -1; // no ImageData read yet. - - if ( Header->IsReadable() ) - { - SetPixelDataSizeFromHeader(); - } + SaveInitialValues(); } /** * \ingroup gdcmFile * \brief canonical destructor - * \note If the gdcmHeader is created by the gdcmFile, it is destroyed - * by the gdcmFile + * \note If the gdcmHeader was created by the gdcmFile constructor, + * it is destroyed by the gdcmFile */ gdcmFile::~gdcmFile() -{ +{ if( SelfHeader ) { delete Header; } Header = 0; + + DeleteInitialValues(); +} + +/** + * \ingroup gdcmFile + * \brief Sets some initial values for the Constructor + * \warning not end user intended + */ +void gdcmFile::SaveInitialValues() +{ + + PixelRead = -1; // no ImageData read yet. + LastAllocatedPixelDataLength = 0; + Pixel_Data = 0; + + InitialSpp = ""; + InitialPhotInt = ""; + InitialPlanConfig = ""; + InitialBitsAllocated = ""; + InitialHighBit = ""; + + InitialRedLUTDescr = 0; + InitialGreenLUTDescr = 0; + InitialBlueLUTDescr = 0; + InitialRedLUTData = 0; + InitialGreenLUTData = 0; + InitialBlueLUTData = 0; + + if ( Header->IsReadable() ) + { + SetPixelDataSizeFromHeader(); + + // the following values *may* be modified + // by gdcmFile::GetImageDataIntoVectorRaw + // we save their initial value. + InitialSpp = Header->GetEntryByNumber(0x0028,0x0002); + InitialPhotInt = Header->GetEntryByNumber(0x0028,0x0004); + InitialPlanConfig = Header->GetEntryByNumber(0x0028,0x0006); + + InitialBitsAllocated = Header->GetEntryByNumber(0x0028,0x0100); + InitialHighBit = Header->GetEntryByNumber(0x0028,0x0102); + + // the following entries *may* be removed from the H table + // (NOT deleted ...) by gdcmFile::GetImageDataIntoVectorRaw + // we keep a pointer on them. + InitialRedLUTDescr = Header->GetDocEntryByNumber(0x0028,0x1101); + InitialGreenLUTDescr = Header->GetDocEntryByNumber(0x0028,0x1102); + InitialBlueLUTDescr = Header->GetDocEntryByNumber(0x0028,0x1103); + + InitialRedLUTData = Header->GetDocEntryByNumber(0x0028,0x1201); + InitialGreenLUTData = Header->GetDocEntryByNumber(0x0028,0x1202); + InitialBlueLUTData = Header->GetDocEntryByNumber(0x0028,0x1203); + } } +/** + * \ingroup gdcmFile + * \brief restores some initial values + * \warning not end user intended + */ +void gdcmFile::RestoreInitialValues() +{ + if ( Header->IsReadable() ) + { + // the following values *may* have been modified + // by gdcmFile::GetImageDataIntoVectorRaw + // we restore their initial value. + if ( InitialSpp != "") + Header->SetEntryByNumber(InitialSpp,0x0028,0x0002); + if ( InitialPhotInt != "") + Header->SetEntryByNumber(InitialPhotInt,0x0028,0x0004); + if ( InitialPlanConfig != "") + + Header->SetEntryByNumber(InitialPlanConfig,0x0028,0x0006); + if ( InitialBitsAllocated != "") + Header->SetEntryByNumber(InitialBitsAllocated,0x0028,0x0100); + if ( InitialHighBit != "") + Header->SetEntryByNumber(InitialHighBit,0x0028,0x0102); + + // the following entries *may* be have been removed from the H table + // (NOT deleted ...) by gdcmFile::GetImageDataIntoVectorRaw + // we restore them. + + if (InitialRedLUTDescr) + Header->AddEntry(InitialRedLUTDescr); + if (InitialGreenLUTDescr) + Header->AddEntry(InitialGreenLUTDescr); + if (InitialBlueLUTDescr) + Header->AddEntry(InitialBlueLUTDescr); + + if (InitialRedLUTData) + Header->AddEntry(InitialBlueLUTDescr); + if (InitialGreenLUTData) + Header->AddEntry(InitialGreenLUTData); + if (InitialBlueLUTData) + Header->AddEntry(InitialBlueLUTData); + } +} + +/** + * \ingroup gdcmFile + * \brief delete initial values (il they were saved) + * of InitialLutDescriptors and InitialLutData + */ +void gdcmFile::DeleteInitialValues() +{ + +// InitialLutDescriptors and InitialLutData +// will have to be deleted if the don't belong any longer +// to the Header H table when the header is deleted... + + if ( InitialRedLUTDescr ) + delete InitialRedLUTDescr; + + if ( InitialGreenLUTDescr ) + delete InitialGreenLUTDescr; + + if ( InitialBlueLUTDescr ) + delete InitialBlueLUTDescr; + + if ( InitialRedLUTData ) + delete InitialRedLUTData; + + if ( InitialGreenLUTData != NULL) + delete InitialGreenLUTData; + + if ( InitialBlueLUTData != NULL) + delete InitialBlueLUTData; +} + +/** + * \ingroup gdcmFile + * \brief drop palette related initial values -if any- + * (InitialLutDescriptors and InitialLutData) + * out of header, to make it consistent with the Pixel_Data + * as it's loaded in memory + */ + +//FIXME : Should be nice, if we could let it here. +// will be moved to PixelData class +// Now, the job is done in gdcmHeader.cxx + + /* +void gdcmFile::DropInitialValues() +{ + gdcmHeader* h=GetHeader(); + if ( GetEntryByNumber(0x0028,0x0002).c_str()[0] == '3' ) + { + // if SamplesPerPixel = 3, sure we don't need any LUT ! + // Drop 0028|1101, 0028|1102, 0028|1103 + // Drop 0028|1201, 0028|1202, 0028|1203 + + gdcmDocEntry* e = h->GetDocEntryByNumber(0x0028,0x01101); + if (e) + { + h->RemoveEntryNoDestroy(e); + } + e = h->GetDocEntryByNumber(0x0028,0x1102); + if (e) + { + h->RemoveEntryNoDestroy(e); + } + e = h->GetDocEntryByNumber(0x0028,0x1103); + if (e) + { + h->RemoveEntryNoDestroy(e); + } + e = h->GetDocEntryByNumber(0x0028,0x01201); + if (e) + { + h->RemoveEntryNoDestroy(e); + } + e = h->GetDocEntryByNumber(0x0028,0x1202); + if (e) + { + h->RemoveEntryNoDestroy(e); + } + e = h->GetDocEntryByNumber(0x0028,0x1203); + if (e) + { + h->RemoveEntryNoDestroy(e); + } + } +} +*/ + //----------------------------------------------------------------------------- // Print @@ -105,11 +276,11 @@ gdcmFile::~gdcmFile() /** * \ingroup gdcmFile - * \brief computes the length (in bytes) to ALLOCATE to receive the + * \brief computes the length (in bytes) we must ALLOCATE to receive the * image(s) pixels (multiframes taken into account) * \warning : it is NOT the group 7FE0 length * (no interest for compressed images). - * @return length to allocate + * \warning : not end user intended ? */ void gdcmFile::SetPixelDataSizeFromHeader() { @@ -155,12 +326,13 @@ void gdcmFile::SetPixelDataSizeFromHeader() nb =16; } } - ImageDataSize = ImageDataSizeRaw = Header->GetXSize() * Header->GetYSize() + ImageDataSize = + ImageDataSizeRaw = Header->GetXSize() * Header->GetYSize() * Header->GetZSize() * (nb/8) * Header->GetSamplesPerPixel(); std::string str_PhotometricInterpretation = Header->GetEntryByNumber(0x0028,0x0004); - /*if ( str_PhotometricInterpretation == "PALETTE COLOR " )*/ + // if ( str_PhotometricInterpretation == "PALETTE COLOR " ), // pb when undealt Segmented Palette Color if ( Header->HasLUT() ) @@ -169,63 +341,59 @@ void gdcmFile::SetPixelDataSizeFromHeader() } } -/** - * \ingroup gdcmFile - * \brief Returns the size (in bytes) of required memory to hold - * the pixel data represented in this file. - * @return The size of pixel data in bytes. - */ -size_t gdcmFile::GetImageDataSize() -{ - return ImageDataSize; -} - -/** - * \ingroup gdcmFile - * \brief Returns the size (in bytes) of required memory to hold - * the pixel data represented in this file, when user DOESN'T want - * to get RGB pixels image when it's stored as a PALETTE COLOR image - * -the (vtk) user is supposed to know how deal with LUTs- - * \warning to be used with GetImagePixelsRaw() - * @return The size of pixel data in bytes. - */ -size_t gdcmFile::GetImageDataSizeRaw() -{ - return ImageDataSizeRaw; -} - /** * \ingroup gdcmFile - * \brief Allocates necessary memory, copies the pixel data - * (image[s]/volume[s]) to newly allocated zone. - * Transforms YBR pixels into RGB pixels if any - * Transforms 3 planes R, G, B into a single RGB Plane - * Transforms single Grey plane + 3 Palettes into a RGB Plane + * \brief - Allocates necessary memory, + * - Reads the pixels from disk (uncompress if necessary), + * - Transforms YBR pixels, if any, into RGB pixels + * - Transforms 3 planes R, G, B, if any, into a single RGB Plane + * - Transforms single Grey plane + 3 Palettes into a RGB Plane + * - Copies the pixel data (image[s]/volume[s]) to newly allocated zone. * @return Pointer to newly allocated pixel data. * NULL if alloc fails */ void *gdcmFile::GetImageData() { - // FIXME - // I need to deallocate PixelData before doing any allocation: - PixelData = new uint8_t[ImageDataSize]; - if ( PixelData ) + // FIXME (Mathieu) + // I need to deallocate Pixel_Data before doing any allocation: + + if ( Pixel_Data ) + if ( LastAllocatedPixelDataLength != ImageDataSize ) + free(Pixel_Data); + if ( !Pixel_Data ) + Pixel_Data = new uint8_t[ImageDataSize]; + + if ( Pixel_Data ) { - GetImageDataIntoVector(PixelData, ImageDataSize); - GetHeader()->SetEntryVoidAreaByNumber( PixelData, + LastAllocatedPixelDataLength = ImageDataSize; + + // we load the pixels (and transform grey level + LUT into RGB) + GetImageDataIntoVector(Pixel_Data, ImageDataSize); + + // We say the value *is* loaded. + GetHeader()->SetEntryByNumber( GDCM_BINLOADED, + GetHeader()->GetGrPixel(), GetHeader()->GetNumPixel()); + + // Will be 7fe0, 0010 in standard case + GetHeader()->SetEntryVoidAreaByNumber( Pixel_Data, GetHeader()->GetGrPixel(), GetHeader()->GetNumPixel()); } PixelRead = 0; // no PixelRaw - return PixelData; + return Pixel_Data; } /** * \ingroup gdcmFile - * \brief Copies at most MaxSize bytes of pixel data to caller's + * \brief + * Read the pixels from disk (uncompress if necessary), + * Transforms YBR pixels, if any, into RGB pixels + * Transforms 3 planes R, G, B, if any, into a single RGB Plane + * Transforms single Grey plane + 3 Palettes into a RGB Plane + * Copies at most MaxSize bytes of pixel data to caller allocated * memory space. - * \warning This function was designed to avoid people that want to build - * a volume from an image stack to need first to get the image pixels + * \warning This function allows people that want to build a volume + * from an image stack *not to* have, first to get the image pixels, * and then move them to the volume area. * It's absolutely useless for any VTK user since vtk chooses * to invert the lines of an image, that is the last line comes first @@ -243,9 +411,8 @@ void *gdcmFile::GetImageData() */ size_t gdcmFile::GetImageDataIntoVector (void* destination, size_t maxSize) { - //size_t l = GetImageDataIntoVectorRaw (destination, maxSize); GetImageDataIntoVectorRaw (destination, maxSize); - PixelRead = 0 ; // no PixelRaw + PixelRead = 0 ; // =0 : no ImageDataRaw if ( !Header->HasLUT() ) { return ImageDataSize; @@ -259,7 +426,6 @@ size_t gdcmFile::GetImageDataIntoVector (void* destination, size_t maxSize) if ( lutRGBA ) { int j; - //int l = ImageDataSizeRaw; //loss of precision // move Gray pixels to temp area memmove(newDest, destination, ImageDataSizeRaw); for (size_t i=0; iSetEntryByNumber(spp,0x0028,0x0002); - std::string rgb = "RGB "; // Photometric Interpretation + std::string rgb = "RGB "; // Photometric Interpretation Header->SetEntryByNumber(rgb,0x0028,0x0004); std::string planConfig = "0"; // Planar Configuration Header->SetEntryByNumber(planConfig,0x0028,0x0006); } - else //why is there a 'else' when an allocation failed ? - { - // need to make RGB Pixels (?) - // from grey Pixels (?!) - // and Gray Lut (!?!) - // or Segmented xxx Palette Color Lookup Table Data and so on - - // Oops! I get one (gdcm-US-ALOKA-16.dcm) - // No idea how to manage such an image + else // GetLUTRGBA() failed + { + // (gdcm-US-ALOKA-16.dcm), contains Segmented xxx Palette Color + // that are *more* than 65535 long ?!? + // No idea how to manage such an image ! + // Need to make RGB Pixels (?) from grey Pixels (?!) and Gray Lut (!?!) // It seems that *no Dicom Viewer* has any idea :-( - // Segmented xxx Palette Color are *more* than 65535 long ?!? - - std::string rgb = "MONOCHROME1 "; // Photometric Interpretation - Header->SetEntryByNumber(rgb,0x0028,0x0004); + + std::string photomInterp = "MONOCHROME1 "; // Photometric Interpretation + Header->SetEntryByNumber(photomInterp,0x0028,0x0004); } /// \todo Drop Palette Color out of the Header? @@ -307,35 +469,50 @@ size_t gdcmFile::GetImageDataIntoVector (void* destination, size_t maxSize) /** * \ingroup gdcmFile - * \brief Allocates necessary memory, copies the pixel data - * (image[s]/volume[s]) to newly allocated zone. - * Transforms YBR pixels into RGB pixels if any - * Transforms 3 planes R, G, B into a single RGB Plane + * \brief Allocates necessary memory, + * Transforms YBR pixels (if any) into RGB pixels + * Transforms 3 planes R, G, B (if any) into a single RGB Plane + * Copies the pixel data (image[s]/volume[s]) to newly allocated zone. * DOES NOT transform Grey plane + 3 Palettes into a RGB Plane * @return Pointer to newly allocated pixel data. * \ NULL if alloc fails */ void * gdcmFile::GetImageDataRaw () { - size_t imgDataSize = ImageDataSize; + size_t imgDataSize; if ( Header->HasLUT() ) - { /// \todo Let gdcmHeader user a chance to get the right value imgDataSize = ImageDataSizeRaw; - } + else + imgDataSize = ImageDataSize; + + // FIXME (Mathieu) + // I need to deallocate Pixel_Data before doing any allocation: + + if ( Pixel_Data ) + if ( LastAllocatedPixelDataLength != imgDataSize ) + free(Pixel_Data); + if ( !Pixel_Data ) + Pixel_Data = new uint8_t[imgDataSize]; - // FIXME - // I need to deallocate PixelData before doing any allocation: - PixelData = new uint8_t[imgDataSize]; - if ( PixelData ) + if ( Pixel_Data ) { - GetImageDataIntoVectorRaw(PixelData, ImageDataSize); - GetHeader()->SetEntryVoidAreaByNumber(PixelData, - GetHeader()->GetGrPixel(), GetHeader()->GetNumPixel()); + LastAllocatedPixelDataLength = imgDataSize; + + // we load the pixels ( grey level or RGB, but NO transformation) + GetImageDataIntoVectorRaw(Pixel_Data, imgDataSize); + + // We say the value *is* loaded. + GetHeader()->SetEntryByNumber( GDCM_BINLOADED, + GetHeader()->GetGrPixel(), GetHeader()->GetNumPixel()); + + // will be 7fe0, 0010 in standard cases + GetHeader()->SetEntryVoidAreaByNumber(Pixel_Data, + GetHeader()->GetGrPixel(), GetHeader()->GetNumPixel()); } PixelRead = 1; // PixelRaw - return PixelData; + return Pixel_Data; } /** @@ -365,8 +542,18 @@ void * gdcmFile::GetImageDataRaw () size_t gdcmFile::GetImageDataIntoVectorRaw (void *destination, size_t maxSize) { int nb, nbu, highBit, sign; + + // we save the initial values of the following + // in order to be able to restore the header in a disk-consistent state + // (if user asks twice to get the pixels from disk) + + if ( PixelRead != -1 ) // File was "read" before + { + RestoreInitialValues(); + } + PixelRead = 1 ; // PixelRaw - + if ( ImageDataSize > maxSize ) { dbg.Verbose(0, "gdcmFile::GetImageDataIntoVector: pixel data bigger" @@ -602,18 +789,23 @@ size_t gdcmFile::GetImageDataIntoVectorRaw (void *destination, size_t maxSize) } // now, it's an RGB image // Lets's write it in the Header + + // Droping Palette Color out of the Header + // has been moved to the Write process. - // CreateOrReplaceIfExist ? - - std::string spp = "3"; // Samples Per Pixel - std::string rgb = "RGB "; // Photometric Interpretation - std::string planConfig = "0"; // Planar Configuration + // TODO : move 'values' modification to the write process + // : save also (in order to be able to restore) + // : 'high bit' -when not equal to 'bits stored' + 1 + // : 'bits allocated', when it's equal to 12 ?! + std::string spp = "3"; // Samples Per Pixel + std::string photInt = "RGB "; // Photometric Interpretation + std::string planConfig = "0"; // Planar Configuration + Header->SetEntryByNumber(spp,0x0028,0x0002); - Header->SetEntryByNumber(rgb,0x0028,0x0004); + Header->SetEntryByNumber(photInt,0x0028,0x0004); Header->SetEntryByNumber(planConfig,0x0028,0x0006); - /// \todo Drop Palette Color out of the Header? return ImageDataSize; } @@ -622,7 +814,7 @@ size_t gdcmFile::GetImageDataIntoVectorRaw (void *destination, size_t maxSize) * \brief performs a shalow copy (not a deep copy) of the user given * pixel area. * 'image' Pixels are presented as C-like 2D arrays : line per line. - * 'volume'Pixels are presented as C-like 3D arrays : lane per plane + * 'volume'Pixels are presented as C-like 3D arrays : plane per plane * \warning user is kindly requested NOT TO 'free' the Pixel area * @param inData user supplied pixel area * @param expectedSize total image size, in Bytes @@ -632,10 +824,11 @@ size_t gdcmFile::GetImageDataIntoVectorRaw (void *destination, size_t maxSize) bool gdcmFile::SetImageData(void *inData, size_t expectedSize) { Header->SetImageDataSize( expectedSize ); - PixelData = inData; - ImageDataSize = expectedSize; +// FIXME : if already allocated, memory leak ! + Pixel_Data = inData; + ImageDataSize = ImageDataSizeRaw = expectedSize; PixelRead = 1; - +// FIXME : 7fe0, 0010 IS NOT set ... return true; } @@ -657,7 +850,7 @@ bool gdcmFile::WriteRawData(std::string const & fileName) printf("Fail to open (write) file [%s] \n", fileName.c_str()); return false; } - fwrite (PixelData, ImageDataSize, 1, fp1); + fwrite (Pixel_Data, ImageDataSize, 1, fp1); fclose (fp1); return true; @@ -801,7 +994,7 @@ bool gdcmFile::WriteBase (std::string const & fileName, FileType type) } // ----------------- End of Special Patch ---------------- - // fwrite(PixelData, ImageDataSize, 1, fp1); // should be useless, now + // fwrite(Pixel_Data, ImageDataSize, 1, fp1); // should be useless, now fclose (fp1); return true; @@ -837,7 +1030,7 @@ void gdcmFile::SwapZone(void *im, int swap, int lgr, int nb) case 4321: for(i=0; i < lgr/2; i++) { - im16[i]= (im16[i] >> 8) | (im16[i] << 8 ); + im16[i]= (im16[i] >> 8) | (im16[i] << 8 ); } break; default: @@ -1046,7 +1239,7 @@ bool gdcmFile::ReadPixelData(void *destination) if ( jpg2000 ) { // JPEG 2000 : call to ??? - res = (bool)gdcm_read_JPEG2000_file (fp,destination); // Not Yet written + res = gdcm_read_JPEG2000_file (fp,destination); // Not Yet written // ------------------------------------- endif (JPEG2000) } else if (jpgLossless) @@ -1064,12 +1257,12 @@ bool gdcmFile::ReadPixelData(void *destination) if ( Header->GetBitsStored() == 8) { // Reading Fragment pixels - res = (bool)gdcm_read_JPEG_file (fp,destination); + res = gdcm_read_JPEG_file (fp,destination); } else { // Reading Fragment pixels - res = (bool)gdcm_read_JPEG_file12 (fp,destination); + res = gdcm_read_JPEG_file12 (fp,destination); } // ------------------------------------- endif (JPEGLossy) }