itkQBallToRgbImageFilter.h

Go to the documentation of this file.

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

The Medical Imaging Interaction Toolkit (MITK)

Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
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 or http://www.mitk.org for details.

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

#ifndef __itkQBallToRgbImageFilter_h
#define __itkQBallToRgbImageFilter_h

#include "itkUnaryFunctorImageFilter.h"
#include "itkOrientationDistributionFunction.h"
#include "itkRGBAPixel.h"
#include "itkImageRegionConstIterator.h"
#include "itkImageRegionIterator.h"

namespace itk
{

  #define __IMG_DAT_ITEM__CEIL_ZERO_ONE__(val) (val) =       \
  ( (val) < 0 ) ? ( 0 ) : ( ( (val)>1 ) ? ( 1 ) : ( (val) ) );


template <typename TInputImage,
typename TOutputImage=itk::Image<itk::RGBAPixel<unsigned char>,3> >
                      class QBallToRgbImageFilter :
                      public ImageToImageFilter<TInputImage,TOutputImage>
                      {
                      public:
  typedef QBallToRgbImageFilter  Self;
  typedef ImageToImageFilter<TInputImage,TOutputImage>
      Superclass;
  typedef SmartPointer<Self>                     Pointer;
  typedef SmartPointer<const Self>               ConstPointer;

  typedef typename Superclass::InputImageType    InputImageType;
  typedef typename Superclass::OutputImageType    OutputImageType;
  typedef typename OutputImageType::PixelType     OutputPixelType;
  typedef typename TInputImage::PixelType         InputPixelType;
  typedef typename InputPixelType::ValueType      InputValueType;

  itkTypeMacro( QBallToRgbImageFilter, ImageToImageFilter )

  
  itkFactorylessNewMacro(Self)
  itkCloneMacro(Self)

  void PrintSelf(std::ostream& os, Indent indent) const
  { this->Superclass::PrintSelf( os, indent ); }

#ifdef ITK_USE_CONCEPT_CHECKING

  itkConceptMacro(InputHasNumericTraitsCheck,
                  (Concept::HasNumericTraits<InputValueType>));
#endif

protected:
  QBallToRgbImageFilter(){}
  virtual ~QBallToRgbImageFilter(){}

  void GenerateData()
  {

    typename InputImageType::Pointer qballImage = static_cast< InputImageType * >( this->ProcessObject::GetInput(0) );

    typename OutputImageType::Pointer outputImage =
        static_cast< OutputImageType * >(this->ProcessObject::GetPrimaryOutput());

    typename InputImageType::RegionType region = qballImage->GetLargestPossibleRegion();

    outputImage->SetSpacing( qballImage->GetSpacing() );   // Set the image spacing
    outputImage->SetOrigin( qballImage->GetOrigin() );     // Set the image origin
    outputImage->SetDirection( qballImage->GetDirection() );  // Set the image direction
    outputImage->SetRegions( qballImage->GetLargestPossibleRegion());
    outputImage->Allocate();

    typedef ImageRegionConstIterator< InputImageType > QBallImageIteratorType;
    QBallImageIteratorType qballIt(qballImage, qballImage->GetLargestPossibleRegion());

    typedef ImageRegionIterator< OutputImageType > OutputImageIteratorType;
    OutputImageIteratorType outputIt(outputImage, outputImage->GetLargestPossibleRegion());

    qballIt.GoToBegin();
    outputIt.GoToBegin();

    while(!qballIt.IsAtEnd() && !outputIt.IsAtEnd()){

      InputPixelType x = qballIt.Get();
      typedef itk::OrientationDistributionFunction<float,QBALL_ODFSIZE> OdfType;
      OdfType odf(x.GetDataPointer());

      int pd = odf.GetPrincipleDiffusionDirection();
      if (pd==-1)
        MITK_ERROR << "ODF corrupted: GetPrincipleDiffusionDirection returned -1";

      vnl_vector_fixed<double,3> dir = OdfType::GetDirection(pd);

      const float fa = odf.GetGeneralizedFractionalAnisotropy();
      float r = fabs(dir[0]) * fa;
      float g = fabs(dir[1]) * fa;
      float b = fabs(dir[2]) * fa;
//      float a = (fa-(m_OpacLevel-m_OpacWindow/2.0f))/m_OpacWindow;
      float a = fa;

      __IMG_DAT_ITEM__CEIL_ZERO_ONE__(r);
      __IMG_DAT_ITEM__CEIL_ZERO_ONE__(g);
      __IMG_DAT_ITEM__CEIL_ZERO_ONE__(b);
      __IMG_DAT_ITEM__CEIL_ZERO_ONE__(a);

      OutputPixelType out;
      out.SetRed(   r * 255.0f);
      out.SetGreen( g * 255.0f);
      out.SetBlue(  b * 255.0f);
      out.SetAlpha( a * 255.0f);

      outputIt.Set(out);

      ++qballIt;
      ++outputIt;
    }

  }

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

} // end namespace itk

#endif