X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=src%2FgdcmSerieHelper.cxx;h=27f6b509bab8d88ba9f3021146f0dab7e6416395;hb=8ba6105c39056bba295025f4b46d2cdf24dab792;hp=bb7d47ebb264c6e738f4e8ad234a2cee1c7da593;hpb=27e4eedc79e0b16ee8decc2fcc94474012f15558;p=gdcm.git diff --git a/src/gdcmSerieHelper.cxx b/src/gdcmSerieHelper.cxx index bb7d47eb..27f6b509 100644 --- a/src/gdcmSerieHelper.cxx +++ b/src/gdcmSerieHelper.cxx @@ -3,8 +3,8 @@ Program: gdcm Module: $RCSfile: gdcmSerieHelper.cxx,v $ Language: C++ - Date: $Date: 2005/04/20 22:04:34 $ - Version: $Revision: 1.5 $ + Date: $Date: 2005/08/30 14:15:34 $ + Version: $Revision: 1.19 $ Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de l'Image). All rights reserved. See Doc/License.txt or @@ -19,7 +19,9 @@ #include "gdcmSerieHelper.h" #include "gdcmDirList.h" #include "gdcmFile.h" +#include "gdcmDictEntry.h" // for TranslateToKey #include "gdcmDebug.h" +#include "gdcmUtil.h" #include #include @@ -27,6 +29,7 @@ namespace gdcm { +//----------------------------------------------------------------------------- //----------------------------------------------------------------------------- // Constructor / Destructor @@ -35,21 +38,24 @@ namespace gdcm */ SerieHelper::SerieHelper() { - // For all the File lists of the gdcm::Serie - GdcmFileList *l = GetFirstCoherentFileList(); + UserLessThanFunction = 0; + + // For all the File lists that may already exist within the gdcm::Serie + 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; + delete *it; // remove entry } l->clear(); - delete l;; + delete l; // remove the list l = GetNextCoherentFileList(); } + DirectOrder = true; } /** @@ -58,18 +64,18 @@ SerieHelper::SerieHelper() 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; + delete *it; // remove entry } l->clear(); - delete l; + delete l; // remove the list l = GetNextCoherentFileList(); } } @@ -85,23 +91,75 @@ SerieHelper::~SerieHelper() */ 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 ( allrules ) // all rules are respected: + { + // Allright ! we have a found a DICOM that match the user expectation. + // Let's add it ! - if ( CoherentGdcmFileListHT.count(uid) == 0 ) + // 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 { - gdcmWarningMacro(" 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 { @@ -110,6 +168,98 @@ void SerieHelper::AddFileName(std::string const &filename) } } +/** + * \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 : AddRestriction(uint16_t group, uint16_t elem, + * std::string const &value, int op); + */ +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 @@ -133,45 +283,81 @@ void SerieHelper::SetDirectory(std::string const &dir, bool recursive) * 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 ( SerieHelper::UserLessThanFunction ) + { + UserOrdering( coherentFileList ); + return; + } + else if ( ImagePositionPatientOrdering( coherentFileList ) ) { return ; } - else if( ImageNumberOrdering(CoherentGdcmFileList ) ) + else if ( ImageNumberOrdering(coherentFileList ) ) { return ; } else { - FileNameOrdering(CoherentGdcmFileList ); + FileNameOrdering(coherentFileList ); } } +/** + * \brief Elementary coherence checking of the files with the same Serie UID + * Only sizes and pixel type are checked right now ... + */ +bool SerieHelper::IsCoherent(FileList *coherentFileList) +{ + if(coherentFileList->size() == 1) + return true; + + FileList::const_iterator it = coherentFileList->begin(); + + int nX = (*it)->GetXSize(); + int nY = (*it)->GetYSize(); + int pixelSize = (*it)->GetPixelSize(); + + it ++; + for ( ; + it != coherentFileList->end(); + ++it) + { + if ( (*it)->GetXSize() != nX ) + return false; + if ( (*it)->GetYSize() != nY ) + return false; + if ( (*it)->GetPixelSize() != pixelSize ) + return false; + // probabely more is to be checked (?) + } + return true; +} /** * \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 */ -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 */ -GdcmFileList *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; } @@ -179,13 +365,13 @@ GdcmFileList *SerieHelper::GetNextCoherentFileList() /** * \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]; } //----------------------------------------------------------------------------- @@ -199,11 +385,12 @@ GdcmFileList *SerieHelper::GetCoherentFileList(std::string SerieUID) * -# Image Position Patient * -# Image Number * -# More to come :-) + * WARNING : FileList = std::vector * @param fileList Coherent File list (same Serie UID) to sort * @return false only if the header is bugged ! */ -bool SerieHelper::ImagePositionPatientOrdering( GdcmFileList *fileList ) -//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]; @@ -216,11 +403,11 @@ bool SerieHelper::ImagePositionPatientOrdering( GdcmFileList *fileList ) std::vector distlist; //!\todo rewrite this for loop. - for ( GdcmFileList::const_iterator + for ( FileList::const_iterator it = fileList->begin(); it != fileList->end(); ++it ) { - if( first ) + if ( first ) { (*it)->GetImageOrientationPatient( cosines ); @@ -242,11 +429,6 @@ bool SerieHelper::ImagePositionPatientOrdering( GdcmFileList *fileList ) dist += normal[i]*ipp[i]; } - if( dist == 0 ) - { - return false; - } - distlist.push_back( dist ); max = min = dist; @@ -264,11 +446,6 @@ bool SerieHelper::ImagePositionPatientOrdering( GdcmFileList *fileList ) dist += normal[i]*ipp[i]; } - if( dist == 0 ) - { - return false; - } - distlist.push_back( dist ); min = (min < dist) ? min : dist; @@ -280,15 +457,16 @@ bool SerieHelper::ImagePositionPatientOrdering( GdcmFileList *fileList ) // 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 ) + if ( min == max ) { - gdcmWarningMacro( "Looks like all images have the exact same image position..."); + gdcmWarningMacro( "Looks like all images have the exact same image position." + << "No PositionPatientOrdering sort performed" ); return false; } @@ -297,7 +475,7 @@ bool SerieHelper::ImagePositionPatientOrdering( GdcmFileList *fileList ) n = 0; //VC++ don't understand what scope is !! it -> it2 - for (GdcmFileList::const_iterator it2 = fileList->begin(); + for (FileList::const_iterator it2 = fileList->begin(); it2 != fileList->end(); ++it2, ++n) { //2*n sort algo !! @@ -308,26 +486,39 @@ bool SerieHelper::ImagePositionPatientOrdering( GdcmFileList *fileList ) // 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 { - gdcmWarningMacro( "2 files same position"); + gdcmWarningMacro( "At least 2 files with same position. No PositionPatientOrdering sort performed"); return false; } } - fileList->clear(); // doesn't delete list elements, only node - - //VC++ don't understand what scope is !! it -> it3 - for (GdcmFileVector::const_iterator it3 = CoherentGdcmFileVector.begin(); - it3 != CoherentGdcmFileVector.end(); ++it3) - { - fileList->push_back( *it3 ); + fileList->clear(); // doesn't delete list elements, only nodes + + if (DirectOrder) + { + //VC++ don't understand what scope is !! it -> it3 + for (FileVector::const_iterator it3 = CoherentFileVector.begin(); + it3 != CoherentFileVector.end(); ++it3) + { + fileList->push_back( *it3 ); + } } + else // user asked for reverse order + { + FileVector::const_iterator it4; + it4 = CoherentFileVector.end(); + do + { + it4--; + fileList->push_back( *it4 ); + } while (it4 != CoherentFileVector.begin() ); + } distlist.clear(); - CoherentGdcmFileVector.clear(); + CoherentFileVector.clear(); return true; } @@ -337,20 +528,24 @@ bool SerieHelper::ImageNumberLessThan(File *file1, File *file2) return file1->GetImageNumber() < file2->GetImageNumber(); } +bool SerieHelper::ImageNumberGreaterThan(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 fileList Coherent File list (same Serie UID) to sort - * @return false if non nona fide stuff encountered + * @return false if non bona fide stuff encountered */ -bool SerieHelper::ImageNumberOrdering(GdcmFileList *fileList) +bool SerieHelper::ImageNumberOrdering(FileList *fileList) { int min, max, pos; int n = fileList->size(); - GdcmFileList::const_iterator it = fileList->begin(); + FileList::const_iterator it = fileList->begin(); min = max = (*it)->GetImageNumber(); for (; it != fileList->end(); ++it, ++n) @@ -361,27 +556,55 @@ bool SerieHelper::ImageNumberOrdering(GdcmFileList *fileList) } // Find out if image numbers are coherent (consecutive) - if( min == max || max == 0 || max >= (n+min)) + if ( min == max || max == 0 || max >= (n+min) ) + { + gdcmWarningMacro( " 'Image numbers' not coherent. No ImageNumberOrdering sort performed."); return false; - - std::sort(fileList->begin(), fileList->end(), SerieHelper::ImageNumberLessThan ); + } + if (DirectOrder) + std::sort(fileList->begin(), fileList->end(), SerieHelper::ImageNumberLessThan ); + else + std::sort(fileList->begin(), fileList->end(), SerieHelper::ImageNumberGreaterThan ); return true; } bool SerieHelper::FileNameLessThan(File *file1, File *file2) { - return file1->GetFileName() < file2->GetFileName(); + return file1->GetFileName() < file2->GetFileName(); } +bool SerieHelper::FileNameGreaterThan(File *file1, File *file2) +{ + return file1->GetFileName() > file2->GetFileName(); +} /** * \brief sorts the images, according to their File Name * @param fileList Coherent File list (same Serie UID) to sort * @return false only if the header is bugged ! */ -bool SerieHelper::FileNameOrdering(GdcmFileList *fileList) +bool SerieHelper::FileNameOrdering(FileList *fileList) { - std::sort(fileList->begin(), fileList->end(), SerieHelper::FileNameLessThan); + if (DirectOrder) + std::sort(fileList->begin(), fileList->end(), SerieHelper::FileNameLessThan); + else + std::sort(fileList->begin(), fileList->end(), SerieHelper::FileNameGreaterThan); + + return true; +} + +/** + * \brief sorts the images, according to user supplied function + * @param fileList Coherent File list (same Serie UID) to sort + * @return false only if the header is bugged ! + */ +bool SerieHelper::UserOrdering(FileList *fileList) +{ + std::sort(fileList->begin(), fileList->end(), SerieHelper::UserLessThanFunction); + if (!DirectOrder) + { + std::reverse(fileList->begin(), fileList->end()); + } return true; } @@ -390,21 +613,21 @@ bool SerieHelper::FileNameOrdering(GdcmFileList *fileList) /** * \brief Canonical printer. */ -void SerieHelper::Print(std::ostream &os, std::string const & indent) +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() ) { gdcmWarningMacro( "No Coherent File list found" ); return; } - while (itl != CoherentGdcmFileListHT.end()) + while (itl != CoherentFileListHT.end()) { 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) {