Applies difference images to 3D images. More...

#include <mitkDiffImageApplier.h>

Inheritance diagram for mitk::DiffImageApplier:

Collaboration diagram for mitk::DiffImageApplier:

Public Types
typedef DiffImageApplier	Self
typedef Object	Superclass
typedef itk::SmartPointer< Self >	Pointer
typedef itk::SmartPointer < const Self >	ConstPointer
Public Member Functions
virtual const char *	GetClassName () const
virtual void	ExecuteOperation (Operation *operation)
Static Public Member Functions
static Pointer	New ()
static DiffImageApplier *	GetInstanceForUndo ()
Protected Member Functions
	DiffImageApplier ()
virtual	~DiffImageApplier ()
template<typename TPixel , unsigned int VImageDimension>
void	ItkImageSwitch2DDiff (itk::Image< TPixel, VImageDimension > *image)
template<typename TPixel , unsigned int VImageDimension>
void	ItkImageSwitch3DDiff (itk::Image< TPixel, VImageDimension > *image)
template<typename TPixel1 , unsigned int VImageDimension1, typename TPixel2 , unsigned int VImageDimension2>
void	ItkImageProcessing2DDiff (itk::Image< TPixel1, VImageDimension1 > itkImage1, itk::Image< TPixel2, VImageDimension2 > itkImage2)
template<typename TPixel1 , unsigned int VImageDimension1, typename TPixel2 , unsigned int VImageDimension2>
void	ItkImageProcessing3DDiff (itk::Image< TPixel1, VImageDimension1 > itkImage1, itk::Image< TPixel2, VImageDimension2 > itkImage2)
template<typename TPixel , unsigned int VImageDimension>
void	ItkInvertPixelValues (itk::Image< TPixel, VImageDimension > *itkImage)
Protected Attributes
Image::Pointer	m_Image
Image::ConstPointer	m_SliceDifferenceImage
unsigned int	m_SliceIndex
unsigned int	m_SliceDimension
unsigned int	m_TimeStep
unsigned int	m_Dimension0
unsigned int	m_Dimension1
double	m_Factor

Detailed Description

Applies difference images to 3D images.

This class is supposed to execute ApplyDiffImageOperations, which contain information about pixel changes within one image slice. Class should be called from the undo stack. At the moment, ApplyDiffImageOperations are only created by OverwriteSliceImageFilter.

Author:: maleike

Definition at line 40 of file mitkDiffImageApplier.h.

Member Typedef Documentation

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

Definition at line 44 of file mitkDiffImageApplier.h.

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

Definition at line 44 of file mitkDiffImageApplier.h.

typedef DiffImageApplier mitk::DiffImageApplier::Self

Definition at line 44 of file mitkDiffImageApplier.h.

typedef Object mitk::DiffImageApplier::Superclass

Definition at line 44 of file mitkDiffImageApplier.h.

Constructor & Destructor Documentation

mitk::DiffImageApplier::DiffImageApplier ( ) [protected]

Definition at line 29 of file mitkDiffImageApplier.cpp.

{
}

mitk::DiffImageApplier::~DiffImageApplier ( ) [protected, virtual]

Definition at line 33 of file mitkDiffImageApplier.cpp.

{
}

Member Function Documentation

void mitk::DiffImageApplier::ExecuteOperation ( Operation * operation ) [virtual]

Implements mitk::OperationActor.

Definition at line 37 of file mitkDiffImageApplier.cpp.

References AccessFixedDimensionByItk, mitk::SegmentationInterpolationController::BlockModified(), mitk::ApplyDiffImageOperation::GetDiffImage(), mitk::ApplyDiffImageOperation::GetFactor(), mitk::ApplyDiffImageOperation::GetImage(), mitk::RenderingManager::GetInstance(), mitk::ApplyDiffImageOperation::GetSliceDimension(), mitk::ApplyDiffImageOperation::GetSliceIndex(), mitk::ApplyDiffImageOperation::GetTimeStep(), mitk::SegmentationInterpolationController::InterpolatorForImage(), mitk::ApplyDiffImageOperation::IsImageStillValid(), mitk::ImageTimeSelector::New(), mitk::RenderingManager::RequestUpdateAll(), mitk::SegmentationInterpolationController::SetChangedSlice(), and mitk::SegmentationInterpolationController::SetChangedVolume().

