X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=src%2FgdcmFileHelper.cxx;h=b61faace8ed0fd7c8a1d2a4c6ba82ebd4570acd1;hb=80075429b6ab9db9e885b9bb9ae1427530c7bef8;hp=98f023df9f98097b075170d37146428e1761a141;hpb=8b7ccc5d0086fd3df994c18e2883bc0e3f7d1984;p=gdcm.git diff --git a/src/gdcmFileHelper.cxx b/src/gdcmFileHelper.cxx index 98f023df..b61faace 100644 --- a/src/gdcmFileHelper.cxx +++ b/src/gdcmFileHelper.cxx @@ -4,8 +4,8 @@ Module: $RCSfile: gdcmFileHelper.cxx,v $ Language: C++ - Date: $Date: 2005/10/18 19:54:27 $ - Version: $Revision: 1.64 $ + Date: $Date: 2009/05/19 15:07:58 $ + Version: $Revision: 1.139 $ Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de l'Image). All rights reserved. See Doc/License.txt or @@ -26,11 +26,23 @@ #include "gdcmSeqEntry.h" #include "gdcmSQItem.h" #include "gdcmDataEntry.h" +#include "gdcmDocEntry.h" #include "gdcmFile.h" #include "gdcmPixelReadConvert.h" #include "gdcmPixelWriteConvert.h" #include "gdcmDocEntryArchive.h" #include "gdcmDictSet.h" +#include "gdcmOrientation.h" + + + +#include // for transform? + +#if defined(__BORLANDC__) + #include // for memset + #include //for toupper + #include +#endif #include @@ -39,85 +51,126 @@ 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); +// To read an image, user needs a GDCM_NAME_SPACE::File +GDCM_NAME_SPACE::File *f = new GDCM_NAME_SPACE::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(); +GDCM_NAME_SPACE::File *f = new GDCM_NAME_SPACE::File(); f->SetFileName(fileName); - f->SetLoadMode(LD_NOSEQ); // or - f->SetLoadMode(LD_NOSHADOW); // or + f->SetLoadMode(LD_NOSEQ); // or + f->SetLoadMode(LD_NOSHADOW); // or f->SetLoadMode(LD_NOSEQ | LD_NOSHADOW); // or f->SetLoadMode(LD_NOSHADOWSEQ); f->Load(); +// To decide whether it's an 'image of interest for him, or not, // 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 +// to get the pixels, user needs a GDCM_NAME_SPACE::FileHelper +GDCM_NAME_SPACE::FileHelper *fh = new GDCM_NAME_SPACE::FileHelper(f); + +// user may ask not to convert Palette (if any) 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 +//To re-write the image, user re-uses the GDCM_NAME_SPACE::FileHelper +GDCM_NAME_SPACE::File *fh = new GDCM_NAME_SPACE::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 + // (WriteMode is set) + +// If user wants to write the file as MONOCHROME1 (0=white) +fh->SetPhotometricInterpretationToMonochrome1(); + +fh->SetWriteTypeToDcmExpl(); // he wants Explicit Value Representation + // Little Endian is the default, + // bigendian not supported for writting (-->SetWriteType(ExplicitVR);) -->WriteType = ExplicitVR; +fh->SetWriteTypeToJPEG(); // lossless compression +fh->SetWriteTypeToJPEG2000(); // lossless compression + +fh->SetImageData( userPixels, userPixelsLength); +or +fh->SetUserData( userPixels, userPixelsLength); // this one performs compression, when required + 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 +PhotometricInterpretation : MONOCHROME2 (0=black), MONOCHROME2 (0=white) + +fh->SetImageData( userPixels, userPixelsLength); +or +fh->SetUserData( userPixels, userPixelsLength); + PixelWriteConverter->SetUserData(inData, expectedSize); + + +fh->SetWriteMode(WMODE_RAW / WMODE_RGB) -fh1->Write(newFileName); - SetWriteFileTypeToImplicitVR() / SetWriteFileTypeToExplicitVR(); - (modifies TransferSyntax) +fh->SetWriteType( ImplicitVR/ExplicitVR/ACR/ACR_LIBIDO/JPEG/JPEG2000) + +fh->Write(newFileName); + CheckMandatoryElements(); // Checks existing ones / Add missing ones + Fix VR if unknown elements + SetWriteFileTypeToImplicitVR() / SetWriteFileTypeToExplicitVR(); / + SetWriteFileTypeToACR() / SetWriteFileTypeToJPEG() / SetWriteFileTypeToJ2K() + (Modifies TransferSyntax if any; Pushes to the Archives old one) 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 ) + (Modifies and pushes to the Archive, when necessary : photochr. interp., + samples per pixel, Planar configuration, + bits allocated, bits stored, high bit -ACR 24 bits- + Pixels element VR, pushes out the LUT ) + SetWriteToRaw() + Sets Photometric Interpretation + DataEntry *pixel =CopyDataEntry(7fe0,0010,VR) + Sets VR, BinArea, Length for PixelData + if MONOCHROME1 + ConvertFixGreyLevels + Archive->Push(photInt); + Archive->Push(pixel); + photInt->Delete(); + pixel->Delete(); + SetWriteToRGB() + if NumberOfScalarComponents==1 + SetWriteToRaw(); return; + PixelReadConverter->BuildRGBImage() + DataEntry *pixel =CopyDataEntry(7fe0,0010,VR) + Archives spp, planConfig,photInt, pixel + Pushes out any LUT CheckWriteIntegrity(); (checks user given pixels length) FileInternal->Write(fileName,WriteType) - fp = opens file(fileName); - ComputeGroup0002Length( ); - BitsAllocated 12->16 - RemoveEntryNoDestroy(palettes, etc) + fp = opens file(fileName); // out|binary + ComputeGroup0002Length( ); Document::WriteContent(fp, writetype); + writes Dicom File Preamble not ACR-NEMA + ElementSet::WriteContent(fp, writetype); + writes recursively all DataElements RestoreWrite(); - (moves back to the File all the archived elements) - RestoreWriteFileType(); - (pushes back group 0002, with TransferSyntax) + (moves back to the GDCM_NAME_SPACE::File all the archived elements) */ -namespace gdcm +namespace GDCM_NAME_SPACE { +typedef std::map GroupHT; // Hash Table //------------------------------------------------------------------------- // Constructor / Destructor /** * \brief Constructor dedicated to deal with the *pixels* area of a ACR/DICOMV3 - * file (gdcm::File only deals with the ... header) + * file (GDCM_NAME_SPACE::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 @@ -130,8 +183,7 @@ namespace gdcm */ FileHelper::FileHelper( ) { - FileInternal = new File( ); - SelfHeader = true; + FileInternal = File::New( ); Initialize(); } @@ -151,48 +203,20 @@ FileHelper::FileHelper( ) */ FileHelper::FileHelper(File *header) { - FileInternal = header; - SelfHeader = false; - Initialize(); - if ( FileInternal->IsReadable() ) - { - PixelReadConverter->GrabInformationsFromFile( FileInternal ); - } -} + gdcmAssertMacro(header); -#ifndef GDCM_LEGACY_REMOVE -/** - * \brief DEPRECATED : use SetFilename() + SetLoadMode() + Load() methods - * 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 - * @deprecated use SetFilename() + Load() methods - */ -FileHelper::FileHelper(std::string const &filename ) -{ - FileInternal = new File( ); - FileInternal->SetFileName( filename ); - FileInternal->Load(); - SelfHeader = true; + FileInternal = header; + FileInternal->Register(); Initialize(); if ( FileInternal->IsReadable() ) { - PixelReadConverter->GrabInformationsFromFile( FileInternal ); + PixelReadConverter->GrabInformationsFromFile( FileInternal, this ); } } -#endif /** * \brief canonical destructor - * \note If the header (gdcm::File) was created by the FileHelper constructor, + * \note If the header (GDCM_NAME_SPACE::File) was created by the FileHelper constructor, * it is destroyed by the FileHelper */ FileHelper::~FileHelper() @@ -210,20 +234,15 @@ FileHelper::~FileHelper() delete Archive; } - if ( SelfHeader ) - { - delete FileInternal; - } - FileInternal = 0; + FileInternal->Unregister(); } //----------------------------------------------------------------------------- // Public /** - * \brief Sets the LoadMode of the internal gdcm::File as a boolean string. - * NO_SEQ, NO_SHADOW, NO_SHADOWSEQ - *... (nothing more, right now) + * \brief Sets the LoadMode of the internal GDCM_NAME_SPACE::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 ! @@ -234,7 +253,7 @@ void FileHelper::SetLoadMode(int loadMode) GetFile()->SetLoadMode( loadMode ); } /** - * \brief Sets the LoadMode of the internal gdcm::File + * \brief Sets the LoadMode of the internal GDCM_NAME_SPACE::File * @param fileName name of the file to be open */ void FileHelper::SetFileName(std::string const &fileName) @@ -252,80 +271,82 @@ bool FileHelper::Load() if ( !FileInternal->Load() ) return false; - PixelReadConverter->GrabInformationsFromFile( FileInternal ); + PixelReadConverter->GrabInformationsFromFile( FileInternal, this ); return true; } /** - * \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 its (group, element) + * and modifies its 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::SetEntryString(std::string const &content, - uint16_t group, uint16_t elem) + uint16_t group, uint16_t 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 its (group, element) + * and modifies its 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::SetEntryBinArea(uint8_t *content, int lgth, - uint16_t group, uint16_t elem) + uint16_t group, uint16_t 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 + * @param vr Value Representation of the DataElement to be inserted + * \return pointer to the modified/created DataEntry (NULL when creation * failed). */ DataEntry *FileHelper::InsertEntryString(std::string const &content, - uint16_t group, uint16_t elem) + uint16_t group, uint16_t elem, + VRKey const &vr ) { - return FileInternal->InsertEntryString(content, group, elem); + return FileInternal->InsertEntryString(content, group, elem, vr); } /** - * \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 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 + * @param vr Value Representation of the DataElement to be inserted + * \return pointer to the modified/created DataEntry (NULL when creation * failed). */ DataEntry *FileHelper::InsertEntryBinArea(uint8_t *binArea, int lgth, - uint16_t group, uint16_t elem) + uint16_t group, uint16_t elem, + VRKey const &vr ) { - return FileInternal->InsertEntryBinArea(binArea, lgth, group, elem); + return FileInternal->InsertEntryBinArea(binArea, lgth, group, elem, vr); } /** - * \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) @@ -351,7 +372,7 @@ size_t FileHelper::GetImageDataSize() } /** - * \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) @@ -367,13 +388,15 @@ size_t FileHelper::GetImageDataRawSize() } /** - * \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() @@ -401,21 +424,23 @@ 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. - * NULL if alloc fails + * (uint8_t is just for prototyping. feel free to cast) + * NULL if alloc fails */ uint8_t *FileHelper::GetImageDataRaw () { return GetRaw(); } -#ifndef GDCM_LEGACY_REMOVE -/** +//#ifndef GDCM_LEGACY_REMOVE +/* * \brief Useless function, since PixelReadConverter forces us * copy the Pixels anyway. * Reads the pixels from disk (uncompress if necessary), @@ -441,6 +466,7 @@ uint8_t *FileHelper::GetImageDataRaw () * @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) { if ( ! GetRaw() ) @@ -473,7 +499,8 @@ size_t FileHelper::GetImageDataIntoVector (void *destination, size_t maxSize) PixelReadConverter->GetRawSize() ); return PixelReadConverter->GetRawSize(); } -#endif +*/ +//#endif /** * \brief Points the internal pointer to the callers inData @@ -484,13 +511,15 @@ size_t FileHelper::GetImageDataIntoVector (void *destination, size_t maxSize) * 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 pixelsn since the size is + * user is allowed to pass any kind of pixels since the size is * given in bytes) * @param expectedSize total image size, *in Bytes* */ void FileHelper::SetImageData(uint8_t *inData, size_t expectedSize) { - SetUserData(inData, expectedSize); + PixelWriteConverter->SetUserData(inData, expectedSize); + /// \todo : shouldn't we call SetCompressJPEGUserData/SetCompressJPEG2000UserData + /// here, too? } /** @@ -503,6 +532,22 @@ void FileHelper::SetImageData(uint8_t *inData, size_t expectedSize) */ void FileHelper::SetUserData(uint8_t *inData, size_t expectedSize) { + // Shouldn't we move theese lines to FileHelper::Write()? +/* + if( WriteType == JPEG2000 ) + { + PixelWriteConverter->SetCompressJPEG2000UserData(inData, expectedSize, FileInternal); + } + else if( WriteType == JPEG ) + { + PixelWriteConverter->SetCompressJPEGUserData(inData, expectedSize, FileInternal); + } + else + { + PixelWriteConverter->SetUserData(inData, expectedSize); + } + */ + // Just try! PixelWriteConverter->SetUserData(inData, expectedSize); } @@ -561,7 +606,7 @@ size_t FileHelper::GetRawDataSize() } /** - * \brief Access to the underlying \ref PixelReadConverter RGBA LUT + * \brief Access to the underlying PixelReadConverter RGBA LUT */ uint8_t* FileHelper::GetLutRGBA() { @@ -571,7 +616,7 @@ uint8_t* FileHelper::GetLutRGBA() } /** - * \brief Access to the underlying \ref PixelReadConverter RGBA LUT Item Number + * \brief Access to the underlying PixelReadConverter RGBA LUT Item Number */ int FileHelper::GetLutItemNumber() { @@ -579,7 +624,7 @@ int FileHelper::GetLutItemNumber() } /** - * \brief Access to the underlying \ref PixelReadConverter RGBA LUT Item Size + * \brief Access to the underlying PixelReadConverter RGBA LUT Item Size */ int FileHelper::GetLutItemSize() { @@ -685,16 +730,22 @@ bool FileHelper::WriteAcr (std::string const &fileName) * @return false if write fails */ bool FileHelper::Write(std::string const &fileName) -{ +{ + CheckMandatoryElements(); //called once, here ! + switch(WriteType) { case ImplicitVR: SetWriteFileTypeToImplicitVR(); break; + case Unknown: // should never happen; ExplicitVR is the default value case ExplicitVR: + + // We let DocEntry::WriteContent to put vr=UN for undocumented Shadow Groups ! SetWriteFileTypeToExplicitVR(); - break; + + break; case ACR: case ACR_LIBIDO: // NOTHING is done here just for LibIDO. @@ -704,16 +755,34 @@ bool FileHelper::Write(std::string const &fileName) // (shame on him !) // We add Recognition Code (RET) if ( ! FileInternal->GetDataEntry(0x0008, 0x0010) ) - FileInternal->InsertEntryString("ACR-NEMA V1.0 ", 0x0008, 0x0010); + FileInternal->InsertEntryString("ACR-NEMA V1.0 ", + 0x0008, 0x0010, "LO"); SetWriteFileTypeToACR(); // SetWriteFileTypeToImplicitVR(); // ACR IS implicit VR ! break; + + /// \todo FIXME : JPEG/JPEG2000 may be either ExplicitVR or ImplicitVR case JPEG: SetWriteFileTypeToJPEG(); - std::cerr << "Writting as JPEG" << std::endl; + // was : + //PixelWriteConverter->SetCompressJPEGUserData( + // inData, expectedSize, FileInternal); + PixelWriteConverter->SetCompressJPEGUserData( + PixelWriteConverter->GetUserData(), + PixelWriteConverter->GetUserDataSize(),FileInternal); + break; + + case JPEG2000: + /// \todo Maybe we should consider doing the compression here ! + // PixelWriteConverter->SetCompressJPEG2000UserData(inData, expectedSize, FileInternal); + + SetWriteFileTypeToJPEG2000(); + PixelWriteConverter->SetCompressJPEG2000UserData( + PixelWriteConverter->GetUserData(), + PixelWriteConverter->GetUserDataSize(), + FileInternal); break; } - CheckMandatoryElements(); // -------------------------------------------------------------- // Special Patch to allow gdcm to re-write ACR-LibIDO formated images @@ -744,16 +813,20 @@ bool FileHelper::Write(std::string const &fileName) break; } - bool check = CheckWriteIntegrity(); // verifies length - if (WriteType == JPEG ) check = true; + bool check; + if (WriteType == JPEG || WriteType == JPEG2000) + check = true; + else + check = CheckWriteIntegrity(); // verifies length + if (check) { check = FileInternal->Write(fileName,WriteType); } RestoreWrite(); - RestoreWriteFileType(); - RestoreWriteMandatory(); + // RestoreWriteFileType(); + // RestoreWriteMandatory(); // -------------------------------------------------------------- // Special Patch to allow gdcm to re-write ACR-LibIDO formated images @@ -769,11 +842,7 @@ bool FileHelper::Write(std::string const &fileName) //----------------------------------------------------------------------------- // Protected /** - * \brief Checks the write integrity - * - * The tests made are : - * - verify the size of the image to write with the possible write - * when the user set an image data + * \brief Verifies the size of the user given PixelData * @return true if check is successfull */ bool FileHelper::CheckWriteIntegrity() @@ -783,44 +852,52 @@ bool FileHelper::CheckWriteIntegrity() int numberBitsAllocated = FileInternal->GetBitsAllocated(); if ( numberBitsAllocated == 0 || numberBitsAllocated == 12 ) { - gdcmWarningMacro( "numberBitsAllocated changed from " - << numberBitsAllocated << " to 16 " + gdcmWarningMacro( "numberBitsAllocated changed from " + << numberBitsAllocated << " to 16 " << " for consistency purpose" ); numberBitsAllocated = 16; } size_t decSize = FileInternal->GetXSize() - * FileInternal->GetYSize() + * FileInternal->GetYSize() * FileInternal->GetZSize() + * FileInternal->GetTSize() * FileInternal->GetSamplesPerPixel() * ( numberBitsAllocated / 8 ); size_t rgbSize = decSize; if ( FileInternal->HasLUT() ) rgbSize = decSize * 3; + size_t userDataSize = PixelWriteConverter->GetUserDataSize(); switch(WriteMode) { case WMODE_RAW : - if ( decSize!=PixelWriteConverter->GetUserDataSize() ) + if ( abs((long)(decSize-userDataSize))>1) // ignore padding zero { gdcmWarningMacro( "Data size (Raw) is incorrect. Should be " - << decSize << " / Found :" - << PixelWriteConverter->GetUserDataSize() ); + << decSize << "(" + << FileInternal->GetXSize() << " * " + << FileInternal->GetYSize() << " * " + << FileInternal->GetZSize() << " * " + << FileInternal->GetTSize() << " * " + << FileInternal->GetSamplesPerPixel() << " * " + << numberBitsAllocated / 8 + << ") / Found :" + << userDataSize ); return false; } break; case WMODE_RGB : - if ( rgbSize!=PixelWriteConverter->GetUserDataSize() ) + if ( abs((long)(rgbSize-userDataSize))>1) // ignore padding zero { gdcmWarningMacro( "Data size (RGB) is incorrect. Should be " - << decSize << " / Found " - << PixelWriteConverter->GetUserDataSize() ); + << rgbSize << " / Found " + << userDataSize ); return false; } break; } } - return true; } @@ -828,6 +905,8 @@ bool FileHelper::CheckWriteIntegrity() * \brief Updates the File to write RAW data (as opposed to RGB data) * (modifies, when necessary, photochromatic interpretation, * bits allocated, Pixels element VR) + * WARNING : if SetPhotometricInterpretationToMonochrome1() was called + * before Pixel Elements is modified :-( */ void FileHelper::SetWriteToRaw() { @@ -838,14 +917,18 @@ void FileHelper::SetWriteToRaw() } else { - DataEntry *photInt = CopyDataEntry(0x0028,0x0004); + // 0x0028,0x0004 : Photometric Interpretation + DataEntry *photInt = CopyDataEntry(0x0028,0x0004,"CS"); if (FileInternal->HasLUT() ) { photInt->SetString("PALETTE COLOR "); } else { - photInt->SetString("MONOCHROME2 "); + if (GetPhotometricInterpretation() == 2) + photInt->SetString("MONOCHROME2 "); // 0 = Black + else + photInt->SetString("MONOCHROME1 "); // 0 = White ! } PixelWriteConverter->SetReadData(PixelReadConverter->GetRaw(), @@ -856,14 +939,29 @@ void FileHelper::SetWriteToRaw() vr = "OW"; if ( FileInternal->GetBitsAllocated()==24 ) // For RGB ACR files vr = "OB"; + // For non RAW data. Mainly JPEG/JPEG2000 + if( WriteType == JPEG || WriteType == JPEG2000) + { + vr = "OW"; + } + DataEntry *pixel = CopyDataEntry(GetFile()->GetGrPixel(),GetFile()->GetNumPixel(),vr); pixel->SetFlag(DataEntry::FLAG_PIXELDATA); pixel->SetBinArea(PixelWriteConverter->GetData(),false); - pixel->SetLength(PixelWriteConverter->GetDataSize()); + pixel->SetLength( + static_cast< uint32_t >(PixelWriteConverter->GetDataSize()) ); + + if (!FileInternal->HasLUT() && GetPhotometricInterpretation() == 1) + { + ConvertFixGreyLevels( pixel->GetBinArea(), pixel->GetLength() ); + } Archive->Push(photInt); Archive->Push(pixel); + + photInt->Delete(); + pixel->Delete(); } } @@ -880,14 +978,14 @@ void FileHelper::SetWriteToRGB() { PixelReadConverter->BuildRGBImage(); - DataEntry *spp = CopyDataEntry(0x0028,0x0002); - spp->SetString("3 "); + DataEntry *spp = CopyDataEntry(0x0028,0x0002,"US"); + spp->SetString("3 "); // Don't drop trailing space - DataEntry *planConfig = CopyDataEntry(0x0028,0x0006); - planConfig->SetString("0 "); + DataEntry *planConfig = CopyDataEntry(0x0028,0x0006,"US"); + planConfig->SetString("0 "); // Don't drop trailing space - DataEntry *photInt = CopyDataEntry(0x0028,0x0004); - photInt->SetString("RGB "); + DataEntry *photInt = CopyDataEntry(0x0028,0x0004,"CS"); + photInt->SetString("RGB "); // Don't drop trailing space if ( PixelReadConverter->GetRGB() ) { @@ -916,6 +1014,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); @@ -932,18 +1035,22 @@ void FileHelper::SetWriteToRGB() // samples per pixels = 1 (in the read file) if ( FileInternal->GetBitsAllocated()==24 ) { - DataEntry *bitsAlloc = CopyDataEntry(0x0028,0x0100); + DataEntry *bitsAlloc = CopyDataEntry(0x0028,0x0100,"US"); bitsAlloc->SetString("8 "); - DataEntry *bitsStored = CopyDataEntry(0x0028,0x0101); + DataEntry *bitsStored = CopyDataEntry(0x0028,0x0101,"US"); bitsStored->SetString("8 "); - DataEntry *highBit = CopyDataEntry(0x0028,0x0102); + DataEntry *highBit = CopyDataEntry(0x0028,0x0102,"US"); highBit->SetString("7 "); Archive->Push(bitsAlloc); Archive->Push(bitsStored); Archive->Push(highBit); + + bitsAlloc->Delete(); + bitsStored->Delete(); + highBit->Delete(); } } else @@ -959,6 +1066,7 @@ void FileHelper::RestoreWrite() { Archive->Restore(0x0028,0x0002); Archive->Restore(0x0028,0x0004); + Archive->Restore(0x0028,0x0006); Archive->Restore(GetFile()->GetGrPixel(),GetFile()->GetNumPixel()); @@ -978,7 +1086,6 @@ void FileHelper::RestoreWrite() // 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); @@ -990,6 +1097,7 @@ void FileHelper::RestoreWrite() Archive->Restore(0x0002,0x0016); Archive->Restore(0x0002,0x0100); Archive->Restore(0x0002,0x0102); + } /** @@ -1014,28 +1122,47 @@ void FileHelper::SetWriteFileTypeToACR() } /** - * \brief Sets in the File the TransferSyntax to 'Explicit VR Little Endian" - */ + * \brief Sets in the File the TransferSyntax to 'JPEG2000' + */ +void FileHelper::SetWriteFileTypeToJPEG2000() +{ + std::string ts = Util::DicomString( + Global::GetTS()->GetSpecialTransferSyntax(TS::JPEG2000Lossless) ); + + DataEntry *tss = CopyDataEntry(0x0002,0x0010,"UI"); + tss->SetString(ts); + + Archive->Push(tss); + tss->Delete(); +} + +/** + * \brief Sets in the File the TransferSyntax to 'JPEG' + */ void FileHelper::SetWriteFileTypeToJPEG() { - std::string ts = Util::DicomString( - Global::GetTS()->GetSpecialTransferSyntax(TS::JPEGBaselineProcess1) ); + std::string ts = Util::DicomString( + Global::GetTS()->GetSpecialTransferSyntax(TS::JPEGLosslessProcess14_1) ); - DataEntry *tss = CopyDataEntry(0x0002,0x0010); + DataEntry *tss = CopyDataEntry(0x0002,0x0010,"UI"); tss->SetString(ts); Archive->Push(tss); + tss->Delete(); } +/** + * \brief Sets in the File the TransferSyntax to 'Explicit VR Little Endian" + */ void FileHelper::SetWriteFileTypeToExplicitVR() { std::string ts = Util::DicomString( Global::GetTS()->GetSpecialTransferSyntax(TS::ExplicitVRLittleEndian) ); - DataEntry *tss = CopyDataEntry(0x0002,0x0010); + DataEntry *tss = CopyDataEntry(0x0002,0x0010,"UI"); tss->SetString(ts); - Archive->Push(tss); + tss->Delete(); } /** @@ -1046,18 +1173,10 @@ void FileHelper::SetWriteFileTypeToImplicitVR() std::string ts = Util::DicomString( Global::GetTS()->GetSpecialTransferSyntax(TS::ImplicitVRLittleEndian) ); - DataEntry *tss = CopyDataEntry(0x0002,0x0010); + DataEntry *tss = CopyDataEntry(0x0002,0x0010,"UI"); tss->SetString(ts); - Archive->Push(tss); -} - - -/** - * \brief Restore in the File the initial group 0002 - */ -void FileHelper::RestoreWriteFileType() -{ + tss->Delete(); } /** @@ -1072,8 +1191,8 @@ void FileHelper::SetWriteToLibido() { std::string rows, columns; - DataEntry *newRow=new DataEntry(oldRow->GetDictEntry()); - DataEntry *newCol=new DataEntry(oldCol->GetDictEntry()); + DataEntry *newRow=DataEntry::New(0x0028, 0x0010, "US"); + DataEntry *newCol=DataEntry::New(0x0028, 0x0011, "US"); newRow->Copy(oldCol); newCol->Copy(oldRow); @@ -1083,11 +1202,15 @@ void FileHelper::SetWriteToLibido() Archive->Push(newRow); Archive->Push(newCol); + + newRow->Delete(); + newCol->Delete(); } - DataEntry *libidoCode = CopyDataEntry(0x0008,0x0010); + DataEntry *libidoCode = CopyDataEntry(0x0008,0x0010,"LO"); libidoCode->SetString("ACRNEMA_LIBIDO_1.1"); Archive->Push(libidoCode); + libidoCode->Delete(); } /** @@ -1100,9 +1223,10 @@ void FileHelper::SetWriteToNoLibido() { if ( recCode->GetString() == "ACRNEMA_LIBIDO_1.1" ) { - DataEntry *libidoCode = CopyDataEntry(0x0008,0x0010); + DataEntry *libidoCode = CopyDataEntry(0x0008,0x0010,"LO"); libidoCode->SetString(""); Archive->Push(libidoCode); + libidoCode->Delete(); } } } @@ -1128,11 +1252,10 @@ void FileHelper::RestoreWriteOfLibido() * @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). */ DataEntry *FileHelper::CopyDataEntry(uint16_t group, uint16_t elem, - const TagName &vr) + const VRKey &vr) { DocEntry *oldE = FileInternal->GetDocEntry(group, elem); DataEntry *newE; @@ -1143,7 +1266,7 @@ DataEntry *FileHelper::CopyDataEntry(uint16_t group, uint16_t elem, if ( oldE ) { - newE = new DataEntry(oldE->GetDictEntry()); + newE = DataEntry::New(group, elem, vr); newE->Copy(oldE); } else @@ -1156,10 +1279,10 @@ DataEntry *FileHelper::CopyDataEntry(uint16_t group, uint16_t elem, /** * \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 ...) - * + * 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 @@ -1167,9 +1290,19 @@ DataEntry *FileHelper::CopyDataEntry(uint16_t group, uint16_t elem, * - 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 he left them. + * 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 : + * \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 ...) @@ -1179,9 +1312,150 @@ DataEntry *FileHelper::CopyDataEntry(uint16_t group, uint16_t elem, * - 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 ? + +We have to deal with 4 *very* different cases : +-1) user created ex nihilo his own image and wants to write it as a Dicom image. + USER_OWN_IMAGE +-2) user modified the pixels of an existing image. + FILTERED_IMAGE +-3) user created a new image, using a set of existing images (eg MIP, MPR, cartography image) + CREATED_IMAGE +-4) user modified/added some tags *without processing* the pixels (anonymization...) + UNMODIFIED_PIXELS_IMAGE +-Probabely some more to be added. + --> Set it with FileHelper::SetContentType(int); +GDCM_NAME_SPACE::FileHelper::CheckMandatoryElements() deals automatically with these cases. + +1)2)3)4) +0008 0012 Instance Creation Date +0008 0013 Instance Creation Time +0008 0018 SOP Instance UID +are *always* created with the current values; user has *no* possible intervention on +them. + +'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 allow him to do that + + None of the 'shadow elements' are droped out. + + +1) +'Conversion Type (0x0008,0x0064) is forced to 'SYN' (Synthetic Image). + +1)3) +'Media Storage SOP Class UID' (0x0002,0x0002) +'SOP Class UID' (0x0008,0x0016) are set to + [Secondary Capture Image Storage] +'Image Type' (0x0008,0x0008) is forced to "DERIVED\PRIMARY" +Conversion Type (0x0008,0x0064) is forced to 'SYN' (Synthetic Image) + +2)4) +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' + +3) TO DO : find a trick to allow user to pass to the writter the list of the Dicom images + or the Series, (or the Study ?) he used to created his image + (MIP, MPR, cartography image, ...) + These info should be stored (?) + 0008 1110 SQ 1 Referenced Study Sequence + 0008 1115 SQ 1 Referenced Series Sequence + 0008 1140 SQ 1 Referenced Image Sequence + +4) When user *knows* he didn't modified the pixels, we keep some informations unchanged : +'Media Storage SOP Class UID' (0x0002,0x0002) +'SOP Class UID' (0x0008,0x0016) +'Image Type' (0x0008,0x0008) +'Conversion Type' (0x0008,0x0064) + + +Bellow follows the full description (hope so !) of the consistency checks performed +by GDCM_NAME_SPACE::FileHelper::CheckMandatoryElements() + + +-->'Media Storage SOP Class UID' (0x0002,0x0002) +-->'SOP Class UID' (0x0008,0x0016) are defaulted to + [Secondary Capture Image Storage] +--> 'Image Type' (0x0008,0x0008) + is forced to "DERIVED\PRIMARY" + (The written image is no longer an 'ORIGINAL' one) + Except if user knows he didn't modify the image (e.g. : he just anonymized the file) + + --> Conversion Type (0x0008,0x0064) + is defaulted to 'SYN' (Synthetic Image) + when *he* knows he created his own image ex nihilo + +--> '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 are forced to current Date and Time + +--> Study Date, Study Time are defaulted to current Date and Time + (they remain unchanged if they exist) + +--> Patient Orientation : (0x0020,0x0020), if not present, is deduced from + Image Orientation (Patient) : (0020|0037) or from + Image Orientation (RET) : (0020 0035) + +--> 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(); + + // --------------------- For Meta Elements --------------------- // just to remember : 'official' 0002 group if ( WriteType != ACR && WriteType != ACR_LIBIDO ) { @@ -1189,53 +1463,168 @@ void FileHelper::CheckMandatoryElements() //0002 0000 UL 1 Meta Group Length //0002 0001 OB 1 File Meta Information Version - //0002 0002 UI 1 Media Stored SOP Class UID - //0002 0003 UI 1 Media Stored SOP Instance UID + //0002 0002 UI 1 Media Storage SOP Class UID + //0002 0003 UI 1 Media Storage SOP Instance UID //0002 0010 UI 1 Transfer Syntax UID //0002 0012 UI 1 Implementation Class UID //0002 0013 SH 1 Implementation Version Name //0002 0016 AE 1 Source Application Entity Title //0002 0100 UI 1 Private Information Creator //0002 0102 OB 1 Private Information - + + // Push out 'ACR-NEMA-special' entries, if any + Archive->Push(0x0008,0x0001); // Length to End + Archive->Push(0x0008,0x0010); // Recognition Code + Archive->Push(0x0028,0x0005); // Image Dimension + // Create them if not found // Always modify the value // Push the entries to the archive. - CopyMandatoryEntry(0x0002,0x0000,"0"); - + CopyMandatoryEntry(0x0002,0x0000,"0","UL"); + 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(); - // 'Media Stored SOP Class UID' - // [Secondary Capture Image Storage] - CopyMandatoryEntry(0x0002,0x0002,"1.2.840.10008.5.1.4.1.1.7"); - - // 'Media Stored SOP Instance UID' - CopyMandatoryEntry(0x0002,0x0003,Util::CreateUniqueUID()); + if ( ContentType == FILTERED_IMAGE || ContentType == UNMODIFIED_PIXELS_IMAGE) + { + // we keep the original 'Media Storage SOP Class UID', we default it if missing + CheckMandatoryEntry(0x0002,0x0002,"1.2.840.10008.5.1.4.1.1.7","UI"); + } + else + { + // It's *not* an image comming straight from a source. We force + // 'Media Storage SOP Class UID' --> [Secondary Capture Image Storage] + CopyMandatoryEntry(0x0002,0x0002,"1.2.840.10008.5.1.4.1.1.7","UI"); + } + + // 'Media Storage SOP Instance UID' + CopyMandatoryEntry(0x0002,0x0003,sop,"UI"); // 'Implementation Class UID' - CopyMandatoryEntry(0x0002,0x0012,Util::CreateUniqueUID()); + // FIXME : in all examples we have, 0x0002,0x0012 is not so long : + // seems to be Root UID + 4 digits (?) + CopyMandatoryEntry(0x0002,0x0012,Util::CreateUniqueUID(),"UI"); // 'Implementation Version Name' std::string version = "GDCM "; version += Util::GetVersion(); - CopyMandatoryEntry(0x0002,0x0013,version); + CopyMandatoryEntry(0x0002,0x0013,version,"SH"); } + // --------------------- For DataSet --------------------- + + // check whether 0018|0015 [CS] [Body Part Examined] value is UPPER CASE + // (avoid dciodvfy to complain!) + DataEntry *e_0018_0015 = FileInternal->GetDataEntry(0x0018, 0x0015); + if ( e_0018_0015) + { + std::string bodyPartExamined = e_0018_0015->GetString(); + std::transform(bodyPartExamined.begin(), bodyPartExamined.end(), bodyPartExamined.begin(), + (int(*)(int)) toupper); + CopyMandatoryEntry(0x0018,0x0015,bodyPartExamined,"CS"); + } + + if ( ContentType != USER_OWN_IMAGE) // when it's not a user made image + { + // If 'SOP Class UID' and 'SOP Instance UID' exist ('true DICOM' image) + // we create the 'Source Image Sequence' SeqEntry + // to hold informations about the Source Image + + // 'SOP Instance UID' + DataEntry *e_0008_0016 = FileInternal->GetDataEntry(0x0008, 0x0016); + // + DataEntry *e_0008_0018 = FileInternal->GetDataEntry(0x0008, 0x0018); + if ( e_0008_0016 && e_0008_0018) + { + // Create 'Source Image Sequence' SeqEntry + SeqEntry *sis = SeqEntry::New (0x0008, 0x2112); + SQItem *sqi = SQItem::New(1); + + // create 'Referenced SOP Class UID' from 'SOP Class UID' + + DataEntry *e_0008_1150 = DataEntry::New(0x0008, 0x1150, "UI"); + e_0008_1150->SetString( e_0008_0016->GetString()); + sqi->AddEntry(e_0008_1150); + e_0008_1150->Delete(); + + // create 'Referenced SOP Instance UID' from 'SOP Instance UID' + // DataEntry *e_0008_0018 = FileInternal->GetDataEntry(0x0008, 0x0018); + + DataEntry *e_0008_1155 = DataEntry::New(0x0008, 0x1155, "UI"); + e_0008_1155->SetString( e_0008_0018->GetString()); + sqi->AddEntry(e_0008_1155); + e_0008_1155->Delete(); + + sis->AddSQItem(sqi,1); + sqi->Delete(); + + // temporarily replaces any previous 'Source Image Sequence' + Archive->Push(sis); + sis->Delete(); + // FIXME : is 'Image Type' *really* depending on the presence of 'SOP Class UID'? + + if ( ContentType == FILTERED_IMAGE) // the user *knows* he just modified the pixels + { + DataEntry *e_0008_0008 = FileInternal->GetDataEntry(0x0008, 0x0008); + if ( e_0008_0008) + { + std::string imageType = e_0008_0008->GetString(); + std::string::size_type p = imageType.find("ORIGINAL"); + if (p == 0) // image is ORIGINAL one + { + // the image is no longer an 'Original' one + CopyMandatoryEntry(0x0008,0x0008,"DERIVED\\PRIMARY","CS"); + } + // if Image Type was not ORIGINAL\..., we keep it. + } + else // 0008_0008 was missing, wee add it. + { + CopyMandatoryEntry(0x0008,0x0008,"DERIVED\\PRIMARY","CS"); + } + } + } + } + + if ( ContentType == FILTERED_IMAGE || ContentType == UNMODIFIED_PIXELS_IMAGE) + { + // we keep the original 'Media Storage SOP Class UID', we default it if missing (it should be present !) + CheckMandatoryEntry(0x0008,0x0016,"1.2.840.10008.5.1.4.1.1.7","UI"); + } + else + { + // It's *not* an image comming straight from a source. We force + // 'Media Storage SOP Class UID' --> [Secondary Capture Image Storage] + CopyMandatoryEntry(0x0008,0x0016,"1.2.840.10008.5.1.4.1.1.7", "UI"); + } + + Archive->Push(0x0028,0x005); // [Image Dimensions (RET) // Push out 'LibIDO-special' entries, if any Archive->Push(0x0028,0x0015); Archive->Push(0x0028,0x0016); Archive->Push(0x0028,0x0017); - Archive->Push(0x0028,0x00199); + Archive->Push(0x0028,0x0198); // very old versions + Archive->Push(0x0028,0x0199); + + // Replace deprecated 0028 0012 US Planes + // by new 0028 0008 IS Number of Frames + + ///\todo : find if there is a rule! + DataEntry *e_0028_0012 = FileInternal->GetDataEntry(0x0028, 0x0012); + if ( e_0028_0012 ) + { + CopyMandatoryEntry(0x0028, 0x0008,e_0028_0012->GetString(),"IS"); + Archive->Push(0x0028,0x0012); + } // 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"); + CopyMandatoryEntry(0x0028,0x0100,"16","US"); } // Check if user wasn't drunk ;-) @@ -1243,9 +1632,13 @@ void FileHelper::CheckMandatoryElements() std::ostringstream s; // check 'Bits Allocated' vs decent values int nbBitsAllocated = FileInternal->GetBitsAllocated(); - if ( nbBitsAllocated == 0 || nbBitsAllocated > 32) + + // We allow now to deal with 'non standard' 64 bits 'real' values + + if ( (nbBitsAllocated == 0 || nbBitsAllocated > 64) // was 32 + || ( nbBitsAllocated > 8 && nbBitsAllocated <16) ) { - CopyMandatoryEntry(0x0028,0x0100,"16"); + CopyMandatoryEntry(0x0028,0x0100,"16","US"); gdcmWarningMacro("(0028,0100) changed from " << nbBitsAllocated << " to 16 for consistency purpose"); nbBitsAllocated = 16; @@ -1256,7 +1649,7 @@ void FileHelper::CheckMandatoryElements() { s.str(""); s << nbBitsAllocated; - CopyMandatoryEntry(0x0028,0x0101,s.str()); + CopyMandatoryEntry(0x0028,0x0101,s.str(),"US"); gdcmWarningMacro("(0028,0101) changed from " << nbBitsStored << " to " << nbBitsAllocated << " for consistency purpose" ); @@ -1270,147 +1663,279 @@ void FileHelper::CheckMandatoryElements() { s.str(""); s << nbBitsStored - 1; - CopyMandatoryEntry(0x0028,0x0102,s.str()); + CopyMandatoryEntry(0x0028,0x0102,s.str(),"US"); gdcmWarningMacro("(0028,0102) changed from " << highBitPosition << " to " << nbBitsAllocated-1 << " for consistency purpose"); } - // --- Check UID-related Entries --- - // If 'SOP Class UID' exists ('true DICOM' image) - // we create the 'Source Image Sequence' SeqEntry - // to hold informations about the Source Image + // check Pixel Representation (default it as 0 -unsigned-) - DataEntry *e_0008_0016 = FileInternal->GetDataEntry(0x0008, 0x0016); - if ( e_0008_0016 ) + DataEntry *e_0028_0103 = FileInternal->GetDataEntry(0x0028, 0x0103); + if ( !e_0028_0103 ) { - // Create 'Source Image Sequence' SeqEntry - SeqEntry *sis = new SeqEntry ( - Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x2112) ); - SQItem *sqi = new SQItem(1); - // (we assume 'SOP Instance UID' exists too) - // create 'Referenced SOP Class UID' - DataEntry *e_0008_1150 = new DataEntry( - Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x1150) ); - e_0008_1150->SetString( e_0008_0016->GetString()); - sqi->AddEntry(e_0008_1150); - - // create 'Referenced SOP Instance UID' - DataEntry *e_0008_0018 = FileInternal->GetDataEntry(0x0008, 0x0018); - DataEntry *e_0008_1155 = new DataEntry( - Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x1155) ); - e_0008_1155->SetString( e_0008_0018->GetString()); - sqi->AddEntry(e_0008_1155); - - sis->AddSQItem(sqi,1); - // temporarily replaces any previous 'Source Image Sequence' - Archive->Push(sis); + gdcmWarningMacro("PixelRepresentation (0028,0103) is supposed to be mandatory"); + CopyMandatoryEntry(0x0028, 0x0103,"0","US"); + } + else + { + int sign = (int)e_0028_0103->GetValue(0); + if (sign !=1 && sign !=0) + { + gdcmWarningMacro("PixelRepresentation (0028,0103) is supposed to be =1 or =0"); + CopyMandatoryEntry(0x0028, 0x0103,"0","US"); + } + } + + std::string pixelAspectRatio = FileInternal->GetEntryString(0x0028,0x0034); + if ( pixelAspectRatio == GDCM_UNFOUND ) // avoid conflict with pixelSpacing ! + { + std::string pixelSpacing = FileInternal->GetEntryString(0x0028,0x0030); + if ( pixelSpacing == GDCM_UNFOUND ) + { + pixelSpacing = "1.0\\1.0"; + // if missing, Pixel Spacing forced to "1.0\1.0" + CopyMandatoryEntry(0x0028,0x0030,pixelSpacing,"DS"); + } + + // 'Imager Pixel Spacing' : defaulted to 'Pixel Spacing' + // --> This one is the *legal* one ! + if ( ContentType != USER_OWN_IMAGE) + // we write it only when we are *sure* the image comes from + // an imager (see also 0008,0x0064) + CheckMandatoryEntry(0x0018,0x1164,pixelSpacing,"DS"); + } +/* +///Exact meaning of RETired fields + +// See page 73 of ACR-NEMA_300-1988.pdf ! + +// 0020,0020 : Patient Orientation : +Patient direction of the first row and +column of the images. The first entry id the direction of the raws, given by the +direction of the last pixel in the first row from the first pixel in tha row. +the second entry is the direction of the columns, given by the direction of the +last pixel in the first column from the first pixel in that column. +L : Left, F : Feet, A : Anterior, P : Posterior. +Up to 3 letters can be used in combination to indicate oblique planes. + +//0020,0030 Image Position (RET) +x,y,z coordinates im mm of the first pixel in the image + +// 0020,0035 Image Orientation (RET) +Direction cosines of the R axis of the image system with respect to the +equipment coordinate axes x,y,z, followed by direction cosines of the C axis of +the image system with respect to the same axes + +//0020,0050 Location +An image location reference, standard for the modality (such as CT bed position), +used to indicate position. Calculation of position for other purposes +is only from (0020,0030) and (0020,0035) +*/ + +/* +// if imagePositionPatient not found, default it with imagePositionRet, if any +// if imageOrientationPatient not found, default it with imageOrientationRet, if any + + std::string imagePositionRet = FileInternal->GetEntryString(0x0020,0x0030); + std::string imageOrientationRet = FileInternal->GetEntryString(0x0020,0x0035); + std::string imagePositionPatient = FileInternal->GetEntryString(0x0020,0x0032); + std::string imageOrientationPatient = FileInternal->GetEntryString(0x0020,0x0037); + + if( imagePositionPatient == GDCM_UNFOUND && imageOrientationPatient == GDCM_UNFOUND + && imagePositionRet != GDCM_UNFOUND && imageOrientationRet != GDCM_UNFOUND) + { + CopyMandatoryEntry(0x0020, 0x0032,imagePositionRet,"DS"); + Archive->Push(0x0020,0x0030); + CopyMandatoryEntry(0x0020, 0x0037,imageOrientationRet,"DS"); + Archive->Push(0x0020,0x0035); + } +*/ + + // Samples Per Pixel (type 1) : default to grayscale + CheckMandatoryEntry(0x0028,0x0002,"1","US"); + + // --- Check UID-related Entries --- - // 'Image Type' (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,"UI"); + + if ( ContentType == USER_OWN_IMAGE) + { + gdcmDebugMacro( "USER_OWN_IMAGE (2)"); + // 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","CS"); // Why not? } - else +/* + if ( ContentType == CREATED_IMAGE) { - // There was no 'SOP Class UID'. - // the source image was NOT a true Dicom one. - // We consider the image is a 'Secondary Capture' one - // SOP Class UID - // [Secondary Capture Image Storage] - SetMandatoryEntry(0x0008,0x0016,"1.2.840.10008.5.1.4.1.1.7"); + /// \todo : find a trick to pass the Media Storage SOP Instance UID of the images used to create the current image + } +*/ + + // ---- The user will never have to take any action on the following ---- -// ---- The user will never have to take any action on the following ----. // new value for 'SOP Instance UID' - SetMandatoryEntry(0x0008,0x0018,Util::CreateUniqueUID()); + //SetMandatoryEntry(0x0008,0x0018,Util::CreateUniqueUID()); // Instance Creation Date - CopyMandatoryEntry(0x0008,0x0012,Util::GetCurrentDate().c_str()); - + const std::string &date = Util::GetCurrentDate(); + CopyMandatoryEntry(0x0008,0x0012,date,"DA"); + // Instance Creation Time - CopyMandatoryEntry(0x0008,0x0013,Util::GetCurrentTime().c_str()); + const std::string &time = Util::GetCurrentTime(); + CopyMandatoryEntry(0x0008,0x0013,time,"TM"); -// ----- 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 -// Entries whose type is 2 are mandatory, with a optional value -// Entries whose type is 2c are mandatory-inside-a-Sequence -// Entries whose type is 3 are optional + // Study Date + CheckMandatoryEntry(0x0008,0x0020,date,"DA"); + // Study Time + CheckMandatoryEntry(0x0008,0x0030,time,"TM"); - // '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 allowed him to do that - CheckMandatoryEntry(0x0020,0x000e,Util::CreateUniqueUID()); + // Accession Number + //CopyMandatoryEntry(0x0008,0x0050,""); + CheckMandatoryEntry(0x0008,0x0050,"","SH"); + + + // ----- 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()); + // adding new Series to an already existing Study + CheckMandatoryEntry(0x0020,0x000d,Util::CreateUniqueUID(),"UI"); + + // '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(),"UI"); + + // Study ID + CheckMandatoryEntry(0x0020,0x0010,"","SH"); + + // Series Number + CheckMandatoryEntry(0x0020,0x0011,"","IS"); + + // Instance Number + CheckMandatoryEntry(0x0020,0x0013,"","IS"); + + // Patient Orientation + // Can be computed from (0020|0037) : Image Orientation (Patient) + GDCM_NAME_SPACE::Orientation *o = GDCM_NAME_SPACE::Orientation::New(); + std::string ori = o->GetOrientation ( FileInternal ); + o->Delete(); + if (ori != "\\" && ori != GDCM_UNFOUND) + CheckMandatoryEntry(0x0020,0x0020,ori,"CS"); + else + CheckMandatoryEntry(0x0020,0x0020,"","CS"); + + // Default Patient Position to HFS + CheckMandatoryEntry(0x0018,0x5100,"HFS","CS"); // Modality : if missing we set it to 'OTher' - CheckMandatoryEntry(0x0008,0x0060,"OT"); + CheckMandatoryEntry(0x0008,0x0060,"OT","CS"); // Manufacturer : if missing we set it to 'GDCM Factory' - CheckMandatoryEntry(0x0008,0x0070,"GDCM Factory"); + CheckMandatoryEntry(0x0008,0x0070,"GDCM Factory","LO"); // Institution Name : if missing we set it to 'GDCM Hospital' - CheckMandatoryEntry(0x0008,0x0080,"GDCM Hospital"); + CheckMandatoryEntry(0x0008,0x0080,"GDCM Hospital","LO"); // Patient's Name : if missing, we set it to 'GDCM^Patient' - CheckMandatoryEntry(0x0010,0x0010,"GDCM^Patient"); + CheckMandatoryEntry(0x0010,0x0010,"GDCM^Patient","PN"); + + // Patient ID : some clinical softwares *demand* it although it's a 'type 2' entry. + CheckMandatoryEntry(0x0010,0x0020,"gdcm ID","LO"); // Patient's Birth Date : 'type 2' entry -> must exist, value not mandatory - CheckMandatoryEntry(0x0010,0x0030,""); + CheckMandatoryEntry(0x0010,0x0030,"","DA"); // Patient's Sex :'type 2' entry -> must exist, value not mandatory - CheckMandatoryEntry(0x0010,0x0040,""); + CheckMandatoryEntry(0x0010,0x0040,"","CS"); // Referring Physician's Name :'type 2' entry -> must exist, value not mandatory - CheckMandatoryEntry(0x0008,0x0090,""); + CheckMandatoryEntry(0x0008,0x0090,"","PN"); + + /* + // 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 +*/ - // Pixel Spacing : defaulted to 1.0\1.0 - CheckMandatoryEntry(0x0028,0x0030,"1.0\\1.0"); - - // 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 ) + if (PhotometricInterpretation == 1) { - Archive->Push(0x0020, 0X0052); } } -void FileHelper::CheckMandatoryEntry(uint16_t group,uint16_t elem,std::string value) +void FileHelper::CheckMandatoryEntry(uint16_t group,uint16_t elem,std::string value,const VRKey &vr ) { DataEntry *entry = FileInternal->GetDataEntry(group,elem); if ( !entry ) { - entry = new DataEntry(Global::GetDicts()->GetDefaultPubDict()->GetEntry(group,elem)); + //entry = DataEntry::New(Global::GetDicts()->GetDefaultPubDict()->GetEntry(group,elem)); + entry = DataEntry::New(group,elem,vr); entry->SetString(value); Archive->Push(entry); - } + entry->Delete(); + } } -void FileHelper::SetMandatoryEntry(uint16_t group,uint16_t elem,std::string value) +/// \todo : what is it used for ? (FileHelper::SetMandatoryEntry) +void FileHelper::SetMandatoryEntry(uint16_t group,uint16_t elem,std::string value,const VRKey &vr) { - DataEntry *entry = new DataEntry(Global::GetDicts()->GetDefaultPubDict()->GetEntry(group,elem)); + //DataEntry *entry = DataEntry::New(Global::GetDicts()->GetDefaultPubDict()->GetEntry(group,elem)); + DataEntry *entry = DataEntry::New(group,elem,vr); entry->SetString(value); Archive->Push(entry); + entry->Delete(); } -void FileHelper::CopyMandatoryEntry(uint16_t group,uint16_t elem,std::string value) +void FileHelper::CopyMandatoryEntry(uint16_t group,uint16_t elem,std::string value,const VRKey &vr) { - DataEntry *entry = CopyDataEntry(group,elem); + DataEntry *entry = CopyDataEntry(group,elem,vr); entry->SetString(value); Archive->Push(entry); + entry->Delete(); } /** @@ -1430,6 +1955,8 @@ void FileHelper::RestoreWriteMandatory() 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); @@ -1446,7 +1973,33 @@ void FileHelper::RestoreWriteMandatory() Archive->Restore(0x0020,0x000d); Archive->Restore(0x0020,0x000e); +} + +/** + * \brief CallStartMethod + */ +void FileHelper::CallStartMethod() +{ + Progress = 0.0f; + Abort = false; + CommandManager::ExecuteCommand(this,CMD_STARTPROGRESS); +} + +/** + * \brief CallProgressMethod + */ +void FileHelper::CallProgressMethod() +{ + CommandManager::ExecuteCommand(this,CMD_PROGRESS); +} +/** + * \brief CallEndMethod + */ +void FileHelper::CallEndMethod() +{ + Progress = 1.0f; + CommandManager::ExecuteCommand(this,CMD_ENDPROGRESS); } //----------------------------------------------------------------------------- @@ -1457,13 +2010,18 @@ void FileHelper::RestoreWriteMandatory() void FileHelper::Initialize() { UserFunction = 0; + ContentType = USER_OWN_IMAGE; WriteMode = WMODE_RAW; WriteType = ExplicitVR; + + PhotometricInterpretation = 2; // Black = 0 PixelReadConverter = new PixelReadConvert; PixelWriteConverter = new PixelWriteConvert; Archive = new DocEntryArchive( FileInternal ); + + KeepOverlays = false; } /** @@ -1495,9 +2053,95 @@ uint8_t *FileHelper::GetRaw() return raw; } +/** + * \brief Deal with Grey levels i.e. re-arange them + * to have low values = dark, high values = bright + */ +void FileHelper::ConvertFixGreyLevels(uint8_t *raw, size_t rawSize) +{ + uint32_t i; // to please M$VC6 + int16_t j; + + // Number of Bits Allocated for storing a Pixel is defaulted to 16 + // when absent from the file. + int bitsAllocated = FileInternal->GetBitsAllocated(); + if ( bitsAllocated == 0 ) + { + bitsAllocated = 16; + } + + else if (bitsAllocated > 8 && bitsAllocated < 16 && bitsAllocated != 12) + { + bitsAllocated = 16; + } + // Number of "Bits Stored", defaulted to number of "Bits Allocated" + // when absent from the file. + int bitsStored = FileInternal->GetBitsStored(); + if ( bitsStored == 0 ) + { + bitsStored = bitsAllocated; + } + + if (!FileInternal->IsSignedPixelData()) + { + if ( bitsAllocated == 8 ) + { + uint8_t *deb = (uint8_t *)raw; + for (i=0; i +void RescaleFunction(TBuffer* buffer, TSource *source, + double slope, double intercept, size_t size) +{ + size /= sizeof(TSource); + + if (slope != 1.0 && intercept != 0.0) + { + // Duff's device. Instead of this code: + // + // for(unsigned int i=0; i 0); + } + } + else if (slope == 1.0 && intercept != 0.0) + { + // Duff's device. Instead of this code: + // + // for(unsigned int i=0; i 0); + } + } + else if (slope != 1.0 && intercept == 0.0) + { + // Duff's device. Instead of this code: + // + // for(unsigned int i=0; i 0); + } + } + else + { + // Duff's device. Instead of this code: + // + // for(unsigned int i=0; i 0); + } + } +} + + +template +void RescaleFunction(ImageIOBase::IOComponentType bufferType, + void* buffer, TSource *source, + double slope, double intercept, size_t size) +{ + switch (bufferType) + { + case ImageIOBase::UCHAR: + RescaleFunction( (unsigned char *)buffer, source, slope, intercept, size); + break; + case ImageIOBase::CHAR: + RescaleFunction( (char *)buffer, source, slope, intercept, size); + break; + case ImageIOBase::USHORT: + RescaleFunction( (unsigned short *)buffer, source, slope, intercept,size); + break; + case ImageIOBase::SHORT: + RescaleFunction( (short *)buffer, source, slope, intercept, size); + break; + case ImageIOBase::UINT: + RescaleFunction( (unsigned int *)buffer, source, slope, intercept, size); + break; + case ImageIOBase::INT: + RescaleFunction( (int *)buffer, source, slope, intercept, size); + break; + case ImageIOBase::FLOAT: + RescaleFunction( (float *)buffer, source, slope, intercept, size); + break; + case ImageIOBase::DOUBLE: + RescaleFunction( (double *)buffer, source, slope, intercept, size); + break; + default: + ::itk::OStringStream message; + message << "itk::ERROR: GDCMImageIO: Unknown component type : " << bufferType; + ::itk::ExceptionObject e(__FILE__, __LINE__, message.str().c_str(),ITK_LOCATION); + throw e; + } +} +*/