X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=src%2FgdcmFile.cxx;h=8c3cb2796cfa1c0f98e232571c47caffcd74e807;hb=fd37aa842b5d31ca266b6bda8a77f3201d02338d;hp=ec0eb7d39ae94caba9033fe0f51820d82b33336b;hpb=8fa22a939771f727812c725d99ea5b75f56f0c71;p=gdcm.git diff --git a/src/gdcmFile.cxx b/src/gdcmFile.cxx index ec0eb7d3..8c3cb279 100644 --- a/src/gdcmFile.cxx +++ b/src/gdcmFile.cxx @@ -1,14 +1,14 @@ -/*========================================================================= + /*========================================================================= Program: gdcm Module: $RCSfile: gdcmFile.cxx,v $ Language: C++ - Date: $Date: 2004/06/28 16:00:18 $ - Version: $Revision: 1.114 $ + Date: $Date: 2004/09/27 08:39:07 $ + Version: $Revision: 1.131 $ Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de l'Image). All rights reserved. See Doc/License.txt or - http://www.creatis.insa-lyon.fr/Public/Gdcm/License.htm for details. + http://www.creatis.insa-lyon.fr/Public/Gdcm/License.html for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR @@ -22,89 +22,251 @@ 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 enable_sequences = true to allow the header - * to be parsed *inside* the SeQuences, - * when they have an actual length - * \warning enable_sequences *has to be* true for reading PAPYRUS 3.0 files - * @param ignore_shadow to allow skipping the shadow elements, - * to save memory space. - * \warning The TRUE value for this param has to be used - * with a FALSE value for the 'enable_sequence' param. - * ('public elements' may be embedded in 'shadow Sequences') */ -gdcmFile::gdcmFile(std::string const & filename, - bool exception_on_error, - bool enable_sequences, - bool ignore_shadow) +gdcmFile::gdcmFile(std::string const & filename ) { - Header = new gdcmHeader( filename, - exception_on_error, - enable_sequences, - 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 @@ -114,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() { @@ -164,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() ) @@ -178,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() +uint8_t* 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()->SetEntryBinAreaByNumber( 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 @@ -252,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; @@ -263,12 +421,11 @@ size_t gdcmFile::GetImageDataIntoVector (void* destination, size_t maxSize) // from Lut R + Lut G + Lut B uint8_t *newDest = new uint8_t[ImageDataSize]; uint8_t *a = (uint8_t *)destination; - uint8_t *lutRGBA = Header->GetLUTRGBA(); + uint8_t *lutRGBA = Header->GetLUTRGBA(); 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? @@ -316,36 +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 () +uint8_t* gdcmFile::GetImageDataRaw () { - size_t imgDataSize = ImageDataSize; + size_t imgDataSize; if ( Header->HasLUT() ) - { /// \todo Let gdcmHeader user a chance to get the right value - // ImageDataSize /= 3; //dangerous 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()->SetEntryBinAreaByNumber(Pixel_Data, + GetHeader()->GetGrPixel(), GetHeader()->GetNumPixel()); } PixelRead = 1; // PixelRaw - return PixelData; + return Pixel_Data; } /** @@ -372,11 +539,21 @@ void * gdcmFile::GetImageDataRaw () * @return On success, the number of bytes actually copied. Zero on * failure e.g. MaxSize is lower than necessary. */ -size_t gdcmFile::GetImageDataIntoVectorRaw (void *destination, size_t maxSize) +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" @@ -473,9 +650,9 @@ size_t gdcmFile::GetImageDataIntoVectorRaw (void *destination, size_t maxSize) } else if ( nb == 32 ) { - guint32 mask = 0xffffffff; + uint32_t mask = 0xffffffff; mask = mask >> (nb - nbu); - guint32 *deb = (guint32 *)destination; + uint32_t *deb = (uint32_t *)destination; for(int i = 0; i> (nbu - highBit - 1)) & mask; @@ -488,14 +665,15 @@ size_t gdcmFile::GetImageDataIntoVectorRaw (void *destination, size_t maxSize) return 0; } } -// DO NOT remove this code commented out. -// Nobody knows what's expecting you ... -// Just to 'see' what was actually read on disk :-( - -// FILE * f2; -// f2 = fopen("SpuriousFile.RAW","wb"); -// fwrite(destination,ImageDataSize,1,f2); -// fclose(f2); +/// \todo +/// DO NOT remove this code commented out. +/// Nobody knows what's expecting you ... +/// Just to 'see' what was actually read on disk :-( +/// +/// FILE* f2; +/// f2 = fopen("SpuriousFile.RAW","wb"); +/// fwrite(destination,ImageDataSize,1,f2); +/// fclose(f2); // Deal with the color // ------------------- @@ -612,18 +790,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; } @@ -632,20 +815,21 @@ 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 * * @return boolean */ -bool gdcmFile::SetImageData(void *inData, size_t expectedSize) +bool gdcmFile::SetImageData(uint8_t* 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; } @@ -661,14 +845,13 @@ bool gdcmFile::SetImageData(void *inData, size_t expectedSize) bool gdcmFile::WriteRawData(std::string const & fileName) { - FILE *fp1; - fp1 = fopen(fileName.c_str(), "wb"); + FILE* fp1 = fopen(fileName.c_str(), "wb"); if (fp1 == NULL) { 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; @@ -736,14 +919,12 @@ bool gdcmFile::WriteAcr (std::string const & fileName) */ bool gdcmFile::WriteBase (std::string const & fileName, FileType type) { - FILE *fp1; - if ( PixelRead == -1 && type != gdcmExplicitVR) { return false; } - fp1 = fopen(fileName.c_str(), "wb"); + FILE* fp1 = fopen(fileName.c_str(), "wb"); if (fp1 == NULL) { printf("Failed to open (write) File [%s] \n", fileName.c_str()); @@ -785,9 +966,8 @@ bool gdcmFile::WriteBase (std::string const & fileName, FileType type) uint16_t grPixel = Header->GetGrPixel(); uint16_t numPixel = Header->GetNumPixel();; - gdcmDocEntry* PixelElement; - - PixelElement = GetHeader()->GetDocEntryByNumber(grPixel, numPixel); + gdcmDocEntry* PixelElement = + GetHeader()->GetDocEntryByNumber(grPixel, numPixel); if ( PixelRead == 1 ) { @@ -815,7 +995,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; @@ -832,7 +1012,7 @@ bool gdcmFile::WriteBase (std::string const & fileName, FileType type) * @param lgr Area Length * @param nb Pixels Bit number */ -void gdcmFile::SwapZone(void *im, int swap, int lgr, int nb) +void gdcmFile::SwapZone(void* im, int swap, int lgr, int nb) { int i; @@ -851,7 +1031,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: @@ -914,9 +1094,9 @@ void gdcmFile::SwapZone(void *im, int swap, int lgr, int nb) * @param destination where the pixel data should be stored. * */ -bool gdcmFile::ReadPixelData(void *destination) +bool gdcmFile::ReadPixelData(void* destination) { - FILE *fp = Header->OpenFile(); + FILE* fp = Header->OpenFile(); if ( !fp ) { @@ -980,7 +1160,7 @@ bool gdcmFile::ReadPixelData(void *destination) // ---------------------- Run Length Encoding if ( Header->IsRLELossLessTransferSyntax() ) { - bool res = (bool)gdcm_read_RLE_file (fp,destination); + bool res = gdcm_read_RLE_file (fp,destination); Header->CloseFile(); return res; } @@ -1060,7 +1240,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) @@ -1078,12 +1258,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) }