{
  ApplyDiffImageOperation* imageOperation = dynamic_cast<ApplyDiffImageOperation*>( operation );
  if (    imageOperation                        // we actually have the kind of operation that we can handle
       && imageOperation->IsImageStillValid() ) // AND the image is not yet deleted
  {
    m_Image = imageOperation->GetImage();
    Image::Pointer image3D = m_Image; // will be changed later in case of 3D+t

    m_SliceDifferenceImage = imageOperation->GetDiffImage();
    m_TimeStep = imageOperation->GetTimeStep();

    m_Factor = imageOperation->GetFactor();

    if ( m_SliceDifferenceImage->GetDimension() == 2 )
    {
      m_SliceIndex = imageOperation->GetSliceIndex();
      m_SliceDimension = imageOperation->GetSliceDimension();
      switch (m_SliceDimension)
      {
        default:
        case 2:
          m_Dimension0 = 0;
          m_Dimension1 = 1;
          break;
        case 1:
          m_Dimension0 = 0;
          m_Dimension1 = 2;
          break;
        case 0:
          m_Dimension0 = 1;
          m_Dimension1 = 2;
          break;
      }

      if ( m_SliceDifferenceImage->GetDimension() != 2 || (m_Image->GetDimension() < 3 || m_Image->GetDimension() > 4) ||
           m_SliceDifferenceImage->GetDimension(0) != m_Image->GetDimension(m_Dimension0) ||
           m_SliceDifferenceImage->GetDimension(1) != m_Image->GetDimension(m_Dimension1) ||
           m_SliceIndex >= m_Image->GetDimension(m_SliceDimension)
         )
      {
       itkExceptionMacro("Slice and image dimensions differ or slice index is too large. Sorry, cannot work like this.");
       return;
      }

      if ( m_Image->GetDimension() == 4 )
      {
        ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
        timeSelector->SetInput( m_Image );
        timeSelector->SetTimeNr( m_TimeStep );
        timeSelector->UpdateLargestPossibleRegion();
        image3D = timeSelector->GetOutput();
      }

       // this will do a long long if/else to find out both pixel types
      AccessFixedDimensionByItk( image3D, ItkImageSwitch2DDiff, 3 );

      if ( m_Factor == 1 || m_Factor == -1 )
      {
        if ( m_Factor == -1 )
        {
          // multiply diff pixels by factor and then send this diff slice
          AccessFixedDimensionByItk( m_SliceDifferenceImage, ItkInvertPixelValues, 2 );
        }

        // just send the diff to SegmentationInterpolationController
        SegmentationInterpolationController* interpolator = SegmentationInterpolationController::InterpolatorForImage( m_Image );
        if (interpolator)
        {
          interpolator->BlockModified(true);
          interpolator->SetChangedSlice( m_SliceDifferenceImage, m_SliceDimension, m_SliceIndex, m_TimeStep );
        }
        
        m_Image->Modified();

        if (interpolator)
        {
          interpolator->BlockModified(false);
        }

        if ( m_Factor == -1 ) // return to normal values
        {
          AccessFixedDimensionByItk( m_SliceDifferenceImage, ItkInvertPixelValues, 2 );
        }
      }
      else // no trivial case, too lazy to do something else
      {
        m_Image->Modified(); // check if interpolation is called. prefer to send diff directly
      }

      RenderingManager::GetInstance()->RequestUpdateAll();
    }
    else if ( m_SliceDifferenceImage->GetDimension() == 3 )
    { 
      // ...
      if (  m_SliceDifferenceImage->GetDimension(0) != m_Image->GetDimension(0) ||
            m_SliceDifferenceImage->GetDimension(1) != m_Image->GetDimension(1) ||
            m_SliceDifferenceImage->GetDimension(2) != m_Image->GetDimension(2) ||
            m_TimeStep >= m_Image->GetDimension(3)
         )
        {
         itkExceptionMacro("Diff image size differs from original image size. Sorry, cannot work like this.");
         return;
        }

      if ( m_Image->GetDimension() == 4 )
      {
        ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
        timeSelector->SetInput( m_Image );
        timeSelector->SetTimeNr( m_TimeStep );
        timeSelector->UpdateLargestPossibleRegion();
        image3D = timeSelector->GetOutput();
      }

      // this will do a long long if/else to find out both pixel types
      AccessFixedDimensionByItk( image3D, ItkImageSwitch3DDiff, 3 );

      if ( m_Factor == 1 || m_Factor == -1 )
      {
        if ( m_Factor == -1 )
        {
          // multiply diff pixels by factor and then send this diff slice
          AccessFixedDimensionByItk( m_SliceDifferenceImage, ItkInvertPixelValues, 3 );
        }

        // just send the diff to SegmentationInterpolationController
        SegmentationInterpolationController* interpolator = SegmentationInterpolationController::InterpolatorForImage( m_Image );
        if (interpolator)
        {
          interpolator->BlockModified(true);
          interpolator->SetChangedVolume( m_SliceDifferenceImage, m_TimeStep );
        }

        m_Image->Modified();

        if (interpolator)
        {
          interpolator->BlockModified(false);
        }

        if ( m_Factor == -1 ) // return to normal values
        {
          AccessFixedDimensionByItk( m_SliceDifferenceImage, ItkInvertPixelValues, 3 );
        }
      }
      else // no trivial case, too lazy to do something else
      {
        m_Image->Modified(); // check if interpolation is called. prefer to send diff directly
      }
      
      RenderingManager::GetInstance()->RequestUpdateAll();
    }
    else
    {
     itkExceptionMacro("Diff image must be 2D or 3D. Sorry, cannot work like this.");
     return;
    }
  }

  m_Image = NULL;
  m_SliceDifferenceImage = NULL;
}

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

