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

itkListSample.h

Go to the documentation of this file.
00001 /*=========================================================================
00002 
00003   Program:   Insight Segmentation & Registration Toolkit
00004   Module:    $RCSfile: itkListSample.h,v $
00005   Language:  C++
00006   Date:      $Date: 2004/04/15 11:13:51 $
00007   Version:   $Revision: 1.22 $
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 __itkListSample_h
00018 #define __itkListSample_h
00019 
00020 #include "itkObjectFactory.h"
00021 #include "itkMacro.h"
00022 #include "itkListSampleBase.h"
00023 #include "itkFixedArray.h"
00024 #include "itkSmartPointer.h"
00025 
00026 #include <vector>
00027 
00028 namespace itk{ 
00029 namespace Statistics{
00030 
00041 template< class TMeasurementVector >
00042 class ITK_EXPORT ListSample : public ListSampleBase< TMeasurementVector >
00043 {
00044 public:
00046   typedef ListSample  Self;
00047   typedef ListSampleBase< TMeasurementVector > Superclass;
00048   typedef SmartPointer< Self > Pointer;
00049   typedef SmartPointer<const Self> ConstPointer;
00050 
00052   itkTypeMacro(ListSample, ListSampleBase);
00053 
00055   itkNewMacro(Self) ;
00056   
00061   typedef typename Superclass::MeasurementVectorType MeasurementVectorType;
00062   typedef typename Superclass::MeasurementType MeasurementType;
00063   typedef typename Superclass::FrequencyType FrequencyType ;
00064   typedef typename Superclass::InstanceIdentifier InstanceIdentifier;
00065   typedef typename Superclass::SearchResultVectorType SearchResultVectorType ;
00066 
00067   typedef MeasurementVectorType ValueType ;
00068 
00070   itkStaticConstMacro(MeasurementVectorSize, unsigned int,
00071                       Superclass::MeasurementVectorSize);
00072 
00074   typedef std::vector< MeasurementVectorType > InternalDataContainerType ;
00075 
00080   void Resize( unsigned int n ) 
00081   { m_InternalContainer.resize(n) ; }
00082 
00084   void Clear() 
00085   { m_InternalContainer.clear() ; }
00086 
00088   void PushBack( MeasurementVectorType mv )
00089   { m_InternalContainer.push_back( mv ) ; }
00090 
00092   unsigned int Size() const
00093   { return static_cast<unsigned int>( m_InternalContainer.size() ); }
00094 
00097   const MeasurementVectorType & GetMeasurementVector(const InstanceIdentifier &id) const;
00098 
00101   void SetMeasurement(const InstanceIdentifier &id, 
00102                       const unsigned int &dim,
00103                       const MeasurementType &value) ;
00104 
00107   void SetMeasurementVector(const InstanceIdentifier &id, 
00108                             const MeasurementVectorType &mv) ;
00109 
00111   FrequencyType GetFrequency(const InstanceIdentifier &id) const ;
00112 
00114   FrequencyType GetTotalFrequency() const
00115   { return static_cast<FrequencyType>( m_InternalContainer.size() ); }
00116 
00117   class ConstIterator;
00118  
00119   class Iterator
00120   {
00121 
00122     friend class ConstIterator;
00123 
00124   public:
00125     
00126     Iterator(){}
00127     
00128     Iterator(typename InternalDataContainerType::iterator iter, 
00129              InstanceIdentifier iid)
00130       :m_Iter(iter), m_InstanceIdentifier(iid)
00131     {}
00132     
00133     FrequencyType GetFrequency() const
00134     { return 1 ;}
00135 
00136     const MeasurementVectorType & GetMeasurementVector() const
00137     { return (MeasurementVectorType&) *m_Iter ;} 
00138 
00139     InstanceIdentifier GetInstanceIdentifier() const
00140     { return m_InstanceIdentifier ;}
00141 
00142     Iterator& operator++()
00143     { ++m_Iter ; ++m_InstanceIdentifier ; return *this ;}
00144     
00145     Iterator& operator--()
00146     { 
00147       --m_Iter ; 
00148 
00149       if ( m_InstanceIdentifier > 1 )
00150         m_InstanceIdentifier; 
00151       
00152       return *this ;
00153     }
00154 
00155     bool operator!=(const Iterator &it)
00156     { return (m_Iter != it.m_Iter) ;}
00157     
00158     bool operator==(const Iterator &it)
00159     { return (m_Iter == it.m_Iter) ;}
00160     
00161     Iterator& operator = (const Iterator & iter)
00162     { 
00163       m_Iter = iter.m_Iter; 
00164       m_InstanceIdentifier = iter.m_InstanceIdentifier ;
00165       return *this ;
00166     }
00167 
00168     Iterator(const Iterator &iter)
00169     {
00170       m_Iter = iter.m_Iter; 
00171       m_InstanceIdentifier = iter.m_InstanceIdentifier ;
00172     }
00173     
00174   private:
00175     typename InternalDataContainerType::iterator m_Iter ;
00176     InstanceIdentifier m_InstanceIdentifier ;
00177   } ;
00178 
00179  
00180   class ConstIterator
00181   {
00182   public:
00183     
00184     ConstIterator(){}
00185     
00186     ConstIterator(typename InternalDataContainerType::const_iterator iter, 
00187              InstanceIdentifier iid)
00188       :m_Iter(iter), m_InstanceIdentifier(iid)
00189     {}
00190     
00191     FrequencyType GetFrequency() const
00192     { return 1 ;}
00193 
00194     const MeasurementVectorType & GetMeasurementVector() const
00195     { return (MeasurementVectorType&) *m_Iter ;} 
00196 
00197     InstanceIdentifier GetInstanceIdentifier() const
00198     { return m_InstanceIdentifier ;}
00199 
00200     ConstIterator& operator++()
00201     { ++m_Iter ; ++m_InstanceIdentifier ; return *this ;}
00202     
00203     ConstIterator& operator--()
00204     { 
00205       --m_Iter ; 
00206 
00207       if ( m_InstanceIdentifier > 1 )
00208         m_InstanceIdentifier; 
00209       
00210       return *this ;
00211     }
00212 
00213     bool operator!=(const ConstIterator &it)
00214     { return (m_Iter != it.m_Iter) ;}
00215     
00216     bool operator==(const ConstIterator &it)
00217     { return (m_Iter == it.m_Iter) ;}
00218     
00219     ConstIterator& operator = (const ConstIterator iter)
00220     { 
00221       m_Iter = iter.m_Iter; 
00222       m_InstanceIdentifier = iter.m_InstanceIdentifier ;
00223       return *this ;
00224     }
00225 
00226     ConstIterator& operator = (const Iterator & iter)
00227     { 
00228       m_Iter = iter.m_Iter; 
00229       m_InstanceIdentifier = iter.m_InstanceIdentifier ;
00230       return *this ;
00231     }
00232 
00233 
00234     ConstIterator(const ConstIterator &iter)
00235     {
00236       m_Iter = iter.m_Iter; 
00237       m_InstanceIdentifier = iter.m_InstanceIdentifier ;
00238     }
00239 
00240     ConstIterator(const Iterator &iter)
00241     {
00242       m_Iter = iter.m_Iter; 
00243       m_InstanceIdentifier = iter.m_InstanceIdentifier ;
00244     }
00245     
00246   private:
00247     typename InternalDataContainerType::const_iterator m_Iter ;
00248     InstanceIdentifier m_InstanceIdentifier ;
00249   } ;
00250 
00252   Iterator Begin()
00253   { 
00254     Iterator iter(m_InternalContainer.begin(), 0);
00255     return iter; 
00256   }
00257   
00259   Iterator End()        
00260   {
00261     Iterator iter(m_InternalContainer.end(), m_InternalContainer.size()); 
00262     return iter; 
00263   }
00264 
00266   ConstIterator Begin() const
00267   { 
00268     ConstIterator iter(m_InternalContainer.begin(), 0);
00269     return iter; 
00270   }
00271   
00273   ConstIterator End() const
00274   {
00275     ConstIterator iter(m_InternalContainer.end(), m_InternalContainer.size()); 
00276     return iter; 
00277   }
00278  
00279 protected:
00280   ListSample() ;
00281   virtual ~ListSample() {}
00282   void PrintSelf(std::ostream& os, Indent indent) const; 
00283   
00284 private:
00285   ListSample(const Self&) ; //purposely not implemented
00286   void operator=(const Self&) ; //purposely not implemented
00287 
00288   InternalDataContainerType m_InternalContainer ;
00289 };
00290 
00291 } // end of namespace Statistics 
00292 } // end of namespace itk 
00293 
00294 #ifndef ITK_MANUAL_INSTANTIATION
00295 #include "itkListSample.txx"
00296 #endif
00297 
00298 #endif

Generated at Wed Mar 30 00:02:36 2005 for ITK by doxygen 1.3.9.1 written by Dimitri van Heesch, © 1997-2000