Program: gdcm
Module: $RCSfile: gdcmSerieHelper.cxx,v $
Language: C++
- Date: $Date: 2006/02/16 20:06:15 $
- Version: $Revision: 1.47 $
+ Date: $Date: 2007/07/05 09:34:12 $
+ Version: $Revision: 1.59 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
#include "gdcmSerieHelper.h"
#include "gdcmDirList.h"
#include "gdcmFile.h"
-#include "gdcmDictEntry.h" // for TranslateToKey
+//#include "gdcmDictEntry.h" // for TranslateToKey : no more !
#include "gdcmDebug.h"
#include "gdcmUtil.h"
#include <map>
#include <stdio.h> //for sscanf
-namespace gdcm
+namespace GDCM_NAME_SPACE
{
//-----------------------------------------------------------------------------
ClearAll();
UserLessThanFunction = 0;
DirectOrder = true;
+
}
/**
FileList *l = GetFirstSingleSerieUIDFileSet();
while (l)
{
- // For all the gdcm::File of a File set
- for (gdcm::FileList::iterator it = l->begin();
+ // For all the GDCM_NAME_SPACE::File of a File set
+ for (GDCM_NAME_SPACE::FileList::iterator it = l->begin();
it != l->end();
++it)
{
// Public
/**
- * \brief add a gdcm::File to the Fileset corresponding to its Serie UID
+ * \brief add a GDCM_NAME_SPACE::File to the Fileset corresponding to its Serie UID
* @param filename Name of the file to deal with
*/
void SerieHelper::AddFileName(std::string const &filename)
}
/**
- * \brief add a gdcm::File to the first (and supposed to be unique) file set
- * of the gdcm::SerieHelper.
+ * \brief add a GDCM_NAME_SPACE::File to the first (and supposed to be unique) file set
+ * of the GDCM_NAME_SPACE::SerieHelper.
* \warning : this method should be used by aware users only!
- * Passing a gdcm::File* has the same effect than passing a file name!
+ * Passing a GDCM_NAME_SPACE::File* has the same effect than passing a file name!
* \todo : decide which one is wrong (the method, or the commentary)!
* the following comment doesn't match the method :-(
* User is supposed to know the files he want to deal with
* vtkGdcmReader parsing twice the same files.
* *no* coherence check is performed, but those specified
* by SerieHelper::AddRestriction()
- * @param header gdcm::File* of the file to deal with
+ * @param header GDCM_NAME_SPACE::File* of the file to deal with
* @return true if file was added, false if file was rejected
*/
bool SerieHelper::AddFile(File *header)
if ( SingleSerieUIDFileSetHT.count(id) == 0 )
{
- gdcmDebugMacro(" New Serie UID :[" << id << "]");
+ gdcmDebugMacro(" New/gdcmSerieHelper.cxx Serie UID :[" << id << "]");
// create a std::list in 'id' position
SingleSerieUIDFileSetHT[id] = new FileList;
}
ExRefine.push_back( r );
}
-#ifndef GDCM_LEGACY_REMOVE
+//#ifndef GDCM_LEGACY_REMOVE
/**
* \brief add a rule for restricting a DICOM file to be in the serie we are
* trying to find. For example you can select only the DICOM files from a
* @deprecated use : AddRestriction(TagKey const &key,
* std::string const &value, int op);
*/
+
void SerieHelper::AddRestriction(uint16_t group, uint16_t elem,
std::string const &value, int op)
{
TagKey t(group, elem);
AddRestriction(t, value, op);
}
-#endif
+
+//#endif
/**
* \brief add an extra 'SerieDetail' for building a 'Serie Identifier'
* e.g : 100 would be *before* 20; 000020.00 vs 00100.00 : OK
*/
void SerieHelper::AddSeriesDetail(uint16_t group, uint16_t elem, bool convert)
-{
-
+{
ExDetail d;
d.group = group;
d.elem = elem;
}
}
+/**
+ * \brief Sets the DicomDirSerie
+ * @param se DicomDirSerie to deal with
+ */
+void SerieHelper::SetDicomDirSerie(DicomDirSerie *se)
+{
+ DirList dirList(se);
+
+ DirListType filenames_list = dirList.GetFilenames();
+ for( DirListType::const_iterator it = filenames_list.begin();
+ it != filenames_list.end(); ++it)
+ {
+ AddFileName( *it );
+ }
+}
+
/**
* \brief Sorts the given Fileset
* \warning This could be implemented in a 'Strategy Pattern' approach
*/
void SerieHelper::OrderFileList(FileList *fileSet)
{
-
+ // Only computed during ImagePositionPatientOrdering
+ // (need to sort the FileList using IPP and IOP !)
+ ZSpacing = -1.0;
+
if ( SerieHelper::UserLessThanFunction )
{
UserOrdering( fileSet );
return true;
}
-#ifndef GDCM_LEGACY_REMOVE
+//#ifndef GDCM_LEGACY_REMOVE
/**
* \brief accessor (DEPRECATED : use GetFirstSingleSerieUIDFileSet )
* Warning : 'coherent' means here they have the same Serie UID
* @return The first FileList if found, otherwhise NULL
*/
+ /*
FileList *SerieHelper::GetFirstCoherentFileList()
{
ItFileSetHt = SingleSerieUIDFileSetHT.begin();
return ItFileSetHt->second;
return NULL;
}
-
+*/
/**
* \brief accessor (DEPRECATED : use GetNextSingleSerieUIDFileSet )
* Warning : 'coherent' means here they have the same Serie UID
* \note : meaningfull only if GetFirstCoherentFileList() already called
* @return The next FileList if found, otherwhise NULL
*/
+ /*
FileList *SerieHelper::GetNextCoherentFileList()
{
gdcmAssertMacro (ItFileSetHt != SingleSerieUIDFileSetHT.end());
return ItFileSetHt->second;
return NULL;
}
+*/
/**
* \brief accessor (DEPRECATED : use GetSingleSerieUIDFileSet )
* @param SerieUID SerieUID
* \return pointer to the FileList if found, otherwhise NULL
*/
+ /*
FileList *SerieHelper::GetCoherentFileList(std::string SerieUID)
{
if ( SingleSerieUIDFileSetHT.count(SerieUID) == 0 )
return 0;
return SingleSerieUIDFileSetHT[SerieUID];
}
-#endif
+*/
+//#endif
/**
std::ostringstream ossOrient;
FileList::const_iterator it = fileSet->begin();
- it ++;
+ //it ++;
for ( ;
it != fileSet->end();
++it)
std::ostringstream ossPosition;
std::string strPosition; // re computed
FileList::const_iterator it = fileSet->begin();
- it ++;
+ //it ++;
for ( ;
it != fileSet->end();
++it)
* value of a given Tag
* @param fileSet File Set to be splitted
* @param group group number of the target Element
- * @param elem element number of the target Element
+ * @param element element number of the target Element
* \return std::map of 'Xcoherent' File sets
*/
std::string strTagValue; // read on disc
FileList::const_iterator it = fileSet->begin();
- it ++;
+ //it ++;
for ( ;
it != fileSet->end();
++it)
// Private
/**
* \brief sorts the images, according to their Patient Position.
- *
+ * As a side effect, it computes the ZSpacing, according to Jolinda Smith'
+ * algorithm. (get it with double GetZSpacing() !)
* We may order, considering :
* -# Image Position Patient
* -# Image Number
bool SerieHelper::ImagePositionPatientOrdering( FileList *fileList )
//based on Jolinda Smith's algorithm
{
+//Tags always use the same coordinate system, where "x" is left
+//to right, "y" is posterior to anterior, and "z" is foot to head (RAH).
+
//iop is calculated based on the file file
float cosines[6];
double normal[3];
double dist;
double min = 0, max = 0;
bool first = true;
+ ZSpacing = -1.0; // will be updated if process doesn't fail
std::multimap<double,File *> distmultimap;
// Use a multimap to sort the distances from 0,0,0
if ( first )
{
(*it)->GetImageOrientationPatient( cosines );
-
+
+ // The "Image Orientation Patient" tag gives the direction cosines
+ // for the rows and columns for the three axes defined above.
+ // Typical axial slices will have a value 1/0/0/0/1/0:
+ // rows increase from left to right,
+ // columns increase from posterior to anterior. This is your everyday
+ // "looking up from the bottom of the head with the eyeballs up" image.
+
+ // The "Image Position Patient" tag gives the coordinates of the first
+ // voxel in the image in the "RAH" coordinate system, relative to some
+ // origin.
+
+ // First, calculate the slice normal from IOP :
+
// You only have to do this once for all slices in the volume. Next,
// for each slice, calculate the distance along the slice normal
// using the IPP ("Image Position Patient") tag.
normal[0] = cosines[1]*cosines[5] - cosines[2]*cosines[4];
normal[1] = cosines[2]*cosines[3] - cosines[0]*cosines[5];
normal[2] = cosines[0]*cosines[4] - cosines[1]*cosines[3];
-
+
+ // For each slice (here : the first), calculate the distance along
+ // the slice normal using the IPP tag
+
ipp[0] = (*it)->GetXOrigin();
ipp[1] = (*it)->GetYOrigin();
ipp[2] = (*it)->GetZOrigin();
}
else
{
+ // Next, for each slice, calculate the distance along the slice normal
+ // using the IPP tag
ipp[0] = (*it)->GetXOrigin();
ipp[1] = (*it)->GetYOrigin();
ipp[2] = (*it)->GetZOrigin();
// Find out if min/max are coherent
if ( min == max )
{
- gdcmWarningMacro("Looks like all images have the exact same image position"
- << ". No PositionPatientOrdering sort performed" );
+ gdcmWarningMacro("Looks like all images have the exact same image position. "
+ << "No PositionPatientOrdering sort performed. "
+ << "No 'ZSpacing' calculated! ");
return false;
}
{
if (distmultimap.count((*it2).first) != 1)
{
- gdcmErrorMacro("File: "
+ gdcmErrorMacro("File: ["
<< ((*it2).second->GetFileName())
- << " Distance: "
+ << "] : more than ONE file at distance: '"
<< (*it2).first
- << " position is not unique");
+ << " (position is not unique!) "
+ << "No PositionPatientOrdering sort performed. "
+ << "No 'ZSpacing' calculated! ");
ok = false;
}
}
if (!ok)
{
- return false;
+ if (! DropDuplicatePositions)
+ return false;
}
+// Now, we could calculate Z Spacing as the difference
+// between the "dist" values for the first two slices.
+
+// The following (un)-commented out code is let here
+// to be re-used by whomsoever is interested...
+
+ std::multimap<double, File *>::iterator it5 = distmultimap.begin();
+ double d1 = (*it5).first;
+ it5++;
+ double d2 = (*it5).first;
+ ZSpacing = d1-d2;
+ if (ZSpacing < 0.0)
+ ZSpacing = - ZSpacing;
+
fileList->clear(); // doesn't delete list elements, only nodes
+// Acording to user requierement, we sort direct order or reverse order.
if (DirectOrder)
{
for (std::multimap<double, File *>::iterator it3 = distmultimap.begin();
++it3)
{
fileList->push_back( (*it3).second );
+ if (DropDuplicatePositions)
+ {
+ it3 = distmultimap.upper_bound((*it3).first); // skip all duplicates
+ if (it3 == distmultimap.end() ) // if last image, stop iterate
+ break;
+ }
}
}
else // user asked for reverse order
{
it4--;
fileList->push_back( (*it4).second );
+ if (DropDuplicatePositions) // skip all duplicates
+ {
+ it4 = distmultimap.upper_bound((*it4).first);
+ if (it4 == distmultimap.begin() ) // if first image, stop iterate
+ break;
+ }
} while (it4 != distmultimap.begin() );
}
*/
void SerieHelper::Print(std::ostream &os, std::string const &indent)
{
- // For all the Coherent File lists of the gdcm::Serie
+ // For all the Coherent File lists of the GDCM_NAME_SPACE::Serie
SingleSerieUIDFileSetmap::iterator itl = SingleSerieUIDFileSetHT.begin();
if ( itl == SingleSerieUIDFileSetHT.end() )
{
// A scout scan prior to a CT volume scan can share the same
// SeriesUID, but they will sometimes have a different Series Number
AddRestriction( TagKey(0x0020, 0x0011) );
+
// 0018 0024 Sequence Name
// For T1-map and phase-contrast MRA, the different flip angles and
// directions are only distinguished by the Sequence Name
AddRestriction( TagKey(0x0018, 0x0024) );
+
// 0018 0050 Slice Thickness
// On some CT systems, scout scans and subsequence volume scans will
// have the same SeriesUID and Series Number - YET the slice
// thickness will differ from the scout slice and the volume slices.
AddRestriction( TagKey(0x0018, 0x0050));
+
// 0028 0010 Rows
// If the 2D images in a sequence don't have the same number of rows,
// then it is difficult to reconstruct them into a 3D volume.
AddRestriction( TagKey(0x0028, 0x0010));
+
// 0028 0011 Columns
// If the 2D images in a sequence don't have the same number of columns,
// then it is difficult to reconstruct them into a 3D volume.
* (he knows more than we do about his images!)
* ex : in tagging series, the only pertnent tag is
* 0018|1312 [In-plane Phase Encoding Direction] value : ROW/COLUMN
- * @param inFile gdcm::File we want to build a Serie Identifier for.
+ * @param inFile GDCM_NAME_SPACE::File we want to build a Serie Identifier for.
* @return the SeriesIdentifier
*/
std::string SerieHelper::CreateUniqueSeriesIdentifier( File *inFile )
{
const ExRule &r = *it2;
std::string s = inFile->GetEntryString( r.group, r.elem );
- if( s == gdcm::GDCM_UNFOUND )
+ if( s == GDCM_UNFOUND )
{
s = "";
}
else // Could not open inFile
{
gdcmWarningMacro("Could not parse series info.");
- std::string id = gdcm::GDCM_UNFOUND;
+ std::string id = GDCM_UNFOUND;
return id;
}
}
const ExDetail &r = *it2;
s = inFile->GetEntryString( r.group, r.elem );
- // User is allowed to ask 'convertion', to allow further ordering
+ // User is allowed to ask for 'convertion', to allow further ordering
// e.g : 100 would be *before* 20; 000020.00 vs 00100.00 : OK
if (it2->convert)
{
for(unsigned int i=0; i<s.size(); i++)
{
while(i<s.size()
- && !( s[i] == '.' || s[i] == '%'
- || (s[i] >= 'a' && s[i] <= 'z')
- || (s[i] >= '0' && s[i] <= '9')
- || (s[i] >= 'A' && s[i] <= 'Z')))
+ && !( s[i] == '.' || s[i] == '%' || s[i] == '_'
+ || (s[i] >= 'a' && s[i] <= 'z')
+ || (s[i] >= '0' && s[i] <= '9')
+ || (s[i] >= 'A' && s[i] <= 'Z')))
{
s.erase(i, 1);
}
id += s.c_str();
id += "%%%"; // make the FileIdentifier Tokenizable
}
-
+ id += inFile->GetFileName();
+ id += "%%%";
return id;
}
std::sort(fileList->begin(), fileList->end(), pt2Func );
}
+/*
+#ifndef GDCM_LEGACY_REMOVE
+bool SerieHelper::AddGdcmFile(File* header)
+{
+ return AddFile(header);
+}
+#endif
+*/
+
//-----------------------------------------------------------------------------
} // end namespace gdcm