mitk::DiffImageApplier * mitk::DiffImageApplier::GetInstanceForUndo ( ) [static]

Definition at line 200 of file mitkDiffImageApplier.cpp.

References New().

Referenced by QmitkSlicesInterpolator::AcceptAllInterpolations(), and mitk::OverwriteSliceImageFilter::GenerateData().

{
  static DiffImageApplier::Pointer s_Instance = DiffImageApplier::New();

  return s_Instance;
}

template<typename TPixel1 , unsigned int VImageDimension1, typename TPixel2 , unsigned int VImageDimension2>

void mitk::DiffImageApplier::ItkImageProcessing2DDiff	(	itk::Image< TPixel1, VImageDimension1 > *	itkImage1,
		itk::Image< TPixel2, VImageDimension2 > *	itkImage2
	)		`[protected]`

Definition at line 250 of file mitkDiffImageApplier.cpp.

{
  typedef itk::Image<TPixel1, VImageDimension1> DiffImageType;
  typedef itk::Image<TPixel2, VImageDimension2> VolumeImageType;

  typedef itk::ImageSliceIteratorWithIndex< VolumeImageType > OutputSliceIteratorType;
  typedef itk::ImageRegionConstIterator< DiffImageType >      DiffSliceIteratorType;

  typename VolumeImageType::RegionType            sliceInVolumeRegion;

  sliceInVolumeRegion = outputImage->GetLargestPossibleRegion();
  sliceInVolumeRegion.SetSize( m_SliceDimension, 1 );             // just one slice
  sliceInVolumeRegion.SetIndex( m_SliceDimension, m_SliceIndex ); // exactly this slice, please
  
  OutputSliceIteratorType outputIterator( outputImage, sliceInVolumeRegion );
  outputIterator.SetFirstDirection(m_Dimension0);
  outputIterator.SetSecondDirection(m_Dimension1);

  DiffSliceIteratorType diffIterator( diffImage, diffImage->GetLargestPossibleRegion() );

  // iterate over output slice (and over input slice simultaneously)
  outputIterator.GoToBegin();
  diffIterator.GoToBegin();
  while ( !outputIterator.IsAtEnd() )
  {
    while ( !outputIterator.IsAtEndOfSlice() )
    {
      while ( !outputIterator.IsAtEndOfLine() )
      {
        TPixel2 newValue = outputIterator.Get() + (TPixel2) ((double)diffIterator.Get() * m_Factor);
        outputIterator.Set( newValue );
        ++outputIterator; 
        ++diffIterator; 
      }
      outputIterator.NextLine();
    }
    outputIterator.NextSlice();
  }
}

template<typename TPixel1 , unsigned int VImageDimension1, typename TPixel2 , unsigned int VImageDimension2>

void mitk::DiffImageApplier::ItkImageProcessing3DDiff	(	itk::Image< TPixel1, VImageDimension1 > *	itkImage1,
		itk::Image< TPixel2, VImageDimension2 > *	itkImage2
	)		`[protected]`

Definition at line 292 of file mitkDiffImageApplier.cpp.

{
  typedef itk::Image<TPixel1, VImageDimension1> DiffImageType;
  typedef itk::Image<TPixel2, VImageDimension2> VolumeImageType;

  typedef itk::ImageRegionIterator< VolumeImageType >      OutputSliceIteratorType;
  typedef itk::ImageRegionConstIterator< DiffImageType >   DiffSliceIteratorType;

  OutputSliceIteratorType outputIterator( outputImage, outputImage->GetLargestPossibleRegion() );
  DiffSliceIteratorType diffIterator( diffImage, diffImage->GetLargestPossibleRegion() );

  // iterate over output slice (and over input slice simultaneously)
  outputIterator.GoToBegin();
  diffIterator.GoToBegin();
  while ( !outputIterator.IsAtEnd() )
  {
    TPixel2 newValue = outputIterator.Get() + (TPixel2) ((double)diffIterator.Get() * m_Factor);
    outputIterator.Set( newValue );
    ++outputIterator; 
    ++diffIterator; 
  }
}

template<typename TPixel , unsigned int VImageDimension>

void mitk::DiffImageApplier::ItkImageSwitch2DDiff ( itk::Image< TPixel, VImageDimension > * image ) [protected]

Definition at line 233 of file mitkDiffImageApplier.cpp.

References myMITKDiffImageApplierFilterAccessAllTypesByItk.

{
  const std::type_info& typeId=*(m_SliceDifferenceImage->GetPixelType().GetTypeId());

  myMITKDiffImageApplierFilterAccessAllTypesByItk( m_SliceDifferenceImage, ItkImageProcessing2DDiff, 2, itkImage );
}

template<typename TPixel , unsigned int VImageDimension>

void mitk::DiffImageApplier::ItkImageSwitch3DDiff ( itk::Image< TPixel, VImageDimension > * image ) [protected]

Definition at line 242 of file mitkDiffImageApplier.cpp.

References myMITKDiffImageApplierFilterAccessAllTypesByItk.

{
  const std::type_info& typeId=*(m_SliceDifferenceImage->GetPixelType().GetTypeId());

  myMITKDiffImageApplierFilterAccessAllTypesByItk( m_SliceDifferenceImage, ItkImageProcessing3DDiff, 3, itkImage );
}

template<typename TPixel , unsigned int VImageDimension>

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

Definition at line 316 of file mitkDiffImageApplier.cpp.

{
  typedef itk::ImageRegionIterator< itk::Image<TPixel,VImageDimension> >      IteratorType;
  IteratorType iter( itkImage, itkImage->GetLargestPossibleRegion() );

  iter.GoToBegin();
  while ( !iter.IsAtEnd() )
  {
    iter.Set( -( iter.Get() ) );
    ++iter;
  }
}

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

Referenced by GetInstanceForUndo().