segmentation utils (jef)

[clitk.git] / itk / clitkExplosionControlledThresholdConnectedImageFilter.h

diff --git a/itk/clitkExplosionControlledThresholdConnectedImageFilter.h b/itk/clitkExplosionControlledThresholdConnectedImageFilter.h
new file mode 100644 (file)
index 0000000..e325f37
--- /dev/null
+++ b/itk/clitkExplosionControlledThresholdConnectedImageFilter.h
@@ -0,0 +1,182 @@
+#ifndef __clitkExplosionControlledThresholdConnectedImageFilter_h
+#define __clitkExplosionControlledThresholdConnectedImageFilter_h
+
+#include "itkImage.h"
+#include "itkImageToImageFilter.h"
+
+namespace clitk {
+
+/** \class ExplosionControlledThresholdConnectedImageFilter
+ * \brief Label pixels that are connected to a seed and lie within a neighborhood
+ * 
+ * ExplosionControlledThresholdConnectedImageFilter labels pixels with ReplaceValue that
+ * are connected to an initial Seed AND whose neighbors all lie within a
+ * Lower and Upper threshold range.
+ *
+ * \ingroup RegionGrowingSegmentation 
+ */
+template <class TInputImage, class TOutputImage>
+class ITK_EXPORT ExplosionControlledThresholdConnectedImageFilter:
+    public itk::ImageToImageFilter<TInputImage,TOutputImage>
+{
+public:
+  /** Standard class typedefs. */
+  typedef ExplosionControlledThresholdConnectedImageFilter             Self;
+  typedef itk::ImageToImageFilter<TInputImage,TOutputImage> Superclass;
+  typedef itk::SmartPointer<Self>                           Pointer;
+  typedef itk::SmartPointer<const Self>                     ConstPointer;
+
+  /** Method for creation through the object factory. */
+  itkNewMacro(Self);
+
+  /** Run-time type information (and related methods).  */
+  itkTypeMacro(ExplosionControlledThresholdConnectedImageFilter,
+               ImageToImageFilter);
+
+  typedef TInputImage                         InputImageType;
+  typedef typename InputImageType::Pointer    InputImagePointer;
+  typedef typename InputImageType::RegionType InputImageRegionType; 
+  typedef typename InputImageType::PixelType  InputImagePixelType; 
+  typedef typename InputImageType::IndexType  IndexType;
+  typedef typename InputImageType::SizeType   InputImageSizeType;
+  
+  typedef TOutputImage                         OutputImageType;
+  typedef typename OutputImageType::Pointer    OutputImagePointer;
+  typedef typename OutputImageType::RegionType OutputImageRegionType; 
+  typedef typename OutputImageType::PixelType  OutputImagePixelType; 
+  
+  void PrintSelf ( std::ostream& os, itk::Indent indent ) const;
+
+  /** Clear the seeds */
+  void ClearSeeds();
+
+  /** Set seed point. */
+  void SetSeed(const IndexType & seed);
+
+  /** Add a seed point */
+  void AddSeed ( const IndexType & seed );
+
+  // Set/Get the lower threshold. The default is 0.
+  itkSetMacro(Lower, InputImagePixelType);
+  itkGetConstMacro(Lower, InputImagePixelType);
+
+  // Set/Get the upper threshold. The default is the largest possible value for the InputPixelType.
+  itkSetMacro(Upper, InputImagePixelType);
+  itkGetConstMacro(Upper, InputImagePixelType);
+  
+  /** Set/Get value to replace thresholded pixels. Pixels that lie *
+   *  within Lower and Upper (inclusive) will be replaced with this
+   *  value. The default is 1. */
+  itkSetMacro(ReplaceValue, OutputImagePixelType);
+  itkGetConstMacro(ReplaceValue, OutputImagePixelType);
+
+  //   /** Set the radius of the neighborhood used for a mask. */
+  //   itkSetMacro(Radius, InputImageSizeType);
+  
+  //   /** Get the radius of the neighborhood used to compute the median */
+  //   itkGetConstReferenceMacro(Radius, InputImageSizeType);
+  
+  /** ImageDimension constants */
+  itkStaticConstMacro(InputImageDimension, unsigned int,
+                      TInputImage::ImageDimension);
+  itkStaticConstMacro(OutputImageDimension, unsigned int,
+                      TOutputImage::ImageDimension);
+
+#ifdef ITK_USE_CONCEPT_CHECKING
+  /** Begin concept checking */
+  itkConceptMacro(InputEqualityComparableCheck,
+                 (itk::Concept::EqualityComparable<InputImagePixelType>));
+  itkConceptMacro(OutputEqualityComparableCheck,
+                 (itk::Concept::EqualityComparable<OutputImagePixelType>));
+  itkConceptMacro(SameDimensionCheck,
+                 (itk::Concept::SameDimension<InputImageDimension, OutputImageDimension>));
+  itkConceptMacro(InputOStreamWritableCheck,
+                 (itk::Concept::OStreamWritable<InputImagePixelType>));
+  itkConceptMacro(OutputOStreamWritableCheck,
+                 (itk::Concept::OStreamWritable<OutputImagePixelType>));
+  /** End concept checking */
+#endif
+
+  // JV
+  itkBooleanMacro(Verbose);
+  itkSetMacro( Verbose, bool);
+  itkGetConstReferenceMacro( Verbose, bool);
+
+  itkBooleanMacro(FullyConnected);
+  itkSetMacro( FullyConnected, bool);
+  itkGetConstReferenceMacro( FullyConnected, bool);
+
+  itkSetMacro( FinalLower, InputImagePixelType);
+  itkGetConstMacro( FinalLower, InputImagePixelType);
+
+  itkSetMacro( FinalUpper, InputImagePixelType);
+  itkGetConstMacro( FinalUpper, InputImagePixelType);
+
+  itkBooleanMacro(AdaptLowerBorder);
+  itkSetMacro( AdaptLowerBorder, bool);
+  itkGetConstReferenceMacro( AdaptLowerBorder, bool);
+
+  itkBooleanMacro(AdaptUpperBorder);
+  itkSetMacro( AdaptUpperBorder, bool);
+  itkGetConstReferenceMacro( AdaptUpperBorder, bool);
+
+  itkSetMacro( Multiplier, double);
+  itkGetConstMacro( Multiplier, double);
+
+  itkSetMacro( MaximumUpperThreshold, InputImagePixelType);
+  itkGetConstMacro( MaximumUpperThreshold, InputImagePixelType);
+
+  itkSetMacro( MinimumLowerThreshold, InputImagePixelType);
+  itkGetConstMacro( MinimumLowerThreshold, InputImagePixelType);
+
+  itkSetMacro(ThresholdStepSize, InputImagePixelType);
+  itkGetConstMacro( ThresholdStepSize, InputImagePixelType);
+
+  itkSetMacro( MinimumThresholdStepSize, InputImagePixelType);
+  itkGetConstMacro( MinimumThresholdStepSize, InputImagePixelType);
+
+  itkSetMacro( MinimumSize, unsigned int);
+  itkGetConstMacro( MinimumSize,unsigned int);
+
+protected:
+  ExplosionControlledThresholdConnectedImageFilter();
+  ~ExplosionControlledThresholdConnectedImageFilter(){};
+  std::vector<IndexType> m_Seeds;
+  InputImagePixelType    m_Lower;
+  InputImagePixelType    m_Upper;
+  OutputImagePixelType   m_ReplaceValue;
+
+  // JV 
+  bool m_Verbose;
+  bool m_FullyConnected;
+  bool m_AdaptLowerBorder;
+  bool m_AdaptUpperBorder;
+  InputImagePixelType m_FinalLower;
+  InputImagePixelType m_FinalUpper;
+  double m_Multiplier;
+  InputImagePixelType m_MaximumUpperThreshold;
+  InputImagePixelType m_MinimumLowerThreshold;
+  InputImagePixelType m_MinimumThresholdStepSize;
+  InputImagePixelType m_ThresholdStepSize;
+  unsigned int m_MinimumSize;
+
+  // Override since the filter needs all the data for the algorithm
+  void GenerateInputRequestedRegion();
+
+  // Override since the filter produces the entire dataset
+  void EnlargeOutputRequestedRegion(itk::DataObject *output);
+  void GenerateData();
+  
+private:
+  ExplosionControlledThresholdConnectedImageFilter(const Self&); //purposely not implemented
+  void operator=(const Self&); //purposely not implemented
+
+};
+
+} // end namespace clitk
+
+#ifndef ITK_MANUAL_INSTANTIATION
+#include "clitkExplosionControlledThresholdConnectedImageFilter.txx"
+#endif
+
+#endif