Program: gdcm
Module: $RCSfile: gdcmFile.cxx,v $
Language: C++
- Date: $Date: 2004/11/16 05:03:35 $
- Version: $Revision: 1.156 $
+ Date: $Date: 2004/11/24 16:39:18 $
+ Version: $Revision: 1.162 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
#include "gdcmFile.h"
#include "gdcmDebug.h"
#include "gdcmUtil.h"
+#include "gdcmBinEntry.h"
#include <fstream>
namespace gdcm
*/
void File::Initialise()
{
- PixelConverter = NULL; //just in case
+ WriteMode = WMODE_DECOMPRESSED;
+ WriteType = WTYPE_IMPL_VR;
+
+ PixelConverter = new PixelConvert;
+ Archive = new DocEntryArchive( HeaderInternal );
+
if ( HeaderInternal->IsReadable() )
{
ImageDataSizeRaw = ComputeDecompressedPixelDataSizeFromHeader();
ImageDataSize = ImageDataSizeRaw;
}
- PixelConverter = new PixelConvert; //LEAK !
PixelConverter->GrabInformationsFromHeader( HeaderInternal );
}
+
SaveInitialValues();
}
*/
File::~File()
{
- if( SelfHeader )
+ if( PixelConverter )
{
- delete HeaderInternal;
+ delete PixelConverter;
+ }
+ if( Archive )
+ {
+ delete Archive;
}
- HeaderInternal = 0;
- DeleteInitialValues();
- if( PixelConverter )
+ if( SelfHeader )
{
- delete PixelConverter;
+ delete HeaderInternal;
}
+ HeaderInternal = 0;
}
/**
*/
void File::SaveInitialValues()
{
-
PixelRead = -1; // no ImageData read yet.
- LastAllocatedPixelDataLength = 0;
Pixel_Data = 0;
-
- InitialSpp = "";
- InitialPhotInt = "";
- InitialPlanConfig = "";
- InitialBitsAllocated = "";
- InitialHighBit = "";
-
- InitialRedLUTDescr = 0;
- InitialGreenLUTDescr = 0;
- InitialBlueLUTDescr = 0;
- InitialRedLUTData = 0;
- InitialGreenLUTData = 0;
- InitialBlueLUTData = 0;
-
- if ( HeaderInternal->IsReadable() )
- {
- // the following values *may* be modified
- // by File::GetImageDataIntoVectorRaw
- // we save their initial value.
- InitialSpp = HeaderInternal->GetEntryByNumber(0x0028,0x0002);
- InitialPhotInt = HeaderInternal->GetEntryByNumber(0x0028,0x0004);
- InitialPlanConfig = HeaderInternal->GetEntryByNumber(0x0028,0x0006);
-
- InitialBitsAllocated = HeaderInternal->GetEntryByNumber(0x0028,0x0100);
- InitialHighBit = HeaderInternal->GetEntryByNumber(0x0028,0x0102);
-
- // the following entries *may* be removed from the H table
- // (NOT deleted ...) by File::GetImageDataIntoVectorRaw
- // we keep a pointer on them.
- InitialRedLUTDescr = HeaderInternal->GetDocEntryByNumber(0x0028,0x1101);
- InitialGreenLUTDescr = HeaderInternal->GetDocEntryByNumber(0x0028,0x1102);
- InitialBlueLUTDescr = HeaderInternal->GetDocEntryByNumber(0x0028,0x1103);
-
- InitialRedLUTData = HeaderInternal->GetDocEntryByNumber(0x0028,0x1201);
- InitialGreenLUTData = HeaderInternal->GetDocEntryByNumber(0x0028,0x1202);
- InitialBlueLUTData = HeaderInternal->GetDocEntryByNumber(0x0028,0x1203);
- }
-}
-
-/**
- * \brief restores some initial values
- * \warning not end user intended
- */
-void File::RestoreInitialValues()
-{
- if ( HeaderInternal->IsReadable() )
- {
- // the following values *may* have been modified
- // by File::GetImageDataIntoVectorRaw
- // we restore their initial value.
- if ( InitialSpp != "")
- HeaderInternal->SetEntryByNumber(InitialSpp,0x0028,0x0002);
- if ( InitialPhotInt != "")
- HeaderInternal->SetEntryByNumber(InitialPhotInt,0x0028,0x0004);
- if ( InitialPlanConfig != "")
-
- HeaderInternal->SetEntryByNumber(InitialPlanConfig,0x0028,0x0006);
- if ( InitialBitsAllocated != "")
- HeaderInternal->SetEntryByNumber(InitialBitsAllocated,0x0028,0x0100);
- if ( InitialHighBit != "")
- HeaderInternal->SetEntryByNumber(InitialHighBit,0x0028,0x0102);
-
- // the following entries *may* be have been removed from the H table
- // (NOT deleted ...) by File::GetImageDataIntoVectorRaw
- // we restore them.
-
- if (InitialRedLUTDescr)
- HeaderInternal->AddEntry(InitialRedLUTDescr);
- if (InitialGreenLUTDescr)
- HeaderInternal->AddEntry(InitialGreenLUTDescr);
- if (InitialBlueLUTDescr)
- HeaderInternal->AddEntry(InitialBlueLUTDescr);
-
- if (InitialRedLUTData)
- HeaderInternal->AddEntry(InitialBlueLUTDescr);
- if (InitialGreenLUTData)
- HeaderInternal->AddEntry(InitialGreenLUTData);
- if (InitialBlueLUTData)
- HeaderInternal->AddEntry(InitialBlueLUTData);
- }
-}
-
-/**
- * \brief delete initial values (il they were saved)
- * of InitialLutDescriptors and InitialLutData
- */
-void File::DeleteInitialValues()
-{
-
-// InitialLutDescriptors and InitialLutData
-// will have to be deleted if the don't belong any longer
-// to the Header H table when the header is deleted...
-
- if ( InitialRedLUTDescr )
- delete InitialRedLUTDescr;
-
- if ( InitialGreenLUTDescr )
- delete InitialGreenLUTDescr;
-
- if ( InitialBlueLUTDescr )
- delete InitialBlueLUTDescr;
-
- if ( InitialRedLUTData )
- delete InitialRedLUTData;
-
- if ( InitialGreenLUTData != NULL)
- delete InitialGreenLUTData;
-
- if ( InitialBlueLUTData != NULL)
- delete InitialBlueLUTData;
}
//-----------------------------------------------------------------------------
return DecompressedSize;
}
+/// Accessor to \ref ImageDataSize
+size_t File::GetImageDataSize()
+{
+ if ( ! GetDecompressed() )
+ {
+ // If the decompression failed nothing can be done.
+ return 0;
+ }
+
+ if ( HeaderInternal->HasLUT() && PixelConverter->BuildRGBImage() )
+ {
+ return PixelConverter->GetRGBSize();
+ }
+ else
+ {
+ // When no LUT or LUT conversion fails, return the decompressed
+ return PixelConverter->GetDecompressedSize();
+ }
+}
+
+/// Accessor to \ref ImageDataSizeRaw
+size_t File::GetImageDataSizeRaw()
+{
+ if ( ! GetDecompressed() )
+ {
+ // If the decompression failed nothing can be done.
+ return 0;
+ }
+ return PixelConverter->GetDecompressedSize();
+}
+
/**
* \brief - Allocates necessary memory,
* - Reads the pixels from disk (uncompress if necessary),
return 0;
}
- uint8_t* pixelData;
if ( HeaderInternal->HasLUT() && PixelConverter->BuildRGBImage() )
{
- pixelData = PixelConverter->GetRGB();
+ return PixelConverter->GetRGB();
}
else
{
// When no LUT or LUT conversion fails, return the decompressed
- pixelData = PixelConverter->GetDecompressed();
- }
-
-// PIXELCONVERT CLEANME
- // Restore the header in a disk-consistent state
- // (if user asks twice to get the pixels from disk)
- if ( PixelRead != -1 ) // File was "read" before
- {
- RestoreInitialValues();
- }
- if ( PixelConverter->GetRGB() )
- {
- // now, it's an RGB image
- // Lets's write it in the Header
- std::string spp = "3"; // Samples Per Pixel
- HeaderInternal->SetEntryByNumber(spp,0x0028,0x0002);
- std::string rgb = "RGB "; // Photometric Interpretation
- HeaderInternal->SetEntryByNumber(rgb,0x0028,0x0004);
- std::string planConfig = "0"; // Planar Configuration
- HeaderInternal->SetEntryByNumber(planConfig,0x0028,0x0006);
- PixelRead = 0; // no PixelRaw
+ return PixelConverter->GetDecompressed();
}
- else
- {
- if ( HeaderInternal->HasLUT() )
- {
- // The LUT interpretation failed
- std::string photometricInterpretation = Util::DicomString("MONOCHROME1");
- HeaderInternal->SetEntryByNumber( photometricInterpretation,
- 0x0028, 0x0004 );
- PixelRead = 0; // no PixelRaw
- }
- else
- {
- if ( PixelConverter->IsDecompressedRGB() )
- {
- ///////////////////////////////////////////////////
- // now, it's an RGB image
- // Lets's write it in the Header
- // Droping Palette Color out of the Header
- // has been moved to the Write process.
- // TODO : move 'values' modification to the write process
- // : save also (in order to be able to restore)
- // : 'high bit' -when not equal to 'bits stored' + 1
- // : 'bits allocated', when it's equal to 12 ?!
- std::string spp = "3"; // Samples Per Pixel
- std::string photInt = "RGB "; // Photometric Interpretation
- std::string planConfig = "0"; // Planar Configuration
- HeaderInternal->SetEntryByNumber(spp,0x0028,0x0002);
- HeaderInternal->SetEntryByNumber(photInt,0x0028,0x0004);
- HeaderInternal->SetEntryByNumber(planConfig,0x0028,0x0006);
- }
- PixelRead = 1; // PixelRaw
- }
- }
-
- // We say the value *is* loaded.
- GetHeader()->SetEntryByNumber( GDCM_BINLOADED,
- GetHeader()->GetGrPixel(), GetHeader()->GetNumPixel());
-
- // Will be 7fe0, 0010 in standard case
- GetHeader()->SetEntryBinAreaByNumber( pixelData,
- GetHeader()->GetGrPixel(), GetHeader()->GetNumPixel());
-// END PIXELCONVERT CLEANME
-
- return pixelData;
}
/**
"than caller's expected MaxSize");
return 0;
}
- memmove( destination,
- (void*)PixelConverter->GetRGB(),
- PixelConverter->GetRGBSize() );
+ memcpy( destination,
+ (void*)PixelConverter->GetRGB(),
+ PixelConverter->GetRGBSize() );
return PixelConverter->GetRGBSize();
}
"than caller's expected MaxSize");
return 0;
}
- memmove( destination,
- (void*)PixelConverter->GetDecompressed(),
- PixelConverter->GetDecompressedSize() );
+ memcpy( destination,
+ (void*)PixelConverter->GetDecompressed(),
+ PixelConverter->GetDecompressedSize() );
return PixelConverter->GetDecompressedSize();
}
*/
uint8_t* File::GetImageDataRaw ()
{
- uint8_t* decompressed = GetDecompressed();
- if ( ! decompressed )
- {
- return 0;
- }
-
-// PIXELCONVERT CLEANME
- // Restore the header in a disk-consistent state
- // (if user asks twice to get the pixels from disk)
- if ( PixelRead != -1 ) // File was "read" before
- {
- RestoreInitialValues();
- }
- if ( PixelConverter->IsDecompressedRGB() )
- {
- ///////////////////////////////////////////////////
- // now, it's an RGB image
- // Lets's write it in the Header
- // Droping Palette Color out of the Header
- // has been moved to the Write process.
- // TODO : move 'values' modification to the write process
- // : save also (in order to be able to restore)
- // : 'high bit' -when not equal to 'bits stored' + 1
- // : 'bits allocated', when it's equal to 12 ?!
- std::string spp = "3"; // Samples Per Pixel
- std::string photInt = "RGB "; // Photometric Interpretation
- std::string planConfig = "0"; // Planar Configuration
- HeaderInternal->SetEntryByNumber(spp,0x0028,0x0002);
- HeaderInternal->SetEntryByNumber(photInt,0x0028,0x0004);
- HeaderInternal->SetEntryByNumber(planConfig,0x0028,0x0006);
- }
-
- // We say the value *is* loaded.
- GetHeader()->SetEntryByNumber( GDCM_BINLOADED,
- GetHeader()->GetGrPixel(), GetHeader()->GetNumPixel());
-
- // will be 7fe0, 0010 in standard cases
- GetHeader()->SetEntryBinAreaByNumber( decompressed,
- GetHeader()->GetGrPixel(), GetHeader()->GetNumPixel());
-
- PixelRead = 1; // PixelRaw
-// END PIXELCONVERT CLEANME
-
- return decompressed;
+ return GetDecompressed();
}
uint8_t* File::GetDecompressed()
bool File::WriteDcmImplVR (std::string const & fileName)
{
- return WriteBase(fileName, ImplicitVR);
+ SetWriteTypeToDcmImplVR();
+ return Write(fileName);
}
/**
bool File::WriteDcmExplVR (std::string const & fileName)
{
- return WriteBase(fileName, ExplicitVR);
+ SetWriteTypeToDcmExplVR();
+ return Write(fileName);
}
/**
bool File::WriteAcr (std::string const & fileName)
{
- return WriteBase(fileName, ACR);
+ SetWriteTypeToAcr();
+ return Write(fileName);
+}
+
+bool File::Write(std::string const& fileName)
+{
+ switch(WriteType)
+ {
+ case WTYPE_IMPL_VR:
+ return WriteBase(fileName,ImplicitVR);
+ case WTYPE_EXPL_VR:
+ return WriteBase(fileName,ExplicitVR);
+ case WTYPE_ACR:
+ return WriteBase(fileName,ACR);
+ }
+ return(false);
}
//-----------------------------------------------------------------------------
*/
bool File::WriteBase (std::string const & fileName, FileType type)
{
- if ( PixelRead == -1 && type != ExplicitVR)
+/* if ( PixelRead == -1 && type != ExplicitVR)
{
return false;
- }
+ }*/
std::ofstream* fp1 = new std::ofstream(fileName.c_str(),
std::ios::out | std::ios::binary);
return false;
}
- if ( type == ImplicitVR || type == ExplicitVR )
+ switch(WriteMode)
{
- // writing Dicom File Preamble
- char filePreamble[128];
- memset(filePreamble, 0, 128);
- fp1->write(filePreamble, 128);
- fp1->write("DICM", 4);
+ case WMODE_NATIVE :
+ SetWriteToNative();
+ break;
+ case WMODE_DECOMPRESSED :
+ SetWriteToDecompressed();
+ break;
+ case WMODE_RGB :
+ SetWriteToRGB();
+ break;
}
// --------------------------------------------------------------
// if recognition code tells us we dealt with a LibIDO image
// we reproduce on disk the switch between lineNumber and columnNumber
// just before writting ...
-
/// \todo the best trick would be *change* the recognition code
/// but pb expected if user deals with, e.g. COMPLEX images
-
- std::string rows, columns;
- if ( HeaderInternal->GetFileType() == ACR_LIBIDO)
+/* if ( HeaderInternal->GetFileType() == ACR_LIBIDO)
{
- rows = HeaderInternal->GetEntryByNumber(0x0028, 0x0010);
- columns = HeaderInternal->GetEntryByNumber(0x0028, 0x0011);
-
- HeaderInternal->SetEntryByNumber(columns, 0x0028, 0x0010);
- HeaderInternal->SetEntryByNumber(rows , 0x0028, 0x0011);
- }
+ SetWriteToLibido();
+ }*/
// ----------------- End of Special Patch ----------------
-
- uint16_t grPixel = HeaderInternal->GetGrPixel();
- uint16_t numPixel = HeaderInternal->GetNumPixel();;
-
- DocEntry* PixelElement =
- GetHeader()->GetDocEntryByNumber(grPixel, numPixel);
-
- if ( PixelRead == 1 )
- {
- // we read pixel 'as is' (no tranformation LUT -> RGB)
- PixelElement->SetLength( ImageDataSizeRaw );
- }
- else if ( PixelRead == 0 )
- {
- // we tranformed GrayLevel pixels + LUT into RGB Pixel
- PixelElement->SetLength( ImageDataSize );
- }
HeaderInternal->Write(fp1, type);
//
// ...and we restore the Header to be Dicom Compliant again
// just after writting
-
- if ( HeaderInternal->GetFileType() == ACR_LIBIDO )
+/* if ( HeaderInternal->GetFileType() == ACR_LIBIDO )
{
- HeaderInternal->SetEntryByNumber(rows , 0x0028, 0x0010);
- HeaderInternal->SetEntryByNumber(columns, 0x0028, 0x0011);
- }
+ RestoreWriteFromLibido();
+ }*/
// ----------------- End of Special Patch ----------------
+
+ RestoreWrite();
+
+
fp1->close ();
delete fp1;
return PixelConverter->GetLutRGBA();
}
+//-----------------------------------------------------------------------------
+// Private
+/**
+ * \brief Set the pixel datas in the good entry of the Header
+ */
+void File::SetPixelData(uint8_t* data)
+{
+ GetHeader()->SetEntryByNumber( GDCM_BINLOADED,
+ GetHeader()->GetGrPixel(), GetHeader()->GetNumPixel());
+
+ // Will be 7fe0, 0010 in standard case
+ DocEntry* currentEntry = GetHeader()->GetDocEntryByNumber(GetHeader()->GetGrPixel(), GetHeader()->GetNumPixel());
+ if ( currentEntry )
+ {
+ if ( BinEntry* binEntry = dynamic_cast<BinEntry *>(currentEntry) )
+ // Flag is to false because datas are kept in the gdcmPixelConvert
+ binEntry->SetBinArea( data, false );
+ }
+}
+
+void File::SetWriteToNative()
+{
+// Nothing to do
+}
+
+void File::SetWriteToDecompressed()
+{
+ if(HeaderInternal->GetNumberOfScalarComponents()==3 && !HeaderInternal->HasLUT())
+ {
+ SetWriteToRGB();
+ }
+ else
+ {
+ ValEntry* photInt = CopyValEntry(0x0028,0x0004);
+ if(HeaderInternal->HasLUT())
+ {
+ photInt->SetValue("PALETTE COLOR ");
+ photInt->SetLength(14);
+ }
+ else
+ {
+ photInt->SetValue("MONOCHROME1 ");
+ photInt->SetLength(12);
+ }
+
+ BinEntry* pixel = CopyBinEntry(GetHeader()->GetGrPixel(),GetHeader()->GetNumPixel());
+ pixel->SetValue(GDCM_BINLOADED);
+ if(Pixel_Data)
+ {
+ pixel->SetBinArea(Pixel_Data,false);
+ pixel->SetLength(ImageDataSize);
+ }
+ else
+ {
+ pixel->SetBinArea(PixelConverter->GetDecompressed(),false);
+ pixel->SetLength(PixelConverter->GetDecompressedSize());
+ }
+
+ Archive->Push(photInt);
+ Archive->Push(pixel);
+ }
+}
+
+void File::SetWriteToRGB()
+{
+ if(HeaderInternal->GetNumberOfScalarComponents()==3 && !HeaderInternal->HasLUT())
+ {
+ PixelConverter->BuildRGBImage();
+
+ ValEntry* spp = CopyValEntry(0x0028,0x0002);
+ spp->SetValue("3 ");
+ spp->SetLength(2);
+
+ ValEntry* planConfig = CopyValEntry(0x0028,0x0006);
+ planConfig->SetValue("0 ");
+ planConfig->SetLength(2);
+
+ ValEntry* photInt = CopyValEntry(0x0028,0x0004);
+ photInt->SetValue("RGB ");
+ photInt->SetLength(4);
+
+ BinEntry* pixel = CopyBinEntry(GetHeader()->GetGrPixel(),GetHeader()->GetNumPixel());
+ pixel->SetValue(GDCM_BINLOADED);
+ if(Pixel_Data)
+ {
+ pixel->SetBinArea(Pixel_Data,false);
+ pixel->SetLength(ImageDataSize);
+ }
+ else if(PixelConverter->GetRGB())
+ {
+ pixel->SetBinArea(PixelConverter->GetRGB(),false);
+ pixel->SetLength(PixelConverter->GetRGBSize());
+ }
+ else // Decompressed data
+ {
+ pixel->SetBinArea(PixelConverter->GetDecompressed(),false);
+ pixel->SetLength(PixelConverter->GetDecompressedSize());
+ }
+
+ Archive->Push(spp);
+ Archive->Push(planConfig);
+ Archive->Push(photInt);
+ Archive->Push(pixel);
+
+ // For old ACR-NEMA
+ // Thus, we have a RGB image and the bits allocated = 24 and
+ // samples per pixels = 1 (in the read file)
+ if(HeaderInternal->GetBitsAllocated()==24)
+ {
+ ValEntry* bitsAlloc = CopyValEntry(0x0028,0x0100);
+ bitsAlloc->SetValue("8 ");
+ bitsAlloc->SetLength(2);
+
+ ValEntry* bitsStored = CopyValEntry(0x0028,0x0101);
+ bitsStored->SetValue("8 ");
+ bitsStored->SetLength(2);
+
+ ValEntry* highBit = CopyValEntry(0x0028,0x0102);
+ highBit->SetValue("7 ");
+ highBit->SetLength(2);
+
+ Archive->Push(bitsAlloc);
+ Archive->Push(bitsStored);
+ Archive->Push(highBit);
+ }
+ }
+ else
+ {
+ SetWriteToDecompressed();
+ }
+}
+
+void File::RestoreWrite()
+{
+ Archive->Restore(0x0028,0x0002);
+ Archive->Restore(0x0028,0x0004);
+ Archive->Restore(0x0028,0x0006);
+ Archive->Restore(GetHeader()->GetGrPixel(),GetHeader()->GetNumPixel());
+
+ // For old ACR-NEMA (24 bits problem)
+ Archive->Restore(0x0028,0x0100);
+ Archive->Restore(0x0028,0x0101);
+ Archive->Restore(0x0028,0x0102);
+}
+
+void File::SetWriteToLibido()
+{
+ ValEntry *oldRow = dynamic_cast<ValEntry *>(HeaderInternal->GetDocEntryByNumber(0x0028, 0x0010));
+ ValEntry *oldCol = dynamic_cast<ValEntry *>(HeaderInternal->GetDocEntryByNumber(0x0028, 0x0011));
+
+ if( oldRow && oldCol )
+ {
+ std::string rows, columns;
+
+ ValEntry *newRow=new ValEntry(oldRow->GetDictEntry());
+ ValEntry *newCol=new ValEntry(oldCol->GetDictEntry());
+
+ newRow->Copy(oldCol);
+ newCol->Copy(oldRow);
+
+ newRow->SetValue(oldCol->GetValue());
+ newCol->SetValue(oldRow->GetValue());
+
+ Archive->Push(newRow);
+ Archive->Push(newCol);
+ }
+}
+
+void File::RestoreWriteFromLibido()
+{
+ Archive->Restore(0x0028,0x0010);
+ Archive->Restore(0x0028,0x0011);
+}
+
+ValEntry* File::CopyValEntry(uint16_t group,uint16_t element)
+{
+ DocEntry* oldE = HeaderInternal->GetDocEntryByNumber(group, element);
+ ValEntry* newE;
+
+ if(oldE)
+ {
+ newE = new ValEntry(oldE->GetDictEntry());
+ newE->Copy(oldE);
+ }
+ else
+ {
+ newE = GetHeader()->NewValEntryByNumber(group,element);
+ }
+
+ return(newE);
+}
+
+BinEntry* File::CopyBinEntry(uint16_t group,uint16_t element)
+{
+ DocEntry* oldE = HeaderInternal->GetDocEntryByNumber(group, element);
+ BinEntry* newE;
+
+ if(oldE)
+ {
+ newE = new BinEntry(oldE->GetDictEntry());
+ newE->Copy(oldE);
+ }
+ else
+ {
+ newE = GetHeader()->NewBinEntryByNumber(group,element);
+ }
+
+
+ return(newE);
+}
+
+//-----------------------------------------------------------------------------
} // end namespace gdcm
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff