Program: gdcm
Module: $RCSfile: gdcmFileHelper.cxx,v $
Language: C++
- Date: $Date: 2005/02/23 09:54:59 $
- Version: $Revision: 1.20 $
+
+ Date: $Date: 2006/07/06 12:38:06 $
+ Version: $Revision: 1.108 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
#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 "gdcmDocEntry.h"
#include "gdcmFile.h"
#include "gdcmPixelReadConvert.h"
#include "gdcmPixelWriteConvert.h"
#include "gdcmDocEntryArchive.h"
#include "gdcmDictSet.h"
+#include "gdcmOrientation.h"
+
+#if defined(__BORLANDC__)
+ #include <mem.h> // for memset
+#endif
#include <fstream>
+/*
+// ----------------------------- 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<uint16_t, int> GroupHT; // Hash Table
//-------------------------------------------------------------------------
// Constructor / Destructor
/**
* 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
* seen as a side effect).
*/
FileHelper::FileHelper( )
-{
- FileInternal = new File( );
- SelfHeader = true;
+{
+ FileInternal = File::New( );
Initialize();
}
* 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
*/
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 );
+ }
}
/**
*/
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 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 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
+ * @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,
+ VRKey const &vr )
{
- return FileInternal->InsertValEntry(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 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 Represenation of the DataElement to be inserted
+ * \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,
+ VRKey const &vr )
{
- return FileInternal->InsertBinEntry(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)
{
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)
{
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()
}
/**
- * \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();
}
-/**
- * \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
* @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() )
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 )
}
/**
- * \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)
*/
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".
*/
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
/**
* \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
*/
bool FileHelper::Write(std::string const &fileName)
{
+
+ CheckMandatoryElements(); //called once, here !
+
+ bool flag = false;
+ DocEntry *e;
switch(WriteType)
{
case ImplicitVR:
SetWriteFileTypeToImplicitVR();
- CheckMandatoryElements();
break;
+
+ case Unknown: // should never happen; ExplicitVR is the default value
case ExplicitVR:
- SetWriteFileTypeToExplicitVR();
- CheckMandatoryElements();
+
+ // User should ask gdcm to write an image in Explicit VR mode
+ // only when he is sure *all* the VR of *all* the DataElements is known.
+ // i.e : when there are *only* Public Groups
+ // or *all* the Shadow Groups are fully described in the relevant Shadow
+ // Dictionnary
+ // Let's just *dream* about it; *never* trust a user !
+ // We turn to Implicit VR if at least the VR of one element is unknown.
+
+
+ e = FileInternal->GetFirstEntry();
+ while (e != 0)
+ {
+ if (e->GetVR() == " ")
+ {
+ SetWriteTypeToDcmImplVR();
+ SetWriteFileTypeToImplicitVR();
+ flag = true;
+ break;
+ }
+ e = FileInternal->GetNextEntry();
+ }
+
+ if (!flag)
+ {
+ SetWriteFileTypeToExplicitVR();
+ }
break;
+
+ SetWriteFileTypeToExplicitVR(); // to see JPRx
+ 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, "LO");
SetWriteFileTypeToACR();
+ // SetWriteFileTypeToImplicitVR(); // ACR IS implicit VR !
+ break;
+
+ /// \todo FIXME : JPEG may be either ExplicitVR or ImplicitVR
+ case JPEG:
+ SetWriteFileTypeToJPEG();
+ break;
+
+ case JPEG2000:
+ SetWriteFileTypeToJPEG2000();
break;
- default:
- SetWriteFileTypeToExplicitVR();
- CheckMandatoryElements();
}
// --------------------------------------------------------------
// 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();
}
}
bool check = CheckWriteIntegrity(); // verifies length
- if(check)
+ if (WriteType == JPEG || WriteType == JPEG2000) check = true;
+ if (check)
{
check = FileInternal->Write(fileName,WriteType);
}
- RestoreWrite();
- RestoreWriteFileType();
+ RestoreWrite();
+ // RestoreWriteFileType();
+ // RestoreWriteMandatory();
+
// --------------------------------------------------------------
// Special Patch to allow gdcm to re-write ACR-LibIDO formated images
*/
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->GetTSize()
+ * 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 :"
}
break;
case WMODE_RGB :
- if( rgbSize!=PixelWriteConverter->GetUserDataSize() )
+ if ( rgbSize!=PixelWriteConverter->GetUserDataSize() )
{
gdcmWarningMacro( "Data size (RGB) is incorrect. Should be "
<< decSize << " / Found "
break;
}
}
-
+
return true;
}
*/
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,"CS");
+ 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);
+ // For non RAW data. Mainly JPEG
+ 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());
Archive->Push(photInt);
Archive->Push(pixel);
+
+ photInt->Delete();
+ pixel->Delete();
}
}
*/
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,"US");
+ spp->SetString("3 ");
- ValEntry *planConfig = CopyValEntry(0x0028,0x0006);
- planConfig->SetValue("0 ");
+ DataEntry *planConfig = CopyDataEntry(0x0028,0x0006,"US");
+ planConfig->SetString("0 ");
- ValEntry *photInt = CopyValEntry(0x0028,0x0004);
- photInt->SetValue("RGB ");
+ DataEntry *photInt = CopyDataEntry(0x0028,0x0004,"CS");
+ photInt->SetString("RGB ");
- if(PixelReadConverter->GetRGB())
+ if ( PixelReadConverter->GetRGB() )
{
PixelWriteConverter->SetReadData(PixelReadConverter->GetRGB(),
PixelReadConverter->GetRGBSize());
}
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);
+ spp->Delete();
+ planConfig->Delete();
+ photInt->Delete();
+ pixel->Delete();
+
// Remove any LUT
Archive->Push(0x0028,0x1101);
Archive->Push(0x0028,0x1102);
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,"US");
+ bitsAlloc->SetString("8 ");
- ValEntry *bitsStored = CopyValEntry(0x0028,0x0101);
- bitsStored->SetValue("8 ");
+ DataEntry *bitsStored = CopyDataEntry(0x0028,0x0101,"US");
+ bitsStored->SetString("8 ");
- ValEntry *highBit = CopyValEntry(0x0028,0x0102);
- highBit->SetValue("7 ");
+ 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
*/
void FileHelper::RestoreWrite()
{
+
Archive->Restore(0x0028,0x0002);
Archive->Restore(0x0028,0x0004);
+
Archive->Restore(0x0028,0x0006);
Archive->Restore(GetFile()->GetGrPixel(),GetFile()->GetNumPixel());
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);
Archive->Restore(0x0002,0x0016);
Archive->Restore(0x0002,0x0100);
Archive->Restore(0x0002,0x0102);
+
}
/**
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);
Archive->Push(0x0002,0x0102);
}
+ /**
+ * \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) );
+
+ 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"
*/
std::string ts = Util::DicomString(
Global::GetTS()->GetSpecialTransferSyntax(TS::ExplicitVRLittleEndian) );
- ValEntry *tss = CopyValEntry(0x0002,0x0010);
- tss->SetValue(ts);
-
+ DataEntry *tss = CopyDataEntry(0x0002,0x0010,"UI");
+ tss->SetString(ts);
Archive->Push(tss);
+ tss->Delete();
}
/**
std::string ts = Util::DicomString(
Global::GetTS()->GetSpecialTransferSyntax(TS::ImplicitVRLittleEndian) );
- ValEntry *tss = CopyValEntry(0x0002,0x0010);
- tss->SetValue(ts);
-
+ DataEntry *tss = CopyDataEntry(0x0002,0x0010,"UI");
+ tss->SetString(ts);
Archive->Push(tss);
+ tss->Delete();
}
*/
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);
}
/**
*/
void FileHelper::SetWriteToLibido()
{
- ValEntry *oldRow = dynamic_cast<ValEntry *>
- (FileInternal->GetDocEntry(0x0028, 0x0010));
- ValEntry *oldCol = dynamic_cast<ValEntry *>
- (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());
+
+ DataEntry *newRow=DataEntry::New(0x0028, 0x0010, "US");
+ DataEntry *newCol=DataEntry::New(0x0028, 0x0011, "US");
+
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,"LO");
+ libidoCode->SetString("ACRNEMA_LIBIDO_1.1");
Archive->Push(libidoCode);
+ libidoCode->Delete();
}
/**
*/
void FileHelper::SetWriteToNoLibido()
{
- ValEntry *recCode = dynamic_cast<ValEntry *>
- (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,"LO");
+ libidoCode->SetString("");
Archive->Push(libidoCode);
+ libidoCode->Delete();
}
}
}
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 VRKey &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 = DataEntry::New(group, elem, vr);
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 ?
+
+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
+
+gdcm::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) TODO : 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::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()
{
- // just to remember : 'official' 0002 group
+ std::string sop = Util::CreateUniqueUID();
+ // --------------------- For Meta Elements ---------------------
+ // 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
//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);*/
+ // 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","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();
+
+ 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'
-/* 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 :
+ // seems to be Root UID + 4 digits (?)
+ CopyMandatoryEntry(0x0002,0x0012,Util::CreateUniqueUID(),"UI");
// '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,"SH");
+ }
- // Push out 'LibIDO-special' entries, if any
- Archive->Push(0x0028,0x0015);
- Archive->Push(0x0028,0x0016);
- Archive->Push(0x0028,0x0017);
- Archive->Push(0x0028,0x00199);
+ // --------------------- For DataSet ---------------------
- // --- Check UID-related Entries ---
-
- // If 'SOP Class UID' exists ('true DICOM' image)
- ValEntry *e0008_0016 = FileInternal->GetValEntry(0x0008, 0x0016);
- if ( e0008_0016 != 0 )
- {
-/* // Create 'Source Image Sequence' SeqEntry
- SeqEntry *s = new SeqEntry (
- Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x2112) );
- SQItem *sqi = new SQItem(1);
+ if ( ContentType != USER_OWN_IMAGE) // when it's not a user made image
+ {
+
+ gdcmDebugMacro( "USER_OWN_IMAGE (1)");
+ // If 'SOP Class UID' exists ('true DICOM' image)
+ // 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 *sis = SeqEntry::New (
+// Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x2112) );
+ SeqEntry *sis = SeqEntry::New (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) );
+ 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'
- ValEntry *e0008_0018 = FileInternal->GetValEntry(0x0008, 0x0018);
- ValEntry *e0008_1155 = new ValEntry(
- Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x1155) );
- e0008_1155->SetValue( e0008_0018->GetValue());
- sqi->AddEntry(e0008_1155);
+ DataEntry *e_0008_0018 = FileInternal->GetDataEntry(0x0008, 0x0018);
+// DataEntry *e_0008_1155 = DataEntry::New(
+// Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x1155) );
+ 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();
- 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);*/
- }
+ // 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
+ // the image is no longer an 'Original' one
+ 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
{
- // 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); */
+ // 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");
}
-
- // 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);
-
- // Instance Creation Date
- ValEntry *e0008_0012 = CopyValEntry(0x0008,0x0012);
- std::string date = Util::GetCurrentDate();
- e0008_0012->SetValue(date.c_str());
- Archive->Push(e0008_0012);
+
+ 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,0x0198); // very old versions
+ Archive->Push(0x0028,0x0199);
- // 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);
-*/
-
-// ----- Add Mandatory Entries if missing ---
-
-// 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
-
-// ValEntry *e;
-
- // Modality
-/* ValEntry *e0008_0060 = FileInternal->GetValEntry(0x0008, 0x0060);
- if ( !e0008_0060 )
+ // 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 )
{
- e0008_0060 = new ValEntry(
- Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x0060) );
- e0008_0060->SetValue("OT");
- Archive->Push(e0008_0060);
- }
+ CopyMandatoryEntry(0x0028, 0x0008,e_0028_0012->GetString(),"IS");
+ Archive->Push(0x0028,0x0012);
+ }
- // Manufacturer
- ValEntry *e0008_0070 = FileInternal->GetValEntry(0x0008, 0x0070);
- if ( !e0008_0070 )
+ // Deal with the pb of (Bits Stored = 12)
+ // - we're gonna write the image as Bits Stored = 16
+ if ( FileInternal->GetEntryString(0x0028,0x0100) == "12")
{
- e0008_0070 = new ValEntry(
- Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x0070) );
- e0008_0070->SetValue("GDCM Factory");
- Archive->Push(e0008_0070);
+ CopyMandatoryEntry(0x0028,0x0100,"16","US");
}
- // Institution Name
- ValEntry *e0008_0080 = FileInternal->GetValEntry(0x0008, 0x0080);
- if ( !e0008_0080 )
+ // Check if user wasn't drunk ;-)
+
+ std::ostringstream s;
+ // check 'Bits Allocated' vs decent values
+ int nbBitsAllocated = FileInternal->GetBitsAllocated();
+ if ( nbBitsAllocated == 0 || nbBitsAllocated > 32)
{
- e0008_0080 = new ValEntry(
- Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x0080) );
- e0008_0080->SetValue("GDCM Hospital");
- Archive->Push(e0008_0080);
+ CopyMandatoryEntry(0x0028,0x0100,"16","US");
+ gdcmWarningMacro("(0028,0100) changed from "
+ << nbBitsAllocated << " to 16 for consistency purpose");
+ nbBitsAllocated = 16;
}
-
- // Patient's Name
- ValEntry *e0010_0010 = FileInternal->GetValEntry(0x0010, 0x0010);
- if ( !e0010_0010 )
+ // check 'Bits Stored' vs 'Bits Allocated'
+ int nbBitsStored = FileInternal->GetBitsStored();
+ if ( nbBitsStored == 0 || nbBitsStored > nbBitsAllocated )
+ {
+ s.str("");
+ s << nbBitsAllocated;
+ CopyMandatoryEntry(0x0028,0x0101,s.str(),"US");
+ 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 )
{
- e0010_0010 = new ValEntry(
- Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0010, 0x0010) );
- e0010_0010->SetValue("GDCM_Patient");
- Archive->Push(e0010_0010);
+ s.str("");
+ s << nbBitsStored - 1;
+ CopyMandatoryEntry(0x0028,0x0102,s.str(),"US");
+ gdcmWarningMacro("(0028,0102) changed from "
+ << highBitPosition << " to " << nbBitsAllocated-1
+ << " for consistency purpose");
}
- // Patient's ID
- ValEntry *e_0010_0020 = FileInternal->GetValEntry(0x0010, 0x0020);
- if ( !e )
+ std::string pixelSpacing = FileInternal->GetEntryString(0x0028,0x0030);
+ if ( pixelSpacing == GDCM_UNFOUND )
{
- e_0010_0020 = new ValEntry(
- Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0010, 0x0020) );
- e_0010_0020->SetValue("GDCM_Patient_ID");
- Archive->Push(e_0010_0020);
+ 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.
- // Patient's Birth Date
- ValEntry *e_0010_0030 = FileInternal->GetValEntry(0x0010, 0x0030);
- if ( !e_0010_0030 )
+//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)
{
- e_0010_0030 = new ValEntry(
- Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0010, 0x0030) );
- e_0010_0030->SetValue("");
- Archive->Push(e_0010_0030);
- }
+ 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 ---
+
+ // 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");
- // Patient's Sex
- ValEntry *e_0010_0040 = FileInternal->GetValEntry(0x0010, 0x0040);
- if ( !e_0010_0040 )
+ if ( ContentType == USER_OWN_IMAGE)
{
- e_0010_0040 = new ValEntry(
- Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0010, 0x0040) );
- e_0010_0040->SetValue("");
- Archive->Push(e_0010_0040);
+ 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?
+ }
+/*
+ if ( ContentType == CREATED_IMAGE)
+ {
+ /// \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 ----
- // 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);
- }*/
-}
+ // new value for 'SOP Instance UID'
+ //SetMandatoryEntry(0x0008,0x0018,Util::CreateUniqueUID());
+
+ // Instance Creation Date
+ const std::string &date = Util::GetCurrentDate();
+ CopyMandatoryEntry(0x0008,0x0012,date,"DA");
+ // Instance Creation Time
+ const std::string &time = Util::GetCurrentTime();
+ CopyMandatoryEntry(0x0008,0x0013,time,"TM");
+
+ // Study Date
+ CheckMandatoryEntry(0x0008,0x0020,date,"DA");
+ // Study Time
+ CheckMandatoryEntry(0x0008,0x0030,time,"TM");
+
+ // 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(),"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::Orientation *o = gdcm::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","CS");
+
+ // Manufacturer : if missing we set it to 'GDCM Factory'
+ CheckMandatoryEntry(0x0008,0x0070,"GDCM Factory","LO");
+
+ // Institution Name : if missing we set it to 'GDCM Hospital'
+ CheckMandatoryEntry(0x0008,0x0080,"GDCM Hospital","LO");
+
+ // Patient's Name : if missing, we set it to '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,"","DA");
+
+ // Patient's Sex :'type 2' entry -> must exist, value not mandatory
+ CheckMandatoryEntry(0x0010,0x0040,"","CS");
+
+ // Referring Physician's Name :'type 2' entry -> must exist, value not mandatory
+ 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
+*/
+
+}
+
+void FileHelper::CheckMandatoryEntry(uint16_t group,uint16_t elem,std::string value,const VRKey &vr )
+{
+ DataEntry *entry = FileInternal->GetDataEntry(group,elem);
+ if ( !entry )
+ {
+ //entry = DataEntry::New(Global::GetDicts()->GetDefaultPubDict()->GetEntry(group,elem));
+ entry = DataEntry::New(group,elem,vr);
+ entry->SetString(value);
+ Archive->Push(entry);
+ entry->Delete();
+ }
+}
+
+/// \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 = 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,const VRKey &vr)
+{
+ DataEntry *entry = CopyDataEntry(group,elem,vr);
+ 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);
+}
+
+
+/**
+ * \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);
+}
+
//-----------------------------------------------------------------------------
// Private
/**
*/
void FileHelper::Initialize()
{
+ UserFunction = 0;
+ ContentType = USER_OWN_IMAGE;
+
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();
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);
+ }
}
//-----------------------------------------------------------------------------
} // end namespace gdcm
+
+
+/* Probabely something to be added to use Rescale Slope/Intercept
+Have a look ,at ITK code !
+
+// Internal function to rescale pixel according to Rescale Slope/Intercept
+template<class TBuffer, class TSource>
+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<size; i++)
+ // {
+ // buffer[i] = (TBuffer)(source[i]*slope + intercept);
+ // }
+ //
+ // use Duff's device which exploits "fall through"
+ register size_t n = (size + 7) / 8;
+ switch ( size % 8)
+ {
+ case 0: do { *buffer++ = (TBuffer)((*source++)*slope + intercept);
+ case 7: *buffer++ = (TBuffer)((*source++)*slope + intercept);
+ case 6: *buffer++ = (TBuffer)((*source++)*slope + intercept);
+ case 5: *buffer++ = (TBuffer)((*source++)*slope + intercept);
+ case 4: *buffer++ = (TBuffer)((*source++)*slope + intercept);
+ case 3: *buffer++ = (TBuffer)((*source++)*slope + intercept);
+ case 2: *buffer++ = (TBuffer)((*source++)*slope + intercept);
+ case 1: *buffer++ = (TBuffer)((*source++)*slope + intercept);
+ } while (--n > 0);
+ }
+ }
+ else if (slope == 1.0 && intercept != 0.0)
+ {
+ // Duff's device. Instead of this code:
+ //
+ // for(unsigned int i=0; i<size; i++)
+ // {
+ // buffer[i] = (TBuffer)(source[i] + intercept);
+ // }
+ //
+ // use Duff's device which exploits "fall through"
+ register size_t n = (size + 7) / 8;
+ switch ( size % 8)
+ {
+ case 0: do { *buffer++ = (TBuffer)(*source++ + intercept);
+ case 7: *buffer++ = (TBuffer)(*source++ + intercept);
+ case 6: *buffer++ = (TBuffer)(*source++ + intercept);
+ case 5: *buffer++ = (TBuffer)(*source++ + intercept);
+ case 4: *buffer++ = (TBuffer)(*source++ + intercept);
+ case 3: *buffer++ = (TBuffer)(*source++ + intercept);
+ case 2: *buffer++ = (TBuffer)(*source++ + intercept);
+ case 1: *buffer++ = (TBuffer)(*source++ + intercept);
+ } while (--n > 0);
+ }
+ }
+ else if (slope != 1.0 && intercept == 0.0)
+ {
+ // Duff's device. Instead of this code:
+ //
+ // for(unsigned int i=0; i<size; i++)
+ // {
+ // buffer[i] = (TBuffer)(source[i]*slope);
+ // }
+ //
+ // use Duff's device which exploits "fall through"
+ register size_t n = (size + 7) / 8;
+ switch ( size % 8)
+ {
+ case 0: do { *buffer++ = (TBuffer)((*source++)*slope);
+ case 7: *buffer++ = (TBuffer)((*source++)*slope);
+ case 6: *buffer++ = (TBuffer)((*source++)*slope);
+ case 5: *buffer++ = (TBuffer)((*source++)*slope);
+ case 4: *buffer++ = (TBuffer)((*source++)*slope);
+ case 3: *buffer++ = (TBuffer)((*source++)*slope);
+ case 2: *buffer++ = (TBuffer)((*source++)*slope);
+ case 1: *buffer++ = (TBuffer)((*source++)*slope);
+ } while (--n > 0);
+ }
+ }
+ else
+ {
+ // Duff's device. Instead of this code:
+ //
+ // for(unsigned int i=0; i<size; i++)
+ // {
+ // buffer[i] = (TBuffer)(source[i]);
+ // }
+ //
+ // use Duff's device which exploits "fall through"
+ register size_t n = (size + 7) / 8;
+ switch ( size % 8)
+ {
+ case 0: do { *buffer++ = (TBuffer)(*source++);
+ case 7: *buffer++ = (TBuffer)(*source++);
+ case 6: *buffer++ = (TBuffer)(*source++);
+ case 5: *buffer++ = (TBuffer)(*source++);
+ case 4: *buffer++ = (TBuffer)(*source++);
+ case 3: *buffer++ = (TBuffer)(*source++);
+ case 2: *buffer++ = (TBuffer)(*source++);
+ case 1: *buffer++ = (TBuffer)(*source++);
+ } while (--n > 0);
+ }
+ }
+
+
+}
+
+
+template<class TSource>
+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;
+ }
+}
+*/
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff