#include <mitkMaskImageFilter.h>

Inheritance diagram for mitk::MaskImageFilter:

Collaboration diagram for mitk::MaskImageFilter:

Public Types
typedef MaskImageFilter	Self
typedef ImageToImageFilter	Superclass
typedef itk::SmartPointer< Self >	Pointer
typedef itk::SmartPointer < const Self >	ConstPointer
Public Member Functions
virtual const char *	GetClassName () const
void	SetMask (const mitk::Image *mask)
const mitk::Image *	GetMask () const
virtual mitk::ScalarType	GetMinValue ()
virtual void	SetMinValue (mitk::ScalarType _arg)
virtual mitk::ScalarType	GetMaxValue ()
virtual void	SetMaxValue (mitk::ScalarType _arg)
virtual void	SetOutsideValue (mitk::ScalarType _arg)
virtual mitk::ScalarType	GetOutsideValue ()
virtual void	SetOverrideOutsideValue (bool _arg)
virtual bool	GetOverrideOutsideValue ()
virtual void	OverrideOutsideValueOn ()
virtual void	OverrideOutsideValueOff ()
Static Public Member Functions
static Pointer	New ()
Protected Member Functions
	MaskImageFilter ()
	~MaskImageFilter ()
virtual void	GenerateInputRequestedRegion ()
virtual void	GenerateOutputInformation ()
virtual void	GenerateData ()
	A version of GenerateData() specific for image processing filters.
template<typename TPixel , unsigned int VImageDimension>
void	InternalComputeMask (itk::Image< TPixel, VImageDimension > *itkImage)
Protected Attributes
mitk::Image::Pointer	m_Mask
mitk::ImageTimeSelector::Pointer	m_InputTimeSelector
mitk::ImageTimeSelector::Pointer	m_MaskTimeSelector
mitk::ImageTimeSelector::Pointer	m_OutputTimeSelector
itk::TimeStamp	m_TimeOfHeaderInitialization
mitk::ScalarType	m_OutsideValue
mitk::ScalarType	m_MinValue
mitk::ScalarType	m_MaxValue
bool	m_OverrideOutsideValue

Detailed Description

Definition at line 34 of file mitkMaskImageFilter.h.

Member Typedef Documentation

typedef itk::SmartPointer<const Self> mitk::MaskImageFilter::ConstPointer

Definition at line 37 of file mitkMaskImageFilter.h.

typedef itk::SmartPointer<Self> mitk::MaskImageFilter::Pointer

Definition at line 37 of file mitkMaskImageFilter.h.

typedef MaskImageFilter mitk::MaskImageFilter::Self

Definition at line 37 of file mitkMaskImageFilter.h.

typedef ImageToImageFilter mitk::MaskImageFilter::Superclass

Definition at line 37 of file mitkMaskImageFilter.h.

Constructor & Destructor Documentation

mitk::MaskImageFilter::MaskImageFilter ( ) [protected]

Definition at line 30 of file mitkMaskImageFilter.cpp.

References m_InputTimeSelector, m_MaskTimeSelector, m_OutputTimeSelector, m_OutsideValue, m_OverrideOutsideValue, and New().

                                     : m_Mask(NULL)
{
  this->SetNumberOfInputs(2);
  this->SetNumberOfRequiredInputs(2);
  m_InputTimeSelector  = mitk::ImageTimeSelector::New();
  m_MaskTimeSelector   = mitk::ImageTimeSelector::New();
  m_OutputTimeSelector = mitk::ImageTimeSelector::New();
  m_OverrideOutsideValue = false;
  m_OutsideValue = 0;
}

mitk::MaskImageFilter::~MaskImageFilter ( ) [protected]

Definition at line 41 of file mitkMaskImageFilter.cpp.

{

}

Member Function Documentation

void mitk::MaskImageFilter::GenerateData ( ) [protected, virtual]

A version of GenerateData() specific for image processing filters.

This implementation will split the processing across multiple threads. The buffer is allocated by this method. Then the BeforeThreadedGenerateData() method is called (if provided). Then, a series of threads are spawned each calling ThreadedGenerateData(). After all the threads have completed processing, the AfterThreadedGenerateData() method is called (if provided). If an image processing filter cannot be threaded, the filter should provide an implementation of GenerateData(). That implementation is responsible for allocating the output buffer. If a filter an be threaded, it should NOT provide a GenerateData() method but should provide a ThreadedGenerateData() instead.

See also:: ThreadedGenerateData()

Reimplemented from mitk::ImageSource.

Definition at line 142 of file mitkMaskImageFilter.cpp.

References AccessByItk, mitk::TimeSlicedGeometry::MSToTimeStep(), QuadProgPP::t(), and mitk::TimeSlicedGeometry::TimeStepToMS().

{
  mitk::Image::ConstPointer input = this->GetInput();
  mitk::Image::Pointer mask  = m_Mask;
  mitk::Image::Pointer output = this->GetOutput();

  if((output->IsInitialized()==false) || (mask.IsNull()) || (mask->GetTimeSlicedGeometry()->GetTimeSteps() == 0))
    return;

  m_InputTimeSelector->SetInput(input);
  m_MaskTimeSelector->SetInput(mask);
  m_OutputTimeSelector->SetInput(this->GetOutput());

  mitk::Image::RegionType outputRegion = output->GetRequestedRegion();
  const mitk::TimeSlicedGeometry *outputTimeGeometry = output->GetTimeSlicedGeometry();
  const mitk::TimeSlicedGeometry *inputTimeGeometry = input->GetTimeSlicedGeometry();
  const mitk::TimeSlicedGeometry *maskTimeGeometry = mask->GetTimeSlicedGeometry();
  ScalarType timeInMS;

  int timestep=0;
  int tstart=outputRegion.GetIndex(3);
  int tmax=tstart+outputRegion.GetSize(3);

  int t;
  for(t=tstart;t<tmax;++t)
  {
    timeInMS = outputTimeGeometry->TimeStepToMS( t );

    timestep = inputTimeGeometry->MSToTimeStep( timeInMS );

    m_InputTimeSelector->SetTimeNr(timestep);
    m_InputTimeSelector->UpdateLargestPossibleRegion();
    m_OutputTimeSelector->SetTimeNr(t);
    m_OutputTimeSelector->UpdateLargestPossibleRegion();

    timestep = maskTimeGeometry->MSToTimeStep( timeInMS );
    m_MaskTimeSelector->SetTimeNr(timestep);
    m_MaskTimeSelector->UpdateLargestPossibleRegion();

    AccessByItk(m_InputTimeSelector->GetOutput(),InternalComputeMask);
  }

  m_TimeOfHeaderInitialization.Modified();
}

void mitk::MaskImageFilter::GenerateInputRequestedRegion ( ) [protected, virtual]

What is the input requested region that is required to produce the output requested region? The base assumption for image processing filters is that the input requested region can be set to match the output requested region. If a filter requires more input (for instance a filter that uses neighborhoods needs more input than output to avoid introducing artificial boundary conditions) or less input (for instance a magnify filter) will have to override this method. In doing so, it should call its superclass' implementation as its first step. Note that this imaging filters operate differently than the classes to this point in the class hierachy. Up till now, the base assumption has been that the largest possible region will be requested of the input.

See also:: ProcessObject::GenerateInputRequestedRegion(), ImageSource::GenerateInputRequestedRegion()

Reimplemented from mitk::ImageToImageFilter.

Definition at line 58 of file mitkMaskImageFilter.cpp.

References mitk::GenerateTimeInInputRegion(), mitk::BaseData::GetTimeSlicedGeometry(), mitk::TimeSlicedGeometry::GetTimeSteps(), mitk::BaseData::IsInitialized(), and mitk::SlicedData::SetRequestedRegionToLargestPossibleRegion().

{
  Superclass::GenerateInputRequestedRegion();

  mitk::Image* output = this->GetOutput();
  mitk::Image* input = const_cast< mitk::Image * > ( this->GetInput() );
  mitk::Image* mask  = m_Mask ;
  if((output->IsInitialized()==false) || (mask == NULL) || (mask->GetTimeSlicedGeometry()->GetTimeSteps() == 0))
    return;

  input->SetRequestedRegionToLargestPossibleRegion();
  mask->SetRequestedRegionToLargestPossibleRegion();

  GenerateTimeInInputRegion(output, input);
  GenerateTimeInInputRegion(output, mask);
}

void mitk::MaskImageFilter::GenerateOutputInformation ( void ) [protected, virtual]

Definition at line 75 of file mitkMaskImageFilter.cpp.

{
  mitk::Image::ConstPointer input = this->GetInput();
  mitk::Image::Pointer output = this->GetOutput();

  if ((output->IsInitialized()) && (this->GetMTime() <= m_TimeOfHeaderInitialization.GetMTime()))
    return;

  itkDebugMacro(<<"GenerateOutputInformation()");

  output->Initialize(input->GetPixelType(), *input->GetTimeSlicedGeometry());

  output->SetPropertyList(input->GetPropertyList()->Clone());    

  m_TimeOfHeaderInitialization.Modified();
}

virtual const char* mitk::MaskImageFilter::GetClassName ( ) const [virtual]

const mitk::Image * mitk::MaskImageFilter::GetMask ( ) const

Definition at line 53 of file mitkMaskImageFilter.cpp.

{
  return m_Mask;
}

virtual mitk::ScalarType mitk::MaskImageFilter::GetMaxValue ( ) [virtual]

get/set the max Value of the original image in the masked area

virtual mitk::ScalarType mitk::MaskImageFilter::GetMinValue ( ) [virtual]

get/set the min Value of the original image in the masked area

virtual mitk::ScalarType mitk::MaskImageFilter::GetOutsideValue ( ) [virtual]

This value is used as outside value. This only works if OverrideOutsideValue is set to true. Default is 0.

