X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;ds=sidebyside;f=vtk%2FvtkGdcmReader.cxx;h=1e0852bdbab52c64923cf2d9c62321b20455b80e;hb=738c5370d807730d3e59ada72a1534876c51c8fd;hp=8497a5f7c84be3ea25ebf2d16ef6ddde3eeefc95;hpb=5740f3482ac603ba6234e79a45701c2e864ee242;p=gdcm.git diff --git a/vtk/vtkGdcmReader.cxx b/vtk/vtkGdcmReader.cxx index 8497a5f7..1e0852bd 100644 --- a/vtk/vtkGdcmReader.cxx +++ b/vtk/vtkGdcmReader.cxx @@ -1,15 +1,15 @@ -// $Header: /cvs/public/gdcm/vtk/vtkGdcmReader.cxx,v 1.18 2003/08/29 09:47:13 malaterre Exp $ +// $Header: /cvs/public/gdcm/vtk/vtkGdcmReader.cxx,v 1.29 2003/12/22 12:46:19 regrain 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 corrersponding image gets loaded in the +// 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 purpous +// 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... @@ -18,17 +18,17 @@ // (indirectely call) ExecuteInformation which ends up in a second // header parsing // 2b/ the core of ExecuteData then needs gdcmFile (which in turns -// initialiszes gdcmHeader in the constructor) in order to access +// 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 consctutor: +// 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 sctructue is loaded in memory. +// 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... @@ -37,21 +37,26 @@ // 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 desctutor nor when the +// 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 +#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; } //---------------------------------------------------------------------------- @@ -59,6 +64,7 @@ vtkGdcmReader::~vtkGdcmReader() { this->RemoveAllFileName(); this->InternalFileNameList.clear(); + if(this->LookupTable) this->LookupTable->Delete(); } //---------------------------------------------------------------------------- @@ -140,12 +146,23 @@ void vtkGdcmReader::BuildFileListFromPattern() } this->RemoveAllInternalFileName(); - for (int idx = this->DataExtent[4]; idx <= this->DataExtent[5]; ++idx) + 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); + } + } } //---------------------------------------------------------------------------- @@ -165,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()) @@ -178,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 @@ -210,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()); @@ -227,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"; @@ -295,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(); @@ -333,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])) { @@ -368,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() @@ -411,6 +446,9 @@ void vtkGdcmReader::ExecuteInformation() this->SetDataScalarTypeToInt(); } + //Set number of scalar components: + this->SetNumberOfScalarComponents(this->NumComponents); + vtkImageReader::ExecuteInformation(); } @@ -423,21 +461,48 @@ 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: - int NumColumns = GdcmFile.GetXSize(); - int NumLines = GdcmFile.GetYSize(); - int NumPlanes = GdcmFile.GetZSize(); - int LineSize = NumColumns * GdcmFile.GetPixelSize(); - unsigned char * Source = (unsigned char*)GdcmFile.GetImageData(); + // to load the image line by line, starting from the end. + int NumColumns = GdcmFile.GetHeader()->GetXSize(); + int NumLines = GdcmFile.GetHeader()->GetYSize(); + int NumPlanes = GdcmFile.GetHeader()->GetZSize(); + int LineSize = NumComponents * NumColumns * GdcmFile.GetHeader()->GetPixelSize(); + + unsigned char * Source; + if( GdcmFile.GetHeader()->HasLUT() ) + { + size = GdcmFile.GetImageDataSizeRaw(); + Source = (unsigned char*) GdcmFile.GetImageDataRaw(); + unsigned char *Lut = GdcmFile.GetHeader()->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; @@ -491,7 +556,7 @@ void vtkGdcmReader::ExecuteData(vtkDataObject *output) // 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]; @@ -540,7 +605,8 @@ void vtkGdcmReader::ExecuteData(vtkDataObject *output) // 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(); } }