ENH: Use BinaryFunctor for "digitializing" input image

Use a thread filter to perform digitizing and masking of the input
image into histograms bins. Created a class scoped functor to perform
the per-pixel operation.

Author: blowekamp

include/itkCoocurrenceTextureFeaturesImageFilter.h

@@ -100,8 +100,11 @@ class ITK_TEMPLATE_EXPORT CoocurrenceTextureFeaturesImageFilter:public ImageToIm
 
   typedef TInputImage                     InputImageType;
   typedef TOutputImage                    OutputImageType;
+  typedef TInputImage                     MaskImageType;
+  typedef TInputImage                     DigitalisedImageType;
 
   typedef typename InputImageType::PixelType    PixelType;
+  typedef typename MaskImageType::PixelType     MaskPixelType;
   typedef typename InputImageType::IndexType    IndexType;
   typedef typename InputImageType::PointType    PointType;
 
@@ -226,7 +229,8 @@ class ITK_TEMPLATE_EXPORT CoocurrenceTextureFeaturesImageFilter:public ImageToIm
   virtual void UpdateOutputInformation() ITK_OVERRIDE;
 
 private:
-  typename InputImageType::Pointer  m_DigitalisedInputImageg;
+  typename DigitalisedImageType::Pointer  m_DigitalisedInputImageg;
+
   NeighborhoodRadiusType            m_NeighborhoodRadius;
   OffsetVectorPointer               m_Offsets;
   unsigned int                      m_NumberOfBinsPerAxis;
@@ -236,6 +240,62 @@ class ITK_TEMPLATE_EXPORT CoocurrenceTextureFeaturesImageFilter:public ImageToIm
   typename TInputImage::SpacingType m_Spacing;
   bool                              m_Normalize;
 
+
+  struct PreProcessingFunctor
+  {
+     PreProcessingFunctor()
+      : m_NumberOfBinsPerAxis(256),
+        m_MaskValue(1),
+        m_Min(NumericTraits<PixelType>::min()),
+        m_Max(NumericTraits<PixelType>::max()){}
+
+    PreProcessingFunctor(unsigned int numberOfBinsPerAxis,
+                         PixelType maskValue,
+                         PixelType min,
+                         PixelType max)
+      : m_NumberOfBinsPerAxis(numberOfBinsPerAxis),
+        m_MaskValue(maskValue),
+        m_Min(min),
+        m_Max(max){}
+
+    ~PreProcessingFunctor() {}
+
+    bool operator!=(const PreProcessingFunctor& other) const
+      {
+        return (m_NumberOfBinsPerAxis != other.m_NumberOfBinsPerAxis)
+          || (m_MaskValue != other.m_MaskValue)
+          || (m_Min != other.m_Min)
+          || (m_Max != other.m_Max);
+      }
+
+    bool operator==(const PreProcessingFunctor & other) const
+      {
+        return !( *this != other );
+      }
+
+    inline typename DigitalisedImageType::PixelType operator()(const MaskPixelType & maskPixel,
+                                                               const PixelType & inputPixel) const
+      {
+        if(maskPixel != m_MaskValue)
+          {
+          return this->m_Min - 10;
+          }
+        else if (inputPixel < this->m_Min || inputPixel >= m_Max)
+          {
+          return m_Min - 1;
+          }
+        else
+          {
+          return (inputPixel - m_Min)/((m_Max-m_Min)/ (float)m_NumberOfBinsPerAxis);
+          }
+      }
+
+    unsigned int m_NumberOfBinsPerAxis;
+
+    PixelType m_MaskValue;
+    PixelType m_Min;
+    PixelType m_Max;
+  };
 };
 } // end of namespace Statistics
 } // end of namespace itk

include/itkCoocurrenceTextureFeaturesImageFilter.hxx

@@ -21,6 +21,7 @@
 #include "itkCoocurrenceTextureFeaturesImageFilter.h"
 #include "itkRegionOfInterestImageFilter.h"
 #include "itkNeighborhoodAlgorithm.h"
+#include "itkBinaryFunctorImageFilter.h"
 
 namespace itk
 {
@@ -77,35 +78,31 @@ void
 CoocurrenceTextureFeaturesImageFilter<TInputImage, TOutputImage>
 ::BeforeThreadedGenerateData()
 {
-  const InputImageType * maskPointer = this->GetMaskImage();
-  this->m_DigitalisedInputImageg = InputImageType::New();
-  this->m_DigitalisedInputImageg->SetRegions(this->GetInput()->GetRequestedRegion());
-  this->m_DigitalisedInputImageg->CopyInformation(this->GetInput());
-  this->m_DigitalisedInputImageg->Allocate();
-  typedef itk::ImageRegionIterator< InputImageType> IteratorType;
-  IteratorType digitIt( this->m_DigitalisedInputImageg, this->m_DigitalisedInputImageg->GetLargestPossibleRegion() );
-  typedef itk::ImageRegionConstIterator< InputImageType> ConstIteratorType;
-  ConstIteratorType inputIt( this->GetInput(), this->GetInput()->GetLargestPossibleRegion() );
-  unsigned int binNumber;
-  while( !inputIt.IsAtEnd() )
+
+  typename TInputImage::Pointer input = InputImageType::New();
+  input->Graft(const_cast<TInputImage *>(this->GetInput()));
+
+  typedef PreProcessingFunctor PPFType;
+  PPFType ppf(m_NumberOfBinsPerAxis, m_InsidePixelValue, m_Min, m_Max);
+
+  typedef BinaryFunctorImageFilter< MaskImageType, InputImageType, InputImageType, PPFType> BinaryFunctorType;
+  typename BinaryFunctorType::Pointer functorF = BinaryFunctorType::New();
+  if (this->GetMaskImage() != ITK_NULLPTR)
     {
-    if( maskPointer && maskPointer->GetPixel( inputIt.GetIndex() ) != this->m_InsidePixelValue )
-      {
-      digitIt.Set(this->m_Min - 10);
-      }
-    else if(inputIt.Get() < this->m_Min || inputIt.Get() >= this->m_Max)
-      {
-      digitIt.Set(this->m_Min - 1);
-      }
-    else
-      {
-      binNumber = ( inputIt.Get() - m_Min)/( (m_Max - m_Min) / (float)m_NumberOfBinsPerAxis );
-      digitIt.Set(binNumber);
-      }
-    ++inputIt;
-    ++digitIt;
+    typename TInputImage::Pointer mask = MaskImageType::New();
+    mask->Graft(const_cast<TInputImage *>(this->GetMaskImage()));
+    functorF->SetInput1(mask);
     }
-  m_Spacing = this->GetInput()->GetSpacing();
+  else
+    {
+    functorF->SetConstant1(m_InsidePixelValue);
+    }
+  functorF->SetInput2(input);
+  functorF->SetFunctor(ppf);
+  functorF->SetNumberOfThreads(this->GetNumberOfThreads());
+
+  functorF->Update();
+  m_DigitalisedInputImageg = functorF->GetOutput();
 
   // Support VectorImages by setting number of components on output.
   OutputImageType * outputPtr = this->GetOutput();