Program: gdcm
Module: $RCSfile: gdcmSerieHelper.cxx,v $
Language: C++
- Date: $Date: 2005/02/02 15:12:09 $
- Version: $Revision: 1.1 $
+ Date: $Date: 2005/07/21 05:00:15 $
+ Version: $Revision: 1.14 $
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 "gdcmDebug.h"
+#include "gdcmUtil.h"
#include <math.h>
-#include <algorithm>
#include <vector>
+#include <algorithm>
namespace gdcm
{
-typedef std::list<File* > GdcmFileList;
-typedef std::vector<File* > GdcmFileVector;
//-----------------------------------------------------------------------------
// Constructor / Destructor
SerieHelper::SerieHelper()
{
// For all the File lists of the gdcm::Serie
- GdcmFileList *l = GetFirstCoherentFileList();
+ FileList *l = GetFirstCoherentFileList();
while (l)
{
// For all the files of a File list
- for (GdcmFileList::iterator it = l->begin();
- it != l->end();
- ++it)
+ for (gdcm::FileList::iterator it = l->begin();
+ it != l->end();
+ ++it)
{
delete *it;
}
SerieHelper::~SerieHelper()
{
// For all the Coherent File lists of the gdcm::Serie
- GdcmFileList *l = GetFirstCoherentFileList();
+ FileList *l = GetFirstCoherentFileList();
while (l)
{
// For all the files of a Coherent File list
- for (GdcmFileList::iterator it = l->begin();
- it != l->end();
- ++it)
+ for (FileList::iterator it = l->begin();
+ it != l->end();
+ ++it)
{
delete *it;
}
*/
void SerieHelper::AddFileName(std::string const &filename)
{
- //directly use string and not const char*:
- File *header = new File( filename );
- if( header->IsReadable() )
+ // Create a DICOM file
+ File *header = new File ();
+ header->SetLoadMode(LoadMode);
+ header->SetFileName( filename );
+ header->Load();
+
+ if ( header->IsReadable() )
{
- // 0020 000e UI REL Series Instance UID
- std::string uid = header->GetEntryValue (0x0020, 0x000e);
- // if uid == GDCM_UNFOUND then consistently we should find GDCM_UNFOUND
- // no need here to do anything special
+ int allrules = 1;
+ // First step the user has defined a set of rules for the DICOM file
+ // he is looking for.
+ // make sure the file correspond to his set of rules:
+
+/*
+ for(SerieRestrictions::iterator it = Restrictions.begin();
+ it != Restrictions.end();
+ ++it)
+ {
+ const Rule &r = *it;
+ // doesn't compile (no matching function...).
+ const std::string s;// = header->GetEntryValue( r.first );
+ if ( !Util::DicomStringEqual(s, r.second.c_str()) )
+ {
+ // Argh ! This rule is unmatch let's just quit
+ allrules = 0;
+ break;
+ }
+ }
+*/
+ // Just keep 'new style' for Rules
+ std::string s;
+ for(SerieExRestrictions::iterator it2 = ExRestrictions.begin();
+ it2 != ExRestrictions.end();
+ ++it2)
+ {
+ const ExRule &r = *it2;
+ s = header->GetEntryValue( r.group, r.elem );
+ if ( !Util::CompareDicomString(s, r.value.c_str(), r.op) )
+ {
+ // Argh ! This rule is unmatch let's just quit
+ allrules = 0;
+ break;
+ }
+ }
- if ( CoherentGdcmFileListHT.count(uid) == 0 )
+ if ( allrules ) // all rules are respected:
+ {
+ // Allright ! we have a found a DICOM that match the user expectation.
+ // Let's add it !
+
+ // 0020 000e UI REL Series Instance UID
+ const std::string &uid = header->GetEntryValue (0x0020, 0x000e);
+ // if uid == GDCM_UNFOUND then consistently we should find GDCM_UNFOUND
+ // no need here to do anything special
+
+ if ( CoherentFileListHT.count(uid) == 0 )
+ {
+ gdcmDebugMacro(" New Serie UID :[" << uid << "]");
+ // create a std::list in 'uid' position
+ CoherentFileListHT[uid] = new FileList;
+ }
+ // Current Serie UID and DICOM header seems to match; add the file:
+ CoherentFileListHT[uid]->push_back( header );
+ }
+ else
{
- gdcmVerboseMacro(" New Serie UID :[" << uid << "]");
- // create a std::list in 'uid' position
- CoherentGdcmFileListHT[uid] = new GdcmFileList;
+ // at least one rule was unmatch we need to deallocate the file:
+ delete header;
}
- // Current Serie UID and DICOM header seems to match add the file:
- CoherentGdcmFileListHT[uid]->push_back( header );
}
else
{
- gdcmVerboseMacro("Could not read file: " << filename );
+ gdcmWarningMacro("Could not read file: " << filename );
delete header;
}
}
+/**
+ * \brief add a gdcm::File to the first (and supposed to be unique) list
+ * of the gdcm::SerieHelper.
+ * \warning : this method should be used by aware users only!
+ * User is supposed to know the files he want to deal with
+ * and consider them they belong to the same Serie
+ * (even if their Serie UID is different)
+ * user will probabely OrderFileList() this list (actually, ordering
+ * user choosen gdm::File is the sole interest of this method)
+ * Moreover, using vtkGdcmReader::SetCoherentFileList() will avoid
+ * 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
+ */
+void SerieHelper::AddGdcmFile(File *header)
+{
+ int allrules = 1;
+ // First step the user has defined a set of rules for the DICOM
+ // he is looking for.
+ // make sure the file correspond to his set of rules:
+ for(SerieRestrictions::iterator it = Restrictions.begin();
+ it != Restrictions.end();
+ ++it)
+ {
+ const Rule &r = *it;
+ const std::string s;// = header->GetEntryValue( r.first );
+ if ( !Util::DicomStringEqual(s, r.second.c_str()) )
+ {
+ // Argh ! This rule is unmatch let's just quit
+ allrules = 0;
+ break;
+ }
+ }
+ if ( allrules ) // all rules are respected:
+ {
+ // Allright ! we have a found a DICOM that match the user expectation.
+ // Let's add it !
+
+ const std::string &uid = "0";
+ // Serie UID of the gdcm::File* may be different.
+ // User is supposed to know what he wants
+
+ if ( CoherentFileListHT.count(uid) == 0 )
+ {
+ gdcmDebugMacro(" New Serie UID :[" << uid << "]");
+ // create a std::list in 'uid' position
+ CoherentFileListHT[uid] = new FileList;
+ }
+ // Current Serie UID and DICOM header seems to match; add the file:
+ CoherentFileListHT[uid]->push_back( header );
+ }
+ // Even if a rule was unmatch we don't deallocate the gdcm::File:
+}
+
+
+/**
+ * \brief add a rules for restricting a DICOM file to be in the serie we are
+ * trying to find. For example you can select only the DICOM file from a
+ * directory which would have a particular EchoTime==4.0.
+ * This method is a user level, value is not required to be formatted as a DICOM
+ * string
+ */
+void SerieHelper::AddRestriction(uint16_t group, uint16_t elem,
+ std::string const &value, int op)
+{
+ ExRule r;
+ r.group = group;
+ r.elem = elem;
+ r.value = value;
+ r.op = op;
+ ExRestrictions.push_back( r );
+}
+
+#ifndef GDCM_LEGACY_REMOVE
+/**
+ * \brief add a rules for restricting a DICOM file to be in the serie we are
+ * trying to find. For example you can select only the DICOM file from a
+ * directory which would have a particular EchoTime==4.0.
+ * This method is a user level, value is not required to be formatted as a DICOM
+ * string
+ * @deprecated use :
+ */
+void SerieHelper::AddRestriction(TagKey const &key, std::string const &value)
+{
+ Rule r;
+ r.first = key;
+ r.second = value;
+ Restrictions.push_back( r );
+}
+#endif
+
/**
* \brief Sets the root Directory
* @param dir Name of the directory to deal with
* But as I don't know how to do it, I leave it this way
* BTW, this is also a Strategy, I don't know this is the best approach :)
*/
-void SerieHelper::OrderGdcmFileList(GdcmFileList *CoherentGdcmFileList)
+void SerieHelper::OrderFileList(FileList *coherentFileList)
{
- if( ImagePositionPatientOrdering( CoherentGdcmFileList ) )
+ if ( ImagePositionPatientOrdering( coherentFileList ) )
{
return ;
}
- else if( ImageNumberOrdering(CoherentGdcmFileList ) )
+ else if ( ImageNumberOrdering(coherentFileList ) )
{
return ;
}
else
{
- FileNameOrdering(CoherentGdcmFileList );
+ FileNameOrdering(coherentFileList );
}
}
/**
* \brief Get the first List while visiting the CoherentFileListHT
- * @return The first GdcmFileList if found, otherwhise NULL
+ * @return The first FileList if found, otherwhise NULL
*/
- std::list<File* > *SerieHelper::GetFirstCoherentFileList()
-// Why doesn't it compile ?!?
-//GdcmFileList *SerieHelper::GetFirstCoherentFileList()
+FileList *SerieHelper::GetFirstCoherentFileList()
{
- ItListHt = CoherentGdcmFileListHT.begin();
- if( ItListHt != CoherentGdcmFileListHT.end() )
+ ItListHt = CoherentFileListHT.begin();
+ if ( ItListHt != CoherentFileListHT.end() )
return ItListHt->second;
return NULL;
}
/**
* \brief Get the next List while visiting the CoherentFileListHT
- * \note : meaningfull only if GetFirstCoherentFileList already called
- * @return The next GdcmFileList if found, otherwhise NULL
+ * \note : meaningfull only if GetFirstCoherentFileList() already called
+ * @return The next FileList if found, otherwhise NULL
*/
-std::list<File* > *SerieHelper::GetNextCoherentFileList()
+FileList *SerieHelper::GetNextCoherentFileList()
{
- gdcmAssertMacro (ItListHt != CoherentGdcmFileListHT.end());
+ gdcmAssertMacro (ItListHt != CoherentFileListHT.end());
++ItListHt;
- if ( ItListHt != CoherentGdcmFileListHT.end() )
+ if ( ItListHt != CoherentFileListHT.end() )
return ItListHt->second;
return NULL;
}
/**
* \brief Get the Coherent Files list according to its Serie UID
* @param SerieUID SerieUID
- * \return pointer to the Coherent Filseslist if found, otherwhise NULL
+ * \return pointer to the Coherent Files list if found, otherwhise NULL
*/
-GdcmFileList *SerieHelper::GetCoherentFileList(std::string SerieUID)
+FileList *SerieHelper::GetCoherentFileList(std::string SerieUID)
{
- if ( CoherentGdcmFileListHT.count(SerieUID) == 0 )
+ if ( CoherentFileListHT.count(SerieUID) == 0 )
return 0;
- return CoherentGdcmFileListHT[SerieUID];
+ return CoherentFileListHT[SerieUID];
}
//-----------------------------------------------------------------------------
* -# Image Position Patient
* -# Image Number
* -# More to come :-)
- * @param CoherentGdcmFileList Coherent File list (same Serie UID) to sort
+ * WARNING : FileList = std::vector<File* >
+ * @param fileList Coherent File list (same Serie UID) to sort
* @return false only if the header is bugged !
*/
-bool SerieHelper::ImagePositionPatientOrdering(
- GdcmFileList *CoherentGdcmFileList )
-//based on Jolinda's algorithm
+bool SerieHelper::ImagePositionPatientOrdering( FileList *fileList )
+//based on Jolinda Smith's algorithm
{
//iop is calculated based on the file file
float cosines[6];
std::vector<float> distlist;
//!\todo rewrite this for loop.
- for ( GdcmFileList::const_iterator
- it = CoherentGdcmFileList->begin();
- it != CoherentGdcmFileList->end(); ++it )
+ for ( FileList::const_iterator
+ it = fileList->begin();
+ it != fileList->end(); ++it )
{
- if( first )
+ if ( first )
{
(*it)->GetImageOrientationPatient( cosines );
dist += normal[i]*ipp[i];
}
- if( dist == 0 )
- {
- return false;
- }
-
distlist.push_back( dist );
max = min = dist;
dist += normal[i]*ipp[i];
}
- if( dist == 0 )
- {
- return false;
- }
-
distlist.push_back( dist );
min = (min < dist) ? min : dist;
// Then I order the slices according to the value "dist". Finally, once
// I've read in all the slices, I calculate the z-spacing as the difference
// between the "dist" values for the first two slices.
- GdcmFileVector CoherentGdcmFileVector(n);
- // CoherentGdcmFileVector.reserve( n );
- CoherentGdcmFileVector.resize( n );
- // gdcmAssertMacro( CoherentGdcmFileVector.capacity() >= n );
+ FileVector CoherentFileVector(n);
+ // CoherentFileVector.reserve( n );
+ CoherentFileVector.resize( n );
+ // gdcmAssertMacro( CoherentFileVector.capacity() >= n );
+
+ // 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" );
+ return false;
+ }
float step = (max - min)/(n - 1);
int pos;
n = 0;
//VC++ don't understand what scope is !! it -> it2
- for (GdcmFileList::const_iterator it2 = CoherentGdcmFileList->begin();
- it2 != CoherentGdcmFileList->end(); ++it2, ++n)
+ for (FileList::const_iterator it2 = fileList->begin();
+ it2 != fileList->end(); ++it2, ++n)
{
//2*n sort algo !!
//Assumption: all files are present (no one missing)
// and images may have differents directions
// -> More than one may have the same 'pos'
// Sorting has then NO meaning !
- if (CoherentGdcmFileVector[pos]==NULL)
- CoherentGdcmFileVector[pos] = *it2;
+ if (CoherentFileVector[pos]==NULL)
+ CoherentFileVector[pos] = *it2;
else
{
- gdcmVerboseMacro( "2 files same position");
+ gdcmWarningMacro( "At least 2 files with same position. No PositionPatientOrdering sort performed");
return false;
}
}
- CoherentGdcmFileList->clear(); // doesn't delete list elements, only node
+ fileList->clear(); // doesn't delete list elements, only nodes
//VC++ don't understand what scope is !! it -> it3
- for (GdcmFileVector::const_iterator it3 = CoherentGdcmFileVector.begin();
- it3 != CoherentGdcmFileVector.end(); ++it3)
+ for (FileVector::const_iterator it3 = CoherentFileVector.begin();
+ it3 != CoherentFileVector.end(); ++it3)
{
- CoherentGdcmFileList->push_back( *it3 );
+ fileList->push_back( *it3 );
}
distlist.clear();
- CoherentGdcmFileVector.clear();
+ CoherentFileVector.clear();
return true;
}
+bool SerieHelper::ImageNumberLessThan(File *file1, File *file2)
+{
+ return file1->GetImageNumber() < file2->GetImageNumber();
+}
+
/**
* \brief sorts the images, according to their Image Number
* \note Works only on bona fide files (i.e image number is a character string
* corresponding to an integer)
* within a bona fide serie (i.e image numbers are consecutive)
- * @param CoherentGdcmFileList Coherent File list (same Serie UID) to sort
- * @return false if non nona fide stuff encountered
+ * @param fileList Coherent File list (same Serie UID) to sort
+ * @return false if non bona fide stuff encountered
*/
-bool SerieHelper::ImageNumberOrdering(GdcmFileList *CoherentGdcmFileList)
+bool SerieHelper::ImageNumberOrdering(FileList *fileList)
{
int min, max, pos;
- int n = 0;//CoherentGdcmFileList.size() is a O(N) operation
+ int n = fileList->size();
- GdcmFileList::const_iterator it = CoherentGdcmFileList->begin();
+ FileList::const_iterator it = fileList->begin();
min = max = (*it)->GetImageNumber();
- for (; it != CoherentGdcmFileList->end(); ++it, ++n)
+ for (; it != fileList->end(); ++it, ++n)
{
pos = (*it)->GetImageNumber();
min = (min < pos) ? min : pos;
}
// Find out if image numbers are coherent (consecutive)
- if( min == max || max == 0 || max >= (n+min))
- return false;
-
- unsigned char *partition = new unsigned char[n];
- memset(partition, 0, n);
-
- GdcmFileVector CoherentGdcmFileVector(n);
-
- for (it = CoherentGdcmFileList->begin();
- it != CoherentGdcmFileList->end(); ++it)
+ if ( min == max || max == 0 || max >= (n+min) )
{
- pos = (*it)->GetImageNumber();
- CoherentGdcmFileVector[pos - min] = *it;
- partition[pos - min]++;
- }
-
- //VC++ doesn't understand what scope is, it -> it3
- CoherentGdcmFileList->clear(); // doesn't delete list elements, only nodes
- for ( GdcmFileVector::const_iterator it3 = CoherentGdcmFileVector.begin();
- it3 != CoherentGdcmFileVector.end(); ++it3 )
- {
- CoherentGdcmFileList->push_back( *it3 );
+ gdcmWarningMacro( " 'Image numbers' not coherent. No ImageNumberOrdering sort performed.");
+ return false;
}
- CoherentGdcmFileVector.clear();
- delete[] partition;
+ std::sort(fileList->begin(), fileList->end(), SerieHelper::ImageNumberLessThan );
return true;
}
+bool SerieHelper::FileNameLessThan(File *file1, File *file2)
+{
+ return file1->GetFileName() < file2->GetFileName();
+}
+
/**
* \brief sorts the images, according to their File Name
- * @param CoherentGdcmFileList Coherent File list (same Serie UID) to sort
+ * @param fileList Coherent File list (same Serie UID) to sort
* @return false only if the header is bugged !
*/
-bool SerieHelper::FileNameOrdering(GdcmFileList *)
+bool SerieHelper::FileNameOrdering(FileList *fileList)
{
- //TODO using the sort
- //sort(CoherentGdcmFileList.begin(), CoherentGdcmFileList.end());
+ std::sort(fileList->begin(), fileList->end(), SerieHelper::FileNameLessThan);
return true;
}
/**
* \brief Canonical printer.
*/
-void SerieHelper::Print()
+void SerieHelper::Print(std::ostream &os, std::string const &indent)
{
// For all the Coherent File lists of the gdcm::Serie
- CoherentFileListmap::iterator itl = CoherentGdcmFileListHT.begin();
- if ( itl == CoherentGdcmFileListHT.end() )
+ CoherentFileListmap::iterator itl = CoherentFileListHT.begin();
+ if ( itl == CoherentFileListHT.end() )
{
- gdcmVerboseMacro( "No Coherent File list found" );
+ gdcmWarningMacro( "No Coherent File list found" );
return;
}
- while (itl != CoherentGdcmFileListHT.end())
+ while (itl != CoherentFileListHT.end())
{
- std::cout << "Serie UID :[" << itl->first << "]" << std::endl;
+ os << "Serie UID :[" << itl->first << "]" << std::endl;
// For all the files of a Coherent File list
- for (GdcmFileList::iterator it = (itl->second)->begin();
+ for (FileList::iterator it = (itl->second)->begin();
it != (itl->second)->end();
++it)
{
- std::cout << " --- " << (*it)->GetFileName() << std::endl;
+ os << indent << " --- " << (*it)->GetFileName() << std::endl;
}
++itl;
}
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff