Program: gdcm
Module: $RCSfile: gdcmSerieHelper.cxx,v $
Language: C++
- Date: $Date: 2005/10/23 15:04:26 $
- Version: $Revision: 1.28 $
+ Date: $Date: 2005/11/25 13:56:32 $
+ Version: $Revision: 1.36 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
*/
SerieHelper::SerieHelper()
{
+ m_UseSeriesDetails = false;
ClearAll();
UserLessThanFunction = 0;
DirectOrder = true;
it != l->end();
++it)
{
- delete *it; // remove each entry
+ (*it)->Delete(); // remove each entry
}
l->clear();
delete l; // remove the container
void SerieHelper::AddFileName(std::string const &filename)
{
// Create a DICOM file
- File *header = new File ();
+ File *header = File::New();
header->SetLoadMode(LoadMode);
header->SetFileName( filename );
header->Load();
else
{
// at least one rule was unmatched we need to deallocate the file:
- delete header;
+ header->Delete();
}
}
else
{
gdcmWarningMacro("Could not read file: " << filename );
- delete header;
+ header->Delete();
}
}
++it)
{
const Rule &r = *it;
- const std::string s;// = header->GetEntryValue( r.first );
+ const std::string s;// = header->GetEntryString( r.first );
if ( !Util::DicomStringEqual(s, r.second.c_str()) )
{
// Argh ! This rule is unmatch let's just quit
* 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
- * @param group Group number of the target tag.
- * @param elem Element number of the target tag.
+ * @param key Target tag we want restrict on a given value
* @param value value to be checked to exclude File
* @param op operator we want to use to check
*/
-void SerieHelper::AddRestriction(uint16_t group, uint16_t elem,
+void SerieHelper::AddRestriction(TagKey const &key,
std::string const &value, int op)
{
ExRule r;
- r.group = group;
- r.elem = elem;
+ r.group = key[0];
+ r.elem = key[1];
r.value = value;
r.op = op;
ExRestrictions.push_back( r );
}
-#ifndef GDCM_LEGACY_REMOVE
-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
FileList::const_iterator it = fileSet->begin();
- int nX = (*it)->GetXSize();
- int nY = (*it)->GetYSize();
- int pixelSize = (*it)->GetPixelSize();
-
+ int nX = (*it)->GetXSize();
+ int nY = (*it)->GetYSize();
+ int pixelSize = (*it)->GetPixelSize();
+ bool signedPixelData = (*it)->IsSignedPixelData();
it ++;
for ( ;
it != fileSet->end();
return false;
if ( (*it)->GetPixelSize() != pixelSize )
return false;
- // probabely more is to be checked (?)
+ if ( (*it)->IsSignedPixelData() != signedPixelData )
+ return false;
+ // probabely more is to be checked (?)
}
return true;
}
int nb = fileSet->size();
if (nb == 0 )
return CoherentFileSet;
- float iop[6];
- std::ostringstream ossOrient;
+ double iop[6];
+
std::string strOrient;
-
+ std::ostringstream ossOrient;
FileList::const_iterator it = fileSet->begin();
it ++;
for ( ;
// Let's build again the 'cosines' string, to be sure of it's format
(*it)->GetImageOrientationPatient(iop);
+
ossOrient << iop[0];
for (int i = 1; i < 6; i++)
{
ossOrient << iop[i];
}
strOrient = ossOrient.str();
-
+ ossOrient.str("");
+ // FIXME : is it a 'cleaner' way to initialize an ostringstream?
+
if ( CoherentFileSet.count(strOrient) == 0 )
{
gdcmDebugMacro(" New Orientation :[" << strOrient << "]");
}
// Current Orientation and DICOM header match; add the file:
CoherentFileSet[strOrient]->push_back( (*it) );
- }
+ }
return CoherentFileSet;
}
/**
- * \brief Splits a Single SerieUID Fileset according to the Positions
+ * \brief Splits a 'Single SerieUID' Fileset according to the Positions
* @param fileSet File Set to be splitted
* \return std::map of 'Xcoherent' File sets
*/
ossPosition << pos[i];
}
strPosition = ossPosition.str();
-
+ ossPosition.str("");
+
if ( CoherentFileSet.count(strPosition) == 0 )
{
gdcmDebugMacro(" New Position :[" << strPosition << "]");
}
/**
- * \brief Splits a SingleSerieUID File set Coherent according to the
+ * \brief Splits a 'Single SerieUID' File set Coherent according to the
* value of a given Tag
* @param fileSet File Set to be splitted
* @param group group number of the target Element
//-----------------------------------------------------------------------------
// Private
/**
- * \brief sorts the images, according to their Patient Position
+ * \brief sorts the images, according to their Patient Position.
+ *
* We may order, considering :
* -# Image Position Patient
* -# Image Number
- * -# File Name
+ * -# file name
* -# More to come :-)
* \note : FileList = std::vector<File* >
* @param fileList Coherent File list (same Serie UID) to sort
//based on Jolinda Smith's algorithm
{
//iop is calculated based on the file file
- float cosines[6];
- float normal[3];
- float ipp[3];
- float dist;
- float min = 0, max = 0;
+ double cosines[6];
+ double normal[3];
+ double ipp[3];
+ double dist;
+ double min = 0, max = 0;
bool first = true;
- int n=0;
- std::vector<float> distlist;
- //!\todo rewrite this for loop.
+ std::multimap<double,File *> distmultimap;
+ // Use a multimap to sort the distances from 0,0,0
for ( FileList::const_iterator
it = fileList->begin();
it != fileList->end(); ++it )
dist += normal[i]*ipp[i];
}
- distlist.push_back( dist );
+ distmultimap.insert(std::pair<const double,File *>(dist, *it));
max = min = dist;
first = false;
dist += normal[i]*ipp[i];
}
- distlist.push_back( dist );
+ distmultimap.insert(std::pair<const double,File *>(dist, *it));
min = (min < dist) ? min : dist;
max = (max > dist) ? max : dist;
}
- ++n;
- }
- // 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.
- FileVector CoherentFileVector(n);
- // CoherentFileVector.reserve( n );
- CoherentFileVector.resize( n );
- // gdcmAssertMacro( CoherentFileVector.capacity() >= n );
+ }
// Find out if min/max are coherent
if ( min == max )
return false;
}
- float step = (max - min)/(n - 1);
- int pos;
- n = 0;
-
- //VC++ don't understand what scope is !! it -> it2
- for (FileList::const_iterator it2 = fileList->begin();
- it2 != fileList->end(); ++it2, ++n)
- {
- //2*n sort algo !!
- //Assumption: all files are present (no one missing)
- pos = (int)( fabs( (distlist[n]-min)/step) + .5 );
-
- // a Dicom 'Serie' may contain scout views
- // and images may have differents directions
- // -> More than one may have the same 'pos'
- // Sorting has then NO meaning !
- if (CoherentFileVector[pos]==NULL)
- CoherentFileVector[pos] = *it2;
- else
- {
- gdcmWarningMacro( "At least 2 files with same position."
- << " No PositionPatientOrdering sort performed");
- return false;
- }
- }
-
+ // Check to see if image shares a common position
+ bool ok = true;
+ for (std::multimap<double, File *>::iterator it2 = distmultimap.begin();
+ it2 != distmultimap.end();
+ ++it2)
+ {
+ if (distmultimap.count((*it2).first) != 1)
+ {
+ gdcmErrorMacro("File: "
+ << ((*it2).second->GetFileName())
+ << " Distance: "
+ << (*it2).first
+ << " position is not unique");
+ ok = false;
+ }
+ }
+ if (!ok)
+ {
+ return false;
+ }
+
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)
+ for (std::multimap<double, File *>::iterator it3 = distmultimap.begin();
+ it3 != distmultimap.end();
+ ++it3)
{
- fileList->push_back( *it3 );
+ fileList->push_back( (*it3).second );
}
}
else // user asked for reverse order
{
- FileVector::const_iterator it4;
- it4 = CoherentFileVector.end();
+ std::multimap<double, File *>::const_iterator it4;
+ it4 = distmultimap.end();
do
{
it4--;
- fileList->push_back( *it4 );
- } while (it4 != CoherentFileVector.begin() );
+ fileList->push_back( (*it4).second );
+ } while (it4 != distmultimap.begin() );
}
- distlist.clear();
- CoherentFileVector.clear();
+ distmultimap.clear();
return true;
}
* \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
+ * @param fileList File set (same Serie UID) to sort
* @return false if non bona fide stuff encountered
*/
bool SerieHelper::ImageNumberOrdering(FileList *fileList)
return true;
}
+std::string SerieHelper::CreateUniqueSeriesIdentifier( File * inFile )
+{
+ if( inFile->IsReadable() )
+ {
+ // 0020 000e UI REL Series Instance UID
+ std::string uid = inFile->GetEntryString (0x0020, 0x000e);
+ std::string id = uid.c_str();
+ if(m_UseSeriesDetails)
+ {
+ // If the user requests, additional information can be appended
+ // to the SeriesUID to further differentiate volumes in the DICOM
+ // objects being processed.
+
+ // 0020 0011 Series Number
+ // A scout scan prior to a CT volume scan can share the same
+ // SeriesUID, but they will sometimes have a different Series Number
+ std::string sNum = inFile->GetEntryString(0x0020, 0x0011);
+ if( sNum == gdcm::GDCM_UNFOUND )
+ {
+ sNum = "";
+ }
+ // 0018 0024 Sequence Name
+ // For T1-map and phase-contrast MRA, the different flip angles and
+ // directions are only distinguished by the Sequence Name
+ std::string sName = inFile->GetEntryString(0x0018, 0x0024);
+ if( sName == gdcm::GDCM_UNFOUND )
+ {
+ sName = "";
+ }
+ // 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.
+ std::string sThick = inFile->GetEntryString (0x0018, 0x0050);
+ if( sThick == gdcm::GDCM_UNFOUND )
+ {
+ sThick = "";
+ }
+ // 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.
+ std::string sRows = inFile->GetEntryString (0x0028, 0x0010);
+ if( sRows == gdcm::GDCM_UNFOUND )
+ {
+ sRows = "";
+ }
+ // 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.
+ std::string sColumns = inFile->GetEntryString (0x0028, 0x0011);
+ if( sColumns == gdcm::GDCM_UNFOUND )
+ {
+ sColumns = "";
+ }
+
+ // Concat the new info
+ std::string num = sNum.c_str();
+ num += sName.c_str();
+ num += sThick.c_str();
+ num += sRows.c_str();
+ num += sColumns.c_str();
+
+ // Append the new info to the SeriesUID
+ id += ".";
+ id += num.c_str();
+ }
+
+ // Eliminate non-alnum characters, including whitespace...
+ // that may have been introduced by concats.
+ for(unsigned int i=0; i<id.size(); i++)
+ {
+ while(i<id.size()
+ && !( id[i] == '.'
+ || (id[i] >= 'a' && id[i] <= 'z')
+ || (id[i] >= '0' && id[i] <= '9')
+ || (id[i] >= 'A' && id[i] <= 'Z')))
+ {
+ id.erase(i, 1);
+ }
+ }
+ return id;
+ }
+ else // Could not open inFile
+ {
+ gdcmWarningMacro("Could not parse series info.");
+ std::string id = gdcm::GDCM_UNFOUND;
+ return id;
+ }
+}
+
+
//-----------------------------------------------------------------------------
// Print
/**
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff