X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=vtk%2FvtkGdcmReader.cxx;h=b9aa0732117d1438b2f337e5138c71cf2fb19a26;hb=f94f85b5578c5a8575f9cadc3702766defd9d707;hp=02f05672b4f7c49687c54acba1ff250152386a69;hpb=c34ecaa3bf4a10a611d4324686a8c25e93d805b8;p=gdcm.git diff --git a/vtk/vtkGdcmReader.cxx b/vtk/vtkGdcmReader.cxx index 02f05672..b9aa0732 100644 --- a/vtk/vtkGdcmReader.cxx +++ b/vtk/vtkGdcmReader.cxx @@ -1,22 +1,70 @@ -// $Header: /cvs/public/gdcm/vtk/vtkGdcmReader.cxx,v 1.15 2003/07/07 09:10:33 regrain Exp $ -#include +// $Header: /cvs/public/gdcm/vtk/vtkGdcmReader.cxx,v 1.28 2003/11/13 10:23:41 malaterre Exp $ +// ////////////////////////////////////////////////////////////// +// WARNING TODO CLENAME +// Actual limitations of this code: +// +// /////// Redundant and unnecessary header parsing +// In it's current state this code actually parses three times the Dicom +// header of a file before the corresponding image gets loaded in the +// ad-hoc vtkData ! +// Here is the process: +// 1/ First loading happens in ExecuteInformation which in order to +// positionate the vtk extents calls CheckFileCoherence. The purpose +// of CheckFileCoherence is to make sure all the images in the future +// stack are "homogenous" (same size, same representation...). This +// can only be achieved by parsing all the Dicom headers... +// 2/ ExecuteData is then responsible for the next two loadings: +// 2a/ ExecuteData calls AllocateOutputData that in turn seems to +// (indirectely call) ExecuteInformation which ends up in a second +// header parsing +// 2b/ the core of ExecuteData then needs gdcmFile (which in turns +// initialises gdcmHeader in the constructor) in order to access +// the data-image. +// +// Possible solution: +// maintain a list of gdcmFiles (created by say ExecuteInformation) created +// once and for all accross the life of vtkGdcmHeader (it would only load +// new gdcmFile if the user changes the list). ExecuteData would then use +// those gdcmFile and hence avoid calling the construtor: +// - advantage: the header of the files would only be parser once. +// - drawback: once execute information is called (i.e. on creation of +// a vtkGdcmHeader) the gdcmFile structure is loaded in memory. +// The average size of a gdcmHeader being of 100Ko, is one +// loads 10 stacks of images with say 200 images each, you +// end-up with a loss of 200Mo... +// +// /////// Never unallocated memory: +// ExecuteData allocates space for the pixel data [which will get pointed +// by the vtkPointData() through the call +// data->GetPointData()->GetScalars()->SetVoidArray(mem, StackNumPixels, 0);] +// This data is never "freed" neither in the destructor nor when the +// filename list is extended, ExecuteData is called a second (or third) +// time... +// ////////////////////////////////////////////////////////////// + +#include "gdcmFile.h" +#include "gdcmHeaderHelper.h" +#include "vtkGdcmReader.h" + +//#include #include #include #include -#include "vtkGdcmReader.h" -#include "gdcm.h" +#include + vtkGdcmReader::vtkGdcmReader() { // Constructor + this->LookupTable = NULL; } //---------------------------------------------------------------------------- vtkGdcmReader::~vtkGdcmReader() { - // FIXME free memory this->RemoveAllFileName(); this->InternalFileNameList.clear(); + if(this->LookupTable) this->LookupTable->Delete(); } //---------------------------------------------------------------------------- @@ -97,13 +145,24 @@ void vtkGdcmReader::BuildFileListFromPattern() return; } - this->RemoveAllInternalFileName(); - for (int idx = this->DataExtent[4]; idx <= this->DataExtent[5]; ++idx) + this->RemoveAllInternalFileName(); + if( this->FileNameList.empty() ) { - this->ComputeInternalFileName(idx); + //Multiframe case: + this->ComputeInternalFileName(this->DataExtent[4]); vtkDebugMacro("Adding file " << this->InternalFileName); this->AddInternalFileName(this->InternalFileName); } + else + { + //stack of 2D dicom case: + for (int idx = this->DataExtent[4]; idx <= this->DataExtent[5]; ++idx) + { + this->ComputeInternalFileName(idx); + vtkDebugMacro("Adding file " << this->InternalFileName); + this->AddInternalFileName(this->InternalFileName); + } + } } //---------------------------------------------------------------------------- @@ -123,7 +182,7 @@ void vtkGdcmReader::BuildFileListFromPattern() // (i.e. an image represents one plane, but a volume represents many planes) int vtkGdcmReader::CheckFileCoherence() { - int ReturnedTotalNumberOfPlanes = 0; // The returned value. + int ReturnedTotalNumberOfPlanes = 0; // The returned value. this->BuildFileListFromPattern(); if (this->InternalFileNameList.empty()) @@ -136,14 +195,14 @@ int vtkGdcmReader::CheckFileCoherence() int ReferenceNZ = 0; // Loop on the filenames: - // - check for their existence and gdcm "parasability" + // - check for their existence and gdcm "parsability" // - get the coherence check done: for (std::list::iterator FileName = InternalFileNameList.begin(); FileName != InternalFileNameList.end(); ++FileName) { // The file is always added in the number of planes - // - If file doesn't exist, it will be replaced by a black place in the + // - If file doesn't exist, it will be replaced by a black plane in the // ExecuteData method // - If file has more than 1 plane, other planes will be added later to // to the ReturnedTotalNumberOfPlanes variable counter @@ -168,7 +227,7 @@ int vtkGdcmReader::CheckFileCoherence() fclose(fp); // Stage 1.2: check for Gdcm parsability - gdcmHeader GdcmHeader(FileName->c_str()); + gdcmHeaderHelper GdcmHeader(FileName->c_str()); if (!GdcmHeader.IsReadable()) { vtkErrorMacro("Gdcm cannot parse file " << FileName->c_str()); @@ -185,6 +244,7 @@ int vtkGdcmReader::CheckFileCoherence() && (type != "32U") && (type != "32S") ) { vtkErrorMacro("Bad File Type for file" << FileName->c_str()); + vtkErrorMacro(" " << type.c_str()); vtkErrorMacro("Removing this file from readed files " << FileName->c_str()); *FileName = "GDCM_UNREADABLE"; @@ -253,11 +313,31 @@ int vtkGdcmReader::CheckFileCoherence() ReturnedTotalNumberOfPlanes += NZ - 1; // First plane already added this->ImageType = type; this->PixelSize = GdcmHeader.GetPixelSize(); + + if( GdcmHeader.HasLUT() ) + { + this->NumComponents = GdcmHeader.GetNumberOfScalarComponentsRaw(); + } + else + { + this->NumComponents = GdcmHeader.GetNumberOfScalarComponents(); //rgb or mono + } + + //Set image spacing + this->DataSpacing[0] = GdcmHeader.GetXSpacing(); + this->DataSpacing[1] = GdcmHeader.GetYSpacing(); + this->DataSpacing[2] = GdcmHeader.GetZSpacing(); + + //Set image origin + this->DataOrigin[0] = GdcmHeader.GetXOrigin(); + this->DataOrigin[1] = GdcmHeader.GetYOrigin(); + this->DataOrigin[2] = GdcmHeader.GetZOrigin(); + } } // End of loop on FileName ///////// The files we CANNOT load are flaged. On debugging purposes - // count the loadable number of files and display thir number: + // count the loadable number of files and display their number: int NumberCoherentFiles = 0; for (std::list::iterator Filename = InternalFileNameList.begin(); Filename != InternalFileNameList.end(); @@ -283,7 +363,6 @@ int vtkGdcmReader::CheckFileCoherence() // Configure the output e.g. WholeExtent, spacing, origin, scalar type... void vtkGdcmReader::ExecuteInformation() { - //FIXME free any old memory this->TotalNumberOfPlanes = this->CheckFileCoherence(); if ( this->TotalNumberOfPlanes == 0) { @@ -292,7 +371,7 @@ void vtkGdcmReader::ExecuteInformation() } // if the user has not set the extent, but has set the VOI - // set the zaxis extent to the VOI z axis + // set the z axis extent to the VOI z axis if (this->DataExtent[4]==0 && this->DataExtent[5] == 0 && (this->DataVOI[4] || this->DataVOI[5])) { @@ -327,11 +406,8 @@ void vtkGdcmReader::ExecuteInformation() this->DataExtent[1] = this->NumColumns - 1; this->DataExtent[2] = 0; this->DataExtent[3] = this->NumLines - 1; - if(this->InternalFileNameList.size() > 1) - { - this->DataExtent[4] = 0; - this->DataExtent[5] = this->TotalNumberOfPlanes - 1; - } + this->DataExtent[4] = 0; + this->DataExtent[5] = this->TotalNumberOfPlanes - 1; // We don't need to positionate the Endian related stuff (by using // this->SetDataByteOrderToBigEndian() or SetDataByteOrderToLittleEndian() @@ -370,6 +446,9 @@ void vtkGdcmReader::ExecuteInformation() this->SetDataScalarTypeToInt(); } + //Set number of scalar components: + this->SetNumberOfScalarComponents(this->NumComponents); + vtkImageReader::ExecuteInformation(); } @@ -382,21 +461,49 @@ size_t vtkGdcmReader::LoadImageInMemory( const unsigned long UpdateProgressTarget, unsigned long & UpdateProgressCount) { - vtkDebugMacro("Copying to memmory image" << FileName.c_str()); + vtkDebugMacro("Copying to memory image" << FileName.c_str()); gdcmFile GdcmFile(FileName.c_str()); - size_t size = GdcmFile.GetImageDataSize(); + size_t size; // If the data structure of vtk for image/volume representation // were straigthforwards the following would suffice: // GdcmFile.GetImageDataIntoVector((void*)Dest, size); - // But vtk chose to invert the lines of an image, that is the last + // But vtk chooses to invert the lines of an image, that is the last // line comes first (for some axis related reasons?). Hence we need - // to load the image line by line, starting from the end: + // to load the image line by line, starting from the end. int NumColumns = GdcmFile.GetXSize(); int NumLines = GdcmFile.GetYSize(); int NumPlanes = GdcmFile.GetZSize(); - int LineSize = NumColumns * GdcmFile.GetPixelSize(); - unsigned char * Source = (unsigned char*)GdcmFile.GetImageData(); + int LineSize = NumComponents * NumColumns * GdcmFile.GetPixelSize(); + + unsigned char * Source; + if( GdcmFile.HasLUT() ) + { + size = GdcmFile.GetImageDataSizeRaw(); + Source = (unsigned char*) GdcmFile.GetImageDataRaw(); + unsigned char *Lut = GdcmFile.GetLUTRGBA(); + + if(!this->LookupTable) this->LookupTable = vtkLookupTable::New(); + this->LookupTable->SetNumberOfTableValues(256); + for (int tmp=0; tmp<256; tmp++) + { + this->LookupTable->SetTableValue(tmp, + (float)Lut[4*tmp+0]/255.0, + (float)Lut[4*tmp+1]/255.0, + (float)Lut[4*tmp+2]/255.0, + 1); + } + this->LookupTable->SetRange(0,255); + vtkDataSetAttributes *a=this->GetOutput()->GetPointData(); + a->GetScalars()->SetLookupTable(this->LookupTable); + free(Lut); + } + else + { + size = GdcmFile.GetImageDataSize(); + Source = (unsigned char*)GdcmFile.GetImageData(); + } + unsigned char * pSource = Source; //pointer for later deletion unsigned char * Destination = Dest + size - LineSize; for (int plane = 0; plane < NumPlanes; plane++) @@ -415,6 +522,9 @@ size_t vtkGdcmReader::LoadImageInMemory( UpdateProgressCount++; } } + //GetImageData allocate a (void*)malloc, remove it: + free(pSource); + return size; } @@ -423,8 +533,7 @@ size_t vtkGdcmReader::LoadImageInMemory( // (see vtkSource.cxx for last step). // This function (redefinition of vtkImageReader::ExecuteData, see // VTK/IO/vtkImageReader.cxx) reads a data from a file. The datas -// extent/axes are assumed to be the -// same as the file extent/order. +// extent/axes are assumed to be the same as the file extent/order. void vtkGdcmReader::ExecuteData(vtkDataObject *output) { if (this->InternalFileNameList.empty()) @@ -433,21 +542,21 @@ void vtkGdcmReader::ExecuteData(vtkDataObject *output) return; } - // FIXME : the bad parse of header is made when allocating OuputData + // FIXME : extraneous parsing of header is made when allocating OuputData vtkImageData *data = this->AllocateOutputData(output); data->SetExtent(this->DataExtent); data->GetPointData()->GetScalars()->SetName("DicomImage-Volume"); // Test if output has valid extent // Prevent memory errors - if((this->DataExtent[1]-this->DataExtent[0]>0) && - (this->DataExtent[3]-this->DataExtent[2]>0) && - (this->DataExtent[5]-this->DataExtent[4]>0)) + if((this->DataExtent[1]-this->DataExtent[0]>=0) && + (this->DataExtent[3]-this->DataExtent[2]>=0) && + (this->DataExtent[5]-this->DataExtent[4]>=0)) { // The memory size for a full stack of images of course depends // on the number of planes and the size of each image: size_t StackNumPixels = this->NumColumns * this->NumLines - * this->TotalNumberOfPlanes; + * this->TotalNumberOfPlanes * this->NumComponents; size_t stack_size = StackNumPixels * this->PixelSize; // Allocate pixel data space itself. unsigned char *mem = new unsigned char [stack_size]; @@ -491,13 +600,13 @@ void vtkGdcmReader::ExecuteData(vtkDataObject *output) } } } // Else, file not loadable - } // Loop on files // The "size" of the vtkScalars data is expressed in number of points, // and is not the memory size representing those points: data->GetPointData()->GetScalars()->SetVoidArray(mem, StackNumPixels, 0); - this->Modified(); + //don't know why it's here, it's calling one more time ExecuteInformation: + //this->Modified(); } }