Main Page   Groups   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members   Concepts

itkSubsample.h

Go to the documentation of this file.
00001 /*=========================================================================
00002 
00003   Program:   Insight Segmentation & Registration Toolkit
00004   Module:    $RCSfile: itkSubsample.h,v $
00005   Language:  C++
00006   Date:      $Date: 2005/09/30 17:24:45 $
00007   Version:   $Revision: 1.30 $
00008 
00009   Copyright (c) Insight Software Consortium. All rights reserved.
00010   See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.
00011 
00012      This software is distributed WITHOUT ANY WARRANTY; without even 
00013      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
00014      PURPOSE.  See the above copyright notices for more information.
00015 
00016 =========================================================================*/
00017 #ifndef __itkSubsample_h
00018 #define __itkSubsample_h
00019 
00020 #include "itkSample.h"
00021 #include "itkMacro.h"
00022 #include "itkObjectFactory.h"
00023 
00024 namespace itk{ 
00025 namespace Statistics{
00026 
00037 template< class TSample >
00038 class ITK_EXPORT Subsample : 
00039     public Sample< typename TSample::MeasurementVectorType >
00040 {
00041 public:
00043   typedef Subsample Self;
00044   typedef Sample< typename TSample::MeasurementVectorType > Superclass ;
00045   typedef SmartPointer< Self > Pointer ;
00046   typedef SmartPointer<const Self> ConstPointer;
00047 
00049   itkTypeMacro(Subsample, Sample);
00050 
00052   itkNewMacro(Self) ;
00053 
00055   typedef typename TSample::Pointer SamplePointer ;
00056 
00059   typedef typename TSample::MeasurementVectorType MeasurementVectorType;
00060   typedef typename TSample::MeasurementType MeasurementType;
00061   typedef typename TSample::InstanceIdentifier InstanceIdentifier;
00062   typedef typename TSample::FrequencyType FrequencyType ;
00063   typedef typename TSample::TotalFrequencyType TotalFrequencyType ;
00064   typedef MeasurementVectorType ValueType ;
00065 
00070   typedef std::vector< InstanceIdentifier > InstanceIdentifierHolder ;
00071 
00073   void SetSample(const TSample* sample)
00074     { 
00075     m_Sample = sample ; 
00076     this->SetMeasurementVectorSize( m_Sample->GetMeasurementVectorSize() );
00077     }
00079 
00080   const TSample* GetSample() const
00081   { return m_Sample ; } 
00082 
00083 
00084   void InitializeWithAllInstances()
00085   {
00086     m_IdHolder.resize(m_Sample->Size()) ;
00087     typename InstanceIdentifierHolder::iterator idIter = m_IdHolder.begin() ;
00088     typename TSample::ConstIterator iter = m_Sample->Begin() ;
00089     typename TSample::ConstIterator last = m_Sample->End() ;
00090     m_TotalFrequency = NumericTraits< FrequencyType >::Zero ;
00091     while (iter != last)
00092       {
00093       *idIter++ = iter.GetInstanceIdentifier() ;
00094       m_TotalFrequency += iter.GetFrequency() ;
00095       ++iter ;
00096       }
00097   }
00098 
00099   void AddInstance(InstanceIdentifier id)
00100   { 
00101     m_IdHolder.push_back(id) ; 
00102     m_TotalFrequency += m_Sample->GetFrequency(id) ;
00103   }
00104 
00107   unsigned int Size() const
00108   { 
00109     return static_cast<unsigned int>( m_IdHolder.size() );
00110   }
00111 
00112   void Clear()
00113   { 
00114     m_IdHolder.clear() ;
00115     m_TotalFrequency = NumericTraits< FrequencyType >::Zero ;
00116   }
00117 
00120   const MeasurementVectorType & GetMeasurementVector(const InstanceIdentifier &id) const
00121   { return m_Sample->GetMeasurementVector(id) ; }
00122 
00124   FrequencyType GetFrequency(const InstanceIdentifier &id) const
00125   { return m_Sample->GetFrequency(id) ; }
00126 
00128   TotalFrequencyType GetTotalFrequency() const
00129   { return m_TotalFrequency ; }
00130 
00131   void Swap(int index1, int index2) ;
00132   
00133   MeasurementVectorType GetMeasurementVectorByIndex(int index) const ;
00134 
00135   FrequencyType GetFrequencyByIndex(int index) const;
00136 
00137   InstanceIdentifier GetInstanceIdentifier(int index) const;
00138 
00139   
00140  
00141   class Iterator
00142   {
00143   public:
00144     Iterator(typename InstanceIdentifierHolder::iterator iter, 
00145              Self* classSample)
00146       :m_Iter(iter), m_Subsample(classSample),
00147        m_Sample(classSample->GetSample())
00148     {}
00149     
00150     FrequencyType GetFrequency() const
00151     { return  m_Sample->GetFrequency(*m_Iter) ; }
00152     
00153     const MeasurementVectorType & GetMeasurementVector() const
00154     { return m_Sample->GetMeasurementVector(*m_Iter) ; } 
00155     
00156     InstanceIdentifier GetInstanceIdentifier() const   
00157     { return *m_Iter ; }
00158     
00159     Iterator& operator++() 
00160     { 
00161       ++m_Iter ;
00162       return *this ;
00163     }
00164     
00165     //Iterator& operator+()
00166     //{ m_Iter += n; return *this ;}
00167 
00168     Iterator& operator+(int n)
00169     { m_Iter += n; return *this ;}
00170     
00171     Iterator& operator-(int n)
00172     { m_Iter -= n; return *this ;}
00173 
00174     bool operator!=(const Iterator& it) 
00175     { return (m_Iter != it.m_Iter) ; }
00176     
00177     bool operator==(const Iterator& it) 
00178     { return (m_Iter == it.m_Iter) ; }
00179     
00180     Iterator& operator=(const Iterator& iter)
00181     {
00182       m_Iter = iter.m_Iter;
00183       m_Subsample = iter.m_Subsample ;
00184       m_Sample = iter.m_Sample ;
00185       return *this ;
00186     }
00187 
00188     Iterator(const Iterator& iter)
00189     {
00190       m_Iter = iter.m_Iter;
00191       m_Subsample = iter.m_Subsample ;
00192       m_Sample = iter.m_Sample ;
00193     }
00194     
00195   private:
00196     // Iterator pointing to ImageToListAdaptor
00197     typename InstanceIdentifierHolder::iterator m_Iter ;  
00198     // Pointer to Subsample object
00199     Self* m_Subsample ;
00200     const TSample* m_Sample ;
00201   } ;
00202 
00203 
00204  
00205   class ConstIterator
00206   {
00207   public:
00208     ConstIterator(typename InstanceIdentifierHolder::const_iterator iter, 
00209              const Self* classSample)
00210       :m_Iter(iter), m_Subsample(classSample),
00211        m_Sample(classSample->GetSample())
00212     {}
00213     
00214     FrequencyType GetFrequency() const
00215     { return  m_Sample->GetFrequency(*m_Iter) ; }
00216     
00217     const MeasurementVectorType & GetMeasurementVector() const
00218     { return m_Sample->GetMeasurementVector(*m_Iter) ; } 
00219     
00220     InstanceIdentifier GetInstanceIdentifier() const   
00221     { return *m_Iter ; }
00222     
00223     ConstIterator& operator++() 
00224     { 
00225       ++m_Iter ;
00226       return *this ;
00227     }
00228     
00229     //ConstIterator& operator+()
00230     //{ m_Iter += n; return *this ;}
00231 
00232     ConstIterator& operator+(int n)
00233     { m_Iter += n; return *this ;}
00234     
00235     ConstIterator& operator-(int n)
00236     { m_Iter -= n; return *this ;}
00237 
00238     bool operator!=(const ConstIterator& it) 
00239     { return (m_Iter != it.m_Iter) ; }
00240     
00241     bool operator==(const ConstIterator& it) 
00242     { return (m_Iter == it.m_Iter) ; }
00243     
00244     ConstIterator& operator=(const ConstIterator& iter)
00245     {
00246       m_Iter = iter.m_Iter;
00247       m_Subsample = iter.m_Subsample ;
00248       m_Sample = iter.m_Sample ;
00249       return *this ;
00250     }
00251 
00252     ConstIterator(const ConstIterator& iter)
00253     {
00254       m_Iter = iter.m_Iter;
00255       m_Subsample = iter.m_Subsample ;
00256       m_Sample = iter.m_Sample ;
00257     }
00258     
00259   private:
00260     // ConstIterator pointing to ImageToListAdaptor
00261     typename InstanceIdentifierHolder::const_iterator m_Iter ;  
00262     // Pointer to Subsample object
00263     const Self* m_Subsample ;
00264     const TSample* m_Sample ;
00265   } ;
00266 
00267 
00268 
00269   Iterator Begin()
00270   { 
00271     Iterator iter(m_IdHolder.begin(), this) ;
00272     return iter; 
00273   }
00274   
00275   Iterator  End()        
00276   {
00277     Iterator iter(m_IdHolder.end(), this) ; 
00278     return iter; 
00279   }
00280 
00281   ConstIterator Begin() const
00282   { 
00283     ConstIterator iter(m_IdHolder.begin(), this) ;
00284     return iter; 
00285   }
00286   
00287   ConstIterator  End()  const
00288   {
00289     ConstIterator iter(m_IdHolder.end(), this) ; 
00290     return iter; 
00291   }
00292  
00293 protected:
00294   Subsample() ;
00295   virtual ~Subsample() {}
00296   void PrintSelf(std::ostream& os, Indent indent) const;
00297   
00298 private:
00299   Subsample(const Self&) ; //purposely not implemented
00300   void operator=(const Self&) ; //purposely not implemented
00301 
00302   const TSample*              m_Sample ;
00303   InstanceIdentifierHolder    m_IdHolder ;
00304   unsigned int                m_ActiveDimension ;
00305   FrequencyType m_TotalFrequency ;
00306 } ; // end of class
00307 
00308 
00309 } // end of namespace Statistics 
00310 } // end of namespace itk
00311 
00312 
00313 #ifndef ITK_MANUAL_INSTANTIATION
00314 #include "itkSubsample.txx"
00315 #endif
00316 
00317 #endif
00318 
00319 
00320 
00321 
00322 
00323 
00324 
00325 

Generated at Sat Sep 2 21:10:36 2006 for ITK by doxygen 1.4.7 written by Dimitri van Heesch, © 1997-2000