X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=src%2FgdcmFileHelper.cxx;h=c44839ede63fad2fd032506a68d3eb7c7f13e641;hb=33b1eec26f02131242fbfdef52184b24763cf4e6;hp=1e31cd1ca71d20b5058799defa0924a162bc8127;hpb=f12e51a575034ba832a0ff3b9f9c5ba219fc8562;p=gdcm.git diff --git a/src/gdcmFileHelper.cxx b/src/gdcmFileHelper.cxx index 1e31cd1c..c44839ed 100644 --- a/src/gdcmFileHelper.cxx +++ b/src/gdcmFileHelper.cxx @@ -3,8 +3,9 @@ Program: gdcm Module: $RCSfile: gdcmFileHelper.cxx,v $ Language: C++ - Date: $Date: 2005/02/23 09:54:59 $ - Version: $Revision: 1.20 $ + + Date: $Date: 2005/11/29 17:21:35 $ + Version: $Revision: 1.84 $ Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de l'Image). All rights reserved. See Doc/License.txt or @@ -22,21 +23,98 @@ #include "gdcmDocument.h" #include "gdcmDebug.h" #include "gdcmUtil.h" -#include "gdcmBinEntry.h" -#include "gdcmValEntry.h" #include "gdcmSeqEntry.h" #include "gdcmSQItem.h" -#include "gdcmContentEntry.h" +#include "gdcmDataEntry.h" #include "gdcmFile.h" #include "gdcmPixelReadConvert.h" #include "gdcmPixelWriteConvert.h" #include "gdcmDocEntryArchive.h" #include "gdcmDictSet.h" +#include "gdcmOrientation.h" #include +/* +// ----------------------------- WARNING ------------------------- + +These lines will be moved to the document-to-be 'User's Guide' + +// To read an image, user needs a gdcm::File +gdcm::File *f = new gdcm::File(fileName); +// or (advanced) : +// user may also decide he doesn't want to load some parts of the header +gdcm::File *f = new gdcm::File(); +f->SetFileName(fileName); + f->SetLoadMode(LD_NOSEQ); // or + f->SetLoadMode(LD_NOSHADOW); // or + f->SetLoadMode(LD_NOSEQ | LD_NOSHADOW); // or + f->SetLoadMode(LD_NOSHADOWSEQ); +f->Load(); + +// user can now check some values +std::string v = f->GetEntryValue(groupNb,ElementNb); + +// to get the pixels, user needs a gdcm::FileHelper +gdcm::FileHelper *fh = new gdcm::FileHelper(f); +// user may ask not to convert Palette to RGB +uint8_t *pixels = fh->GetImageDataRaw(); +int imageLength = fh->GetImageDataRawSize(); +// He can now use the pixels, create a new image, ... +uint8_t *userPixels = ... + +To re-write the image, user re-uses the gdcm::FileHelper + +fh->SetImageData( userPixels, userPixelsLength); +fh->SetTypeToRaw(); // Even if it was possible to convert Palette to RGB + // (WriteMode is set) + +fh->SetWriteTypeToDcmExpl(); // he wants Explicit Value Representation + // Little Endian is the default + // no other value is allowed + (-->SetWriteType(ExplicitVR);) + -->WriteType = ExplicitVR; +fh->Write(newFileName); // overwrites the file, if any + +// or : +fh->WriteDcmExplVR(newFileName); + + +// ----------------------------- WARNING ------------------------- + +These lines will be moved to the document-to-be 'Developer's Guide' + +WriteMode : WMODE_RAW / WMODE_RGB +WriteType : ImplicitVR, ExplicitVR, ACR, ACR_LIBIDO + +fh1->Write(newFileName); + SetWriteFileTypeToImplicitVR() / SetWriteFileTypeToExplicitVR(); + (modifies TransferSyntax) + SetWriteToRaw(); / SetWriteToRGB(); + (modifies, when necessary : photochromatic interpretation, + samples per pixel, Planar configuration, + bits allocated, bits stored, high bit -ACR 24 bits- + Pixels element VR, pushes out the LUT ) + CheckWriteIntegrity(); + (checks user given pixels length) + FileInternal->Write(fileName,WriteType) + fp = opens file(fileName); + ComputeGroup0002Length( ); + BitsAllocated 12->16 + RemoveEntry(palettes, etc) + Document::WriteContent(fp, writetype); + RestoreWrite(); + (moves back to the File all the archived elements) + RestoreWriteFileType(); + (pushes back group 0002, with TransferSyntax) +*/ + + + + namespace gdcm { +typedef std::map GroupHT; // Hash Table //------------------------------------------------------------------------- // Constructor / Destructor /** @@ -45,6 +123,7 @@ namespace gdcm * 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 + * ( GetImageDataSize() + GetImageData() methods) * \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 @@ -52,9 +131,8 @@ namespace gdcm * seen as a side effect). */ FileHelper::FileHelper( ) -{ - FileInternal = new File( ); - SelfHeader = true; +{ + FileInternal = File::New( ); Initialize(); } @@ -64,6 +142,7 @@ FileHelper::FileHelper( ) * 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 + * ( GetImageDataSize() + GetImageData() methods) * \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 @@ -73,29 +152,15 @@ FileHelper::FileHelper( ) */ FileHelper::FileHelper(File *header) { - FileInternal = header; - SelfHeader = false; - Initialize(); -} + gdcmAssertMacro(header); -/** - * \brief Constructor dedicated to deal with the *pixels* area of a ACR/DICOMV3 - * file (gdcm::File 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 - * \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 - */ -FileHelper::FileHelper(std::string const &filename ) -{ - FileInternal = new File( filename ); - SelfHeader = true; + FileInternal = header; + FileInternal->Register(); Initialize(); + if ( FileInternal->IsReadable() ) + { + PixelReadConverter->GrabInformationsFromFile( FileInternal, this ); + } } /** @@ -105,98 +170,128 @@ FileHelper::FileHelper(std::string const &filename ) */ FileHelper::~FileHelper() { - if( PixelReadConverter ) + if ( PixelReadConverter ) { delete PixelReadConverter; } - if( PixelWriteConverter ) + if ( PixelWriteConverter ) { delete PixelWriteConverter; } - if( Archive ) + if ( Archive ) { delete Archive; } - if( SelfHeader ) - { - delete FileInternal; - } - FileInternal = 0; + FileInternal->Unregister(); } //----------------------------------------------------------------------------- // Public + /** - * \brief Accesses an existing DocEntry (i.e. a Dicom Element) - * through it's (group, element) and modifies it's content with - * the given value. + * \brief Sets the LoadMode of the internal gdcm::File as a boolean string. + * NO_SEQ, NO_SHADOW, NO_SHADOWSEQ ... (nothing more, right now) + * WARNING : before using NO_SHADOW, be sure *all* your files + * contain accurate values in the 0x0000 element (if any) + * of *each* Shadow Group. The parser will fail if the size is wrong ! + * @param loadMode Load mode to be used + */ +void FileHelper::SetLoadMode(int loadMode) +{ + GetFile()->SetLoadMode( loadMode ); +} +/** + * \brief Sets the LoadMode of the internal gdcm::File + * @param fileName name of the file to be open + */ +void FileHelper::SetFileName(std::string const &fileName) +{ + FileInternal->SetFileName( fileName ); +} + +/** + * \brief Loader + * @return false if file cannot be open or no swap info was found, + * or no tag was found. + */ +bool FileHelper::Load() +{ + if ( !FileInternal->Load() ) + return false; + + PixelReadConverter->GrabInformationsFromFile( FileInternal, this ); + return true; +} + +/** + * \brief Accesses an existing DataEntry through it's (group, element) + * and modifies it's content with the given value. * @param content new value (string) to substitute with * @param group group number of the Dicom Element to modify * @param elem element number of the Dicom Element to modify - * \return false if DocEntry not found + * \return false if DataEntry not found */ -bool FileHelper::SetValEntry(std::string const &content, - uint16_t group, uint16_t elem) +bool FileHelper::SetEntryString(std::string const &content, + uint16_t group, uint16_t elem) { - return FileInternal->SetValEntry(content, group, elem); + return FileInternal->SetEntryString(content, group, elem); } /** - * \brief Accesses an existing DocEntry (i.e. a Dicom Element) - * through it's (group, element) and modifies it's content with - * the given value. + * \brief Accesses an existing DataEntry through it's (group, element) + * and modifies it's content with the given value. * @param content new value (void* -> uint8_t*) to substitute with * @param lgth new value length * @param group group number of the Dicom Element to modify * @param elem element number of the Dicom Element to modify - * \return false if DocEntry not found + * \return false if DataEntry not found */ -bool FileHelper::SetBinEntry(uint8_t *content, int lgth, - uint16_t group, uint16_t elem) +bool FileHelper::SetEntryBinArea(uint8_t *content, int lgth, + uint16_t group, uint16_t elem) { - return FileInternal->SetBinEntry(content, lgth, group, elem); + return FileInternal->SetEntryBinArea(content, lgth, group, elem); } /** - * \brief Modifies the value of a given DocEntry (Dicom entry) - * when it exists. Creates it with the given value when unexistant. - * @param content (string)value to be set + * \brief Modifies the value of a given DataEntry when it exists. + * Creates it with the given value when unexistant. + * @param content (string) value to be set * @param group Group number of the Entry * @param elem Element number of the Entry - * \return pointer to the modified/created Dicom entry (NULL when creation + * \return pointer to the modified/created DataEntry (NULL when creation * failed). */ -ValEntry *FileHelper::InsertValEntry(std::string const &content, - uint16_t group, uint16_t elem) +DataEntry *FileHelper::InsertEntryString(std::string const &content, + uint16_t group, uint16_t elem) { - return FileInternal->InsertValEntry(content,group,elem); + return FileInternal->InsertEntryString(content, group, elem); } /** - * \brief Modifies the value of a given DocEntry (Dicom entry) - * when it exists. Creates it with the given value when unexistant. + * \brief Modifies the value of a given DataEntry when it exists. + * Creates it with the given value when unexistant. * A copy of the binArea is made to be kept in the Document. * @param binArea (binary)value to be set * @param lgth new value length * @param group Group number of the Entry * @param elem Element number of the Entry - * \return pointer to the modified/created Dicom entry (NULL when creation + * \return pointer to the modified/created DataEntry (NULL when creation * failed). */ -BinEntry *FileHelper::InsertBinEntry(uint8_t *binArea, int lgth, - uint16_t group, uint16_t elem) +DataEntry *FileHelper::InsertEntryBinArea(uint8_t *binArea, int lgth, + uint16_t group, uint16_t elem) { - return FileInternal->InsertBinEntry(binArea, lgth, group, elem); + return FileInternal->InsertEntryBinArea(binArea, lgth, group, elem); } /** - * \brief Modifies the value of a given DocEntry (Dicom entry) - * when it exists. Creates it, empty (?!) when unexistant. + * \brief Adds an empty SeqEntry + * (remove any existing entry with same group,elem) * @param group Group number of the Entry * @param elem Element number of the Entry - * \return pointer to the modified/created Dicom entry (NULL when creation + * \return pointer to the created SeqEntry (NULL when creation * failed). */ SeqEntry *FileHelper::InsertSeqEntry(uint16_t group, uint16_t elem) @@ -218,12 +313,11 @@ size_t FileHelper::GetImageDataSize() { return PixelWriteConverter->GetUserDataSize(); } - return PixelReadConverter->GetRGBSize(); } /** - * \brief Get the size of the image data + * \brief Get the size of the image data. * If the image could be converted to RGB using a LUT, * this transformation is not taken into account by GetImageDataRawSize * (use GetImageDataSize if you wish) @@ -235,18 +329,19 @@ size_t FileHelper::GetImageDataRawSize() { return PixelWriteConverter->GetUserDataSize(); } - return PixelReadConverter->GetRawSize(); } /** - * \brief - Allocates necessary memory, + * \brief brings pixels into memory : + * - 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. + * (uint8_t is just for prototyping. feel free to cast) * NULL if alloc fails */ uint8_t *FileHelper::GetImageData() @@ -274,12 +369,14 @@ uint8_t *FileHelper::GetImageData() } /** - * \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 + * \brief brings pixels into memory : + * - 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. + * (uint8_t is just for prototyping. feel free to cast) * NULL if alloc fails */ uint8_t *FileHelper::GetImageDataRaw () @@ -287,15 +384,17 @@ uint8_t *FileHelper::GetImageDataRaw () return GetRaw(); } -/** - * \brief - * Read the pixels from disk (uncompress if necessary), +#ifndef GDCM_LEGACY_REMOVE +/* + * \ brief Useless function, since PixelReadConverter forces us + * copy the Pixels anyway. + * 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 at most MaxSize bytes of pixel data to caller allocated * memory space. - * \warning This function allows people that want to build a volume + * \ 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 @@ -304,12 +403,12 @@ uint8_t *FileHelper::GetImageDataRaw () * to load the image line by line, starting from the end. * VTK users have to call GetImageData * - * @param destination Address (in caller's memory space) at which the + * @ param destination Address (in caller's memory space) at which the * pixel data should be copied - * @param maxSize Maximum number of bytes to be copied. When MaxSize + * @ param maxSize Maximum number of bytes to be copied. When MaxSize * is not sufficient to hold the pixel data the copy is not * executed (i.e. no partial copy). - * @return On success, the number of bytes actually copied. Zero on + * @ return On success, the number of bytes actually copied. Zero on * failure e.g. MaxSize is lower than necessary. */ size_t FileHelper::GetImageDataIntoVector (void *destination, size_t maxSize) @@ -340,13 +439,17 @@ size_t FileHelper::GetImageDataIntoVector (void *destination, size_t maxSize) return 0; } memcpy( destination, - (void*)PixelReadConverter->GetRaw(), + (void *)PixelReadConverter->GetRaw(), PixelReadConverter->GetRawSize() ); return PixelReadConverter->GetRawSize(); } +#endif /** - * \brief Set the image data defined by the user, BUT WITHOUT COPYING THE DATA. + * \brief Points the internal pointer to the callers inData + * image representation, BUT WITHOUT COPYING THE DATA. + * 'image' Pixels are presented as C-like 2D arrays : line per line. + * 'volume'Pixels are presented as C-like 3D arrays : plane per plane * \warning Since the pixels are not copied, it is the caller's responsability * not to deallocate its data before gdcm uses them (e.g. with * the Write() method ) @@ -361,11 +464,8 @@ void FileHelper::SetImageData(uint8_t *inData, size_t expectedSize) } /** - * \brief Set the image data defined by the user, BUT WITHOUT COPYING THE DATA. + * \brief Set the image data defined by the user * \warning When writting the file, this data are get as default data to write - * \warning Since the pixels are not copied, it is the caller's responsability - * not to deallocate its data before gdcm uses them (e.g. with - * the Write() method ) * @param inData user supplied pixel area (uint8_t* is just for the compiler. * user is allowed to pass any kind of pixels since the size is * given in bytes) @@ -435,9 +535,27 @@ size_t FileHelper::GetRawDataSize() */ uint8_t* FileHelper::GetLutRGBA() { + if ( PixelReadConverter->GetLutRGBA() ==0 ) + PixelReadConverter->BuildLUTRGBA(); return PixelReadConverter->GetLutRGBA(); } +/** + * \brief Access to the underlying \ref PixelReadConverter RGBA LUT Item Number + */ +int FileHelper::GetLutItemNumber() +{ + return PixelReadConverter->GetLutItemNumber(); +} + +/** + * \brief Access to the underlying \ref PixelReadConverter RGBA LUT Item Size + */ +int FileHelper::GetLutItemSize() +{ + return PixelReadConverter->GetLutItemSize(); +} + /** * \brief Writes on disk A SINGLE Dicom file * NO test is performed on processor "Endiannity". @@ -448,26 +566,26 @@ uint8_t* FileHelper::GetLutRGBA() */ bool FileHelper::WriteRawData(std::string const &fileName) { - std::ofstream fp1(fileName.c_str(), std::ios::out | std::ios::binary ); + std::ofstream fp1(fileName.c_str(), std::ios::out | std::ios::binary ); if (!fp1) { gdcmWarningMacro( "Fail to open (write) file:" << fileName.c_str()); return false; } - if( PixelWriteConverter->GetUserData() ) + if ( PixelWriteConverter->GetUserData() ) { - fp1.write( (char*)PixelWriteConverter->GetUserData(), + fp1.write( (char *)PixelWriteConverter->GetUserData(), PixelWriteConverter->GetUserDataSize() ); } else if ( PixelReadConverter->GetRGB() ) { - fp1.write( (char*)PixelReadConverter->GetRGB(), + fp1.write( (char *)PixelReadConverter->GetRGB(), PixelReadConverter->GetRGBSize()); } else if ( PixelReadConverter->GetRaw() ) { - fp1.write( (char*)PixelReadConverter->GetRaw(), + fp1.write( (char *)PixelReadConverter->GetRaw(), PixelReadConverter->GetRawSize()); } else @@ -483,7 +601,7 @@ bool FileHelper::WriteRawData(std::string const &fileName) /** * \brief Writes on disk A SINGLE Dicom file, * using the Implicit Value Representation convention - * NO test is performed on processor "Endiannity". + * NO test is performed on processor "Endianity". * @param fileName name of the file to be created * (any already existing file is overwritten) * @return false if write fails @@ -542,20 +660,30 @@ bool FileHelper::Write(std::string const &fileName) { case ImplicitVR: SetWriteFileTypeToImplicitVR(); - CheckMandatoryElements(); break; + case Unknown: // should never happen; ExplicitVR is the default value case ExplicitVR: SetWriteFileTypeToExplicitVR(); - CheckMandatoryElements(); break; case ACR: case ACR_LIBIDO: + // NOTHING is done here just for LibIDO. + // Just to avoid further trouble if user creates a file ex-nihilo, + // wants to write it as an ACR-NEMA file, + // and forgets to create any Entry belonging to group 0008 + // (shame on him !) + // We add Recognition Code (RET) + if ( ! FileInternal->GetDataEntry(0x0008, 0x0010) ) + FileInternal->InsertEntryString("ACR-NEMA V1.0 ", 0x0008, 0x0010); SetWriteFileTypeToACR(); + // SetWriteFileTypeToImplicitVR(); // ACR IS implicit VR ! + break; + case JPEG: + SetWriteFileTypeToJPEG(); + std::cerr << "Writting as JPEG" << std::endl; break; - default: - SetWriteFileTypeToExplicitVR(); - CheckMandatoryElements(); } + CheckMandatoryElements(); // -------------------------------------------------------------- // Special Patch to allow gdcm to re-write ACR-LibIDO formated images @@ -565,7 +693,8 @@ bool FileHelper::Write(std::string const &fileName) // just before writting ... /// \todo the best trick would be *change* the recognition code /// but pb expected if user deals with, e.g. COMPLEX images - if( WriteType == ACR_LIBIDO ) + + if ( WriteType == ACR_LIBIDO ) { SetWriteToLibido(); } @@ -586,13 +715,15 @@ bool FileHelper::Write(std::string const &fileName) } bool check = CheckWriteIntegrity(); // verifies length - if(check) + if (WriteType == JPEG ) check = true; + if (check) { check = FileInternal->Write(fileName,WriteType); } RestoreWrite(); RestoreWriteFileType(); + RestoreWriteMandatory(); // -------------------------------------------------------------- // Special Patch to allow gdcm to re-write ACR-LibIDO formated images @@ -617,27 +748,30 @@ bool FileHelper::Write(std::string const &fileName) */ bool FileHelper::CheckWriteIntegrity() { - if(PixelWriteConverter->GetUserData()) + if ( PixelWriteConverter->GetUserData() ) { int numberBitsAllocated = FileInternal->GetBitsAllocated(); if ( numberBitsAllocated == 0 || numberBitsAllocated == 12 ) { + gdcmWarningMacro( "numberBitsAllocated changed from " + << numberBitsAllocated << " to 16 " + << " for consistency purpose" ); numberBitsAllocated = 16; } size_t decSize = FileInternal->GetXSize() - * FileInternal->GetYSize() - * FileInternal->GetZSize() - * ( numberBitsAllocated / 8 ) - * FileInternal->GetSamplesPerPixel(); + * FileInternal->GetYSize() + * FileInternal->GetZSize() + * FileInternal->GetSamplesPerPixel() + * ( numberBitsAllocated / 8 ); size_t rgbSize = decSize; - if( FileInternal->HasLUT() ) + if ( FileInternal->HasLUT() ) rgbSize = decSize * 3; switch(WriteMode) { case WMODE_RAW : - if( decSize!=PixelWriteConverter->GetUserDataSize() ) + if ( decSize!=PixelWriteConverter->GetUserDataSize() ) { gdcmWarningMacro( "Data size (Raw) is incorrect. Should be " << decSize << " / Found :" @@ -646,7 +780,7 @@ bool FileHelper::CheckWriteIntegrity() } break; case WMODE_RGB : - if( rgbSize!=PixelWriteConverter->GetUserDataSize() ) + if ( rgbSize!=PixelWriteConverter->GetUserDataSize() ) { gdcmWarningMacro( "Data size (RGB) is incorrect. Should be " << decSize << " / Found " @@ -656,7 +790,7 @@ bool FileHelper::CheckWriteIntegrity() break; } } - + return true; } @@ -667,39 +801,42 @@ bool FileHelper::CheckWriteIntegrity() */ void FileHelper::SetWriteToRaw() { - if( FileInternal->GetNumberOfScalarComponents() == 3 - && !FileInternal->HasLUT()) + if ( FileInternal->GetNumberOfScalarComponents() == 3 + && !FileInternal->HasLUT() ) { SetWriteToRGB(); } else { - ValEntry *photInt = CopyValEntry(0x0028,0x0004); - if(FileInternal->HasLUT()) + DataEntry *photInt = CopyDataEntry(0x0028,0x0004); + if (FileInternal->HasLUT() ) { - photInt->SetValue("PALETTE COLOR "); + photInt->SetString("PALETTE COLOR "); } else { - photInt->SetValue("MONOCHROME2 "); + photInt->SetString("MONOCHROME2 "); } PixelWriteConverter->SetReadData(PixelReadConverter->GetRaw(), PixelReadConverter->GetRawSize()); std::string vr = "OB"; - if( FileInternal->GetBitsAllocated()>8 ) + if ( FileInternal->GetBitsAllocated()>8 ) vr = "OW"; - if( FileInternal->GetBitsAllocated()==24 ) // For RGB ACR files + if ( FileInternal->GetBitsAllocated()==24 ) // For RGB ACR files vr = "OB"; - BinEntry *pixel = - CopyBinEntry(GetFile()->GetGrPixel(),GetFile()->GetNumPixel(),vr); - pixel->SetValue(GDCM_BINLOADED); + DataEntry *pixel = + CopyDataEntry(GetFile()->GetGrPixel(),GetFile()->GetNumPixel(),vr); + pixel->SetFlag(DataEntry::FLAG_PIXELDATA); pixel->SetBinArea(PixelWriteConverter->GetData(),false); pixel->SetLength(PixelWriteConverter->GetDataSize()); Archive->Push(photInt); Archive->Push(pixel); + + photInt->Delete(); + pixel->Delete(); } } @@ -712,20 +849,20 @@ void FileHelper::SetWriteToRaw() */ void FileHelper::SetWriteToRGB() { - if(FileInternal->GetNumberOfScalarComponents()==3) + if ( FileInternal->GetNumberOfScalarComponents()==3 ) { PixelReadConverter->BuildRGBImage(); - ValEntry *spp = CopyValEntry(0x0028,0x0002); - spp->SetValue("3 "); + DataEntry *spp = CopyDataEntry(0x0028,0x0002); + spp->SetString("3 "); - ValEntry *planConfig = CopyValEntry(0x0028,0x0006); - planConfig->SetValue("0 "); + DataEntry *planConfig = CopyDataEntry(0x0028,0x0006); + planConfig->SetString("0 "); - ValEntry *photInt = CopyValEntry(0x0028,0x0004); - photInt->SetValue("RGB "); + DataEntry *photInt = CopyDataEntry(0x0028,0x0004); + photInt->SetString("RGB "); - if(PixelReadConverter->GetRGB()) + if ( PixelReadConverter->GetRGB() ) { PixelWriteConverter->SetReadData(PixelReadConverter->GetRGB(), PixelReadConverter->GetRGBSize()); @@ -737,13 +874,13 @@ void FileHelper::SetWriteToRGB() } std::string vr = "OB"; - if( FileInternal->GetBitsAllocated()>8 ) + if ( FileInternal->GetBitsAllocated()>8 ) vr = "OW"; - if( FileInternal->GetBitsAllocated()==24 ) // For RGB ACR files + if ( FileInternal->GetBitsAllocated()==24 ) // For RGB ACR files vr = "OB"; - BinEntry *pixel = - CopyBinEntry(GetFile()->GetGrPixel(),GetFile()->GetNumPixel(),vr); - pixel->SetValue(GDCM_BINLOADED); + DataEntry *pixel = + CopyDataEntry(GetFile()->GetGrPixel(),GetFile()->GetNumPixel(),vr); + pixel->SetFlag(DataEntry::FLAG_PIXELDATA); pixel->SetBinArea(PixelWriteConverter->GetData(),false); pixel->SetLength(PixelWriteConverter->GetDataSize()); @@ -752,6 +889,11 @@ void FileHelper::SetWriteToRGB() Archive->Push(photInt); Archive->Push(pixel); + spp->Delete(); + planConfig->Delete(); + photInt->Delete(); + pixel->Delete(); + // Remove any LUT Archive->Push(0x0028,0x1101); Archive->Push(0x0028,0x1102); @@ -760,23 +902,30 @@ void FileHelper::SetWriteToRGB() Archive->Push(0x0028,0x1202); Archive->Push(0x0028,0x1203); + // push out Palette Color Lookup Table UID, if any + Archive->Push(0x0028,0x1199); + // For old '24 Bits' ACR-NEMA // Thus, we have a RGB image and the bits allocated = 24 and // samples per pixels = 1 (in the read file) - if(FileInternal->GetBitsAllocated()==24) + if ( FileInternal->GetBitsAllocated()==24 ) { - ValEntry *bitsAlloc = CopyValEntry(0x0028,0x0100); - bitsAlloc->SetValue("8 "); + DataEntry *bitsAlloc = CopyDataEntry(0x0028,0x0100); + bitsAlloc->SetString("8 "); - ValEntry *bitsStored = CopyValEntry(0x0028,0x0101); - bitsStored->SetValue("8 "); + DataEntry *bitsStored = CopyDataEntry(0x0028,0x0101); + bitsStored->SetString("8 "); - ValEntry *highBit = CopyValEntry(0x0028,0x0102); - highBit->SetValue("7 "); + DataEntry *highBit = CopyDataEntry(0x0028,0x0102); + highBit->SetString("7 "); Archive->Push(bitsAlloc); Archive->Push(bitsStored); Archive->Push(highBit); + + bitsAlloc->Delete(); + bitsStored->Delete(); + highBit->Delete(); } } else @@ -808,6 +957,10 @@ void FileHelper::RestoreWrite() Archive->Restore(0x0028,0x1202); Archive->Restore(0x0028,0x1203); + // For the Palette Color Lookup Table UID + Archive->Restore(0x0028,0x1203); + + // group 0002 may be pushed out for ACR-NEMA writting purposes Archive->Restore(0x0002,0x0000); Archive->Restore(0x0002,0x0001); @@ -834,7 +987,7 @@ void FileHelper::SetWriteFileTypeToACR() Archive->Push(0x0002,0x0001); Archive->Push(0x0002,0x0002); Archive->Push(0x0002,0x0003); - Archive->Push(0x0002,0x0010);// Only TransferSyntax was pushed out ! + Archive->Push(0x0002,0x0010); Archive->Push(0x0002,0x0012); Archive->Push(0x0002,0x0013); Archive->Push(0x0002,0x0016); @@ -845,15 +998,28 @@ void FileHelper::SetWriteFileTypeToACR() /** * \brief Sets in the File the TransferSyntax to 'Explicit VR Little Endian" */ +void FileHelper::SetWriteFileTypeToJPEG() +{ + std::string ts = Util::DicomString( + Global::GetTS()->GetSpecialTransferSyntax(TS::JPEGBaselineProcess1) ); + + DataEntry *tss = CopyDataEntry(0x0002,0x0010); + tss->SetString(ts); + + Archive->Push(tss); + tss->Delete(); +} + void FileHelper::SetWriteFileTypeToExplicitVR() { std::string ts = Util::DicomString( Global::GetTS()->GetSpecialTransferSyntax(TS::ExplicitVRLittleEndian) ); - ValEntry *tss = CopyValEntry(0x0002,0x0010); - tss->SetValue(ts); + DataEntry *tss = CopyDataEntry(0x0002,0x0010); + tss->SetString(ts); Archive->Push(tss); + tss->Delete(); } /** @@ -864,10 +1030,11 @@ void FileHelper::SetWriteFileTypeToImplicitVR() std::string ts = Util::DicomString( Global::GetTS()->GetSpecialTransferSyntax(TS::ImplicitVRLittleEndian) ); - ValEntry *tss = CopyValEntry(0x0002,0x0010); - tss->SetValue(ts); + DataEntry *tss = CopyDataEntry(0x0002,0x0010); + tss->SetString(ts); Archive->Push(tss); + tss->Delete(); } @@ -876,17 +1043,6 @@ void FileHelper::SetWriteFileTypeToImplicitVR() */ void FileHelper::RestoreWriteFileType() { - // group 0002 may be pushed out for ACR-NEMA writting purposes - Archive->Restore(0x0002,0x0000); - Archive->Restore(0x0002,0x0001); - Archive->Restore(0x0002,0x0002); - Archive->Restore(0x0002,0x0003); - Archive->Restore(0x0002,0x0010);//only TransferSyntax was pushed out/restored - Archive->Restore(0x0002,0x0012); - Archive->Restore(0x0002,0x0013); - Archive->Restore(0x0002,0x0016); - Archive->Restore(0x0002,0x0100); - Archive->Restore(0x0002,0x0102); } /** @@ -894,31 +1050,33 @@ void FileHelper::RestoreWriteFileType() */ void FileHelper::SetWriteToLibido() { - ValEntry *oldRow = dynamic_cast - (FileInternal->GetDocEntry(0x0028, 0x0010)); - ValEntry *oldCol = dynamic_cast - (FileInternal->GetDocEntry(0x0028, 0x0011)); + DataEntry *oldRow = FileInternal->GetDataEntry(0x0028, 0x0010); + DataEntry *oldCol = FileInternal->GetDataEntry(0x0028, 0x0011); - if( oldRow && oldCol ) + if ( oldRow && oldCol ) { std::string rows, columns; - ValEntry *newRow=new ValEntry(oldRow->GetDictEntry()); - ValEntry *newCol=new ValEntry(oldCol->GetDictEntry()); + DataEntry *newRow=DataEntry::New(oldRow->GetDictEntry()); + DataEntry *newCol=DataEntry::New(oldCol->GetDictEntry()); newRow->Copy(oldCol); newCol->Copy(oldRow); - newRow->SetValue(oldCol->GetValue()); - newCol->SetValue(oldRow->GetValue()); + newRow->SetString(oldCol->GetString()); + newCol->SetString(oldRow->GetString()); Archive->Push(newRow); Archive->Push(newCol); + + newRow->Delete(); + newCol->Delete(); } - ValEntry *libidoCode = CopyValEntry(0x0008,0x0010); - libidoCode->SetValue("ACRNEMA_LIBIDO_1.1"); + DataEntry *libidoCode = CopyDataEntry(0x0008,0x0010); + libidoCode->SetString("ACRNEMA_LIBIDO_1.1"); Archive->Push(libidoCode); + libidoCode->Delete(); } /** @@ -926,15 +1084,15 @@ void FileHelper::SetWriteToLibido() */ void FileHelper::SetWriteToNoLibido() { - ValEntry *recCode = dynamic_cast - (FileInternal->GetDocEntry(0x0008,0x0010)); - if( recCode ) + DataEntry *recCode = FileInternal->GetDataEntry(0x0008,0x0010); + if ( recCode ) { - if( recCode->GetValue() == "ACRNEMA_LIBIDO_1.1" ) + if ( recCode->GetString() == "ACRNEMA_LIBIDO_1.1" ) { - ValEntry *libidoCode = CopyValEntry(0x0008,0x0010); - libidoCode->SetValue(""); + DataEntry *libidoCode = CopyDataEntry(0x0008,0x0010); + libidoCode->SetString(""); Archive->Push(libidoCode); + libidoCode->Delete(); } } } @@ -947,73 +1105,161 @@ void FileHelper::RestoreWriteOfLibido() Archive->Restore(0x0028,0x0010); Archive->Restore(0x0028,0x0011); Archive->Restore(0x0008,0x0010); -} - -/** - * \brief Duplicates a ValEntry or creates it. - * @param group Group number of the Entry - * @param elem Element number of the Entry - * \return pointer to the new Val Entry (NULL when creation failed). - */ -ValEntry *FileHelper::CopyValEntry(uint16_t group, uint16_t elem) -{ - DocEntry *oldE = FileInternal->GetDocEntry(group, elem); - ValEntry *newE; - if( oldE ) - { - newE = new ValEntry(oldE->GetDictEntry()); - newE->Copy(oldE); - } - else - { - newE = GetFile()->NewValEntry(group, elem); - } - - return newE; + // Restore 'LibIDO-special' entries, if any + Archive->Restore(0x0028,0x0015); + Archive->Restore(0x0028,0x0016); + Archive->Restore(0x0028,0x0017); + Archive->Restore(0x0028,0x00199); } /** - * \brief Duplicates a BinEntry or creates it. + * \brief Duplicates a DataEntry or creates it. * @param group Group number of the Entry * @param elem Element number of the Entry * @param vr Value Representation of the Entry * FIXME : what is it used for? * \return pointer to the new Bin Entry (NULL when creation failed). */ -BinEntry *FileHelper::CopyBinEntry(uint16_t group, uint16_t elem, - const std::string &vr) +DataEntry *FileHelper::CopyDataEntry(uint16_t group, uint16_t elem, + const TagName &vr) { DocEntry *oldE = FileInternal->GetDocEntry(group, elem); - BinEntry *newE; + DataEntry *newE; - if( oldE ) - if( oldE->GetVR()!=vr ) + if ( oldE && vr != GDCM_VRUNKNOWN ) + if ( oldE->GetVR() != vr ) oldE = NULL; - if( oldE ) + if ( oldE ) { - newE = new BinEntry(oldE->GetDictEntry()); + newE = DataEntry::New(oldE->GetDictEntry()); newE->Copy(oldE); } else { - newE = GetFile()->NewBinEntry(group, elem, vr); + newE = GetFile()->NewDataEntry(group, elem, vr); } return newE; } /** - * \brief Checks the Mandatory Elements - * adds the mandatory Entries if not found - * (when user asks to write as a DICOM file, an ACR-NEMA file - * he read before) + * \brief This method is called automatically, just before writting + * in order to produce a 'True Dicom V3' image. + * + * We cannot know *how* the user made the File : + * (reading an old ACR-NEMA file or a not very clean DICOM file ...) + * Just before writting : + * - we check the Entries + * - we create the mandatory entries if they are missing + * - we modify the values if necessary + * - we push the sensitive entries to the Archive + * The writing process will restore the entries as they where before + * entering FileHelper::CheckMandatoryElements, so the user will always + * see the entries just as they were before he decided to write. + * + * \note + * - Entries whose type is 1 are mandatory, with a mandatory value + * - Entries whose type is 1c are mandatory-inside-a-Sequence, + * with a mandatory value + * - Entries whose type is 2 are mandatory, with an optional value + * - Entries whose type is 2c are mandatory-inside-a-Sequence, + * with an optional value + * - Entries whose type is 3 are optional + * + * \todo + * - warn the user if we had to add some entries : + * even if a mandatory entry is missing, we add it, with a default value + * (we don't want to give up the writting process if user forgot to + * specify Lena's Patient ID, for instance ...) + * - read the whole PS 3.3 Part of DICOM (890 pages) + * and write a *full* checker (probably one method per Modality ...) + * Any contribution is welcome. + * - write a user callable full checker, to allow post reading + * and/or pre writting image consistency check. */ + +/* ------------------------------------------------------------------------------------- +To be moved to User's guide / WIKI ? + + + +-->'Media Storage SOP Class UID' (0x0002,0x0002) +-->'SOP Class UID' (0x0008,0x0016) are set to + [Secondary Capture Image Storage] + (Potentialy, the image was modified by user, and post-processed; + it's no longer a 'native' image) + Except if user told he wants to keep MediaStorageSOPClassUID, + when *he* knows he didn't modify the image (e.g. : he just anonymized the file) + +--> 'Image Type' (0x0008,0x0008) + is forced to "DERIVED\PRIMARY" + (The written image is no longer an 'ORIGINAL' one) + Except if user told he wants to keep MediaStorageSOPClassUID, + when *he* knows he didn't modify the image (e.g. : he just anonymized the file) + +--> 'Modality' (0x0008,0x0060) + is defaulted to "OT" (other) if missing. + (a fully user created image belongs to *no* modality) + +--> 'Media Storage SOP Instance UID' (0x0002,0x0003) +--> 'Implementation Class UID' (0x0002,0x0012) + are automatically generated; no user intervention possible + +--> 'Serie Instance UID'(0x0020,0x000e) +--> 'Study Instance UID'(0x0020,0x000d) are kept as is if already exist + created if it doesn't. + The user is allowed to create his own Series/Studies, + keeping the same 'Serie Instance UID' / 'Study Instance UID' + for various images + Warning : + The user shouldn't add any image to a 'Manufacturer Serie' + but there is no way no to allowed him to do that + +--> If 'SOP Class UID' exists in the native image ('true DICOM' image) + we create the 'Source Image Sequence' SeqEntry (0x0008, 0x2112) + + --> 'Referenced SOP Class UID' (0x0008, 0x1150) + whose value is the original 'SOP Class UID' + --> 'Referenced SOP Instance UID' (0x0008, 0x1155) + whose value is the original 'SOP Class UID' + +--> Bits Stored, Bits Allocated, Hight Bit Position are checked for consistency +--> Pixel Spacing (0x0028,0x0030) is defaulted to "1.0\1.0" +--> Samples Per Pixel (0x0028,0x0002) is defaulted to 1 (grayscale) +--> Imager Pixel Spacing (0x0018,0x1164) : defaulted to Pixel Spacing value + +--> Instance Creation Date, Instance Creation Time, Study Date, Study Time + are force to current Date and Time + +--> Conversion Type (0x0008,0x0064) + is forced to 'SYN' (Synthetic Image) + +--> Patient Orientation : (0x0020,0x0020), if not present, is deduced from + Image Orientation (Patient) : (0020|0037) + +--> Study ID, Series Number, Instance Number, Patient Orientation (Type 2) + are created, with empty value if there are missing. + +--> Manufacturer, Institution Name, Patient's Name, (Type 2) + are defaulted with a 'gdcm' value. + +--> Patient ID, Patient's Birth Date, Patient's Sex, (Type 2) +--> Referring Physician's Name (Type 2) + are created, with empty value if there are missing. + + -------------------------------------------------------------------------------------*/ + void FileHelper::CheckMandatoryElements() { + std::string sop = Util::CreateUniqueUID(); + // just to remember : 'official' 0002 group - + if ( WriteType != ACR && WriteType != ACR_LIBIDO ) + { + // Group 000002 (Meta Elements) already pushed out + //0002 0000 UL 1 Meta Group Length //0002 0001 OB 1 File Meta Information Version //0002 0002 UI 1 Media Stored SOP Class UID @@ -1024,46 +1270,41 @@ void FileHelper::CheckMandatoryElements() //0002 0016 AE 1 Source Application Entity Title //0002 0100 UI 1 Private Information Creator //0002 0102 OB 1 Private Information - - - // Create them if not found - ValEntry *e0002_0000 = CopyValEntry(0x0002,0x0000); - e0002_0000->SetValue("0"); // for the moment - Archive->Push(e0002_0000); -/* BinEntry *e0002_0001 = CopyBinEntry(0x0002,0x0001, "OB"); - e0002_0001->SetBinArea((uint8_t*)Util::GetFileMetaInformationVersion(),false); - e0002_0001->SetLength(2);*/ - -/* ValEntry *e0002_0002 = CopyValEntry(0x0002,0x0002); - // [Secondary Capture Image Storage] - e0002_0002->SetValue("1.2.840.10008.5.1.4.1.1.7"); - Archive->Push(e0002_0002);*/ - - // 'Media Stored SOP Instance UID' -/* ValEntry *e0002_0003 = CopyValEntry(0x0002,0x0003); - e0002_0003->SetValue(Util::CreateUniqueUID()); - Archive->Push(e0002_0003); */ - -/* ValEntry *e0002_0010 = CopyValEntry(0x0002,0x0010); - //[Explicit VR - Little Endian] - e0002_0010->SetValue("1.2.840.10008.1.2.1"); - Archive->Push(e0002_0010);*/ + // Create them if not found + // Always modify the value + // Push the entries to the archive. + CopyMandatoryEntry(0x0002,0x0000,"0"); + DataEntry *e_0002_0001 = CopyDataEntry(0x0002,0x0001, "OB"); + e_0002_0001->SetBinArea((uint8_t*)Util::GetFileMetaInformationVersion(), + false); + e_0002_0001->SetLength(2); + Archive->Push(e_0002_0001); + e_0002_0001->Delete(); + + if ( KeepMediaStorageSOPClassUID) + // It up to the use to *know* whether he modified the pixels or not. + // he is allowed to keep the original 'Media Storage SOP Class UID' + CheckMandatoryEntry(0x0002,0x0002,"1.2.840.10008.5.1.4.1.1.7"); + else + // Potentialy this is a post-processed image + // 'Media Storage SOP Class UID' --> [Secondary Capture Image Storage] + CopyMandatoryEntry(0x0002,0x0002,"1.2.840.10008.5.1.4.1.1.7"); + + // 'Media Storage SOP Instance UID' + CopyMandatoryEntry(0x0002,0x0003,sop); + // 'Implementation Class UID' -/* ValEntry *e0002_0012 = CopyValEntry(0x0002,0x0012); - e0002_0012->SetValue(Util::CreateUniqueUID()); - Archive->Push(e0002_0012); */ + // FIXME : in all examples we have, 0x0002,0x0012 is not so long : + // semms to be Root UID + 4 digits (?) + CopyMandatoryEntry(0x0002,0x0012,Util::CreateUniqueUID()); // 'Implementation Version Name' - ValEntry *e0002_0013 = CopyValEntry(0x0002,0x0013); - e0002_0013->SetValue("GDCM 1.0"); - Archive->Push(e0002_0013); - - //'Source Application Entity Title' Not Mandatory - //ValEntry *e0002_0016 = CopyValEntry(0x0002,0x0016); - // e0002_0016->SetValue("1.2.840.10008.5.1.4.1.1.7"); - // Archive->Push(e0002_0016); + std::string version = "GDCM "; + version += Util::GetVersion(); + CopyMandatoryEntry(0x0002,0x0013,version); + } // Push out 'LibIDO-special' entries, if any Archive->Push(0x0028,0x0015); @@ -1071,178 +1312,347 @@ void FileHelper::CheckMandatoryElements() Archive->Push(0x0028,0x0017); Archive->Push(0x0028,0x00199); + // Deal with the pb of (Bits Stored = 12) + // - we're gonna write the image as Bits Stored = 16 + if ( FileInternal->GetEntryString(0x0028,0x0100) == "12") + { + CopyMandatoryEntry(0x0028,0x0100,"16"); + } + + // Check if user wasn't drunk ;-) + + std::ostringstream s; + // check 'Bits Allocated' vs decent values + int nbBitsAllocated = FileInternal->GetBitsAllocated(); + if ( nbBitsAllocated == 0 || nbBitsAllocated > 32) + { + CopyMandatoryEntry(0x0028,0x0100,"16"); + gdcmWarningMacro("(0028,0100) changed from " + << nbBitsAllocated << " to 16 for consistency purpose"); + nbBitsAllocated = 16; + } + // check 'Bits Stored' vs 'Bits Allocated' + int nbBitsStored = FileInternal->GetBitsStored(); + if ( nbBitsStored == 0 || nbBitsStored > nbBitsAllocated ) + { + s.str(""); + s << nbBitsAllocated; + CopyMandatoryEntry(0x0028,0x0101,s.str()); + gdcmWarningMacro("(0028,0101) changed from " + << nbBitsStored << " to " << nbBitsAllocated + << " for consistency purpose" ); + nbBitsStored = nbBitsAllocated; + } + // check 'Hight Bit Position' vs 'Bits Allocated' and 'Bits Stored' + int highBitPosition = FileInternal->GetHighBitPosition(); + if ( highBitPosition == 0 || + highBitPosition > nbBitsAllocated-1 || + highBitPosition < nbBitsStored-1 ) + { + s.str(""); + s << nbBitsStored - 1; + CopyMandatoryEntry(0x0028,0x0102,s.str()); + gdcmWarningMacro("(0028,0102) changed from " + << highBitPosition << " to " << nbBitsAllocated-1 + << " for consistency purpose"); + } + + std::string pixelSpacing = FileInternal->GetEntryString(0x0028,0x0030); + if ( pixelSpacing == GDCM_UNKNOWN ) + pixelSpacing = "1.0\\1.0"; + else + // if missing, Pixel Spacing forced to "1.0\1.0" + CopyMandatoryEntry(0x0028,0x0030,"1.0\\1.0"); + + // 'Imager Pixel Spacing' : defaulted to 'Pixel Spacing' + // --> This one is the *legal* one ! + // FIXME : we should write it only when we are *sure* the image comes from + // an imager (see also 0008,0x0064) + + CheckMandatoryEntry(0x0018,0x1164,pixelSpacing); + + // Samples Per Pixel (type 1) : default to grayscale + CheckMandatoryEntry(0x0028,0x0002,"1"); + // --- Check UID-related Entries --- // If 'SOP Class UID' exists ('true DICOM' image) - ValEntry *e0008_0016 = FileInternal->GetValEntry(0x0008, 0x0016); - if ( e0008_0016 != 0 ) + // we create the 'Source Image Sequence' SeqEntry + // to hold informations about the Source Image + + DataEntry *e_0008_0016 = FileInternal->GetDataEntry(0x0008, 0x0016); + if ( e_0008_0016 ) { -/* // Create 'Source Image Sequence' SeqEntry - SeqEntry *s = new SeqEntry ( - Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x2112) ); - SQItem *sqi = new SQItem(1); + // Create 'Source Image Sequence' SeqEntry + SeqEntry *sis = SeqEntry::New ( + Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x2112) ); + SQItem *sqi = SQItem::New(1); // (we assume 'SOP Instance UID' exists too) // create 'Referenced SOP Class UID' - ValEntry *e0008_1150 = new ValEntry( - Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x1150) ); - e0008_1150->SetValue( e0008_0016->GetValue()); - sqi->AddEntry(e0008_1150); + DataEntry *e_0008_1150 = DataEntry::New( + Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x1150) ); + e_0008_1150->SetString( e_0008_0016->GetString()); + sqi->AddEntry(e_0008_1150); + e_0008_1150->Delete(); // create 'Referenced SOP Instance UID' - ValEntry *e0008_0018 = FileInternal->GetValEntry(0x0008, 0x0018); - ValEntry *e0008_1155 = new ValEntry( + DataEntry *e_0008_0018 = FileInternal->GetDataEntry(0x0008, 0x0018); + DataEntry *e_0008_1155 = DataEntry::New( Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x1155) ); - e0008_1155->SetValue( e0008_0018->GetValue()); - sqi->AddEntry(e0008_1155); + e_0008_1155->SetString( e_0008_0018->GetString()); + sqi->AddEntry(e_0008_1155); + e_0008_1155->Delete(); + + sis->AddSQItem(sqi,1); + sqi->Delete(); - s->AddSQItem(sqi,1); // temporarily replaces any previous 'Source Image Sequence' - Archive->Push(s); + Archive->Push(sis); + sis->Delete(); - // 'Image Type' - ValEntry *e0008_0008 = CopyValEntry(0x0008,0x0008); - e0008_0008->SetValue("DERIVED\\PRIMARY"); - Archive->Push(e0008_0008);*/ - } - else - { - // SOP Class UID -/* e0008_0016 = new ValEntry( - Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x0016) ); - // [Secondary Capture Image Storage] - e0008_0016 ->SetValue("1.2.840.10008.5.1.4.1.1.7"); - Archive->Push(e0008_0016); */ + // FIXME : is 'Image Type' *really* depending on the presence of'SOP Class UID'? + if ( KeepMediaStorageSOPClassUID) + // It up to the use to *know* whether he modified the pixels or not. + // he is allowed to keep the original 'Media Storage SOP Class UID' + // and 'Image Type' as well + CheckMandatoryEntry(0x0008,0x0008,"DERIVED\\PRIMARY"); + else + // Potentialy this is a post-processed image + // (The written image is no longer an 'ORIGINAL' one) + CopyMandatoryEntry(0x0008,0x0008,"DERIVED\\PRIMARY"); + } + // At the end, not to overwrite the original ones, + // needed by 'Referenced SOP Instance UID', 'Referenced SOP Class UID' + // 'SOP Instance UID' + CopyMandatoryEntry(0x0008,0x0018,sop); + + // the gdcm written image is a [Secondary Capture Image Storage] + // except if user told us he dind't modify the pixels, and, therefore + // he want to keep the 'Media Storage SOP Class UID' + + // 'Media Storage SOP Class UID' : [Secondary Capture Image Storage] + if ( KeepMediaStorageSOPClassUID) + { + // It up to the use to *know* whether he modified the pixels or not. + // he is allowed to keep the original 'Media Storage SOP Class UID' + CheckMandatoryEntry(0x0008,0x0016,"1.2.840.10008.5.1.4.1.1.7"); + } + else + { + // Potentialy this is a post-processed image + // 'Media Storage SOP Class UID' --> [Secondary Capture Image Storage] + CopyMandatoryEntry(0x0008,0x0016,"1.2.840.10008.5.1.4.1.1.7"); + + // FIXME : Must we Force Value, or Default value ? + // Is it Type 1 for any Modality ? + // --> Answer seems to be NO :-( + // FIXME : we should write it only when we are *sure* the image + // *does not* come from an imager (see also 0018,0x1164) + + // Conversion Type. + // Other possible values are : + // See PS 3.3, Page 408 + + // DV = Digitized Video + // DI = Digital Interface + // DF = Digitized Film + // WSD = Workstation + // SD = Scanned Document + // SI = Scanned Image + // DRW = Drawing + // SYN = Synthetic Image + + CheckMandatoryEntry(0x0008,0x0064,"SYN"); + } + + // ---- The user will never have to take any action on the following ---- + // new value for 'SOP Instance UID' - ValEntry *e0008_0018 = new ValEntry( - Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x0018) ); - e0008_0018->SetValue( Util::CreateUniqueUID() ); - Archive->Push(e0008_0018); + //SetMandatoryEntry(0x0008,0x0018,Util::CreateUniqueUID()); // Instance Creation Date - ValEntry *e0008_0012 = CopyValEntry(0x0008,0x0012); - std::string date = Util::GetCurrentDate(); - e0008_0012->SetValue(date.c_str()); - Archive->Push(e0008_0012); + const std::string &date = Util::GetCurrentDate(); + CopyMandatoryEntry(0x0008,0x0012,date); // Instance Creation Time - ValEntry *e0008_0013 = CopyValEntry(0x0008,0x0013); - std::string time = Util::GetCurrentTime(); - e0008_0013->SetValue(time.c_str()); - Archive->Push(e0008_0013); - -/* // new value for 'Serie Instance UID' - // TODO prevoir booleen pour figer la valeur d'un appel a l'autre - // calculer nouvelle valeur a chaque fois - - ValEntry *e0020_000e = new ValEntry( - Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0020, 0x000e) ); - e0020_000e->SetValue( Util::CreateUniqueUID() ); - Archive->Push(e0020_000e); - - // new value for 'Study Instance UID' - // TODO prevoir flag pour figer la valeur d'un appel a l'autre - // calculer nouvelle valeur a chaque fois - // reutiliser la valeur image origine - - ValEntry *e0020_000d = new ValEntry( - Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0020, 0x000d) ); - e0020_000d->SetValue( Util::CreateUniqueUID() ); - Archive->Push(e0020_000d); -*/ + const std::string &time = Util::GetCurrentTime(); + CopyMandatoryEntry(0x0008,0x0013,time); -// ----- Add Mandatory Entries if missing --- + // Study Date + CopyMandatoryEntry(0x0008,0x0020,date); + // Study Time + CopyMandatoryEntry(0x0008,0x0030,time); -// Entries whose type is 1 are mandatory, with a mandatory value -// Entries whose type is 1c are ? -// Entries whose type is 2 are mandatory, with a optional value -// Entries whose type is 2c are ? -// Entries whose type is 3 are optional + // Accession Number + //CopyMandatoryEntry(0x0008,0x0050,""); + CheckMandatoryEntry(0x0008,0x0050,""); + -// ValEntry *e; + // ----- Add Mandatory Entries if missing --- + // Entries whose type is 1 are mandatory, with a mandatory value + // Entries whose type is 1c are mandatory-inside-a-Sequence, + // with a mandatory value + // Entries whose type is 2 are mandatory, with an optional value + // Entries whose type is 2c are mandatory-inside-a-Sequence, + // with an optional value + // Entries whose type is 3 are optional + + // 'Study Instance UID' + // Keep the value if exists + // The user is allowed to create his own Study, + // keeping the same 'Study Instance UID' for various images + // The user may add images to a 'Manufacturer Study', + // adding new Series to an already existing Study + CheckMandatoryEntry(0x0020,0x000d,Util::CreateUniqueUID()); + + // 'Serie Instance UID' + // Keep the value if exists + // The user is allowed to create his own Series, + // keeping the same 'Serie Instance UID' for various images + // The user shouldn't add any image to a 'Manufacturer Serie' + // but there is no way no to prevent him for doing that + CheckMandatoryEntry(0x0020,0x000e,Util::CreateUniqueUID()); + + // Study ID + CheckMandatoryEntry(0x0020,0x0010,""); + + // Series Number + CheckMandatoryEntry(0x0020,0x0011,""); + + // Instance Number + CheckMandatoryEntry(0x0020,0x0013,""); + + // Patient Orientation + // Can be computed from (0020|0037) : Image Orientation (Patient) + gdcm::Orientation *o = gdcm::Orientation::New(); + std::string ori = o->GetOrientation ( FileInternal ); + o->Delete(); + if (ori != "\\" ) + CheckMandatoryEntry(0x0020,0x0020,ori); + else + CheckMandatoryEntry(0x0020,0x0020,""); + + // Modality : if missing we set it to 'OTher' + CheckMandatoryEntry(0x0008,0x0060,"OT"); - // Modality -/* ValEntry *e0008_0060 = FileInternal->GetValEntry(0x0008, 0x0060); - if ( !e0008_0060 ) - { - e0008_0060 = new ValEntry( - Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x0060) ); - e0008_0060->SetValue("OT"); - Archive->Push(e0008_0060); - } + // Manufacturer : if missing we set it to 'GDCM Factory' + CheckMandatoryEntry(0x0008,0x0070,"GDCM Factory"); - // Manufacturer - ValEntry *e0008_0070 = FileInternal->GetValEntry(0x0008, 0x0070); - if ( !e0008_0070 ) - { - e0008_0070 = new ValEntry( - Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x0070) ); - e0008_0070->SetValue("GDCM Factory"); - Archive->Push(e0008_0070); - } + // Institution Name : if missing we set it to 'GDCM Hospital' + CheckMandatoryEntry(0x0008,0x0080,"GDCM Hospital"); - // Institution Name - ValEntry *e0008_0080 = FileInternal->GetValEntry(0x0008, 0x0080); - if ( !e0008_0080 ) - { - e0008_0080 = new ValEntry( - Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x0080) ); - e0008_0080->SetValue("GDCM Hospital"); - Archive->Push(e0008_0080); - } + // Patient's Name : if missing, we set it to 'GDCM^Patient' + CheckMandatoryEntry(0x0010,0x0010,"GDCM^Patient"); - // Patient's Name - ValEntry *e0010_0010 = FileInternal->GetValEntry(0x0010, 0x0010); - if ( !e0010_0010 ) - { - e0010_0010 = new ValEntry( - Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0010, 0x0010) ); - e0010_0010->SetValue("GDCM_Patient"); - Archive->Push(e0010_0010); - } + // Patient ID + CheckMandatoryEntry(0x0010,0x0020,""); - // Patient's ID - ValEntry *e_0010_0020 = FileInternal->GetValEntry(0x0010, 0x0020); - if ( !e ) - { - e_0010_0020 = new ValEntry( - Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0010, 0x0020) ); - e_0010_0020->SetValue("GDCM_Patient_ID"); - Archive->Push(e_0010_0020); - } + // Patient's Birth Date : 'type 2' entry -> must exist, value not mandatory + CheckMandatoryEntry(0x0010,0x0030,""); - // Patient's Birth Date - ValEntry *e_0010_0030 = FileInternal->GetValEntry(0x0010, 0x0030); - if ( !e_0010_0030 ) + // Patient's Sex :'type 2' entry -> must exist, value not mandatory + CheckMandatoryEntry(0x0010,0x0040,""); + + // Referring Physician's Name :'type 2' entry -> must exist, value not mandatory + CheckMandatoryEntry(0x0008,0x0090,""); + + // Remove some inconstencies (probably some more will be added) + + // if (0028 0008)Number of Frames exists + // Push out (0020 0052),Frame of Reference UID + // (only meaningfull within a Serie) + DataEntry *e_0028_0008 = FileInternal->GetDataEntry(0x0028, 0x0008); + if ( !e_0028_0008 ) { - e_0010_0030 = new ValEntry( - Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0010, 0x0030) ); - e_0010_0030->SetValue(""); - Archive->Push(e_0010_0030); + Archive->Push(0x0020, 0x0052); } + + // Deal with element 0x0000 (group length) of each group. + // First stage : get all the different Groups + /* + GroupHT grHT; + DocEntry *d = FileInternal->GetFirstEntry(); + while(d) + { + grHT[d->GetGroup()] = 0; + d=FileInternal->GetNextEntry(); + } + // Second stage : add the missing ones (if any) + for (GroupHT::iterator it = grHT.begin(); it != grHT.end(); ++it) + { + CheckMandatoryEntry(it->first, 0x0000, "0"); + } + // Third stage : update all 'zero level' groups length +*/ +} - // Patient's Sex - ValEntry *e_0010_0040 = FileInternal->GetValEntry(0x0010, 0x0040); - if ( !e_0010_0040 ) +void FileHelper::CheckMandatoryEntry(uint16_t group,uint16_t elem,std::string value) +{ + DataEntry *entry = FileInternal->GetDataEntry(group,elem); + if ( !entry ) { - e_0010_0040 = new ValEntry( - Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0010, 0x0040) ); - e_0010_0040->SetValue(""); - Archive->Push(e_0010_0040); + entry = DataEntry::New(Global::GetDicts()->GetDefaultPubDict()->GetEntry(group,elem)); + entry->SetString(value); + Archive->Push(entry); + entry->Delete(); } +} + +void FileHelper::SetMandatoryEntry(uint16_t group,uint16_t elem,std::string value) +{ + DataEntry *entry = DataEntry::New(Global::GetDicts()->GetDefaultPubDict()->GetEntry(group,elem)); + entry->SetString(value); + Archive->Push(entry); + entry->Delete(); +} + +void FileHelper::CopyMandatoryEntry(uint16_t group,uint16_t elem,std::string value) +{ + DataEntry *entry = CopyDataEntry(group,elem); + entry->SetString(value); + Archive->Push(entry); + entry->Delete(); +} + +/** + * \brief Restore in the File the initial group 0002 + */ +void FileHelper::RestoreWriteMandatory() +{ + // group 0002 may be pushed out for ACR-NEMA writting purposes + Archive->Restore(0x0002,0x0000); + Archive->Restore(0x0002,0x0001); + Archive->Restore(0x0002,0x0002); + Archive->Restore(0x0002,0x0003); + Archive->Restore(0x0002,0x0010); + Archive->Restore(0x0002,0x0012); + Archive->Restore(0x0002,0x0013); + Archive->Restore(0x0002,0x0016); + Archive->Restore(0x0002,0x0100); + Archive->Restore(0x0002,0x0102); + + // FIXME : Check if none is missing ! + + Archive->Restore(0x0008,0x0012); + Archive->Restore(0x0008,0x0013); + Archive->Restore(0x0008,0x0016); + Archive->Restore(0x0008,0x0018); + Archive->Restore(0x0008,0x0060); + Archive->Restore(0x0008,0x0070); + Archive->Restore(0x0008,0x0080); + Archive->Restore(0x0008,0x0090); + Archive->Restore(0x0008,0x2112); + + Archive->Restore(0x0010,0x0010); + Archive->Restore(0x0010,0x0030); + Archive->Restore(0x0010,0x0040); + + Archive->Restore(0x0020,0x000d); + Archive->Restore(0x0020,0x000e); +} - // Referring Physician's Name - ValEntry *e_0008_0090 = FileInternal->GetValEntry(0x0008, 0x0090); - if ( !e_0008_0090 ) - { - e_0008_0090 = new ValEntry( - Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x0090) ); - e_0008_0090->SetValue(""); - Archive->Push(e_0008_0090); - }*/ -} - //----------------------------------------------------------------------------- // Private /** @@ -1250,31 +1660,34 @@ void FileHelper::CheckMandatoryElements() */ void FileHelper::Initialize() { + UserFunction = 0; + KeepMediaStorageSOPClassUID = false; + WriteMode = WMODE_RAW; WriteType = ExplicitVR; - PixelReadConverter = new PixelReadConvert; + PixelReadConverter = new PixelReadConvert; PixelWriteConverter = new PixelWriteConvert; Archive = new DocEntryArchive( FileInternal ); - - if ( FileInternal->IsReadable() ) - { - PixelReadConverter->GrabInformationsFromFile( FileInternal ); - } } /** - * \brief + * \brief Reads/[decompresses] the pixels, + * *without* making RGB from Palette Colors + * @return the pixels area, whatever its type + * (uint8_t is just for prototyping : feel free to Cast it) */ uint8_t *FileHelper::GetRaw() { + PixelReadConverter->SetUserFunction( UserFunction ); + uint8_t *raw = PixelReadConverter->GetRaw(); if ( ! raw ) { // The Raw image migth not be loaded yet: std::ifstream *fp = FileInternal->OpenFile(); PixelReadConverter->ReadAndDecompressPixelData( fp ); - if(fp) + if ( fp ) FileInternal->CloseFile(); raw = PixelReadConverter->GetRaw(); @@ -1284,19 +1697,25 @@ uint8_t *FileHelper::GetRaw() return 0; } } - return raw; } //----------------------------------------------------------------------------- -// Print +/** + * \brief Prints the common part of DataEntry, SeqEntry + * @param os ostream we want to print in + * @param indent (unused) + */ void FileHelper::Print(std::ostream &os, std::string const &) { FileInternal->SetPrintLevel(PrintLevel); FileInternal->Print(os); - PixelReadConverter->SetPrintLevel(PrintLevel); - PixelReadConverter->Print(os); + if ( FileInternal->IsReadable() ) + { + PixelReadConverter->SetPrintLevel(PrintLevel); + PixelReadConverter->Print(os); + } } //-----------------------------------------------------------------------------