virtual bool mitk::MaskImageFilter::GetOverrideOutsideValue ( ) [virtual]

If OverrideOutsideValue is set to false, this minimum of the pixel type of the output image is taken as outside value. If set to true, the value set via SetOutsideValue is used as background.

template<typename TPixel , unsigned int VImageDimension>

void mitk::MaskImageFilter::InternalComputeMask ( itk::Image< TPixel, VImageDimension > * itkImage ) [protected]

Definition at line 93 of file mitkMaskImageFilter.cpp.

References QuadProgPP::max(), min, and mitk::ImageToItk< TOutputImage >::SetInput().

{
  typedef itk::Image<TPixel, VImageDimension> ItkInputImageType;
  typedef itk::Image<unsigned char, VImageDimension> ItkMaskImageType;
  typedef itk::Image<TPixel, VImageDimension> ItkOutputImageType;
  
  typedef itk::ImageRegionConstIterator< ItkInputImageType > ItkInputImageIteratorType;
  typedef itk::ImageRegionConstIterator< ItkMaskImageType > ItkMaskImageIteratorType;
  typedef itk::ImageRegionIteratorWithIndex< ItkOutputImageType > ItkOutputImageIteratorType;

  typename mitk::ImageToItk<ItkMaskImageType>::Pointer maskimagetoitk = mitk::ImageToItk<ItkMaskImageType>::New();
  maskimagetoitk->SetInput(m_MaskTimeSelector->GetOutput());
  maskimagetoitk->Update();
  typename ItkMaskImageType::Pointer maskItkImage = maskimagetoitk->GetOutput();

  typename mitk::ImageToItk<ItkOutputImageType>::Pointer outputimagetoitk = mitk::ImageToItk<ItkOutputImageType>::New();
  outputimagetoitk->SetInput(m_OutputTimeSelector->GetOutput());
  outputimagetoitk->Update();
  typename ItkOutputImageType::Pointer outputItkImage = outputimagetoitk->GetOutput();

  // create the iterators
  typename ItkInputImageType::RegionType inputRegionOfInterest = inputItkImage->GetLargestPossibleRegion();
  ItkInputImageIteratorType  inputIt( inputItkImage, inputRegionOfInterest );
  ItkMaskImageIteratorType  maskIt ( maskItkImage, inputRegionOfInterest );
  ItkOutputImageIteratorType outputIt( outputItkImage, inputRegionOfInterest );

  typename ItkOutputImageType::PixelType outsideValue = itk::NumericTraits<typename ItkOutputImageType::PixelType>::min();
  if ( m_OverrideOutsideValue )
    outsideValue = static_cast<typename ItkOutputImageType::PixelType>( m_OutsideValue );

  m_MinValue = (itk::NumericTraits<typename ItkOutputImageType::PixelType>::max());
  m_MaxValue = (itk::NumericTraits<typename ItkOutputImageType::PixelType>::min());


  for ( inputIt.GoToBegin(), maskIt.GoToBegin(), outputIt.GoToBegin(); !inputIt.IsAtEnd() && !maskIt.IsAtEnd(); ++inputIt, ++maskIt, ++outputIt)
  {
    if ( maskIt.Get() > itk::NumericTraits<typename ItkMaskImageType::PixelType>::Zero )
    {
      outputIt.Set(inputIt.Get());
      m_MinValue = vnl_math_min((float)inputIt.Get(), (float)m_MinValue);
      m_MaxValue = vnl_math_max((float)inputIt.Get(), (float)m_MaxValue);
    }
    else
    {
      outputIt.Set(outsideValue);
    }
  }
}

static Pointer mitk::MaskImageFilter::New ( ) [static]

Method for creation through the object factory.

Reimplemented from mitk::ImageToImageFilter.

Referenced by MaskImageFilter().

virtual void mitk::MaskImageFilter::OverrideOutsideValueOff ( ) [virtual]

virtual void mitk::MaskImageFilter::OverrideOutsideValueOn ( ) [virtual]

void mitk::MaskImageFilter::SetMask ( const mitk::Image * mask )

Definition at line 46 of file mitkMaskImageFilter.cpp.

{
  // Process object is not const-correct so the const_cast is required here
  m_Mask = const_cast< mitk::Image * >( mask );
  this->ProcessObject::SetNthInput(1, m_Mask );
}

virtual void mitk::MaskImageFilter::SetMaxValue ( mitk::ScalarType _arg ) [virtual]

virtual void mitk::MaskImageFilter::SetMinValue ( mitk::ScalarType _arg ) [virtual]

virtual void mitk::MaskImageFilter::SetOutsideValue ( mitk::ScalarType _arg ) [virtual]

This value is used as outside value. This only works if OverrideOutsideValue is set to true. Default is 0.

virtual void mitk::MaskImageFilter::SetOverrideOutsideValue ( bool _arg ) [virtual]

If OverrideOutsideValue is set to false, this minimum of the pixel type of the output image is taken as outside value. If set to true, the value set via SetOutsideValue is used as background.