Go to the documentation of this file.00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017 #ifndef __itkMovingHistogramMorphologyImageFilter_h
00018 #define __itkMovingHistogramMorphologyImageFilter_h
00019
00020 #include "itkMovingHistogramImageFilter.h"
00021 #include <list>
00022 #include <map>
00023
00024 namespace itk {
00025
00026 namespace Function {
00027 template <class TInputPixel, class TCompare>
00028 class MorphologyHistogram
00029 {
00030 public:
00031 MorphologyHistogram()
00032 {
00033 m_UseVectorBasedAlgorithm = UseVectorBasedAlgorithm();
00034 if( m_UseVectorBasedAlgorithm )
00035 { initVector(); }
00036 }
00037 ~MorphologyHistogram(){}
00038
00039 MorphologyHistogram * Clone() const
00040 {
00041 MorphologyHistogram * result = new MorphologyHistogram();
00042 result->m_Map = this->m_Map;
00043 result->m_Vector = this->m_Vector;
00044 result->m_CurrentValue = this->m_CurrentValue;
00045 result->m_Compare = this->m_Compare;
00046 result->m_Direction = this->m_Direction;
00047 result->m_Boundary = this->m_Boundary;
00048 return result;
00049 }
00050
00051
00052
00053
00054 inline void AddBoundary()
00055 {
00056 if( m_UseVectorBasedAlgorithm )
00057 { AddBoundaryVector(); }
00058 else
00059 { AddBoundaryMap(); }
00060 }
00061
00062 inline void RemoveBoundary()
00063 {
00064 if( m_UseVectorBasedAlgorithm )
00065 { RemoveBoundaryVector(); }
00066 else
00067 { RemoveBoundaryMap(); }
00068 }
00069
00070 inline void AddPixel( const TInputPixel &p )
00071 {
00072 if( m_UseVectorBasedAlgorithm )
00073 { AddPixelVector( p ); }
00074 else
00075 { AddPixelMap( p ); }
00076 }
00077
00078 inline void RemovePixel( const TInputPixel &p )
00079 {
00080 if( m_UseVectorBasedAlgorithm )
00081 { RemovePixelVector( p ); }
00082 else
00083 { RemovePixelMap( p ); }
00084 }
00085
00086 inline TInputPixel GetValue( const TInputPixel & )
00087 {
00088 if( m_UseVectorBasedAlgorithm )
00089 { return GetValueVector(); }
00090 else
00091 { return GetValueMap(); }
00092 }
00093
00094
00095 inline static bool UseVectorBasedAlgorithm()
00096 {
00097
00098
00099 return typeid(TInputPixel) == typeid(unsigned char)
00100 || typeid(TInputPixel) == typeid(signed char)
00101 || typeid(TInputPixel) == typeid(unsigned short)
00102 || typeid(TInputPixel) == typeid(signed short)
00103 || typeid(TInputPixel) == typeid(bool);
00104 }
00105
00106 bool m_UseVectorBasedAlgorithm;
00107
00108
00109
00110
00111
00112 typedef typename std::map< TInputPixel, unsigned long, TCompare > MapType;
00113
00114 inline void AddBoundaryMap()
00115 { m_Map[ m_Boundary ]++; }
00116
00117 inline void RemoveBoundaryMap()
00118 { m_Map[ m_Boundary ]--; }
00119
00120 inline void AddPixelMap( const TInputPixel &p )
00121 { m_Map[ p ]++; }
00122
00123 inline void RemovePixelMap( const TInputPixel &p )
00124 { m_Map[ p ]--; }
00125
00126 inline TInputPixel GetValueMap()
00127 {
00128
00129 typename MapType::iterator mapIt = m_Map.begin();
00130 while( mapIt != m_Map.end() )
00131 {
00132 if( mapIt->second == 0 )
00133 {
00134
00135
00136
00137 TInputPixel toErase = mapIt->first;
00138 mapIt++;
00139 m_Map.erase( toErase );
00140 }
00141 else
00142 {
00143 mapIt++;
00144
00145
00146 break;
00147 }
00148 }
00149
00150
00151 return m_Map.begin()->first;
00152 }
00153
00154 MapType m_Map;
00155
00156
00157
00158
00159
00160
00161 inline void initVector()
00162 {
00163
00164 m_Vector.resize( static_cast<int>( NumericTraits< TInputPixel >::max() - NumericTraits< TInputPixel >::NonpositiveMin() + 1 ), 0 );
00165 if( m_Compare( NumericTraits< TInputPixel >::max(), NumericTraits< TInputPixel >::NonpositiveMin() ) )
00166 {
00167 m_CurrentValue = NumericTraits< TInputPixel >::NonpositiveMin();
00168 m_Direction = -1;
00169 }
00170 else
00171 {
00172 m_CurrentValue = NumericTraits< TInputPixel >::max();
00173 m_Direction = 1;
00174 }
00175 }
00176
00177
00178 inline void AddBoundaryVector()
00179 { AddPixelVector( m_Boundary ); }
00180
00181 inline void RemoveBoundaryVector()
00182 { RemovePixelVector( m_Boundary ); }
00183
00184 inline void AddPixelVector( const TInputPixel &p )
00185 {
00186 m_Vector[ static_cast<int>( p - NumericTraits< TInputPixel >::NonpositiveMin() ) ]++;
00187 if( m_Compare( p, m_CurrentValue ) )
00188 { m_CurrentValue = p; }
00189 }
00190
00191 inline void RemovePixelVector( const TInputPixel &p )
00192 {
00193 m_Vector[ static_cast<int>( p - NumericTraits< TInputPixel >::NonpositiveMin() ) ]--;
00194 while( m_Vector[ static_cast<int>( m_CurrentValue - NumericTraits< TInputPixel >::NonpositiveMin() ) ] == 0 )
00195 { m_CurrentValue += m_Direction; }
00196 }
00197
00198 inline TInputPixel GetValueVector()
00199 { return m_CurrentValue; }
00200
00201 std::vector<unsigned long> m_Vector;
00202 TInputPixel m_CurrentValue;
00203 TCompare m_Compare;
00204 signed int m_Direction;
00205
00206
00207
00208
00209 void SetBoundary( const TInputPixel & val )
00210 { m_Boundary = val; }
00211
00212 TInputPixel m_Boundary;
00213 };
00214 }
00215
00216
00228 template<class TInputImage, class TOutputImage, class TKernel, class THistogram>
00229 class ITK_EXPORT MovingHistogramMorphologyImageFilter :
00230 public MovingHistogramImageFilter<TInputImage, TOutputImage, TKernel, THistogram>
00231 {
00232 public:
00234 typedef MovingHistogramMorphologyImageFilter Self;
00235 typedef MovingHistogramImageFilter<TInputImage, TOutputImage, TKernel, THistogram>
00236 Superclass;
00237 typedef SmartPointer<Self> Pointer;
00238 typedef SmartPointer<const Self> ConstPointer;
00239
00241 itkNewMacro(Self);
00242
00244 itkTypeMacro(MovingHistogramMorphologyImageFilter,
00245 ImageToImageFilter);
00246
00248 typedef TInputImage InputImageType;
00249 typedef TOutputImage OutputImageType;
00250 typedef typename TInputImage::RegionType RegionType;
00251 typedef typename TInputImage::SizeType SizeType;
00252 typedef typename TInputImage::IndexType IndexType;
00253 typedef typename TInputImage::PixelType PixelType;
00254 typedef typename TInputImage::OffsetType OffsetType;
00255 typedef typename Superclass::OutputImageRegionType OutputImageRegionType;
00256 typedef typename TOutputImage::PixelType OutputPixelType;
00257
00259 itkStaticConstMacro(ImageDimension, unsigned int,
00260 TInputImage::ImageDimension);
00261
00263 typedef TKernel KernelType;
00264
00266 typedef typename KernelType::ConstIterator KernelIteratorType;
00267
00269 typedef typename KernelType::SizeType RadiusType;
00270
00271 typedef typename std::list< OffsetType > OffsetListType;
00272
00273 typedef typename std::map< OffsetType, OffsetListType, typename OffsetType::LexicographicCompare > OffsetMapType;
00274
00276 itkSetMacro(Boundary, PixelType);
00277 itkGetConstMacro(Boundary, PixelType);
00279
00282 static bool GetUseVectorBasedAlgorithm()
00283 { return THistogram::UseVectorBasedAlgorithm(); }
00284
00285 protected:
00286 MovingHistogramMorphologyImageFilter();
00287 ~MovingHistogramMorphologyImageFilter() {};
00288 void PrintSelf(std::ostream& os, Indent indent) const;
00289
00291
00292
00293
00294
00296 virtual THistogram * NewHistogram();
00297
00298 PixelType m_Boundary;
00299
00300 private:
00301 MovingHistogramMorphologyImageFilter(const Self&);
00302 void operator=(const Self&);
00303
00304 };
00305
00306 }
00307
00308 #ifndef ITK_MANUAL_INSTANTIATION
00309 #include "itkMovingHistogramMorphologyImageFilter.txx"
00310 #endif
00311
00312 #endif
00313