00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
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
00166
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
00197 typename InstanceIdentifierHolder::iterator m_Iter ;
00198
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
00230
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
00261 typename InstanceIdentifierHolder::const_iterator m_Iter ;
00262
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&) ;
00300 void operator=(const Self&) ;
00301
00302 const TSample* m_Sample ;
00303 InstanceIdentifierHolder m_IdHolder ;
00304 unsigned int m_ActiveDimension ;
00305 FrequencyType m_TotalFrequency ;
00306 } ;
00307
00308
00309 }
00310 }
00311
00312
00313 #ifndef ITK_MANUAL_INSTANTIATION
00314 #include "itkSubsample.txx"
00315 #endif
00316
00317 #endif
00318
00319
00320
00321
00322
00323
00324
00325