vtkITKArchetypeImageSeriesReader.h

Go to the documentation of this file.
00001 /*=========================================================================
00002 
00003 Copyright Brigham and Women's Hospital (BWH) All Rights Reserved.
00004 
00005 See Doc/copyright/copyright.txt
00006 or http://www.slicer.org/copyright/copyright.txt for details.
00007 
00008 Program:   vtkITK
00009 Module:    $HeadURL: http://svn.slicer.org/Slicer3/trunk/Libs/vtkITK/vtkITKArchetypeImageSeriesReader.h $
00010 Date:      $Date: 2010-11-29 10:41:18 -0500 (Mon, 29 Nov 2010) $
00011 Version:   $Revision: 15588 $
00012 
00013 ==========================================================================*/
00014 
00021 //
00026 
00027 #ifndef __vtkITKArchetypeImageSeriesReader_h
00028 #define __vtkITKArchetypeImageSeriesReader_h
00029 
00030 #include "vtkImageSource.h"
00031 #include "vtkMatrix4x4.h"
00032 #include "itkSpatialOrientation.h"
00033 #include <vector>
00034 #include <string>
00035 
00036 #include "itkMetaDataDictionary.h"
00037 #include "gdcmDictSet.h"        
00038 #include "gdcmDict.h"           
00039 #include "gdcmDictEntry.h"      
00040 #include "gdcmGlobal.h"         
00041 
00042 #include "vtkITK.h"
00043 
00044 class VTK_ITK_EXPORT vtkITKArchetypeImageSeriesReader : public vtkImageSource
00045 {
00046 public:
00047   static vtkITKArchetypeImageSeriesReader *New();
00048   vtkTypeRevisionMacro(vtkITKArchetypeImageSeriesReader,vtkImageSource);
00049   void PrintSelf(ostream& os, vtkIndent indent);   
00050 
00051   //BTX
00052   typedef itk::SpatialOrientation::ValidCoordinateOrientationFlags CoordinateOrientationCode;
00053   //ETX
00054 
00057   vtkSetStringMacro(Archetype);
00058   vtkGetStringMacro(Archetype);
00059 
00062   unsigned int GetNumberOfFileNames()
00063     {
00064     return this->FileNames.size();
00065     };
00066 
00071   unsigned int AddFileName( const char* filename );
00072   const char* GetFileName( unsigned int n );
00073   void ResetFileNames();
00074 
00078   vtkSetVector3Macro(DefaultDataSpacing,double);
00079   vtkGetVector3Macro(DefaultDataSpacing,double);
00080 
00085   vtkSetVector3Macro(DefaultDataOrigin,double);
00086   vtkGetVector3Macro(DefaultDataOrigin,double);
00087 
00091   vtkSetMacro(FileNameSliceOffset,int);
00092   vtkGetMacro(FileNameSliceOffset,int);
00093 
00098   vtkSetMacro(FileNameSliceSpacing,int);
00099   vtkGetMacro(FileNameSliceSpacing,int);
00100 
00104   vtkSetMacro(FileNameSliceCount,int);
00105   vtkGetMacro(FileNameSliceCount,int);
00106 
00108   virtual int CanReadFile(const char* filename);
00109 
00112   void SetDesiredCoordinateOrientationToAxial ()
00113     {
00114     this->DesiredCoordinateOrientation =
00115       itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_RAI;
00117     this->UseNativeCoordinateOrientation = 0;
00118     this->Modified();
00119     }
00120   void SetDesiredCoordinateOrientationToCoronal ()
00121     {
00122     this->DesiredCoordinateOrientation =
00123       itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_RSA;
00125     this->UseNativeCoordinateOrientation = 0;
00126     this->Modified();
00127     }
00128   void SetDesiredCoordinateOrientationToSagittal ()
00129   {
00130     this->DesiredCoordinateOrientation =
00131       itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_ASL;
00133     this->UseNativeCoordinateOrientation = 0;
00134     this->Modified();
00135   }
00136   void SetDesiredCoordinateOrientationToNative ()
00137     {
00138     this->UseNativeCoordinateOrientation = 1;
00139     this->Modified();
00140     }
00141 
00146   virtual void SetOutputScalarTypeToDouble()
00147     {
00148     UseNativeScalarType = 0;
00149     this->SetOutputScalarType(VTK_DOUBLE);
00150     }
00151   virtual void SetOutputScalarTypeToFloat()
00152     {
00153     UseNativeScalarType = 0;
00154     this->SetOutputScalarType(VTK_FLOAT);
00155     }
00156   virtual void SetOutputScalarTypeToLong()
00157     {
00158     UseNativeScalarType = 0;
00159     this->SetOutputScalarType(VTK_LONG);
00160     }
00161   virtual void SetOutputScalarTypeToUnsignedLong()
00162     {
00163     UseNativeScalarType = 0;
00164     this->SetOutputScalarType(VTK_UNSIGNED_LONG);
00165     }
00166   virtual void SetOutputScalarTypeToInt()
00167     {
00168     UseNativeScalarType = 0;
00169     this->SetOutputScalarType(VTK_INT);
00170     }
00171   virtual void SetOutputScalarTypeToUnsignedInt()
00172     {
00173     UseNativeScalarType = 0;
00174     this->SetOutputScalarType(VTK_UNSIGNED_INT);
00175     }
00176   virtual void SetOutputScalarTypeToShort()
00177     {
00178     UseNativeScalarType = 0;
00179     this->SetOutputScalarType(VTK_SHORT);
00180     }
00181   virtual void SetOutputScalarTypeToUnsignedShort()
00182     {
00183     UseNativeScalarType = 0;
00184     this->SetOutputScalarType(VTK_UNSIGNED_SHORT);
00185     }
00186   virtual void SetOutputScalarTypeToChar()
00187     {
00188     UseNativeScalarType = 0;
00189     this->SetOutputScalarType(VTK_CHAR);
00190     }
00191   virtual void SetOutputScalarTypeToUnsignedChar()
00192     {
00193     UseNativeScalarType = 0;
00194     this->SetOutputScalarType(VTK_UNSIGNED_CHAR);
00195     }
00196   virtual void SetOutputScalarTypeToNative()
00197     {
00198     UseNativeScalarType = 1;
00199     this->Modified();
00200     }
00201 
00204   void SetUseNativeOriginOn() 
00205     {
00206     UseNativeOrigin = true;
00207     }
00208 
00211   void SetUseNativeOriginOff() 
00212     {
00213     UseNativeOrigin = false;
00214     }
00215 
00218   vtkSetMacro(OutputScalarType, int);
00219   vtkGetMacro(OutputScalarType, int);
00220 
00223   vtkSetMacro(NumberOfComponents, unsigned int);
00224   vtkGetMacro(NumberOfComponents, unsigned int);
00225 
00228   vtkSetMacro(SingleFile, int);
00229   vtkGetMacro(SingleFile, int);
00230 
00233   vtkSetMacro(UseOrientationFromFile, int);
00234   vtkGetMacro(UseOrientationFromFile, int);
00235 
00238   vtkMatrix4x4* GetRasToIjkMatrix();
00239 
00245   //
00249   //
00250   void RegisterExtraBuiltInFactories();
00251   void UnRegisterDeprecatedBuiltInFactories();
00252 
00253   //BTX
00256   const itk::MetaDataDictionary &GetMetaDataDictionary() const;
00257   std::vector<std::string> Tags;
00258   std::vector<std::string> TagValues;
00259   void ParseDictionary();
00260   //ETX
00261 
00262   unsigned int GetNumberOfItemsInDictionary(); 
00263   bool HasKey( char* tag );
00264   const char* GetNthKey( unsigned int n );
00265   const char* GetNthValue( unsigned int n );
00266   const char* GetTagValue( char* tag );
00267 
00269   bool GetGroupingByTags()
00270     {
00271     return GroupingByTags;
00272     }
00273 
00274   void SetGroupingByTagsOn()
00275     {
00276     GroupingByTags = true;
00277     }
00278 
00279   void SetGroupingByTagsOff()
00280     {
00281     GroupingByTags = false;
00282     }
00283 
00285   int GetSelectedUID()
00286     {
00287     return SelectedUID;
00288     }
00289 
00290   void SetSelectedUID( int v )
00291     {
00292     SelectedUID = v;
00293     SetGroupingByTagsOn();
00294     }
00295 
00297   int GetSelectedContentTime()
00298     {
00299     return SelectedContentTime;
00300     }
00301 
00302   void SetSelectedContentTime( int v )
00303     {
00304     SelectedContentTime = v;
00305     SetGroupingByTagsOn();
00306     }
00307 
00309   int GetSelectedTriggerTime()
00310     {
00311     return SelectedTriggerTime;
00312     }
00313 
00314   void SetSelectedTriggerTime( int v )
00315     {
00316     SelectedTriggerTime = v;
00317     SetGroupingByTagsOn();
00318     }
00319 
00321   int GetSelectedEchoNumbers()
00322     {
00323     return SelectedEchoNumbers;
00324     }
00325 
00326   void SetSelectedEchoNumbers( int v )
00327     {
00328     SelectedEchoNumbers = v;
00329     SetGroupingByTagsOn();
00330     }
00331 
00332   
00334   int GetSelectedDiffusion()
00335     {
00336     return SelectedDiffusion;
00337     }
00338 
00339   void SetSelectedDiffusion( int v )
00340     {
00341     SelectedDiffusion = v;
00342     SetGroupingByTagsOn();
00343     }
00344 
00346   int GetSelectedSlice()
00347     {
00348     return SelectedSlice;
00349     }
00350 
00351   void SetSelectedSlice( int v )
00352     {
00353     SelectedSlice = v;
00354     SetGroupingByTagsOn();
00355     }
00356 
00358   int GetSelectedOrientation()
00359     {
00360     return SelectedOrientation;
00361     }
00362 
00363   void SetSelectedOrientation( int v )
00364     {
00365     SelectedOrientation = v;
00366     SetGroupingByTagsOn();
00367     }
00368 
00370   unsigned int GetNumberOfSeriesInstanceUIDs()
00371     {
00372     return this->SeriesInstanceUIDs.size();
00373     }
00374 
00375   unsigned int GetNumberOfContentTime()
00376     {
00377     return this->ContentTime.size();
00378     }
00379 
00380   unsigned int GetNumberOfTriggerTime()
00381     {
00382     return this->TriggerTime.size();
00383     }
00384 
00385   unsigned int GetNumberOfEchoNumbers()
00386     {
00387     return this->EchoNumbers.size();
00388     }  
00389 
00390   unsigned int GetNumberOfSliceLocation()
00391     {
00392     return this->SliceLocation.size();
00393     }
00394 
00395   unsigned int GetNumberOfDiffusionGradientOrientation()
00396     {
00397     return this->DiffusionGradientOrientation.size();
00398     };
00399 
00400   unsigned int GetNumberOfImageOrientationPatient()
00401     {
00402     return this->ImageOrientationPatient.size();
00403     };
00404 
00405   unsigned int GetNumberOfImagePositionPatient()
00406     {
00407     return this->ImagePositionPatient.size();
00408     }
00409 
00411   int ExistSeriesInstanceUID( const char* SeriesInstanceUID )
00412     {
00413     for (unsigned int k = 0; k < GetNumberOfSeriesInstanceUIDs(); k++)
00414       {
00415       if ( this->SeriesInstanceUIDs[k].find(SeriesInstanceUID) != std::string::npos )
00416         {
00417         return k;
00418         }
00419       }
00420     return -1;
00421     }
00422 
00423   int ExistContentTime( const char* contentTime )
00424     {
00425       for (unsigned int k = 0; k < GetNumberOfContentTime(); k++)
00426         {
00427         if ( this->ContentTime[k].find(contentTime) != std::string::npos )
00428           {
00429           return k;
00430           }
00431         }
00432       return -1;
00433     }
00434 
00435   int ExistTriggerTime( const char* triggerTime )
00436     {
00437       for (unsigned int k = 0; k < GetNumberOfTriggerTime(); k++)
00438         {
00439         if ( this->TriggerTime[k].find(triggerTime) != std::string::npos )
00440           {
00441           return k;
00442           }
00443         }
00444       return -1;
00445     }
00446 
00447   int ExistEchoNumbers( const char* echoNumbers )
00448     {
00449       for (unsigned int k = 0; k < GetNumberOfEchoNumbers(); k++)
00450         {
00451         if ( this->EchoNumbers[k].find(echoNumbers) != std::string::npos )
00452           {
00453           return k;
00454           }
00455         }
00456       return -1;
00457     }
00458 
00459   int ExistDiffusionGradientOrientation( float* dgo )
00460     {
00461       float a = 0;
00462       for (int n = 0; n < 3; n++)
00463         {
00464         a += dgo[n]*dgo[n];
00465         }
00466       
00467       for (unsigned int k = 0; k < GetNumberOfDiffusionGradientOrientation(); k++)
00468         {
00469         float b = 0;
00470         float c = 0;
00471         for (int n = 0; n < 3; n++)
00472           {
00473           b += this->DiffusionGradientOrientation[k][n] * this->DiffusionGradientOrientation[k][n];
00474           c += this->DiffusionGradientOrientation[k][n] * dgo[n];
00475           }
00476         c = fabs(c)/sqrt(a*b);
00477         
00478         if ( c > 0.99999 )
00479           {
00480           return k;
00481           }
00482         }
00483       return -1;
00484     }
00485 
00486   int ExistSliceLocation( float sliceLocation )
00487     {
00488       for (unsigned int k = 0; k < GetNumberOfSliceLocation(); k++)
00489         {
00490         if ( this->SliceLocation[k] == sliceLocation )
00491           {
00492           return k;
00493           }
00494         }
00495       return -1;
00496     }
00497 
00498   int ExistImageOrientationPatient( float * directionCosine )
00499     {
00501       float a = sqrt( directionCosine[0]*directionCosine[0] + directionCosine[1]*directionCosine[1] + directionCosine[2]*directionCosine[2] );
00502       for (int k = 0; k < 3; k++)
00503         {
00504         directionCosine[k] /= a;
00505         }
00506       a = sqrt( directionCosine[3]*directionCosine[3] + directionCosine[4]*directionCosine[4] + directionCosine[5]*directionCosine[5] );
00507       for (int k = 3; k < 6; k++)
00508         {
00509         directionCosine[k] /= a;
00510         }
00511       
00512       for (unsigned int k = 0; k < GetNumberOfImageOrientationPatient(); k++)
00513         {
00514         std::vector<float> aVec = ImageOrientationPatient[k];
00515         a = sqrt( aVec[0]*aVec[0] + aVec[1]*aVec[1] + aVec[2]*aVec[2] );
00516         float b = (directionCosine[0]*aVec[0] + directionCosine[1]*aVec[1] + directionCosine[2]*aVec[2])/a;
00517         if ( b < 0.99999 )
00518           {
00519           continue;
00520           }
00521 
00522         a = sqrt( aVec[3]*aVec[3] + aVec[4]*aVec[4] + aVec[5]*aVec[5] );
00523         b = (directionCosine[3]*aVec[3] + directionCosine[4]*aVec[4] + directionCosine[5]*aVec[5])/a;
00524         if ( b > 0.99999 )
00525           {
00526           return k;
00527           } 
00528         }
00529       return -1;
00530     }
00531   
00532   int ExistImagePositionPatient( float* ipp )
00533     {
00534       float a = 0;
00535       for (int n = 0; n < 3; n++)
00536         {
00537         a += ipp[n]*ipp[n];
00538         }
00539 
00540       for (unsigned int k = 0; k < GetNumberOfImagePositionPatient(); k++)
00541         {
00542         float b = 0;
00543         float c = 0;
00544         for (int n = 0; n < 3; n++)
00545           {
00546           b += this->ImagePositionPatient[k][n] * this->ImagePositionPatient[k][n];
00547           c += this->ImagePositionPatient[k][n] * ipp[n];
00548           }
00549         c = fabs(c)/sqrt(a*b);
00550         if ( c > 0.99999 )
00551           {
00552           return k;
00553           }
00554         }
00555       return -1;
00556     }
00557     
00559   const char* GetNthSeriesInstanceUID( unsigned int n )
00560     {
00561       if ( n >= this->GetNumberOfSeriesInstanceUIDs() )
00562         {
00563         return NULL;
00564         } 
00565       return this->SeriesInstanceUIDs[n].c_str();
00566     }
00567 
00568   const char* GetNthContentTime( unsigned int n )
00569     {
00570       if ( n >= this->GetNumberOfContentTime() )
00571         {
00572         return NULL;
00573         } 
00574       return this->ContentTime[n].c_str();
00575     }
00576   
00577   const char* GetNthTriggerTime( unsigned int n )
00578     {
00579       if ( n >= this->GetNumberOfTriggerTime() )
00580         {
00581         return NULL;
00582         } 
00583       return this->TriggerTime[n].c_str();
00584     }
00585 
00586   const char* GetNthEchoNumbers( unsigned int n )
00587     {
00588       if ( n >= this->GetNumberOfEchoNumbers() )
00589         {
00590         return NULL;
00591         } 
00592       return this->EchoNumbers[n].c_str();
00593     }
00594 
00595   float* GetNthDiffusionGradientOrientation( unsigned int n )
00596     {
00597       if ( n >= this->GetNumberOfDiffusionGradientOrientation() )
00598         {
00599         return NULL;
00600         } 
00601       float *dgo = new float [3];
00602       for (int k = 0; k <3; k++)
00603         {
00604         dgo[k] = this->DiffusionGradientOrientation[n][k];
00605         }
00606       return dgo;
00607     }
00608 
00609   float GetNthSliceLocation( unsigned int n )
00610     {
00611       if ( n >= this->GetNumberOfSliceLocation() )
00612         {
00613         return this->SliceLocation[0];
00614         } 
00615       return this->SliceLocation[0];
00616     }
00617   
00618   float* GetNthImageOrientationPatient( unsigned int n )
00619     {
00620       if ( n >= this->GetNumberOfImageOrientationPatient() )
00621         {
00622         return NULL;
00623         } 
00624       float *dgo = new float [6];
00625       for (int k = 0; k <6; k++)
00626         {
00627         dgo[k] = this->ImageOrientationPatient[n][k];
00628         }
00629       return dgo;
00630     }
00631 
00632   float* GetNthImagePositionPatient( unsigned int n )
00633     {
00634       if (n >= this->GetNumberOfImagePositionPatient() )
00635         {
00636         return NULL;
00637         }
00638       float *ipp = new float [3];
00639       for (int k = 0; k <3; k++)
00640         {
00641         ipp[k] = this->ImagePositionPatient[n][k];
00642         }
00643       return ipp;
00644     }
00645 
00648   int InsertSeriesInstanceUIDs ( const char * aUID )
00649     {
00650       int k = ExistSeriesInstanceUID( aUID );
00651       if ( k >= 0 )
00652         {
00653         return k;
00654         }
00655       
00656       std::string aVector(aUID);
00657       this->SeriesInstanceUIDs.push_back( aVector );
00658       return (this->SeriesInstanceUIDs.size()-1);
00659     }
00660 
00661   int InsertContentTime ( const char * aTime )
00662     {
00663       int k = ExistContentTime( aTime );
00664       if ( k >= 0 )
00665         {
00666         return k;
00667         }
00668       
00669       std::string aVector(aTime);
00670       this->ContentTime.push_back( aVector );
00671       return (this->ContentTime.size()-1);
00672     }
00673 
00674   int InsertTriggerTime ( const char * aTime )
00675     {
00676       int k = ExistTriggerTime( aTime );
00677       if ( k >= 0 )
00678         {
00679         return k;
00680         }
00681       
00682       std::string aVector(aTime);
00683       this->TriggerTime.push_back( aVector );
00684       return (this->TriggerTime.size()-1);
00685     }
00686 
00687   int InsertEchoNumbers ( const char * aEcho )
00688     {
00689       int k = ExistEchoNumbers( aEcho );
00690       if ( k >= 0 )
00691         {
00692         return k;
00693         }
00694       
00695       std::string aVector(aEcho);
00696       this->EchoNumbers.push_back( aVector );
00697       return (this->EchoNumbers.size()-1);
00698     }
00699   
00700   int InsertDiffusionGradientOrientation ( float *a )
00701     {
00702       int k = ExistDiffusionGradientOrientation( a );
00703       if ( k >= 0 )
00704         {
00705         return k;
00706         }
00707       std::vector< float > aVector(3);
00708       float aMag = sqrt(a[0]*a[0]+a[1]*a[1]+a[2]*a[2]);
00709       for (k = 0; k < 3; k++)
00710         {
00711         aVector[k] = a[k]/aMag;
00712         }
00713       
00714       this->DiffusionGradientOrientation.push_back( aVector );
00715       return (this->DiffusionGradientOrientation.size()-1);
00716     }
00717 
00718   int InsertSliceLocation ( float a )
00719     {
00720       int k = ExistSliceLocation( a );
00721       if ( k >= 0 )
00722         {
00723         return k;
00724         }
00725 
00726       this->SliceLocation.push_back( a );
00727       return (this->SliceLocation.size()-1);
00728     }
00729 
00730   int InsertImageOrientationPatient ( float *a )
00731     {
00732       int k = ExistImageOrientationPatient( a );
00733       if ( k >= 0 )
00734         {
00735         return k;
00736         }
00737       std::vector< float > aVector(6);
00738       float aMag = sqrt(a[0]*a[0]+a[1]*a[1]+a[2]*a[2]);
00739       float bMag = sqrt(a[3]*a[3]+a[4]*a[4]+a[5]*a[5]);
00740       for (k = 0; k < 3; k++)
00741         {
00742         aVector[k] = a[k]/aMag;
00743         aVector[k+3] = a[k+3]/bMag;
00744         }
00745 
00746       this->ImageOrientationPatient.push_back( aVector );
00747       return (this->ImageOrientationPatient.size()-1);
00748     }
00749 
00750   int InsertImagePositionPatient ( float *a )
00751     {
00752       int k = ExistImagePositionPatient( a );
00753       if ( k >= 0 )
00754         {
00755         return k;
00756         }
00757       
00758       std::vector< float > aVector(3);
00759       for ( unsigned int i = 0; i < 3; i++ ) aVector[i] = a[i]; 
00760       this->ImagePositionPatient.push_back( aVector );
00761       return (this->ImagePositionPatient.size()-1);
00762     }
00763 
00764   void AnalyzeDicomHeaders( );
00765 
00766   void AssembleNthVolume( int n );
00767   int AssembleVolumeContainingArchetype();
00768 
00769   void GroupFiles ( int idxSeriesInstanceUID,
00770                     int idxContentTime,
00771                     int idxTriggerTime,
00772                     int idxEchoNumbers,
00773                     int idxDiffusionGradientOrientation,
00774                     int idxSliceLocation,
00775                     int idxImageOrientationPatient );
00776 
00777   const char* GetNthFileName ( int idxSeriesInstanceUID,
00778                                int idxContentTime,
00779                                int idxTriggerTime,
00780                                int idxEchoNumbers,
00781                                int idxDiffusionGradientOrientation,
00782                                int idxSliceLocation,
00783                                int idxImageOrientationPatient,
00784                                int n );
00785 
00786 
00787 protected:
00788   vtkITKArchetypeImageSeriesReader();
00789   ~vtkITKArchetypeImageSeriesReader();
00790 
00791   char *Archetype;
00792   int SingleFile;
00793   int UseOrientationFromFile;
00794   int DataExtent[6];
00795 
00796   int          OutputScalarType;
00797   unsigned int NumberOfComponents;
00798 
00799   double DefaultDataSpacing[3];
00800   double DefaultDataOrigin[3];
00801   float ScanAxis[3];
00802   float ScanOrigin[3];
00803 
00804   int FileNameSliceOffset;
00805   int FileNameSliceSpacing;
00806   int FileNameSliceCount;
00807 
00808   vtkMatrix4x4* RasToIjkMatrix;
00809 
00810   char UseNativeCoordinateOrientation;
00811   char UseNativeScalarType;
00812   bool UseNativeOrigin;
00813 
00814   bool GroupingByTags;
00815   int SelectedUID;
00816   int SelectedContentTime;
00817   int SelectedTriggerTime;
00818   int SelectedEchoNumbers;
00819   int SelectedDiffusion;
00820   int SelectedSlice;
00821   int SelectedOrientation;
00822 
00823   unsigned int IndexArchetype;
00824 
00825   //BTX
00826   std::vector<std::string> FileNames;
00827   std::vector<std::pair <double, int> > FileNameSliceKey;
00828   CoordinateOrientationCode DesiredCoordinateOrientation;
00829   //ETX
00830   virtual void ExecuteInformation();
00832   virtual void ExecuteData(vtkDataObject *data);
00833 
00834   //BTX
00835   itk::MetaDataDictionary Dictionary;
00836   //ETX
00837 
00851 
00852   //BTX
00853   std::vector<std::string> AllFileNames;
00854   bool AnalyzeHeader;
00855   bool IsOnlyFile;
00856 
00857   std::vector<std::string> SeriesInstanceUIDs;
00858   std::vector<std::string> ContentTime;
00859   std::vector<std::string> TriggerTime;
00860   std::vector<std::string> EchoNumbers;
00861   std::vector< std::vector<float> > DiffusionGradientOrientation;
00862   std::vector<float> SliceLocation;
00863   std::vector< std::vector<float> > ImageOrientationPatient;
00864   std::vector< std::vector<float> > ImagePositionPatient;
00865 
00867   std::vector<long int> IndexSeriesInstanceUIDs;
00868   std::vector<long int> IndexContentTime;
00869   std::vector<long int> IndexTriggerTime;
00870   std::vector<long int> IndexEchoNumbers;  
00871   std::vector<long int> IndexDiffusionGradientOrientation;
00872   std::vector<long int> IndexSliceLocation;
00873   std::vector<long int> IndexImageOrientationPatient;
00874   std::vector<long int> IndexImagePositionPatient;
00875   //ETX
00876 
00877 private:
00878   vtkITKArchetypeImageSeriesReader(const vtkITKArchetypeImageSeriesReader&);  
00879   void operator=(const vtkITKArchetypeImageSeriesReader&);  
00880 };
00881 
00882 #endif

Generated on 6 Apr 2011 for Slicer3 by  doxygen 1.6.1