itkBinaryThresholdSurfaceVoxelImageFunction.h

Go to the documentation of this file.

/*=============================================================================

  NifTK: A software platform for medical image computing.

  Copyright (c) University College London (UCL). All rights reserved.

  This software is distributed WITHOUT ANY WARRANTY; without even
  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  PURPOSE.

  See LICENSE.txt in the top level directory for details.

=============================================================================*/

#ifndef itkBinaryThresholdSurfaceVoxelImageFunction_h
#define itkBinaryThresholdSurfaceVoxelImageFunction_h

#include <itkImageFunction.h>

namespace itk
{

template <class TInputImage, class TCoordRep = float>
class ITK_EXPORT BinaryThresholdSurfaceVoxelImageFunction : 
  public ImageFunction<TInputImage,bool,TCoordRep> 
{
public:
  typedef BinaryThresholdSurfaceVoxelImageFunction              Self;
  typedef ImageFunction<TInputImage,bool,TCoordRep> Superclass;
  typedef SmartPointer<Self>                        Pointer;
  typedef SmartPointer<const Self>                  ConstPointer;
  
  itkTypeMacro(BinaryThresholdSurfaceVoxelImageFunction, ImageFunction);

  itkNewMacro(Self);

  typedef typename Superclass::InputImageType InputImageType;
  
  typedef typename TInputImage::PixelType PixelType;

  itkStaticConstMacro(ImageDimension, unsigned int,Superclass::ImageDimension);

  typedef typename Superclass::PointType PointType;

  typedef typename Superclass::IndexType IndexType;

  typedef typename InputImageType::RegionType RegionType;

  typedef typename Superclass::ContinuousIndexType ContinuousIndexType;

  virtual bool Evaluate( const PointType& point ) const
    {
    IndexType index;
    this->ConvertPointToNearestIndex( point, index );
    return ( this->EvaluateAtIndex( index ) );
    }

  virtual bool EvaluateAtContinuousIndex( 
    const ContinuousIndexType & index ) const
    {
    IndexType nindex;

    this->ConvertContinuousIndexToNearestIndex (index, nindex);
    return this->EvaluateAtIndex(nindex);
    }

  virtual bool EvaluateAtIndex( const IndexType & index ) const
    {
      PixelType value = this->GetInputImage()->GetPixel(index);

      RegionType region = this->GetInputImage()->GetBufferedRegion();
      if ( m_Lower <= value && value <= m_Upper) {
  
  IndexType indexAbove = index;
  indexAbove[1]--;

  if ( region.IsInside( indexAbove ) ) {
    PixelType valueAbove = this->GetInputImage()->GetPixel(indexAbove);
        
    if ( ! ( m_Lower <= valueAbove && valueAbove <= m_Upper ) )
      return true;
  }
#if 0   
  int i;
  for (i=-1; i<=1; i+=2) {
    indexAbove = index;
    indexAbove[0] = index[0] + i;
    indexAbove[1]--;

    if ( region.IsInside( indexAbove ) ) {
      PixelType valueAbove = this->GetInputImage()->GetPixel(indexAbove);
        
      if ( ! ( m_Lower <= valueAbove && valueAbove <= m_Upper ) )
        return true;
    }
  }
  
  for (i=-1; i<=1; i+=2) {
    indexAbove = index;
    indexAbove[1]--;
    indexAbove[2] = index[2] + i;

    if ( region.IsInside( indexAbove ) ) {
      PixelType valueAbove = this->GetInputImage()->GetPixel(indexAbove);
        
      if ( ! ( m_Lower <= valueAbove && valueAbove <= m_Upper ) )
        return true;
    }
  }
#endif
      }
      return false;
    }

  itkGetConstReferenceMacro(Lower,PixelType);

  itkGetConstReferenceMacro(Upper,PixelType);

  void ThresholdAbove(PixelType thresh);
  
  void ThresholdBelow(PixelType thresh);

  void ThresholdBetween(PixelType lower, PixelType upper);

protected:
  BinaryThresholdSurfaceVoxelImageFunction();
  ~BinaryThresholdSurfaceVoxelImageFunction(){};
  void PrintSelf(std::ostream& os, Indent indent) const;

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

  PixelType m_Lower;
  PixelType m_Upper;
};

} // end namespace itk


// Define instantiation macro for this template.
#define ITK_TEMPLATE_BinaryThresholdSurfaceVoxelImageFunction(_, EXPORT, x, y) namespace itk { \
  _(2(class EXPORT BinaryThresholdSurfaceVoxelImageFunction< ITK_TEMPLATE_2 x >)) \
  namespace Templates { typedef BinaryThresholdSurfaceVoxelImageFunction< ITK_TEMPLATE_2 x > \
                               BinaryThresholdSurfaceVoxelImageFunction##y; } \
  }

#if ITK_TEMPLATE_EXPLICIT
# include "Templates/itkBinaryThresholdSurfaceVoxelImageFunction+-.h"
#endif

#if ITK_TEMPLATE_TXX
# include "itkBinaryThresholdSurfaceVoxelImageFunction.txx"
#endif

#endif