+2004-12-03 Benoit Regrain <Benoit.Regrain@creatis.insa-lyon.fr>
+ * Rename src/gdcmPixelConvert.[h|cxx] to src/gdcmPixelReadConvert.[h|cxx]
+
2004-12-02 Benoit Regrain <Benoit.Regrain@creatis.insa-lyon.fr>
* vtk/vtkGdcmReader.cxx : correct error in vtkDebugMacro, vtkWarningMacro
and vtkErrorMacro use.
Program: gdcm
Module: $RCSfile: PrintFile.cxx,v $
Language: C++
- Date: $Date: 2004/11/25 10:24:33 $
- Version: $Revision: 1.14 $
+ Date: $Date: 2004/12/03 10:21:53 $
+ Version: $Revision: 1.15 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
{
std::cout << std::endl << "==========================================="
<< std::endl;
- f1->GetPixelConverter()->Print();
+ f1->GetPixelReadConverter()->Print();
std::cout << std::endl << "==========================================="
<< std::endl;
}
Program: gdcm
Module: $RCSfile: PrintHeader.cxx,v $
Language: C++
- Date: $Date: 2004/11/25 10:24:33 $
- Version: $Revision: 1.10 $
+ Date: $Date: 2004/12/03 10:21:53 $
+ Version: $Revision: 1.11 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
fileName += "/test.acr";
}
- gdcm::File *f1 = new gdcm::File( fileName.c_str() );
- gdcm::Header *e1 = f1->GetHeader();
+ gdcm::Header *e1 = new gdcm::Header( fileName.c_str() );
if (argc > 2)
{
std::string transferSyntaxName = e1->GetTransfertSyntaxName();
std::cout << " TransferSyntaxName= [" << transferSyntaxName << "]" << std::endl;
- if ( transferSyntaxName != "Implicit VR - Little Endian"
- && transferSyntaxName != "Explicit VR - Little Endian"
- && transferSyntaxName != "Deflated Explicit VR - Little Endian"
- && transferSyntaxName != "Explicit VR - Big Endian"
- && transferSyntaxName != "Uncompressed ACR-NEMA" )
- {
- std::cout << std::endl << "==========================================="
- << std::endl;
- f1->GetPixelConverter()->Print();
- std::cout << std::endl << "==========================================="
- << std::endl;
- }
-
if(e1->IsReadable())
std::cout <<std::endl<<fileName<<" is Readable"<<std::endl;
else
Program: gdcm
Module: $RCSfile: TestWrite.cxx,v $
Language: C++
- Date: $Date: 2004/11/16 04:26:18 $
- Version: $Revision: 1.9 $
+ Date: $Date: 2004/12/03 10:21:53 $
+ Version: $Revision: 1.10 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
&& transferSyntaxName != "Uncompressed ACR-NEMA" ) {
std::cout << std::endl << "==========================================="
<< std::endl;
- f1->GetPixelConverter()->Print();
+ f1->GetPixelReadConverter()->Print();
std::cout << std::endl << "==========================================="
<< std::endl;
}
Program: gdcm
Module: $RCSfile: Write.cxx,v $
Language: C++
- Date: $Date: 2004/11/16 04:26:18 $
- Version: $Revision: 1.9 $
+ Date: $Date: 2004/12/03 10:21:53 $
+ Version: $Revision: 1.10 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
&& transferSyntaxName != "Uncompressed ACR-NEMA" ) {
std::cout << std::endl << "==========================================="
<< std::endl;
- f1->GetPixelConverter()->Print();
+ f1->GetPixelReadConverter()->Print();
std::cout << std::endl << "==========================================="
<< std::endl;
}
gdcmJpeg12.cxx
gdcmJpeg16.cxx
gdcmJpeg2000.cxx
- gdcmPixelConvert.cxx
+ gdcmPixelReadConvert.cxx
gdcmRLEFrame.cxx
gdcmRLEFramesInfo.cxx
gdcmSeqEntry.cxx
Program: gdcm
Module: $RCSfile: gdcmFile.cxx,v $
Language: C++
- Date: $Date: 2004/11/30 14:17:52 $
- Version: $Revision: 1.167 $
+ Date: $Date: 2004/12/03 10:21:54 $
+ Version: $Revision: 1.168 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
WriteMode = WMODE_DECOMPRESSED;
WriteType = WTYPE_IMPL_VR;
- PixelConverter = new PixelConvert;
+ PixelReadConverter = new PixelReadConvert;
Archive = new DocEntryArchive( HeaderInternal );
if ( HeaderInternal->IsReadable() )
{
- PixelConverter->GrabInformationsFromHeader( HeaderInternal );
+ PixelReadConverter->GrabInformationsFromHeader( HeaderInternal );
}
Pixel_Data = 0;
*/
File::~File()
{
- if( PixelConverter )
+ if( PixelReadConverter )
{
- delete PixelConverter;
+ delete PixelReadConverter;
}
if( Archive )
{
*/
size_t File::GetImageDataSize()
{
- return PixelConverter->GetRGBSize();
+ return PixelReadConverter->GetRGBSize();
}
/**
*/
size_t File::GetImageDataRawSize()
{
- return PixelConverter->GetDecompressedSize();
+ return PixelReadConverter->GetDecompressedSize();
}
/**
return 0;
}
- if ( HeaderInternal->HasLUT() && PixelConverter->BuildRGBImage() )
+ if ( HeaderInternal->HasLUT() && PixelReadConverter->BuildRGBImage() )
{
- return PixelConverter->GetRGB();
+ return PixelReadConverter->GetRGB();
}
else
{
// When no LUT or LUT conversion fails, return the decompressed
- return PixelConverter->GetDecompressed();
+ return PixelReadConverter->GetDecompressed();
}
}
return 0;
}
- if ( HeaderInternal->HasLUT() && PixelConverter->BuildRGBImage() )
+ if ( HeaderInternal->HasLUT() && PixelReadConverter->BuildRGBImage() )
{
- if ( PixelConverter->GetRGBSize() > maxSize )
+ if ( PixelReadConverter->GetRGBSize() > maxSize )
{
dbg.Verbose(0, "File::GetImageDataIntoVector: pixel data bigger"
"than caller's expected MaxSize");
return 0;
}
memcpy( destination,
- (void*)PixelConverter->GetRGB(),
- PixelConverter->GetRGBSize() );
- return PixelConverter->GetRGBSize();
+ (void*)PixelReadConverter->GetRGB(),
+ PixelReadConverter->GetRGBSize() );
+ return PixelReadConverter->GetRGBSize();
}
// Either no LUT conversion necessary or LUT conversion failed
- if ( PixelConverter->GetDecompressedSize() > maxSize )
+ if ( PixelReadConverter->GetDecompressedSize() > maxSize )
{
dbg.Verbose(0, "File::GetImageDataIntoVector: pixel data bigger"
"than caller's expected MaxSize");
return 0;
}
memcpy( destination,
- (void*)PixelConverter->GetDecompressed(),
- PixelConverter->GetDecompressedSize() );
- return PixelConverter->GetDecompressedSize();
+ (void*)PixelReadConverter->GetDecompressed(),
+ PixelReadConverter->GetDecompressedSize() );
+ return PixelReadConverter->GetDecompressedSize();
}
/**
uint8_t* File::GetDecompressed()
{
- uint8_t* decompressed = PixelConverter->GetDecompressed();
+ uint8_t* decompressed = PixelReadConverter->GetDecompressed();
if ( ! decompressed )
{
// The decompressed image migth not be loaded yet:
std::ifstream* fp = HeaderInternal->OpenFile();
- PixelConverter->ReadAndDecompressPixelData( fp );
+ PixelReadConverter->ReadAndDecompressPixelData( fp );
if(fp)
HeaderInternal->CloseFile();
- decompressed = PixelConverter->GetDecompressed();
+ decompressed = PixelReadConverter->GetDecompressed();
if ( ! decompressed )
{
dbg.Verbose(0, "File::GetDecompressed: read/decompress of "
}
/**
- * \brief Access to the underlying \ref PixelConverter RGBA LUT
+ * \brief Access to the underlying \ref PixelReadConverter RGBA LUT
*/
uint8_t* File::GetLutRGBA()
{
- return PixelConverter->GetLutRGBA();
+ return PixelReadConverter->GetLutRGBA();
}
//-----------------------------------------------------------------------------
SetWriteFileTypeToExplicitVR();
}
+ // --------------------------------------------------------------
+ // Special Patch to allow gdcm to re-write ACR-LibIDO formated images
+ //
+ // 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
if( type == ACR_LIBIDO )
{
SetWriteToLibido();
{
SetWriteToNoLibido();
}
+ // ----------------- End of Special Patch ----------------
switch(WriteMode)
{
- case WMODE_NATIVE :
- SetWriteToNative();
- break;
case WMODE_DECOMPRESSED :
SetWriteToDecompressed();
break;
break;
}
- // --------------------------------------------------------------
- // Special Patch to allow gdcm to re-write ACR-LibIDO formated images
- //
- // 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
-/* if ( HeaderInternal->GetFileType() == ACR_LIBIDO)
- {
- SetWriteToLibido();
- }*/
- // ----------------- End of Special Patch ----------------
-
bool check = CheckWriteIntegrity();
if(check)
{
check = HeaderInternal->Write(fileName,type);
}
+ RestoreWrite();
+ RestoreWriteFileType();
+
// --------------------------------------------------------------
// Special Patch to allow gdcm to re-write ACR-LibIDO formated images
//
// ...and we restore the Header to be Dicom Compliant again
// just after writting
-/* if ( HeaderInternal->GetFileType() == ACR_LIBIDO )
- {
- RestoreWriteFromLibido();
- }*/
- // ----------------- End of Special Patch ----------------
-
- RestoreWrite();
- RestoreWriteFileType();
RestoreWriteOfLibido();
+ // ----------------- End of Special Patch ----------------
return check;
}
switch(WriteMode)
{
- case WMODE_NATIVE :
- break;
case WMODE_DECOMPRESSED :
if( decSize!=ImageDataSize )
{
return true;
}
-void File::SetWriteToNative()
+/*void File::SetWriteToNative()
{
if(Pixel_Data)
{
Archive->Push(pixel);
}
-}
+}*/
void File::SetWriteToDecompressed()
{
}
else
{
- pixel->SetBinArea(PixelConverter->GetDecompressed(),false);
- pixel->SetLength(PixelConverter->GetDecompressedSize());
+ pixel->SetBinArea(PixelReadConverter->GetDecompressed(),false);
+ pixel->SetLength(PixelReadConverter->GetDecompressedSize());
}
Archive->Push(photInt);
{
if(HeaderInternal->GetNumberOfScalarComponents()==3)
{
- PixelConverter->BuildRGBImage();
+ PixelReadConverter->BuildRGBImage();
ValEntry* spp = CopyValEntry(0x0028,0x0002);
spp->SetValue("3 ");
pixel->SetBinArea(Pixel_Data,false);
pixel->SetLength(ImageDataSize);
}
- else if(PixelConverter->GetRGB())
+ else if(PixelReadConverter->GetRGB())
{
- pixel->SetBinArea(PixelConverter->GetRGB(),false);
- pixel->SetLength(PixelConverter->GetRGBSize());
+ pixel->SetBinArea(PixelReadConverter->GetRGB(),false);
+ pixel->SetLength(PixelReadConverter->GetRGBSize());
}
else // Decompressed data
{
- pixel->SetBinArea(PixelConverter->GetDecompressed(),false);
- pixel->SetLength(PixelConverter->GetDecompressedSize());
+ pixel->SetBinArea(PixelReadConverter->GetDecompressed(),false);
+ pixel->SetLength(PixelReadConverter->GetDecompressedSize());
}
Archive->Push(spp);
newE = GetHeader()->NewBinEntryByNumber(group,element);
}
-
return(newE);
}
Program: gdcm
Module: $RCSfile: gdcmFile.h,v $
Language: C++
- Date: $Date: 2004/11/30 14:17:52 $
- Version: $Revision: 1.79 $
+ Date: $Date: 2004/12/03 10:21:54 $
+ Version: $Revision: 1.80 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
#include "gdcmCommon.h"
#include "gdcmHeader.h"
-#include "gdcmPixelConvert.h"
+#include "gdcmPixelReadConvert.h"
#include "gdcmDocEntryArchive.h"
namespace gdcm
public:
enum TWriteMode
{
- WMODE_NATIVE,
WMODE_DECOMPRESSED,
WMODE_RGB
};
size_t GetImageDataSize();
size_t GetImageDataRawSize();
- /// Accessor to \ref PixelConverter
- PixelConvert* GetPixelConverter() { return PixelConverter; };
+ /// Accessor to \ref PixelReadConverter
+ PixelReadConvert* GetPixelReadConverter() { return PixelReadConverter; };
uint8_t* GetImageData();
uint8_t* GetImageDataRaw();
uint8_t* GetLutRGBA();
// Write mode
- void SetWriteModeToNative() { SetWriteMode(WMODE_NATIVE); };
void SetWriteModeToDecompressed() { SetWriteMode(WMODE_DECOMPRESSED); };
void SetWriteModeToRGB() { SetWriteMode(WMODE_RGB); };
void SetWriteMode(unsigned int mode) { WriteMode = mode; };
bool WriteBase(std::string const& fileName, FileType type);
bool CheckWriteIntegrity();
- void SetWriteToNative();
void SetWriteToDecompressed();
void SetWriteToRGB();
void RestoreWrite();
bool Parsed;
/// Utility pixel converter
- PixelConvert* PixelConverter;
+ PixelReadConvert* PixelReadConverter;
// Utility header archive
DocEntryArchive *Archive;
Program: gdcm
Module: $RCSfile: gdcmJPEGFragment.h,v $
Language: C++
- Date: $Date: 2004/10/20 14:30:40 $
- Version: $Revision: 1.4 $
+ Date: $Date: 2004/12/03 10:21:54 $
+ Version: $Revision: 1.5 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
{
friend class Document;
friend class File;
-friend class PixelConvert;
+friend class PixelReadConvert;
long Offset;
long Length;
public:
Program: gdcm
Module: $RCSfile: gdcmJPEGFragmentsInfo.h,v $
Language: C++
- Date: $Date: 2004/10/20 14:30:40 $
- Version: $Revision: 1.5 $
+ Date: $Date: 2004/12/03 10:21:54 $
+ Version: $Revision: 1.6 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
{
friend class Document;
friend class File;
-friend class PixelConvert;
+friend class PixelReadConvert;
private:
typedef std::list< JPEGFragment* > JPEGFragmentsList;
JPEGFragmentsList Fragments;
/*=========================================================================
Program: gdcm
- Module: $RCSfile: gdcmPixelConvert.cxx,v $
+ Module: $RCSfile: gdcmPixelReadConvert.cxx,v $
Language: C++
- Date: $Date: 2004/11/30 16:59:32 $
- Version: $Revision: 1.34 $
+ Date: $Date: 2004/12/03 10:21:55 $
+ Version: $Revision: 1.1 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
// look for "fixMem" and convert that to a member of this class
// Removing the prefix fixMem and dealing with allocations should do the trick
//
-// grep PIXELCONVERT everywhere and clean up !
+// grep PixelReadConvert everywhere and clean up !
#include "gdcmDebug.h"
-#include "gdcmPixelConvert.h"
+#include "gdcmPixelReadConvert.h"
#include <fstream>
#include <stdio.h>
//-----------------------------------------------------------------------------
// Constructor / Destructor
-PixelConvert::PixelConvert()
+PixelReadConvert::PixelReadConvert()
{
RGB = 0;
RGBSize = 0;
LutBlueData =0;
}
-void PixelConvert::Squeeze()
+void PixelReadConvert::Squeeze()
{
if ( RGB )
{
LutRGBA = 0;
}
-PixelConvert::~PixelConvert()
+PixelReadConvert::~PixelReadConvert()
{
Squeeze();
}
-void PixelConvert::AllocateRGB()
+void PixelReadConvert::AllocateRGB()
{
if ( RGB ) {
delete [] RGB;
RGB = new uint8_t[ RGBSize ];
}
-void PixelConvert::AllocateDecompressed()
+void PixelReadConvert::AllocateDecompressed()
{
if ( Decompressed ) {
delete [] Decompressed;
* \brief Read from file a 12 bits per pixel image and decompress it
* into a 16 bits per pixel image.
*/
-void PixelConvert::ReadAndDecompress12BitsTo16Bits( std::ifstream* fp )
+void PixelReadConvert::ReadAndDecompress12BitsTo16Bits( std::ifstream* fp )
throw ( FormatError )
{
int nbPixels = XSize * YSize;
fp->read( (char*)&b0, 1);
if ( fp->fail() || fp->eof() )//Fp->gcount() == 1
{
- throw FormatError( "PixelConvert::ReadAndDecompress12BitsTo16Bits()",
+ throw FormatError( "PixelReadConvert::ReadAndDecompress12BitsTo16Bits()",
"Unfound first block" );
}
fp->read( (char*)&b1, 1 );
if ( fp->fail() || fp->eof())//Fp->gcount() == 1
{
- throw FormatError( "PixelConvert::ReadAndDecompress12BitsTo16Bits()",
+ throw FormatError( "PixelReadConvert::ReadAndDecompress12BitsTo16Bits()",
"Unfound second block" );
}
fp->read( (char*)&b2, 1 );
if ( fp->fail() || fp->eof())//Fp->gcount() == 1
{
- throw FormatError( "PixelConvert::ReadAndDecompress12BitsTo16Bits()",
+ throw FormatError( "PixelReadConvert::ReadAndDecompress12BitsTo16Bits()",
"Unfound second block" );
}
* High Byte 'Planes'...(for what it may mean)
* @return Boolean
*/
-bool PixelConvert::DecompressRLE16BitsFromRLE8Bits( int NumberOfFrames )
+bool PixelReadConvert::DecompressRLE16BitsFromRLE8Bits( int NumberOfFrames )
{
size_t PixelNumber = XSize * YSize;
size_t decompressedSize = XSize * YSize * NumberOfFrames;
* @param fp File Pointer: on entry the position should be the one of
* the fragment to be decoded.
*/
-bool PixelConvert::ReadAndDecompressRLEFragment( uint8_t* subDecompressed,
+bool PixelReadConvert::ReadAndDecompressRLEFragment( uint8_t* subDecompressed,
long fragmentSize,
long decompressedSegmentSize,
std::ifstream* fp )
if ( numberOfReadBytes > fragmentSize )
{
- dbg.Verbose(0, "PixelConvert::ReadAndDecompressRLEFragment: we "
+ dbg.Verbose(0, "PixelReadConvert::ReadAndDecompressRLEFragment: we "
"read more bytes than the segment size.");
return false;
}
* at which the pixel data should be copied
* @return Boolean
*/
-bool PixelConvert::ReadAndDecompressRLEFile( std::ifstream* fp )
+bool PixelReadConvert::ReadAndDecompressRLEFile( std::ifstream* fp )
{
uint8_t* subDecompressed = Decompressed;
long decompressedSegmentSize = XSize * YSize;
/**
* \brief Swap the bytes, according to \ref SwapCode.
*/
-void PixelConvert::ConvertSwapZone()
+void PixelReadConvert::ConvertSwapZone()
{
unsigned int i;
}
break;
default:
- dbg.Verbose( 0, "PixelConvert::ConvertSwapZone: SwapCode value "
+ dbg.Verbose( 0, "PixelReadConvert::ConvertSwapZone: SwapCode value "
"(16 bits) not allowed." );
}
}
}
break;
default:
- dbg.Verbose( 0, "PixelConvert::ConvertSwapZone: SwapCode value "
+ dbg.Verbose( 0, "PixelReadConvert::ConvertSwapZone: SwapCode value "
"(32 bits) not allowed." );
}
}
/**
* \brief Deal with endianity i.e. re-arange bytes inside the integer
*/
-void PixelConvert::ConvertReorderEndianity()
+void PixelReadConvert::ConvertReorderEndianity()
{
if ( BitsAllocated != 8 )
{
* @param fp File Pointer
* @return Boolean
*/
-bool PixelConvert::ReadAndDecompressJPEGFile( std::ifstream* fp )
+bool PixelReadConvert::ReadAndDecompressJPEGFile( std::ifstream* fp )
{
uint8_t* localDecompressed = Decompressed;
// Loop on the fragment[s]
else
{
// other JPEG lossy not supported
- dbg.Error("PixelConvert::ReadAndDecompressJPEGFile: unknown "
+ dbg.Error("PixelReadConvert::ReadAndDecompressJPEGFile: unknown "
"jpeg lossy compression ");
return false;
}
* \brief Re-arrange the bits within the bytes.
* @return Boolean
*/
-bool PixelConvert::ConvertReArrangeBits() throw ( FormatError )
+bool PixelReadConvert::ConvertReArrangeBits() throw ( FormatError )
{
if ( BitsStored != BitsAllocated )
{
}
else
{
- dbg.Verbose(0, "PixelConvert::ConvertReArrangeBits: weird image");
- throw FormatError( "PixelConvert::ConvertReArrangeBits()",
+ dbg.Verbose(0, "PixelReadConvert::ConvertReArrangeBits: weird image");
+ throw FormatError( "PixelReadConvert::ConvertReArrangeBits()",
"weird image !?" );
}
}
* \brief Convert (Y plane, cB plane, cR plane) to RGB pixels
* \warning Works on all the frames at a time
*/
-void PixelConvert::ConvertYcBcRPlanesToRGBPixels()
+void PixelReadConvert::ConvertYcBcRPlanesToRGBPixels()
{
uint8_t* localDecompressed = Decompressed;
uint8_t* copyDecompressed = new uint8_t[ DecompressedSize ];
* \brief Convert (Red plane, Green plane, Blue plane) to RGB pixels
* \warning Works on all the frames at a time
*/
-void PixelConvert::ConvertRGBPlanesToRGBPixels()
+void PixelReadConvert::ConvertRGBPlanesToRGBPixels()
{
uint8_t* localDecompressed = Decompressed;
uint8_t* copyDecompressed = new uint8_t[ DecompressedSize ];
delete[] copyDecompressed;
}
-bool PixelConvert::ReadAndDecompressPixelData( std::ifstream* fp )
+bool PixelReadConvert::ReadAndDecompressPixelData( std::ifstream* fp )
{
// ComputeDecompressedAndRGBSizes is already made by
// ::GrabInformationsFromHeader. So, the structure sizes are
//// First stage: get our hands on the Pixel Data.
if ( !fp )
{
- dbg.Verbose( 0, "PixelConvert::ReadAndDecompressPixelData: "
+ dbg.Verbose( 0, "PixelReadConvert::ReadAndDecompressPixelData: "
"unavailable file pointer." );
return false;
}
fp->seekg( PixelOffset, std::ios::beg );
if( fp->fail() || fp->eof()) //Fp->gcount() == 1
{
- dbg.Verbose( 0, "PixelConvert::ReadAndDecompressPixelData: "
+ dbg.Verbose( 0, "PixelReadConvert::ReadAndDecompressPixelData: "
"unable to find PixelOffset in file." );
return false;
}
// variable). But DecompressedSize is the right size of the image !
if( PixelDataLength != DecompressedSize)
{
- dbg.Verbose( 0, "PixelConvert::ReadAndDecompressPixelData: "
- "Mismatch between PixelConvert and DecompressedSize." );
+ dbg.Verbose( 0, "PixelReadConvert::ReadAndDecompressPixelData: "
+ "Mismatch between PixelReadConvert and DecompressedSize." );
}
if( PixelDataLength > DecompressedSize)
{
if ( fp->fail() || fp->eof())//Fp->gcount() == 1
{
- dbg.Verbose( 0, "PixelConvert::ReadAndDecompressPixelData: "
+ dbg.Verbose( 0, "PixelReadConvert::ReadAndDecompressPixelData: "
"reading of decompressed pixel data failed." );
return false;
}
{
if ( ! ReadAndDecompressRLEFile( fp ) )
{
- dbg.Verbose( 0, "PixelConvert::ReadAndDecompressPixelData: "
+ dbg.Verbose( 0, "PixelReadConvert::ReadAndDecompressPixelData: "
"RLE decompressor failed." );
return false;
}
// Default case concerns JPEG family
if ( ! ReadAndDecompressJPEGFile( fp ) )
{
- dbg.Verbose( 0, "PixelConvert::ReadAndDecompressPixelData: "
+ dbg.Verbose( 0, "PixelReadConvert::ReadAndDecompressPixelData: "
"JPEG decompressor failed." );
return false;
}
return true;
}
-void PixelConvert::ConvertHandleColor()
+void PixelReadConvert::ConvertHandleColor()
{
//////////////////////////////////
// Deal with the color decoding i.e. handle:
* \brief Predicate to know wether the image[s] (once decompressed) is RGB.
* \note See comments of \ref ConvertHandleColor
*/
-bool PixelConvert::IsDecompressedRGB()
+bool PixelReadConvert::IsDecompressedRGB()
{
if ( IsMonochrome
|| PlanarConfiguration == 2
return true;
}
-void PixelConvert::ComputeDecompressedAndRGBSizes()
+void PixelReadConvert::ComputeDecompressedAndRGBSizes()
{
int bitsAllocated = BitsAllocated;
// Number of "Bits Allocated" is fixed to 16 when it's 12, since
}
}
-void PixelConvert::GrabInformationsFromHeader( Header* header )
+void PixelReadConvert::GrabInformationsFromHeader( Header* header )
{
// Just in case some access to a Header element requires disk access.
// Note: gdcmDocument::Fp is leaved open after OpenFile.
fp->read( (char*)LutRedData, (size_t)lutRedDataEntry->GetLength());
if ( fp->fail() || fp->eof())//Fp->gcount() == 1
{
- dbg.Verbose(0, "PixelConvert::GrabInformationsFromHeader: "
+ dbg.Verbose(0, "PixelReadConvert::GrabInformationsFromHeader: "
"unable to read red LUT data" );
}
}
fp->read( (char*)LutGreenData, (size_t)lutGreenDataEntry->GetLength() );
if ( fp->fail() || fp->eof())//Fp->gcount() == 1
{
- dbg.Verbose(0, "PixelConvert::GrabInformationsFromHeader: "
+ dbg.Verbose(0, "PixelReadConvert::GrabInformationsFromHeader: "
"unable to read green LUT data" );
}
}
fp->read( (char*)LutBlueData, (size_t)lutBlueDataEntry->GetLength() );
if ( fp->fail() || fp->eof())//Fp->gcount() == 1
{
- dbg.Verbose(0, "PixelConvert::GrabInformationsFromHeader: "
+ dbg.Verbose(0, "PixelReadConvert::GrabInformationsFromHeader: "
"unable to read blue LUT data" );
}
}
* no known Dicom reader deals with them :-(
* @return a RGBA Lookup Table
*/
-void PixelConvert::BuildLUTRGBA()
+void PixelReadConvert::BuildLUTRGBA()
{
if ( LutRGBA )
{
&lengthR, &debR, &nbitsR );
if( nbRead != 3 )
{
- dbg.Verbose(0, "PixelConvert::BuildLUTRGBA: wrong red LUT descriptor");
+ dbg.Verbose(0, "PixelReadConvert::BuildLUTRGBA: wrong red LUT descriptor");
}
int lengthG; // Green LUT length in Bytes
&lengthG, &debG, &nbitsG );
if( nbRead != 3 )
{
- dbg.Verbose(0, "PixelConvert::BuildLUTRGBA: wrong green LUT descriptor");
+ dbg.Verbose(0, "PixelReadConvert::BuildLUTRGBA: wrong green LUT descriptor");
}
int lengthB; // Blue LUT length in Bytes
&lengthB, &debB, &nbitsB );
if( nbRead != 3 )
{
- dbg.Verbose(0, "PixelConvert::BuildLUTRGBA: wrong blue LUT descriptor");
+ dbg.Verbose(0, "PixelReadConvert::BuildLUTRGBA: wrong blue LUT descriptor");
}
////////////////////////////////////////////////////////
/**
* \brief Build the RGB image from the Decompressed imagage and the LUTs.
*/
-bool PixelConvert::BuildRGBImage()
+bool PixelReadConvert::BuildRGBImage()
{
if ( RGB )
{
* @param indent Indentation string to be prepended during printing.
* @param os Stream to print to.
*/
-void PixelConvert::Print( std::string indent, std::ostream &os )
+void PixelReadConvert::Print( std::string indent, std::ostream &os )
{
os << indent
<< "--- Pixel information -------------------------"
}
else
{
- dbg.Verbose(0, "PixelConvert::Print: set as RLE file "
+ dbg.Verbose(0, "PixelReadConvert::Print: set as RLE file "
"but NO RLEinfo present.");
}
}
}
else
{
- dbg.Verbose(0, "PixelConvert::Print: set as JPEG file "
+ dbg.Verbose(0, "PixelReadConvert::Print: set as JPEG file "
"but NO JPEGinfo present.");
}
}
/*=========================================================================
Program: gdcm
- Module: $RCSfile: gdcmPixelConvert.h,v $
+ Module: $RCSfile: gdcmPixelReadConvert.h,v $
Language: C++
- Date: $Date: 2004/10/25 04:08:20 $
- Version: $Revision: 1.14 $
+ Date: $Date: 2004/12/03 10:21:55 $
+ Version: $Revision: 1.1 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
=========================================================================*/
-#ifndef GDCMPIXELCONVERT_H
-#define GDCMPIXELCONVERT_H
+#ifndef GDCMPIXELREADCONVERT_H
+#define GDCMPIXELREADCONVERT_H
#include "gdcmCommon.h"
#include "gdcmRLEFramesInfo.h"
* \brief Utility container for gathering the various forms the pixel data
* migth take during the user demanded processes.
*/
-class GDCM_EXPORT PixelConvert
+class GDCM_EXPORT PixelReadConvert
{
public:
- PixelConvert();
- ~PixelConvert();
+ PixelReadConvert();
+ ~PixelReadConvert();
//// Getter accessors:
uint8_t* GetRGB() { return RGB; }
Program: gdcm
Module: $RCSfile: gdcmRLEFrame.h,v $
Language: C++
- Date: $Date: 2004/10/22 13:56:46 $
- Version: $Revision: 1.8 $
+ Date: $Date: 2004/12/03 10:21:54 $
+ Version: $Revision: 1.9 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
class GDCM_EXPORT RLEFrame
{
friend class Document;
-friend class PixelConvert;
+friend class PixelReadConvert;
unsigned int NumberFragments;
long Offset[15];
long Length[15];
Program: gdcm
Module: $RCSfile: gdcmRLEFramesInfo.h,v $
Language: C++
- Date: $Date: 2004/10/20 14:30:40 $
- Version: $Revision: 1.6 $
+ Date: $Date: 2004/12/03 10:21:54 $
+ Version: $Revision: 1.7 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
typedef std::list< RLEFrame* > RLEFrameList;
friend class Document;
friend class File;
-friend class PixelConvert;
+friend class PixelReadConvert;
RLEFrameList Frames;
public:
~RLEFramesInfo();
projects / gdcm.git / commitdiff