Program: gdcm
Module: $RCSfile: vtkGdcmReader.cxx,v $
Language: C++
- Date: $Date: 2005/08/30 14:40:35 $
- Version: $Revision: 1.77 $
+ Date: $Date: 2010/09/01 13:33:36 $
+ Version: $Revision: 1.98 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
// //////////////////////////////////////////////////////////////
//
//===> Many users expect from vtkGdcmReader it 'orders' the images
-// (that's the job of gdcm::SerieHelper ...)
+// (that's the job of GDCM_NAME_SPACE::SerieHelper ...)
// When user *knows* the files with same Serie UID
// have same sizes, same 'pixel' type, same color convention, ...
// the right way to proceed is as follow :
//
-// gdcm::SerieHelper *sh= new gdcm::SerieHelper();
+// GDCM_NAME_SPACE::SerieHelper *sh= new GDCM_NAME_SPACE::SerieHelper();
// // if user wants *not* to load some parts of the file headers
// sh->SetLoadMode(loadMode);
+//
// // if user wants *not* to load some files
// sh->AddRestriction(group, element, value, operator);
// sh->AddRestriction( ...
//
// // if user wants to sort reverse order
// sh->SetSortOrderToReverse();
-// // here, we suppose only the first Coherent File List is of interest
-// gdcm::FileList *l = sh->GetFirstCoherentFileList();
+//
+// // here, we suppose only the first 'Serie' is of interest
+// // it's up to the user to decide !
+// GDCM_NAME_SPACE::FileList *l = sh->GetFirstSingleSerieUIDFileSet();
+//
// // if user is doesn't trust too much the files with same Serie UID
// if ( !sh->IsCoherent(l) )
// return; // not same sizes, same 'pixel' type -> stop
+//
+// // WARNING : all that follows works only with 'bona fide' Series
+// // (In some Series; there are more than one 'orientation'
+// // Don't expected to build a 'volume' with that!
+// //
+// // -> use sh->SplitOnOrientation(l)
+// // - or sh->SplitOnPosition(l), or SplitOnTagValue(l, gr, el) -
+// // depending on what you want to do
+// // and iterate on the various 'X Coherent File Sets'
+//
+// // if user *knows* he has to drop the 'duplicates' images
+// // (same Position)
+// sh->SetDropDuplicatePositions(true);
+//
+// // Sorting the list is mandatory
+// // a side effect is to compute ZSpacing for the file set
// sh->OrderFileList(l); // sort the list
//
// vtkGdcmReader *reader = vtkGdcmReader::New();
+//
// // if user wants to modify pixel order (Mirror, TopDown, 90°Rotate, ...)
// // he has to supply the function that does the job
// // (a *very* simple example is given in vtkgdcmSerieViewer.cxx)
// reader->SetUserFunction (userSuppliedFunction);
-// // to pass a 'Coherent File List' as produced by gdcm::SerieHelper
+//
+// // to pass a 'Coherent File List' as produced by GDCM_NAME_SPACE::SerieHelper
// reader->SetCoherentFileList(l);
// reader->Update();
//
#include "gdcmFileHelper.h"
#include "gdcmFile.h"
+#include "gdcmSerieHelper.h" // for ImagePositionPatientOrdering()
#include "vtkGdcmReader.h"
#include "gdcmDebug.h"
#include <vtkPointData.h>
#include <vtkLookupTable.h>
-vtkCxxRevisionMacro(vtkGdcmReader, "$Revision: 1.77 $")
+vtkCxxRevisionMacro(vtkGdcmReader, "$Revision: 1.98 $")
vtkStandardNewMacro(vtkGdcmReader)
//-----------------------------------------------------------------------------
{
this->LookupTable = NULL;
this->AllowLookupTable = false;
- this->AllowLightChecking = false;
- this->LoadMode = GDCM_LD_ALL; // Load everything (possible values :
- // - LD_NOSEQ,
- // - LD_NOSHADOW,
- // - LD_NOSHADOWSEQ)
+ //this->AllowLightChecking = false;
+ this->LoadMode = GDCM_NAME_SPACE::LD_ALL; // Load everything (possible values :
+ // - LD_NOSEQ,
+ // - LD_NOSHADOW,
+ // - LD_NOSHADOWSEQ)
this->CoherentFileList = 0;
this->UserFunction = 0;
this->OwnFile=true;
- this->Execution=false;
+ // this->Execution=false; // For VTK5.0
+
+ this->KeepOverlays = false;
+ this->FlipY = true; // to keep old behaviour
}
vtkGdcmReader::~vtkGdcmReader()
*/
void vtkGdcmReader::ExecuteInformation()
{
- if(this->Execution)
- return;
-
- this->Execution=true;
+// if(this->Execution) // For VTK5.0
+// return;
+//
+// this->Execution=true; // end For VTK5.0
this->RemoveAllInternalFile();
if(this->MTime>this->fileTime)
{
vtkDebugMacro(<< "32 bits signed image");
this->SetDataScalarTypeToInt();
}
- else if ( ImageType == "FD" )
+ else if ( ImageType == "FD" ) // This is not genuine DICOM, but so usefull
{
vtkDebugMacro(<< "64 bits Double image");
this->SetDataScalarTypeToDouble();
this->fileTime=this->MTime;
}
- this->Superclass::ExecuteInformation();
+ this->Superclass::ExecuteInformation();
- this->GetOutput()->SetUpdateExtentToWholeExtent();
- this->BuildData(this->GetOutput());
+ //this->GetOutput()->SetUpdateExtentToWholeExtent();// For VTK5.0
+ //this->BuildData(this->GetOutput());
- this->Execution=false;
- this->RemoveAllInternalFile();
+ //this->Execution=false;
+ //this->RemoveAllInternalFile(); // End For VTK5.0
}
/*
return;
}
*/
-}
-
-void vtkGdcmReader::BuildData(vtkDataObject *output)
-{
- vtkImageData *data = this->AllocateOutputData(output);
+
+ // data->AllocateScalars(); // For VTK5.0
+ // if (this->UpdateExtentIsEmpty(output))
+ // {
+ // return;
+ // }
+//} // end For VTK5.0
+
+ data->AllocateScalars(); // For VTK5.0
+
+#if (VTK_MAJOR_VERSION >= 5) || ( VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION > 2 )
+//#if (VTK_MAJOR_VERSION >= 5)
+ if (this->UpdateExtentIsEmpty(output))
+ {
+ return;
+ }
+#endif
data->GetPointData()->GetScalars()->SetName("DicomImage-Volume");
size_t size = this->NumColumns * this->NumLines * this->NumPlanes
* data->GetScalarSize() * this->NumComponents;
unsigned char *Dest = (unsigned char *)data->GetScalarPointer();
- for (std::vector<gdcm::File* >::iterator it = InternalFileList.begin();
+ for (std::vector<GDCM_NAME_SPACE::File* >::iterator it = InternalFileList.begin();
it != InternalFileList.end();
++it)
{
Dest += size;
}
}
+ this->RemoveAllInternalFile(); // For VTK5.0
}
/*
*/
void vtkGdcmReader::LoadFileInformation()
{
- gdcm::File *file;
+ GDCM_NAME_SPACE::File *file;
bool foundReference=false;
std::string type;
fclose(fp);
// Read the file
- file=new gdcm::File();
+ file=GDCM_NAME_SPACE::File::New();
file->SetLoadMode( LoadMode );
file->SetFileName(filename->c_str() );
file->Load();
vtkErrorMacro(<< "Gdcm cannot parse file " << filename->c_str());
vtkErrorMacro(<< "Removing this file from read files: "
<< filename->c_str());
- delete file;
+ file->Delete();
file=NULL;
InternalFileList.push_back(file);
continue;
type = file->GetPixelType();
if ( (type != "8U") && (type != "8S")
&& (type != "16U") && (type != "16S")
- && (type != "32U") && (type != "32S") )
+ && (type != "32U") && (type != "32S")
+ && (type != "FD") ) // Sure this one is NOT kosher
{
vtkErrorMacro(<< "Bad File Type for file " << filename->c_str() << "\n"
<< " File type found : " << type.c_str()
- << " (might be 8U, 8S, 16U, 16S, 32U, 32S) \n"
+ << " (might be 8U, 8S, 16U, 16S, 32U, 32S, FD) \n"
<< " Removing this file from read files");
- delete file;
+ file->Delete();
file=NULL;
InternalFileList.push_back(file);
continue;
}
else if(!TestFileInformation(file))
{
- delete file;
+ file->Delete();
file=NULL;
}
* These informations are required to specify the output image
* caracteristics
*/
-void vtkGdcmReader::GetFileInformation(gdcm::File *file)
+void vtkGdcmReader::GetFileInformation(GDCM_NAME_SPACE::File *file)
{
// Get the image caracteristics
this->NumColumns = file->GetXSize();
this->NumLines = file->GetYSize();
this->NumPlanes = file->GetZSize();
- this->TotalNumberOfPlanes = this->NumPlanes*InternalFileNameList.size();
+
+ if (CoherentFileList == 0)
+ this->TotalNumberOfPlanes = this->NumPlanes*InternalFileNameList.size();
+ else
+ this->TotalNumberOfPlanes = this->NumPlanes*CoherentFileList->size();
this->ImageType = file->GetPixelType();
this->PixelSize = file->GetPixelSize();
this->DataSpacing[0] = file->GetXSpacing();
this->DataSpacing[1] = file->GetYSpacing();
- this->DataSpacing[2] = file->GetZSpacing();
+
+ // Most of the file headers have NO z spacing
+ // It must be calculated from the whole GDCM_NAME_SPACE::Serie (if any)
+ // using Jolinda Smith's algoritm.
+ // see GDCM_NAME_SPACE::SerieHelper::ImagePositionPatientOrdering()
+ if (CoherentFileList == 0)
+ this->DataSpacing[2] = file->GetZSpacing();
+ else
+ {
+ // Just because OrderFileList() is a member of GDCM_NAME_SPACE::SerieHelper
+ // we need to instanciate sh.
+ GDCM_NAME_SPACE::SerieHelper *sh = GDCM_NAME_SPACE::SerieHelper::New();
+ sh->OrderFileList(CoherentFileList); // calls ImagePositionPatientOrdering()
+ this->DataSpacing[2] = sh->GetZSpacing();
+ sh->Delete();
+ }
// Get the image data caracteristics
if( file->HasLUT() && this->AllowLookupTable )
*
* \return True if the file match, False otherwise
*/
-bool vtkGdcmReader::TestFileInformation(gdcm::File *file)
+bool vtkGdcmReader::TestFileInformation(GDCM_NAME_SPACE::File *file)
{
int numColumns = file->GetXSize();
int numLines = file->GetYSize();
int numPlanes = file->GetZSize();
- int pixelSize = file->GetPixelSize();
int numComponents;
+ unsigned int pixelSize = file->GetPixelSize();
if( file->HasLUT() && this->AllowLookupTable )
numComponents = file->GetNumberOfScalarComponentsRaw();
}
if( numLines != this->NumLines )
{
- vtkErrorMacro(<< "File y value doesn't match with the previous ones: "
+ vtkErrorMacro(<< "File Y value doesn't match with the previous ones: "
<< file->GetFileName().c_str()
<< ". Found " << numLines << ", must be "
<< this->NumLines);
}
if( numPlanes != this->NumPlanes )
{
- vtkErrorMacro(<< "File z value doesn't match with the previous ones: "
+ vtkErrorMacro(<< "File Z value doesn't match with the previous ones: "
<< file->GetFileName().c_str()
<< ". Found " << numPlanes << ", must be "
<< this->NumPlanes);
it!=InternalFileList.end();
++it)
{
- delete (*it);
+ (*it)->Delete();
}
}
this->InternalFileList.clear();
{
if (!(updateProgressCount%updateProgressTarget))
{
- this->UpdateProgress(updateProgressCount/(50.0*updateProgressTarget));
+ this->UpdateProgress(
+ updateProgressCount/(50.0*updateProgressTarget));
}
}
}
{
vtkDebugMacro(<< "Copying to memory image [" << fileName.c_str() << "]");
- gdcm::File *f;
- f = new gdcm::File();
+ GDCM_NAME_SPACE::File *f;
+ f = new GDCM_NAME_SPACE::File();
f->SetLoadMode( LoadMode );
f->SetFileName( fileName.c_str() );
f->Load( );
}*/
/*
- * Loads the contents of the image/volume contained by gdcm::File* f at
+ * Loads the contents of the image/volume contained by GDCM_NAME_SPACE::File* f at
* the Dest memory address. Returns the size of the data loaded.
* \ param f File to consider. NULL if the file must be skiped
* \remarks Assume that if (f != NULL) then its caracteristics match
* with the previous ones
*/
void vtkGdcmReader::LoadImageInMemory(
- gdcm::File *f,
+ GDCM_NAME_SPACE::File *f,
unsigned char *dest,
const unsigned long updateProgressTarget,
unsigned long &updateProgressCount)
if(!f)
return;
- gdcm::FileHelper *fileH = new gdcm::FileHelper( f );
+ GDCM_NAME_SPACE::FileHelper *fileH = GDCM_NAME_SPACE::FileHelper::New( f );
fileH->SetUserFunction( UserFunction );
-
+
+ fileH->SetKeepOverlays ( this->KeepOverlays);
+
int numColumns = f->GetXSize();
int numLines = f->GetYSize();
int numPlanes = f->GetZSize();
numComponents = f->GetNumberOfScalarComponentsRaw();
else
numComponents = f->GetNumberOfScalarComponents(); //rgb or mono
-
+ vtkDebugMacro(<< "numComponents:" << numComponents);
vtkDebugMacro(<< "Copying to memory image [" << f->GetFileName().c_str() << "]");
- size_t size;
+ //size_t size;
// If the data structure of vtk for image/volume representation
// were straigthforwards the following would be enough:
if( fileH->GetFile()->HasLUT() && AllowLookupTable )
{
- size = fileH->GetImageDataSize();
+ // to avoid bcc 5.5 w
+ /*size = */ fileH->GetImageDataSize();
src = (unsigned char*) fileH->GetImageDataRaw();
unsigned char *lut = (unsigned char*) fileH->GetLutRGBA();
this->LookupTable->SetRange(0,255);
vtkDataSetAttributes *a = this->GetOutput()->GetPointData();
a->GetScalars()->SetLookupTable(this->LookupTable);
- free(lut);
+ delete[] lut;
}
else
{
- size = fileH->GetImageDataSize();
- src = (unsigned char*)fileH->GetImageData();
- }
+ //size = fileH->GetImageDataSize();
+ // useless - just an accessor; 'size' unused
+ //if (this->GetFlipY())
+ src = (unsigned char*)fileH->GetImageData();
+ //else
+ // very strange, but it doesn't work (I have to memcpy the pixels ?!?)
+ // dest = (unsigned char*)fileH->GetImageData();
+ }
+if (this->GetFlipY()) {
unsigned char *dst = dest + planeSize - lineSize;
for (int plane = 0; plane < numPlanes; plane++)
{
// Update progress related:
if (!(updateProgressCount%updateProgressTarget))
{
- this->UpdateProgress(updateProgressCount/(50.0*updateProgressTarget));
+ this->UpdateProgress(
+ updateProgressCount/(50.0*updateProgressTarget));
}
updateProgressCount++;
}
dst += 2 * planeSize;
}
-
- delete fileH;
+}
+else // we don't flip (upside down) the image
+{
+ memcpy((void*)dest, (void*)src, numPlanes * numLines * lineSize);
+}
+ fileH->Delete();
}
//-----------------------------------------------------------------------------
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff