itkBinaryThresholdImageFilter.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef __itkBinaryThresholdImageFilter_h
#define __itkBinaryThresholdImageFilter_h

#include "itkUnaryFunctorImageFilter.h"
#include "itkConceptChecking.h"
#include "itkSimpleDataObjectDecorator.h"

namespace itk
{
namespace Functor
{
template< class TInput, class TOutput >
class BinaryThreshold
{
public:
  BinaryThreshold()
  {
    m_LowerThreshold = NumericTraits< TInput >::NonpositiveMin();
    m_UpperThreshold = NumericTraits< TInput >::max();
    m_OutsideValue   = NumericTraits< TOutput >::Zero;
    m_InsideValue    = NumericTraits< TOutput >::max();
  }

  ~BinaryThreshold() {}

  void SetLowerThreshold(const TInput & thresh)
  { m_LowerThreshold = thresh; }
  void SetUpperThreshold(const TInput & thresh)
  { m_UpperThreshold = thresh; }
  void SetInsideValue(const TOutput & value)
  { m_InsideValue = value; }
  void SetOutsideValue(const TOutput & value)
  { m_OutsideValue = value; }

  bool operator!=(const BinaryThreshold & other) const
  {
    if ( m_LowerThreshold != other.m_LowerThreshold
         || m_UpperThreshold != other.m_UpperThreshold
         || m_InsideValue    != other.m_InsideValue
         || m_OutsideValue   != other.m_OutsideValue  )
      {
      return true;
      }
    return false;
  }

  bool operator==(const BinaryThreshold & other) const
  {
    return !( *this != other );
  }

  inline TOutput operator()(const TInput & A) const
  {
    if ( m_LowerThreshold <= A && A <= m_UpperThreshold )
      {
      return m_InsideValue;
      }
    return m_OutsideValue;
  }

private:
  TInput  m_LowerThreshold;
  TInput  m_UpperThreshold;
  TOutput m_InsideValue;
  TOutput m_OutsideValue;
};
}

template< class TInputImage, class TOutputImage >
class ITK_EXPORT BinaryThresholdImageFilter:
  public
  UnaryFunctorImageFilter< TInputImage, TOutputImage,
                           Functor::BinaryThreshold<
                             typename TInputImage::PixelType,
                             typename TOutputImage::PixelType > >
{
public:
  typedef BinaryThresholdImageFilter Self;
  typedef UnaryFunctorImageFilter< TInputImage, TOutputImage,
                                   Functor::BinaryThreshold<
                                     typename TInputImage::PixelType,
                                     typename TOutputImage::PixelType >
                                   >                                   Superclass;
  typedef SmartPointer< Self >       Pointer;
  typedef SmartPointer< const Self > ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(BinaryThresholdImageFilter, UnaryFunctorImageFilter);

  typedef typename TInputImage::PixelType  InputPixelType;
  typedef typename TOutputImage::PixelType OutputPixelType;

  typedef SimpleDataObjectDecorator< InputPixelType > InputPixelObjectType;

  itkSetMacro(OutsideValue, OutputPixelType);

  itkGetConstReferenceMacro(OutsideValue, OutputPixelType);

  itkSetMacro(InsideValue, OutputPixelType);

  itkGetConstReferenceMacro(InsideValue, OutputPixelType);

  virtual void SetUpperThreshold(const InputPixelType threshold);

  virtual void SetUpperThresholdInput(const InputPixelObjectType *);

  virtual void SetLowerThreshold(const InputPixelType threshold);

  virtual void SetLowerThresholdInput(const InputPixelObjectType *);

  virtual InputPixelType GetUpperThreshold() const;

  virtual InputPixelObjectType * GetUpperThresholdInput();

  virtual const InputPixelObjectType * GetUpperThresholdInput() const;

  virtual InputPixelType GetLowerThreshold() const;

  virtual InputPixelObjectType * GetLowerThresholdInput();

  virtual const InputPixelObjectType * GetLowerThresholdInput() const;

#ifdef ITK_USE_CONCEPT_CHECKING

  itkConceptMacro( OutputEqualityComparableCheck,
                   ( Concept::EqualityComparable< OutputPixelType > ) );
  itkConceptMacro( InputPixelTypeComparable,
                   ( Concept::Comparable< InputPixelType > ) );
  itkConceptMacro( InputOStreamWritableCheck,
                   ( Concept::OStreamWritable< InputPixelType > ) );
  itkConceptMacro( OutputOStreamWritableCheck,
                   ( Concept::OStreamWritable< OutputPixelType > ) );

#endif
protected:
  BinaryThresholdImageFilter();
  virtual ~BinaryThresholdImageFilter() {}
  void PrintSelf(std::ostream & os, Indent indent) const;

  virtual void BeforeThreadedGenerateData();

private:
  BinaryThresholdImageFilter(const Self &); //purposely not implemented
  void operator=(const Self &);             //purposely not implemented

  OutputPixelType m_InsideValue;
  OutputPixelType m_OutsideValue;
};
} // end namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkBinaryThresholdImageFilter.hxx"
#endif

#endif