Program: gdcm
Module: $RCSfile: gdcmFile.cxx,v $
Language: C++
- Date: $Date: 2004/10/22 13:56:46 $
- Version: $Revision: 1.149 $
+ Date: $Date: 2004/11/23 11:14:13 $
+ Version: $Revision: 1.159 $
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()
{
+ WriteMode = WMODE_DECOMPRESSED;
+ WriteType = WTYPE_IMPL_VR;
+ PixelConverter = NULL; //just in case
+ Archive = NULL;
+
if ( HeaderInternal->IsReadable() )
{
ImageDataSizeRaw = ComputeDecompressedPixelDataSizeFromHeader();
PixelConverter = new PixelConvert;
PixelConverter->GrabInformationsFromHeader( HeaderInternal );
+
+ Archive = new DocEntryArchive( HeaderInternal );
}
+
SaveInitialValues();
}
*/
File::~File()
{
+ if( PixelConverter )
+ {
+ delete PixelConverter;
+ }
+ if( Archive )
+ {
+ delete Archive;
+ }
+
if( SelfHeader )
{
delete HeaderInternal;
*/
void File::SaveInitialValues()
{
-
PixelRead = -1; // no ImageData read yet.
LastAllocatedPixelDataLength = 0;
Pixel_Data = 0;
InitialRedLUTData = 0;
InitialGreenLUTData = 0;
InitialBlueLUTData = 0;
-
+
if ( HeaderInternal->IsReadable() )
{
// the following values *may* be modified
*/
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 )
+// FIXME
+// We don't know if the InitialLutData are still in the header or not !
+/* if ( InitialRedLUTDescr )
delete InitialRedLUTDescr;
if ( InitialGreenLUTDescr )
delete InitialGreenLUTDescr;
- if ( InitialBlueLUTDescr )
- delete InitialBlueLUTDescr;
+ if ( InitialBlueLUTDescr )
+ delete InitialBlueLUTDescr;
- if ( InitialRedLUTData )
+ if ( InitialRedLUTData )
delete InitialRedLUTData;
- if ( InitialGreenLUTData != NULL)
+ if ( InitialGreenLUTData )
delete InitialGreenLUTData;
- if ( InitialBlueLUTData != NULL)
- delete InitialBlueLUTData;
+ if ( InitialBlueLUTData )
+ delete InitialBlueLUTData;*/
}
//-----------------------------------------------------------------------------
// - it is not defined (i.e. it's value is 0)
// - it's 12, since we will expand the image to 16 bits (see
// PixelConvert::ConvertDecompress12BitsTo16Bits() )
- if ( ( numberBitsAllocated == 0 ) || ( numberBitsAllocated == 12 ) )
+ if ( numberBitsAllocated == 0 || numberBitsAllocated == 12 )
{
numberBitsAllocated = 16;
}
pixelData = PixelConverter->GetDecompressed();
}
-// PIXELCONVERT CLEANME
+/*// 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
if ( HeaderInternal->HasLUT() )
{
// The LUT interpretation failed
- std::string photometricInterpretation = "MONOCHROME1 ";
+ std::string photometricInterpretation = Util::DicomString("MONOCHROME1");
HeaderInternal->SetEntryByNumber( photometricInterpretation,
0x0028, 0x0004 );
PixelRead = 0; // no 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
+ SetPixelData(pixelData);
+// 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();
}
return 0;
}
-// PIXELCONVERT CLEANME
+/*// 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
}
// 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());
+ SetPixelData(decompressed);
PixelRead = 1; // PixelRaw
-// END PIXELCONVERT CLEANME
+// END PIXELCONVERT CLEANME*/
return decompressed;
}
// The decompressed image migth not be loaded yet:
std::ifstream* fp = HeaderInternal->OpenFile();
PixelConverter->ReadAndDecompressPixelData( fp );
- HeaderInternal->CloseFile();
+ if(fp) HeaderInternal->CloseFile();
decompressed = PixelConverter->GetDecompressed();
if ( ! decompressed )
{
std::ofstream fp1(fileName.c_str(), std::ios::out | std::ios::binary );
if (!fp1)
{
- printf("Fail to open (write) file [%s] \n", fileName.c_str());
+ dbg.Verbose(2, "Fail to open (write) file:", fileName.c_str());
return false;
}
fp1.write((char*)Pixel_Data, ImageDataSize);
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);
}
//-----------------------------------------------------------------------------
std::ios::out | std::ios::binary);
if (fp1 == NULL)
{
- printf("Failed to open (write) File [%s] \n", fileName.c_str());
+ dbg.Verbose(2, "Failed to open (write) File: " , fileName.c_str());
return false;
}
if ( type == ImplicitVR || type == ExplicitVR )
{
// writing Dicom File Preamble
- uint8_t* filePreamble = new uint8_t[128];
+ char filePreamble[128];
memset(filePreamble, 0, 128);
- fp1->write((char*)filePreamble, 128);
+ fp1->write(filePreamble, 128);
fp1->write("DICM", 4);
+ }
- delete[] filePreamble;
+ switch(WriteMode)
+ {
+ case WMODE_NATIVE :
+ SetWriteToNative();
+ break;
+ case WMODE_DECOMPRESSED :
+ SetWriteToDecompressed();
+ break;
+ case WMODE_RGB :
+ SetWriteToRGB();
+ break;
}
// --------------------------------------------------------------
std::string rows, columns;
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 ----------------
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 true;
}
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->HasLUT() ) || (!PixelConverter->BuildRGBImage()))
+ if(HeaderInternal->HasLUT() && PixelConverter->BuildRGBImage())
+ {
+ SetWriteToRGB();
+ }
+ else
+ {
+ ValEntry* photInt = CopyValEntry(0x0028,0x0004);
+ photInt->SetValue("MONOCHROME1 ");
+ photInt->SetLength(12);
+
+ BinEntry* pixel = CopyBinEntry(GetHeader()->GetGrPixel(),GetHeader()->GetNumPixel());
+ pixel->SetValue(GDCM_BINLOADED);
+ pixel->SetBinArea(PixelConverter->GetDecompressed(),false);
+ pixel->SetLength(PixelConverter->GetDecompressedSize());
+
+ Archive->Push(photInt);
+ Archive->Push(pixel);
+ }
+/* else
+ {
+ SetWriteToRGB();
+ } */
+}
+
+void File::SetWriteToRGB()
+{
+ if(PixelConverter->BuildRGBImage())
+ {
+ ValEntry* spp = CopyValEntry(0x0028,0x0002);
+ spp->SetValue("3 ");
+ spp->SetLength(2);
+
+ ValEntry* photInt = CopyValEntry(0x0028,0x0004);
+ photInt->SetValue("RGB ");
+ photInt->SetLength(4);
+
+ ValEntry* planConfig = CopyValEntry(0x0028,0x0006);
+ planConfig->SetValue("0 ");
+ planConfig->SetLength(2);
+
+ BinEntry* pixel = CopyBinEntry(GetHeader()->GetGrPixel(),GetHeader()->GetNumPixel());
+ pixel->SetValue(GDCM_BINLOADED);
+ pixel->SetBinArea(PixelConverter->GetRGB(),false);
+ pixel->SetLength(PixelConverter->GetRGBSize());
+
+ Archive->Push(spp);
+ Archive->Push(photInt);
+ Archive->Push(planConfig);
+ Archive->Push(pixel);
+ }
+ else
+ {
+ SetWriteToDecompressed();
+ }
+}
+
+void File::RestoreWrite()
+{
+ Archive->Restore(0x0028,0x0002);
+ Archive->Restore(0x0028,0x0004);
+ Archive->Restore(0x0028,0x0006);
+ Archive->Restore(GetHeader()->GetGrPixel(),GetHeader()->GetNumPixel());
+}
+
+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