diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkDiffusionMultiShellQballReconstructionImageFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkDiffusionMultiShellQballReconstructionImageFilter.h
index 6e7bccd182..f1e55fa6ac 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkDiffusionMultiShellQballReconstructionImageFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/itkDiffusionMultiShellQballReconstructionImageFilter.h
@@ -1,220 +1,220 @@
 /*===================================================================
 
 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 __itkDiffusionMultiShellQballReconstructionImageFilter_h_
 #define __itkDiffusionMultiShellQballReconstructionImageFilter_h_
 
 #include <itkImageToImageFilter.h>
 
 namespace itk{
 /** \class DiffusionMultiShellQballReconstructionImageFilter
     I. Aganj, C. Lenglet, G. Sapiro, E. Yacoub, K. Ugurbil, and N. Harel, “Reconstruction of the orientation distribution function in single and multiple shell q-ball imaging within constant solid angle,” Magnetic Resonance in Medicine, vol. 64, no. 2, pp. 554–566, 2010.
  */
 
 template< class TReferenceImagePixelType, class TGradientImagePixelType, class TOdfPixelType, int NOrderL, int NrOdfDirections>
 class DiffusionMultiShellQballReconstructionImageFilter : public ImageToImageFilter< Image< TReferenceImagePixelType, 3 >, Image< Vector< TOdfPixelType, NrOdfDirections >, 3 > >
 {
 
 public:
 
     typedef DiffusionMultiShellQballReconstructionImageFilter Self;
     typedef SmartPointer<Self>                      Pointer;
     typedef SmartPointer<const Self>                ConstPointer;
     typedef ImageToImageFilter< Image< TReferenceImagePixelType, 3>, Image< Vector< TOdfPixelType, NrOdfDirections >, 3 > > Superclass;
     typedef typename Superclass::OutputImageRegionType OutputImageRegionType;
 
     typedef TReferenceImagePixelType                  ReferencePixelType;
 
     /** GradientImageType
     * (e.g. type short)*/
     typedef TGradientImagePixelType                   GradientPixelType;
 
     /** GradientImageType
     * 3D VectorImage containing GradientPixelTypes */
 
     typedef VectorImage< GradientPixelType, 3 >       GradientImagesType;
 
     /** ODF PixelType */
     typedef Vector< TOdfPixelType, NrOdfDirections >  OdfPixelType;
     /** ODF ImageType */
     typedef Image< OdfPixelType, 3 >                  OdfImageType;
     /** BzeroImageType */
     typedef Image< TOdfPixelType, 3 >                 BZeroImageType;
 
 
     /** Container to hold gradient directions of the 'n' DW measurements */
     typedef VectorContainer< unsigned int, vnl_vector_fixed< double, 3 > > GradientDirectionContainerType;
 
     typedef Image< Vector< TOdfPixelType, (NOrderL*NOrderL + NOrderL + 2)/2 + NOrderL >, 3 > CoefficientImageType;
 
     typedef std::map<unsigned int, std::vector<unsigned int> > BValueMap;
     typedef std::map<unsigned int, std::vector<unsigned int> >::iterator BValueMapIteraotr;
     typedef std::vector<unsigned int> IndiciesVector;
 
     // --------------------------------------------------------------------------------------------//
 
     /** Method for creation through the object factory. */
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
     /** Runtime information support. */
     itkTypeMacro(DiffusionMultiShellQballReconstructionImageFilter, ImageToImageFilter)
 
     /** Get reference image */
     virtual typename Superclass::InputImageType * GetInputImage()
     { return ( static_cast< typename Superclass::InputImageType *>(this->ProcessObject::GetInput(0)) ); }
 
     /** Replaces the Input method.
-      * Var vols = mitk::DiffusionImage<type>
+      * Var vols = mitk::Image
       * -----------------------------------------------------
-      * GradientDirectionContainerType-Input gradientDirectionContainer (e.g. vols->GetDirections)
-      * GradientImagesType-Input gradientImage (e.g. vols->GetVectorImage)
-      * float-Input bvalue (e.g. vols->GetB_Value) */
+      * GradientDirectionContainerType-Input gradientDirectionContainer (e.g. GradientDirectionsContainerProperty)
+      * GradientImagesType-Input gradientImage (e.g. itkVectorImage)
+      * float-Input bvalue (e.g. ReferenceBValueProperty) */
     void SetGradientImage( const GradientDirectionContainerType * gradientDirectionContainer, const GradientImagesType *gradientImage , float bvalue);//, std::vector<bool> listOfUserSelctedBValues );
 
    /** Set a BValue Map (key = bvalue, value = indicies splittet for each shell)
      * If the input image containes more than three q-shells
      * (e.g. b-Values of 0, 1000, 2000, 3000, 4000, ...).
      * For the Analytical-Reconstruction it is needed to set a
      * BValue Map containing three shells in an arithmetic series
      *  (e.g. 0, 1000, 2000, 3000).
      */
     inline void SetBValueMap(BValueMap map){this->m_BValueMap = map;}
 
     /** Threshold on the reference image data. The output ODF will be a null
    * pdf for pixels in the reference image that have a value less than this
    * threshold. */
     itkSetMacro( Threshold, ReferencePixelType )
     itkGetMacro( Threshold, ReferencePixelType )
 
     itkGetMacro( CoefficientImage, typename CoefficientImageType::Pointer )
     /** Return non-diffusion weighted images */
     itkGetMacro( BZeroImage, typename BZeroImageType::Pointer)
 
     /** Factor for Laplacian-Baltrami smoothing of the SH-coefficients*/
     itkSetMacro( Lambda, double )
     itkGetMacro( Lambda, double )
 
 protected:
     DiffusionMultiShellQballReconstructionImageFilter();
     ~DiffusionMultiShellQballReconstructionImageFilter() { }
     void PrintSelf(std::ostream& os, Indent indent) const;
     void BeforeThreadedGenerateData();
     void ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, ThreadIdType NumberOfThreads );
 
 
 private:
 
     enum ReconstructionType
     {
         Mode_Analytical3Shells,
         Mode_NumericalNShells,
         Mode_Standard1Shell
     };
 
     ReconstructionType m_ReconstructionType;
 
     // Interpolation
     bool m_Interpolation_Flag;
     vnl_matrix< double > * m_Interpolation_SHT1_inv;
     vnl_matrix< double > * m_Interpolation_SHT2_inv;
     vnl_matrix< double > * m_Interpolation_SHT3_inv;
     vnl_matrix< double > * m_TARGET_SH_shell1;
     vnl_matrix< double > * m_TARGET_SH_shell2;
     vnl_matrix< double > * m_TARGET_SH_shell3;
     unsigned int m_MaxDirections;
 
     vnl_matrix< double > * m_CoeffReconstructionMatrix;
     vnl_matrix< double > * m_ODFSphericalHarmonicBasisMatrix;
 
     /** container to hold gradient directions */
     GradientDirectionContainerType::Pointer m_GradientDirectionContainer;
 
     /** Number of gradient measurements */
     unsigned int m_NumberOfGradientDirections;
 
     /** Number of baseline images */
     unsigned int m_NumberOfBaselineImages;
 
     /** Threshold on the reference image data */
     ReferencePixelType m_Threshold;
 
     typename BZeroImageType::Pointer m_BZeroImage;
 
     typename CoefficientImageType::Pointer m_CoefficientImage;
 
     float m_BValue;
 
     BValueMap m_BValueMap;
 
     double m_Lambda;
 
     bool m_IsHemisphericalArrangementOfGradientDirections;
 
     bool m_IsArithmeticProgession;
 
     void ComputeReconstructionMatrix(IndiciesVector const & refVector);
     void ComputeODFSHBasis();
     bool CheckDuplicateDiffusionGradients();
     bool CheckForDifferingShellDirections();
     IndiciesVector GetAllDirections();
     void ComputeSphericalHarmonicsBasis(vnl_matrix<double>* QBallReference, vnl_matrix<double>* SHBasisOutput, int Lorder , vnl_matrix<double>* LaplaciaBaltramiOutput =0 , vnl_vector<int>* SHOrderAssociation =0 , vnl_matrix<double> * SHEigenvalues =0);
     void Normalize(OdfPixelType & odf );
     void S_S0Normalization( vnl_vector<double> & vec, double b0  = 0 );
     void DoubleLogarithm(vnl_vector<double> & vec);
     double CalculateThreashold(const double value, const double delta);
     void Projection1(vnl_vector<double> & vec, double delta = 0.01);
     void Projection2( vnl_vector<double> & E1, vnl_vector<double> & E2, vnl_vector<double> & E3, double delta = 0.01);
     void Projection3( vnl_vector<double> & A, vnl_vector<double> & alpha, vnl_vector<double> & beta, double delta = 0.01);
     void StandardOneShellReconstruction(const OutputImageRegionType& outputRegionForThread);
     void AnalyticalThreeShellReconstruction(const OutputImageRegionType& outputRegionForThread);
     void NumericalNShellReconstruction(const OutputImageRegionType& outputRegionForThread);
     void GenerateAveragedBZeroImage(const OutputImageRegionType& outputRegionForThread);
     void ComputeSphericalFromCartesian(vnl_matrix<double> * Q, const IndiciesVector & refShell);
 
 
     //------------------------- VNL-function ------------------------------------
 
     template<typename CurrentValue, typename WntValue>
     vnl_vector< WntValue> element_cast (vnl_vector< CurrentValue> const& v1)
     {
       vnl_vector<WntValue> result(v1.size());
 
       for(unsigned int i = 0 ; i < v1.size(); i++)
            result[i] = static_cast< WntValue>(v1[i]);
 
       return result;
     }
 
     template<typename type>
     double dot (vnl_vector_fixed< type ,3> const& v1, vnl_vector_fixed< type ,3 > const& v2 )
     {
       double result = (v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2]) / (v1.two_norm() * v2.two_norm());
       return result ;
     }
 
 
 
 
 };
 
 }
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkDiffusionMultiShellQballReconstructionImageFilter.cpp"
 #endif
 
 #endif //__itkDiffusionMultiShellQballReconstructionImageFilter_h_
 
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/mitkTeemDiffusionTensor3DReconstructionImageFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/mitkTeemDiffusionTensor3DReconstructionImageFilter.h
index 32bccf0800..f465a7c29c 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/mitkTeemDiffusionTensor3DReconstructionImageFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Reconstruction/mitkTeemDiffusionTensor3DReconstructionImageFilter.h
@@ -1,117 +1,116 @@
 /*===================================================================
 
 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 __mitkTeemDiffusionTensor3DReconstructionImageFilter_h__
 #define __mitkTeemDiffusionTensor3DReconstructionImageFilter_h__
 
 #include "mitkImage.h"
 #include "mitkTensorImage.h"
-#include "mitkDiffusionImage.h"
 #include "itkDiffusionTensor3D.h"
 
 namespace mitk
 {
 
   enum TeemTensorEstimationMethods{
     TeemTensorEstimationMethodsLLS,
     TeemTensorEstimationMethodsNLS,
     TeemTensorEstimationMethodsWLS,
     TeemTensorEstimationMethodsMLE,
   };
 
   template< class DiffusionImagePixelType = short,
     class TTensorPixelType=float >
   class TeemDiffusionTensor3DReconstructionImageFilter : public itk::Object
   {
   public:
 
     typedef TTensorPixelType TensorPixelType;
 
     typedef itk::Vector<TensorPixelType,7> VectorType;
     typedef itk::Image<VectorType,3> VectorImageType;
 
     typedef itk::DiffusionTensor3D<TensorPixelType> TensorType;
     typedef itk::Image<TensorType,3 > ItkTensorImageType;
 
     typedef itk::Vector<TensorPixelType,6> ItkTensorVectorType;
     typedef itk::Image<ItkTensorVectorType,3> ItkTensorVectorImageType;
 
     typedef DiffusionImagePixelType DiffusionPixelType;
     typedef itk::VectorImage< DiffusionPixelType, 3 >   DiffusionImageType;
 
     mitkClassMacro( TeemDiffusionTensor3DReconstructionImageFilter,
       itk::Object );
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     itkGetMacro(Input,
-      typename DiffusionImage<DiffusionImagePixelType>::Pointer);
+      mitk::Image::Pointer);
     itkSetMacro(Input,
-      typename DiffusionImage<DiffusionImagePixelType>::Pointer);
+      mitk::Image::Pointer);
 
     itkGetMacro(EstimateErrorImage, bool);
     itkSetMacro(EstimateErrorImage, bool);
 
     itkGetMacro(Sigma, float);
     itkSetMacro(Sigma, float);
 
     itkGetMacro(EstimationMethod, TeemTensorEstimationMethods);
     itkSetMacro(EstimationMethod, TeemTensorEstimationMethods);
 
     itkGetMacro(NumIterations, int);
     itkSetMacro(NumIterations, int);
 
     itkGetMacro(ConfidenceThreshold, double);
     itkSetMacro(ConfidenceThreshold, double);
 
     itkGetMacro(ConfidenceFuzzyness, float);
     itkSetMacro(ConfidenceFuzzyness, float);
 
     itkGetMacro(MinPlausibleValue, double);
     itkSetMacro(MinPlausibleValue, double);
 
     itkGetMacro(Output, mitk::TensorImage::Pointer);
     itkGetMacro(OutputItk, mitk::TensorImage::Pointer);
 
     // do the work
     virtual void Update();
 
   protected:
 
     TeemDiffusionTensor3DReconstructionImageFilter();
     virtual ~TeemDiffusionTensor3DReconstructionImageFilter();
 
-    typename DiffusionImage<DiffusionImagePixelType>::Pointer m_Input;
+    mitk::Image::Pointer m_Input;
     bool m_EstimateErrorImage;
     float m_Sigma;
     TeemTensorEstimationMethods m_EstimationMethod;
     int m_NumIterations;
     double m_ConfidenceThreshold;
     float m_ConfidenceFuzzyness;
     double m_MinPlausibleValue;
     mitk::TensorImage::Pointer m_Output;
     mitk::TensorImage::Pointer m_OutputItk;
     mitk::Image::Pointer m_ErrorImage;
   };
 
 }
 
 #include "mitkTeemDiffusionTensor3DReconstructionImageFilter.cpp"
 
 #endif
 
 
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkDWIHeadMotionCorrectionFilter.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkDWIHeadMotionCorrectionFilter.cpp
index d11c505925..3f6fbc61a9 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkDWIHeadMotionCorrectionFilter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkDWIHeadMotionCorrectionFilter.cpp
@@ -1,327 +1,316 @@
 /*===================================================================
 
 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 MITKDIFFUSIONIMAGETODIFFUSIONIMAGEFILTER_CPP
-#define MITKDIFFUSIONIMAGETODIFFUSIONIMAGEFILTER_CPP
+#ifndef MITKDWIHEADMOTIONCORRECTIONFILTER_CPP
+#define MITKDWIHEADMOTIONCORRECTIONFILTER_CPP
 
 #include "mitkDWIHeadMotionCorrectionFilter.h"
 
 #include "itkSplitDWImageFilter.h"
 #include "itkB0ImageExtractionToSeparateImageFilter.h"
 
 #include "mitkImageTimeSelector.h"
 
 #include "mitkPyramidImageRegistrationMethod.h"
 //#include "mitkRegistrationMethodITK4.h"
-#include "mitkImageToDiffusionImageSource.h"
+#include <mitkDiffusionPropertyHelper.h>
 
 #include "mitkDiffusionImageCorrectionFilter.h"
 #include <mitkImageWriteAccessor.h>
+#include <mitkProperties.h>
 
 #include <vector>
 
 #include "mitkIOUtil.h"
 #include <itkImage.h>
 
-template< typename DiffusionPixelType>
-mitk::DWIHeadMotionCorrectionFilter<DiffusionPixelType>
-  ::DWIHeadMotionCorrectionFilter()
+mitk::DWIHeadMotionCorrectionFilter::DWIHeadMotionCorrectionFilter()
   : m_CurrentStep(0),
     m_Steps(100),
     m_IsInValidState(true),
     m_AbortRegistration(false),
     m_AverageUnweighted(true)
 {
 
 }
 
-template< typename DiffusionPixelType>
-void mitk::DWIHeadMotionCorrectionFilter<DiffusionPixelType>
-::GenerateData()
+
+void mitk::DWIHeadMotionCorrectionFilter::GenerateData()
 {
   typedef itk::SplitDWImageFilter< DiffusionPixelType, DiffusionPixelType> SplitFilterType;
 
-  DiffusionImageType* input = const_cast<DiffusionImageType*>(this->GetInput(0));
+  InputImageType* input = const_cast<InputImageType*>(this->GetInput(0));
+
+  ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
+  mitk::CastToItkImage(input, itkVectorImagePointer);
 
   typedef mitk::PyramidImageRegistrationMethod RegistrationMethod;
   // typedef mitk::RegistrationMethodITKV4 RegistrationMethod
-
-  unsigned int numberOfSteps = input->GetVectorImage()->GetNumberOfComponentsPerPixel () ;
+  unsigned int numberOfSteps = itkVectorImagePointer->GetNumberOfComponentsPerPixel () ;
   m_Steps = numberOfSteps;
   //
   //  (1) Extract the b-zero images to a 3d+t image, register them by NCorr metric and
   //     rigid registration : they will then be used are reference image for registering
   //     the gradient images
   //
   typedef itk::B0ImageExtractionToSeparateImageFilter< DiffusionPixelType, DiffusionPixelType> B0ExtractorType;
-  typename B0ExtractorType::Pointer b0_extractor = B0ExtractorType::New();
-  b0_extractor->SetInput( input->GetVectorImage() );
-  b0_extractor->SetDirections( input->GetDirections() );
+  B0ExtractorType::Pointer b0_extractor = B0ExtractorType::New();
+  b0_extractor->SetInput( itkVectorImagePointer );
+  b0_extractor->SetDirections( static_cast<mitk::GradientDirectionsProperty*>( input->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() );
   b0_extractor->Update();
 
   mitk::Image::Pointer b0Image = mitk::Image::New();
   b0Image->InitializeByItk( b0_extractor->GetOutput() );
   b0Image->SetImportChannel( b0_extractor->GetOutput()->GetBufferPointer(),
                              mitk::Image::CopyMemory );
 
   // (2.1) Use the extractor to access the extracted b0 volumes
   mitk::ImageTimeSelector::Pointer t_selector =
       mitk::ImageTimeSelector::New();
 
   t_selector->SetInput( b0Image );
   t_selector->SetTimeNr(0);
   t_selector->Update();
 
   // first unweighted image as reference space for the registration
   mitk::Image::Pointer b0referenceImage = t_selector->GetOutput();
   const unsigned int numberOfb0Images = b0Image->GetTimeSteps();
 
   // register b-zeros only if the flag to average is set, use the first one otherwise
   if( m_AverageUnweighted && numberOfb0Images > 1)
   {
 
     RegistrationMethod::Pointer registrationMethod = RegistrationMethod::New();
     registrationMethod->SetFixedImage( b0referenceImage );
     registrationMethod->SetTransformToRigid();
 
     // the unweighted images are of same modality
     registrationMethod->SetCrossModalityOff();
 
     // use the advanced (windowed sinc) interpolation
     registrationMethod->SetUseAdvancedInterpolation(true);
 
     // Initialize the temporary output image
     mitk::Image::Pointer registeredB0Image = b0Image->Clone();
 
     mitk::ImageTimeSelector::Pointer t_selector2 =
           mitk::ImageTimeSelector::New();
 
     t_selector2->SetInput( b0Image );
 
     for( unsigned int i=1; i<numberOfb0Images; i++)
       {
 
         m_CurrentStep = i + 1;
         if( m_AbortRegistration == true) {
           m_IsInValidState = false;
           mitkThrow() << "Stopped by user.";
         };
 
         t_selector2->SetTimeNr(i);
         t_selector2->Update();
 
         registrationMethod->SetMovingImage( t_selector2->GetOutput() );
 
         try
         {
           MITK_INFO << " === (" << i <<"/"<< numberOfb0Images-1 << ") :: Starting registration";
           registrationMethod->Update();
         }
         catch( const itk::ExceptionObject& e)
         {
           m_IsInValidState = false;
           mitkThrow() << "Failed to register the b0 images, the PyramidRegistration threw an exception: \n" << e.what();
         }
 
       // import volume to the inter-results
       mitk::ImageWriteAccessor imac(registrationMethod->GetResampledMovingImage());
       registeredB0Image->SetImportVolume( imac.GetData(),
         i, 0, mitk::Image::ReferenceMemory );
       }
 
     // use the accumulateImageFilter as provided by the ItkAccumulateFilter method in the header file
     AccessFixedDimensionByItk_1(registeredB0Image, ItkAccumulateFilter, (4), b0referenceImage );
 
   }
 
 
   //
   // (2) Split the diffusion image into a 3d+t regular image, extract only the weighted images
   //
-  typename SplitFilterType::Pointer split_filter = SplitFilterType::New();
-  split_filter->SetInput (input->GetVectorImage() );
-  split_filter->SetExtractAllAboveThreshold(8, input->GetBValueMap() );
+  SplitFilterType::Pointer split_filter = SplitFilterType::New();
+  split_filter->SetInput (itkVectorImagePointer );
+  split_filter->SetExtractAllAboveThreshold(8, static_cast<mitk::BValueMapProperty*>(input->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )->GetBValueMap() );
 
   try
   {
     split_filter->Update();
   }
   catch( const itk::ExceptionObject &e)
   {
     m_IsInValidState = false;
     mitkThrow() << " Caught exception from SplitImageFilter : " << e.what();
   }
 
   mitk::Image::Pointer splittedImage = mitk::Image::New();
   splittedImage->InitializeByItk( split_filter->GetOutput() );
   splittedImage->SetImportChannel( split_filter->GetOutput()->GetBufferPointer(),
                                    mitk::Image::CopyMemory );
 
 
   //
   // (3) Use again the time-selector to access the components separately in order
   //     to perform the registration of  Image -> unweighted reference
   //
 
   RegistrationMethod::Pointer weightedRegistrationMethod
       = RegistrationMethod::New();
 
   weightedRegistrationMethod->SetTransformToAffine();
   weightedRegistrationMethod->SetCrossModalityOn();
 
   //
   //   - (3.1) Set the reference image
   //      - a single b0 image
   //      - average over the registered b0 images if multiple present
   //
   weightedRegistrationMethod->SetFixedImage( b0referenceImage );
   // use the advanced (windowed sinc) interpolation
   weightedRegistrationMethod->SetUseAdvancedInterpolation(true);
   weightedRegistrationMethod->SetVerboseOn();
 
   //
   //   - (3.2) Register all timesteps in the splitted image onto the first reference
   //
   unsigned int maxImageIdx = splittedImage->GetTimeSteps();
   mitk::TimeGeometry* tsg = splittedImage->GetTimeGeometry();
   mitk::ProportionalTimeGeometry* ptg = dynamic_cast<ProportionalTimeGeometry*>(tsg);
   ptg->Expand(maxImageIdx+1);
   ptg->SetTimeStepGeometry( ptg->GetGeometryForTimeStep(0), maxImageIdx );
 
 
   mitk::Image::Pointer registeredWeighted = mitk::Image::New();
   registeredWeighted->Initialize( splittedImage->GetPixelType(0), *tsg );
 
   // insert the first unweighted reference as the first volume
   // in own scope to release the accessor asap after copy
   {
     mitk::ImageWriteAccessor imac(b0referenceImage);
     registeredWeighted->SetImportVolume( imac.GetData(),
       0,0, mitk::Image::CopyMemory );
   }
 
 
   // mitk::Image::Pointer registeredWeighted = splittedImage->Clone();
   // this time start at 0, we have only gradient images in the 3d+t file
   // the reference image comes form an other image
   mitk::ImageTimeSelector::Pointer t_selector_w =
       mitk::ImageTimeSelector::New();
 
   t_selector_w->SetInput( splittedImage );
 
   // store the rotation parts of the transformations in a vector
   typedef RegistrationMethod::TransformMatrixType MatrixType;
   std::vector< MatrixType > estimated_transforms;
 
 
   for( unsigned int i=0; i<maxImageIdx; i++)
   {
     m_CurrentStep = numberOfb0Images + i + 1;
     if( m_AbortRegistration == true) {
       m_IsInValidState = false;
       mitkThrow() << "Stopped by user.";
     };
 
     t_selector_w->SetTimeNr(i);
     t_selector_w->Update();
 
     weightedRegistrationMethod->SetMovingImage( t_selector_w->GetOutput() );
 
     try
     {
       MITK_INFO << " === (" << i+1 <<"/"<< maxImageIdx << ") :: Starting registration";
       weightedRegistrationMethod->Update();
     }
     catch( const itk::ExceptionObject& e)
     {
       m_IsInValidState = false;
       mitkThrow() << "Failed to register the b0 images, the PyramidRegistration threw an exception: \n" << e.what();
     }
 
     // allow expansion
     mitk::ImageWriteAccessor imac(weightedRegistrationMethod->GetResampledMovingImage());
     registeredWeighted->SetImportVolume( imac.GetData(),
       i+1, 0, mitk::Image::CopyMemory);
 
     estimated_transforms.push_back( weightedRegistrationMethod->GetLastRotationMatrix() );
   }
 
 
   //
   // (4) Cast the resulting image back to an diffusion weighted image
   //
-  typename DiffusionImageType::GradientDirectionContainerType *gradients = input->GetDirections();
-  typename DiffusionImageType::GradientDirectionContainerType::Pointer gradients_new =
-      DiffusionImageType::GradientDirectionContainerType::New();
-  typename DiffusionImageType::GradientDirectionType bzero_vector;
+  mitk::DiffusionPropertyHelper::GradientDirectionsContainerType *gradients = static_cast<mitk::GradientDirectionsProperty*>( input->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
+  mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer gradients_new =
+    mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::New();
+  mitk::DiffusionPropertyHelper::GradientDirectionType bzero_vector;
   bzero_vector.fill(0);
 
   // compose the direction vector
   //  - no direction for the first image
   //  - correct ordering of the directions based on the index list
   gradients_new->push_back( bzero_vector );
 
-  typename SplitFilterType::IndexListType index_list = split_filter->GetIndexList();
-  typename SplitFilterType::IndexListType::const_iterator lIter = index_list.begin();
+  SplitFilterType::IndexListType index_list = split_filter->GetIndexList();
+  SplitFilterType::IndexListType::const_iterator lIter = index_list.begin();
 
   while( lIter != index_list.end() )
   {
     gradients_new->push_back( gradients->at( *lIter ) );
     ++lIter;
   }
 
-  typename mitk::ImageToDiffusionImageSource< DiffusionPixelType >::Pointer caster =
-      mitk::ImageToDiffusionImageSource< DiffusionPixelType >::New();
-
-  caster->SetImage( registeredWeighted );
-  caster->SetBValue( input->GetReferenceBValue() );
-  caster->SetGradientDirections( gradients_new.GetPointer() );
-
-  try
-  {
-    caster->Update();
-  }
-  catch( const itk::ExceptionObject& e)
-  {
-    m_IsInValidState = false;
-    MITK_ERROR << "Casting back to diffusion image failed: ";
-    mitkThrow() << "Subprocess failed with exception: " << e.what();
-  }
+  registeredWeighted->SetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( gradients_new.GetPointer() ));
+  registeredWeighted->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>(input->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() ) );
 
   //
   // (5) Adapt the gradient directions according to the estimated transforms
   //
-  typedef mitk::DiffusionImageCorrectionFilter< DiffusionPixelType > CorrectionFilterType;
-  typename CorrectionFilterType::Pointer corrector = CorrectionFilterType::New();
+  typedef mitk::DiffusionImageCorrectionFilter CorrectionFilterType;
+  CorrectionFilterType::Pointer corrector = CorrectionFilterType::New();
 
-  OutputImagePointerType output = caster->GetOutput();
+  mitk::Image::Pointer output = registeredWeighted;
   corrector->SetImage( output );
   corrector->CorrectDirections( estimated_transforms );
 
   //
   // (6) Pass the corrected image to the filters output port
   //
   m_CurrentStep += 1;
-  this->GetOutput()->SetVectorImage(output->GetVectorImage());
-  this->GetOutput()->SetReferenceBValue(output->GetReferenceBValue());
-  this->GetOutput()->SetMeasurementFrame(output->GetMeasurementFrame());
-  this->GetOutput()->SetDirections(output->GetDirections());
-  this->GetOutput()->InitializeFromVectorImage();
+
+  this->GetOutput()->Initialize( output );
+
+  this->GetOutput()->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( static_cast<mitk::GradientDirectionsProperty*>( output->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() ) );
+  this->GetOutput()->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( static_cast<mitk::MeasurementFrameProperty*>( output->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )->GetMeasurementFrame() ) );
+  this->GetOutput()->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>(output->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() ) );
+
+  mitk::DiffusionPropertyHelper propertyHelper( this->GetOutput() );
+  propertyHelper.InitializeImage();
   this->GetOutput()->Modified();
 }
 
-#endif // MITKDIFFUSIONIMAGETODIFFUSIONIMAGEFILTER_CPP
+#endif // MITKDWIHEADMOTIONCORRECTIONFILTER_CPP
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkDWIHeadMotionCorrectionFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkDWIHeadMotionCorrectionFilter.h
index d8065ff27d..e159597b08 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkDWIHeadMotionCorrectionFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkDWIHeadMotionCorrectionFilter.h
@@ -1,132 +1,131 @@
 /*===================================================================
 
 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 MITKDWIHEADMOTIONCORRECTIONFILTER_H
 #define MITKDWIHEADMOTIONCORRECTIONFILTER_H
 
-#include "mitkDiffusionImageToDiffusionImageFilter.h"
+#include "mitkImageToImageFilter.h"
 
 #include <itkAccumulateImageFilter.h>
 #include <itkExtractImageFilter.h>
 
 #include "mitkITKImageImport.h"
+#include <itkVectorImage.h>
+#include <MitkDiffusionCoreExports.h>
 
 namespace mitk
 {
 
 /**
  * @class DWIHeadMotionCorrectionFilter
  *
  * @brief Performs standard head-motion correction by using affine registration of the gradient images.
  *
  * (Head) motion correction is a essential pre-processing step before performing any further analysis of a diffusion-weighted
  * images since all model fits ( tensor, QBI ) rely on an aligned diffusion-weighted dataset. The correction is done in two steps. First the
  * unweighted images ( if multiple present ) are separately registered on the first one by means of rigid registration and normalized correlation
  * as error metric. Second, the weighted gradient images are registered to the unweighted reference ( computed as average from the aligned images from first step )
  * by an affine transformation using the MattesMutualInformation metric as optimizer guidance.
  *
  */
-template< typename DiffusionPixelType>
-class DWIHeadMotionCorrectionFilter
-    : public DiffusionImageToDiffusionImageFilter< DiffusionPixelType >
+
+class MitkDiffusionCore_EXPORT DWIHeadMotionCorrectionFilter
+    : public ImageToImageFilter
 {
 public:
 
   // class macros
   mitkClassMacro( DWIHeadMotionCorrectionFilter,
-                  DiffusionImageToDiffusionImageFilter<DiffusionPixelType> )
+                  ImageToImageFilter )
 
   itkFactorylessNewMacro(Self)
   itkCloneMacro(Self)
 
   itkGetMacro( Steps, unsigned long )
   itkGetMacro( CurrentStep, unsigned long )
   itkGetMacro( IsInValidState, bool)
   itkSetMacro( AbortRegistration, bool )
   itkSetMacro( AverageUnweighted, bool )
 
   // public typedefs
-  typedef typename Superclass::InputImageType         DiffusionImageType;
-  typedef typename Superclass::InputImagePointerType  DiffusionImagePointerType;
-
-  typedef typename Superclass::OutputImageType        OutputImageType;
-  typedef typename Superclass::OutputImagePointerType OutputImagePointerType;
+  typedef short         DiffusionPixelType;
+  typedef Superclass::InputImageType         InputImageType;
+  typedef Superclass::OutputImageType        OutputImageType;
+  typedef itk::VectorImage<DiffusionPixelType, 3> ITKDiffusionImageType;
 
 protected:
   DWIHeadMotionCorrectionFilter();
   virtual ~DWIHeadMotionCorrectionFilter() {}
 
   virtual void GenerateData();
 
   unsigned long   m_CurrentStep;
   unsigned long   m_Steps;
   bool            m_IsInValidState;       ///< Whether the filter is in a valid state, false if error occured
   bool            m_AbortRegistration;        ///< set flag to abort
   bool            m_AverageUnweighted;
 
 };
 
 /**
  * @brief Averages an 3d+t image along the time axis.
  *
  * The method uses the AccumulateImageFilter as provided by ITK and collapses the given 3d+t image
  * to an 3d image while computing the average over the time axis for each of the spatial voxels.
  */
 template< typename TPixel, unsigned int VDimensions>
 static void ItkAccumulateFilter(
     const itk::Image< TPixel, VDimensions>* image,
     mitk::Image::Pointer& output)
 {
   // input 3d+t --> output 3d
   typedef itk::Image< TPixel, 4> InputItkType;
   typedef itk::Image< TPixel, 3> OutputItkType;
   // the accumulate filter requires the same dimension in output and input image
   typedef typename itk::AccumulateImageFilter< InputItkType, InputItkType > FilterType;
 
   typename FilterType::Pointer filter = FilterType::New();
   filter->SetInput( image );
   filter->SetAccumulateDimension( 3 );
   filter->SetAverage( true );
 
   // we need to extract the volume to reduce the size from 4 to 3 for further processing
   typedef typename itk::ExtractImageFilter< InputItkType, OutputItkType > ExtractFilterType;
   typename ExtractFilterType::Pointer extractor = ExtractFilterType::New();
   extractor->SetInput( filter->GetOutput() );
   extractor->SetDirectionCollapseToIdentity();
 
   typename InputItkType::RegionType extractRegion = image->GetLargestPossibleRegion();
   // crop out the time axis
   extractRegion.SetSize( 3, 0);
   extractor->SetExtractionRegion( extractRegion );
 
   try
   {
     extractor->Update();
   }
   catch( const itk::ExceptionObject& e)
   {
     mitkThrow() << " Exception while averaging: " << e.what();
   }
 
   output = mitk::GrabItkImageMemory( extractor->GetOutput() );
 }
 
 } //end namespace mitk
 
-#include "mitkDWIHeadMotionCorrectionFilter.cpp"
-
 
 #endif // MITKDWIHEADMOTIONCORRECTIONFILTER_H
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkRegistrationWrapper.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkRegistrationWrapper.cpp
index 0e1982705b..2f488f4334 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkRegistrationWrapper.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkRegistrationWrapper.cpp
@@ -1,196 +1,216 @@
 #include "mitkRegistrationWrapper.h"
 
 #include "mitkPyramidImageRegistrationMethod.h"
-#include "mitkDiffusionImage.h"
+#include "mitkImage.h"
 #include <mitkDiffusionImageCorrectionFilter.h>
 #include "itkB0ImageExtractionImageFilter.h"
 #include <itkResampleImageFilter.h>
 #include <itkWindowedSincInterpolateImageFunction.h>
 #include <itkLinearInterpolateImageFunction.h>
 #include <itkNearestNeighborExtrapolateImageFunction.h>
 #include <itkBSplineInterpolateImageFunction.h>
+#include <mitkDiffusionPropertyHelper.h>
 
 #include <vnl/vnl_inverse.h>
 
 void mitk::RegistrationWrapper::ApplyTransformationToImage(mitk::Image::Pointer img, const mitk::RegistrationWrapper::RidgidTransformType &transformation,double* offset, mitk::Image* resampleReference,  bool binary)
 {
-  typedef mitk::DiffusionImage<short> DiffusionImageType;
+  mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer gradientDirections =
+  static_cast<mitk::GradientDirectionsProperty*>( img->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
 
-  if (dynamic_cast<DiffusionImageType*> (img.GetPointer()) == NULL)
+  if (gradientDirections.IsNull() || ( gradientDirections->Size() == 0) )
   {
 
     ItkImageType::Pointer itkImage = ItkImageType::New();
 
     CastToItkImage(img, itkImage);
 
     typedef itk::Euler3DTransform< double > RigidTransformType;
     RigidTransformType::Pointer rtransform = RigidTransformType::New();
     RigidTransformType::ParametersType parameters(RigidTransformType::ParametersDimension);
 
     for (int i = 0; i<6;++i)
       parameters[i] = transformation[i];
 
     rtransform->SetParameters( parameters );
 
     mitk::Point3D origin = itkImage->GetOrigin();
     origin[0]-=offset[0];
     origin[1]-=offset[1];
     origin[2]-=offset[2];
 
     mitk::Point3D newOrigin = rtransform->GetInverseTransform()->TransformPoint(origin);
 
     itk::Matrix<double,3,3> dir = itkImage->GetDirection();
     itk::Matrix<double,3,3> transM  ( vnl_inverse(rtransform->GetMatrix().GetVnlMatrix()));
     itk::Matrix<double,3,3> newDirection = transM * dir;
 
     itkImage->SetOrigin(newOrigin);
     itkImage->SetDirection(newDirection);
 
     // Perform Resampling if reference image is provided
     if (resampleReference != NULL)
     {
       typedef itk::ResampleImageFilter<ItkImageType, ItkImageType>  ResampleFilterType;
 
       ItkImageType::Pointer itkReference = ItkImageType::New();
       CastToItkImage(resampleReference,itkReference);
 
       typedef itk::Function::WelchWindowFunction<4> WelchWindowFunction;
       typedef itk::WindowedSincInterpolateImageFunction< ItkImageType, 4,WelchWindowFunction> WindowedSincInterpolatorType;
       WindowedSincInterpolatorType::Pointer sinc_interpolator = WindowedSincInterpolatorType::New();
 
 
       typedef itk::LinearInterpolateImageFunction< ItkImageType> LinearInterpolatorType;
       LinearInterpolatorType::Pointer lin_interpolator = LinearInterpolatorType::New();
 
       typedef itk::NearestNeighborInterpolateImageFunction< ItkImageType, double > NearestNeighborInterpolatorType;
       NearestNeighborInterpolatorType::Pointer nn_interpolator = NearestNeighborInterpolatorType::New();
 
       typedef itk::BSplineInterpolateImageFunction< ItkImageType, double > BSplineInterpolatorType;
       BSplineInterpolatorType::Pointer bSpline_interpolator = BSplineInterpolatorType::New();
 
 
       ResampleFilterType::Pointer resampler = ResampleFilterType::New();
       resampler->SetInput(itkImage);
       resampler->SetReferenceImage( itkReference );
       resampler->UseReferenceImageOn();
       if (binary)
         resampler->SetInterpolator(nn_interpolator);
       else
         resampler->SetInterpolator(lin_interpolator);
 
       resampler->Update();
 
       GrabItkImageMemory(resampler->GetOutput(), img);
     }
     else
     {
       // !! CastToItk behaves very differently depending on the original data type
       // if the target type is the same as the original, only a pointer to the data is set
       // and an additional GrabItkImageMemory will cause a segfault when the image is destroyed
       // GrabItkImageMemory - is not necessary in this case since we worked on the original data
       // See Bug 17538.
       if (img->GetPixelType().GetComponentTypeAsString() != "double")
         img = GrabItkImageMemory(itkImage);
     }
   }
   else
   {
-    DiffusionImageType::Pointer diffImages = dynamic_cast<DiffusionImageType*>(img.GetPointer());
+    mitk::Image::Pointer diffImages = dynamic_cast<mitk::Image*>(img.GetPointer());
 
     typedef itk::Euler3DTransform< double > RigidTransformType;
     RigidTransformType::Pointer rtransform = RigidTransformType::New();
     RigidTransformType::ParametersType parameters(RigidTransformType::ParametersDimension);
 
     for (int i = 0; i<6;++i)
     {
       parameters[i] = transformation[i];
     }
 
     rtransform->SetParameters( parameters );
 
-    mitk::Point3D b0origin = diffImages->GetVectorImage()->GetOrigin();
+    typedef itk::VectorImage<short, 3> ITKDiffusionImageType;
+    ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
+    mitk::CastToItkImage(diffImages, itkVectorImagePointer);
+
+    mitk::Point3D b0origin = itkVectorImagePointer->GetOrigin();
     b0origin[0]-=offset[0];
     b0origin[1]-=offset[1];
     b0origin[2]-=offset[2];
 
     mitk::Point3D newOrigin = rtransform->GetInverseTransform()->TransformPoint(b0origin);
 
-    itk::Matrix<double,3,3> dir = diffImages->GetVectorImage()->GetDirection();
+    itk::Matrix<double,3,3> dir = itkVectorImagePointer->GetDirection();
     itk::Matrix<double,3,3> transM  ( vnl_inverse(rtransform->GetMatrix().GetVnlMatrix()));
     itk::Matrix<double,3,3> newDirection = transM * dir;
 
-    diffImages->GetVectorImage()->SetOrigin(newOrigin);
-    diffImages->GetVectorImage()->SetDirection(newDirection);
+    itkVectorImagePointer->SetOrigin(newOrigin);
+    itkVectorImagePointer->SetDirection(newDirection);
     diffImages->Modified();
 
-    mitk::DiffusionImageCorrectionFilter<short>::Pointer correctionFilter = mitk::DiffusionImageCorrectionFilter<short>::New();
+    mitk::DiffusionImageCorrectionFilter::Pointer correctionFilter = mitk::DiffusionImageCorrectionFilter::New();
 
     // For Diff. Images: Need to rotate the gradients (works in-place)
     correctionFilter->SetImage(diffImages);
     correctionFilter->CorrectDirections(transM.GetVnlMatrix());
     img = diffImages;
   }
 }
 
 void mitk::RegistrationWrapper::GetTransformation(mitk::Image::Pointer fixedImage, mitk::Image::Pointer movingImage, RidgidTransformType transformation,double* offset, bool useSameOrigin, mitk::Image* mask)
 {
   // Handle the case that fixed/moving image is a DWI image
-  mitk::DiffusionImage<short>* fixedDwi = dynamic_cast<mitk::DiffusionImage<short>*> (fixedImage.GetPointer());
-  mitk::DiffusionImage<short>* movingDwi = dynamic_cast<mitk::DiffusionImage<short>*> (movingImage.GetPointer());
+  mitk::Image* fixedDwi = dynamic_cast<mitk::Image*> (fixedImage.GetPointer());
+  mitk::Image* movingDwi = dynamic_cast<mitk::Image*> (movingImage.GetPointer());
   itk::B0ImageExtractionImageFilter<short,short >::Pointer b0Extraction = itk::B0ImageExtractionImageFilter<short,short>::New();
   offset[0]=offset[1]=offset[2]=0;
-  if (fixedDwi != NULL)
+
+  typedef itk::VectorImage<short, 3> ITKDiffusionImageType;
+  ITKDiffusionImageType::Pointer itkFixedDwiPointer = ITKDiffusionImageType::New();
+  mitk::CastToItkImage(fixedDwi, itkFixedDwiPointer);
+
+  ITKDiffusionImageType::Pointer itkMovingDwiPointer = ITKDiffusionImageType::New();
+  mitk::CastToItkImage(movingDwi, itkMovingDwiPointer);
+
+  mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer fixedGradientDirections =
+    static_cast<mitk::GradientDirectionsProperty*>( fixedDwi->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
+
+  mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer movingGradientDirections =
+    static_cast<mitk::GradientDirectionsProperty*>( movingDwi->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
+
+  if (fixedGradientDirections.IsNull() || ( fixedGradientDirections->Size() == 0))
   { // Set b0 extraction as fixed image
-    b0Extraction->SetInput(fixedDwi->GetVectorImage());
-    b0Extraction->SetDirections(fixedDwi->GetDirections());
+    b0Extraction->SetInput( itkFixedDwiPointer );
+    b0Extraction->SetDirections(fixedGradientDirections);
     b0Extraction->Update();
     mitk::Image::Pointer tmp = mitk::Image::New();
     tmp->InitializeByItk(b0Extraction->GetOutput());
     tmp->SetVolume(b0Extraction->GetOutput()->GetBufferPointer());
     fixedImage = tmp;
   }
-  if (movingDwi != NULL)
+  if (movingGradientDirections || ( movingGradientDirections->Size() == 0))
   { // Set b0 extraction as moving image
-    b0Extraction->SetInput(movingDwi->GetVectorImage());
-    b0Extraction->SetDirections(movingDwi->GetDirections());
+    b0Extraction->SetInput( itkMovingDwiPointer );
+    b0Extraction->SetDirections(movingGradientDirections);
     b0Extraction->Update();
     mitk::Image::Pointer tmp = mitk::Image::New();
     tmp->InitializeByItk(b0Extraction->GetOutput());
     tmp->SetVolume(b0Extraction->GetOutput()->GetBufferPointer());
     movingImage = tmp;
   }
 
   // align the offsets of the two images. this is done to avoid non-overlapping initialization
   Point3D origin = fixedImage->GetGeometry()->GetOrigin();
   Point3D originMoving = movingImage->GetGeometry()->GetOrigin();
 
   mitk::Image::Pointer tmpImage = movingImage->Clone();
   if (useSameOrigin)
   {
     offset[0] = originMoving[0]-origin[0];
     offset[1] = originMoving[1]-origin[1];
     offset[2] = originMoving[2]-origin[2];
     tmpImage->GetGeometry()->SetOrigin(origin);
   }
 
   // Start registration
   mitk::PyramidImageRegistrationMethod::Pointer registrationMethod = mitk::PyramidImageRegistrationMethod::New();
   registrationMethod->SetFixedImage( fixedImage );
 
   if (mask != NULL)
   {
     registrationMethod->SetFixedImageMask(mask);
     registrationMethod->SetUseFixedImageMask(true);
   }
   else
   {
     registrationMethod->SetUseFixedImageMask(false);
   }
 
   registrationMethod->SetTransformToRigid();
   registrationMethod->SetCrossModalityOn();
 
   registrationMethod->SetMovingImage(tmpImage);
   registrationMethod->Update();
   registrationMethod->GetParameters(transformation); // first three: euler angles, last three translation
 }
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkAdcImageFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkAdcImageFilter.h
index deead178e9..7b7802c3cc 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkAdcImageFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkAdcImageFilter.h
@@ -1,80 +1,80 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 /*===================================================================
 
 This file is based heavily on a corresponding ITK filter.
 
 ===================================================================*/
 #ifndef __itkAdcImageFilter_h_
 #define __itkAdcImageFilter_h_
 
 #include "itkImageToImageFilter.h"
 #include "itkVectorImage.h"
-#include <mitkDiffusionImage.h>
+#include <mitkDiffusionPropertyHelper.h>
 
 namespace itk{
 /** \class AdcImageFilter
  */
 
 template< class TInPixelType, class TOutPixelType >
 class AdcImageFilter :
         public ImageToImageFilter< VectorImage< TInPixelType, 3 >, Image< TOutPixelType, 3 > >
 {
 
 public:
 
     typedef AdcImageFilter Self;
     typedef SmartPointer<Self>                      Pointer;
     typedef SmartPointer<const Self>                ConstPointer;
     typedef ImageToImageFilter< VectorImage< TInPixelType, 3 >, Image< TOutPixelType, 3 > >  Superclass;
-    typedef mitk::DiffusionImage< short >::GradientDirectionType GradientDirectionType;
-    typedef mitk::DiffusionImage< short >::GradientDirectionContainerType::Pointer GradientContainerType;
+    typedef mitk::DiffusionPropertyHelper::GradientDirectionType GradientDirectionType;
+    typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer GradientContainerType;
 
     /** Method for creation through the object factory. */
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     /** Runtime information support. */
     itkTypeMacro(AdcImageFilter, ImageToImageFilter)
 
     typedef typename Superclass::InputImageType InputImageType;
     typedef typename Superclass::OutputImageType OutputImageType;
     typedef typename Superclass::OutputImageRegionType OutputImageRegionType;
 
     itkSetMacro( B_value, double )
     itkSetMacro( GradientDirections, GradientContainerType )
 
     protected:
         AdcImageFilter();
     ~AdcImageFilter() {}
     void PrintSelf(std::ostream& os, Indent indent) const;
 
     void BeforeThreadedGenerateData();
     void ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, ThreadIdType);
 
     double    m_B_value;
     GradientContainerType m_GradientDirections;
 };
 
 }
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkAdcImageFilter.txx"
 #endif
 
 #endif //__itkAdcImageFilter_h_
 
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiNormilzationFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiNormilzationFilter.h
index cdb43eec2e..c268bb5e40 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiNormilzationFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiNormilzationFilter.h
@@ -1,100 +1,100 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 /*===================================================================
 
 This file is based heavily on a corresponding ITK filter.
 
 ===================================================================*/
 #ifndef __itkDwiNormilzationFilter_h_
 #define __itkDwiNormilzationFilter_h_
 
 #include "itkImageToImageFilter.h"
 #include "itkVectorImage.h"
-#include <mitkDiffusionImage.h>
 #include <itkLabelStatisticsImageFilter.h>
 #include <itkImageRegionIteratorWithIndex.h>
 #include <itkShiftScaleImageFilter.h>
+#include <mitkDiffusionPropertyHelper.h>
 
 namespace itk{
 /** \class DwiNormilzationFilter
  *  \brief Normalizes the data vectors either using the specified reference value or the voxelwise baseline value.
  */
 
 template< class TInPixelType >
 class DwiNormilzationFilter :
         public ImageToImageFilter< VectorImage< TInPixelType, 3 >, VectorImage< TInPixelType, 3 > >
 {
 
 public:
 
     typedef DwiNormilzationFilter Self;
     typedef SmartPointer<Self>                      Pointer;
     typedef SmartPointer<const Self>                ConstPointer;
     typedef ImageToImageFilter< VectorImage< TInPixelType, 3 >, VectorImage< TInPixelType, 3 > >  Superclass;
 
     /** Method for creation through the object factory. */
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     /** Runtime information support. */
     itkTypeMacro(DwiNormilzationFilter, ImageToImageFilter)
 
     typedef itk::Image< double, 3 > DoubleImageType;
     typedef itk::Image< unsigned char, 3 > UcharImageType;
     typedef itk::Image< unsigned short, 3 > BinImageType;
     typedef itk::Image< TInPixelType, 3 > TInPixelImageType;
     typedef typename Superclass::InputImageType InputImageType;
     typedef typename Superclass::OutputImageType OutputImageType;
     typedef typename Superclass::OutputImageRegionType OutputImageRegionType;
-    typedef mitk::DiffusionImage< short >::GradientDirectionType GradientDirectionType;
-    typedef mitk::DiffusionImage< short >::GradientDirectionContainerType::Pointer GradientContainerType;
+    typedef mitk::DiffusionPropertyHelper::GradientDirectionType GradientDirectionType;
+    typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer GradientContainerType;
     typedef itk::LabelStatisticsImageFilter< TInPixelImageType,BinImageType >  StatisticsFilterType;
     typedef itk::Statistics::Histogram< typename TInPixelImageType::PixelType  > HistogramType;
     typedef typename HistogramType::MeasurementType MeasurementType;
     typedef itk::ShiftScaleImageFilter<TInPixelImageType, DoubleImageType>  ShiftScaleImageFilterType;
 
     itkSetMacro( GradientDirections, GradientContainerType )
     itkSetMacro( ScalingFactor, TInPixelType )
     itkSetMacro( UseGlobalReference, bool )
     itkSetMacro( MaskImage, UcharImageType::Pointer )
     itkSetMacro( Reference, double )
 
     protected:
         DwiNormilzationFilter();
     ~DwiNormilzationFilter() {}
     void PrintSelf(std::ostream& os, Indent indent) const;
 
     void BeforeThreadedGenerateData();
     void ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, ThreadIdType);
 
     UcharImageType::Pointer m_MaskImage;
     GradientContainerType   m_GradientDirections;
     int                     m_B0Index;
     TInPixelType            m_ScalingFactor;
     bool                    m_UseGlobalReference;
     double                  m_Reference;
 
 };
 
 }
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkDwiNormilzationFilter.txx"
 #endif
 
 #endif //__itkDwiNormilzationFilter_h_
 
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkElectrostaticRepulsionDiffusionGradientReductionFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkElectrostaticRepulsionDiffusionGradientReductionFilter.h
index dd75de3f14..9c80bb27e4 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkElectrostaticRepulsionDiffusionGradientReductionFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkElectrostaticRepulsionDiffusionGradientReductionFilter.h
@@ -1,123 +1,126 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 /*=========================================================================
 
 Program:   Tensor ToolKit - TTK
 Module:    $URL: svn://scm.gforge.inria.fr/svn/ttk/trunk/Algorithms/itkElectrostaticRepulsionDiffusionGradientReductionFilter.h $
 Language:  C++
 Date:      $Date: 2010-06-07 13:39:13 +0200 (Mo, 07 Jun 2010) $
 Version:   $Revision: 68 $
 
 Copyright (c) INRIA 2010. All rights reserved.
 See LICENSE.txt for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 #ifndef _itk_ElectrostaticRepulsionDiffusionGradientReductionFilter_h_
 #define _itk_ElectrostaticRepulsionDiffusionGradientReductionFilter_h_
 
 #include <itkImageToImageFilter.h>
 #include <itkVectorImage.h>
 #include <itkPointShell.h>
 
 namespace itk
 {
 
 /**
 * \brief Select subset of the input vectors equally distributed over the sphere using an iterative electrostatic repulsion strategy.   */
 
   template <class TInputScalarType, class TOutputScalarType>
   class ElectrostaticRepulsionDiffusionGradientReductionFilter
     : public ImageToImageFilter<itk::VectorImage<TInputScalarType,3>, itk::VectorImage<TOutputScalarType,3> >
   {
 
   public:
 
     typedef ElectrostaticRepulsionDiffusionGradientReductionFilter Self;
     typedef SmartPointer<Self>                      Pointer;
     typedef SmartPointer<const Self>                ConstPointer;
     typedef ImageToImageFilter< itk::VectorImage<TOutputScalarType,3>, itk::VectorImage<TOutputScalarType,3> >
       Superclass;
 
     /** Method for creation through the object factory. */
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     /** Runtime information support. */
     itkTypeMacro(ElectrostaticRepulsionDiffusionGradientReductionFilter, ImageToImageFilter)
 
     typedef TInputScalarType                         InputScalarType;
     typedef itk::VectorImage<InputScalarType,3>      InputImageType;
     typedef typename InputImageType::PixelType       InputPixelType;
 
     typedef TOutputScalarType                         OutputScalarType;
     typedef itk::VectorImage<OutputScalarType,3>      OutputImageType;
     typedef typename OutputImageType::PixelType       OutputPixelType;
 
     typedef OutputScalarType                          BaselineScalarType;
     typedef BaselineScalarType                        BaselinePixelType;
     typedef typename itk::Image<BaselinePixelType,3>  BaselineImageType;
 
     typedef vnl_vector_fixed< double, 3 >                               GradientDirectionType;
     typedef itk::VectorContainer< unsigned int, GradientDirectionType > GradientDirectionContainerType;
 
     typedef std::vector<unsigned int>           IndicesVector;
     typedef std::map<unsigned int, IndicesVector>     BValueMap;
 
     itkGetMacro(OriginalGradientDirections, GradientDirectionContainerType::Pointer)
     itkSetMacro(OriginalGradientDirections, GradientDirectionContainerType::Pointer)
 
     itkGetMacro(GradientDirections, GradientDirectionContainerType::Pointer)
     itkSetMacro(GradientDirections, GradientDirectionContainerType::Pointer)
 
     IndicesVector GetUsedGradientIndices(){return m_UsedGradientIndices;}
     void SetOriginalBValueMap(BValueMap inp){m_OriginalBValueMap = inp;}
     void SetShellSelectionBValueMap(BValueMap inp){m_InputBValueMap = inp;}
     void SetNumGradientDirections(std::vector<unsigned int> numDirs){m_NumGradientDirections = numDirs;}
 
+
+    void UpdateOutputInformation();
+
   protected:
     ElectrostaticRepulsionDiffusionGradientReductionFilter();
     ~ElectrostaticRepulsionDiffusionGradientReductionFilter() {}
 
     void GenerateData();
     double Costs(); ///< calculates electrostatic energy of current direction set
 
     GradientDirectionContainerType::Pointer m_GradientDirections;   ///< container for the subsampled output gradient directions
     GradientDirectionContainerType::Pointer m_OriginalGradientDirections;   ///< input gradient directions
 
     IndicesVector m_UsedGradientIndices;
     IndicesVector m_UnusedGradientIndices;
     IndicesVector m_BaselineImageIndices;
 
     BValueMap m_OriginalBValueMap;
     BValueMap m_InputBValueMap;
 
     std::vector<unsigned int> m_NumGradientDirections;
   };
 
 
 } // end of namespace
 
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkElectrostaticRepulsionDiffusionGradientReductionFilter.txx"
 #endif
 
 
 #endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkElectrostaticRepulsionDiffusionGradientReductionFilter.txx b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkElectrostaticRepulsionDiffusionGradientReductionFilter.txx
index 3b601cdb0a..7253e35b42 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkElectrostaticRepulsionDiffusionGradientReductionFilter.txx
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkElectrostaticRepulsionDiffusionGradientReductionFilter.txx
@@ -1,247 +1,261 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 /*=========================================================================
 
 Program:   Tensor ToolKit - TTK
 Module:    $URL: svn://scm.gforge.inria.fr/svn/ttk/trunk/Algorithms/itkElectrostaticRepulsionDiffusionGradientReductionFilter.txx $
 Language:  C++
 Date:      $Date: 2010-06-07 13:39:13 +0200 (Mo, 07 Jun 2010) $
 Version:   $Revision: 68 $
 
 Copyright (c) INRIA 2010. All rights reserved.
 See LICENSE.txt for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 #ifndef _itk_ElectrostaticRepulsionDiffusionGradientReductionFilter_txx_
 #define _itk_ElectrostaticRepulsionDiffusionGradientReductionFilter_txx_
 #endif
 
 #define _USE_MATH_DEFINES
 
 #include "itkElectrostaticRepulsionDiffusionGradientReductionFilter.h"
 #include <math.h>
 #include <time.h>
 #include <itkImageRegionIterator.h>
 #include <itkImageRegion.h>
 
 namespace itk
 {
 
 template <class TInputScalarType, class TOutputScalarType>
 ElectrostaticRepulsionDiffusionGradientReductionFilter<TInputScalarType, TOutputScalarType>
 ::ElectrostaticRepulsionDiffusionGradientReductionFilter()
 {
     this->SetNumberOfRequiredInputs( 1 );
 }
 
 template <class TInputScalarType, class TOutputScalarType>
 double
 ElectrostaticRepulsionDiffusionGradientReductionFilter<TInputScalarType, TOutputScalarType>
 ::Costs()
 {
     double costs = 2*M_PI;
     for (IndicesVector::iterator it = m_UsedGradientIndices.begin(); it!=m_UsedGradientIndices.end(); ++it)
     {
         for (IndicesVector::iterator it2 = m_UsedGradientIndices.begin(); it2!=m_UsedGradientIndices.end(); ++it2)
             if (it != it2)
             {
                 vnl_vector_fixed<double,3> v1 = m_OriginalGradientDirections->at(*it);
                 vnl_vector_fixed<double,3> v2 = m_OriginalGradientDirections->at(*it2);
 
                 v1.normalize(); v2.normalize();
                 double temp = dot_product(v1,v2);
                 if (temp>1)
                     temp = 1;
                 else if (temp<-1)
                     temp = -1;
 
                 double angle = acos(temp);
 
                 if (angle<costs)
                     costs = angle;
 
                 temp = dot_product(-v1,v2);
                 if (temp>1)
                     temp = 1;
                 else if (temp<-1)
                     temp = -1;
 
                 angle = acos(temp);
                 if (angle<costs)
                     costs = angle;
             }
     }
 
     return costs;
 }
 
 template <class TInputScalarType, class TOutputScalarType>
 void
 ElectrostaticRepulsionDiffusionGradientReductionFilter<TInputScalarType, TOutputScalarType>
 ::GenerateData()
 {
     unsigned int randSeed = time(NULL);
 
     if(m_InputBValueMap.empty() || m_NumGradientDirections.size()!=m_InputBValueMap.size())
         return;
 
     BValueMap manipulatedMap = m_InputBValueMap;
 
     int shellCounter = 0;
     for(BValueMap::iterator it = m_InputBValueMap.begin(); it != m_InputBValueMap.end(); it++ )
     {
         srand(randSeed);
 
         // initialize index vectors
         m_UsedGradientIndices.clear();
         m_UnusedGradientIndices.clear();
 
         if ( it->second.size() <= m_NumGradientDirections[shellCounter] )
         {
             itkWarningMacro( << "current directions: " << it->second.size() << " wanted directions: " << m_NumGradientDirections[shellCounter]);
             m_NumGradientDirections[shellCounter] = it->second.size();
             shellCounter++;
             continue;
         }
         MITK_INFO << "Shell number: " << shellCounter;
 
         unsigned int c=0;
 
         for (unsigned int i=0; i<it->second.size(); i++)
         {
             if (c<m_NumGradientDirections[shellCounter])
                 m_UsedGradientIndices.push_back(it->second.at(i));
             else
                 m_UnusedGradientIndices.push_back(it->second.at(i));
             c++;
         }
 
         double minAngle = Costs();
         double newMinAngle = 0;
 
         MITK_INFO << "minimum angle: " << 180*minAngle/M_PI;
         int stagnationCount = 0;
         int rejectionCount = 0;
         int maxRejections = m_NumGradientDirections[shellCounter] * 1000;
         if (maxRejections<10000)
             maxRejections = 10000;
         int iUsed = 0;
         if (m_UsedGradientIndices.size()>0)
             while ( stagnationCount<1000 && rejectionCount<maxRejections )
             {
                 // make proposal for new gradient configuration by randomly removing one of the currently used directions and instead adding one of the unused directions
                 //int iUsed = rand() % m_UsedGradientIndices.size();
                 int iUnUsed = rand() % m_UnusedGradientIndices.size();
                 int vUsed = m_UsedGradientIndices.at(iUsed);
                 int vUnUsed = m_UnusedGradientIndices.at(iUnUsed);
                 m_UsedGradientIndices.at(iUsed) = vUnUsed;
                 m_UnusedGradientIndices.at(iUnUsed) = vUsed;
 
                 newMinAngle = Costs();          // calculate costs of proposed configuration
                 if (newMinAngle > minAngle)     // accept or reject proposal
                 {
                     MITK_INFO << "minimum angle: " << 180*newMinAngle/M_PI;
 
                     if ( (newMinAngle-minAngle)<0.01 )
                         stagnationCount++;
                     else
                         stagnationCount = 0;
 
                     minAngle = newMinAngle;
                     rejectionCount = 0;
                 }
                 else
                 {
                     rejectionCount++;
                     m_UsedGradientIndices.at(iUsed) = vUsed;
                     m_UnusedGradientIndices.at(iUnUsed) = vUnUsed;
                 }
                 iUsed++;
                 iUsed = iUsed % m_UsedGradientIndices.size();
             }
         manipulatedMap[it->first] = m_UsedGradientIndices;
         shellCounter++;
     }
 
     int vecLength = 0 ;
     for(BValueMap::iterator it = manipulatedMap.begin(); it != manipulatedMap.end(); it++)
         vecLength += it->second.size();
 
     // initialize output image
     typename OutputImageType::Pointer outImage = OutputImageType::New();
     outImage->SetSpacing( this->GetInput()->GetSpacing() );   // Set the image spacing
     outImage->SetOrigin( this->GetInput()->GetOrigin() );     // Set the image origin
     outImage->SetDirection( this->GetInput()->GetDirection() );  // Set the image direction
     outImage->SetLargestPossibleRegion( this->GetInput()->GetLargestPossibleRegion());
     outImage->SetBufferedRegion( this->GetInput()->GetLargestPossibleRegion() );
     outImage->SetRequestedRegion( this->GetInput()->GetLargestPossibleRegion() );
     outImage->SetVectorLength( vecLength ); // Set the vector length
     outImage->Allocate();
 
     itk::ImageRegionIterator< OutputImageType > newIt(outImage, outImage->GetLargestPossibleRegion());
     newIt.GoToBegin();
 
     typename InputImageType::Pointer inImage = const_cast<InputImageType*>(this->GetInput(0));
     itk::ImageRegionIterator< InputImageType > oldIt(inImage, inImage->GetLargestPossibleRegion());
     oldIt.GoToBegin();
 
     // initial new value of voxel
     OutputPixelType newVec;
     newVec.SetSize( vecLength );
     newVec.AllocateElements( vecLength );
 
     // generate new pixel values
     while(!newIt.IsAtEnd())
     {
         // init new vector with zeros
         newVec.Fill(0.0);
         InputPixelType oldVec = oldIt.Get();
 
         int index = 0;
         for(BValueMap::iterator it=manipulatedMap.begin(); it!=manipulatedMap.end(); it++)
             for(unsigned int j=0; j<it->second.size(); j++)
             {
                 newVec[index] = oldVec[it->second.at(j)];
                 index++;
             }
         newIt.Set(newVec);
 
         ++newIt;
         ++oldIt;
     }
 
     // set new gradient directions
     m_GradientDirections = GradientDirectionContainerType::New();
     int index = 0;
     for(BValueMap::iterator it = manipulatedMap.begin(); it != manipulatedMap.end(); it++)
         for(unsigned int j = 0; j < it->second.size(); j++)
         {
             m_GradientDirections->InsertElement(index, m_OriginalGradientDirections->at(it->second.at(j)));
             index++;
         }
 
     this->SetNumberOfRequiredOutputs (1);
     this->SetNthOutput (0, outImage);
     MITK_INFO << "...done";
 }
 
+template <class TInputScalarType, class TOutputScalarType>
+void
+ElectrostaticRepulsionDiffusionGradientReductionFilter<TInputScalarType, TOutputScalarType>
+::UpdateOutputInformation()
+{
+  Superclass::UpdateOutputInformation();
 
+  int vecLength = 0 ;
+    for(unsigned int index = 0; index < m_NumGradientDirections.size(); index++)
+    {
+      vecLength += m_NumGradientDirections[index];
+    }
+
+  this->GetOutput()->SetVectorLength( vecLength );
+}
 
 } // end of namespace
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkExtractDwiChannelFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkExtractDwiChannelFilter.h
index 5db210b559..54fcc4e434 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkExtractDwiChannelFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkExtractDwiChannelFilter.h
@@ -1,78 +1,77 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 /*===================================================================
 
 This file is based heavily on a corresponding ITK filter.
 
 ===================================================================*/
 #ifndef __itkExtractDwiChannelFilter_h_
 #define __itkExtractDwiChannelFilter_h_
 
 #include "itkImageToImageFilter.h"
 #include "itkVectorImage.h"
-#include <mitkDiffusionImage.h>
 #include <itkImageRegionIteratorWithIndex.h>
-#include <mitkDiffusionImage.h>
+#include <mitkImage.h>
 
 namespace itk{
 /** \class ExtractDwiChannelFilter
- *  \brief Remove spcified channels from diffusion-weighted image.
+ *  \brief Remove specified channels from diffusion-weighted image.
  */
 
 template< class TInPixelType >
 class ExtractDwiChannelFilter :
         public ImageToImageFilter< VectorImage< TInPixelType, 3 >, Image< TInPixelType, 3 > >
 {
 
 public:
 
     typedef ExtractDwiChannelFilter Self;
     typedef SmartPointer<Self>                      Pointer;
     typedef SmartPointer<const Self>                ConstPointer;
     typedef ImageToImageFilter< VectorImage< TInPixelType, 3 >, Image< TInPixelType, 3 > >  Superclass;
 
     /** Method for creation through the object factory. */
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     /** Runtime information support. */
     itkTypeMacro(ExtractDwiChannelFilter, ImageToImageFilter)
 
     typedef typename Superclass::InputImageType                                             InputImageType;
     typedef typename Superclass::OutputImageType                                            OutputImageType;
     typedef typename Superclass::OutputImageRegionType                                      OutputImageRegionType;
 
     itkSetMacro( ChannelIndex, unsigned int )
 
     protected:
         ExtractDwiChannelFilter();
     ~ExtractDwiChannelFilter() {}
 
     void BeforeThreadedGenerateData();
     void ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, ThreadIdType );
 
     unsigned int    m_ChannelIndex;
 };
 
 }
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkExtractDwiChannelFilter.txx"
 #endif
 
 #endif //__itkExtractDwiChannelFilter_h_
 
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkNonLocalMeansDenoisingFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkNonLocalMeansDenoisingFilter.h
index 878443938b..34cf4ef219 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkNonLocalMeansDenoisingFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkNonLocalMeansDenoisingFilter.h
@@ -1,147 +1,145 @@
 /*===================================================================
 
 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 __itkNonLocalMeansDenoisingFilter_h_
 #define __itkNonLocalMeansDenoisingFilter_h_
 
 #include "itkImageToImageFilter.h"
 #include "itkVectorImage.h"
-#include <mitkDiffusionImage.h>
-
 
 
 namespace itk{
   /** @class NonLocalMeansDenoisingFilter
    * @brief This class denoises a vectorimage according to the non-local means procedure.
    *
    * This Filter needs as an input a diffusion weigthed image, which will be denoised unsing the non-local means principle.
    * An input mask is optional to denoise only inside the mask range. All other voxels will be set to 0.
   */
 
   template< class TPixelType >
   class NonLocalMeansDenoisingFilter :
     public ImageToImageFilter< VectorImage < TPixelType, 3 >, VectorImage < TPixelType, 3 > >
   {
   public:
 
     /** Typedefs */
     typedef NonLocalMeansDenoisingFilter                                                          Self;
     typedef SmartPointer<Self>                                                                    Pointer;
     typedef SmartPointer<const Self>                                                              ConstPointer;
     typedef ImageToImageFilter< VectorImage < TPixelType, 3 >, VectorImage < TPixelType, 3 > >    Superclass;
     typedef typename Superclass::InputImageType                                                   InputImageType;
     typedef typename Superclass::OutputImageType                                                  OutputImageType;
     typedef typename Superclass::OutputImageRegionType                                            OutputImageRegionType;
     typedef Image <TPixelType, 3>                                                                 MaskImageType;
 
     /** Method for creation through the object factory. */
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     /** Runtime information support. */
     itkTypeMacro(NonLocalMeansDenoisingFilter, ImageToImageFilter)
 
     /**
      * @brief Set flag to use joint information
      */
     itkSetMacro(UseJointInformation, bool)
     /**
      * @brief Set the searchradius
      *
      * The searchradius generates a neighborhood of size (2 * searchradius + 1)³.
      * Default is 4.
      */
     itkSetMacro(SearchRadius, int)
     /**
      * @brief Set the comparisonradius
      *
      * The comparisonradius generates neighborhoods of size (2 * comparisonradius +1)³.
      * Default is 1.
      */
     itkSetMacro(ComparisonRadius, int)
     /**
      * @brief Set the variance of the noise
      *
      * The variance of the noise needs to be estimated to use this filter properly.
      * Default is 1.
      */
     itkSetMacro(Variance, double)
     /**
      * @brief Set flag to use a rician adaption
      *
      * If this flag is true the filter uses a method which is optimized for Rician distributed noise.
      */
     itkSetMacro(UseRicianAdaption, bool)
     /**
      * @brief Get the amount of calculated Voxels
      *
      * @return the number of calculated Voxels until yet, useful for the use of a progressbars.
      */
     itkGetMacro(CurrentVoxelCount, unsigned int)
 
 
     /** @brief Set the input image. **/
     void SetInputImage(const InputImageType* image);
     /**
      * @brief Set a denoising mask
      *
      * optional
      *
      * Set a mask to denoise only the masked area, all voxel outside this area will be set to 0.
      */
     void SetInputMask(MaskImageType* mask);
 
   protected:
     NonLocalMeansDenoisingFilter();
     ~NonLocalMeansDenoisingFilter() {}
 
     /**
      * @brief Calculations which need to be done before the denoising starts
      *
      * This method is called before the denoising starts. It calculates the ROI if a mask is used
      * and sets the number of processed voxels to zero.
      */
     void BeforeThreadedGenerateData();
 
     /**
      * @brief Denoising procedure
      *
      * This method calculates the denoised voxelvalue for each voxel in the image in multiple threads.
      * If a mask is used, voxels outside the masked area will be set to 0.
      *
      * @param outputRegionForThread Region to denoise for each thread.
      */
     void ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, ThreadIdType);
 
 
 
   private:
 
     int m_SearchRadius;                               ///< Radius of the searchblock.
     int m_ComparisonRadius;                           ///< Radius of the comparisonblock.
     bool m_UseJointInformation;                       ///< Flag to use joint information.
     bool m_UseRicianAdaption;                         ///< Flag to use rician adaption.
     unsigned int m_CurrentVoxelCount;                 ///< Amount of processed voxels.
     double m_Variance;                                ///< Estimated noise variance.
     typename MaskImageType::Pointer m_Mask;           ///< Pointer to the mask image.
   };
 }
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkNonLocalMeansDenoisingFilter.txx"
 #endif
 
 #endif //__itkNonLocalMeansDenoisingFilter_h_
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkRemoveDwiChannelFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkRemoveDwiChannelFilter.h
index 7e18435d36..168a92b5f8 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkRemoveDwiChannelFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkRemoveDwiChannelFilter.h
@@ -1,85 +1,84 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 /*===================================================================
 
 This file is based heavily on a corresponding ITK filter.
 
 ===================================================================*/
 #ifndef __itkRemoveDwiChannelFilter_h_
 #define __itkRemoveDwiChannelFilter_h_
 
 #include "itkImageToImageFilter.h"
 #include "itkVectorImage.h"
-#include <mitkDiffusionImage.h>
 #include <itkImageRegionIteratorWithIndex.h>
-#include <mitkDiffusionImage.h>
+#include <mitkDiffusionPropertyHelper.h>
 
 namespace itk{
 /** \class RemoveDwiChannelFilter
  *  \brief Remove spcified channels from diffusion-weighted image.
  */
 
 template< class TInPixelType >
 class RemoveDwiChannelFilter :
         public ImageToImageFilter< VectorImage< TInPixelType, 3 >, VectorImage< TInPixelType, 3 > >
 {
 
 public:
 
     typedef RemoveDwiChannelFilter Self;
     typedef SmartPointer<Self>                      Pointer;
     typedef SmartPointer<const Self>                ConstPointer;
     typedef ImageToImageFilter< VectorImage< TInPixelType, 3 >, VectorImage< TInPixelType, 3 > >  Superclass;
 
     /** Method for creation through the object factory. */
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     /** Runtime information support. */
     itkTypeMacro(RemoveDwiChannelFilter, ImageToImageFilter)
 
     typedef typename Superclass::InputImageType                                             InputImageType;
     typedef typename Superclass::OutputImageType                                            OutputImageType;
     typedef typename Superclass::OutputImageRegionType                                      OutputImageRegionType;
-    typedef typename mitk::DiffusionImage< TInPixelType >::GradientDirectionType            DirectionType;
-    typedef typename mitk::DiffusionImage< TInPixelType >::GradientDirectionContainerType   DirectionContainerType;
+    typedef typename mitk::DiffusionPropertyHelper::GradientDirectionType            DirectionType;
+    typedef typename mitk::DiffusionPropertyHelper::GradientDirectionsContainerType   DirectionContainerType;
 
     void SetChannelIndices( std::vector< unsigned int > indices ){ m_ChannelIndices = indices; }
     void SetDirections( typename DirectionContainerType::Pointer directions ){ m_Directions = directions; }
     typename DirectionContainerType::Pointer GetNewDirections(){ return m_NewDirections; }
 
     protected:
         RemoveDwiChannelFilter();
     ~RemoveDwiChannelFilter() {}
     void PrintSelf(std::ostream& os, Indent indent) const;
 
     void BeforeThreadedGenerateData();
     void ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, ThreadIdType id );
 
     std::vector< unsigned int >                 m_ChannelIndices;
     typename DirectionContainerType::Pointer    m_Directions;
     typename DirectionContainerType::Pointer    m_NewDirections;
 };
 
 }
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkRemoveDwiChannelFilter.txx"
 #endif
 
 #endif //__itkRemoveDwiChannelFilter_h_
 
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkResampleDwiImageFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkResampleDwiImageFilter.h
index 2bbaf13288..925d1ff77a 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkResampleDwiImageFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkResampleDwiImageFilter.h
@@ -1,138 +1,146 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 /*=========================================================================
 
 Program:   Tensor ToolKit - TTK
 Module:    $URL: svn://scm.gforge.inria.fr/svn/ttk/trunk/Algorithms/itkResampleDwiImageFilter.h $
 Language:  C++
 Date:      $Date: 2010-06-07 13:39:13 +0200 (Mo, 07 Jun 2010) $
 Version:   $Revision: 68 $
 
 Copyright (c) INRIA 2010. All rights reserved.
 See LICENSE.txt for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 #ifndef _itk_ResampleDwiImageFilter_h_
 #define _itk_ResampleDwiImageFilter_h_
 
 #include <itkImageToImageFilter.h>
 #include <itkVectorImage.h>
 #include <itkPointShell.h>
 
 namespace itk
 {
 
 /**
 * \brief Resample DWI channel by channel.   */
 
 template <class TScalarType>
 class ResampleDwiImageFilter
         : public ImageToImageFilter<itk::VectorImage<TScalarType,3>, itk::VectorImage<TScalarType,3> >
 {
 
 public:
 
     enum Interpolation {
         Interpolate_NearestNeighbour,
         Interpolate_Linear,
         Interpolate_BSpline,
         Interpolate_WindowedSinc
     };
 
     typedef ResampleDwiImageFilter Self;
     typedef SmartPointer<Self>                      Pointer;
     typedef SmartPointer<const Self>                ConstPointer;
     typedef ImageToImageFilter< itk::VectorImage<TScalarType,3>, itk::VectorImage<TScalarType,3> >
     Superclass;
 
     typedef itk::Vector< double, 3 > DoubleVectorType;
     typedef itk::VectorImage<TScalarType,3> DwiImageType;
     typedef itk::Image<TScalarType,3> DwiChannelType;
 
     /** Method for creation through the object factory. */
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     /** Runtime information support. */
     itkTypeMacro(ResampleDwiImageFilter, ImageToImageFilter)
 
     itkSetMacro( Interpolation, Interpolation )
 
     void SetSamplingFactor(DoubleVectorType sampling)
     {
         m_NewSpacing = this->GetInput()->GetSpacing();
         m_NewSpacing[0] /= sampling[0];
         m_NewSpacing[1] /= sampling[1];
         m_NewSpacing[2] /= sampling[2];
         m_NewImageRegion = this->GetInput()->GetLargestPossibleRegion();
         m_NewImageRegion.SetSize(0, m_NewImageRegion.GetSize(0)*sampling[0]);
         m_NewImageRegion.SetSize(1, m_NewImageRegion.GetSize(1)*sampling[1]);
         m_NewImageRegion.SetSize(2, m_NewImageRegion.GetSize(2)*sampling[2]);
     }
     void SetNewSpacing(DoubleVectorType spacing)
     {
         DoubleVectorType oldSpacing = this->GetInput()->GetSpacing();
         DoubleVectorType sampling;
         sampling[0] = oldSpacing[0]/spacing[0];
         sampling[1] = oldSpacing[1]/spacing[1];
         sampling[2] = oldSpacing[2]/spacing[2];
 
         m_NewSpacing = spacing;
         m_NewImageRegion = this->GetInput()->GetLargestPossibleRegion();
         m_NewImageRegion.SetSize(0, m_NewImageRegion.GetSize(0)*sampling[0]);
         m_NewImageRegion.SetSize(1, m_NewImageRegion.GetSize(1)*sampling[1]);
         m_NewImageRegion.SetSize(2, m_NewImageRegion.GetSize(2)*sampling[2]);
     }
     void SetNewImageSize(ImageRegion<3> region)
     {
         ImageRegion<3> oldRegion = this->GetInput()->GetLargestPossibleRegion();
         DoubleVectorType sampling;
         sampling[0] = (double)region.GetSize(0)/oldRegion.GetSize(0);
         sampling[1] = (double)region.GetSize(1)/oldRegion.GetSize(1);
         sampling[2] = (double)region.GetSize(2)/oldRegion.GetSize(2);
 
         m_NewImageRegion = region;
         m_NewSpacing = this->GetInput()->GetSpacing();
         m_NewSpacing[0] /= sampling[0];
         m_NewSpacing[1] /= sampling[1];
         m_NewSpacing[2] /= sampling[2];
     }
 
+    virtual void UpdateOutputInformation();
+
+    virtual void PropagateRequestedRegion(){}
+
+    virtual void PropagateRequestedRegion(itk::DataObject *output){}
+
+    virtual void VerifyInputInformation(){}
+
     protected:
         ResampleDwiImageFilter();
     ~ResampleDwiImageFilter(){}
 
     void GenerateData();
 
     DoubleVectorType m_NewSpacing;
     ImageRegion<3>   m_NewImageRegion;
     Interpolation    m_Interpolation;
 };
 
 
 } // end of namespace
 
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkResampleDwiImageFilter.txx"
 #endif
 
 
 #endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkResampleDwiImageFilter.txx b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkResampleDwiImageFilter.txx
index 516c121104..b317f88f4d 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkResampleDwiImageFilter.txx
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkResampleDwiImageFilter.txx
@@ -1,166 +1,176 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 /*=========================================================================
 
 Program:   Tensor ToolKit - TTK
 Module:    $URL: svn://scm.gforge.inria.fr/svn/ttk/trunk/Algorithms/itkResampleDwiImageFilter.txx $
 Language:  C++
 Date:      $Date: 2010-06-07 13:39:13 +0200 (Mo, 07 Jun 2010) $
 Version:   $Revision: 68 $
 
 Copyright (c) INRIA 2010. All rights reserved.
 See LICENSE.txt for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 #ifndef _itk_ResampleDwiImageFilter_txx_
 #define _itk_ResampleDwiImageFilter_txx_
 #endif
 
 #define _USE_MATH_DEFINES
 
 #include "itkResampleDwiImageFilter.h"
 #include <itkImageRegionIterator.h>
 #include <itkImageRegion.h>
 #include <itkResampleImageFilter.h>
 #include <itkBSplineInterpolateImageFunction.h>
 #include <itkNearestNeighborInterpolateImageFunction.h>
 #include <itkLinearInterpolateImageFunction.h>
 #include <itkWindowedSincInterpolateImageFunction.h>
 
 namespace itk
 {
 
 template <class TScalarType>
 ResampleDwiImageFilter<TScalarType>
 ::ResampleDwiImageFilter()
     : m_Interpolation(Interpolate_Linear)
 {
     this->SetNumberOfRequiredInputs( 1 );
 }
 
 template <class TScalarType>
 void
 ResampleDwiImageFilter<TScalarType>
 ::GenerateData()
 {
 //    // initialize output image
 //    itk::Vector< double, 3 > spacing = this->GetInput()->GetSpacing();
 //    spacing[0] /= m_SamplingFactor[0];
 //    spacing[1] /= m_SamplingFactor[1];
 //    spacing[2] /= m_SamplingFactor[2];
 //    ImageRegion<3> region = this->GetInput()->GetLargestPossibleRegion();
 //    region.SetSize(0, region.GetSize(0)*m_SamplingFactor[0]);
 //    region.SetSize(1, region.GetSize(1)*m_SamplingFactor[1]);
 //    region.SetSize(2, region.GetSize(2)*m_SamplingFactor[2]);
 
     itk::Point<double,3> origin = this->GetInput()->GetOrigin();
     origin[0] -= this->GetInput()->GetSpacing()[0]/2;
     origin[1] -= this->GetInput()->GetSpacing()[1]/2;
     origin[2] -= this->GetInput()->GetSpacing()[2]/2;
 
     origin[0] += m_NewSpacing[0]/2;
     origin[1] += m_NewSpacing[1]/2;
     origin[2] += m_NewSpacing[2]/2;
 
     typename DwiImageType::Pointer outImage = DwiImageType::New();
     outImage->SetSpacing( m_NewSpacing );
     outImage->SetOrigin( origin );
     outImage->SetDirection( this->GetInput()->GetDirection() );
     outImage->SetLargestPossibleRegion( m_NewImageRegion );
     outImage->SetBufferedRegion( m_NewImageRegion );
     outImage->SetRequestedRegion( m_NewImageRegion );
     outImage->SetVectorLength( this->GetInput()->GetVectorLength() );
     outImage->Allocate();
 
     typename itk::ResampleImageFilter<DwiChannelType, DwiChannelType>::Pointer resampler = itk::ResampleImageFilter<DwiChannelType, DwiChannelType>::New();
     resampler->SetOutputParametersFromImage(outImage);
 
     switch (m_Interpolation)
     {
     case Interpolate_NearestNeighbour:
     {
         typename itk::NearestNeighborInterpolateImageFunction<DwiChannelType>::Pointer interp = itk::NearestNeighborInterpolateImageFunction<DwiChannelType>::New();
         resampler->SetInterpolator(interp);
         break;
     }
     case Interpolate_Linear:
     {
         typename itk::LinearInterpolateImageFunction<DwiChannelType>::Pointer interp = itk::LinearInterpolateImageFunction<DwiChannelType>::New();
         resampler->SetInterpolator(interp);
         break;
     }
     case Interpolate_BSpline:
     {
         typename itk::BSplineInterpolateImageFunction<DwiChannelType>::Pointer interp = itk::BSplineInterpolateImageFunction<DwiChannelType>::New();
         resampler->SetInterpolator(interp);
         break;
     }
     case Interpolate_WindowedSinc:
     {
         typename itk::WindowedSincInterpolateImageFunction<DwiChannelType, 3>::Pointer interp = itk::WindowedSincInterpolateImageFunction<DwiChannelType, 3>::New();
         resampler->SetInterpolator(interp);
         break;
     }
     default:
     {
         typename itk::LinearInterpolateImageFunction<DwiChannelType>::Pointer interp = itk::LinearInterpolateImageFunction<DwiChannelType>::New();
         resampler->SetInterpolator(interp);
     }
     }
 
     for (unsigned int i=0; i<this->GetInput()->GetVectorLength(); i++)
     {
         typename DwiChannelType::Pointer channel = DwiChannelType::New();
         channel->SetSpacing( this->GetInput()->GetSpacing() );
         channel->SetOrigin( this->GetInput()->GetOrigin() );
         channel->SetDirection( this->GetInput()->GetDirection() );
         channel->SetLargestPossibleRegion( this->GetInput()->GetLargestPossibleRegion() );
         channel->SetBufferedRegion( this->GetInput()->GetLargestPossibleRegion() );
         channel->SetRequestedRegion( this->GetInput()->GetLargestPossibleRegion() );
         channel->Allocate();
 
         ImageRegionIterator<DwiChannelType> it(channel, channel->GetLargestPossibleRegion());
         while(!it.IsAtEnd())
         {
             typename DwiImageType::PixelType pix = this->GetInput()->GetPixel(it.GetIndex());
             it.Set(pix[i]);
             ++it;
         }
 
         resampler->SetInput(channel);
         resampler->Update();
         channel = resampler->GetOutput();
 
         ImageRegionIterator<DwiImageType> it2(outImage, outImage->GetLargestPossibleRegion());
         while(!it2.IsAtEnd())
         {
             typename DwiImageType::PixelType pix = it2.Get();
             pix[i] = channel->GetPixel(it2.GetIndex());
             it2.Set(pix);
             ++it2;
         }
     }
 
     this->SetNthOutput(0, outImage);
 }
 
+template <class TScalarType>
+void
+ResampleDwiImageFilter<TScalarType>
+::UpdateOutputInformation()
+{
+  // Calls to superclass updateoutputinformation
+  //Superclass::UpdateOutputInformation();
 
+  this->GetOutput()->SetSpacing(m_NewSpacing);
+  this->GetOutput()->SetLargestPossibleRegion(m_NewImageRegion);
+}
 
 } // end of namespace
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkResidualImageFilter.txx b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkResidualImageFilter.txx
index 49715a1226..fb1c06a99a 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkResidualImageFilter.txx
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkResidualImageFilter.txx
@@ -1,285 +1,285 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 /*=========================================================================
 
 Program:   Tensor ToolKit - TTK
 Module:    $URL: svn://scm.gforge.inria.fr/svn/ttk/trunk/Algorithms/itkTensorImageToDiffusionImageFilter.txx $
 Language:  C++
 Date:      $Date: 2010-06-07 13:39:13 +0200 (Mo, 07 Jun 2010) $
 Version:   $Revision: 68 $
 
 Copyright (c) INRIA 2010. All rights reserved.
 See LICENSE.txt for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 #ifndef _itk_ResidualImageFilter_txx_
 #define _itk_ResidualImageFilter_txx_
 #endif
 
 #include "itkResidualImageFilter.h"
 #include <mitkCommon.h>
 #include <cmath>
 
 namespace itk
 {
 
 
 
 
   template <class TInputScalarType, class TOutputScalarType>
   void
   ResidualImageFilter<TInputScalarType, TOutputScalarType>
   ::GenerateData()
   {
     typename InputImageType::SizeType size = this->GetInput()->GetLargestPossibleRegion().GetSize();
     typename InputImageType::SizeType size2 = m_SecondDiffusionImage->GetLargestPossibleRegion().GetSize();
 
     if(size != size2)
     {
       MITK_ERROR << "Sizes do not match";
       return;
     }
 
     // Initialize output image
     typename OutputImageType::Pointer outputImage =
         static_cast< OutputImageType * >(this->ProcessObject::GetPrimaryOutput());
 
     outputImage->SetSpacing( this->GetInput()->GetSpacing() );   // Set the image spacing
     outputImage->SetOrigin( this->GetInput()->GetOrigin() );     // Set the image origin
     outputImage->SetDirection( this->GetInput()->GetDirection() );  // Set the image direction
     outputImage->SetRegions( this->GetInput()->GetLargestPossibleRegion() );
     outputImage->Allocate();
     outputImage->FillBuffer(0.0);
 
 
 
 
 
     std::vector< std::vector<double> > residuals;
 
     // per slice, per volume
     std::vector< std::vector <std::vector<double> > > residualsPerSlice;
 
     // Detrmine number of B0 images
     int numberB0=0;
     for(unsigned int i=0; i<m_Gradients->Size(); i++)
     {
       GradientDirectionType grad = m_Gradients->ElementAt(i);
 
       if(fabs(grad[0]) < 0.001 && fabs(grad[1]) < 0.001 && fabs(grad[2]) < 0.001)
       {
         numberB0++;
       }
     }
 
     residuals.resize(this->GetInput()->GetVectorLength()-numberB0);
 
     // Calculate the standard residual image and for each volume put all residuals in a vector
     for(unsigned int z=0; z<size[2]; z++)
     {
       std::vector< std::vector<double> > sliceResiduals; // residuals per volume for this slice
       sliceResiduals.resize(this->GetInput()->GetVectorLength()-numberB0);
 
       for(unsigned int y=0; y<size[1]; y++)
       {
         for(unsigned int x=0; x<size[0]; x++)
         {
 
           // Check if b0 exceeds threshold
           itk::Index<3> ix;
           ix[0] = x;
           ix[1] = y;
           ix[2] = z;
 
 
           typename InputImageType::PixelType p1 = this->GetInput()->GetPixel(ix);
           typename InputImageType::PixelType p2 = m_SecondDiffusionImage->GetPixel(ix);
 
           if(p1.GetSize() != p2.GetSize())
           {
             MITK_ERROR << "Vector sizes do not match";
             return;
           }
 
 
           if(p1.GetElement(m_B0Index) <= m_B0Threshold)
           {
             continue;
           }
 
 
 
           double res = 0;
           int shift = 0; // correction for the skipped B0 images
 
           for(unsigned int i = 0; i<p1.GetSize(); i++)
           {
 
 
 
             GradientDirectionType grad = m_Gradients->ElementAt(i);
             if(!(fabs(grad[0]) < 0.001 && fabs(grad[1]) < 0.001 && fabs(grad[2]) < 0.001))
             {
               double val1 = (double)p1.GetElement(i);
               double val2 = (double)p2.GetElement(i);
 
               res += abs(val1-val2);
 
               residuals[i-shift].push_back(val1-val2);
               sliceResiduals[i-shift].push_back(val1-val2);
 
             }
             else
             {
               shift++;
             }
 
 
 
           }
 
 
           res = res/p1.GetSize();
 
           outputImage->SetPixel(ix, res);
 
         }
       }
 
       residualsPerSlice.push_back(sliceResiduals);
     }
 
 
 
 
 
     // for each dw volume: sort the the measured residuals (for each voxel) to enable determining Q1 and Q3; calculate means
     // determine percentage of errors as described in QUALITY ASSESSMENT THROUGH ANALYSIS OF RESIDUALS OF DIFFUSION IMAGE FITTING
     // Leemans et al 2008
 
     double q1,q3, median;
     std::vector< std::vector<double> >::iterator it = residuals.begin();
     while(it != residuals.end())
     {
       std::vector<double> res = *it;
 
       // sort
       std::sort(res.begin(), res.end());
 
       q1 = res[0.25*res.size()];
       m_Q1.push_back(q1);
       q3 = res[0.75*res.size()];
       m_Q3.push_back(q3);
 
 
 
       median = res[0.5*res.size()];
       double iqr = q3-q1;
       double outlierThreshold = median + 1.5*iqr;
       double numberOfOutliers = 0.0;
 
       std::vector<double>::iterator resIt = res.begin();
       double mean = 0;
       while(resIt != res.end())
       {
         double f = *resIt;
         if(f>outlierThreshold)
         {
           numberOfOutliers++;
         }
         mean += f;
         ++resIt;
       }
 
       double percOfOutliers = 100 * numberOfOutliers / res.size();
       m_PercentagesOfOutliers.push_back(percOfOutliers);
 
       mean /= res.size();
       m_Means.push_back(mean);
 
       ++it;
     }
 
 
 
     // Calculate for each slice the number of outliers per volume(dw volume)
     std::vector< std::vector <std::vector<double> > >::iterator sliceIt = residualsPerSlice.begin();
 
     while(sliceIt != residualsPerSlice.end())
     {
       std::vector< std::vector<double> > currentSlice = *sliceIt;
       std::vector<double> percentages;
 
       std::vector< std::vector<double> >::iterator volIt = currentSlice.begin();
       while(volIt != currentSlice.end())
       {
 
 
         std::vector<double> currentVolume = *volIt;
 
         //sort
         std::sort(currentVolume.begin(), currentVolume.end());
 
 
 
         q1 = currentVolume[0.25*currentVolume.size()];
         q3 = currentVolume[0.75*currentVolume.size()];
         median = currentVolume[0.5*currentVolume.size()];
         double iqr = q3-q1;
         double outlierThreshold = median + 1.5*iqr;
         double numberOfOutliers = 0.0;
 
         std::vector<double>::iterator resIt = currentVolume.begin();
-        double mean;
+        double mean(0.0);
         while(resIt != currentVolume.end())
         {
           double f = *resIt;
           if(f>outlierThreshold)
           {
             numberOfOutliers++;
           }
           mean += f;
           ++resIt;
        }
 
        double percOfOutliers = 100 * numberOfOutliers / currentVolume.size();
        percentages.push_back(percOfOutliers);
 
        ++volIt;
      }
 
      m_OutliersPerSlice.push_back(percentages);
 
 
 
       ++sliceIt;
     }
 
 
 
 
   }
 
 
 
 
 
 
 } // end of namespace
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorDerivedMeasurementsFilter.txx b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorDerivedMeasurementsFilter.txx
index 34cb1f08cb..ad119b1a73 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorDerivedMeasurementsFilter.txx
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorDerivedMeasurementsFilter.txx
@@ -1,145 +1,145 @@
 /*===================================================================
 
 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 __itkTensorDerivedMeasurementsFilter_txx
 #define __itkTensorDerivedMeasurementsFilter_txx
 
 
-
+#include <itkImageRegionIterator.h>
 
 
 namespace itk {
 
   template <class TPixel>
       TensorDerivedMeasurementsFilter<TPixel>::TensorDerivedMeasurementsFilter() : m_Measure(AD)
   {
   }
 
   template <class TPixel>
       void TensorDerivedMeasurementsFilter<TPixel>::GenerateData()
   {
     typename TensorImageType::Pointer tensorImage = static_cast< TensorImageType * >( this->ProcessObject::GetInput(0) );
     typedef ImageRegionConstIterator< TensorImageType > TensorImageIteratorType;
     typedef ImageRegionIterator< OutputImageType > OutputImageIteratorType;
 
 
     typename OutputImageType::Pointer outputImage =
         static_cast< OutputImageType * >(this->ProcessObject::GetPrimaryOutput());
 
     typename TensorImageType::RegionType region = tensorImage->GetLargestPossibleRegion();
 
 
     outputImage->SetSpacing( tensorImage->GetSpacing() );   // Set the image spacing
     outputImage->SetOrigin( tensorImage->GetOrigin() );     // Set the image origin
     outputImage->SetDirection( tensorImage->GetDirection() );  // Set the image direction
     outputImage->SetRegions( tensorImage->GetLargestPossibleRegion());
     outputImage->Allocate();
 
     TensorImageIteratorType tensorIt(tensorImage, tensorImage->GetLargestPossibleRegion());
     OutputImageIteratorType outputIt(outputImage, outputImage->GetLargestPossibleRegion());
 
     tensorIt.GoToBegin();
     outputIt.GoToBegin();
 
     while(!tensorIt.IsAtEnd() && !outputIt.IsAtEnd()){
 
       TensorType tensor = tensorIt.Get();
 
       switch(m_Measure)
       {
       case FA:
         {
           TPixel diffusionIndex = tensor.GetFractionalAnisotropy();
           outputIt.Set(diffusionIndex);
           break;
         }
       case RA:
         {
           TPixel diffusionIndex = tensor.GetRelativeAnisotropy();
           outputIt.Set(diffusionIndex);
           break;
         }
       case AD:
         {
           // eigenvalues are sorted in ascending order by default because the
           // itk::SymmetricEigenAnalysis defaults are not touched in the tensor implementation
           typename TensorType::EigenValuesArrayType evs;
           tensor.ComputeEigenValues(evs);
           outputIt.Set(evs[2]);
           break;
         }
       case RD:
         {
           // eigenvalues are sorted in ascending order by default because the
           // itk::SymmetricEigenAnalysis defaults are not touched in the tensor implementation
           typename TensorType::EigenValuesArrayType evs;
           tensor.ComputeEigenValues(evs);
           outputIt.Set((evs[0]+evs[1])/2.0);
 
           break;
         }
       case CA:
         {
           // eigenvalues are sorted in ascending order by default because the
           // itk::SymmetricEigenAnalysis defaults are not touched in the tensor implementation
           typename TensorType::EigenValuesArrayType evs;
           tensor.ComputeEigenValues(evs);
           if (evs[2] == 0)
           {
             outputIt.Set(0);
             break;
           }
           outputIt.Set(1.0-(evs[0]+evs[1])/(2.0*evs[2]));
           break;
         }
       case L2:
         {
           // eigenvalues are sorted in ascending order by default because the
           // itk::SymmetricEigenAnalysis defaults are not touched in the tensor implementation
           typename TensorType::EigenValuesArrayType evs;
           tensor.ComputeEigenValues(evs);
           outputIt.Set(evs[1]);
           break;
         }
       case L3:
         {
           // eigenvalues are sorted in ascending order by default because the
           // itk::SymmetricEigenAnalysis defaults are not touched in the tensor implementation
           typename TensorType::EigenValuesArrayType evs;
           tensor.ComputeEigenValues(evs);
           outputIt.Set(evs[0]);
           break;
         }
       case MD:
         {
           typename TensorType::EigenValuesArrayType evs;
           tensor.ComputeEigenValues(evs);
           outputIt.Set((evs[0]+evs[1]+evs[2])/3.0);
           break;
         }
       }
 
       ++tensorIt;
       ++outputIt;
     }
 
 
   }
 
 
 }
 
 #endif // __itkTensorDerivedMeasurements_txx
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorImageToDiffusionImageFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorImageToDiffusionImageFilter.h
index cbed2d792b..b588be572a 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorImageToDiffusionImageFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorImageToDiffusionImageFilter.h
@@ -1,168 +1,171 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 /*=========================================================================
 
 Program:   Tensor ToolKit - TTK
 Module:    $URL: svn://scm.gforge.inria.fr/svn/ttk/trunk/Algorithms/itkTensorImageToDiffusionImageFilter.h $
 Language:  C++
 Date:      $Date: 2010-06-07 13:39:13 +0200 (Mo, 07 Jun 2010) $
 Version:   $Revision: 68 $
 
 Copyright (c) INRIA 2010. All rights reserved.
 See LICENSE.txt for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 #ifndef _itk_TensorImageToDiffusionImageFilter_h_
 #define _itk_TensorImageToDiffusionImageFilter_h_
 
 #include "itkImageToImageFilter.h"
 
 #include <itkDiffusionTensor3D.h>
 #include <itkVectorContainer.h>
 
 namespace itk
 {
 
   template <class TInputScalarType, class TOutputScalarType>
   class TensorImageToDiffusionImageFilter
     : public ImageToImageFilter<itk::Image<itk::DiffusionTensor3D<TInputScalarType>,3>, itk::VectorImage<TOutputScalarType,3> >
   {
 
   public:
 
     typedef TInputScalarType                          InputScalarType;
     typedef itk::DiffusionTensor3D<InputScalarType>   InputPixelType;
     typedef itk::Image<InputPixelType,3>              InputImageType;
     typedef typename InputImageType::RegionType       InputImageRegionType;
 
     typedef TOutputScalarType                         OutputScalarType;
     typedef itk::VectorImage<OutputScalarType,3>      OutputImageType;
     typedef typename OutputImageType::PixelType       OutputPixelType;
     typedef typename OutputImageType::RegionType      OutputImageRegionType;
 
     typedef OutputScalarType                          BaselineScalarType;
     typedef BaselineScalarType                        BaselinePixelType;
     typedef typename itk::Image<BaselinePixelType,3>  BaselineImageType;
     typedef typename BaselineImageType::RegionType    BaselineImageRegionType;
 
     typedef itk::Image< short, 3>                     MaskImageType;
     typedef MaskImageType::RegionType                  MaskImageRegionType;
 
     typedef TensorImageToDiffusionImageFilter Self;
     typedef ImageToImageFilter<InputImageType, OutputImageType> Superclass;
 
     typedef SmartPointer<Self> Pointer;
     typedef SmartPointer<const Self> ConstPointer;
 
     itkTypeMacro (TensorImageToDiffusionImageFilter, ImageToImageFilter);
 
     itkStaticConstMacro (ImageDimension, unsigned int,
       OutputImageType::ImageDimension);
 
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     typedef vnl_vector_fixed<double,3>    GradientType;
     typedef VectorContainer<unsigned int, GradientType> GradientListType;
     typedef GradientListType::Pointer     GradientListPointerType;
 
     /** Manually Set/Get a list of gradients */
     void SetGradientList(const GradientListPointerType list)
     {
       m_GradientList = list;
       this->Modified();
     }
     GradientListPointerType GetGradientList(void) const
     {return m_GradientList;}
 
 
     void SetBValue( const double& bval)
     { m_BValue = bval; }
 
     void SetMaskImage( MaskImageType::Pointer maskimage )
     {
       m_MaskImage = maskimage;
     }
 
 
     /**
      * @brief Set an external baseline image for signal generation (optional)
      *
      * An option to enforce a specific baseline image. If none provided (default) the filter uses
      * the itk::TensorToL2NormImageFilter to generate the modelled baseline image.
      */
     void SetExternalBaselineImage( typename BaselineImageType::Pointer bimage)
     {
       m_BaselineImage = bimage;
     }
 
     itkSetMacro(Min, OutputScalarType);
     itkSetMacro(Max, OutputScalarType);
 
 
   protected:
     TensorImageToDiffusionImageFilter()
     {
       m_BValue = 1.0;
       m_BaselineImage = 0;
       m_Min = 0.0;
       m_Max = 10000.0;
     }
 
     virtual ~TensorImageToDiffusionImageFilter(){}
 
     void PrintSelf (std::ostream& os, Indent indent) const
     {
       Superclass::PrintSelf (os, indent);
     }
 
     virtual void BeforeThreadedGenerateData( void );
 
     virtual void ThreadedGenerateData( const
       OutputImageRegionType &outputRegionForThread, ThreadIdType);
 
     //void GenerateData();
 
-    GradientListPointerType              m_GradientList;
+    virtual void UpdateOutputInformation();
+
+
+  private:
+
+    TensorImageToDiffusionImageFilter (const Self&);
+    void operator=(const Self&);
+
+    GradientListType::Pointer            m_GradientList;
     double                               m_BValue;
     typename BaselineImageType::Pointer  m_BaselineImage;
 
     OutputScalarType                     m_Min;
     OutputScalarType                     m_Max;
 
     MaskImageType::Pointer               m_MaskImage;
 
-  private:
-
-    TensorImageToDiffusionImageFilter (const Self&);
-    void operator=(const Self&);
-
   };
 
 
 } // end of namespace
 
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkTensorImageToDiffusionImageFilter.txx"
 #endif
 
 
 #endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorImageToDiffusionImageFilter.txx b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorImageToDiffusionImageFilter.txx
index e812dfb51a..67a9b355d2 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorImageToDiffusionImageFilter.txx
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkTensorImageToDiffusionImageFilter.txx
@@ -1,235 +1,244 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 /*=========================================================================
    2
    3 Program:   Tensor ToolKit - TTK
    4 Module:    $URL: svn://scm.gforge.inria.fr/svn/ttk/trunk/Algorithms/itkTensorImageToDiffusionImageFilter.txx $
    5 Language:  C++
    6 Date:      $Date: 2010-06-07 13:39:13 +0200 (Mo, 07 Jun 2010) $
    7 Version:   $Revision: 68 $
    8
    9 Copyright (c) INRIA 2010. All rights reserved.
   10 See LICENSE.txt for details.
   11
   12 This software is distributed WITHOUT ANY WARRANTY; without even
   13 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
   14 PURPOSE.  See the above copyright notices for more information.
   15
   16 =========================================================================*/
 #ifndef _itk_TensorImageToDiffusionImageFilter_txx_
 #define _itk_TensorImageToDiffusionImageFilter_txx_
 #endif
 
 #include "itkTensorImageToDiffusionImageFilter.h"
 #include "itkTensorToL2NormImageFilter.h"
 #include "itkRescaleIntensityImageFilter.h"
 #include <itkImageRegionIterator.h>
 #include <itkImageRegionConstIterator.h>
 
 namespace itk
 {
 
 template <class TInputScalarType, class TOutputScalarType>
 void
 TensorImageToDiffusionImageFilter<TInputScalarType, TOutputScalarType>
 ::BeforeThreadedGenerateData()
 {
 
   if( m_GradientList->Size()==0 )
   {
     throw itk::ExceptionObject (__FILE__,__LINE__,"Error: gradient list is empty, cannot generate DWI.");
   }
 
   if( m_BaselineImage.IsNull() )
   {
     // create a B0 image by taking the norm of the tensor field * scale:
     typedef itk::TensorToL2NormImageFilter<InputImageType, itk::Image<InputScalarType,3> >
         TensorToL2NormFilterType;
 
     typename TensorToL2NormFilterType::Pointer myFilter1 = TensorToL2NormFilterType::New();
     myFilter1->SetInput (this->GetInput());
 
     try
     {
       myFilter1->Update();
     }
     catch (itk::ExceptionObject &e)
     {
       std::cerr << e;
       return;
     }
 
     typename itk::RescaleIntensityImageFilter< itk::Image<InputScalarType,3>, BaselineImageType>::Pointer rescaler=
         itk::RescaleIntensityImageFilter<itk::Image<InputScalarType,3>, BaselineImageType>::New();
 
     rescaler->SetOutputMinimum ( m_Min );
     rescaler->SetOutputMaximum ( m_Max );
     rescaler->SetInput ( myFilter1->GetOutput() );
     try
     {
       rescaler->Update();
     }
     catch (itk::ExceptionObject &e)
     {
       std::cerr << e;
       return;
     }
 
     m_BaselineImage = rescaler->GetOutput();
   }
 
   typename OutputImageType::Pointer outImage = OutputImageType::New();
   outImage->SetSpacing( this->GetInput()->GetSpacing() );   // Set the image spacing
   outImage->SetOrigin( this->GetInput()->GetOrigin() );     // Set the image origin
   outImage->SetDirection( this->GetInput()->GetDirection() );  // Set the image direction
   outImage->SetLargestPossibleRegion( this->GetInput()->GetLargestPossibleRegion());
   outImage->SetBufferedRegion( this->GetInput()->GetLargestPossibleRegion() );
   outImage->SetRequestedRegion( this->GetInput()->GetLargestPossibleRegion() );
   outImage->SetVectorLength(m_GradientList->Size());
   outImage->Allocate();
 
   this->SetNumberOfRequiredOutputs (1);
   this->SetNthOutput (0, outImage);
 
 }
 
 template <class TInputScalarType, class TOutputScalarType>
 void TensorImageToDiffusionImageFilter<TInputScalarType, TOutputScalarType>
 ::ThreadedGenerateData (const OutputImageRegionType &outputRegionForThread, ThreadIdType threadId )
 {
   typedef ImageRegionIterator<OutputImageType>      IteratorOutputType;
   typedef ImageRegionConstIterator<InputImageType>  IteratorInputType;
   typedef ImageRegionConstIterator<BaselineImageType>  IteratorBaselineType;
 
   unsigned long numPixels = outputRegionForThread.GetNumberOfPixels();
   unsigned long step = numPixels/100;
   unsigned long progress = 0;
 
   IteratorOutputType itOut (this->GetOutput(), outputRegionForThread);
   IteratorInputType  itIn (this->GetInput(), outputRegionForThread);
   IteratorBaselineType itB0 (m_BaselineImage, outputRegionForThread);
 
   typedef ImageRegionConstIterator< MaskImageType >   IteratorMaskImageType;
   IteratorMaskImageType itMask;
 
   if( m_MaskImage.IsNotNull() )
   {
     itMask = IteratorMaskImageType( m_MaskImage, outputRegionForThread);
     itMask.GoToBegin();
   }
 
   if( threadId==0 )
   {
     this->UpdateProgress (0.0);
   }
 
   while(!itIn.IsAtEnd())
   {
 
     if( this->GetAbortGenerateData() )
     {
       throw itk::ProcessAborted(__FILE__,__LINE__);
     }
 
     InputPixelType T = itIn.Get();
 
     BaselinePixelType b0 = itB0.Get();
 
     OutputPixelType out;
     out.SetSize(m_GradientList->Size());
     out.Fill(0);
 
     short maskvalue = 1;
     if( m_MaskImage.IsNotNull() )
     {
       maskvalue = itMask.Get();
       ++itMask;
     }
 
     std::vector<unsigned int> b0_indices;
     if( b0 > 0)
     {
       for( unsigned int i=0; i<m_GradientList->Size(); i++)
       {
         GradientType g = m_GradientList->at(i);
 
         // normalize vector so the following computations work
         const double twonorm = g.two_norm();
         if( twonorm < vnl_math::eps )
         {
           b0_indices.push_back(i);
           continue;
         }
 
         GradientType gn = g.normalize();
 
         InputPixelType S;
         S[0] = gn[0]*gn[0];
         S[1] = gn[1]*gn[0];
         S[2] = gn[2]*gn[0];
         S[3] = gn[1]*gn[1];
         S[4] = gn[2]*gn[1];
         S[5] = gn[2]*gn[2];
 
         const double res =
                 T[0]*S[0] +
             2 * T[1]*S[1] +     T[3]*S[3] +
             2 * T[2]*S[2] + 2 * T[4]*S[4] + T[5]*S[5];
 
         // check for corrupted tensor
         if (res>=0)
         {
           // estimate the bvalue from the base value and the norm of the gradient
           //   - because of this estimation the vector have to be normalized beforehand
           //     otherwise the modelled signal is wrong ( i.e. not scaled properly )
           const double bval = m_BValue * twonorm * twonorm;
           out[i] = static_cast<OutputScalarType>( maskvalue * 1.0 * b0 * exp ( -1.0 * bval * res ) );
         }
       }
     }
 
     for(unsigned int idx = 0; idx < b0_indices.size(); idx++ )
     {
       out[b0_indices.at(idx)] = b0;
     }
 
 
     itOut.Set(out);
 
     if( threadId==0 && step>0)
     {
       if( (progress%step)==0 )
       {
         this->UpdateProgress ( double(progress)/double(numPixels) );
       }
     }
 
     ++progress;
     ++itB0;
     ++itIn;
     ++itOut;
 
   }
 
   if( threadId==0 )
   {
     this->UpdateProgress (1.0);
   }
 }
 
+template <class TInputScalarType, class TOutputScalarType>
+void
+TensorImageToDiffusionImageFilter<TInputScalarType, TOutputScalarType>
+::UpdateOutputInformation()
+{
+  // Calls to superclass updateoutputinformation
+  Superclass::UpdateOutputInformation();
 
+  this->GetOutput()->SetVectorLength( m_GradientList->size() );
+}
 
 } // end of namespace
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/mitkDiffusionImageToDiffusionImageFilter.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/mitkDiffusionImageToDiffusionImageFilter.cpp
deleted file mode 100644
index 69623e4da8..0000000000
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/mitkDiffusionImageToDiffusionImageFilter.cpp
+++ /dev/null
@@ -1,73 +0,0 @@
-/*===================================================================
-
-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 _mitk_DiffusionImageToDiffusionImageFilter_cpp
-#define _mitk_DiffusionImageToDiffusionImageFilter_cpp
-
-#include "mitkDiffusionImageToDiffusionImageFilter.h"
-
-template <typename DiffusionPixelType>
-mitk::DiffusionImageToDiffusionImageFilter<DiffusionPixelType>
-::DiffusionImageToDiffusionImageFilter()
-{
-  this->SetNumberOfRequiredInputs(1);
-  this->SetNumberOfRequiredOutputs(1);
-}
-
-template <typename DiffusionPixelType>
-void mitk::DiffusionImageToDiffusionImageFilter<DiffusionPixelType>
-::SetInput(const InputImageType *input)
-{
-  // call to the more general method
-  this->SetInput(0, input);
-}
-
-template <typename DiffusionPixelType>
-void mitk::DiffusionImageToDiffusionImageFilter<DiffusionPixelType>
-::SetInput(unsigned int index, const InputImageType *input)
-{
-  if( index+1 > this->GetNumberOfInputs() )
-  {
-    this->SetNumberOfRequiredInputs( index + 1 );
-  }
-  // Process object is not const-correct so the const_cast is required here
-  this->itk::ProcessObject::SetNthInput(index,
-    const_cast< typename Self::InputImageType *>( input ) );
-}
-
-
-template <typename DiffusionPixelType>
-const typename mitk::DiffusionImageToDiffusionImageFilter<DiffusionPixelType>::InputImageType*
-mitk::DiffusionImageToDiffusionImageFilter<DiffusionPixelType>
-::GetInput()
-{
-  // call to the more general method
-  return this->GetInput(0);
-}
-
-template <typename DiffusionPixelType>
-const typename mitk::DiffusionImageToDiffusionImageFilter<DiffusionPixelType>::InputImageType*
-mitk::DiffusionImageToDiffusionImageFilter<DiffusionPixelType>
-::GetInput(unsigned int idx)
-{
-  return static_cast< const typename Self::InputImageType * >
-    (this->itk::ProcessObject::GetInput(idx));
-}
-
-
-
-
-#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/mitkDiffusionImageToDiffusionImageFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/mitkDiffusionImageToDiffusionImageFilter.h
deleted file mode 100644
index 8108b9888d..0000000000
--- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/mitkDiffusionImageToDiffusionImageFilter.h
+++ /dev/null
@@ -1,73 +0,0 @@
-/*===================================================================
-
-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 MITKDIFFUSIONIMAGETODIFFUSIONIMAGEFILTER_H
-#define MITKDIFFUSIONIMAGETODIFFUSIONIMAGEFILTER_H
-
-#include "mitkDiffusionImageSource.h"
-#include "mitkDiffusionImage.h"
-
-
-namespace mitk {
-/**
- * @class DiffusionImageToDiffusionImageFilter
- * @brief Base class for all DiffusionImage filters
- *
- * The class inherits the mitk::ImageToImageFilter to gain access to the filtering pipline.
- */
-template <typename DiffusionPixelType>
-class DiffusionImageToDiffusionImageFilter
-    : public DiffusionImageSource< DiffusionPixelType >
-{
-public:
-  /** typedefs for compatibility */
-  typedef mitk::DiffusionImage< DiffusionPixelType >     InputImageType;
-  typedef typename InputImageType::Pointer               InputImagePointerType;
-
-  mitkClassMacro( DiffusionImageToDiffusionImageFilter,
-                  DiffusionImageSource<DiffusionPixelType> )
-
-  itkFactorylessNewMacro(Self)
-  itkCloneMacro(Self)
-
-  typedef typename Superclass::OutputType                OutputImageType;
-  typedef typename OutputImageType::Pointer              OutputImagePointerType;
-
-  using itk::ProcessObject::SetInput;
-  virtual void SetInput( const InputImageType* image);
-  virtual void SetInput( unsigned int, const InputImageType* image);
-
-  const InputImageType* GetInput(void);
-  const InputImageType* GetInput(unsigned int);
-
-
-protected:
-  DiffusionImageToDiffusionImageFilter();
-  virtual ~DiffusionImageToDiffusionImageFilter() {}
-
-  virtual void PrintSelf(std::ostream &os, itk::Indent indent) const {}
-  virtual void GenerateInputRequestedRegion() {}
-
-private:
-  // purposely not implemented
-  void operator=(const Self&);
-};
-
-} // end namespace mitk
-
-#include "mitkDiffusionImageToDiffusionImageFilter.cpp"
-
-#endif // MITKDIFFUSIONIMAGETODIFFUSIONIMAGEFILTER_H
diff --git a/Modules/DiffusionImaging/DiffusionCore/CMakeLists.txt b/Modules/DiffusionImaging/DiffusionCore/CMakeLists.txt
index b0ee596bbe..1629e3cd19 100644
--- a/Modules/DiffusionImaging/DiffusionCore/CMakeLists.txt
+++ b/Modules/DiffusionImaging/DiffusionCore/CMakeLists.txt
@@ -1,19 +1,19 @@
 # With apple gcc 4.2.1 the following waring leads to an build error if boost is enabled
 if(APPLE)
   mitkFunctionCheckCAndCXXCompilerFlags("-Wno-error=empty-body" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
 endif()
 
 MITK_CREATE_MODULE(
   SUBPROJECTS MITK-DTI
-  INCLUDE_DIRS Algorithms Algorithms/Reconstruction Algorithms/Registration Algorithms/Reconstruction/MultishellProcessing DicomImport IODataStructures/DiffusionWeightedImages IODataStructures/QBallImages IODataStructures/TensorImages IODataStructures Rendering ${CMAKE_CURRENT_BINARY_DIR}
+  INCLUDE_DIRS Algorithms Algorithms/Reconstruction Algorithms/Registration Algorithms/Reconstruction/MultishellProcessing DicomImport IODataStructures/DiffusionWeightedImages IODataStructures/Properties IODataStructures/QBallImages IODataStructures/TensorImages IODataStructures Rendering ${CMAKE_CURRENT_BINARY_DIR}
   DEPENDS MitkMapperExt MitkPlanarFigure MitkImageExtraction MitkSceneSerializationBase MitkDICOMReader
   PACKAGE_DEPENDS VTK|vtkFiltersProgrammable ITK|ITKDistanceMap+ITKRegistrationCommon+ITKLabelVoting+ITKVTK Boost
                   ITK|ITKMetricsv4+ITKRegistrationMethodsv4
   WARNINGS_AS_ERRORS
 )
 
 if(MSVC)
   mitkFunctionCheckCAndCXXCompilerFlags("/wd4005" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
 endif()
 
 add_subdirectory(Testing)
diff --git a/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionDICOMFileReader.cpp b/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionDICOMFileReader.cpp
index b4fb13c110..93dc5802af 100644
--- a/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionDICOMFileReader.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionDICOMFileReader.cpp
@@ -1,306 +1,311 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include "mitkDiffusionDICOMFileReader.h"
 
 #include "mitkDiffusionDICOMFileReaderHelper.h"
 
 #include "mitkDiffusionHeaderSiemensDICOMFileReader.h"
 #include "mitkDiffusionHeaderSiemensMosaicDICOMFileReader.h"
 #include "mitkDiffusionHeaderGEDICOMFileReader.h"
 #include "mitkDiffusionHeaderPhilipsDICOMFileReader.h"
+#include <mitkDiffusionPropertyHelper.h>
+#include <mitkITKImageImport.h>
 
 #include "mitkStringProperty.h"
+#include <mitkImageCast.h>
 
 static void PerformHeaderAnalysis( mitk::DiffusionHeaderDICOMFileReader::DICOMHeaderListType headers )
 {
   unsigned int images = headers.size();
 
   unsigned int unweighted_images = 0;
   unsigned int weighted_images = 0;
 
   mitk::DiffusionHeaderDICOMFileReader::DICOMHeaderListType::const_iterator c_iter = headers.begin();
   while( c_iter != headers.end() )
   {
     const mitk::DiffusionImageDICOMHeaderInformation h = *c_iter;
     if( h.baseline ) unweighted_images++;
     if( h.b_value > 0 ) weighted_images++;
 
     ++c_iter;
   }
 
   MITK_INFO << "  :: Analyzed volumes " << images  << "\n"
             << "  :: \t"<< unweighted_images << " b = 0" << "\n"
             << "  :: \t"<< weighted_images << " b > 0";
 }
 
 mitk::DiffusionDICOMFileReader::DiffusionDICOMFileReader()
 {
 
 }
 
 mitk::DiffusionDICOMFileReader::~DiffusionDICOMFileReader()
 {
 
 }
 
 bool mitk::DiffusionDICOMFileReader
 ::LoadImages()
 {
   unsigned int numberOfOutputs = this->GetNumberOfOutputs();
   bool success = true;
 
   for(unsigned int o = 0; o < numberOfOutputs; ++o)
   {
     success &= this->LoadSingleOutputImage( this->m_OutputHeaderContainer.at(o),
                                             this->InternalGetOutput(o), this->m_IsMosaicData.at(o) );
   }
 
   return success;
 }
 
 bool mitk::DiffusionDICOMFileReader
 ::LoadSingleOutputImage( DiffusionHeaderDICOMFileReader::DICOMHeaderListType retrievedHeader,
                          DICOMImageBlockDescriptor& block, bool is_mosaic)
 {
   // prepare data reading
   DiffusionDICOMFileReaderHelper helper;
   DiffusionDICOMFileReaderHelper::VolumeFileNamesContainer filenames;
 
   const DICOMImageFrameList& frames = block.GetImageFrameList();
   int numberOfDWImages = block.GetIntProperty("timesteps", 1);
 
   int numberOfFramesPerDWImage = frames.size() / numberOfDWImages;
 
   assert( int( double((double) frames.size() / (double) numberOfDWImages)) == numberOfFramesPerDWImage );
   for( int idx = 0; idx < numberOfDWImages; idx++ )
   {
     std::vector< std::string > FileNamesPerVolume;
 
     DICOMImageFrameList::const_iterator timeStepStart = frames.begin() + idx * numberOfFramesPerDWImage;
     DICOMImageFrameList::const_iterator timeStepEnd   = frames.begin() + (idx+1) * numberOfFramesPerDWImage;
     for (DICOMImageFrameList::const_iterator frameIter = timeStepStart;
          frameIter != timeStepEnd;
          ++frameIter)
     {
       FileNamesPerVolume.push_back( (*frameIter)->Filename );
     }
 
     filenames.push_back( FileNamesPerVolume );
   }
 
   // TODO : only prototyping to test loading of diffusion images
   // we need some solution for the different types
-  typedef mitk::DiffusionImage<short> DiffusionImageType;
-  DiffusionImageType::Pointer output_image = DiffusionImageType::New();
+  mitk::Image::Pointer output_image = mitk::Image::New();
 
-  DiffusionImageType::GradientDirectionContainerType::Pointer directions =
-      DiffusionImageType::GradientDirectionContainerType::New();
+  mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer directions =
+      mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::New();
 
 
   double max_bvalue = 0;
   for( int idx = 0; idx < numberOfDWImages; idx++ )
   {
     DiffusionImageDICOMHeaderInformation header = retrievedHeader.at(idx);
 
     if( max_bvalue < header.b_value )
       max_bvalue = header.b_value;
   }
 
   // normalize the retrieved gradient directions according to the set b-value (maximal one)
   for( int idx = 0; idx < numberOfDWImages; idx++ )
   {
     DiffusionImageDICOMHeaderInformation header = retrievedHeader.at(idx);
-    DiffusionImageType::GradientDirectionType grad = header.g_vector;
+    mitk::DiffusionPropertyHelper::GradientDirectionType grad = header.g_vector;
 
     grad.normalize();
     grad *= sqrt( header.b_value / max_bvalue );
 
     directions->push_back( grad );
   }
 
   // initialize the output image
-  output_image->SetReferenceBValue( max_bvalue );
-  output_image->SetDirections( directions );
+  output_image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( directions ) );
+  output_image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( max_bvalue ) );
 
   if( is_mosaic && this->m_ResolveMosaic )
   {
     mitk::DiffusionHeaderSiemensMosaicDICOMFileReader::Pointer mosaic_reader =
         mitk::DiffusionHeaderSiemensMosaicDICOMFileReader::New();
 
     // retrieve the remaining meta-information needed for mosaic reconstruction
     // it suffices to get it exemplatory from the first file in the file list
     mosaic_reader->RetrieveMosaicInformation( filenames.at(0).at(0) );
 
     mitk::MosaicDescriptor mdesc = mosaic_reader->GetMosaicDescriptor();
-    output_image->SetVectorImage( helper.LoadMosaicToVector<short, 3>( filenames, mdesc ) );
+    mitk::CastToMitkImage( helper.LoadMosaicToVector<short, 3>( filenames, mdesc ), output_image );
 
   }
   else
   {
-    output_image->SetVectorImage( helper.LoadToVector<short, 3>( filenames ) );
+    mitk::CastToMitkImage( helper.LoadToVector<short, 3>( filenames ), output_image );
   }
-  output_image->InitializeFromVectorImage();
+
+  mitk::DiffusionPropertyHelper propertyHelper( output_image );
+  propertyHelper.InitializeImage();
+
   output_image->SetProperty("diffusion.dicom.importname", mitk::StringProperty::New( helper.GetOutputName(filenames) ) );
   block.SetMitkImage( (mitk::Image::Pointer) output_image );
 
   return block.GetMitkImage().IsNotNull();
 
 }
 
 void mitk::DiffusionDICOMFileReader
 ::AnalyzeInputFiles()
 {
   this->SetGroup3DandT(true);
 
   Superclass::AnalyzeInputFiles();
 
   // collect output from superclass
   size_t number_of_outputs = this->GetNumberOfOutputs();
 
   if(number_of_outputs == 0)
   {
     MITK_ERROR << "Failed to parse input, retrieved 0 outputs from SeriesGDCMReader ";
   }
 
   MITK_INFO("diffusion.dicomreader") << "Retrieved " << number_of_outputs << "outputs.";
 
   for( unsigned int outputidx = 0; outputidx < this->GetNumberOfOutputs(); outputidx++ )
   {
     DICOMImageBlockDescriptor block_0 = this->GetOutput(outputidx);
 
     // collect vendor ID from the first output, first image
     StringList inputFilename;
     DICOMImageFrameInfo::Pointer frame_0 = block_0.GetImageFrameList().at(0);
     inputFilename.push_back( frame_0->Filename );
 
 
     mitk::DiffusionHeaderDICOMFileReader::Pointer headerReader;
 
     bool isMosaic = false;
     gdcm::Scanner gdcmScanner;
 
     gdcm::Tag t_vendor(0x008, 0x0070);
     gdcm::Tag t_imagetype(0x008, 0x008);
 
     // add DICOM Tag for vendor
     gdcmScanner.AddTag( t_vendor );
     // add DICOM Tag for image type
     gdcmScanner.AddTag( t_imagetype );
     if( gdcmScanner.Scan( inputFilename ) )
     {
 
       // retrieve both vendor and image type
       std::string vendor = gdcmScanner.GetValue( frame_0->Filename.c_str(), t_vendor );
       std::string image_type = gdcmScanner.GetValue( frame_0->Filename.c_str(), t_imagetype );
       MITK_INFO("diffusion.dicomreader") << "Output " << outputidx+1 << "  Got vendor: " << vendor << " image type " << image_type;
 
       // parse vendor tag
       if(    vendor.find("SIEMENS") != std::string::npos )
         //&& image_type.find("DIFFUSION") != std::string::npos )
       {
         if( image_type.find("MOSAIC") != std::string::npos )
         {
           headerReader = mitk::DiffusionHeaderSiemensMosaicDICOMFileReader::New();
           isMosaic = true;
         }
         else
         {
           headerReader = mitk::DiffusionHeaderSiemensDICOMFileReader::New();
         }
 
       }
       else if( vendor.find("GE") != std::string::npos )
       {
         headerReader = mitk::DiffusionHeaderGEDICOMFileReader::New();
       }
       else if( vendor.find("Philips") != std::string::npos )
       {
         headerReader = mitk::DiffusionHeaderPhilipsDICOMFileReader::New();
       }
       else
       {
         // unknown vendor
       }
 
       if( headerReader.IsNull() )
       {
         MITK_ERROR << "No header reader for given vendor. ";
         continue;
       }
 
     }
     else
     {
       continue;
     }
 
 
     bool canread = false;
     // iterate over the threeD+t block
 
     int numberOfTimesteps = block_0.GetIntProperty("timesteps", 1);
     int framesPerTimestep = block_0.GetImageFrameList().size() / numberOfTimesteps;
 
     for( int idx = 0; idx < numberOfTimesteps; idx++ )
     {
       int access_idx = idx * framesPerTimestep;
       DICOMImageFrameInfo::Pointer frame = this->GetOutput( outputidx ).GetImageFrameList().at( access_idx );
       canread = headerReader->ReadDiffusionHeader( frame->Filename );
     }
 
     if( canread )
     {
       // collect the information
       mitk::DiffusionHeaderDICOMFileReader::DICOMHeaderListType retrievedHeader = headerReader->GetHeaderInformation();
 
       m_IsMosaicData.push_back(isMosaic);
       m_OutputHeaderContainer.push_back( retrievedHeader );
       m_OutputReaderContainer.push_back( headerReader );
     }
   }
 
   this->SetNumberOfOutputs( this->m_OutputHeaderContainer.size() );
 
   for( unsigned int outputidx = 0; outputidx < this->GetNumberOfOutputs(); outputidx++ )
   {
     // TODO : Analyze outputs + header information, i.e. for the loading confidence
     MITK_INFO("diffusion.dicomreader") << "---- DICOM Analysis Report ----  :: Output " << outputidx+1 << " of " << this->GetNumberOfOutputs();
 
     try{
       PerformHeaderAnalysis( this->m_OutputHeaderContainer.at( outputidx) );
     }
     catch( const std::exception& se)
     {
       MITK_ERROR << "STD Exception " << se.what();
     }
 
     MITK_INFO("diffusion.dicomreader") << "===========================================";
 
   }
 
 
 
 }
 
 
 bool mitk::DiffusionDICOMFileReader
 ::CanHandleFile(const std::string & /* filename */)
 {
   //FIXME :
   return true;
 }
 
diff --git a/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionDICOMFileReaderHelper.h b/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionDICOMFileReaderHelper.h
index 6cd30e36d7..e4da4b1849 100644
--- a/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionDICOMFileReaderHelper.h
+++ b/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionDICOMFileReaderHelper.h
@@ -1,283 +1,281 @@
 #ifndef MITKDIFFUSIONDICOMFILEREADERHELPER_H
 #define MITKDIFFUSIONDICOMFILEREADERHELPER_H
 
-#include "mitkDiffusionImage.h"
-
 #include "itkImageSeriesReader.h"
 #include "itkVectorImage.h"
 
 #include "itkImageRegionIteratorWithIndex.h"
 
 namespace mitk
 {
 
 /**
  * @brief The MosaicDescriptor struct is a help struct holding the necessary information for
  *        loading a mosaic DICOM file into an MITK file with correct geometry information
  */
 struct MosaicDescriptor
 {
   unsigned int nimages;
   bool slicenormalup;
 
   itk::ImageBase<3>::SpacingType spacing;
   itk::ImageBase<3>::DirectionType direction;
   float origin[3];
 };
 
 class DiffusionDICOMFileReaderHelper
 {
 public:
   typedef std::vector< std::string > StringContainer;
 
   typedef std::vector< StringContainer > VolumeFileNamesContainer;
 
   std::string GetOutputName(const VolumeFileNamesContainer& filenames)
   {
     typedef itk::Image< short, 3> InputImageType;
     typedef itk::ImageSeriesReader< InputImageType > SeriesReaderType;
 
     SeriesReaderType::Pointer probe_reader = SeriesReaderType::New();
     probe_reader->SetFileNames( filenames.at(0) );
     probe_reader->GenerateOutputInformation();
     probe_reader->Update();
 
     std::string seriesDescTag, seriesNumberTag, patientName;
     SeriesReaderType::DictionaryArrayRawPointer inputDict = probe_reader->GetMetaDataDictionaryArray();
 
     if( ! itk::ExposeMetaData< std::string > ( *(*inputDict)[0], "0008|103e", seriesDescTag ) )
       seriesDescTag = "UNSeries";
 
     if( ! itk::ExposeMetaData< std::string > ( *(*inputDict)[0], "0020|0011", seriesNumberTag ) )
       seriesNumberTag = "00000";
 
     if( ! itk::ExposeMetaData< std::string > ( *(*inputDict)[0], "0010|0010", patientName ) )
       patientName = "UnknownName";
 
     std::stringstream ss;
     ss << seriesDescTag << "_" << seriesNumberTag << "_" << patientName;
 
     return ss.str();
 
   }
 
   template< typename PixelType, unsigned int VecImageDimension>
   typename itk::VectorImage< PixelType, VecImageDimension >::Pointer LoadToVector(
       const VolumeFileNamesContainer& filenames
       //const itk::ImageBase<3>::RegionType requestedRegion
       )
   {
     typedef itk::Image< PixelType, 3> InputImageType;
     typedef itk::ImageSeriesReader< InputImageType > SeriesReaderType;
 
     typename SeriesReaderType::Pointer probe_reader = SeriesReaderType::New();
     probe_reader->SetFileNames( filenames.at(0) );
     probe_reader->GenerateOutputInformation();
     const itk::ImageBase<3>::RegionType requestedRegion = probe_reader->GetOutput()->GetLargestPossibleRegion();
 
     MITK_INFO << " --- Probe reader : \n" <<
                  " Retrieved LPR " << requestedRegion;
 
     typedef itk::VectorImage< PixelType, 3 > VectorImageType;
 
     typename VectorImageType::Pointer output_image = VectorImageType::New();
     output_image->SetNumberOfComponentsPerPixel( filenames.size() );
     output_image->SetSpacing( probe_reader->GetOutput()->GetSpacing() );
     output_image->SetOrigin( probe_reader->GetOutput()->GetOrigin() );
     output_image->SetDirection( probe_reader->GetOutput()->GetDirection() );
     output_image->SetLargestPossibleRegion( probe_reader->GetOutput()->GetLargestPossibleRegion() );
     output_image->SetBufferedRegion( requestedRegion );
     output_image->Allocate();
 
     itk::ImageRegionIterator< VectorImageType > vecIter(
           output_image, requestedRegion );
 
     VolumeFileNamesContainer::const_iterator volumesFileNamesIter = filenames.begin();
 
     // iterate over the given volumes
     unsigned int component = 0;
     while( volumesFileNamesIter != filenames.end() )
     {
 
       MITK_INFO << " ======== Loading volume " << component+1 << " of " << filenames.size();
 
       typename SeriesReaderType::Pointer volume_reader = SeriesReaderType::New();
       volume_reader->SetFileNames( *volumesFileNamesIter );
 
       try
       {
         volume_reader->UpdateLargestPossibleRegion();
       }
       catch( const itk::ExceptionObject &e)
       {
         mitkThrow() << " ITK Series reader failed : "<< e.what();
       }
 
       itk::ImageRegionConstIterator< InputImageType > iRCIter (
             volume_reader->GetOutput(),
             volume_reader->GetOutput()->GetLargestPossibleRegion() );
 
       // transfer to vector image
       iRCIter.GoToBegin();
       vecIter.GoToBegin();
 
 
 
       while( !iRCIter.IsAtEnd() )
       {
         typename VectorImageType::PixelType vector_pixel = vecIter.Get();
         vector_pixel.SetElement( component, iRCIter.Get() );
         vecIter.Set( vector_pixel );
 
         ++vecIter;
         ++iRCIter;
       }
 
       ++volumesFileNamesIter;
       component++;
     }
 
     return output_image;
 
   }
 
 
   /**
    * Create the vector image for the resulting diffusion image from a mosaic DICOM image set,
    * The method needs to be provided with the MosaicDescriptor struct to be able to compute the
    * correct index and to set the geometry information of the image itself.
    */
   template< typename PixelType, unsigned int VecImageDimension>
   typename itk::VectorImage< PixelType, VecImageDimension >::Pointer LoadMosaicToVector(
       const VolumeFileNamesContainer& filenames,
       const MosaicDescriptor& mosaicInfo )
   {
     typedef itk::Image< PixelType, 3> MosaicImageType;
     typedef itk::ImageFileReader< MosaicImageType > SingleImageReaderType;
 
     // generate output
     typedef itk::VectorImage< PixelType, 3 > VectorImageType;
 
         VolumeFileNamesContainer::const_iterator volumesFileNamesIter = filenames.begin();
 
     // probe the first file to retrieve the size of the 2d image
     // we need this information to compute the index relation between mosaic and resulting 3d position
     // but we need it only once
     typename SingleImageReaderType::Pointer mosaic_probe = SingleImageReaderType::New();
     mosaic_probe->SetFileName( (*volumesFileNamesIter).at(0) );
     try
     {
       mosaic_probe->UpdateLargestPossibleRegion();
     }
     catch( const itk::ExceptionObject &e)
     {
       mitkThrow() << " ITK Image file reader failed : "<< e.what();
     }
 
     typename MosaicImageType::RegionType mosaic_lpr = mosaic_probe->GetOutput()->GetLargestPossibleRegion();
     MITK_INFO << " == MOSAIC: " << mosaic_lpr;
 
     itk::ImageBase<3>::SizeValueType images_per_row = ceil( sqrt( (float) mosaicInfo.nimages ) );
 
     itk::ImageBase<3>::RegionType requestedRegion;
     requestedRegion.SetSize( 0, mosaic_lpr.GetSize()[0]/images_per_row);
     requestedRegion.SetSize( 1, mosaic_lpr.GetSize()[1]/images_per_row);
     requestedRegion.SetSize( 2, mosaicInfo.nimages);
 
     typename VectorImageType::Pointer output_image = VectorImageType::New();
     output_image->SetNumberOfComponentsPerPixel( filenames.size() );
 
     typename VectorImageType::DirectionType dmatrix;
     dmatrix.SetIdentity();
 
     std::vector<double> dirx = mosaic_probe->GetImageIO()->GetDirection(0);
     std::vector<double> diry = mosaic_probe->GetImageIO()->GetDirection(1);
     std::vector<double> dirz = mosaic_probe->GetImageIO()->GetDirection(2);
 
     dmatrix.GetVnlMatrix().set_column( 0,  &dirx[0] );
     dmatrix.GetVnlMatrix().set_column( 1,  &diry[0] );
     dmatrix.GetVnlMatrix().set_column( 2,  &dirz[0] );
 
 
     /*
      FIXME!!! The struct currently does not provide the geometry information
               the loading works as required*/
     output_image->SetSpacing( mosaicInfo.spacing );
     output_image->SetOrigin( mosaic_probe->GetOutput()->GetOrigin() );
     output_image->SetDirection( dmatrix );
     output_image->SetLargestPossibleRegion( requestedRegion );
     output_image->SetBufferedRegion( requestedRegion );
     output_image->Allocate();
 
     itk::ImageRegionIteratorWithIndex< VectorImageType > vecIter(
           output_image, requestedRegion );
 
     // hold the image sizes in an extra variable ( used very often )
     typename MosaicImageType::SizeValueType dx = requestedRegion.GetSize()[0];
     typename MosaicImageType::SizeValueType dy = requestedRegion.GetSize()[1];
 
     // iterate over the given volumes
     unsigned int component = 0;
     while( volumesFileNamesIter != filenames.end() )
     {
 
       MITK_INFO << " ======== Loading volume " << component+1 << " of " << filenames.size();
 
       typename SingleImageReaderType::Pointer mosaic_reader = SingleImageReaderType::New();
       mosaic_reader->SetFileName( (*volumesFileNamesIter).at(0) );
 
       try
       {
         mosaic_reader->UpdateLargestPossibleRegion();
       }
       catch( const itk::ExceptionObject &e)
       {
         mitkThrow() << " ITK Image file reader failed : "<< e.what();
       }
 
       typename MosaicImageType::Pointer current_mosaic = mosaic_reader->GetOutput();
 
       vecIter.GoToBegin();
       while( !vecIter.IsAtEnd() )
       {
         typename VectorImageType::PixelType vector_pixel = vecIter.Get();
         typename VectorImageType::IndexType threeD_index = vecIter.GetIndex();
 
         typename MosaicImageType::IndexType mosaic_index;
 
         mosaic_index[2] = 0;
 
         // first find the corresponding tile in the mosaic
         // this is defined by the z-position of the vector (3D) image iterator
         //      in x : z_index % #images_in_grid
         //      in y : z_index / #images_in_grid
         //
         // the remaining is just computing the correct position in the mosaic, done by
         //                --------- index of (0,0,z) -----        + --- current 2d position ---
         mosaic_index[0] = (threeD_index[2] % images_per_row) * dx + threeD_index[0];
         mosaic_index[1] = (threeD_index[2] / images_per_row) * dy + threeD_index[1];
 
         typename MosaicImageType::PixelType mosaic_pixel = current_mosaic->GetPixel( mosaic_index );
 
         vector_pixel.SetElement( component, mosaic_pixel );
 
         vecIter.Set( vector_pixel );
 
         ++vecIter;
       }
 
       ++volumesFileNamesIter;
       component++;
 
     }
 
     return output_image;
 
   }
 
 };
 
 
 }
 
 #endif // MITKDIFFUSIONDICOMFILEREADERHELPER_H
diff --git a/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderDICOMFileReader.h b/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderDICOMFileReader.h
index ed62cf3f1e..7e1f348f36 100644
--- a/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderDICOMFileReader.h
+++ b/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderDICOMFileReader.h
@@ -1,117 +1,120 @@
 /*===================================================================
 
 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 MITKDIFFUSIONHEADERFILEREADER_H
 #define MITKDIFFUSIONHEADERFILEREADER_H
 
 #include <MitkDiffusionCoreExports.h>
+#include <mitkCommon.h>
 
 #include <itkLightObject.h>
-#include "mitkDiffusionImage.h"
+#include <itkObjectFactory.h>
 
 #include "gdcmScanner.h"
 #include "gdcmReader.h"
+#include <vnl/vnl_vector_fixed.h>
+
 
 namespace mitk
 {
 
 /**
  * @brief The DiffusionImageHeaderInformation struct
  */
 struct DiffusionImageDICOMHeaderInformation
 {
   DiffusionImageDICOMHeaderInformation()
     : b_value(0),
       baseline(false),
       isotropic(false)
   {
     g_vector.fill(0);
   }
 
   void Print()
   {
     MITK_INFO << " DiffusionImageHeaderInformation : \n"
               << "    : b value   : " << b_value << "\n"
               << "    : gradient  : " << g_vector << "\n"
               << "    : isotropic : " << isotropic << "\n --- \n";
   }
 
   unsigned int b_value;
   vnl_vector_fixed< double, 3> g_vector;
   bool baseline;
   bool isotropic;
 };
 
 struct DiffusionImageMosaicDICOMHeaderInformation
     : public DiffusionImageDICOMHeaderInformation
 {
   unsigned long n_images;
   bool slicenormalup;
 };
 
 
 
 /**
  * @class DiffusionHeaderDICOMFileReader
  *
  * @brief Abstract class for all vendor specific diffusion file header reader
  *
  * To provide a diffusion header reader for a new vendor, reimplement the \sa ReadDiffusionHeader method.
  */
 class MitkDiffusionCore_EXPORT DiffusionHeaderDICOMFileReader
     : public itk::LightObject
 {
 public:
 
   typedef std::vector< DiffusionImageDICOMHeaderInformation > DICOMHeaderListType;
 
   mitkClassMacro( DiffusionHeaderDICOMFileReader, itk::LightObject )
   itkSimpleNewMacro( Self )
 
   /**
    * @brief IsDiffusionHeader Parse the given dicom file and collect the special diffusion image information
    * @return
    */
   virtual bool ReadDiffusionHeader( std::string ){ return false; }
 
   DICOMHeaderListType GetHeaderInformation();
 
 protected:
   DiffusionHeaderDICOMFileReader();
 
   virtual ~DiffusionHeaderDICOMFileReader();
 
   DICOMHeaderListType m_HeaderInformationList;
 };
 
 /**
  * @brief Retrieve the value of a gdcm tag to the given string
  *
  * @param tag the gdcm::Tag to be search for
  * @param dataset a gdcm::DataSet to look into
  * @param target a string to store the value of the given tag if found
  * @param verbose make some output
  *
  * @return true if a string was found, false otherwise
  */
 bool RevealBinaryTag(const gdcm::Tag tag, const gdcm::DataSet& dataset, std::string& target);
 
 bool RevealBinaryTagC(const gdcm::Tag tag, const gdcm::DataSet& dataset, char* target_array );
 
 
 } // end namespace mitk
 
 #endif // MITKDIFFUSIONHEADERFILEREADER_H
diff --git a/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderGEDICOMFileReader.cpp b/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderGEDICOMFileReader.cpp
index 04f552619e..e90e9b77a4 100644
--- a/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderGEDICOMFileReader.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderGEDICOMFileReader.cpp
@@ -1,101 +1,102 @@
 #include "mitkDiffusionHeaderGEDICOMFileReader.h"
+#include <vnl/vnl_math.h>
 
 mitk::DiffusionHeaderGEDICOMFileReader
 ::DiffusionHeaderGEDICOMFileReader()
 {
 
 }
 
 mitk::DiffusionHeaderGEDICOMFileReader
 ::~DiffusionHeaderGEDICOMFileReader()
 {
 
 }
 
 bool mitk::DiffusionHeaderGEDICOMFileReader
 ::ReadDiffusionHeader(std::string filename)
 {
 
   gdcm::Reader gdcmReader;
   gdcmReader.SetFileName( filename.c_str() );
 
   gdcmReader.Read();
 
   gdcm::Tag ge_bvalue_tag( 0x0043, 0x1039 );
   gdcm::Tag ge_gradient_x( 0x0019, 0x10bb );
   gdcm::Tag ge_gradient_y( 0x0019, 0x10bc );
   gdcm::Tag ge_gradient_z( 0x0019, 0x10bd );
 
   bool success = true;
   DiffusionImageDICOMHeaderInformation header_info;
 
   std::string ge_tagvalue_string;
   char* pEnd;
 
   // start with b-value
   success = RevealBinaryTag( ge_bvalue_tag, gdcmReader.GetFile().GetDataSet(), ge_tagvalue_string );
   // b value stored in the first bytes
   // typical example:  "1000\8\0\0" for bvalue=1000
   //                   "40\8\0\0" for bvalue=40
   // so we need to cut off the last 6 elements
   const char* bval_string = ge_tagvalue_string.substr(0,ge_tagvalue_string.length()-6).c_str();
   header_info.b_value = static_cast<unsigned int>(strtod( bval_string, &pEnd ));
 
   // now retrieve the gradient direction
   if(success &&
      RevealBinaryTag( ge_gradient_x, gdcmReader.GetFile().GetDataSet(), ge_tagvalue_string ) )
   {
     header_info.g_vector[0] = strtod( ge_tagvalue_string.c_str(), &pEnd );
   }
   else
   {
     success = false;
   }
 
   if( success &&
       RevealBinaryTag( ge_gradient_y, gdcmReader.GetFile().GetDataSet(), ge_tagvalue_string ) )
   {
     header_info.g_vector[1] = strtod( ge_tagvalue_string.c_str(), &pEnd );
   }
   else
   {
     success = false;
   }
 
   if( success &&
       RevealBinaryTag( ge_gradient_z, gdcmReader.GetFile().GetDataSet(), ge_tagvalue_string ) )
   {
     header_info.g_vector[2] = strtod( ge_tagvalue_string.c_str(), &pEnd );
   }
   else
   {
     success = false;
   }
 
   if( success )
   {
     // Fix for (0,0,0) direction in IVIM datasets
     if( header_info.b_value > 0 &&
         header_info.g_vector.two_norm() < vnl_math::eps )
     {
       header_info.g_vector.fill(1);
       header_info.g_vector.normalize();
       header_info.isotropic = true;
     }
 
     // mark baseline
     if( header_info.b_value == 0 )
       header_info.baseline = true;
 
     this->m_HeaderInformationList.push_back( header_info );
 
     header_info.Print();
   }
 
   return success;
 
 
 
 }
 
 
diff --git a/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderPhilipsDICOMFileReader.cpp b/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderPhilipsDICOMFileReader.cpp
index b037bbb3da..a9c8710521 100644
--- a/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderPhilipsDICOMFileReader.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderPhilipsDICOMFileReader.cpp
@@ -1,95 +1,97 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include "mitkDiffusionHeaderPhilipsDICOMFileReader.h"
 
 #include <sstream>
 
+#include <vnl/vnl_math.h>
+
 mitk::DiffusionHeaderPhilipsDICOMFileReader::DiffusionHeaderPhilipsDICOMFileReader()
 {
 }
 
 mitk::DiffusionHeaderPhilipsDICOMFileReader::~DiffusionHeaderPhilipsDICOMFileReader()
 {
 
 }
 
 bool mitk::DiffusionHeaderPhilipsDICOMFileReader::ReadDiffusionHeader(std::string filename)
 {
   gdcm::Reader gdcmReader;
   gdcmReader.SetFileName( filename.c_str() );
 
   gdcmReader.Read();
 
   gdcm::Tag philips_bvalue_tag( 0x2001, 0x1003 );
   //gdcm::Tag philips_gradient_direction( 0x2001, 0x1004 );
 
   DiffusionImageDICOMHeaderInformation header_info;
   //std::string tagvalue_string;
   //char* pEnd;
 
   // reveal b-value
   float bvalue = 0;
   if( RevealBinaryTagC( philips_bvalue_tag, gdcmReader.GetFile().GetDataSet(), (char*) &bvalue) )
   {
 
     header_info.b_value = std::ceil( bvalue );
 
     if( header_info.b_value == 0)
       header_info.baseline = true;
   }
   else
   {
     MITK_WARN("diffusion.dicomreader.philips") << "No b-value found. Most probably no diffusion-weighted image.";
     return false;
   }
 
   gdcm::Tag philips_new_bvalue_tag( 0x0018,0x9087 );
   double dbvalue = 0;
   if( RevealBinaryTagC( philips_new_bvalue_tag, gdcmReader.GetFile().GetDataSet(), (char*) &dbvalue) )
   {
     MITK_INFO("philips.dicom.diffusion.bvalue") << dbvalue;
   }
 
   if( header_info.baseline )
   {
     // no direction in unweighted images
     header_info.g_vector.fill(0);
   }
   else
   {
     MITK_INFO("philips.dicom.diffusion.gradientdir") << "Parsing gradient direction.";
 
     gdcm::Tag philips_gradient_direction_new( 0x0018, 0x9089 );
     double gr_dir_arr[3] = {1,0,-1};
 
     if( RevealBinaryTagC( philips_gradient_direction_new, gdcmReader.GetFile().GetDataSet(), (char*) &gr_dir_arr ) )
     {
       MITK_INFO("philips.dicom.diffusion.gradient") << "(" << gr_dir_arr[0] <<"," << gr_dir_arr[1] <<"," <<gr_dir_arr[2] <<")";
     }
 
     header_info.g_vector.copy_in( &gr_dir_arr[0] );
     if( header_info.g_vector.two_norm() < vnl_math::eps )
     {
       header_info.g_vector.fill(1);
       header_info.isotropic = true;
     }
   }
 
   this->m_HeaderInformationList.push_back( header_info );
 
   return true;
 }
diff --git a/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderSiemensDICOMFileHelper.cpp b/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderSiemensDICOMFileHelper.cpp
index 043f5e94f2..d5e17f2e14 100644
--- a/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderSiemensDICOMFileHelper.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderSiemensDICOMFileHelper.cpp
@@ -1,42 +1,42 @@
 #include "mitkDiffusionHeaderSiemensDICOMFileHelper.h"
 
 #include <cstdlib>
 #include <cmath>
 
 mitk::SiemensDiffusionHeaderType mitk::GetHeaderType( std::string header )
 {
   // The CSA2 format begins with the string ‘SV10’, the CSA1 format does not.
   if( header.find("SV10") != std::string::npos )
   {
     return mitk::SIEMENS_CSA2;
   }
   else
   {
     return mitk::SIEMENS_CSA1;
   }
 }
 
 bool mitk::ParseInputString( std::string input, std::vector<double>& values, Siemens_Header_Format format_specs )
 {
-
   // TODO : Compute offset based on the format_specs, where does the 84 come from???
   int offset = 84;
   int vm = *(input.c_str() + format_specs.NameLength );
 
   for (int k = 0; k < vm; k++)
   {
     int itemLength = *(input.c_str() + offset + 4);
 
     int strideSize = static_cast<int> (ceil(static_cast<double>(itemLength)/4) * 4);
     std::string valueString = input.substr( offset+16, itemLength );
 
     double value = atof( valueString.c_str() );
     values.push_back( value );
 
     offset += 16+strideSize;
   }
 
-  return true;
+  // If there are no values it is invalid
+  return (values.size() > 0 );
 }
 
 
diff --git a/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderSiemensDICOMFileReader.cpp b/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderSiemensDICOMFileReader.cpp
index 62416888ca..5cf26e5b8e 100644
--- a/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderSiemensDICOMFileReader.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/DicomImport/mitkDiffusionHeaderSiemensDICOMFileReader.cpp
@@ -1,151 +1,152 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include "mitkDiffusionHeaderSiemensDICOMFileReader.h"
 #include "mitkDiffusionHeaderSiemensDICOMFileHelper.h"
 
 #include "gdcmScanner.h"
 #include "gdcmReader.h"
 
+#include <vnl/vnl_math.h>
 
 /**
  * @brief Extract b value from the siemens diffusion tag
  */
 bool mitk::DiffusionHeaderSiemensDICOMFileReader
 ::ExtractSiemensDiffusionTagInformation( std::string tag_value, mitk::DiffusionImageDICOMHeaderInformation& values)
 {
   SiemensDiffusionHeaderType hformat = mitk::GetHeaderType( tag_value );
   Siemens_Header_Format specs = this->m_SiemensFormatsCollection.at( hformat );
 
   MITK_DEBUG << " Header format: " << hformat;
   MITK_DEBUG << " :: Retrieving b value. ";
 
   std::string::size_type tag_position =
       tag_value.find( "B_value", 0 );
 
   if( tag_position == std::string::npos )
   {
     MITK_ERROR << "No b value information found. ";
     return false;
   }
 
   std::string value_string = tag_value.substr( tag_position, tag_value.size() - tag_position + 1 );
 
   std::vector<double> value_array;
   if( ParseInputString(value_string, value_array, specs) )
   {
     values.b_value = value_array.at(0);
   }
   else
   {
     MITK_INFO("diffusion.dicomreader.siemens") << "No b-value tag found. ";
     return false;
   }
 
   // search for GradientDirectionInformation if the bvalue is not null
   if( values.b_value > 0 )
   {
     std::string::size_type tag_position = tag_value.find( "DiffusionGradientDirection", 0 );
     // Possibly it is a IVIM dataset, i.e. the gradient direction is not relevant
     // and possibly either not set or set to zero
     if( tag_position == std::string::npos )
     {
       MITK_WARN << "No gradient direction information, but non-zero b-value. Possibly an IVIM dataset. " << "\n"
                 << "Setting gradient to (1,1,1).";
 
       values.isotropic = true;
       values.g_vector.fill(1);
       return false;
     }
 
     value_array.clear();
     std::string gradient_direction_str = tag_value.substr( tag_position, tag_value.size() - tag_position + 1 );
 
     if( ParseInputString(gradient_direction_str, value_array, specs) )
     {
       if( value_array.size() != 3 )
       {
         MITK_ERROR << " Retrieved gradient information of length " << value_array.size();
         return false;
       }
 
       for( unsigned int i=0; i<value_array.size(); i++)
       {
         values.g_vector[i] = value_array.at(i);
       }
 
       // Test for isotropic data (i.e. IVIM)
       if( values.g_vector.two_norm() < vnl_math::eps )
       {
         values.g_vector.fill(1);
         values.isotropic = true;
       }
     }
 
   }
   else
   {
     values.baseline = true;
   }
 
   return true;
 }
 
 mitk::DiffusionHeaderSiemensDICOMFileReader
 ::DiffusionHeaderSiemensDICOMFileReader()
 {
   Siemens_Header_Format Siemens_CSA1_Format( 64, sizeof(int32_t), 4, sizeof(int32_t), sizeof(int32_t)  );
   Siemens_Header_Format Siemens_CSA2_Format( 64, sizeof(int32_t), 4, sizeof(int32_t), sizeof(int32_t)  );
 
   m_SiemensFormatsCollection.push_back( Siemens_CSA1_Format );
   m_SiemensFormatsCollection.push_back( Siemens_CSA2_Format );
 }
 
 mitk::DiffusionHeaderSiemensDICOMFileReader
 ::~DiffusionHeaderSiemensDICOMFileReader()
 {
 
 }
 
 bool mitk::DiffusionHeaderSiemensDICOMFileReader
 ::ReadDiffusionHeader(std::string filename)
 {
   gdcm::Reader gdcmReader;
   gdcmReader.SetFileName( filename.c_str() );
 
   gdcmReader.Read();
 
   MITK_INFO << " -- Analyzing: " << filename;
 
   const gdcm::DataSet& dataset = gdcmReader.GetFile().GetDataSet();
 
   const gdcm::Tag t_sie_diffusion( 0x0029,0x1010 );
   //const gdcm::Tag t_sie_diffusion_vec( 0x0029,0x100e );
   //const gdcm::Tag t_sie_diffusion2( 0x0029,0x100c );
 
   std::string siemens_diffusionheader_str;
   if( RevealBinaryTag( t_sie_diffusion, dataset, siemens_diffusionheader_str ) )
   {
     DiffusionImageDICOMHeaderInformation values;
     this->ExtractSiemensDiffusionTagInformation( siemens_diffusionheader_str, values );
 
     m_HeaderInformationList.push_back( values );
   }
 
   return true;
 
 
 }
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImage.h b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImage.h
deleted file mode 100644
index b5d61d4946..0000000000
--- a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImage.h
+++ /dev/null
@@ -1,218 +0,0 @@
-/*===================================================================
-
-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 __mitkDiffusionImage__h
-#define __mitkDiffusionImage__h
-
-#include "mitkImage.h"
-#include "itkVectorImage.h"
-#include "itkVectorImageToImageAdaptor.h"
-#include <itkImageDuplicator.h>
-#include "MitkDiffusionCoreExports.h"
-
-namespace mitk
-{
-
-/**
-  * \brief this class encapsulates diffusion volumes (vectorimages not
-  * yet supported by mitkImage)
-  */
-template< class TPixelType >
-class MITK_EXPORT DiffusionImage : public Image
-{
-
-public:
-  typedef typename itk::VectorImage<TPixelType, 3>                    ImageType;
-  typedef vnl_vector_fixed< double, 3 >                               GradientDirectionType;
-  typedef itk::VectorContainer< unsigned int,GradientDirectionType >  GradientDirectionContainerType;
-  typedef GradientDirectionContainerType::Pointer                     GradientDirectionContainerTypePointer;
-  typedef vnl_matrix_fixed< double, 3, 3 >                            MeasurementFrameType;
-  typedef std::vector< unsigned int >                                 IndicesVector;
-  typedef itk::VectorImage< TPixelType, 3 >                           ItkDwiType;
-  typedef itk::ImageDuplicator< ItkDwiType >                          DwiDuplicatorType;
-
-  /**
-   * \brief The BValueMap contains seperated IndicesVectors for each b value (index for GradientDirectionContainer)
-   * key   := b value
-   * value := indicesVector
-  */
-  typedef std::map< unsigned int , IndicesVector >                    BValueMap;
-
-  mitkClassMacro( DiffusionImage, Image )
-  itkFactorylessNewMacro(Self)
-  itkCloneMacro(Self)
-  mitkCloneMacro(Self)
-
-  /**
-  * \brief Return the itkVectorImage as pointer
-  */
-  typename ImageType::Pointer GetVectorImage();
-
-  /**
-  * \brief Return the itkVectorImage as const pointer
-  */
-  const typename ImageType::Pointer GetVectorImage() const;
-
-  /**
-  * \brief Set the itkVectorImage
-  *
-  * \param SmartPointer ofitk::VectorImage
-  */
-  void SetVectorImage(typename ImageType::Pointer image );
-
-  /**
-  * \brief Initialize the mitkImage (base-class) using the first b-zero value of the itkVectorImage
-  *
-  * \warning First set itkVectorImage, GradientDirectionContainer and the b value of the image.
-  * Has to be called.
-  */
-  void InitializeFromVectorImage();
-
-  /**
-  * \brief Return the directions as GradientDirectionContainer const pointer
-  *
-  * \warning MeasurementFrame already applied
-  */
-  GradientDirectionContainerType::Pointer GetDirections() const;
-
-  /**
-  * \brief Return the directions as GradientDirectionContainer const pointer
-  *
-  * \warning no MeasurmentFrame applied
-  */
-  GradientDirectionContainerType::Pointer GetDirectionsWithoutMeasurementFrame() const;
-
-  /**
-  * \brief Set the original and current GradientDirectionContainer
-  * \param GradientdirectionContainer as pointer
-  * \warning Replace the original (m_OriginalDirections) and current (m_Directions) GradientDirectionContainer.
-  * For the current directions the MeasurmentFrame is applied. Remove existing GradientDirectionContainer observer
-  * of m_Directions and add a new observer to it (observer update the m_B_ValueMap if modifications occours on the container)
-  */
-  void SetDirections( GradientDirectionContainerType::Pointer directions );
-
-  /**
-  * \brief Set the original and current GradientDirectionContainer
-  * \param std::vector<itk::Vector<double,3> >
-  * \warning Replace the original (m_OriginalDirections) and current (m_Directions) GradientDirectionContainer.
-  * For the current directions the MeasurmentFrame is applied.
-  * Remove existing GradientDirectionContainer observer of m_Directions and add a new observer to it
-  * (observer update the m_B_ValueMap if modifications occours on the container).
-  * Calls the overloaded GradientDirectionContainer pointer version of the method.
-  */
-  void SetDirections( const std::vector<itk::Vector<double,3> > & directions );
-
-  /**
-  * \brief Return a copy of the MeasurmentFrame (m_MeasurementFrame)
-  */
-  MeasurementFrameType GetMeasurementFrame() const;
-
-  /**
-  * \brief Set the MeasurementFrame
-  *
-  * \param Const reference of MeasurementFrameType
-  */
-  void SetMeasurementFrame( const MeasurementFrameType & mFrame );
-
-  /**
-  * \brief Return true if gradients of with diffrent b-values exist
-  */
-  bool GetNumberOfBValues() const;
-
-  /**
-  * \brief Return a BValueMap (key: b value, Value: IndicesVector of the GradientDirectionContainer)
-  */
-  const BValueMap & GetBValueMap() const;
-
-  /**
-  * \brief Return the reference b value
-  * GradientsLength * referenceBValue encoding the true b value of the corresponding GradientDirection
-  */
-  float GetReferenceBValue() const;
-
-  /**
-  * \brief Set the reference b value s
-  */
-  void SetReferenceBValue( float val );
-
-  GradientDirectionContainerType::Pointer CalcAveragedDirectionSet(double precision, GradientDirectionContainerType::Pointer directions);
-  void AverageRedundantGradients(double precision);
-  void SetDisplayIndexForRendering(int displayIndex);
-
-protected:
-  DiffusionImage();
-  DiffusionImage(const DiffusionImage<TPixelType> &);
-  virtual ~DiffusionImage();
-
-  // Helper Methods
-  bool AreAlike(GradientDirectionType g1, GradientDirectionType g2, double precision);
-  float GetB_Value(unsigned int i);
-
-  /**
-  * \brief Apply the previouse set MeasurmentFrame to all gradients in the GradientsDirectionContainer (m_Directions)
-  *
-  * \warning first set the MeasurmentFrame
-  */
-  void ApplyMeasurementFrame();
-
-  /**
-  * \brief Update the BValueMap (m_B_ValueMap) using the current gradient directions (m_Directions)
-  *
-  * \warning Have to be called after each manipulation on the GradientDirectionContainer
-  * !especially after manipulation of the m_Directions (GetDirections()) container via pointer access!
-  */
-  void UpdateBValueMap();
-
-  typename ImageType::Pointer               m_VectorImage;
-  float                                     m_B_Value;
-  MeasurementFrameType                      m_MeasurementFrame;
-  GradientDirectionContainerType::Pointer   m_OriginalDirections;
-  GradientDirectionContainerType::Pointer   m_Directions;
-  int                                       m_DisplayIndex;
-  BValueMap                                 m_B_ValueMap;
-
-};
-
-/**
-* @brief Equal A function comparing two images for beeing equal in meta- and imagedata
-*
-* @ingroup MITKTestingAPI
-*
-* Following aspects are tested for equality:
-*  - mitk image equal test
-*  - GradientDirectionContainer
-*  - MeasurementFrame
-*  - reference BValue
-*  - BValueMap
-*  - itkVectorImage
-*
-* @param rightHandSide An image to be compared
-* @param leftHandSide An image to be compared
-* @param eps Tolarence for comparison. You can use mitk::eps in most cases.
-* @param verbose Flag indicating if the user wants detailed console output or not.
-* @return true, if all subsequent comparisons are true, false otherwise
-*/
-
-template<class TPixelType>
-inline bool Equal(const mitk::DiffusionImage<TPixelType> &leftHandSide, const mitk::DiffusionImage<TPixelType> &rightHandSide, ScalarType eps, bool verbose );
-
-
-} // namespace mitk
-
-#include "mitkDiffusionImage.txx"
-
-#endif /* __mitkDiffusionImage__h */
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImage.txx b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImage.txx
deleted file mode 100644
index 75baf432c6..0000000000
--- a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImage.txx
+++ /dev/null
@@ -1,631 +0,0 @@
-/*===================================================================
-
-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.
-
-===================================================================*/
-
-#include "itkImageRegionIterator.h"
-#include "itkImageRegionConstIterator.h"
-#include "mitkImageCast.h"
-
-#include "mitkDiffusionImage.h"
-
-#include "itkImageDuplicator.h"
-#include "itkTestingComparisonImageFilter.h"
-
-
-template<typename TPixelType>
-mitk::DiffusionImage<TPixelType>::DiffusionImage()
-  : m_VectorImage(0), m_B_Value(-1.0), m_OriginalDirections(0), m_Directions(0)
-{
-  MeasurementFrameType mf;
-  for(int i=0; i<3; i++)
-    for(int j=0; j<3; j++)
-      mf[i][j] = 0;
-  for(int i=0; i<3; i++)
-    mf[i][i] = 1;
-  m_MeasurementFrame = mf;
-}
-
-template<typename TPixelType>
-mitk::DiffusionImage<TPixelType>::DiffusionImage(const DiffusionImage<TPixelType> & orig)
-  : mitk::Image(orig),
-    m_VectorImage( 0 ),
-    m_B_Value(0),
-    m_OriginalDirections(0),
-    m_Directions(0)
-{
-  // Deep copy VectorImage
-  typename itk::ImageDuplicator<ImageType>::Pointer duplicator = itk::ImageDuplicator<ImageType>::New();
-  duplicator->SetInputImage( orig.m_VectorImage );
-  duplicator->Update();
-
-  GradientDirectionContainerType::ConstIterator origIt;
-  GradientDirectionContainerType::ConstIterator origItEnd;
-
-  // Deep Copy OrignalDirectioncontainer
-  GradientDirectionContainerType::Pointer OriginalDirectionscontainer = GradientDirectionContainerType::New();
-  origIt = orig.GetDirectionsWithoutMeasurementFrame()->Begin();
-  origItEnd = orig.GetDirectionsWithoutMeasurementFrame()->End();
-
-  for(;origIt != origItEnd; ++origIt)
-    OriginalDirectionscontainer->push_back(origIt.Value());
-
-  // Deep Copy Directioncontainer
-  GradientDirectionContainerType::Pointer DirectionsContainer = GradientDirectionContainerType::New();
-  origIt = orig.GetDirections()->Begin();
-  origItEnd = orig.GetDirections()->End();
-
-  for(;origIt != origItEnd; ++origIt)
-    DirectionsContainer->push_back(origIt.Value());
-
-  // Set member of the new clone
-  m_VectorImage = duplicator->GetOutput();
-  m_B_Value = orig.GetReferenceBValue();
-  m_OriginalDirections = OriginalDirectionscontainer;
-  m_Directions = DirectionsContainer;
-  m_MeasurementFrame = orig.GetMeasurementFrame();
-  ApplyMeasurementFrame();
-  UpdateBValueMap();
-  InitializeFromVectorImage();
-
-  //  m_VectorImage = duplicator->GetOutput();
-  //  m_B_Value = orig.GetB_Value();
-  //  m_MeasurementFrame = orig.GetMeasurementFrame();
-  //  m_Directions = copyInContainer;
-  //  m_OriginalDirections = copyInContainer;
-
-
-}
-
-
-template<typename TPixelType>
-mitk::DiffusionImage<TPixelType>::~DiffusionImage()
-{
-  // Remove Observer for m_Directions
-  //RemoveObserver();
-}
-
-template<typename TPixelType>
-void mitk::DiffusionImage<TPixelType>
-::InitializeFromVectorImage()
-{
-  if(!m_VectorImage || !m_Directions || m_B_Value==-1.0)
-  {
-    MITK_INFO << "DiffusionImage could not be initialized. Set all members first!" << std::endl;
-    // Fehjlermedlung updaten
-    return;
-  }
-
-  // find bzero index
-  int firstZeroIndex = -1;
-  for(GradientDirectionContainerType::ConstIterator it = m_Directions->Begin();
-      it != m_Directions->End(); ++it)
-  {
-    firstZeroIndex++;
-    GradientDirectionType g = it.Value();
-    if(g[0] == 0 && g[1] == 0 && g[2] == 0 )
-      break;
-  }
-
-  typedef itk::Image<TPixelType,3> ImgType;
-  typename ImgType::Pointer img = ImgType::New();
-  img->SetSpacing( m_VectorImage->GetSpacing() );   // Set the image spacing
-  img->SetOrigin( m_VectorImage->GetOrigin() );     // Set the image origin
-  img->SetDirection( m_VectorImage->GetDirection() );  // Set the image direction
-  img->SetLargestPossibleRegion( m_VectorImage->GetLargestPossibleRegion());
-  img->SetBufferedRegion( m_VectorImage->GetLargestPossibleRegion() );
-  img->Allocate();
-
-  int vecLength = m_VectorImage->GetVectorLength();
-  InitializeByItk( img.GetPointer(), 1, vecLength );
-
-  itk::ImageRegionIterator<ImgType> itw (img, img->GetLargestPossibleRegion() );
-  itw.GoToBegin();
-
-  itk::ImageRegionConstIterator<ImageType> itr (m_VectorImage, m_VectorImage->GetLargestPossibleRegion() );
-  itr.GoToBegin();
-
-  while(!itr.IsAtEnd())
-  {
-    itw.Set(itr.Get().GetElement(firstZeroIndex));
-    ++itr;
-    ++itw;
-  }
-
-  // init
-  SetImportVolume(img->GetBufferPointer());
-
-  m_DisplayIndex = firstZeroIndex;
-  MITK_INFO << "Diffusion-Image successfully initialized.";
-}
-
-template<typename TPixelType>
-void mitk::DiffusionImage<TPixelType>
-::SetDisplayIndexForRendering(int displayIndex)
-{
-  int index = displayIndex;
-  int vecLength = m_VectorImage->GetVectorLength();
-  index = index > vecLength-1 ? vecLength-1 : index;
-  if( m_DisplayIndex != index )
-  {
-    typedef itk::Image<TPixelType,3> ImgType;
-    typename ImgType::Pointer img = ImgType::New();
-    CastToItkImage(this, img);
-
-    itk::ImageRegionIterator<ImgType> itw (img, img->GetLargestPossibleRegion() );
-    itw.GoToBegin();
-
-    itk::ImageRegionConstIterator<ImageType> itr (m_VectorImage, m_VectorImage->GetLargestPossibleRegion() );
-    itr.GoToBegin();
-
-    while(!itr.IsAtEnd())
-    {
-      itw.Set(itr.Get().GetElement(index));
-      ++itr;
-      ++itw;
-    }
-  }
-
-  m_DisplayIndex = index;
-}
-
-template<typename TPixelType>
-bool mitk::DiffusionImage<TPixelType>::AreAlike(GradientDirectionType g1,
-                                                GradientDirectionType g2,
-                                                double precision)
-{
-  GradientDirectionType diff = g1 - g2;
-  GradientDirectionType diff2 = g1 + g2;
-  return diff.two_norm() < precision || diff2.two_norm() < precision;
-}
-
-
-template<typename TPixelType>
-mitk::DiffusionImage<TPixelType>::GradientDirectionContainerType::Pointer
-mitk::DiffusionImage<TPixelType>::CalcAveragedDirectionSet(double precision, GradientDirectionContainerType::Pointer directions)
-{
-  // save old and construct new direction container
-  GradientDirectionContainerType::Pointer newDirections = GradientDirectionContainerType::New();
-
-  // fill new direction container
-  for(GradientDirectionContainerType::ConstIterator gdcitOld = directions->Begin();
-      gdcitOld != directions->End(); ++gdcitOld)
-  {
-    // already exists?
-    bool found = false;
-    for(GradientDirectionContainerType::ConstIterator gdcitNew = newDirections->Begin();
-        gdcitNew != newDirections->End(); ++gdcitNew)
-    {
-      if(AreAlike(gdcitNew.Value(), gdcitOld.Value(), precision))
-      {
-        found = true;
-        break;
-      }
-    }
-
-    // if not found, add it to new container
-    if(!found)
-    {
-      newDirections->push_back(gdcitOld.Value());
-    }
-  }
-
-  return newDirections;
-}
-
-template<typename TPixelType>
-void mitk::DiffusionImage<TPixelType>::AverageRedundantGradients(double precision)
-{
-
-  GradientDirectionContainerType::Pointer newDirs =
-      CalcAveragedDirectionSet(precision, m_Directions);
-
-  GradientDirectionContainerType::Pointer newOriginalDirs =
-      CalcAveragedDirectionSet(precision, m_OriginalDirections);
-
-  // if sizes equal, we do not need to do anything in this function
-  if(m_Directions->size() == newDirs->size() || m_OriginalDirections->size() == newOriginalDirs->size())
-    return;
-
-  GradientDirectionContainerType::Pointer oldDirections = m_OriginalDirections;
-  m_Directions = newDirs;
-  m_OriginalDirections = newOriginalDirs;
-
-  // new image
-  typename ImageType::Pointer oldImage = m_VectorImage;
-  m_VectorImage = ImageType::New();
-  m_VectorImage->SetSpacing( oldImage->GetSpacing() );   // Set the image spacing
-  m_VectorImage->SetOrigin( oldImage->GetOrigin() );     // Set the image origin
-  m_VectorImage->SetDirection( oldImage->GetDirection() );  // Set the image direction
-  m_VectorImage->SetLargestPossibleRegion( oldImage->GetLargestPossibleRegion() );
-  m_VectorImage->SetVectorLength( m_Directions->size() );
-  m_VectorImage->SetBufferedRegion( oldImage->GetLargestPossibleRegion() );
-  m_VectorImage->Allocate();
-
-  // average image data that corresponds to identical directions
-  itk::ImageRegionIterator< ImageType > newIt(m_VectorImage, m_VectorImage->GetLargestPossibleRegion());
-  newIt.GoToBegin();
-  itk::ImageRegionIterator< ImageType > oldIt(oldImage, oldImage->GetLargestPossibleRegion());
-  oldIt.GoToBegin();
-
-  // initial new value of voxel
-  typename ImageType::PixelType newVec;
-  newVec.SetSize(m_Directions->size());
-  newVec.AllocateElements(m_Directions->size());
-
-  std::vector<std::vector<int> > dirIndices;
-  for(GradientDirectionContainerType::ConstIterator gdcitNew = m_Directions->Begin();
-      gdcitNew != m_Directions->End(); ++gdcitNew)
-  {
-    dirIndices.push_back(std::vector<int>(0));
-    for(GradientDirectionContainerType::ConstIterator gdcitOld = oldDirections->Begin();
-        gdcitOld != oldDirections->End(); ++gdcitOld)
-    {
-      if(AreAlike(gdcitNew.Value(), gdcitOld.Value(), precision))
-      {
-        //MITK_INFO << gdcitNew.Value() << "  " << gdcitOld.Value();
-        dirIndices[gdcitNew.Index()].push_back(gdcitOld.Index());
-      }
-    }
-  }
-
-  //int ind1 = -1;
-  while(!newIt.IsAtEnd())
-  {
-
-    // progress
-    //typename ImageType::IndexType ind = newIt.GetIndex();
-    //ind1 = ind.m_Index[2];
-
-    // init new vector with zeros
-    newVec.Fill(0.0);
-
-    // the old voxel value with duplicates
-    typename ImageType::PixelType oldVec = oldIt.Get();
-
-    for(unsigned int i=0; i<dirIndices.size(); i++)
-    {
-      // do the averaging
-      const unsigned int numavg = dirIndices[i].size();
-      unsigned int sum = 0;
-      for(unsigned int j=0; j<numavg; j++)
-      {
-        //MITK_INFO << newVec[i] << " << " << oldVec[dirIndices[i].at(j)];
-        sum += oldVec[dirIndices[i].at(j)];
-      }
-      if(numavg == 0)
-      {
-        MITK_ERROR << "mitkDiffusionImage: Error on averaging. Possibly due to corrupted data";
-        return;
-      }
-      newVec[i] = sum / numavg;
-    }
-
-    newIt.Set(newVec);
-
-    ++newIt;
-    ++oldIt;
-  }
-  ApplyMeasurementFrame();
-  UpdateBValueMap();
-  std::cout << std::endl;
-}
-
-template<typename TPixelType>
-void mitk::DiffusionImage<TPixelType>::ApplyMeasurementFrame()
-{
-  if(m_OriginalDirections.IsNull())
-  {
-    // original direction container was not set
-    return;
-  }
-
-  m_Directions = GradientDirectionContainerType::New();
-  int c = 0;
-  for(GradientDirectionContainerType::ConstIterator gdcit = m_OriginalDirections->Begin();
-      gdcit != m_OriginalDirections->End(); ++gdcit)
-  {
-    vnl_vector<double> vec = gdcit.Value();
-    vec = vec.pre_multiply(m_MeasurementFrame);
-    m_Directions->InsertElement(c, vec);
-    c++;
-  }
-}
-
-template<typename TPixelType>
-void mitk::DiffusionImage<TPixelType>::UpdateBValueMap()
-{
-  if(!m_B_ValueMap.empty())
-    m_B_ValueMap.clear();
-
-  GradientDirectionContainerType::ConstIterator gdcit;
-  for( gdcit = this->m_Directions->Begin(); gdcit != this->m_Directions->End(); ++gdcit)
-    m_B_ValueMap[this->GetB_Value(gdcit.Index())].push_back(gdcit.Index());
-}
-
-template<typename TPixelType>
-float mitk::DiffusionImage<TPixelType>::GetB_Value(unsigned int i)
-{
-  if(i > m_Directions->Size()-1)
-    return -1;
-
-  if(m_Directions->ElementAt(i).one_norm() <= 0.0)
-  {
-    return 0;
-  }
-  else
-  {
-    double twonorm = m_Directions->ElementAt(i).two_norm();
-    double bval = m_B_Value*twonorm*twonorm;
-
-    if (bval<0)
-      bval = ceil(bval - 0.5);
-    else
-      bval = floor(bval + 0.5);
-
-    return bval;
-  }
-}
-
-template<typename TPixelType>
-void mitk::DiffusionImage<TPixelType>::SetDirections( GradientDirectionContainerType::Pointer directions )
-{
-  this->m_OriginalDirections = directions;
-  ApplyMeasurementFrame();
-  UpdateBValueMap();
-}
-
-template<typename TPixelType>
-void mitk::DiffusionImage<TPixelType>::SetDirections(const std::vector<itk::Vector<double, 3> > &directions)
-{
-  GradientDirectionContainerType::Pointer tempContainer = GradientDirectionContainerType::New();
-  for(unsigned int i=0; i<directions.size(); i++)
-    tempContainer->InsertElement( i, directions[i].GetVnlVector() );
-  SetDirections(tempContainer);
-}
-
-template<typename TPixelType>
-typename mitk::DiffusionImage<TPixelType>::MeasurementFrameType mitk::DiffusionImage<TPixelType>::GetMeasurementFrame() const
-{
-  return m_MeasurementFrame;
-}
-
-template<typename TPixelType>
-void mitk::DiffusionImage<TPixelType>::SetMeasurementFrame( const MeasurementFrameType & mFrame )
-{
-  m_MeasurementFrame = mFrame;
-  ApplyMeasurementFrame();
-}
-
-template<typename TPixelType>
-bool mitk::DiffusionImage<TPixelType>::GetNumberOfBValues() const
-{
-  return m_B_ValueMap.size();
-}
-
-template<typename TPixelType>
-const typename mitk::DiffusionImage<TPixelType>::BValueMap & mitk::DiffusionImage<TPixelType>::GetBValueMap() const
-{
-  return m_B_ValueMap;
-}
-
-template<typename TPixelType>
-float mitk::DiffusionImage<TPixelType>::GetReferenceBValue() const
-{
-  return m_B_Value;
-}
-
-template<typename TPixelType>
-void mitk::DiffusionImage<TPixelType>::SetReferenceBValue( float val )
-{
-  m_B_Value = val;
-}
-
-template<typename TPixelType>
-typename mitk::DiffusionImage<TPixelType>::GradientDirectionContainerTypePointer mitk::DiffusionImage<TPixelType>::GetDirections() const
-{
-  return m_Directions;
-}
-
-template<typename TPixelType>
-typename mitk::DiffusionImage<TPixelType>::GradientDirectionContainerTypePointer mitk::DiffusionImage<TPixelType>::GetDirectionsWithoutMeasurementFrame() const
-{
-  return m_OriginalDirections;
-}
-
-template<typename TPixelType>
-typename itk::VectorImage<TPixelType, 3>::Pointer mitk::DiffusionImage<TPixelType>::GetVectorImage()
-{
-  return m_VectorImage;
-}
-
-template<typename TPixelType>
-const typename itk::VectorImage<TPixelType, 3>::Pointer mitk::DiffusionImage<TPixelType>::GetVectorImage() const
-{
-  return m_VectorImage;
-}
-
-template<typename TPixelType>
-void mitk::DiffusionImage<TPixelType>::SetVectorImage(typename ImageType::Pointer image )
-{
-  m_VectorImage = image;
-}
-
-template<class TPixelType>
-inline bool mitk::Equal(const mitk::DiffusionImage<TPixelType>& leftHandSide, const mitk::DiffusionImage<TPixelType> &rightHandSide, ScalarType eps, bool verbose )
-{
-
-  bool returnValue = true;
-
-  if(leftHandSide.GetReferenceBValue() != rightHandSide.GetReferenceBValue())
-  {
-    if(verbose)
-      MITK_INFO << "[( DiffusionImage )] Reference BValue is not Equal.";
-    returnValue = false;
-  }
-
-  if(leftHandSide.GetMeasurementFrame() != rightHandSide.GetMeasurementFrame())
-  {
-    if(verbose)
-      MITK_INFO << "[( DiffusionImage )] MeasurementFrame is not Equal.";
-    returnValue = false;
-  }
-
-  if(leftHandSide.GetBValueMap().size() != rightHandSide.GetBValueMap().size())
-  {
-    if(verbose)
-      MITK_INFO << "[( DiffusionImage )] BValue Map: Size is not Equal.";
-    returnValue = false;
-  }
-
-  if(leftHandSide.GetNumberOfBValues() != rightHandSide.GetNumberOfBValues())
-  {
-    if(verbose)
-      MITK_INFO << "[( DiffusionImage )] BValue Map (GetNumberOfBValues): Size is not Equal.";
-    returnValue = false;
-  }
-
-  // Slow testing area
-
-  const mitk::Image* img1 = dynamic_cast<const mitk::Image*>(&leftHandSide);
-  const mitk::Image* img2 = dynamic_cast<const mitk::Image*>(&rightHandSide);
-
-  if(mitk::Equal(*img1,*img2,eps,verbose) == false)
-  {
-    if(verbose)
-      MITK_INFO << "[( DiffusionImage )] Base-Class (mitk::Image) is not Equal.";
-    returnValue = false;
-  }
-
-  {
-    typename mitk::DiffusionImage<TPixelType>::GradientDirectionContainerType::Iterator lhsIt = leftHandSide.GetDirectionsWithoutMeasurementFrame()->Begin();
-    typename mitk::DiffusionImage<TPixelType>::GradientDirectionContainerType::Iterator lhsItEnd = leftHandSide.GetDirectionsWithoutMeasurementFrame()->End();
-    typename mitk::DiffusionImage<TPixelType>::GradientDirectionContainerType::Iterator rhsIt = rightHandSide.GetDirectionsWithoutMeasurementFrame()->Begin();
-
-    for(;lhsIt != lhsItEnd;)
-    {
-      bool vectorNotEqual = false;
-      for(unsigned int i = 0 ; i < lhsIt.Value().size(); i++)
-          vectorNotEqual |= !mitk::Equal(lhsIt.Value().get(i),rhsIt.Value().get(i),0.0001);
-
-      if(vectorNotEqual)
-      {
-        if(verbose)
-          MITK_INFO << "[( DiffusionImage )] Original GradientDirections are not Equal.";
-        returnValue = false;
-        break;
-      }
-      ++rhsIt;
-      ++lhsIt;
-    }
-  }
-
-  {
-    typename mitk::DiffusionImage<TPixelType>::GradientDirectionContainerType::Iterator lhsIt = leftHandSide.GetDirections()->Begin();
-    typename mitk::DiffusionImage<TPixelType>::GradientDirectionContainerType::Iterator lhsItEnd = leftHandSide.GetDirections()->End();
-    typename mitk::DiffusionImage<TPixelType>::GradientDirectionContainerType::Iterator rhsIt = rightHandSide.GetDirections()->Begin();
-
-    for(;lhsIt != lhsItEnd;)
-    {
-      bool vectorNotEqual = false;
-      for(unsigned int i = 0 ; i < lhsIt.Value().size(); i++)
-          vectorNotEqual |= !mitk::Equal(lhsIt.Value().get(i),rhsIt.Value().get(i),0.0001);
-
-      if(vectorNotEqual)
-      {
-        if(verbose)
-          MITK_INFO << "[( DiffusionImage )] GradientDirections are not Equal.";
-        returnValue = false;
-        break;
-      }
-      ++rhsIt;
-      ++lhsIt;
-    }
-  }
-
-  {
-
-    typename mitk::DiffusionImage<TPixelType>::BValueMap rhsMap = rightHandSide.GetBValueMap();
-    typename mitk::DiffusionImage<TPixelType>::BValueMap lhsMap = leftHandSide.GetBValueMap();
-    typename mitk::DiffusionImage<TPixelType>::BValueMap::const_iterator lhsIt = lhsMap.begin();
-    typename mitk::DiffusionImage<TPixelType>::BValueMap::const_iterator lhsItEnd = lhsMap.end();
-    typename mitk::DiffusionImage<TPixelType>::BValueMap::const_iterator rhsIt = rhsMap.begin();
-
-    for(;lhsIt != lhsItEnd;)
-    {
-      if(lhsIt->first != rhsIt->first)
-      {
-        if(verbose)
-          MITK_INFO << "[( DiffusionImage )] BValue Map: lhsKey " <<  lhsIt->first << " != rhsKey " << rhsIt->first << " is not Equal.";
-        returnValue = false;
-        break;
-      }
-
-      if(lhsIt->second.size() != rhsIt->second.size())
-      {
-        if(verbose)
-          MITK_INFO << "[( DiffusionImage )] BValue Map: Indices vector size is not Equal. (Key: " << lhsIt->first <<")";
-        returnValue = false;
-        break;
-      }
-
-
-      typename mitk::DiffusionImage<TPixelType>::IndicesVector::const_iterator lhsIndVecIt = lhsIt->second.begin();
-      typename mitk::DiffusionImage<TPixelType>::IndicesVector::const_iterator lhsIndVecItEnd = lhsIt->second.end();
-      typename mitk::DiffusionImage<TPixelType>::IndicesVector::const_iterator rhsIndVecIt = rhsIt->second.begin();
-
-      for(;lhsIndVecIt != lhsIndVecItEnd;)
-      {
-        if(*lhsIndVecIt != *rhsIndVecIt)
-        {
-          if(verbose)
-            MITK_INFO << "[( DiffusionImage )] BValue Map: Indices are not Equal. (Key: " << lhsIt->first <<")";
-          returnValue = false;
-          break;
-        }
-        ++rhsIndVecIt;
-        ++lhsIndVecIt;
-      }
-
-      lhsIt++;
-      rhsIt++;
-    }
-  }
-
-
-  try{
-    itk::ImageRegionIterator< itk::VectorImage< TPixelType, 3 > > it1(leftHandSide.GetVectorImage(), leftHandSide.GetVectorImage()->GetLargestPossibleRegion());
-    itk::ImageRegionIterator< itk::VectorImage< TPixelType, 3 > > it2(rightHandSide.GetVectorImage(), rightHandSide.GetVectorImage()->GetLargestPossibleRegion());
-    while(!it1.IsAtEnd())
-    {
-      if (it1.Get()!=it2.Get()){
-        if(verbose)
-          MITK_INFO << "[( DiffusionImage )] Capsulated itk::VectorImage is not Equal.";
-        returnValue = false;
-        break;
-      }
-      ++it1;
-      ++it2;
-    }
-  }
-  catch(...)
-  {
-    if(verbose)
-      MITK_INFO << "[( DiffusionImage )] Comparision of itk Vector image abort by exception.";
-    returnValue = false;
-  }
-
-  return returnValue;
-}
-
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageCorrectionFilter.cpp b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageCorrectionFilter.cpp
index 2f909c5b73..d93af7cf2d 100644
--- a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageCorrectionFilter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageCorrectionFilter.cpp
@@ -1,117 +1,118 @@
 /*===================================================================
 
 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 MITKDIFFUSIONIMAGECORRECTIONFILTER_CPP
 #define MITKDIFFUSIONIMAGECORRECTIONFILTER_CPP
 
 #include "mitkDiffusionImageCorrectionFilter.h"
+#include <mitkDiffusionPropertyHelper.h>
 
 #include <vnl/algo/vnl_symmetric_eigensystem.h>
 #include <vnl/vnl_inverse.h>
 
-template< typename TPixelType >
-mitk::DiffusionImageCorrectionFilter<TPixelType>::DiffusionImageCorrectionFilter()
+
+mitk::DiffusionImageCorrectionFilter::DiffusionImageCorrectionFilter()
 {
 
 }
 
-template< typename TPixelType >
-typename mitk::DiffusionImageCorrectionFilter<TPixelType>::TransformMatrixType
-mitk::DiffusionImageCorrectionFilter<TPixelType>
+
+mitk::DiffusionImageCorrectionFilter::TransformMatrixType
+mitk::DiffusionImageCorrectionFilter
 ::GetRotationComponent(const TransformMatrixType &A)
 {
   TransformMatrixType B;
 
   B = A * A.transpose();
 
   // get the eigenvalues and eigenvectors
   typedef double MType;
   vnl_vector< MType > eigvals;
   vnl_matrix< MType > eigvecs;
   vnl_symmetric_eigensystem_compute< MType > ( B, eigvecs, eigvals );
 
   vnl_matrix_fixed< MType, 3, 3 > eigvecs_fixed;
   eigvecs_fixed.set_columns(0, eigvecs );
 
   TransformMatrixType C;
   C.set_identity();
 
   vnl_vector_fixed< MType, 3 > eigvals_sqrt;
   for(unsigned int i=0; i<3; i++)
   {
     C(i,i) = std::sqrt( eigvals[i] );
   }
 
   TransformMatrixType S = vnl_inverse( eigvecs_fixed * C * vnl_inverse( eigvecs_fixed )) * A;
 
   return S;
 }
 
-template< typename TPixelType >
-void mitk::DiffusionImageCorrectionFilter<TPixelType>
+
+void mitk::DiffusionImageCorrectionFilter
 ::CorrectDirections( const TransformsVectorType& transformations)
 {
   if( m_SourceImage.IsNull() )
   {
     mitkThrow() << " No diffusion image given! ";
   }
 
-  GradientDirectionContainerPointerType directions = m_SourceImage->GetDirections();
+  GradientDirectionContainerPointerType directions = static_cast<mitk::GradientDirectionsProperty*>( m_SourceImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
   GradientDirectionContainerPointerType corrected_directions =
       GradientDirectionContainerType::New();
 
   unsigned int transformed = 0;
   for(size_t i=0; i< directions->Size(); i++ )
   {
 
     // skip b-zero images
     if( directions->ElementAt(i).one_norm() <= 0.0 )
     {
       corrected_directions->push_back( directions->ElementAt(i) );
       continue;
     }
 
     GradientDirectionType corrected = GetRotationComponent(
                                           transformations.at(transformed))
                                         * directions->ElementAt(i);
     // store the corrected direction
     corrected_directions->push_back( corrected );
     transformed++;
   }
 
   // replace the old directions with the corrected ones
-  m_SourceImage->SetDirections( corrected_directions );
+  m_SourceImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( corrected_directions ) );
 
 }
 
-template< typename TPixelType >
-void mitk::DiffusionImageCorrectionFilter<TPixelType>
+
+void mitk::DiffusionImageCorrectionFilter
 ::CorrectDirections( const TransformMatrixType& transformation)
 {
   if( m_SourceImage.IsNull() )
   {
     mitkThrow() << " No diffusion image given! ";
   }
   TransformsVectorType transfVec;
-  for (unsigned int i=0; i< m_SourceImage->GetDirections()->Size();i++)
+  for (unsigned int i=0; i< static_cast<mitk::GradientDirectionsProperty*>( m_SourceImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer()->Size();i++)
   {
     transfVec.push_back(transformation);
   }
   this->CorrectDirections(transfVec);
 }
 
 #endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageCorrectionFilter.h b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageCorrectionFilter.h
index 7d6c3b3e59..405cea700d 100644
--- a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageCorrectionFilter.h
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageCorrectionFilter.h
@@ -1,97 +1,96 @@
 /*===================================================================
 
 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 MITKDIFFUSIONIMAGECORRECTIONFILTER_H
 #define MITKDIFFUSIONIMAGECORRECTIONFILTER_H
 
-#include "mitkDiffusionImageSource.h"
+#include "mitkImageSource.h"
+#include <MitkDiffusionCoreExports.h>
 
 namespace mitk
 {
 /**
  * @class DiffusionImageCorrectionFilter
  */
-template< typename TPixelType >
-class DiffusionImageCorrectionFilter
-        : public DiffusionImageSource< TPixelType >
+class MitkDiffusionCore_EXPORT DiffusionImageCorrectionFilter
+        : public ImageSource
 {
 public:
   /** class macros */
   mitkClassMacro( DiffusionImageCorrectionFilter,
-                  DiffusionImageSource<TPixelType> )
+                  ImageSource )
 
   itkSimpleNewMacro(Self)
 
+  typedef short DiffusionPixelType;
   typedef vnl_vector_fixed< double, 3 >      GradientDirectionType;
   typedef vnl_matrix_fixed< double, 3, 3 >   TransformMatrixType;
   typedef itk::VectorContainer< unsigned int, GradientDirectionType >
                                              GradientDirectionContainerType;
   typedef GradientDirectionContainerType::Pointer GradientDirectionContainerPointerType;
 
   typedef std::vector< TransformMatrixType >  TransformsVectorType;
 
-  typedef typename Superclass::OutputType DiffusionImageType;
-  typedef typename DiffusionImageType::Pointer    DiffusionImageTypePointer;
-  typedef itk::VectorImage<TPixelType,3>     ImageType;
+  typedef Superclass::OutputType DiffusionImageType;
+  typedef DiffusionImageType::Pointer    DiffusionImageTypePointer;
+  typedef itk::VectorImage<DiffusionPixelType,3>     ImageType;
 
   /**
    * @brief Set the mitk image ( a 3d+t image ) which is to be reinterpreted as dw image
    * @param mitkImage
    */
   void SetImage( DiffusionImageTypePointer input )
   {
     m_SourceImage = input;
   }
 
   /**
    * @brief Correct each gradient direction according to the given transform
    *
    * The size of the input is expected to correspond to the count of gradient images in the image.
    */
   void CorrectDirections( const TransformsVectorType& );
 
   /**
    * @brief Correct all gradient directions according to the given transform
    *
    * This will apply the same rotation to all directions.
    */
   void CorrectDirections( const TransformMatrixType& );
 
 
 protected:
   DiffusionImageCorrectionFilter();
   virtual ~DiffusionImageCorrectionFilter() {}
 
   /**
    * @brief Get the rotation component following the Finite Strain
    *
    * For a given transformation \f$A\f$ its rotation component is defined as \f$ (AA^{T})^{-1/2}\f$.
    *
    * The computation first computes \f$ B = AA^T \f$ and then estimates the square root. Square root of
    * diagonal matrices is defined as
    *  \f$ S = Q * \sqrt{C} * Q^{-1} \f$ with \f$ C \f$ having the eigenvalues on the diagonal.
    *
    */
   TransformMatrixType GetRotationComponent( const TransformMatrixType& );
 
   DiffusionImageTypePointer m_SourceImage;
 };
 
 }
 
-#include "mitkDiffusionImageCorrectionFilter.cpp"
-
 #endif // MITKDIFFUSIONIMAGECORRECTIONFILTER_H
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSource.cpp b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSource.cpp
deleted file mode 100644
index ce24a5b93e..0000000000
--- a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSource.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-/*===================================================================
-
-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 __MITK_DIFFUSIONIMAGE_SOURCE_CPP__
-#define __MITK_DIFFUSIONIMAGE_SOURCE_CPP__
-
-#include "mitkDiffusionImageSource.h"
-#include "mitkDiffusionImage.h"
-
-template<typename TPixelType>
-mitk::DiffusionImageSource<TPixelType>::DiffusionImageSource()
-{
-  // Create the output. We use static_cast<> here because we know the default
-  // output must be of type DiffusionImage
-  typename mitk::DiffusionImage<TPixelType>::Pointer output
-    = static_cast<typename mitk::DiffusionImage<TPixelType>*>(this->MakeOutput(0).GetPointer());
-
-  Superclass::SetNumberOfRequiredOutputs(1);
-  Superclass::SetNthOutput(0, output.GetPointer());
-}
-
-template<typename TPixelType>
-mitk::DiffusionImageSource<TPixelType>::~DiffusionImageSource()
-{
-}
-
-template<typename TPixelType>
-itk::DataObject::Pointer mitk::DiffusionImageSource<TPixelType>::MakeOutput ( DataObjectPointerArraySizeType /*idx*/ )
-{
-    return OutputType::New().GetPointer();
-}
-
-
-template<typename TPixelType>
-itk::DataObject::Pointer mitk::DiffusionImageSource<TPixelType>::MakeOutput( const DataObjectIdentifierType & name )
-{
-  itkDebugMacro("MakeOutput(" << name << ")");
-  if( this->IsIndexedOutputName(name) )
-    {
-    return this->MakeOutput( this->MakeIndexFromOutputName(name) );
-    }
-  return static_cast<itk::DataObject *>(OutputType::New().GetPointer());
-}
-
-template<typename TPixelType>
-typename mitk::DiffusionImageSource<TPixelType>::OutputType*
-mitk::DiffusionImageSource<TPixelType>::GetOutput(void)
-{
-  return itkDynamicCastInDebugMode<OutputType*>( this->GetPrimaryOutput() );
-}
-
-template<typename TPixelType>
-const typename mitk::DiffusionImageSource<TPixelType>::OutputType*
-mitk::DiffusionImageSource<TPixelType>::GetOutput(void) const
-{
-  return itkDynamicCastInDebugMode<const OutputType*>( this->GetPrimaryOutput() );
-}
-
-template<typename TPixelType>
-typename mitk::DiffusionImageSource<TPixelType>::OutputType*
-mitk::DiffusionImageSource<TPixelType>::GetOutput(DataObjectPointerArraySizeType idx)
-{
-  OutputType* out = dynamic_cast<OutputType*>( this->ProcessObject::GetOutput(idx) );
-  if ( out == NULL && this->ProcessObject::GetOutput(idx) != NULL )
-  {
-    itkWarningMacro (<< "Unable to convert output number " << idx << " to type " <<  typeid( OutputType ).name () );
-  }
-  return out;
-}
-
-template<typename TPixelType>
-const typename mitk::DiffusionImageSource<TPixelType>::OutputType*
-mitk::DiffusionImageSource<TPixelType>::GetOutput(DataObjectPointerArraySizeType idx) const
-{
-  const OutputType* out = dynamic_cast<const OutputType*>( this->ProcessObject::GetOutput(idx) );
-  if ( out == NULL && this->ProcessObject::GetOutput(idx) != NULL )
-  {
-    itkWarningMacro (<< "Unable to convert output number " << idx << " to type " <<  typeid( OutputType ).name () );
-  }
-  return out;
-}
-
-#endif //__MITK_DIFFUSIONIMAGE_SOURCE_CPP__
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSource.h b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSource.h
deleted file mode 100644
index ae199534a9..0000000000
--- a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSource.h
+++ /dev/null
@@ -1,85 +0,0 @@
-/*===================================================================
-
-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 _MITK_DIFFUSION_IMAGE_DATA_SOURCE_H_HEADER_
-#define _MITK_DIFFUSION_IMAGE_DATA_SOURCE_H_HEADER_
-
-#include "mitkImageSource.h"
-
-namespace mitk {
-
-  template<typename TPixelType>
-  class DiffusionImage;
-  /*class DiffusionImage<double>;
-  class DiffusionImage<int>;
-  class DiffusionImage<unsigned int>;
-  class DiffusionImage<short>;
-  class DiffusionImage<unsigned short>;
-  class DiffusionImage<char>;
-  class DiffusionImage<unsigned char>;
-  class DiffusionImage<long>;
-  class DiffusionImage<unsigned long>;*/
-
-//##Documentation
-//## @brief Superclass of all classes generating diffusion volumes (instances
-//## of class DiffusionImage) as output.
-//##
-//## @ingroup Process
-template<typename TPixelType>
-class DiffusionImageSource : public ImageSource
-{
-public:
-  mitkClassMacro(DiffusionImageSource, BaseDataSource);
-  itkFactorylessNewMacro(Self)
-  itkCloneMacro(Self)
-
-  typedef DiffusionImage<TPixelType> OutputType;
-  typedef itk::DataObject::Pointer DataObjectPointer;
-
-  /**
-    * @brief Get the output data of the diffusion image source object.
-    */
-  mitkBaseDataSourceGetOutputDeclarations
-
-  /**
-   * Allocates a new output object and returns it. Currently the
-   * index idx is not evaluated.
-   * @param idx the index of the output for which an object should be created
-   * @returns the new object
-   */
-  virtual itk::DataObject::Pointer MakeOutput ( DataObjectPointerArraySizeType idx );
-
-  /**
-   * This is a default implementation to make sure we have something.
-   * Once all the subclasses of ProcessObject provide an appopriate
-   * MakeOutput(), then ProcessObject::MakeOutput() can be made pure
-   * virtual.
-   */
-  virtual itk::DataObject::Pointer MakeOutput(const DataObjectIdentifierType &name);
-
-protected:
-  DiffusionImageSource();
-
-  virtual ~DiffusionImageSource();
-};
-
-} // namespace mitk
-
-#include "mitkDiffusionImageSource.cpp"
-
-
-#endif /* _MITK_DIFFUSION_IMAGE_DATA_SOURCE_H_HEADER_ */
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkImageToDiffusionImageSource.cpp b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkImageToDiffusionImageSource.cpp
deleted file mode 100644
index 6dcbfbba98..0000000000
--- a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkImageToDiffusionImageSource.cpp
+++ /dev/null
@@ -1,143 +0,0 @@
-/*===================================================================
-
-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 __mitk_ImageToDiffusionImageSource_txx
-#define __mitk_ImageToDiffusionImageSource_txx
-
-#include "mitkImageToDiffusionImageSource.h"
-
-#include <itkComposeImageFilter.h>
-#include <itkExtractImageFilter.h>
-
-#include "mitkImageTimeSelector.h"
-
-#include <itkVectorImage.h>
-#include <itkImage.h>
-
-#include "mitkImageCast.h"
-
-#include "mitkException.h"
-
-template< typename TPixelType>
-mitk::ImageToDiffusionImageSource<TPixelType>::ImageToDiffusionImageSource()
-  : m_SourceImage(0),
-    m_GradientDirections(0)
-{
-
-}
-
-template< typename TPixelType>
-void mitk::ImageToDiffusionImageSource<TPixelType>
-::GenerateOutputInformation()
-{
-  // sanity checks ( input not null, timesteps corresponds to number of directions specified )
-  if( m_GradientDirections.IsNull() || m_GradientDirections->empty() )
-  {
-    mitkThrow() << "No gradient directions were set. Cannot proceed.";
-  }
-
-  if( m_SourceImage.IsNull() )
-  {
-    mitkThrow() << "No input image was set. Cannot proceed.";
-  }
-
-  if( m_GradientDirections->size() != m_SourceImage->GetTimeSteps() )
-  {
-      mitkThrow() << "Size mismatch between container size " << m_GradientDirections->size() <<
-                     "and image volumes."<< m_SourceImage->GetTimeSteps() <<" Cannot proceed.";
-  }
-
-
-  // already pass in the meta-data
-  typename OutputType::Pointer metaImage = OutputType::New();
-
-  // set identity as measurement frame
-  vnl_matrix_fixed< double, 3, 3 > measurement_frame;
-  measurement_frame.set_identity();
-  metaImage->SetMeasurementFrame( measurement_frame );
-
-  // set directions and bvalue
-  metaImage->SetDirections(this->m_GradientDirections);
-  metaImage->SetReferenceBValue(this->m_BValue);
-
-  m_OutputCache = metaImage;
-  m_CacheTime.Modified();
-
-}
-
-template< typename TPixelType>
-void mitk::ImageToDiffusionImageSource<TPixelType>
-::GenerateData()
-{
-  if ( ( ! m_OutputCache ) || ( this->GetMTime( ) > m_CacheTime.GetMTime( ) ) )
-  {
-    this->GenerateOutputInformation();
-    itkWarningMacro("Cache regenerated!");
-  }
-
-  // now cast the mitk image to the vector image and pass in as volume
-  typedef itk::Image< TPixelType, 4 > InputItkType;
-  typedef itk::Image< TPixelType, 3> SingleVolumeType;
-  typedef itk::VectorImage< TPixelType, 3> VectorImageType;
-
-  typedef itk::ComposeImageFilter< SingleVolumeType > ComposeFilterType;
-  typename ComposeFilterType::Pointer vec_composer = ComposeFilterType::New();
-
-  mitk::ImageTimeSelector::Pointer t_selector =
-      mitk::ImageTimeSelector::New();
-
-  t_selector->SetInput( m_SourceImage );
-
-  for( unsigned int i=0; i< m_SourceImage->GetTimeSteps(); i++)
-  {
-    t_selector->SetTimeNr(i);
-    t_selector->Update();
-
-    typename SingleVolumeType::Pointer singleImageItk;
-    mitk::CastToItkImage( t_selector->GetOutput(), singleImageItk );
-
-    vec_composer->SetInput( i, singleImageItk );
-
-  }
-
-  try
-  {
-    vec_composer->Update();
-  }
-  catch( const itk::ExceptionObject& e)
-  {
-    MITK_ERROR << "Caugt exception while updating compose filter: " << e.what();
-  }
-
-
-  m_OutputCache->SetVectorImage( vec_composer->GetOutput() );
-
-  // transfer to the output image
-  static_cast<OutputType*>(this->GetOutput())
-      ->SetVectorImage(m_OutputCache->GetVectorImage());
-  static_cast<OutputType*>(this->GetOutput())
-      ->SetReferenceBValue(m_OutputCache->GetReferenceBValue());
-  static_cast<OutputType*>(this->GetOutput())
-      ->SetMeasurementFrame(m_OutputCache->GetMeasurementFrame());
-  static_cast<OutputType*>(this->GetOutput())
-      ->SetDirections(m_OutputCache->GetDirections());
-  static_cast<OutputType*>(this->GetOutput())
-      ->InitializeFromVectorImage();
-
-
-}
-
-#endif //__mitk_ImageToDiffusionImageSource_txx
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkImageToDiffusionImageSource.h b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkImageToDiffusionImageSource.h
deleted file mode 100644
index 0b31f3c261..0000000000
--- a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/DiffusionWeightedImages/mitkImageToDiffusionImageSource.h
+++ /dev/null
@@ -1,104 +0,0 @@
-/*===================================================================
-
-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 MITKIMAGETODIFFUSIONIMAGESOURCE_H
-#define MITKIMAGETODIFFUSIONIMAGESOURCE_H
-
-#include "mitkDiffusionImageSource.h"
-
-namespace mitk
-{
-/**
- * @class ImageToDiffusionImageSource
- * @brief The class requires a 3d+t image, list of gradient directions and a corresponding b-value
- * and reinterprets the input image as a diffusion-weighted image.
- *
- * The filter throws an mitk::Exception if
- *  - no gradient list was set
- *  - no input image was set
- *  - the size of the gradient list and the count of timesteps do not match
- */
-template< typename TPixelType >
-class ImageToDiffusionImageSource
-    : public DiffusionImageSource< TPixelType >
-{
-public:
-
-  typedef vnl_vector_fixed< double, 3 >      GradientDirectionType;
-  typedef vnl_matrix_fixed< double, 3, 3 >      MeasurementFrameType;
-  typedef itk::VectorContainer< unsigned int,
-    GradientDirectionType >::Pointer          GradientDirectionContainerType;
-
-  mitkClassMacro( ImageToDiffusionImageSource,
-                  DiffusionImageSource<TPixelType> )
-
-  itkSimpleNewMacro(Self)
-
-  typedef typename Superclass::OutputType OutputType;
-  typedef itk::VectorImage<TPixelType,3>     ImageType;
-
-  /**
-   * @brief Set the mitk image ( a 3d+t image ) which is to be reinterpreted as dw image
-   * @param mitkImage
-   */
-  void SetImage( mitk::Image::Pointer mitkImage )
-  {
-    m_SourceImage = mitkImage;
-  }
-
-  /**
-   * @brief Set the gradient directions corresponding to the volumes of the input image
-   * @param container the container with the gradient directions
-   *
-   * @note The gradient directions must correspond to the volumes stored in the 3d+t input
-   */
-  void SetGradientDirections( GradientDirectionContainerType container )
-  {
-    m_GradientDirections = container;
-  }
-
-  /**
-   * @brief Set the b-value
-   * @param bvalue the b-value associated with the gradient list
-   */
-  void SetBValue( float bvalue )
-  {
-    this->m_BValue = bvalue;
-  }
-
-
-protected:
-  ImageToDiffusionImageSource();
-  virtual ~ImageToDiffusionImageSource(){}
-
-  virtual void GenerateData();
-
-  virtual void GenerateOutputInformation();
-
-  mitk::Image::Pointer m_SourceImage;
-  GradientDirectionContainerType m_GradientDirections;
-
-  typename OutputType::Pointer m_OutputCache;
-  itk::TimeStamp m_CacheTime;
-
-  float m_BValue;
-};
-
-
-}
-
-#include "mitkImageToDiffusionImageSource.cpp"
-#endif // MITKIMAGETODIFFUSIONIMAGESOURCE_H
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkBValueMapProperty.cpp b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkBValueMapProperty.cpp
new file mode 100644
index 0000000000..3e364ab6e7
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkBValueMapProperty.cpp
@@ -0,0 +1,103 @@
+/*===================================================================
+
+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.
+
+===================================================================*/
+
+#include "mitkBValueMapProperty.h"
+
+mitk::BValueMapProperty::BValueMapProperty()
+  : m_BValueMap()
+{
+}
+
+mitk::BValueMapProperty::BValueMapProperty(const BValueMapProperty& other)
+  : mitk::BaseProperty(other)
+{
+  m_BValueMap = other.GetBValueMap();
+}
+
+mitk::BValueMapProperty::BValueMapProperty(const BValueMap& bValueMap)
+{
+  m_BValueMap = bValueMap;
+}
+
+mitk::BValueMapProperty::~BValueMapProperty()
+{
+}
+
+const mitk::BValueMapProperty::BValueMap & mitk::BValueMapProperty::GetBValueMap() const
+{
+  return m_BValueMap;
+}
+
+void mitk::BValueMapProperty::SetBValueMap(const BValueMap & map)
+{
+  this->m_BValueMap = map;
+}
+
+bool mitk::BValueMapProperty::IsEqual(const BaseProperty& property) const
+{
+  return this->m_BValueMap == static_cast<const Self&>(property).m_BValueMap;
+}
+
+bool mitk::BValueMapProperty::Assign(const BaseProperty& property)
+{
+  this->m_BValueMap = static_cast<const Self&>(property).m_BValueMap;
+  return true;
+}
+
+mitk::BValueMapProperty::BValueMap mitk::BValueMapProperty::CreateBValueMap(const mitk::BValueMapProperty::GradientDirectionsContainerType * gdc, float referenceBValue)
+{
+  mitk::BValueMapProperty::BValueMap map;
+
+  mitk::BValueMapProperty::GradientDirectionsContainerType::ConstIterator gdcit;
+  for( gdcit = gdc->Begin(); gdcit != gdc->End(); ++gdcit)
+  {
+    float keyBValue = mitk::BValueMapProperty::GetBValueOfGradientDirection(gdcit.Index(),referenceBValue, gdc);
+    map[keyBValue].push_back(gdcit.Index());
+  }
+
+  return map;
+}
+
+
+float mitk::BValueMapProperty::GetBValueOfGradientDirection(unsigned int i, float referenceBValue, const mitk::BValueMapProperty::GradientDirectionsContainerType * gdc)
+{
+  if(i > gdc->Size()-1)
+    return -1;
+
+  if(gdc->ElementAt(i).one_norm() <= 0.0)
+  {
+    return 0;
+  }
+  else
+  {
+    double twonorm = gdc->ElementAt(i).two_norm();
+    double bval = referenceBValue*twonorm*twonorm;
+
+    if (bval<0)
+      bval = ceil(bval - 0.5);
+    else
+      bval = floor(bval + 0.5);
+
+    return bval;
+  }
+}
+
+itk::LightObject::Pointer  mitk::BValueMapProperty::InternalClone() const
+{
+  itk::LightObject::Pointer result(new Self(*this));
+  result->UnRegister();
+  return result;
+}
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkBValueMapProperty.h b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkBValueMapProperty.h
new file mode 100644
index 0000000000..6fee11e8e3
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkBValueMapProperty.h
@@ -0,0 +1,74 @@
+/*===================================================================
+
+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 MITKBVALUEMAPPROPERTY_H
+#define MITKBVALUEMAPPROPERTY_H
+
+#include "mitkBaseProperty.h"
+#include <map>
+#include <vector>
+
+#include <MitkDiffusionCoreExports.h>
+#include <itkVectorContainer.h>
+#include <vnl/vnl_vector_fixed.h>
+namespace mitk
+{
+
+  /** This property will store the b value map */
+
+  class MitkDiffusionCore_EXPORT BValueMapProperty : public mitk::BaseProperty
+  {
+  public:
+    /**
+    * \brief The BValueMap contains seperated IndicesVectors for each b value (index for GradientDirectionContainer)
+    * key   := b value
+    * value := indicesVector
+    */
+    typedef std::map< unsigned int , std::vector< unsigned int >  >   BValueMap;
+    typedef unsigned int                                              IndexType;
+    typedef vnl_vector_fixed< double, 3 >                             ValueType;
+    typedef ValueType                                                 GradientDirectionType;
+    typedef itk::VectorContainer< IndexType, GradientDirectionType >  GradientDirectionsContainerType;
+    mitkClassMacro(BValueMapProperty, BaseProperty)
+
+    itkFactorylessNewMacro(Self)
+    itkCloneMacro(Self)
+
+    mitkNewMacro1Param(BValueMapProperty, const BValueMapProperty&)
+    mitkNewMacro1Param(BValueMapProperty, const BValueMap&)
+
+    const BValueMap & GetBValueMap() const;
+    void SetBValueMap(const BValueMap & map);
+
+    static BValueMap CreateBValueMap(const GradientDirectionsContainerType * gdc, float referenceBValue);
+    static float GetBValueOfGradientDirection(unsigned int i, float referenceBValue, const GradientDirectionsContainerType *gdc);
+  protected:
+
+    BValueMapProperty();
+    ~BValueMapProperty();
+
+    BValueMapProperty(const BValueMapProperty& other);
+    BValueMapProperty(const BValueMap& bValueMap);
+
+    virtual bool IsEqual(const BaseProperty& property) const;
+    virtual bool Assign(const BaseProperty & property);
+
+    BValueMap m_BValueMap;
+
+    virtual itk::LightObject::Pointer InternalClone() const;
+  };
+}
+#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkBValueMapPropertySerializer.cpp b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkBValueMapPropertySerializer.cpp
new file mode 100644
index 0000000000..f406a883e3
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkBValueMapPropertySerializer.cpp
@@ -0,0 +1,131 @@
+/*===================================================================
+
+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 mitkBValueMapPropertySerializer_h_included
+#define mitkBValueMapPropertySerializer_h_included
+
+#include "mitkBasePropertySerializer.h"
+
+#include "mitkBValueMapProperty.h"
+
+#include <MitkDiffusionCoreExports.h>
+
+namespace mitk
+{
+
+class MitkDiffusionCore_EXPORT BValueMapPropertySerializer : public BasePropertySerializer
+{
+
+protected:
+
+
+  void split(const std::string &s, char delim, std::vector<unsigned int> &elems) {
+    std::stringstream ss(s);
+    std::string item;
+    while (std::getline(ss, item, delim)) {
+      elems.push_back(std::atoi(item.c_str()));
+    }
+  }
+
+  std::vector<unsigned int> split(const std::string &s, char delim) {
+    std::vector<unsigned int> elems;
+    split(s, delim, elems);
+    return elems;
+  }
+
+public:
+
+  mitkClassMacro( BValueMapPropertySerializer, BasePropertySerializer )
+  itkFactorylessNewMacro(Self)
+  itkCloneMacro(Self)
+
+  virtual TiXmlElement* Serialize()
+  {
+    if (const BValueMapProperty* prop = dynamic_cast<const BValueMapProperty*>(m_Property.GetPointer()))
+    {
+
+      BValueMapProperty::BValueMap map = prop->GetBValueMap();
+
+      if(map.empty()) return NULL;
+
+      BValueMapProperty::BValueMap::const_iterator it = map.begin();
+      BValueMapProperty::BValueMap::const_iterator end = map.end();
+
+      TiXmlElement* element = new TiXmlElement("bvaluemap");
+
+
+
+      while (it != end) {
+        TiXmlElement* child = new TiXmlElement("entry");
+        {
+          std::stringstream ss;
+          ss << it->first;
+          child->SetAttribute("key", ss.str());
+        }
+
+        {
+          std::stringstream ss;
+          for(unsigned int i = 0 ; i < it->second.size(); i++)
+          {
+
+            ss << it->second[i] << ",";
+          }
+          child->SetAttribute("value", ss.str());
+        }
+        element->InsertEndChild(*child);
+        ++it;
+      }
+
+      return element;
+    }
+    else return NULL;
+  }
+
+
+  virtual BaseProperty::Pointer Deserialize(TiXmlElement* element)
+  {
+    if (!element) return NULL;
+
+    BValueMapProperty::BValueMap map;
+
+    TiXmlElement* entry = element->FirstChildElement( "entry" )->ToElement();
+    while(entry != NULL){
+
+      std::string key, value;
+      entry->QueryStringAttribute("key",&key);
+      entry->QueryStringAttribute("value",&value);
+
+      std::vector<unsigned int> indices = split(value.c_str(), ',');
+
+      map[std::atoi(key.c_str())] = indices;
+      entry = entry->NextSiblingElement( "entry" );
+    }
+
+    return BValueMapProperty::New(map).GetPointer();
+  }
+
+protected:
+
+  BValueMapPropertySerializer(){}
+  virtual ~BValueMapPropertySerializer() {}
+};
+
+} // namespace
+
+// important to put this into the GLOBAL namespace (because it starts with 'namespace mitk')
+MITK_REGISTER_SERIALIZER(BValueMapPropertySerializer)
+
+#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkDiffusionPropertyHelper.cpp b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkDiffusionPropertyHelper.cpp
new file mode 100644
index 0000000000..b1b0af9b03
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkDiffusionPropertyHelper.cpp
@@ -0,0 +1,387 @@
+/*===================================================================
+
+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.
+
+===================================================================*/
+
+#include "mitkDiffusionPropertyHelper.h"
+#include <mitkITKImageImport.h>
+#include <mitkImageCast.h>
+#include <itkImageRegionIterator.h>
+#include <mitkProperties.h>
+
+const std::string mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME = "meta.GradientDirections";
+const std::string mitk::DiffusionPropertyHelper::ORIGINALGRADIENTCONTAINERPROPERTYNAME = "meta.OriginalGradientDirections";
+const std::string mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME = "meta.MeasurementFrame";
+const std::string mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME = "meta.ReferenceBValue";
+const std::string mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME = "BValueMap";
+
+mitk::DiffusionPropertyHelper::DiffusionPropertyHelper()
+{
+}
+
+mitk::DiffusionPropertyHelper::DiffusionPropertyHelper( mitk::Image* inputImage)
+  : m_Image( inputImage )
+{
+  // Update props
+}
+
+mitk::DiffusionPropertyHelper::~DiffusionPropertyHelper()
+{
+}
+
+mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer
+  mitk::DiffusionPropertyHelper::CalcAveragedDirectionSet(double precision, GradientDirectionsContainerType::Pointer directions)
+{
+  // save old and construct new direction container
+  GradientDirectionsContainerType::Pointer newDirections = GradientDirectionsContainerType::New();
+
+  // fill new direction container
+  for(GradientDirectionsContainerType::ConstIterator gdcitOld = directions->Begin();
+    gdcitOld != directions->End(); ++gdcitOld)
+  {
+    // already exists?
+    bool found = false;
+    for(GradientDirectionsContainerType::ConstIterator gdcitNew = newDirections->Begin();
+      gdcitNew != newDirections->End(); ++gdcitNew)
+    {
+      if(AreAlike(gdcitNew.Value(), gdcitOld.Value(), precision))
+      {
+        found = true;
+        break;
+      }
+    }
+
+    // if not found, add it to new container
+    if(!found)
+    {
+      newDirections->push_back(gdcitOld.Value());
+    }
+  }
+
+  return newDirections;
+}
+
+void mitk::DiffusionPropertyHelper::AverageRedundantGradients(double precision)
+{
+
+  mitk::GradientDirectionsProperty* DirectionsProperty = static_cast<mitk::GradientDirectionsProperty*>( m_Image->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() );
+  GradientDirectionsContainerType::Pointer oldDirs = DirectionsProperty->GetGradientDirectionsContainer();
+
+  GradientDirectionsContainerType::Pointer newDirs =
+    CalcAveragedDirectionSet(precision, oldDirs);
+
+  // if sizes equal, we do not need to do anything in this function
+  if(oldDirs->size() == newDirs->size())
+    return;
+
+  // new image
+  ImageType::Pointer oldImage = ImageType::New();
+  mitk::CastToItkImage( m_Image, oldImage);
+  ImageType::Pointer newITKImage = ImageType::New();
+  newITKImage->SetSpacing( oldImage->GetSpacing() );   // Set the image spacing
+  newITKImage->SetOrigin( oldImage->GetOrigin() );     // Set the image origin
+  newITKImage->SetDirection( oldImage->GetDirection() );  // Set the image direction
+  newITKImage->SetLargestPossibleRegion( oldImage->GetLargestPossibleRegion() );
+  newITKImage->SetVectorLength( newDirs->size() );
+  newITKImage->SetBufferedRegion( oldImage->GetLargestPossibleRegion() );
+  newITKImage->Allocate();
+
+  // average image data that corresponds to identical directions
+  itk::ImageRegionIterator< ImageType > newIt(newITKImage, newITKImage->GetLargestPossibleRegion());
+  newIt.GoToBegin();
+  itk::ImageRegionIterator< ImageType > oldIt(oldImage, oldImage->GetLargestPossibleRegion());
+  oldIt.GoToBegin();
+
+  // initial new value of voxel
+  ImageType::PixelType newVec;
+  newVec.SetSize(newDirs->size());
+  newVec.AllocateElements(newDirs->size());
+
+  // find which gradients should be averaged
+  GradientDirectionsContainerType::Pointer oldDirections = oldDirs;
+  std::vector<std::vector<int> > dirIndices;
+  for(GradientDirectionsContainerType::ConstIterator gdcitNew = newDirs->Begin();
+    gdcitNew != newDirs->End(); ++gdcitNew)
+  {
+    dirIndices.push_back(std::vector<int>(0));
+    for(GradientDirectionsContainerType::ConstIterator gdcitOld = oldDirs->Begin();
+      gdcitOld != oldDirections->End(); ++gdcitOld)
+    {
+      if(AreAlike(gdcitNew.Value(), gdcitOld.Value(), precision))
+      {
+        //MITK_INFO << gdcitNew.Value() << "  " << gdcitOld.Value();
+        dirIndices[gdcitNew.Index()].push_back(gdcitOld.Index());
+      }
+    }
+  }
+
+  //int ind1 = -1;
+  while(!newIt.IsAtEnd())
+  {
+
+    // progress
+    //typename ImageType::IndexType ind = newIt.GetIndex();
+    //ind1 = ind.m_Index[2];
+
+    // init new vector with zeros
+    newVec.Fill(0.0);
+
+    // the old voxel value with duplicates
+    ImageType::PixelType oldVec = oldIt.Get();
+
+    for(unsigned int i=0; i<dirIndices.size(); i++)
+    {
+      // do the averaging
+      const unsigned int numavg = dirIndices[i].size();
+      unsigned int sum = 0;
+      for(unsigned int j=0; j<numavg; j++)
+      {
+        //MITK_INFO << newVec[i] << " << " << oldVec[dirIndices[i].at(j)];
+        sum += oldVec[dirIndices[i].at(j)];
+      }
+      if(numavg == 0)
+      {
+        MITK_ERROR << "VectorImage: Error on averaging. Possibly due to corrupted data";
+        return;
+      }
+      newVec[i] = sum / numavg;
+    }
+
+    newIt.Set(newVec);
+
+    ++newIt;
+    ++oldIt;
+  }
+
+  mitk::GrabItkImageMemory( newITKImage, m_Image );
+
+  m_Image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( newDirs ) );
+  m_Image->SetProperty( mitk::DiffusionPropertyHelper::ORIGINALGRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( newDirs ) );
+  ApplyMeasurementFrame();
+  UpdateBValueMap();
+  std::cout << std::endl;
+}
+
+void mitk::DiffusionPropertyHelper::ApplyMeasurementFrame()
+{
+
+  if(  m_Image->GetProperty(mitk::DiffusionPropertyHelper::ORIGINALGRADIENTCONTAINERPROPERTYNAME.c_str()).IsNull() )
+  {
+    return;
+  }
+
+  GradientDirectionsContainerType::Pointer  originalDirections = static_cast<mitk::GradientDirectionsProperty*>( m_Image->GetProperty(mitk::DiffusionPropertyHelper::ORIGINALGRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer())->GetGradientDirectionsContainer();
+
+  MeasurementFrameType  measurementFrame = static_cast<mitk::MeasurementFrameProperty*>( m_Image->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )->GetMeasurementFrame();
+
+  GradientDirectionsContainerType::Pointer directions = GradientDirectionsContainerType::New();
+
+  if( originalDirections.IsNull() || ( originalDirections->size() == 0 ) )
+  {
+    // original direction container was not set
+    return;
+  }
+
+  GradientDirectionsContainerType::Pointer direction = GradientDirectionsContainerType::New();
+  int c = 0;
+  for(GradientDirectionsContainerType::ConstIterator gdcit = originalDirections->Begin();
+      gdcit != originalDirections->End(); ++gdcit)
+  {
+    vnl_vector<double> vec = gdcit.Value();
+    vec = vec.pre_multiply(measurementFrame);
+    directions->InsertElement(c, vec);
+    c++;
+  }
+
+  m_Image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( directions ) );
+}
+
+void mitk::DiffusionPropertyHelper::UpdateBValueMap()
+{
+  BValueMapType b_ValueMap;
+
+  if(m_Image->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).IsNull())
+  {
+  }
+  else
+  {
+    b_ValueMap = static_cast<mitk::BValueMapProperty*>(m_Image->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )->GetBValueMap();
+  }
+
+  if(!b_ValueMap.empty())
+  {
+    b_ValueMap.clear();
+  }
+
+  if( m_Image->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).IsNotNull() )
+  {
+    GradientDirectionsContainerType::Pointer directions = static_cast<mitk::GradientDirectionsProperty*>( m_Image->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
+
+    GradientDirectionsContainerType::ConstIterator gdcit;
+    for( gdcit = directions->Begin(); gdcit != directions->End(); ++gdcit)
+    {
+      b_ValueMap[GetB_Value(gdcit.Index())].push_back(gdcit.Index());
+    }
+  }
+
+  m_Image->SetProperty( mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str(), mitk::BValueMapProperty::New( b_ValueMap ) );
+}
+
+bool mitk::DiffusionPropertyHelper::AreAlike(GradientDirectionType g1,
+                                                GradientDirectionType g2,
+                                                double precision)
+{
+  GradientDirectionType diff = g1 - g2;
+  GradientDirectionType diff2 = g1 + g2;
+  return diff.two_norm() < precision || diff2.two_norm() < precision;
+}
+
+float mitk::DiffusionPropertyHelper::GetB_Value(unsigned int i)
+{
+  GradientDirectionsContainerType::Pointer directions = static_cast<mitk::GradientDirectionsProperty*>( m_Image->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
+
+  float b_value = static_cast<mitk::FloatProperty*>(m_Image->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue();
+
+  if(i > directions->Size()-1)
+    return -1;
+
+  if(directions->ElementAt(i).one_norm() <= 0.0)
+  {
+    return 0;
+  }
+  else
+  {
+    double twonorm = directions->ElementAt(i).two_norm();
+    double bval = b_value*twonorm*twonorm;
+
+    if (bval<0)
+      bval = ceil(bval - 0.5);
+    else
+      bval = floor(bval + 0.5);
+
+    return bval;
+  }
+}
+
+void mitk::DiffusionPropertyHelper::InitializeImage()
+{
+  this->ApplyMeasurementFrame();
+  this->UpdateBValueMap();
+
+  // initialize missing properties
+}
+
+
+bool mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(const mitk::Image * image)
+{
+  bool isDiffusionWeightedImage( true );
+
+  if( image == NULL )
+  {
+    isDiffusionWeightedImage = false;
+  }
+
+  if( isDiffusionWeightedImage )
+  {
+    mitk::FloatProperty::Pointer referenceBValue = dynamic_cast<mitk::FloatProperty *>(image->GetProperty(REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer());
+
+    if( referenceBValue.IsNull() )
+    {
+      isDiffusionWeightedImage = false;
+    }
+
+  }
+
+  unsigned int gradientDirections( 0 );
+  if( isDiffusionWeightedImage )
+  {
+    mitk::GradientDirectionsProperty::Pointer gradientDirectionsProperty = dynamic_cast<mitk::GradientDirectionsProperty *>(image->GetProperty(GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer());
+
+    if( gradientDirectionsProperty.IsNull() )
+    {
+      isDiffusionWeightedImage = false;
+    }
+    else
+    {
+      gradientDirections = gradientDirectionsProperty->GetGradientDirectionsContainer()->size();
+    }
+  }
+
+  if( isDiffusionWeightedImage )
+  {
+    unsigned int components = image->GetPixelType().GetNumberOfComponents();
+
+    if( components != gradientDirections )
+    {
+      isDiffusionWeightedImage = false;
+    }
+  }
+
+  return isDiffusionWeightedImage;
+}
+
+const mitk::DiffusionPropertyHelper::BValueMapType & mitk::DiffusionPropertyHelper::GetBValueMap(const mitk::Image *image)
+{
+  return dynamic_cast<mitk::BValueMapProperty *>(image->GetProperty(BVALUEMAPPROPERTYNAME.c_str()).GetPointer())->GetBValueMap();
+}
+
+float mitk::DiffusionPropertyHelper::GetReferenceBValue(const mitk::Image *image)
+{
+   return dynamic_cast<mitk::FloatProperty *>(image->GetProperty(REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer())->GetValue();
+}
+
+const mitk::DiffusionPropertyHelper::MeasurementFrameType & mitk::DiffusionPropertyHelper::GetMeasurementFrame(const mitk::Image *image)
+{
+  return dynamic_cast<mitk::MeasurementFrameProperty *>(image->GetProperty(MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer())->GetMeasurementFrame();
+}
+
+mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer mitk::DiffusionPropertyHelper::GetOriginalGradientContainer(const mitk::Image *image)
+{
+  return dynamic_cast<mitk::GradientDirectionsProperty *>(image->GetProperty(ORIGINALGRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer())->GetGradientDirectionsContainer();
+}
+
+mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer mitk::DiffusionPropertyHelper::GetGradientContainer(const mitk::Image *image)
+{
+  return dynamic_cast<mitk::GradientDirectionsProperty *>(image->GetProperty(GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer())->GetGradientDirectionsContainer();
+}
+
+bool mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage() const
+{
+  return IsDiffusionWeightedImage(m_Image);
+}
+
+const mitk::DiffusionPropertyHelper::BValueMapType &mitk::DiffusionPropertyHelper::GetBValueMap() const
+{
+  return GetBValueMap(m_Image);
+}
+
+float mitk::DiffusionPropertyHelper::GetReferenceBValue() const
+{
+  return GetReferenceBValue(m_Image);
+}
+
+const mitk::DiffusionPropertyHelper::MeasurementFrameType & mitk::DiffusionPropertyHelper::GetMeasurementFrame() const
+{
+  return GetMeasurementFrame(m_Image);
+}
+
+mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer mitk::DiffusionPropertyHelper::GetOriginalGradientContainer() const
+{
+  return GetOriginalGradientContainer(m_Image);
+}
+
+mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer mitk::DiffusionPropertyHelper::GetGradientContainer() const
+{
+  return GetGradientContainer(m_Image);
+}
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkDiffusionPropertyHelper.h b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkDiffusionPropertyHelper.h
new file mode 100644
index 0000000000..0e599e2950
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkDiffusionPropertyHelper.h
@@ -0,0 +1,128 @@
+/*===================================================================
+
+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 MITKDIFFUSIONPROPERTYHELPER_H
+#define MITKDIFFUSIONPROPERTYHELPER_H
+
+#include <MitkDiffusionCoreExports.h>
+
+#include <mitkImage.h>
+#include <mitkBValueMapProperty.h>
+#include <mitkGradientDirectionsProperty.h>
+#include <mitkMeasurementFrameProperty.h>
+
+namespace mitk
+{
+  /** \brief Helper class for mitk::Images containing diffusion weighted data
+  *
+  * This class takes a pointer to a mitk::Image containing diffusion weighted information and provides
+  * functions to manipulate the diffusion meta-data. Will log an error if required information is
+  * missing.
+  */
+
+  class MitkDiffusionCore_EXPORT DiffusionPropertyHelper
+  {
+  public:
+
+    typedef short                                                         DiffusionPixelType;
+
+    typedef mitk::BValueMapProperty::BValueMap                            BValueMapType;
+    typedef GradientDirectionsProperty::GradientDirectionType             GradientDirectionType;
+    typedef GradientDirectionsProperty::GradientDirectionsContainerType   GradientDirectionsContainerType;
+    typedef mitk::MeasurementFrameProperty::MeasurementFrameType          MeasurementFrameType;
+    typedef itk::VectorImage< DiffusionPixelType, 3>                      ImageType;
+
+    static const std::string GRADIENTCONTAINERPROPERTYNAME;
+    static const std::string ORIGINALGRADIENTCONTAINERPROPERTYNAME;
+    static const std::string MEASUREMENTFRAMEPROPERTYNAME;
+    static const std::string REFERENCEBVALUEPROPERTYNAME;
+    static const std::string BVALUEMAPPROPERTYNAME;
+
+    /// Public constructor, takes a mitk::Image pointer as argument
+    DiffusionPropertyHelper( mitk::Image* inputImage );
+    ~DiffusionPropertyHelper();
+
+    /** \brief Decide whether a provided image is a valid diffusion weighted image
+     *
+     * An image will be considered a valid diffusion weighted image if the following are true
+     * - It has a reference b value
+     * - It has a gradient directions property
+     * - The number of gradients directions matches the number of components of the image
+     *
+     * This does not guarantee that the data is sensible or accurate, it just verfies that it
+     * meets the formal requirements to possibly be a valid diffusion weighted image.
+     */
+    static bool IsDiffusionWeightedImage(const mitk::Image *);
+
+    /// Convenience method to get the BValueMap
+    static const BValueMapType & GetBValueMap(const mitk::Image *);
+    /// Convenience method to get the BValue
+    static float GetReferenceBValue(const mitk::Image *);
+    /// Convenience method to get the measurement frame
+    static const MeasurementFrameType & GetMeasurementFrame(const mitk::Image *);
+    /// Convenience method to get the original gradient directions
+    static GradientDirectionsContainerType::Pointer GetOriginalGradientContainer(const mitk::Image *);
+    /// Convenience method to get the gradient directions
+    static GradientDirectionsContainerType::Pointer GetGradientContainer(const mitk::Image *);
+
+    const BValueMapType & GetBValueMap() const;
+    float GetReferenceBValue() const;
+    const MeasurementFrameType & GetMeasurementFrame() const;
+    GradientDirectionsContainerType::Pointer GetOriginalGradientContainer() const;
+    GradientDirectionsContainerType::Pointer GetGradientContainer() const;
+
+    bool IsDiffusionWeightedImage() const;
+
+    void AverageRedundantGradients(double precision);
+
+    /** \brief Make certain the owned image is up to date with all necessary properties
+     *
+     * This function will generate the B Value map and copy all properties to the owned image.
+     */
+    void InitializeImage();
+
+    GradientDirectionsContainerType::Pointer CalcAveragedDirectionSet(double precision, GradientDirectionsContainerType::Pointer directions);
+
+  protected:
+
+    DiffusionPropertyHelper();
+
+    /**
+    * \brief Apply the previouse set MeasurementFrame to all gradients in the GradientsDirectionContainer (m_Directions)
+    *
+    * \warning first set the MeasurementFrame
+    */
+    void ApplyMeasurementFrame();
+
+    /**
+    * \brief Update the BValueMap (m_B_ValueMap) using the current gradient directions (m_Directions)
+    *
+    * \warning Have to be called after each manipulation on the GradientDirectionContainer
+    * !especially after manipulation of the m_Directions (GetDirections()) container via pointer access!
+    */
+    void UpdateBValueMap();
+
+    /// Determines whether gradients can be considered to be equal
+    bool AreAlike(GradientDirectionType g1, GradientDirectionType g2, double precision);
+
+    /// Get the b value belonging to an index
+    float GetB_Value(unsigned int i);
+
+    mitk::Image* m_Image;
+
+  };
+}
+#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkGradientDirectionsProperty.cpp b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkGradientDirectionsProperty.cpp
new file mode 100644
index 0000000000..1ef0d3e495
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkGradientDirectionsProperty.cpp
@@ -0,0 +1,83 @@
+/*===================================================================
+
+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.
+
+===================================================================*/
+
+#include "mitkGradientDirectionsProperty.h"
+
+mitk::GradientDirectionsProperty::GradientDirectionsProperty()
+{
+  m_GradientDirectionsContainer = mitk::GradientDirectionsProperty::GradientDirectionsContainerType::New();
+}
+
+mitk::GradientDirectionsProperty::GradientDirectionsProperty(const GradientDirectionsProperty& other)
+  : mitk::BaseProperty(other)
+{
+  m_GradientDirectionsContainer = other.GetGradientDirectionsContainer();
+}
+
+mitk::GradientDirectionsProperty::GradientDirectionsProperty(const GradientDirectionsContainerType::Pointer gradientDirectionsContainer)
+{
+  m_GradientDirectionsContainer = gradientDirectionsContainer;
+}
+
+mitk::GradientDirectionsProperty::GradientDirectionsProperty(const AlternativeGradientDirectionsContainerType gradientDirectionsContainer)
+{
+  m_GradientDirectionsContainer = mitk::GradientDirectionsProperty::GradientDirectionsContainerType::New();
+  for(unsigned int index(0); index < gradientDirectionsContainer.size(); index++)
+  {
+    GradientDirectionType newDirection = gradientDirectionsContainer.at(index).GetVnlVector();
+    m_GradientDirectionsContainer->InsertElement( index, newDirection);
+  }
+}
+
+mitk::GradientDirectionsProperty::~GradientDirectionsProperty()
+{
+}
+
+const mitk::GradientDirectionsProperty::GradientDirectionsContainerType::Pointer mitk::GradientDirectionsProperty::GetGradientDirectionsContainer() const
+{
+  return m_GradientDirectionsContainer;
+}
+
+bool mitk::GradientDirectionsProperty::IsEqual(const BaseProperty& property) const
+{
+
+  GradientDirectionsContainerType::Pointer lhs = this->m_GradientDirectionsContainer;
+  GradientDirectionsContainerType::Pointer rhs = static_cast<const Self&>(property).m_GradientDirectionsContainer;
+
+  if(lhs->Size() != rhs->Size()) return false;
+
+  GradientDirectionsContainerType::Iterator lhsit = lhs->Begin();
+  GradientDirectionsContainerType::Iterator rhsit = rhs->Begin();
+
+  bool equal = true;
+  for(unsigned int i = 0 ; i < lhs->Size(); i++, ++lhsit, ++rhsit)
+    equal |= lhsit.Value() == rhsit.Value();
+
+  return  equal;
+}
+
+bool mitk::GradientDirectionsProperty::Assign(const BaseProperty& property)
+{
+  this->m_GradientDirectionsContainer = static_cast<const Self&>(property).m_GradientDirectionsContainer;
+  return true;
+}
+
+itk::LightObject::Pointer  mitk::GradientDirectionsProperty::InternalClone() const
+{
+  itk::LightObject::Pointer result(new Self(*this));
+  result->UnRegister();
+  return result;
+}
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkGradientDirectionsProperty.h b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkGradientDirectionsProperty.h
new file mode 100644
index 0000000000..4fb765388a
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkGradientDirectionsProperty.h
@@ -0,0 +1,68 @@
+/*===================================================================
+
+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 MITKGRADIENTDIRECTIONSPROPERTY_H
+#define MITKGRADIENTDIRECTIONSPROPERTY_H
+
+#include "mitkBaseProperty.h"
+#include <vnl/vnl_vector_fixed.h>
+#include <itkVectorContainer.h>
+#include <itkVector.h>
+
+#include <MitkDiffusionCoreExports.h>
+
+namespace mitk
+{
+
+  /** This property will store the gradients directions and the original gradient directions */
+  class MitkDiffusionCore_EXPORT GradientDirectionsProperty : public mitk::BaseProperty
+  {
+  public:
+    typedef unsigned int                                             IndexType;
+    typedef vnl_vector_fixed< double, 3 >                            ValueType;
+    typedef ValueType                                                GradientDirectionType;
+    typedef itk::VectorContainer< IndexType, GradientDirectionType > GradientDirectionsContainerType;
+    typedef std::vector< itk::Vector<double,3> >                     AlternativeGradientDirectionsContainerType;
+
+    mitkClassMacro(GradientDirectionsProperty, BaseProperty)
+
+    itkFactorylessNewMacro(Self)
+    itkCloneMacro(Self)
+
+    mitkNewMacro1Param(GradientDirectionsProperty, const GradientDirectionsProperty&);
+    mitkNewMacro1Param(GradientDirectionsProperty, const GradientDirectionsContainerType::Pointer);
+    mitkNewMacro1Param(GradientDirectionsProperty, const AlternativeGradientDirectionsContainerType );
+
+    const GradientDirectionsContainerType::Pointer GetGradientDirectionsContainer() const;
+
+  protected:
+
+    GradientDirectionsProperty();
+    ~GradientDirectionsProperty();
+
+    GradientDirectionsProperty(const GradientDirectionsProperty& other);
+    GradientDirectionsProperty(const GradientDirectionsContainerType::Pointer gradientDirectionsContainer);
+    GradientDirectionsProperty(const AlternativeGradientDirectionsContainerType gradientDirectionsContainer);
+
+    virtual bool IsEqual(const BaseProperty& property) const;
+    virtual bool Assign(const BaseProperty & property);
+
+    GradientDirectionsContainerType::Pointer m_GradientDirectionsContainer;
+
+    virtual itk::LightObject::Pointer InternalClone() const;
+  };
+}
+#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkGradientDirectionsPropertySerializer.cpp b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkGradientDirectionsPropertySerializer.cpp
new file mode 100644
index 0000000000..4c540ff733
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkGradientDirectionsPropertySerializer.cpp
@@ -0,0 +1,106 @@
+/*===================================================================
+
+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 mitkGradientDirectionPropertySerializer_h_included
+#define mitkGradientDirectionPropertySerializer_h_included
+
+#include "mitkBasePropertySerializer.h"
+
+#include "mitkGradientDirectionsProperty.h"
+
+#include "MitkDiffusionCoreExports.h"
+
+namespace mitk
+{
+
+class MitkDiffusionCore_EXPORT GradientDirectionsPropertySerializer : public BasePropertySerializer
+{
+  public:
+
+    mitkClassMacro( GradientDirectionsPropertySerializer, BasePropertySerializer )
+    itkFactorylessNewMacro(Self)
+    itkCloneMacro(Self)
+
+    virtual TiXmlElement* Serialize()
+    {
+      if (const GradientDirectionsProperty* prop = dynamic_cast<const GradientDirectionsProperty*>(m_Property.GetPointer()))
+      {
+
+        typedef mitk::GradientDirectionsProperty::GradientDirectionsContainerType GradientDirectionsContainerType;
+        GradientDirectionsContainerType::Pointer gdc = prop->GetGradientDirectionsContainer().GetPointer();
+
+        if(gdc.IsNull() || gdc->Size() == 0) return NULL;
+
+
+        GradientDirectionsContainerType::Iterator it = gdc->Begin();
+        GradientDirectionsContainerType::Iterator end = gdc->End();
+
+        TiXmlElement* element = new TiXmlElement("gradientdirections");
+
+        while (it != end) {
+          TiXmlElement* child = new TiXmlElement("entry");
+          std::stringstream ss;
+          ss << it.Value();
+          child->SetAttribute("value", ss.str());
+          element->InsertEndChild(*child);
+
+          ++it;
+        }
+
+        return element;
+      }
+      else return NULL;
+    }
+
+    virtual BaseProperty::Pointer Deserialize(TiXmlElement* element)
+    {
+      if (!element) return NULL;
+
+      mitk::GradientDirectionsProperty::GradientDirectionsContainerType::Pointer gdc;
+      gdc = mitk::GradientDirectionsProperty::GradientDirectionsContainerType::New();
+
+      TiXmlElement* entry = element->FirstChildElement( "entry" )->ToElement();
+      while(entry != NULL){
+
+        std::stringstream ss;
+        std::string value;
+
+        entry->QueryStringAttribute("value",&value);
+        ss << value;
+
+        vnl_vector_fixed<double, 3> vector;
+        vector.read_ascii(ss);
+
+        gdc->push_back(vector);
+
+        entry = entry->NextSiblingElement( "entry" );
+      }
+
+      return GradientDirectionsProperty::New(gdc).GetPointer();
+    }
+
+  protected:
+
+    GradientDirectionsPropertySerializer() {}
+    virtual ~GradientDirectionsPropertySerializer() {}
+};
+
+} // namespace
+
+// important to put this into the GLOBAL namespace (because it starts with 'namespace mitk')
+MITK_REGISTER_SERIALIZER(GradientDirectionsPropertySerializer)
+
+#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkMeasurementFrameProperty.cpp b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkMeasurementFrameProperty.cpp
new file mode 100644
index 0000000000..dea5153be0
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkMeasurementFrameProperty.cpp
@@ -0,0 +1,65 @@
+/*===================================================================
+
+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.
+
+===================================================================*/
+
+#include "mitkMeasurementFrameProperty.h"
+
+mitk::MeasurementFrameProperty::MeasurementFrameProperty()
+  : m_MeasurementFrame()
+{
+}
+
+mitk::MeasurementFrameProperty::MeasurementFrameProperty(const MeasurementFrameProperty& other)
+  : mitk::BaseProperty(other)
+{
+  m_MeasurementFrame = other.GetMeasurementFrame();
+}
+
+mitk::MeasurementFrameProperty::MeasurementFrameProperty(const MeasurementFrameType& measurementFrame)
+{
+  m_MeasurementFrame = measurementFrame;
+}
+
+mitk::MeasurementFrameProperty::~MeasurementFrameProperty()
+{
+}
+
+const mitk::MeasurementFrameProperty::MeasurementFrameType & mitk::MeasurementFrameProperty::GetMeasurementFrame() const
+{
+  return m_MeasurementFrame;
+}
+
+void mitk::MeasurementFrameProperty::SetMeasurementFrame(const MeasurementFrameType & frame)
+{
+  m_MeasurementFrame = frame;
+}
+
+bool mitk::MeasurementFrameProperty::IsEqual(const BaseProperty& property) const
+{
+  return this->m_MeasurementFrame == static_cast<const Self&>(property).m_MeasurementFrame;
+}
+
+bool mitk::MeasurementFrameProperty::Assign(const BaseProperty& property)
+{
+  this->m_MeasurementFrame = static_cast<const Self&>(property).m_MeasurementFrame;
+  return true;
+}
+
+itk::LightObject::Pointer  mitk::MeasurementFrameProperty::InternalClone() const
+{
+  itk::LightObject::Pointer result(new Self(*this));
+  result->UnRegister();
+  return result;
+}
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkMeasurementFrameProperty.h b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkMeasurementFrameProperty.h
new file mode 100644
index 0000000000..c892bba7a3
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkMeasurementFrameProperty.h
@@ -0,0 +1,60 @@
+/*===================================================================
+
+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 MITKMEASUREMENTFRAMEPROPERTY_H
+#define MITKMEASUREMENTFRAMEPROPERTY_H
+
+#include "mitkBaseProperty.h"
+#include <vnl/vnl_matrix_fixed.h>
+
+#include <MitkDiffusionCoreExports.h>
+
+namespace mitk
+{
+
+  /** This property will store the measurement frame */
+  class MitkDiffusionCore_EXPORT MeasurementFrameProperty : public mitk::BaseProperty
+  {
+  public:
+    typedef vnl_matrix_fixed< double, 3, 3 >                            MeasurementFrameType;
+    mitkClassMacro(MeasurementFrameProperty, BaseProperty)
+
+      itkFactorylessNewMacro(Self)
+      itkCloneMacro(Self)
+
+      mitkNewMacro1Param(MeasurementFrameProperty, const MeasurementFrameProperty&);
+    mitkNewMacro1Param(MeasurementFrameProperty, const MeasurementFrameType&);
+
+    const MeasurementFrameType &GetMeasurementFrame() const;
+    void SetMeasurementFrame(const MeasurementFrameType & frame);
+
+  protected:
+
+    MeasurementFrameProperty();
+    ~MeasurementFrameProperty();
+
+    MeasurementFrameProperty(const MeasurementFrameProperty& other);
+    MeasurementFrameProperty(const MeasurementFrameType& measurementFrame);
+
+    virtual bool IsEqual(const BaseProperty& property) const;
+    virtual bool Assign(const BaseProperty & property);
+
+    MeasurementFrameType m_MeasurementFrame;
+
+    virtual itk::LightObject::Pointer InternalClone() const;
+  };
+}
+#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkMeasurementFramePropertySerializer.cpp b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkMeasurementFramePropertySerializer.cpp
new file mode 100644
index 0000000000..60c17f8f59
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkMeasurementFramePropertySerializer.cpp
@@ -0,0 +1,89 @@
+/*===================================================================
+
+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 mitkMeasurementFramePropertySerializer_h_included
+#define mitkMeasurementFramePropertySerializer_h_included
+
+#include "mitkBasePropertySerializer.h"
+
+#include "mitkMeasurementFrameProperty.h"
+
+#include <MitkDiffusionCoreExports.h>
+
+namespace mitk
+{
+
+class MitkDiffusionCore_EXPORT MeasurementFramePropertySerializer : public BasePropertySerializer
+{
+  public:
+
+    mitkClassMacro( MeasurementFramePropertySerializer, BasePropertySerializer )
+    itkFactorylessNewMacro(Self)
+    itkCloneMacro(Self)
+
+    virtual TiXmlElement* Serialize()
+    {
+      if (const MeasurementFrameProperty* prop = dynamic_cast<const MeasurementFrameProperty*>(m_Property.GetPointer()))
+      {
+
+        typedef mitk::MeasurementFrameProperty::MeasurementFrameType MeasurementFrameType;
+        const MeasurementFrameType & mft = prop->GetMeasurementFrame();
+
+        if(mft.is_zero()) return NULL;
+
+        TiXmlElement* element = new TiXmlElement("measurementframe");
+
+        TiXmlElement* child = new TiXmlElement("entry");
+        std::stringstream ss;
+        ss << mft;
+        child->SetAttribute("value", ss.str());
+        element->InsertEndChild(*child);
+
+        return element;
+      }
+      else return NULL;
+    }
+
+    virtual BaseProperty::Pointer Deserialize(TiXmlElement* element)
+    {
+      if (!element) return NULL;
+
+      TiXmlElement* entry = element->FirstChildElement( "entry" )->ToElement();
+
+      std::stringstream ss;
+      std::string value;
+
+      entry->QueryStringAttribute("value",&value);
+      ss << value;
+
+      MeasurementFrameProperty::MeasurementFrameType matrix;
+      matrix.read_ascii(ss);
+
+      return MeasurementFrameProperty::New(matrix).GetPointer();
+    }
+
+  protected:
+
+    MeasurementFramePropertySerializer() {}
+    virtual ~MeasurementFramePropertySerializer() {}
+};
+
+} // namespace
+
+// important to put this into the GLOBAL namespace (because it starts with 'namespace mitk')
+MITK_REGISTER_SERIALIZER(MeasurementFramePropertySerializer)
+
+#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkNodePredicateIsDWI.cpp b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkNodePredicateIsDWI.cpp
new file mode 100644
index 0000000000..7afb4abc04
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkNodePredicateIsDWI.cpp
@@ -0,0 +1,39 @@
+/*===================================================================
+
+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.
+
+===================================================================*/
+
+#include "mitkNodePredicateIsDWI.h"
+#include "mitkDataNode.h"
+#include <mitkDiffusionPropertyHelper.h>
+
+mitk::NodePredicateIsDWI::NodePredicateIsDWI()
+: NodePredicateBase()
+{
+}
+
+mitk::NodePredicateIsDWI::~NodePredicateIsDWI()
+{
+}
+
+
+bool mitk::NodePredicateIsDWI::CheckNode(const mitk::DataNode* node) const
+{
+  if (node == NULL)
+    throw std::invalid_argument("NodePredicateIsDWI: invalid node");
+
+  mitk::Image* image = dynamic_cast<mitk::Image*>(node->GetData());
+
+  return mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( image );
+}
diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkNodePredicateIsDWI.h b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkNodePredicateIsDWI.h
new file mode 100644
index 0000000000..7ca6f29d70
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/Properties/mitkNodePredicateIsDWI.h
@@ -0,0 +1,56 @@
+/*===================================================================
+
+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 MITKNODEPREDICATEISDWI_H_HEADER_INCLUDED_
+#define MITKNODEPREDICATEISDWI_H_HEADER_INCLUDED_
+
+#include <MitkDiffusionCoreExports.h>
+
+#include "mitkNodePredicateBase.h"
+#include "mitkBaseProperty.h"
+#include "mitkBaseData.h"
+
+namespace mitk {
+
+    /**Documentation
+     * @brief Predicate that evaluates whether a given node contains a diffusion weighted image
+     * @ingroup DataStorage
+     */
+
+    class MitkDiffusionCore_EXPORT NodePredicateIsDWI : public NodePredicateBase
+    {
+    public:
+      mitkClassMacro(NodePredicateIsDWI, NodePredicateBase);
+      itkFactorylessNewMacro(NodePredicateIsDWI)
+
+      //##Documentation
+      //## @brief Standard Destructor
+      virtual ~NodePredicateIsDWI();
+
+      //##Documentation
+      //## @brief Checks, if the node's data contains a property that is equal to m_ValidProperty
+      virtual bool CheckNode(const mitk::DataNode* node) const;
+
+    protected:
+      //##Documentation
+      //## @brief Constructor to check for a named property
+      NodePredicateIsDWI();
+    };
+
+} // namespace mitk
+
+#endif /* MITKNODEPREDICATEISDWI_H_HEADER_INCLUDED_ */
diff --git a/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkDiffusionImageMapper.cpp b/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkDiffusionImageMapper.cpp
deleted file mode 100644
index dd8b9888ce..0000000000
--- a/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkDiffusionImageMapper.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-/*===================================================================
-
-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 DiffusionImageMapper_txx_HEADER_INCLUDED
-#define DiffusionImageMapper_txx_HEADER_INCLUDED
-
-#include "mitkProperties.h"
-#include "mitkDiffusionImage.h"
-
-template<class TPixelType>
-mitk::DiffusionImageMapper<TPixelType>::DiffusionImageMapper()
-{
-
-}
-
-template<class TPixelType>
-mitk::DiffusionImageMapper<TPixelType>::~DiffusionImageMapper()
-{
-
-}
-
-template<class TPixelType>
-void
-mitk::DiffusionImageMapper<TPixelType>::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
-{
-  int displayIndex(0);
-
-
-  this->GetDataNode()->GetIntProperty( "DisplayChannel", displayIndex, renderer );
-  mitk::Image *input = const_cast< mitk::Image* >(
-    this->GetInput()
-    );
-  mitk::DiffusionImage<TPixelType> *input2 = dynamic_cast< mitk::DiffusionImage<TPixelType>* >(
-    input
-    );
-
-  input2->SetDisplayIndexForRendering(displayIndex);
-  Superclass::GenerateDataForRenderer(renderer);
-}
-
-template<class TPixelType>
-void mitk::DiffusionImageMapper<TPixelType>::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
-{
-  node->AddProperty( "DisplayChannel", mitk::IntProperty::New( 0 ), renderer, overwrite );
-  Superclass::SetDefaultProperties(node, renderer, overwrite);
-}
-
-#endif
diff --git a/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkDiffusionImageMapper.h b/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkDiffusionImageMapper.h
deleted file mode 100644
index fa53102f1d..0000000000
--- a/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkDiffusionImageMapper.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/*===================================================================
-
-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 DiffusionImageMapper_H_HEADER_INCLUDED
-#define DiffusionImageMapper_H_HEADER_INCLUDED
-
-#include "mitkImageVtkMapper2D.h"
-
-namespace mitk {
-
-  //##Documentation
-  //## @brief Mapper for raw diffusion weighted images
-  //## @ingroup Mapper
-  template<class TPixelType>
-  class DiffusionImageMapper : public ImageVtkMapper2D
-  {
-  public:
-
-    mitkClassMacro(DiffusionImageMapper,ImageVtkMapper2D);
-    itkFactorylessNewMacro(Self)
-    itkCloneMacro(Self)
-
-    void GenerateDataForRenderer( mitk::BaseRenderer *renderer );
-
-    static void SetDefaultProperties(DataNode* node, BaseRenderer* renderer = NULL, bool overwrite = false );
-
-  protected:
-
-    DiffusionImageMapper();
-    virtual ~DiffusionImageMapper();
-
-  };
-
-} // namespace mitk
-
-#include "mitkDiffusionImageMapper.cpp"
-
-
-#endif /* COMPOSITEMAPPER_H_HEADER_INCLUDED */
-
diff --git a/Modules/DiffusionImaging/DiffusionCore/Testing/files.cmake b/Modules/DiffusionImaging/DiffusionCore/Testing/files.cmake
index 4a2a9d22b0..9e87b8b605 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Testing/files.cmake
+++ b/Modules/DiffusionImaging/DiffusionCore/Testing/files.cmake
@@ -1,16 +1,15 @@
 set(MODULE_TESTS
-  mitkDiffusionImageEqualTest.cpp
   mitkNonLocalMeansDenoisingTest.cpp
-  mitkDiffusionImageEqualTest.cpp
+  mitkDiffusionPropertySerializerTest.cpp
 )
 
 set(MODULE_CUSTOM_TESTS
   mitkPyramidImageRegistrationMethodTest.cpp
   mitkDWHeadMotionCorrectionTest.cpp
   mitkImageReconstructionTest.cpp
   mitkConvertDWITypeTest.cpp
   mitkExtractSingleShellTest.cpp
   mitkNonLocalMeansDenoisingTest.cpp
   mitkDiffusionDICOMFileReaderTest.cpp
 )
 
diff --git a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkB0ExtractionToSeparateImagesFilterTest.cpp b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkB0ExtractionToSeparateImagesFilterTest.cpp
index c157efef62..101143f9d9 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkB0ExtractionToSeparateImagesFilterTest.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkB0ExtractionToSeparateImagesFilterTest.cpp
@@ -1,109 +1,108 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include "mitkTestingMacros.h"
 #include "itkVectorImage.h"
 #include "mitkBaseData.h"
 #include "mitkBaseDataIOFactory.h"
 
 #include "mitkImageWriter.h"
 #include "itkImageFileWriter.h"
 
 #include "itkB0ImageExtractionToSeparateImageFilter.h"
-#include "mitkDiffusionImage.h"
 
 #include "mitkDiffusionCoreObjectFactory.h"
 
 /** Documentation
  *  Test for factory registration
  */
 int mitkB0ExtractionToSeparateImagesFilterTest(int  argc , char* argv[])
 {
   // always start with this!
   MITK_TEST_BEGIN("mitkB0ExtractionToSeparateImagesFilterTest");
 
   MITK_TEST_CONDITION_REQUIRED(argc > 2, "Test image is specified. ");
 
   typedef short DiffusionPixelType;
-  typedef mitk::DiffusionImage< DiffusionPixelType > DiffusionImageType;
+  typedef mitk::Image DiffusionImageType;
   typedef mitk::NrrdDiffusionImageReader< DiffusionPixelType> DiffusionNrrdReaderType;
 
   RegisterDiffusionImagingObjectFactory();
 
   std::string inputFileName( argv[1] );
 
   std::vector<mitk::BaseData::Pointer> inputBaseDataVector = mitk::BaseDataIO::LoadBaseDataFromFile( inputFileName, "","",false);
 
   MITK_TEST_CONDITION_REQUIRED( inputBaseDataVector.size() > 0, "BaseDataIO returned non-empty vector.");
 
   mitk::BaseData::Pointer baseData = inputBaseDataVector.at(0);
 
   MITK_TEST_CONDITION_REQUIRED( baseData.IsNotNull(), "BaseData is not null")
 
       DiffusionImageType* vols = dynamic_cast< DiffusionImageType* >(baseData.GetPointer());
 
   MITK_TEST_CONDITION_REQUIRED( vols != NULL, "Casting basedata to diffusion image successfull." );
 
   // filter
   typedef itk::B0ImageExtractionToSeparateImageFilter< short, short> FilterType;
   typename FilterType::Pointer filter = FilterType::New();
 
   MITK_TEST_CONDITION_REQUIRED(filter.IsNotNull(), "Filter instance created. ");
 
   filter->SetInput(vols->GetVectorImage());
   filter->SetDirections(vols->GetDirections());
   filter->Update();
 
   // output
   mitk::Image::Pointer mitkImage = mitk::Image::New();
 
   MITK_TEST_CONDITION_REQUIRED( mitkImage.IsNotNull(), "mitkImage not null." );
 
   mitkImage->InitializeByItk( filter->GetOutput() );
 
   MITK_TEST_CONDITION_REQUIRED( mitkImage->GetDimension()==4, "Output image is a 4D image.");
 
   mitkImage->SetImportChannel( filter->GetOutput()->GetBufferPointer() );
 
   typedef itk::ImageFileWriter< FilterType::OutputImageType > itkImageWriterType;
   typename itkImageWriterType::Pointer itkWriter = itkImageWriterType::New();
 
   itkWriter->SetFileName( argv[2] );
   itkWriter->SetInput( filter->GetOutput() );
 
   try
   {
     itkWriter->Update();
   }
   catch(itk::ExceptionObject &e)
   {
     MITK_ERROR << "Catched exception from image writer. " << e.what();
   }
 
   /*
   // write output
   mitk::ImageWriter::Pointer writer = mitk::ImageWriter::New();
   MITK_TEST_CONDITION_REQUIRED( writer.IsNotNull(), "Writer instance created. ");
 
   writer->SetInput( mitkImage );
   writer->SetExtension(".nrrd");
   writer->SetFileName( "/localdata/hering/_Images/TestB0Extraction" );
 
   writer->Update();
 */
   // always end with this!
   MITK_TEST_END();
 }
diff --git a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkConvertDWITypeTest.cpp b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkConvertDWITypeTest.cpp
index aeae0f8536..4e6449576a 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkConvertDWITypeTest.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkConvertDWITypeTest.cpp
@@ -1,51 +1,46 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include "mitkTestingMacros.h"
 #include "mitkIOUtil.h"
 
 #include "mitkDWIHeadMotionCorrectionFilter.h"
 
-typedef short                                       DiffusionPixelType;
-typedef mitk::DiffusionImage< DiffusionPixelType >  DiffusionImageType;
-
 /**
  * @brief Custom test to provide CMD-line access to the mitk::DWIHeadMotionCorrectionFilter
  *
  * @param argv : Input and Output image full path
  */
 int mitkConvertDWITypeTest( int argc, char* argv[] )
 {
   MITK_TEST_BEGIN("mitkConvertDWITypeTest");
 
   MITK_TEST_CONDITION_REQUIRED( argc > 2, "Specify input and output.");
 
   mitk::Image::Pointer inputImage = mitk::IOUtil::LoadImage( argv[1] );
-  DiffusionImageType* dwimage =
-      static_cast<DiffusionImageType*>( inputImage.GetPointer() );
 
   try
   {
-    mitk::IOUtil::Save(dwimage, argv[2]);
+    mitk::IOUtil::Save(inputImage, argv[2]);
   }
   catch( const itk::ExceptionObject& e)
   {
-    MITK_ERROR << "Catched exception: " << e.what();
+    MITK_ERROR << "Caught exception: " << e.what();
     mitkThrow() << "Failed with exception from subprocess!";
   }
 
   MITK_TEST_END();
 }
diff --git a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkDWHeadMotionCorrectionTest.cpp b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkDWHeadMotionCorrectionTest.cpp
index 7805c72b3c..e19fc61f9c 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkDWHeadMotionCorrectionTest.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkDWHeadMotionCorrectionTest.cpp
@@ -1,60 +1,60 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include "mitkTestingMacros.h"
 #include "mitkIOUtil.h"
 
-#include "mitkDWIHeadMotionCorrectionFilter.h"
+#include <mitkDWIHeadMotionCorrectionFilter.h>
 
 typedef short                                       DiffusionPixelType;
-typedef mitk::DiffusionImage< DiffusionPixelType >  DiffusionImageType;
+typedef mitk::Image  DiffusionImageType;
 
 /**
  * @brief Custom test to provide CMD-line access to the mitk::DWIHeadMotionCorrectionFilter
  *
  * @param argv : Input and Output image full path
  */
 int mitkDWHeadMotionCorrectionTest( int argc, char* argv[] )
 {
   MITK_TEST_BEGIN("mitkDWHeadMotionCorrectionTest");
 
   MITK_TEST_CONDITION_REQUIRED( argc > 2, "Specify input and output.");
 
 //  itk::MultiThreader::SetGlobalMaximumNumberOfThreads(1);
 
   mitk::Image::Pointer inputImage = mitk::IOUtil::LoadImage( argv[1] );
   DiffusionImageType* dwimage =
       static_cast<DiffusionImageType*>( inputImage.GetPointer() );
 
-  mitk::DWIHeadMotionCorrectionFilter<DiffusionPixelType>::Pointer corrfilter =
-      mitk::DWIHeadMotionCorrectionFilter<DiffusionPixelType>::New();
+  mitk::DWIHeadMotionCorrectionFilter::Pointer corrfilter =
+      mitk::DWIHeadMotionCorrectionFilter::New();
 
   corrfilter->SetInput( dwimage );
   corrfilter->SetAverageUnweighted(false);
   corrfilter->Update();
 
   try
   {
     mitk::IOUtil::SaveBaseData(corrfilter->GetOutput(), argv[2]);
   }
   catch( const itk::ExceptionObject& e)
   {
     MITK_ERROR << "Catched exception: " << e.what();
     mitkThrow() << "Failed with exception from subprocess!";
   }
 
   MITK_TEST_END();
 }
diff --git a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkDiffusionDICOMFileReaderTest.cpp b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkDiffusionDICOMFileReaderTest.cpp
index 1b18949742..bfdd73c944 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkDiffusionDICOMFileReaderTest.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkDiffusionDICOMFileReaderTest.cpp
@@ -1,115 +1,113 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include "mitkDiffusionDICOMFileReader.h"
 #include "mitkDiffusionDICOMFileReaderTestHelper.h"
 #include "mitkDICOMTagBasedSorter.h"
 #include "mitkDICOMSortByTag.h"
 
 #include <mitkIOUtil.h>
 
 #include "mitkTestingMacros.h"
 
 using mitk::DICOMTag;
 
 int mitkDiffusionDICOMFileReaderTest(int argc, char* argv[])
 {
   MITK_TEST_BEGIN("mitkDiffusionDICOMFileReaderTest");
 
   mitk::DiffusionDICOMFileReader::Pointer gdcmReader = mitk::DiffusionDICOMFileReader::New();
   MITK_TEST_CONDITION_REQUIRED(gdcmReader.IsNotNull(), "DICOMITKSeriesGDCMReader can be instantiated.");
 
   std::string output_filename = "/tmp/dicom_out.dwi";
   if( argc > 3)
   {
     mitk::DICOMFileReaderTestHelper::SetTestInputFilenames( argc-1,argv );
     output_filename = std::string( argv[argc-1] );
   }
   else
   {
     mitk::DICOMFileReaderTestHelper::SetTestInputFilenames( argc,argv );
   }
 
   // check the Set/GetInput function
   mitk::DICOMFileReaderTestHelper::TestInputFilenames( gdcmReader );
   MITK_INFO << "Test input filenanems";
 
   // check that output is a good reproduction of input (no duplicates, no new elements)
   mitk::DICOMFileReaderTestHelper::TestOutputsContainInputs( gdcmReader );
   MITK_INFO << "Test output";
 
   // repeat test with some more realistic sorting
   gdcmReader = mitk::DiffusionDICOMFileReader::New(); // this also tests destruction
   mitk::DICOMTagBasedSorter::Pointer tagSorter = mitk::DICOMTagBasedSorter::New();
 
   // Use tags as in Qmitk
   // all the things that split by tag in DicomSeriesReader
   tagSorter->AddDistinguishingTag( DICOMTag(0x0028, 0x0010) ); // Number of Rows
   tagSorter->AddDistinguishingTag( DICOMTag(0x0028, 0x0011) ); // Number of Columns
   tagSorter->AddDistinguishingTag( DICOMTag(0x0028, 0x0030) ); // Pixel Spacing
   tagSorter->AddDistinguishingTag( DICOMTag(0x0018, 0x1164) ); // Imager Pixel Spacing
   tagSorter->AddDistinguishingTag( DICOMTag(0x0020, 0x0037) ); // Image Orientation (Patient) // TODO add tolerance parameter (l. 1572 of original code)
   // TODO handle as real vectors! cluster with configurable errors!
   //tagSorter->AddDistinguishingTag( DICOMTag(0x0020, 0x000e) ); // Series Instance UID
   //tagSorter->AddDistinguishingTag( DICOMTag(0x0020, 0x0010) );
   tagSorter->AddDistinguishingTag( DICOMTag(0x0018, 0x0050) ); // Slice Thickness
   tagSorter->AddDistinguishingTag( DICOMTag(0x0028, 0x0008) ); // Number of Frames
   tagSorter->AddDistinguishingTag( DICOMTag(0x0020, 0x0052) ); // Frame of Reference UID
 
  // gdcmReader->AddSortingElement( tagSorter );
   //mitk::DICOMFileReaderTestHelper::TestOutputsContainInputs( gdcmReader );
 
   mitk::DICOMSortCriterion::ConstPointer sorting =
     mitk::DICOMSortByTag::New( DICOMTag(0x0020, 0x0013), // instance number
       mitk::DICOMSortByTag::New( DICOMTag(0x0020, 0x0012), // aqcuisition number
         mitk::DICOMSortByTag::New( DICOMTag(0x0008, 0x0032), // aqcuisition time
           mitk::DICOMSortByTag::New( DICOMTag(0x0018, 0x1060), // trigger time
             mitk::DICOMSortByTag::New( DICOMTag(0x0008, 0x0018) // SOP instance UID (last resort, not really meaningful but decides clearly)
             ).GetPointer()
           ).GetPointer()
         ).GetPointer()
       ).GetPointer()
     ).GetPointer();
   tagSorter->SetSortCriterion( sorting );
 
   MITK_INFO << "Created sort";
 
   gdcmReader->AddSortingElement( tagSorter );
   mitk::DICOMFileReaderTestHelper::TestOutputsContainInputs( gdcmReader );
 
   MITK_INFO << "Created sort";
 
   //gdcmReader->PrintOutputs(std::cout, true);
 
   // really load images
   //mitk::DICOMFileReaderTestHelper::TestMitkImagesAreLoaded( gdcmReader );
   gdcmReader->LoadImages();
 
   mitk::Image::Pointer loaded_image = gdcmReader->GetOutput(0).GetMitkImage();
 
-  mitk::DiffusionImage<short>::Pointer d_img = static_cast<mitk::DiffusionImage<short>*>( loaded_image.GetPointer() );
-
   try
   {
-    mitk::IOUtil::Save(d_img, output_filename.c_str());
+    mitk::IOUtil::Save(loaded_image, output_filename.c_str());
   }
   catch( const itk::ExceptionObject& e)
   {
     MITK_TEST_FAILED_MSG( << "Writer failed : " << e.what() );
   }
 
   MITK_TEST_END();
 }
diff --git a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkDiffusionImageEqualTest.cpp b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkDiffusionImageEqualTest.cpp
deleted file mode 100644
index 8f33698338..0000000000
--- a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkDiffusionImageEqualTest.cpp
+++ /dev/null
@@ -1,116 +0,0 @@
-/*===================================================================
-
-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.
-
-===================================================================*/
-
-#include "mitkDiffusionImage.h"
-#include "mitkIOUtil.h"
-#include "mitkTestingMacros.h"
-#include "mitkTestFixture.h"
-#include "itkDwiGradientLengthCorrectionFilter.h"
-
-class mitkDiffusionImageEqualTestSuite : public mitk::TestFixture
-{
-
-  CPPUNIT_TEST_SUITE(mitkDiffusionImageEqualTestSuite);
-  MITK_TEST(Equal_CloneAndOriginal_ReturnsTrue);
-  MITK_TEST(Equal_DifferentGradientContainerElements_ReturnsFalse);
-  MITK_TEST(Equal_DifferentBValue_ReturnsFalse);
-  MITK_TEST(Equal_DifferentVectorImagePixel_ReturnFalse);
-  MITK_TEST(Equal_GetNumberOfBValues_ReturnFalse);
-  MITK_TEST(Equal_DifferentMeasurmentFrame_ReturnFalse);
-  //MITK_TEST(Equal_DifferentChannels_ReturnFalse);
-
-
-  CPPUNIT_TEST_SUITE_END();
-
-private:
-
-  /** Members used inside the different (sub-)tests. All members are initialized via setUp().*/
-  mitk::DiffusionImage<short>::Pointer m_Image;
-  mitk::DiffusionImage<short>::Pointer m_AnotherImage;
-
-public:
-
-  /**
-* @brief Setup Always call this method before each Test-case to ensure correct and new intialization of the used members for a new test case. (If the members are not used in a test, the method does not need to be called).
-*/
-  void setUp()
-  {
-    //generate a gradient test image
-    std::string imagePath = GetTestDataFilePath("DiffusionImaging/ImageReconstruction/test_multi.dwi");
-    m_Image = static_cast<mitk::DiffusionImage<short>*>( mitk::IOUtil::LoadImage(imagePath).GetPointer());
-    m_AnotherImage = m_Image->Clone();
-  }
-
-  void tearDown()
-  {
-    m_Image = NULL;
-    m_AnotherImage = NULL;
-  }
-
-  void Equal_CloneAndOriginal_ReturnsTrue()
-  {
-    MITK_ASSERT_EQUAL( m_Image, m_AnotherImage, "A clone should be equal to its original.");
-  }
-
-  void Equal_DifferentGradientContainerElements_ReturnsFalse()
-  {
-    mitk::DiffusionImage<short>::GradientDirectionType dummyVec;
-    dummyVec.fill(std::numeric_limits<double>::max());
-    mitk::DiffusionImage<short>::GradientDirectionContainerType::ElementIdentifier mid_pos(m_AnotherImage->GetDirections()->Size()*0.5);
-    m_AnotherImage->GetDirections()->SetElement(mid_pos, dummyVec);
-    MITK_ASSERT_NOT_EQUAL( m_Image, m_AnotherImage, "GradientDirectionContainer Elements are not equal.");
-  }
-
-  void Equal_DifferentBValue_ReturnsFalse()
-  {
-    m_AnotherImage->SetReferenceBValue(std::numeric_limits<unsigned int>::max());
-    MITK_ASSERT_NOT_EQUAL( m_Image, m_AnotherImage, "BValue is not equal.");
-  }
-
-  void Equal_DifferentVectorImagePixel_ReturnFalse()
-  {
-    mitk::DiffusionImage<short>::ImageType::IndexType indx;
-    indx.Fill(0);
-    mitk::DiffusionImage<short>::ImageType::PixelType pix;
-    short* val = new short[pix.Size()];
-    pix.SetData(val);
-    pix.Fill(std::numeric_limits<short>::min());
-    m_AnotherImage->GetVectorImage()->SetPixel(indx,pix);
-    MITK_ASSERT_NOT_EQUAL( m_Image, m_AnotherImage, "itkVectorImage voxel at pos [0,0,0] should be different.");
-  }
-
-  void Equal_DifferentMeasurmentFrame_ReturnFalse()
-  {
-    mitk::DiffusionImage<short>::MeasurementFrameType null_measurementframe;
-    null_measurementframe.fill(0);
-    m_AnotherImage->SetMeasurementFrame(null_measurementframe);
-    MITK_ASSERT_NOT_EQUAL( m_Image, m_AnotherImage, "MeasurementFrame is an empty matrix. Result should be false.");
-  }
-
-  void Equal_GetNumberOfBValues_ReturnFalse()
-  {
-    itk::DwiGradientLengthCorrectionFilter::Pointer lengthCorrectionFilter = itk::DwiGradientLengthCorrectionFilter::New();
-    lengthCorrectionFilter->SetReferenceBValue(m_AnotherImage->GetReferenceBValue());
-    lengthCorrectionFilter->SetReferenceGradientDirectionContainer(m_AnotherImage->GetDirections());
-    lengthCorrectionFilter->SetRoundingValue(10000);
-    lengthCorrectionFilter->Update();
-    m_AnotherImage->SetDirections(lengthCorrectionFilter->GetOutputGradientDirectionContainer());
-    MITK_ASSERT_NOT_EQUAL( m_Image, m_AnotherImage, "NumberOfBValues should different.");
-  }
-
-};
-
-MITK_TEST_SUITE_REGISTRATION(mitkDiffusionImageEqual)
diff --git a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkDiffusionPropertySerializerTest.cpp b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkDiffusionPropertySerializerTest.cpp
new file mode 100644
index 0000000000..436646692c
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkDiffusionPropertySerializerTest.cpp
@@ -0,0 +1,184 @@
+/*===================================================================
+
+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.
+
+===================================================================*/
+
+#include "mitkIOUtil.h"
+#include "mitkTestingMacros.h"
+#include "mitkTestFixture.h"
+
+#include <mitkBasePropertySerializer.h>
+
+#include <mitkBValueMapProperty.h>
+
+#include <mitkGradientDirectionsProperty.h>
+#include <mitkMeasurementFrameProperty.h>
+
+#include <mitkDiffusionPropertyHelper.h>
+
+class mitkDiffusionPropertySerializerTestSuite : public mitk::TestFixture
+{
+
+  CPPUNIT_TEST_SUITE(mitkDiffusionPropertySerializerTestSuite);
+  MITK_TEST(Equal_SerializeandDeserialize_ReturnsTrue);
+
+  //MITK_TEST(Equal_DifferentChannels_ReturnFalse);
+
+
+  CPPUNIT_TEST_SUITE_END();
+
+private:
+
+  /** Members used inside the different (sub-)tests. All members are initialized via setUp().*/
+  mitk::PropertyList::Pointer propList; //represet image propertylist
+  mitk::BValueMapProperty::Pointer bvaluemap_prop;
+  mitk::GradientDirectionsProperty::Pointer gradientdirection_prop;
+  mitk::MeasurementFrameProperty::Pointer measurementframe_prop;
+
+public:
+
+  /**
+* @brief Setup Always call this method before each Test-case to ensure correct and new intialization of the used members for a new test case. (If the members are not used in a test, the method does not need to be called).
+*/
+  void setUp()
+  {
+
+    propList = mitk::PropertyList::New();
+
+    mitk::BValueMapProperty::BValueMap map;
+    std::vector<unsigned int> indices1;
+    indices1.push_back(1);
+    indices1.push_back(2);
+    indices1.push_back(3);
+    indices1.push_back(4);
+
+    map[0] = indices1;
+    std::vector<unsigned int> indices2;
+    indices2.push_back(4);
+    indices2.push_back(3);
+    indices2.push_back(2);
+    indices2.push_back(1);
+
+    map[1000] = indices2;
+    bvaluemap_prop = mitk::BValueMapProperty::New(map).GetPointer();
+    propList->SetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str(),bvaluemap_prop);
+
+
+    mitk::GradientDirectionsProperty::GradientDirectionsContainerType::Pointer gdc;
+    gdc = mitk::GradientDirectionsProperty::GradientDirectionsContainerType::New();
+
+    double a[3] = {3.0,4.0,1.4};
+    vnl_vector_fixed<double,3> vec1;
+    vec1.set(a);
+    gdc->push_back(vec1);
+
+    double b[3] = {1.0,5.0,123.4};
+    vnl_vector_fixed<double,3> vec2;
+    vec2.set(b);
+    gdc->push_back(vec2);
+
+    double c[3] = {13.0,84.02,13.4};
+    vnl_vector_fixed<double,3> vec3;
+    vec3.set(c);
+    gdc->push_back(vec3);
+
+
+    gradientdirection_prop = mitk::GradientDirectionsProperty::New(gdc.GetPointer()).GetPointer();
+    propList->SetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), gradientdirection_prop);
+
+    mitk::MeasurementFrameProperty::MeasurementFrameType mft;
+
+    double row0[3] = {1,0,0};
+    double row1[3] = {0,1,0};
+    double row2[3] = {0,0,1};
+
+    mft.set_row(0,row0);
+    mft.set_row(1,row1);
+    mft.set_row(2,row2);
+
+    measurementframe_prop = mitk::MeasurementFrameProperty::New(mft).GetPointer();
+    propList->SetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), measurementframe_prop);
+  }
+
+  void tearDown()
+  {
+
+  }
+
+  void Equal_SerializeandDeserialize_ReturnsTrue()
+  {
+
+    assert(propList);
+
+    /* try to serialize each property in the list, then deserialize again and check for equality */
+    for (mitk::PropertyList::PropertyMap::const_iterator it = propList->GetMap()->begin(); it != propList->GetMap()->end(); ++it)
+    {
+      const mitk::BaseProperty* prop = it->second;
+      // construct name of serializer class
+      std::string serializername = std::string(prop->GetNameOfClass()) + "Serializer";
+      std::list<itk::LightObject::Pointer> allSerializers = itk::ObjectFactoryBase::CreateAllInstance(serializername.c_str());
+      MITK_TEST_CONDITION(allSerializers.size() > 0, std::string("Creating serializers for ") + serializername);
+      if (allSerializers.size() == 0)
+      {
+        MITK_TEST_OUTPUT( << "serialization not possible, skipping " << prop->GetNameOfClass());
+        continue;
+      }
+      if (allSerializers.size() > 1)
+      {
+        MITK_TEST_OUTPUT (<< "Warning: " << allSerializers.size() << " serializers found for " << prop->GetNameOfClass() << "testing only the first one.");
+      }
+      mitk::BasePropertySerializer* serializer = dynamic_cast<mitk::BasePropertySerializer*>( allSerializers.begin()->GetPointer());
+      MITK_TEST_CONDITION(serializer != NULL, serializername + std::string(" is valid"));
+      if (serializer != NULL)
+      {
+        serializer->SetProperty(prop);
+        TiXmlElement* valueelement = NULL;
+        try
+        {
+          valueelement = serializer->Serialize();
+//          TiXmlPrinter p;
+//          valueelement->Accept(&p);
+//          MITK_INFO << p.CStr();
+        }
+        catch (...)
+        {
+        }
+        MITK_TEST_CONDITION(valueelement != NULL, std::string("Serialize property with ") + serializername);
+
+        if (valueelement == NULL)
+        {
+          MITK_TEST_OUTPUT( << "serialization failed, skipping deserialization");
+          continue;
+        }
+
+        mitk::BaseProperty::Pointer deserializedProp = serializer->Deserialize( valueelement );
+        MITK_TEST_CONDITION(deserializedProp.IsNotNull(), "serializer created valid property");
+        if (deserializedProp.IsNotNull())
+        {
+          MITK_TEST_CONDITION(*(deserializedProp.GetPointer()) == *prop, "deserialized property equals initial property for type " << prop->GetNameOfClass());
+        }
+
+      }
+      else
+      {
+        MITK_TEST_OUTPUT( << "created serializer object is of class " << allSerializers.begin()->GetPointer()->GetNameOfClass())
+      }
+    } // for all properties
+
+  }
+
+
+};
+
+MITK_TEST_SUITE_REGISTRATION(mitkDiffusionPropertySerializer)
diff --git a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkExtractSingleShellTest.cpp b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkExtractSingleShellTest.cpp
index f2b1ae2338..43686ea03e 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkExtractSingleShellTest.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkExtractSingleShellTest.cpp
@@ -1,96 +1,103 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include "mitkTestingMacros.h"
 #include "mitkIOUtil.h"
 
 #include <itkElectrostaticRepulsionDiffusionGradientReductionFilter.h>
 
 #include "mitkDWIHeadMotionCorrectionFilter.h"
+#include <mitkDiffusionPropertyHelper.h>
+#include <mitkImageCast.h>
+#include <mitkProperties.h>
 
 typedef short                                       DiffusionPixelType;
-typedef mitk::DiffusionImage< DiffusionPixelType >  DiffusionImageType;
 
 
 int mitkExtractSingleShellTest( int argc, char* argv[] )
 {
   MITK_TEST_BEGIN("mitkExtractSingleShellTest");
 
   MITK_TEST_CONDITION_REQUIRED( argc > 3, "Specify input and output and the shell to be extracted");
 
   /*
     1. Get input data
     */
-  mitk::Image::Pointer inputImage = mitk::IOUtil::LoadImage( argv[1] );
-  DiffusionImageType* dwimage =
-      static_cast<DiffusionImageType*>( inputImage.GetPointer() );
+  mitk::Image::Pointer dwimage = mitk::IOUtil::LoadImage( argv[1] );
 
-  MITK_TEST_CONDITION_REQUIRED( dwimage != NULL, "Input is a dw-image");
+  mitk::GradientDirectionsProperty::Pointer gradientsProperty = static_cast<mitk::GradientDirectionsProperty *>( dwimage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() );
+
+  MITK_TEST_CONDITION_REQUIRED( gradientsProperty.IsNotNull(), "Input is a dw-image");
 
   unsigned int extract_value = 0;
   std::istringstream input(argv[3]);
 
   input >> extract_value;
 
   typedef itk::ElectrostaticRepulsionDiffusionGradientReductionFilter<DiffusionPixelType, DiffusionPixelType> FilterType;
-  typedef DiffusionImageType::BValueMap BValueMap;
+  typedef mitk::DiffusionPropertyHelper::BValueMapType BValueMap;
 
   // GetShellSelection from GUI
   BValueMap shellSelectionMap;
-  BValueMap originalShellMap = dwimage->GetBValueMap();
+  BValueMap originalShellMap = static_cast<mitk::BValueMapProperty*>(dwimage->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )->GetBValueMap();
   std::vector<unsigned int> newNumGradientDirections;
 
   shellSelectionMap[extract_value] = originalShellMap[extract_value];
   newNumGradientDirections.push_back( originalShellMap[extract_value].size() ) ;
 
-  DiffusionImageType::GradientDirectionContainerType::Pointer gradientContainer = dwimage->GetDirections();
+  itk::VectorImage< short, 3 >::Pointer itkVectorImagePointer = itk::VectorImage< short, 3 >::New();
+  mitk::CastToItkImage(dwimage, itkVectorImagePointer);
+  itk::VectorImage< short, 3 > *vectorImage = itkVectorImagePointer.GetPointer();
+
+  mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer gradientContainer = static_cast<mitk::GradientDirectionsProperty*>( dwimage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
   FilterType::Pointer filter = FilterType::New();
-  filter->SetInput(dwimage->GetVectorImage());
+  filter->SetInput(vectorImage);
   filter->SetOriginalGradientDirections(gradientContainer);
   filter->SetNumGradientDirections(newNumGradientDirections);
   filter->SetOriginalBValueMap(originalShellMap);
   filter->SetShellSelectionBValueMap(shellSelectionMap);
 
   try
   {
     filter->Update();
   }
   catch( const itk::ExceptionObject& e)
   {
     MITK_TEST_FAILED_MSG( << "Failed due to ITK exception: " << e.what() );
   }
 
-  DiffusionImageType::Pointer image = DiffusionImageType::New();
-  image->SetVectorImage( filter->GetOutput() );
-  image->SetReferenceBValue(dwimage->GetReferenceBValue());
-  image->SetDirections(filter->GetGradientDirections());
-  image->SetMeasurementFrame(dwimage->GetMeasurementFrame());
-  image->InitializeFromVectorImage();
+  mitk::Image::Pointer outImage = mitk::GrabItkImageMemory( filter->GetOutput() );
+  outImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( filter->GetGradientDirections() ) );
+  outImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>(dwimage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() ) );
+  outImage->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( static_cast<mitk::MeasurementFrameProperty*>(dwimage->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )->GetMeasurementFrame() ) );
+  mitk::DiffusionPropertyHelper propertyHelper( outImage );
+  propertyHelper.InitializeImage();
+
   /*
    * 3. Write output data
    **/
   try
   {
-    mitk::IOUtil::Save(image, argv[2]);
+    mitk::IOUtil::Save(outImage, argv[2]);
   }
   catch( const itk::ExceptionObject& e)
   {
     MITK_ERROR << "Catched exception: " << e.what();
     mitkThrow() << "Failed with exception from subprocess!";
   }
 
   MITK_TEST_END();
 }
diff --git a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkImageReconstructionTest.cpp b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkImageReconstructionTest.cpp
index e1f16dcca7..33bfd4cd53 100755
--- a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkImageReconstructionTest.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkImageReconstructionTest.cpp
@@ -1,152 +1,158 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include <mitkImageCast.h>
 #include <mitkTensorImage.h>
 #include <mitkQBallImage.h>
-#include <mitkDiffusionImage.h>
 #include <mitkIOUtil.h>
 #include <mitkBaseDataIOFactory.h>
 #include <itkDiffusionTensor3D.h>
 #include <mitkTestingMacros.h>
 #include <itkDiffusionTensor3DReconstructionImageFilter.h>
 #include <itkDiffusionTensor3D.h>
 #include <itkDiffusionQballReconstructionImageFilter.h>
 #include <itkAnalyticalDiffusionQballReconstructionImageFilter.h>
+#include <mitkImage.h>
+#include <mitkDiffusionPropertyHelper.h>
 
 using namespace std;
 
 int mitkImageReconstructionTest(int argc, char* argv[])
 {
     MITK_TEST_BEGIN("mitkImageReconstructionTest");
 
     MITK_TEST_CONDITION_REQUIRED(argc>1,"check for input data")
 
     try
     {
-        mitk::DiffusionImage<short>::Pointer dwi = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[1])->GetData());
+        mitk::Image::Pointer dwi = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[1])->GetData());
 
+        itk::VectorImage<short,3>::Pointer itkVectorImagePointer = itk::VectorImage<short,3>::New();
+        mitk::CastToItkImage(dwi, itkVectorImagePointer);
+
+        float b_value = mitk::DiffusionPropertyHelper::GetReferenceBValue( dwi );
+        mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer gradients = mitk::DiffusionPropertyHelper::GetGradientContainer(dwi);
         {
             MITK_INFO << "Tensor reconstruction " << argv[2];
             mitk::TensorImage::Pointer tensorImage = dynamic_cast<mitk::TensorImage*>(mitk::IOUtil::LoadDataNode(argv[2])->GetData());
             typedef itk::DiffusionTensor3DReconstructionImageFilter< short, short, float > TensorReconstructionImageFilterType;
             TensorReconstructionImageFilterType::Pointer filter = TensorReconstructionImageFilterType::New();
-            filter->SetGradientImage( dwi->GetDirections(), dwi->GetVectorImage() );
-            filter->SetBValue(dwi->GetReferenceBValue());
+            filter->SetGradientImage( gradients, itkVectorImagePointer );
+            filter->SetBValue( b_value );
             filter->Update();
             mitk::TensorImage::Pointer testImage = mitk::TensorImage::New();
             testImage->InitializeByItk( filter->GetOutput() );
             testImage->SetVolume( filter->GetOutput()->GetBufferPointer() );
             MITK_TEST_CONDITION_REQUIRED(mitk::Equal(*testImage, *tensorImage, 0.0001, true), "tensor reconstruction test.");
         }
 
         {
             MITK_INFO << "Numerical Q-ball reconstruction " << argv[3];
             mitk::QBallImage::Pointer qballImage = dynamic_cast<mitk::QBallImage*>(mitk::IOUtil::LoadDataNode(argv[3])->GetData());
             typedef itk::DiffusionQballReconstructionImageFilter<short, short, float, QBALL_ODFSIZE> QballReconstructionImageFilterType;
             QballReconstructionImageFilterType::Pointer filter = QballReconstructionImageFilterType::New();
-            filter->SetGradientImage( dwi->GetDirections(), dwi->GetVectorImage() );
-            filter->SetBValue(dwi->GetReferenceBValue());
+            filter->SetGradientImage( gradients, itkVectorImagePointer );
+            filter->SetBValue( b_value );
             filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_STANDARD);
             filter->Update();
             mitk::QBallImage::Pointer testImage = mitk::QBallImage::New();
             testImage->InitializeByItk( filter->GetOutput() );
             testImage->SetVolume( filter->GetOutput()->GetBufferPointer() );
             MITK_TEST_CONDITION_REQUIRED(mitk::Equal(*testImage, *qballImage, 0.0001, true), "Numerical Q-ball reconstruction test.");
         }
 
         {
             MITK_INFO << "Standard Q-ball reconstruction " << argv[4];
             mitk::QBallImage::Pointer qballImage = dynamic_cast<mitk::QBallImage*>(mitk::IOUtil::LoadDataNode(argv[4])->GetData());
             typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,4,QBALL_ODFSIZE> FilterType;
             FilterType::Pointer filter = FilterType::New();
-            filter->SetGradientImage( dwi->GetDirections(), dwi->GetVectorImage() );
-            filter->SetBValue(dwi->GetReferenceBValue());
+            filter->SetGradientImage( gradients, itkVectorImagePointer );
+            filter->SetBValue( b_value );
             filter->SetLambda(0.006);
             filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
             filter->Update();
             mitk::QBallImage::Pointer testImage = mitk::QBallImage::New();
             testImage->InitializeByItk( filter->GetOutput() );
             testImage->SetVolume( filter->GetOutput()->GetBufferPointer() );
             MITK_TEST_CONDITION_REQUIRED(mitk::Equal(*testImage, *qballImage, 0.0001, true), "Standard Q-ball reconstruction test.");
         }
 
         {
             MITK_INFO << "CSA Q-ball reconstruction " << argv[5];
             mitk::QBallImage::Pointer qballImage = dynamic_cast<mitk::QBallImage*>(mitk::IOUtil::LoadDataNode(argv[5])->GetData());
             typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,4,QBALL_ODFSIZE> FilterType;
             FilterType::Pointer filter = FilterType::New();
-            filter->SetGradientImage( dwi->GetDirections(), dwi->GetVectorImage() );
-            filter->SetBValue(dwi->GetReferenceBValue());
+            filter->SetGradientImage( gradients, itkVectorImagePointer );
+            filter->SetBValue( b_value );
             filter->SetLambda(0.006);
             filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
             filter->Update();
             mitk::QBallImage::Pointer testImage = mitk::QBallImage::New();
             testImage->InitializeByItk( filter->GetOutput() );
             testImage->SetVolume( filter->GetOutput()->GetBufferPointer() );
             MITK_TEST_CONDITION_REQUIRED(mitk::Equal(*testImage, *qballImage, 0.0001, true), "CSA Q-ball reconstruction test.");
         }
 
         {
             MITK_INFO << "ADC profile reconstruction " << argv[6];
             mitk::QBallImage::Pointer qballImage = dynamic_cast<mitk::QBallImage*>(mitk::IOUtil::LoadDataNode(argv[6])->GetData());
             typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,4,QBALL_ODFSIZE> FilterType;
             FilterType::Pointer filter = FilterType::New();
-            filter->SetGradientImage( dwi->GetDirections(), dwi->GetVectorImage() );
-            filter->SetBValue(dwi->GetReferenceBValue());
+            filter->SetGradientImage( gradients, itkVectorImagePointer );
+            filter->SetBValue( b_value );
             filter->SetLambda(0.006);
             filter->SetNormalizationMethod(FilterType::QBAR_ADC_ONLY);
             filter->Update();
             mitk::QBallImage::Pointer testImage = mitk::QBallImage::New();
             testImage->InitializeByItk( filter->GetOutput() );
             testImage->SetVolume( filter->GetOutput()->GetBufferPointer() );
             MITK_TEST_CONDITION_REQUIRED(mitk::Equal(*testImage, *qballImage, 0.0001, true), "ADC profile reconstruction test.");
         }
 
         {
             MITK_INFO << "Raw signal modeling " << argv[7];
             mitk::QBallImage::Pointer qballImage = dynamic_cast<mitk::QBallImage*>(mitk::IOUtil::LoadDataNode(argv[7])->GetData());
             typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,4,QBALL_ODFSIZE> FilterType;
             FilterType::Pointer filter = FilterType::New();
-            filter->SetGradientImage( dwi->GetDirections(), dwi->GetVectorImage() );
-            filter->SetBValue(dwi->GetReferenceBValue());
+            filter->SetGradientImage( gradients, itkVectorImagePointer );
+            filter->SetBValue( b_value );
             filter->SetLambda(0.006);
             filter->SetNormalizationMethod(FilterType::QBAR_RAW_SIGNAL);
             filter->Update();
             mitk::QBallImage::Pointer testImage = mitk::QBallImage::New();
             testImage->InitializeByItk( filter->GetOutput() );
             testImage->SetVolume( filter->GetOutput()->GetBufferPointer() );
             MITK_TEST_CONDITION_REQUIRED(mitk::Equal(*testImage, *qballImage, 0.0001, true), "Raw signal modeling test.");
         }
     }
     catch (itk::ExceptionObject e)
     {
         MITK_INFO << e;
         return EXIT_FAILURE;
     }
     catch (std::exception e)
     {
         MITK_INFO << e.what();
         return EXIT_FAILURE;
     }
     catch (...)
     {
         MITK_INFO << "ERROR!?!";
         return EXIT_FAILURE;
     }
 
     MITK_TEST_END();
 }
diff --git a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkNonLocalMeansDenoisingTest.cpp b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkNonLocalMeansDenoisingTest.cpp
index 680b5c6295..62a7941cb4 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkNonLocalMeansDenoisingTest.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkNonLocalMeansDenoisingTest.cpp
@@ -1,176 +1,169 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
-#include "mitkDiffusionImage.h"
 #include "mitkIOUtil.h"
 #include "mitkTestingMacros.h"
 #include "mitkTestFixture.h"
 #include "itkNonLocalMeansDenoisingFilter.h"
+#include "mitkGradientDirectionsProperty.h"
+#include "mitkITKImageImport.h"
+#include <mitkImageCast.h>
 
 class mitkNonLocalMeansDenoisingTestSuite : public mitk::TestFixture
 {
 
   CPPUNIT_TEST_SUITE(mitkNonLocalMeansDenoisingTestSuite);
   MITK_TEST(Denoise_NLMg_shouldReturnTrue);
   MITK_TEST(Denoise_NLMr_shouldReturnTrue);
   MITK_TEST(Denoise_NLMv_shouldReturnTrue);
   MITK_TEST(Denoise_NLMvr_shouldReturnTrue);
   CPPUNIT_TEST_SUITE_END();
 
 private:
 
+  typedef itk::VectorImage<short,3> VectorImagetType;
+
   /** Members used inside the different (sub-)tests. All members are initialized via setUp().*/
-  mitk::DiffusionImage<short>::Pointer m_Image;
-  mitk::DiffusionImage<short>::Pointer m_ReferenceImage;
-  mitk::DiffusionImage<short>::Pointer m_DenoisedImage;
+  mitk::Image::Pointer m_Image;
+  mitk::Image::Pointer m_ReferenceImage;
+  mitk::Image::Pointer m_DenoisedImage;
   itk::Image<short, 3>::Pointer m_ImageMask;
   itk::NonLocalMeansDenoisingFilter<short>::Pointer m_DenoisingFilter;
 
 public:
 
   /**
 * @brief Setup Always call this method before each Test-case to ensure correct and new intialization of the used members for a new test case. (If the members are not used in a test, the method does not need to be called).
 */
   void setUp()
   {
     //generate test images
     std::string imagePath = GetTestDataFilePath("DiffusionImaging/Denoising/test_multi.dwi");
-//    std::string maskPath = GetTestDataFilePath("DiffusionImaging/Denoising/denoising_mask.nrrd");
 
-    m_Image = static_cast<mitk::DiffusionImage<short>*>( mitk::IOUtil::LoadImage(imagePath).GetPointer());
-//    mitk::Image::Pointer imageMask = static_cast<mitk::Image*>( mitk::IOUtil::LoadImage(maskPath).GetPointer());
-//    mitk::CastToItkImage(imageMask, m_ImageMask);
+    m_Image =  mitk::IOUtil::LoadImage(imagePath);
     m_ReferenceImage = NULL;
-    m_DenoisedImage = mitk::DiffusionImage<short>::New();
+    m_DenoisedImage = mitk::Image::New();
 
     //initialise Filter
     m_DenoisingFilter = itk::NonLocalMeansDenoisingFilter<short>::New();
-    m_DenoisingFilter->SetInputImage(m_Image->GetVectorImage());
-//    m_DenoisingFilter->SetInputMask(m_ImageMask);
+    VectorImagetType::Pointer vectorImage;
+    mitk::CastToItkImage(m_Image,vectorImage);
+    m_DenoisingFilter->SetInputImage(vectorImage);
     m_DenoisingFilter->SetNumberOfThreads(1);
     m_DenoisingFilter->SetComparisonRadius(1);
     m_DenoisingFilter->SetSearchRadius(1);
     m_DenoisingFilter->SetVariance(500);
   }
 
   void tearDown()
   {
     m_Image = NULL;
     m_ImageMask = NULL;
     m_ReferenceImage = NULL;
     m_DenoisingFilter = NULL;
     m_DenoisedImage = NULL;
   }
 
   void Denoise_NLMg_shouldReturnTrue()
   {
     std::string referenceImagePath = GetTestDataFilePath("DiffusionImaging/Denoising/test_multi_NLMg.dwi");
-    m_ReferenceImage = static_cast<mitk::DiffusionImage<short>*>( mitk::IOUtil::LoadImage(referenceImagePath).GetPointer());
+    m_ReferenceImage =  mitk::IOUtil::LoadImage(referenceImagePath);
 
     m_DenoisingFilter->SetUseRicianAdaption(false);
     m_DenoisingFilter->SetUseJointInformation(false);
     try
     {
       m_DenoisingFilter->Update();
     }
     catch(std::exception& e)
     {
       MITK_ERROR << e.what();
     }
 
-    m_DenoisedImage->SetVectorImage(m_DenoisingFilter->GetOutput());
-    m_DenoisedImage->SetReferenceBValue(m_Image->GetReferenceBValue());
-    m_DenoisedImage->SetDirections(m_Image->GetDirections());
-    m_DenoisedImage->InitializeFromVectorImage();
+    mitk::GrabItkImageMemory(m_DenoisingFilter->GetOutput(),m_DenoisedImage);
+    m_DenoisedImage->SetPropertyList(m_Image->GetPropertyList()->Clone());
 
     MITK_ASSERT_EQUAL( m_DenoisedImage, m_ReferenceImage, "NLMg should always return the same result.");
   }
 
   void Denoise_NLMr_shouldReturnTrue()
   {
     std::string referenceImagePath = GetTestDataFilePath("DiffusionImaging/Denoising/test_multi_NLMr.dwi");
-    m_ReferenceImage = static_cast<mitk::DiffusionImage<short>*>( mitk::IOUtil::LoadImage(referenceImagePath).GetPointer());
+    m_ReferenceImage = mitk::IOUtil::LoadImage(referenceImagePath);
 
     m_DenoisingFilter->SetUseRicianAdaption(true);
     m_DenoisingFilter->SetUseJointInformation(false);
     try
     {
       m_DenoisingFilter->Update();
     }
     catch(std::exception& e)
     {
       MITK_ERROR << e.what();
     }
 
-    m_DenoisedImage->SetVectorImage(m_DenoisingFilter->GetOutput());
-    m_DenoisedImage->SetReferenceBValue(m_Image->GetReferenceBValue());
-    m_DenoisedImage->SetDirections(m_Image->GetDirections());
-    m_DenoisedImage->InitializeFromVectorImage();
+    mitk::GrabItkImageMemory(m_DenoisingFilter->GetOutput(),m_DenoisedImage);
+    m_DenoisedImage->SetPropertyList(m_Image->GetPropertyList()->Clone());
 
     MITK_ASSERT_EQUAL( m_DenoisedImage, m_ReferenceImage, "NLMr should always return the same result.");
   }
 
   void Denoise_NLMv_shouldReturnTrue()
   {
     std::string referenceImagePath = GetTestDataFilePath("DiffusionImaging/Denoising/test_multi_NLMv.dwi");
-    m_ReferenceImage = static_cast<mitk::DiffusionImage<short>*>( mitk::IOUtil::LoadImage(referenceImagePath).GetPointer());
-
+    m_ReferenceImage = mitk::IOUtil::LoadImage(referenceImagePath);
     m_DenoisingFilter->SetUseRicianAdaption(false);
     m_DenoisingFilter->SetUseJointInformation(true);
     try
     {
       m_DenoisingFilter->Update();
     }
     catch(std::exception& e)
     {
       MITK_ERROR << e.what();
     }
 
-    m_DenoisedImage->SetVectorImage(m_DenoisingFilter->GetOutput());
-    m_DenoisedImage->SetReferenceBValue(m_Image->GetReferenceBValue());
-    m_DenoisedImage->SetDirections(m_Image->GetDirections());
-    m_DenoisedImage->InitializeFromVectorImage();
+    mitk::GrabItkImageMemory(m_DenoisingFilter->GetOutput(),m_DenoisedImage);
+    m_DenoisedImage->SetPropertyList(m_Image->GetPropertyList()->Clone());
 
     MITK_ASSERT_EQUAL( m_DenoisedImage, m_ReferenceImage, "NLMv should always return the same result.");
   }
 
   void Denoise_NLMvr_shouldReturnTrue()
   {
     std::string referenceImagePath = GetTestDataFilePath("DiffusionImaging/Denoising/test_multi_NLMvr.dwi");
-    m_ReferenceImage = static_cast<mitk::DiffusionImage<short>*>( mitk::IOUtil::LoadImage(referenceImagePath).GetPointer());
+    m_ReferenceImage = mitk::IOUtil::LoadImage(referenceImagePath);
 
     m_DenoisingFilter->SetUseRicianAdaption(true);
     m_DenoisingFilter->SetUseJointInformation(true);
     try
     {
       m_DenoisingFilter->Update();
     }
     catch(std::exception& e)
     {
       MITK_ERROR << e.what();
     }
 
-    m_DenoisedImage->SetVectorImage(m_DenoisingFilter->GetOutput());
-    m_DenoisedImage->SetReferenceBValue(m_Image->GetReferenceBValue());
-    m_DenoisedImage->SetDirections(m_Image->GetDirections());
-    m_DenoisedImage->InitializeFromVectorImage();
+    mitk::GrabItkImageMemory(m_DenoisingFilter->GetOutput(),m_DenoisedImage);
+    m_DenoisedImage->SetPropertyList(m_Image->GetPropertyList()->Clone());
 
     MITK_ASSERT_EQUAL( m_DenoisedImage, m_ReferenceImage, "NLMvr should always return the same result.");
   }
 
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkNonLocalMeansDenoising)
diff --git a/Modules/DiffusionImaging/DiffusionCore/files.cmake b/Modules/DiffusionImaging/DiffusionCore/files.cmake
index f9995fbe3d..dae157948b 100644
--- a/Modules/DiffusionImaging/DiffusionCore/files.cmake
+++ b/Modules/DiffusionImaging/DiffusionCore/files.cmake
@@ -1,138 +1,149 @@
 set(CPP_FILES
 
   # DicomImport
   DicomImport/mitkDicomDiffusionImageReader.cpp
   # DicomImport/mitkGroupDiffusionHeadersFilter.cpp
   DicomImport/mitkDicomDiffusionImageHeaderReader.cpp
   DicomImport/mitkGEDicomDiffusionImageHeaderReader.cpp
   DicomImport/mitkPhilipsDicomDiffusionImageHeaderReader.cpp
   DicomImport/mitkSiemensDicomDiffusionImageHeaderReader.cpp
   DicomImport/mitkSiemensMosaicDicomDiffusionImageHeaderReader.cpp
 
   DicomImport/mitkDiffusionDICOMFileReader.cpp
   DicomImport/mitkDiffusionHeaderDICOMFileReader.cpp
   DicomImport/mitkDiffusionHeaderSiemensDICOMFileReader.cpp
   DicomImport/mitkDiffusionHeaderSiemensDICOMFileHelper.cpp
   DicomImport/mitkDiffusionHeaderSiemensMosaicDICOMFileReader.cpp
   DicomImport/mitkDiffusionHeaderGEDICOMFileReader.cpp
   DicomImport/mitkDiffusionHeaderPhilipsDICOMFileReader.cpp
 
 
   # DataStructures -> DWI
   IODataStructures/DiffusionWeightedImages/mitkDiffusionImageHeaderInformation.cpp
-  IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSource.cpp
-
-  IODataStructures/DiffusionWeightedImages/mitkImageToDiffusionImageSource.cpp
   IODataStructures/DiffusionWeightedImages/mitkDiffusionImageCorrectionFilter.cpp
 
+  # Properties
+  IODataStructures/Properties/mitkBValueMapProperty.cpp
+  IODataStructures/Properties/mitkGradientDirectionsProperty.cpp
+  IODataStructures/Properties/mitkMeasurementFrameProperty.cpp
+  IODataStructures/Properties/mitkDiffusionPropertyHelper.cpp
+  IODataStructures/Properties/mitkNodePredicateIsDWI.cpp
+
+  # Serializer
+  IODataStructures/Properties/mitkBValueMapPropertySerializer.cpp
+  IODataStructures/Properties/mitkGradientDirectionsPropertySerializer.cpp
+  IODataStructures/Properties/mitkMeasurementFramePropertySerializer.cpp
+
   # DataStructures -> QBall
   IODataStructures/QBallImages/mitkQBallImageSource.cpp
   IODataStructures/QBallImages/mitkQBallImage.cpp
 
   # DataStructures -> Tensor
   IODataStructures/TensorImages/mitkTensorImage.cpp
 
   Rendering/vtkMaskedProgrammableGlyphFilter.cpp
   Rendering/mitkVectorImageVtkGlyphMapper3D.cpp
   Rendering/vtkOdfSource.cxx
   Rendering/vtkThickPlane.cxx
   Rendering/mitkOdfNormalizationMethodProperty.cpp
   Rendering/mitkOdfScaleByProperty.cpp
 
   # Algorithms
   Algorithms/mitkPartialVolumeAnalysisHistogramCalculator.cpp
   Algorithms/mitkPartialVolumeAnalysisClusteringCalculator.cpp
   Algorithms/itkDwiGradientLengthCorrectionFilter.cpp
   Algorithms/itkElectrostaticRepulsionDiffusionGradientReductionFilter.h
 
   # Registration Algorithms & Co.
   Algorithms/Registration/mitkRegistrationWrapper.cpp
   Algorithms/Registration/mitkPyramidImageRegistrationMethod.cpp
   # Algorithms/Registration/mitkRegistrationMethodITK4.cpp
+  Algorithms/Registration/mitkDWIHeadMotionCorrectionFilter.cpp
 
 
   # MultishellProcessing
   Algorithms/Reconstruction/MultishellProcessing/itkADCAverageFunctor.cpp
   Algorithms/Reconstruction/MultishellProcessing/itkADCFitFunctor.cpp
   Algorithms/Reconstruction/MultishellProcessing/itkKurtosisFitFunctor.cpp
   Algorithms/Reconstruction/MultishellProcessing/itkBiExpFitFunctor.cpp
 
   # Function Collection
   mitkDiffusionFunctionCollection.cpp
 )
 
 set(H_FILES
   # function Collection
   mitkDiffusionFunctionCollection.h
 
   # Rendering
-  Rendering/mitkDiffusionImageMapper.h
   Rendering/mitkOdfVtkMapper2D.h
 
   # Reconstruction
   Algorithms/Reconstruction/itkDiffusionQballReconstructionImageFilter.h
   Algorithms/Reconstruction/mitkTeemDiffusionTensor3DReconstructionImageFilter.h
   Algorithms/Reconstruction/itkAnalyticalDiffusionQballReconstructionImageFilter.h
   Algorithms/Reconstruction/itkDiffusionMultiShellQballReconstructionImageFilter.h
   Algorithms/Reconstruction/itkPointShell.h
   Algorithms/Reconstruction/itkOrientationDistributionFunction.h
   Algorithms/Reconstruction/itkDiffusionIntravoxelIncoherentMotionReconstructionImageFilter.h
 
   # MultishellProcessing
   Algorithms/Reconstruction/MultishellProcessing/itkRadialMultishellToSingleshellImageFilter.h
   Algorithms/Reconstruction/MultishellProcessing/itkDWIVoxelFunctor.h
   Algorithms/Reconstruction/MultishellProcessing/itkADCAverageFunctor.h
   Algorithms/Reconstruction/MultishellProcessing/itkKurtosisFitFunctor.h
   Algorithms/Reconstruction/MultishellProcessing/itkBiExpFitFunctor.h
   Algorithms/Reconstruction/MultishellProcessing/itkADCFitFunctor.h
 
-  # IO Datastructures
-  IODataStructures/DiffusionWeightedImages/mitkDiffusionImage.h
+  # Properties
+  IODataStructures/Properties/mitkBValueMapProperty.h
+  IODataStructures/Properties/mitkGradientDirectionsProperty.h
+  IODataStructures/Properties/mitkMeasurementFrameProperty.h
+  IODataStructures/Properties/mitkDiffusionPropertyHelper.h
 
   # Algorithms
   Algorithms/itkDiffusionQballGeneralizedFaImageFilter.h
   Algorithms/itkDiffusionQballPrepareVisualizationImageFilter.h
   Algorithms/itkTensorDerivedMeasurementsFilter.h
   Algorithms/itkBrainMaskExtractionImageFilter.h
   Algorithms/itkB0ImageExtractionImageFilter.h
   Algorithms/itkB0ImageExtractionToSeparateImageFilter.h
   Algorithms/itkTensorImageToDiffusionImageFilter.h
   Algorithms/itkTensorToL2NormImageFilter.h
   Algorithms/itkGaussianInterpolateImageFunction.h
   Algorithms/mitkPartialVolumeAnalysisHistogramCalculator.h
   Algorithms/mitkPartialVolumeAnalysisClusteringCalculator.h
   Algorithms/itkDiffusionTensorPrincipalDirectionImageFilter.h
   Algorithms/itkCartesianToPolarVectorImageFilter.h
   Algorithms/itkPolarToCartesianVectorImageFilter.h
   Algorithms/itkDistanceMapFilter.h
   Algorithms/itkProjectionFilter.h
   Algorithms/itkResidualImageFilter.h
   Algorithms/itkExtractChannelFromRgbaImageFilter.h
   Algorithms/itkTensorReconstructionWithEigenvalueCorrectionFilter.h
   Algorithms/itkMergeDiffusionImagesFilter.h
   Algorithms/itkDwiPhantomGenerationFilter.h
   Algorithms/itkFiniteDiffOdfMaximaExtractionFilter.h
   Algorithms/itkMrtrixPeakImageConverter.h
   Algorithms/itkFslPeakImageConverter.h
   Algorithms/itkShCoefficientImageImporter.h
   Algorithms/itkShCoefficientImageExporter.h
   Algorithms/itkOdfMaximaExtractionFilter.h
   Algorithms/itkResampleDwiImageFilter.h
   Algorithms/itkDwiGradientLengthCorrectionFilter.h
   Algorithms/itkAdcImageFilter.h
   Algorithms/itkDwiNormilzationFilter.h
   Algorithms/itkSplitDWImageFilter.h
   Algorithms/itkRemoveDwiChannelFilter.h
   Algorithms/itkExtractDwiChannelFilter.h
 
   Algorithms/Registration/mitkDWIHeadMotionCorrectionFilter.h
-  Algorithms/mitkDiffusionImageToDiffusionImageFilter.h
   Algorithms/itkNonLocalMeansDenoisingFilter.h
   Algorithms/itkVectorImageToImageFilter.h
 
 
 )
 
 set( TOOL_FILES
 )
 
diff --git a/Modules/DiffusionImaging/DiffusionIO/CMakeLists.txt b/Modules/DiffusionImaging/DiffusionIO/CMakeLists.txt
index 134852a470..fd6007c431 100644
--- a/Modules/DiffusionImaging/DiffusionIO/CMakeLists.txt
+++ b/Modules/DiffusionImaging/DiffusionIO/CMakeLists.txt
@@ -1,7 +1,8 @@
 MITK_CREATE_MODULE(
   SUBPROJECTS MITK-DTI
+  INCLUDE_DIRS ${CMAKE_CURRENT_BINARY_DIR}
   DEPENDS MitkConnectomics MitkQuantification MitkFiberTracking
   AUTOLOAD_WITH MitkCore
   WARNINGS_AS_ERRORS
 )
 
diff --git a/Modules/DiffusionImaging/DiffusionIO/files.cmake b/Modules/DiffusionImaging/DiffusionIO/files.cmake
index 8d8f04bd0d..5686192842 100644
--- a/Modules/DiffusionImaging/DiffusionIO/files.cmake
+++ b/Modules/DiffusionImaging/DiffusionIO/files.cmake
@@ -1,39 +1,39 @@
 set(CPP_FILES
   mitkDiffusionModuleActivator.cpp
   mitkNrrdTbssImageWriterFactory.cpp
   #mitkFiberBundleXIOFactory.cpp
   mitkConnectomicsNetworkReader.cpp
   mitkConnectomicsNetworkWriter.cpp
   mitkConnectomicsNetworkSerializer.cpp
   mitkConnectomicsNetworkDefinitions.cpp
   mitkNrrdTbssRoiImageIOFactory.cpp
   #mitkFiberBundleXWriterFactory.cpp
   mitkNrrdTbssRoiImageWriterFactory.cpp
   mitkNrrdTensorImageReader.cpp
   mitkNrrdTensorImageWriter.cpp
   mitkTensorImageSerializer.cpp
   mitkTensorImageSource.cpp
   mitkFiberTrackingObjectFactory.cpp
   mitkConnectomicsObjectFactory.cpp
   mitkQuantificationObjectFactory.cpp
   mitkNrrdTbssImageIOFactory.cpp
   mitkDiffusionCoreObjectFactory.cpp
 
   mitkDiffusionIOMimeTypes.cpp
 
   mitkNrrdDiffusionImageReader.cpp
   mitkNrrdDiffusionImageWriter.cpp
-  mitkDiffusionImageSerializer.cpp
 
   mitkNrrdQBallImageReader.cpp
   mitkNrrdQBallImageWriter.cpp
   mitkQBallImageSerializer.cpp
 
   mitkFiberBundleXReader.cpp
   mitkFiberBundleXWriter.cpp
   mitkFiberBundleXSerializer.cpp
   mitkFiberBundleXMapper2D.cpp
   mitkFiberBundleXMapper3D.cpp
   mitkCompositeMapper.cpp
+
 )
 
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionCoreObjectFactory.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionCoreObjectFactory.cpp
index 6a33ecfd0e..9282a2e9d3 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionCoreObjectFactory.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionCoreObjectFactory.cpp
@@ -1,181 +1,159 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include "mitkDiffusionCoreObjectFactory.h"
 
 #include "mitkProperties.h"
 #include "mitkBaseRenderer.h"
 #include "mitkDataNode.h"
 
 #include "mitkNrrdDiffusionImageWriter.h"
-#include "mitkDiffusionImage.h"
 
 #include "mitkCompositeMapper.h"
-#include "mitkDiffusionImageMapper.h"
 #include "mitkGPUVolumeMapper3D.h"
 #include "mitkVolumeDataVtkMapper3D.h"
 
 
 typedef short DiffusionPixelType;
 
-typedef mitk::DiffusionImage<DiffusionPixelType> DiffusionImageShort;
 typedef std::multimap<std::string, std::string> MultimapType;
 
 mitk::DiffusionCoreObjectFactory::DiffusionCoreObjectFactory()
   : CoreObjectFactoryBase()
 {
 
   static bool alreadyDone = false;
   if (!alreadyDone)
   {
     MITK_DEBUG << "DiffusionCoreObjectFactory c'tor" << std::endl;
 
     CreateFileExtensionsMap();
 
     alreadyDone = true;
   }
 
 }
 
 mitk::DiffusionCoreObjectFactory::~DiffusionCoreObjectFactory()
 {
 
 }
 
 mitk::Mapper::Pointer mitk::DiffusionCoreObjectFactory::CreateMapper(mitk::DataNode* node, MapperSlotId id)
 {
   mitk::Mapper::Pointer newMapper=NULL;
 
   if ( id == mitk::BaseRenderer::Standard2D )
   {
     std::string classname("QBallImage");
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::CompositeMapper::New();
       newMapper->SetDataNode(node);
       node->SetMapper(3, ((CompositeMapper*)newMapper.GetPointer())->GetImageMapper());
     }
     classname = "TensorImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::CompositeMapper::New();
       newMapper->SetDataNode(node);
       node->SetMapper(3, ((CompositeMapper*)newMapper.GetPointer())->GetImageMapper());
     }
 
-    classname = "DiffusionImage";
-    if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
-    {
-      newMapper = mitk::DiffusionImageMapper<short>::New();
-      newMapper->SetDataNode(node);
-    }
-
   }
   else if ( id == mitk::BaseRenderer::Standard3D )
   {
     std::string classname("QBallImage");
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::GPUVolumeMapper3D::New();
       newMapper->SetDataNode(node);
     }
     classname = "TensorImage";
     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
     {
       newMapper = mitk::GPUVolumeMapper3D::New();
       newMapper->SetDataNode(node);
     }
-    classname = "DiffusionImage";
-    if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
-    {
-      newMapper = mitk::GPUVolumeMapper3D::New();
-      newMapper->SetDataNode(node);
-    }
   }
 
   return newMapper;
 }
 
 void mitk::DiffusionCoreObjectFactory::SetDefaultProperties(mitk::DataNode* node)
 {
   std::string classname = "QBallImage";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::CompositeMapper::SetDefaultProperties(node);
     mitk::GPUVolumeMapper3D::SetDefaultProperties(node);
   }
 
   classname = "TensorImage";
   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
   {
     mitk::CompositeMapper::SetDefaultProperties(node);
     mitk::GPUVolumeMapper3D::SetDefaultProperties(node);
   }
 
-  classname = "DiffusionImage";
-  if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
-  {
-    mitk::DiffusionImageMapper<short>::SetDefaultProperties(node);
-    mitk::GPUVolumeMapper3D::SetDefaultProperties(node);
-  }
 }
 
 const char* mitk::DiffusionCoreObjectFactory::GetFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions(m_FileExtensionsMap, fileExtension);
   return fileExtension.c_str();
 }
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::DiffusionCoreObjectFactory::GetFileExtensionsMap()
 {
   return m_FileExtensionsMap;
 }
 
 const char* mitk::DiffusionCoreObjectFactory::GetSaveFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions(m_SaveFileExtensionsMap, fileExtension);
   return fileExtension.c_str();
 }
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::DiffusionCoreObjectFactory::GetSaveFileExtensionsMap()
 {
   return m_SaveFileExtensionsMap;
 }
 
 void mitk::DiffusionCoreObjectFactory::CreateFileExtensionsMap()
 {
 
 }
 
 struct RegisterDiffusionCoreObjectFactory{
   RegisterDiffusionCoreObjectFactory()
     : m_Factory( mitk::DiffusionCoreObjectFactory::New() )
   {
     mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory( m_Factory );
   }
 
   ~RegisterDiffusionCoreObjectFactory()
   {
     mitk::CoreObjectFactory::GetInstance()->UnRegisterExtraFactory( m_Factory );
   }
 
   mitk::DiffusionCoreObjectFactory::Pointer m_Factory;
 };
 
 static RegisterDiffusionCoreObjectFactory registerDiffusionCoreObjectFactory;
 
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.cpp
index bb2494355f..3969ba1da0 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.cpp
@@ -1,161 +1,225 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include "mitkDiffusionIOMimeTypes.h"
 #include "mitkIOMimeTypes.h"
+#include <itksys/SystemTools.hxx>
+#include <itkNrrdImageIO.h>
+#include <itkMetaDataDictionary.h>
+#include <itkMetaDataObject.h>
 
 namespace mitk
 {
 
 std::vector<CustomMimeType*> DiffusionIOMimeTypes::Get()
 {
   std::vector<CustomMimeType*> mimeTypes;
 
   // order matters here (descending rank for mime types)
 
   mimeTypes.push_back(DWI_MIMETYPE().Clone());
   mimeTypes.push_back(DTI_MIMETYPE().Clone());
   mimeTypes.push_back(QBI_MIMETYPE().Clone());
 
   mimeTypes.push_back(FIBERBUNDLE_MIMETYPE().Clone());
 
   mimeTypes.push_back(CONNECTOMICS_MIMETYPE().Clone());
 
   return mimeTypes;
 }
 
 // Mime Types
 
 CustomMimeType DiffusionIOMimeTypes::FIBERBUNDLE_MIMETYPE()
 {
   CustomMimeType mimeType(FIBERBUNDLE_MIMETYPE_NAME());
   std::string category = "Fiber Bundle File";
   mimeType.SetComment("Fiber Bundles");
   mimeType.SetCategory(category);
   mimeType.AddExtension("fib");
   mimeType.AddExtension("trk");
   //mimeType.AddExtension("vtk");
   return mimeType;
 }
 
-CustomMimeType DiffusionIOMimeTypes::DWI_MIMETYPE()
+DiffusionIOMimeTypes::DwiMimeType::DwiMimeType()
+  : CustomMimeType(DWI_MIMETYPE_NAME())
 {
-  CustomMimeType mimeType(DWI_MIMETYPE_NAME());
   std::string category = "Diffusion Weighted Image";
-  mimeType.SetComment("Diffusion Weighted Images");
-  mimeType.SetCategory(category);
-  mimeType.AddExtension("dwi");
-  mimeType.AddExtension("hdwi");
-  mimeType.AddExtension("fsl");
-  mimeType.AddExtension("fslgz");
-  return mimeType;
+  this->SetCategory(category);
+  this->SetComment("Diffusion Weighted Images");
+
+  this->AddExtension("dwi");
+  this->AddExtension("hdwi");
+  this->AddExtension("fsl");
+  this->AddExtension("fslgz");
+  this->AddExtension("nrrd");
+}
+
+bool DiffusionIOMimeTypes::DwiMimeType::AppliesTo(const std::string &path) const
+{
+  bool canRead( CustomMimeType::AppliesTo(path) );
+
+  // fix for bug 18572
+  // Currently this function is called for writing as well as reading, in that case
+  // the image information can of course not be read
+  // This is a bug, this function should only be called for reading.
+  if( ! itksys::SystemTools::FileExists( path.c_str() ) )
+  {
+    return canRead;
+  }
+  //end fix for bug 18572
+
+  std::string ext = itksys::SystemTools::GetFilenameLastExtension( path );
+  ext = itksys::SystemTools::LowerCase( ext );
+
+  // Simple NRRD files should only be considered for this mime type if they contain
+  // corresponding tags
+  if( ext == ".nrrd" )
+  {
+    itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
+    io->SetFileName(path);
+    io->ReadImageInformation();
+
+    itk::MetaDataDictionary imgMetaDictionary = io->GetMetaDataDictionary();
+    std::vector<std::string> imgMetaKeys = imgMetaDictionary.GetKeys();
+    std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin();
+    std::string metaString;
+
+    for (; itKey != imgMetaKeys.end(); itKey ++)
+    {
+      itk::ExposeMetaData<std::string> (imgMetaDictionary, *itKey, metaString);
+      if (itKey->find("modality") != std::string::npos)
+      {
+        if (metaString.find("DWMRI") != std::string::npos)
+        {
+          return canRead;
+        }
+      }
+    }
+
+    canRead = false;
+  }
+
+  return canRead;
+}
+
+DiffusionIOMimeTypes::DwiMimeType* DiffusionIOMimeTypes::DwiMimeType::Clone() const
+{
+  return new DwiMimeType(*this);
+}
+
+
+DiffusionIOMimeTypes::DwiMimeType DiffusionIOMimeTypes::DWI_MIMETYPE()
+{
+  return DwiMimeType();
 }
 
 CustomMimeType DiffusionIOMimeTypes::DTI_MIMETYPE()
 {
   CustomMimeType mimeType(DTI_MIMETYPE_NAME());
   std::string category = "Tensor Images";
   mimeType.SetComment("Diffusion Tensor Images");
   mimeType.SetCategory(category);
   mimeType.AddExtension("dti");
   mimeType.AddExtension("hdti");
   return mimeType;
 }
 
 CustomMimeType DiffusionIOMimeTypes::QBI_MIMETYPE()
 {
   CustomMimeType mimeType(QBI_MIMETYPE_NAME());
   std::string category = "Q-Ball Images";
   mimeType.SetComment("Diffusion Q-Ball Images");
   mimeType.SetCategory(category);
   mimeType.AddExtension("qbi");
   mimeType.AddExtension("hqbi");
   return mimeType;
 }
 
 CustomMimeType DiffusionIOMimeTypes::CONNECTOMICS_MIMETYPE()
 {
   CustomMimeType mimeType(CONNECTOMICS_MIMETYPE_NAME());
   std::string category = "Connectomics Networks";
   mimeType.SetComment("Connectomics Networks");
   mimeType.SetCategory(category);
   mimeType.AddExtension("cnf");
   return mimeType;
 }
 
 // Names
 std::string DiffusionIOMimeTypes::DWI_MIMETYPE_NAME()
 {
   static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".dwi";
   return name;
 }
 
 std::string DiffusionIOMimeTypes::DTI_MIMETYPE_NAME()
 {
   static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".dti";
   return name;
 }
 
 std::string DiffusionIOMimeTypes::QBI_MIMETYPE_NAME()
 {
   static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".qbi";
   return name;
 }
 
 std::string DiffusionIOMimeTypes::FIBERBUNDLE_MIMETYPE_NAME()
 {
   static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".fib";
   return name;
 }
 
 std::string DiffusionIOMimeTypes::CONNECTOMICS_MIMETYPE_NAME()
 {
   static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".cnf";
   return name;
 }
 
 // Descriptions
 std::string DiffusionIOMimeTypes::FIBERBUNDLE_MIMETYPE_DESCRIPTION()
 {
   static std::string description = "Fiberbundles";
   return description;
 }
 
 std::string DiffusionIOMimeTypes::DWI_MIMETYPE_DESCRIPTION()
 {
   static std::string description = "Diffusion Weighted Images";
   return description;
 }
 
 std::string DiffusionIOMimeTypes::DTI_MIMETYPE_DESCRIPTION()
 {
   static std::string description = "Diffusion Tensor Images";
   return description;
 }
 
 std::string DiffusionIOMimeTypes::QBI_MIMETYPE_DESCRIPTION()
 {
   static std::string description = "Q-Ball Images";
   return description;
 }
 
 std::string DiffusionIOMimeTypes::CONNECTOMICS_MIMETYPE_DESCRIPTION()
 {
   static std::string description = "Connectomics Networks";
   return description;
 }
 
 }
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.h b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.h
index fa4b3c02fa..5caa50bd8c 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionIOMimeTypes.h
@@ -1,72 +1,81 @@
 /*===================================================================
 
 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 MITKDIFFUSIONIOMIMETYPES_H
 #define MITKDIFFUSIONIOMIMETYPES_H
 
 #include "mitkCustomMimeType.h"
+#include <MitkDiffusionIOExports.h>
 
 #include <string>
 
 namespace mitk {
 
 class DiffusionIOMimeTypes
 {
 public:
 
+  class MitkDiffusionIO_EXPORT DwiMimeType : public CustomMimeType
+  {
+  public:
+    DwiMimeType();
+    virtual bool AppliesTo(const std::string &path) const;
+    virtual DwiMimeType* Clone() const;
+  };
+
   // Get all Diffusion Mime Types
   static std::vector<CustomMimeType*> Get();
 
   // ------------------------------ VTK formats ----------------------------------
 
   static CustomMimeType FIBERBUNDLE_MIMETYPE(); // fib
 
   static std::string FIBERBUNDLE_MIMETYPE_NAME();
 
   static std::string FIBERBUNDLE_MIMETYPE_DESCRIPTION();
 
   // ------------------------- Image formats (ITK based) --------------------------
 
-  static CustomMimeType DWI_MIMETYPE(); // dwi, hdwi
+  static DwiMimeType DWI_MIMETYPE(); // dwi, hdwi
   static CustomMimeType DTI_MIMETYPE(); // dti, hdti
   static CustomMimeType QBI_MIMETYPE(); // qbi, hqbi
 
   static std::string DWI_MIMETYPE_NAME();
   static std::string DTI_MIMETYPE_NAME();
   static std::string QBI_MIMETYPE_NAME();
 
   static std::string DWI_MIMETYPE_DESCRIPTION();
   static std::string DTI_MIMETYPE_DESCRIPTION();
   static std::string QBI_MIMETYPE_DESCRIPTION();
 
   // ------------------------------ MITK formats ----------------------------------
 
   static CustomMimeType CONNECTOMICS_MIMETYPE(); // cnf
 
   static std::string CONNECTOMICS_MIMETYPE_NAME();
 
   static std::string CONNECTOMICS_MIMETYPE_DESCRIPTION();
 
 private:
 
   // purposely not implemented
   DiffusionIOMimeTypes();
   DiffusionIOMimeTypes(const DiffusionIOMimeTypes&);
 };
 
 }
 
 #endif // MITKDIFFUSIONIOMIMETYPES_H
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageSerializer.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageSerializer.cpp
deleted file mode 100644
index 5e67c079e7..0000000000
--- a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageSerializer.cpp
+++ /dev/null
@@ -1,74 +0,0 @@
-/*===================================================================
-
-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.
-
-===================================================================*/
-
-#include "mitkDiffusionImageSerializer.h"
-#include "mitkDiffusionImage.h"
-#include "mitkNrrdDiffusionImageWriter.h"
-
-#include <itksys/SystemTools.hxx>
-
-
-MITK_REGISTER_SERIALIZER(DiffusionImageSerializer)
-
-
-mitk::DiffusionImageSerializer::DiffusionImageSerializer()
-{
-}
-
-
-mitk::DiffusionImageSerializer::~DiffusionImageSerializer()
-{
-}
-
-
-std::string mitk::DiffusionImageSerializer::Serialize()
-{
-  const DiffusionImage<short>* image = dynamic_cast<const DiffusionImage<short>*>( m_Data.GetPointer() );
-  if (image == NULL)
-  {
-    MITK_ERROR << " Object at " << (const void*) this->m_Data
-              << " is not an mitk::DiffusionImage. Cannot serialize as DiffusionImage.";
-    return "";
-  }
-
-  std::string filename( this->GetUniqueFilenameInWorkingDirectory() );
-  filename += "_";
-  filename += m_FilenameHint;
-  filename += ".dwi";
-
-  std::string fullname(m_WorkingDirectory);
-  fullname += "/";
-  fullname += itksys::SystemTools::ConvertToOutputPath(filename.c_str());
-
-  try
-  {
-    NrrdDiffusionImageWriter writer;
-    writer.SetOutputLocation(fullname);
-    writer.SetInput(const_cast<DiffusionImage<short>*>(image));
-    writer.Write();
-  }
-  catch (std::exception& e)
-  {
-    MITK_ERROR << " Error serializing object at " << (const void*) this->m_Data
-              << " to "
-              << fullname
-              << ": "
-              << e.what();
-    return "";
-  }
-  return filename;
-}
-
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageSerializer.h b/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageSerializer.h
deleted file mode 100644
index d1b4a593d0..0000000000
--- a/Modules/DiffusionImaging/DiffusionIO/mitkDiffusionImageSerializer.h
+++ /dev/null
@@ -1,39 +0,0 @@
-/*===================================================================
-
-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 mitkDiffusionImageSerializer_h_included
-#define mitkDiffusionImageSerializer_h_included
-
-#include "mitkBaseDataSerializer.h"
-
-namespace mitk
-{
-/**
-  \brief Serializes mitk::Surface for mitk::SceneIO
-*/
-class DiffusionImageSerializer : public BaseDataSerializer
-{
-  public:
-    mitkClassMacro( DiffusionImageSerializer, BaseDataSerializer );
-    itkFactorylessNewMacro(Self)
-    itkCloneMacro(Self)
-    virtual std::string Serialize();
-  protected:
-    DiffusionImageSerializer();
-    virtual ~DiffusionImageSerializer();
-};
-} // namespace
-#endif
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageReader.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageReader.cpp
index fd381448fa..bd86415a15 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageReader.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageReader.cpp
@@ -1,420 +1,434 @@
 /*===================================================================
 
 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 __mitkNrrdDiffusionImageReader_cpp
 #define __mitkNrrdDiffusionImageReader_cpp
 
 #include "mitkNrrdDiffusionImageReader.h"
 
+#include <iostream>
+#include <fstream>
+
+
+// Diffusion properties
+#include <mitkGradientDirectionsProperty.h>
+#include <mitkBValueMapProperty.h>
+#include <mitkMeasurementFrameProperty.h>
+#include <mitkProperties.h>
+
+// ITK includes
+#include <itkImageRegionIterator.h>
+#include <itkMetaDataObject.h>
+#include "itksys/SystemTools.hxx"
 #include "itkImageFileReader.h"
 #include "itkMetaDataObject.h"
 #include "itkNrrdImageIO.h"
 #include "itkNiftiImageIO.h"
 
-#include <iostream>
-#include <fstream>
-
-#include "itksys/SystemTools.hxx"
 #include "mitkCustomMimeType.h"
 #include "mitkDiffusionIOMimeTypes.h"
 
-namespace mitk
-{
-
-NrrdDiffusionImageReader::
-NrrdDiffusionImageReader(const NrrdDiffusionImageReader & other)
-  : AbstractFileReader(other)
-{
-}
+#include <mitkITKImageImport.h>
+#include <mitkItkImageFileReader.h>
+#include <mitkImageWriteAccessor.h>
+#include <mitkImageDataItem.h>
+#include "mitkIOUtil.h"
 
 
-NrrdDiffusionImageReader* NrrdDiffusionImageReader::Clone() const
+namespace mitk
 {
-  return new NrrdDiffusionImageReader(*this);
-}
 
-
-NrrdDiffusionImageReader::
-~NrrdDiffusionImageReader()
-{}
+  NrrdDiffusionImageReader::
+  NrrdDiffusionImageReader(const NrrdDiffusionImageReader & other)
+    : AbstractFileReader(other)
+  {
+  }
 
 
-NrrdDiffusionImageReader::
-NrrdDiffusionImageReader()
-  : mitk::AbstractFileReader( CustomMimeType( mitk::DiffusionIOMimeTypes::DWI_MIMETYPE_NAME() ), mitk::DiffusionIOMimeTypes::DWI_MIMETYPE_DESCRIPTION() )
-{
-  m_ServiceReg = this->RegisterService();
-}
+  NrrdDiffusionImageReader* NrrdDiffusionImageReader::Clone() const
+  {
+    return new NrrdDiffusionImageReader(*this);
+  }
 
-std::vector<itk::SmartPointer<mitk::BaseData> >
-NrrdDiffusionImageReader::
-Read()
-{
-  std::vector<itk::SmartPointer<mitk::BaseData> > result;
 
-  // Since everything is completely read in GenerateOutputInformation() it is stored
-  // in a cache variable. A timestamp is associated.
-  // If the timestamp of the cache variable is newer than the MTime, we only need to
-  // assign the cache variable to the DataObject.
-  // Otherwise, the tree must be read again from the file and OuputInformation must
-  // be updated!
+  NrrdDiffusionImageReader::
+  ~NrrdDiffusionImageReader()
+  {}
 
-  if(m_OutputCache.IsNull()) InternalRead();
+  NrrdDiffusionImageReader::
+  NrrdDiffusionImageReader()
+    : mitk::AbstractFileReader( CustomMimeType( mitk::DiffusionIOMimeTypes::DWI_MIMETYPE_NAME() ), mitk::DiffusionIOMimeTypes::DWI_MIMETYPE_DESCRIPTION() )
+  {
+    m_ServiceReg = this->RegisterService();
+  }
 
-  OutputType::Pointer resultImage = OutputType::New();
-  resultImage->SetVectorImage(m_OutputCache->GetVectorImage());
-  resultImage->SetReferenceBValue(m_OutputCache->GetReferenceBValue());
-  resultImage->SetMeasurementFrame(m_OutputCache->GetMeasurementFrame());
-  resultImage->SetDirections(m_OutputCache->GetDirections());
-  resultImage->InitializeFromVectorImage();
+  std::vector<itk::SmartPointer<mitk::BaseData> >
+  NrrdDiffusionImageReader::
+  Read()
+  {
+    std::vector<itk::SmartPointer<mitk::BaseData> > result;
 
-  result.push_back(resultImage.GetPointer());
-  return result;
-}
+    // Since everything is completely read in GenerateOutputInformation() it is stored
+    // in a cache variable. A timestamp is associated.
+    // If the timestamp of the cache variable is newer than the MTime, we only need to
+    // assign the cache variable to the DataObject.
+    // Otherwise, the tree must be read again from the file and OuputInformation must
+    // be updated!
 
+    if(m_OutputCache.IsNull()) InternalRead();
 
-void NrrdDiffusionImageReader::InternalRead()
-{
-  OutputType::Pointer outputForCache = OutputType::New();
-  if ( this->GetInputLocation() == "")
-  {
-    throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, the filename to be read is empty!");
+    result.push_back(m_OutputCache.GetPointer());
+    return result;
   }
-  else
+
+
+  void NrrdDiffusionImageReader::InternalRead()
   {
-    try
+    OutputType::Pointer outputForCache = OutputType::New();
+    if ( this->GetInputLocation() == "")
     {
-      const std::string& locale = "C";
-      const std::string& currLocale = setlocale( LC_ALL, NULL );
-
-      if ( locale.compare(currLocale)!=0 )
+      throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, the filename to be read is empty!");
+    }
+    else
+    {
+      try
       {
-        try
+        const std::string& locale = "C";
+        const std::string& currLocale = setlocale( LC_ALL, NULL );
+
+        if ( locale.compare(currLocale)!=0 )
         {
-          setlocale(LC_ALL, locale.c_str());
+          try
+          {
+            setlocale(LC_ALL, locale.c_str());
+          }
+          catch(...)
+          {
+            MITK_INFO << "Could not set locale " << locale;
+          }
         }
-        catch(...)
+
+
+        MITK_INFO << "NrrdDiffusionImageReader: reading image information";
+        VectorImageType::Pointer itkVectorImage;
+
+        std::string ext = itksys::SystemTools::GetFilenameLastExtension(this->GetInputLocation());
+        ext = itksys::SystemTools::LowerCase(ext);
+        if (ext == ".hdwi" || ext == ".dwi" || ext == ".nrrd")
         {
-          MITK_INFO << "Could not set locale " << locale;
+          typedef itk::ImageFileReader<VectorImageType> FileReaderType;
+          FileReaderType::Pointer reader = FileReaderType::New();
+          reader->SetFileName(this->GetInputLocation());
+          itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
+          reader->SetImageIO(io);
+          reader->Update();
+          itkVectorImage = reader->GetOutput();
         }
-      }
+        else if(ext == ".fsl" || ext == ".fslgz")
+        {
+          // create temporary file with correct ending for nifti-io
+          std::string fname3 = "temp_dwi";
+          fname3 += ext == ".fsl" ? ".nii" : ".nii.gz";
+          itksys::SystemTools::CopyAFile(this->GetInputLocation().c_str(), fname3.c_str());
+
+          // create reader and read file
+          typedef itk::Image<DiffusionPixelType,4> ImageType4D;
+          itk::NiftiImageIO::Pointer io2 = itk::NiftiImageIO::New();
+          typedef itk::ImageFileReader<ImageType4D> FileReaderType;
+          FileReaderType::Pointer reader = FileReaderType::New();
+          reader->SetFileName(fname3);
+          reader->SetImageIO(io2);
+          reader->Update();
+          ImageType4D::Pointer img4 = reader->GetOutput();
+
+          // delete temporary file
+          itksys::SystemTools::RemoveFile(fname3.c_str());
+
+          // convert 4D file to vector image
+          itkVectorImage = VectorImageType::New();
+
+          VectorImageType::SpacingType spacing;
+          ImageType4D::SpacingType spacing4 = img4->GetSpacing();
+          for(int i=0; i<3; i++)
+            spacing[i] = spacing4[i];
+          itkVectorImage->SetSpacing( spacing );   // Set the image spacing
 
+          VectorImageType::PointType origin;
+          ImageType4D::PointType origin4 = img4->GetOrigin();
+          for(int i=0; i<3; i++)
+            origin[i] = origin4[i];
+          itkVectorImage->SetOrigin( origin );     // Set the image origin
 
-      MITK_INFO << "NrrdDiffusionImageReader: reading image information";
-      ImageType::Pointer img;
+          VectorImageType::DirectionType direction;
+          ImageType4D::DirectionType direction4 = img4->GetDirection();
+          for(int i=0; i<3; i++)
+            for(int j=0; j<3; j++)
+              direction[i][j] = direction4[i][j];
+          itkVectorImage->SetDirection( direction );  // Set the image direction
 
-      std::string ext = itksys::SystemTools::GetFilenameLastExtension(this->GetInputLocation());
-      ext = itksys::SystemTools::LowerCase(ext);
-      if (ext == ".hdwi" || ext == ".dwi")
-      {
-        typedef itk::ImageFileReader<ImageType> FileReaderType;
-        FileReaderType::Pointer reader = FileReaderType::New();
-        reader->SetFileName(this->GetInputLocation());
-        itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
-        reader->SetImageIO(io);
-        reader->Update();
-        img = reader->GetOutput();
+          VectorImageType::RegionType region;
+          ImageType4D::RegionType region4 = img4->GetLargestPossibleRegion();
 
-        int vecsize = img->GetVectorLength();
-        std::cout << vecsize << std::endl;
+          VectorImageType::RegionType::SizeType size;
+          ImageType4D::RegionType::SizeType size4 = region4.GetSize();
 
+          for(int i=0; i<3; i++)
+            size[i] = size4[i];
 
-      }
-      else if(ext == ".fsl" || ext == ".fslgz")
-      {
-        // create temporary file with correct ending for nifti-io
-        std::string fname3 = "temp_dwi";
-        fname3 += ext == ".fsl" ? ".nii" : ".nii.gz";
-        itksys::SystemTools::CopyAFile(this->GetInputLocation().c_str(), fname3.c_str());
-
-        // create reader and read file
-        typedef itk::Image<short,4> ImageType4D;
-        itk::NiftiImageIO::Pointer io2 = itk::NiftiImageIO::New();
-        typedef itk::ImageFileReader<ImageType4D> FileReaderType;
-        FileReaderType::Pointer reader = FileReaderType::New();
-        reader->SetFileName(fname3);
-        reader->SetImageIO(io2);
-        reader->Update();
-        ImageType4D::Pointer img4 = reader->GetOutput();
-
-        // delete temporary file
-        itksys::SystemTools::RemoveFile(fname3.c_str());
-
-        // convert 4D file to vector image
-        img = ImageType::New();
-
-        ImageType::SpacingType spacing;
-        ImageType4D::SpacingType spacing4 = img4->GetSpacing();
-        for(int i=0; i<3; i++)
-          spacing[i] = spacing4[i];
-        img->SetSpacing( spacing );   // Set the image spacing
-
-        ImageType::PointType origin;
-        ImageType4D::PointType origin4 = img4->GetOrigin();
-        for(int i=0; i<3; i++)
-          origin[i] = origin4[i];
-        img->SetOrigin( origin );     // Set the image origin
-
-        ImageType::DirectionType direction;
-        ImageType4D::DirectionType direction4 = img4->GetDirection();
-        for(int i=0; i<3; i++)
-          for(int j=0; j<3; j++)
-            direction[i][j] = direction4[i][j];
-        img->SetDirection( direction );  // Set the image direction
-
-        ImageType::RegionType region;
-        ImageType4D::RegionType region4 = img4->GetLargestPossibleRegion();
-
-        ImageType::RegionType::SizeType size;
-        ImageType4D::RegionType::SizeType size4 = region4.GetSize();
-
-        for(int i=0; i<3; i++)
-          size[i] = size4[i];
-
-        ImageType::RegionType::IndexType index;
-        ImageType4D::RegionType::IndexType index4 = region4.GetIndex();
-        for(int i=0; i<3; i++)
-          index[i] = index4[i];
-
-        region.SetSize(size);
-        region.SetIndex(index);
-        img->SetRegions( region );
-
-        img->SetVectorLength(size4[3]);
-        img->Allocate();
-
-        itk::ImageRegionIterator<ImageType>   it (img, img->GetLargestPossibleRegion() );
-        typedef ImageType::PixelType VecPixType;
-        for (it.GoToBegin(); !it.IsAtEnd(); ++it)
-        {
-          VecPixType vec = it.Get();
-          ImageType::IndexType currentIndex = it.GetIndex();
+          VectorImageType::RegionType::IndexType index;
+          ImageType4D::RegionType::IndexType index4 = region4.GetIndex();
           for(int i=0; i<3; i++)
-            index4[i] = currentIndex[i];
-          for(unsigned int ind=0; ind<vec.Size(); ind++)
+            index[i] = index4[i];
+
+          region.SetSize(size);
+          region.SetIndex(index);
+          itkVectorImage->SetRegions( region );
+
+          itkVectorImage->SetVectorLength(size4[3]);
+          itkVectorImage->Allocate();
+
+          itk::ImageRegionIterator<VectorImageType>   it ( itkVectorImage,  itkVectorImage->GetLargestPossibleRegion() );
+          typedef VectorImageType::PixelType VecPixType;
+          for (it.GoToBegin(); !it.IsAtEnd(); ++it)
           {
-            index4[3] = ind;
-            vec[ind] = img4->GetPixel(index4);
+            VecPixType vec = it.Get();
+            VectorImageType::IndexType currentIndex = it.GetIndex();
+            for(int i=0; i<3; i++)
+              index4[i] = currentIndex[i];
+            for(unsigned int ind=0; ind<vec.Size(); ind++)
+            {
+              index4[3] = ind;
+              vec[ind] = img4->GetPixel(index4);
+            }
+            it.Set(vec);
           }
-          it.Set(vec);
         }
-      }
 
-      m_DiffusionVectors = GradientDirectionContainerType::New();
-      m_OriginalDiffusionVectors = GradientDirectionContainerType::New();
-      if (ext == ".hdwi" || ext == ".dwi")
-      {
+        // Diffusion Image information START
+        GradientDirectionContainerType::Pointer DiffusionVectors = GradientDirectionContainerType::New();
+        GradientDirectionContainerType::Pointer OriginalDiffusionVectors = GradientDirectionContainerType::New();
+        MeasurementFrameType MeasurementFrame;
+        float BValue = -1;
+        // Diffusion Image information END
 
-        itk::MetaDataDictionary imgMetaDictionary = img->GetMetaDataDictionary();
-        std::vector<std::string> imgMetaKeys = imgMetaDictionary.GetKeys();
-        std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin();
-        std::string metaString;
+        if (ext == ".hdwi" || ext == ".dwi" || ext == ".nrrd")
+        {
 
-        GradientDirectionType vect3d;
+          itk::MetaDataDictionary imgMetaDictionary =  itkVectorImage->GetMetaDataDictionary();
+          std::vector<std::string> imgMetaKeys = imgMetaDictionary.GetKeys();
+          std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin();
+          std::string metaString;
 
-        int numberOfImages = 0;
-        int numberOfGradientImages = 0;
-        bool readb0 = false;
-        double xx, xy, xz, yx, yy, yz, zx, zy, zz;
+          GradientDirectionType vect3d;
 
-        for (; itKey != imgMetaKeys.end(); itKey ++)
-        {
-          double x,y,z;
+          int numberOfImages = 0;
+          int numberOfGradientImages = 0;
+          bool readb0 = false;
+          double xx, xy, xz, yx, yy, yz, zx, zy, zz;
 
-          itk::ExposeMetaData<std::string> (imgMetaDictionary, *itKey, metaString);
-          if (itKey->find("DWMRI_gradient") != std::string::npos)
+          for (; itKey != imgMetaKeys.end(); itKey ++)
           {
-            sscanf(metaString.c_str(), "%lf %lf %lf\n", &x, &y, &z);
-            vect3d[0] = x; vect3d[1] = y; vect3d[2] = z;
-            m_DiffusionVectors->InsertElement( numberOfImages, vect3d );
-            ++numberOfImages;
-            // If the direction is 0.0, this is a reference image
-            if (vect3d[0] == 0.0 &&
-                vect3d[1] == 0.0 &&
-                vect3d[2] == 0.0)
+            double x,y,z;
+
+            itk::ExposeMetaData<std::string> (imgMetaDictionary, *itKey, metaString);
+            if (itKey->find("DWMRI_gradient") != std::string::npos)
             {
-              continue;
+              sscanf(metaString.c_str(), "%lf %lf %lf\n", &x, &y, &z);
+              vect3d[0] = x; vect3d[1] = y; vect3d[2] = z;
+              DiffusionVectors->InsertElement( numberOfImages, vect3d );
+              ++numberOfImages;
+              // If the direction is 0.0, this is a reference image
+              if (vect3d[0] == 0.0 &&
+                  vect3d[1] == 0.0 &&
+                  vect3d[2] == 0.0)
+              {
+                continue;
+              }
+              ++numberOfGradientImages;;
             }
-            ++numberOfGradientImages;;
-          }
-          else if (itKey->find("DWMRI_b-value") != std::string::npos)
-          {
-            readb0 = true;
-            m_B_Value = atof(metaString.c_str());
-          }
-          else if (itKey->find("measurement frame") != std::string::npos)
-          {
-            sscanf(metaString.c_str(), " ( %lf , %lf , %lf ) ( %lf , %lf , %lf ) ( %lf , %lf , %lf ) \n", &xx, &xy, &xz, &yx, &yy, &yz, &zx, &zy, &zz);
-
-            if (xx>10e-10 || xy>10e-10 || xz>10e-10 ||
-                yx>10e-10 || yy>10e-10 || yz>10e-10 ||
-                zx>10e-10 || zy>10e-10 || zz>10e-10 )
+            else if (itKey->find("DWMRI_b-value") != std::string::npos)
             {
-              m_MeasurementFrame(0,0) = xx;
-              m_MeasurementFrame(0,1) = xy;
-              m_MeasurementFrame(0,2) = xz;
-              m_MeasurementFrame(1,0) = yx;
-              m_MeasurementFrame(1,1) = yy;
-              m_MeasurementFrame(1,2) = yz;
-              m_MeasurementFrame(2,0) = zx;
-              m_MeasurementFrame(2,1) = zy;
-              m_MeasurementFrame(2,2) = zz;
+              readb0 = true;
+              BValue = atof(metaString.c_str());
             }
-            else
+            else if (itKey->find("measurement frame") != std::string::npos)
             {
-              m_MeasurementFrame(0,0) = 1;
-              m_MeasurementFrame(0,1) = 0;
-              m_MeasurementFrame(0,2) = 0;
-              m_MeasurementFrame(1,0) = 0;
-              m_MeasurementFrame(1,1) = 1;
-              m_MeasurementFrame(1,2) = 0;
-              m_MeasurementFrame(2,0) = 0;
-              m_MeasurementFrame(2,1) = 0;
-              m_MeasurementFrame(2,2) = 1;
+              sscanf(metaString.c_str(), " ( %lf , %lf , %lf ) ( %lf , %lf , %lf ) ( %lf , %lf , %lf ) \n", &xx, &xy, &xz, &yx, &yy, &yz, &zx, &zy, &zz);
+
+              if (xx>10e-10 || xy>10e-10 || xz>10e-10 ||
+                  yx>10e-10 || yy>10e-10 || yz>10e-10 ||
+                  zx>10e-10 || zy>10e-10 || zz>10e-10 )
+              {
+                MeasurementFrame(0,0) = xx;
+                MeasurementFrame(0,1) = xy;
+                MeasurementFrame(0,2) = xz;
+                MeasurementFrame(1,0) = yx;
+                MeasurementFrame(1,1) = yy;
+                MeasurementFrame(1,2) = yz;
+                MeasurementFrame(2,0) = zx;
+                MeasurementFrame(2,1) = zy;
+                MeasurementFrame(2,2) = zz;
+              }
+              else
+              {
+                MeasurementFrame(0,0) = 1;
+                MeasurementFrame(0,1) = 0;
+                MeasurementFrame(0,2) = 0;
+                MeasurementFrame(1,0) = 0;
+                MeasurementFrame(1,1) = 1;
+                MeasurementFrame(1,2) = 0;
+                MeasurementFrame(2,0) = 0;
+                MeasurementFrame(2,1) = 0;
+                MeasurementFrame(2,2) = 1;
+              }
             }
           }
-        }
-
-        if(!readb0)
-        {
-          MITK_INFO << "BValue not specified in header file";
-        }
 
-      }
-      else if(ext == ".fsl" || ext == ".fslgz")
-      {
+          if(!readb0)
+          {
+            MITK_INFO << "BValue not specified in header file";
+          }
 
-        std::string line;
-        std::vector<float> bvec_entries;
-        std::string fname = this->GetInputLocation();
-        fname += ".bvecs";
-        std::ifstream myfile (fname.c_str());
-        if (myfile.is_open())
+        }
+        else if(ext == ".fsl" || ext == ".fslgz")
         {
-          while ( myfile.good() )
+
+          std::string line;
+          std::vector<float> bvec_entries;
+          std::string fname = this->GetInputLocation();
+          fname += ".bvecs";
+          std::ifstream myfile (fname.c_str());
+          if (myfile.is_open())
           {
-            getline (myfile,line);
-            char* pch = strtok (const_cast<char*>(line.c_str())," ");
-            while (pch != NULL)
+            while ( myfile.good() )
             {
-              bvec_entries.push_back(atof(pch));
-              pch = strtok (NULL, " ");
+              getline (myfile,line);
+              char* pch = strtok (const_cast<char*>(line.c_str())," ");
+              while (pch != NULL)
+              {
+                bvec_entries.push_back(atof(pch));
+                pch = strtok (NULL, " ");
+              }
             }
+            myfile.close();
+          }
+          else
+          {
+            MITK_INFO << "Unable to open bvecs file";
           }
-          myfile.close();
-        }
-        else
-        {
-          MITK_INFO << "Unable to open bvecs file";
-        }
 
-        std::vector<float> bval_entries;
-        std::string fname2 = this->GetInputLocation();
-        fname2 += ".bvals";
-        std::ifstream myfile2 (fname2.c_str());
-        if (myfile2.is_open())
-        {
-          while ( myfile2.good() )
+          std::vector<float> bval_entries;
+          std::string fname2 = this->GetInputLocation();
+          fname2 += ".bvals";
+          std::ifstream myfile2 (fname2.c_str());
+          if (myfile2.is_open())
           {
-            getline (myfile2,line);
-            char* pch = strtok (const_cast<char*>(line.c_str())," ");
-            while (pch != NULL)
+            while ( myfile2.good() )
             {
-              bval_entries.push_back(atof(pch));
-              pch = strtok (NULL, " ");
+              getline (myfile2,line);
+              char* pch = strtok (const_cast<char*>(line.c_str())," ");
+              while (pch != NULL)
+              {
+                bval_entries.push_back(atof(pch));
+                pch = strtok (NULL, " ");
+              }
             }
+            myfile2.close();
+          }
+          else
+          {
+            MITK_INFO << "Unable to open bvals file";
           }
-          myfile2.close();
-        }
-        else
-        {
-          MITK_INFO << "Unable to open bvals file";
-        }
-
 
-        m_B_Value = -1;
-        unsigned int numb = bval_entries.size();
-        for(unsigned int i=0; i<numb; i++)
-        {
 
-          // Take the first entry in bvals as the reference b-value
-          if(m_B_Value == -1 && bval_entries.at(i) != 0)
+          BValue = -1;
+          unsigned int numb = bval_entries.size();
+          for(unsigned int i=0; i<numb; i++)
           {
-            m_B_Value = bval_entries.at(i);
-          }
 
-          float b_val = bval_entries.at(i);
+            // Take the first entry in bvals as the reference b-value
+            if(BValue == -1 && bval_entries.at(i) != 0)
+            {
+              BValue = bval_entries.at(i);
+            }
 
+            float b_val = bval_entries.at(i);
 
-          vnl_vector_fixed< double, 3 > vec;
-          vec[0] = bvec_entries.at(i);
-          vec[1] = bvec_entries.at(i+numb);
-          vec[2] = bvec_entries.at(i+2*numb);
 
-          // Adjust the vector length to encode gradient strength
-          float factor = b_val/m_B_Value;
-          if(vec.magnitude() > 0)
-          {
-            vec[0] = sqrt(factor)*vec[0];
-            vec[1] = sqrt(factor)*vec[1];
-            vec[2] = sqrt(factor)*vec[2];
+            vnl_vector_fixed< double, 3 > vec;
+            vec[0] = bvec_entries.at(i);
+            vec[1] = bvec_entries.at(i+numb);
+            vec[2] = bvec_entries.at(i+2*numb);
+
+            // Adjust the vector length to encode gradient strength
+            float factor = b_val/BValue;
+            if(vec.magnitude() > 0)
+            {
+              vec[0] = sqrt(factor)*vec[0];
+              vec[1] = sqrt(factor)*vec[1];
+              vec[2] = sqrt(factor)*vec[2];
+            }
+
+            DiffusionVectors->InsertElement(i,vec);
           }
 
-          m_DiffusionVectors->InsertElement(i,vec);
+          for(int i=0; i<3; i++)
+            for(int j=0; j<3; j++)
+              MeasurementFrame[i][j] = i==j ? 1 : 0;
         }
 
-        for(int i=0; i<3; i++)
-          for(int j=0; j<3; j++)
-            m_MeasurementFrame[i][j] = i==j ? 1 : 0;
-      }
+        outputForCache = mitk::GrabItkImageMemory( itkVectorImage);
 
-      outputForCache->SetVectorImage(img);
-      outputForCache->SetReferenceBValue(m_B_Value);
-      outputForCache->SetMeasurementFrame(m_MeasurementFrame);
-      outputForCache->SetDirections(m_DiffusionVectors);
+        // create BValueMap
+        mitk::BValueMapProperty::BValueMap BValueMap = mitk::BValueMapProperty::CreateBValueMap(DiffusionVectors,BValue);
+        outputForCache->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( DiffusionVectors ) );
+        outputForCache->SetProperty( mitk::DiffusionPropertyHelper::ORIGINALGRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( OriginalDiffusionVectors ) );
+        outputForCache->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( MeasurementFrame ) );
+        outputForCache->SetProperty( mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str(), mitk::BValueMapProperty::New( BValueMap ) );
+        outputForCache->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( BValue ) );
 
 
-      // Since we have already read the tree, we can store it in a cache variable
-      // so that it can be assigned to the DataObject in GenerateData();
-      m_OutputCache = outputForCache;
-      m_CacheTime.Modified();
+        // Since we have already read the tree, we can store it in a cache variable
+        // so that it can be assigned to the DataObject in GenerateData();
+        m_OutputCache = outputForCache;
+        m_CacheTime.Modified();
 
-      try
+        try
+        {
+          setlocale(LC_ALL, currLocale.c_str());
+        }
+        catch(...)
+        {
+          MITK_INFO << "Could not reset locale " << currLocale;
+        }
+      }
+      catch(std::exception& e)
       {
-        setlocale(LC_ALL, currLocale.c_str());
+        MITK_INFO << "Std::Exception while reading file!!";
+        MITK_INFO << e.what();
+        throw itk::ImageFileReaderException(__FILE__, __LINE__, e.what());
       }
       catch(...)
       {
-        MITK_INFO << "Could not reset locale " << currLocale;
+        MITK_INFO << "Exception while reading file!!";
+        throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, an error occurred while reading the requested vessel tree file!");
       }
     }
-    catch(std::exception& e)
-    {
-      MITK_INFO << "Std::Exception while reading file!!";
-      MITK_INFO << e.what();
-      throw itk::ImageFileReaderException(__FILE__, __LINE__, e.what());
-    }
-    catch(...)
-    {
-      MITK_INFO << "Exception while reading file!!";
-      throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, an error occurred while reading the requested vessel tree file!");
-    }
   }
-}
 
 } //namespace MITK
 
 #endif
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageReader.h b/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageReader.h
index f7c10669af..ac1fb1d29c 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageReader.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageReader.h
@@ -1,72 +1,73 @@
 /*===================================================================
 
 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 __mitkNrrdDiffusionImageReader_h
 #define __mitkNrrdDiffusionImageReader_h
 
 #include "mitkCommon.h"
-#include "itkVectorContainer.h"
+
+// MITK includes
+#include "mitkImageSource.h"
 #include "mitkFileReader.h"
-#include "vnl/vnl_vector_fixed.h"
-#include "vnl/vnl_matrix_fixed.h"
 
+#include <mitkDiffusionPropertyHelper.h>
+
+// ITK includes
 #include "itkVectorImage.h"
 #include "mitkAbstractFileReader.h"
-#include "mitkDiffusionImage.h"
+
+
 
 namespace mitk
 {
 
   /** \brief
   */
 
   class NrrdDiffusionImageReader : public mitk::AbstractFileReader
   {
   public:
 
     NrrdDiffusionImageReader(const NrrdDiffusionImageReader & other);
     NrrdDiffusionImageReader();
     virtual ~NrrdDiffusionImageReader();
 
     using AbstractFileReader::Read;
     virtual std::vector<itk::SmartPointer<BaseData> > Read();
 
-    typedef mitk::DiffusionImage<short>                                 OutputType;
-    typedef itk::VectorImage<short,3>                                   ImageType;
-    typedef vnl_vector_fixed< double, 3 >                               GradientDirectionType;
-    typedef vnl_matrix_fixed< double, 3, 3 >                            MeasurementFrameType;
-    typedef itk::VectorContainer< unsigned int,GradientDirectionType >  GradientDirectionContainerType;
+    typedef short                                                           DiffusionPixelType;
+
+    typedef mitk::Image                                                     OutputType;
+    typedef mitk::DiffusionPropertyHelper::ImageType                        VectorImageType;
+    typedef mitk::DiffusionPropertyHelper::GradientDirectionType            GradientDirectionType;
+    typedef mitk::DiffusionPropertyHelper::MeasurementFrameType             MeasurementFrameType;
+    typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType  GradientDirectionContainerType;
 
   protected:
     OutputType::Pointer m_OutputCache;
     itk::TimeStamp m_CacheTime;
-    GradientDirectionContainerType::Pointer m_OriginalDiffusionVectors;
-    GradientDirectionContainerType::Pointer m_DiffusionVectors;
-    float m_B_Value;
-    MeasurementFrameType m_MeasurementFrame;
 
     void InternalRead();
 
   private:
 
     NrrdDiffusionImageReader* Clone() const;
     us::ServiceRegistration<mitk::IFileReader> m_ServiceReg;
   };
 
 } //namespace MITK
 
-
 #endif // __mitkNrrdDiffusionImageReader_h
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageWriter.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageWriter.cpp
index d9f7f745ba..94f152f17f 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageWriter.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageWriter.cpp
@@ -1,326 +1,332 @@
 /*===================================================================
 
 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 __mitkNrrdDiffusionImageWriter__cpp
 #define __mitkNrrdDiffusionImageWriter__cpp
 
 #include "mitkNrrdDiffusionImageWriter.h"
 #include "itkMetaDataDictionary.h"
 #include "itkMetaDataObject.h"
 #include "itkNrrdImageIO.h"
 #include "itkNiftiImageIO.h"
 #include "itkImageFileWriter.h"
 #include "itksys/SystemTools.hxx"
 #include "mitkDiffusionIOMimeTypes.h"
+#include "mitkImageCast.h"
 
 #include <iostream>
 #include <fstream>
 
 
 mitk::NrrdDiffusionImageWriter::NrrdDiffusionImageWriter()
-  : AbstractFileWriter(mitk::DiffusionImage<short>::GetStaticNameOfClass(), CustomMimeType( mitk::DiffusionIOMimeTypes::DWI_MIMETYPE_NAME() ), mitk::DiffusionIOMimeTypes::DWI_MIMETYPE_DESCRIPTION())
+  : AbstractFileWriter(mitk::Image::GetStaticNameOfClass(), CustomMimeType( mitk::DiffusionIOMimeTypes::DWI_MIMETYPE_NAME() ), mitk::DiffusionIOMimeTypes::DWI_MIMETYPE_DESCRIPTION())
 {
   RegisterService();
 }
 
 mitk::NrrdDiffusionImageWriter::NrrdDiffusionImageWriter(const mitk::NrrdDiffusionImageWriter& other)
   : AbstractFileWriter(other)
 {
 }
 
 mitk::NrrdDiffusionImageWriter::~NrrdDiffusionImageWriter()
 {}
 
 void mitk::NrrdDiffusionImageWriter::Write()
 {
-  InputType::ConstPointer input = dynamic_cast<const InputType*>(this->GetInput());
+  mitk::Image::ConstPointer input = dynamic_cast<const mitk::Image *>(this->GetInput());
+
+  VectorImageType::Pointer itkImg;
+  mitk::CastToItkImage(input,itkImg);
+
   if (input.IsNull())
   {
     MITK_ERROR <<"Sorry, input to NrrdDiffusionImageWriter is NULL!";
     return;
   }
   if ( this->GetOutputLocation().empty() )
   {
     MITK_ERROR << "Sorry, filename has not been set!";
     return ;
   }
   const std::string& locale = "C";
   const std::string& currLocale = setlocale( LC_ALL, NULL );
 
   if ( locale.compare(currLocale)!=0 )
   {
     try
     {
       setlocale(LC_ALL, locale.c_str());
     }
     catch(...)
     {
       MITK_INFO << "Could not set locale " << locale;
     }
   }
 
   char keybuffer[512];
   char valbuffer[512];
 
   //itk::MetaDataDictionary dic = input->GetImage()->GetMetaDataDictionary();
 
-  vnl_matrix_fixed<double,3,3> measurementFrame = input->GetMeasurementFrame();
+  vnl_matrix_fixed<double,3,3> measurementFrame = mitk::DiffusionPropertyHelper::GetMeasurementFrame(input);
   if (measurementFrame(0,0) || measurementFrame(0,1) || measurementFrame(0,2) ||
     measurementFrame(1,0) || measurementFrame(1,1) || measurementFrame(1,2) ||
     measurementFrame(2,0) || measurementFrame(2,1) || measurementFrame(2,2))
   {
     sprintf( valbuffer, " (%lf,%lf,%lf) (%lf,%lf,%lf) (%lf,%lf,%lf)", measurementFrame(0,0), measurementFrame(0,1), measurementFrame(0,2), measurementFrame(1,0), measurementFrame(1,1), measurementFrame(1,2), measurementFrame(2,0), measurementFrame(2,1), measurementFrame(2,2));
-    itk::EncapsulateMetaData<std::string>(input->GetVectorImage()->GetMetaDataDictionary(),std::string("measurement frame"),std::string(valbuffer));
+    itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string("measurement frame"),std::string(valbuffer));
   }
 
   sprintf( valbuffer, "DWMRI");
-  itk::EncapsulateMetaData<std::string>(input->GetVectorImage()->GetMetaDataDictionary(),std::string("modality"),std::string(valbuffer));
+  itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string("modality"),std::string(valbuffer));
 
-  if(input->GetDirections()->Size())
+  if(mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size())
   {
-    sprintf( valbuffer, "%1f", input->GetReferenceBValue() );
-    itk::EncapsulateMetaData<std::string>(input->GetVectorImage()->GetMetaDataDictionary(),std::string("DWMRI_b-value"),std::string(valbuffer));
+    sprintf( valbuffer, "%1f", mitk::DiffusionPropertyHelper::GetReferenceBValue(input) );
+    itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string("DWMRI_b-value"),std::string(valbuffer));
   }
 
-  for(unsigned int i=0; i<input->GetDirections()->Size(); i++)
+  for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size(); i++)
   {
     sprintf( keybuffer, "DWMRI_gradient_%04d", i );
 
     /*if(itk::ExposeMetaData<std::string>(input->GetMetaDataDictionary(),
     std::string(keybuffer),tmp))
     continue;*/
 
-    sprintf( valbuffer, "%1f %1f %1f", input->GetDirections()->ElementAt(i).get(0),
-      input->GetDirections()->ElementAt(i).get(1), input->GetDirections()->ElementAt(i).get(2));
+    sprintf( valbuffer, "%1f %1f %1f", mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).get(0),
+      mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).get(1), mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).get(2));
 
-    itk::EncapsulateMetaData<std::string>(input->GetVectorImage()->GetMetaDataDictionary(),std::string(keybuffer),std::string(valbuffer));
+    itk::EncapsulateMetaData<std::string>(itkImg->GetMetaDataDictionary(),std::string(keybuffer),std::string(valbuffer));
   }
 
   typedef itk::VectorImage<short,3> ImageType;
 
   std::string ext = itksys::SystemTools::GetFilenameLastExtension(this->GetOutputLocation());
   ext = itksys::SystemTools::LowerCase(ext);
 
   // default extension is .dwi
   if( ext == "")
   {
-    ext = ".dwi";
+    ext = ".nrrd";
     this->SetOutputLocation(this->GetOutputLocation() + ext);
   }
 
-  if (ext == ".hdwi" || ext == ".dwi")
+  if (ext == ".hdwi" || ext == ".nrrd" || ext == ".dwi")
   {
+
+    MITK_INFO << "Extension " << ext;
     itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
     //io->SetNrrdVectorType( nrrdKindList );
     io->SetFileType( itk::ImageIOBase::Binary );
     io->UseCompressionOn();
 
     typedef itk::ImageFileWriter<ImageType> WriterType;
     WriterType::Pointer nrrdWriter = WriterType::New();
     nrrdWriter->UseInputMetaDataDictionaryOn();
-    nrrdWriter->SetInput( input->GetVectorImage() );
+    nrrdWriter->SetInput( itkImg );
     nrrdWriter->SetImageIO(io);
     nrrdWriter->SetFileName(this->GetOutputLocation());
     nrrdWriter->UseCompressionOn();
     nrrdWriter->SetImageIO(io);
     try
     {
       nrrdWriter->Update();
     }
     catch (itk::ExceptionObject e)
     {
       std::cout << e << std::endl;
       throw;
     }
 
   }
   else if (ext == ".fsl" || ext == ".fslgz")
   {
     MITK_INFO << "Writing Nifti-Image for FSL";
-    ImageType::Pointer vecimg = input->GetVectorImage();
 
     typedef itk::Image<short,4> ImageType4D;
     ImageType4D::Pointer img4 = ImageType4D::New();
 
-    ImageType::SpacingType spacing = vecimg->GetSpacing();
+    ImageType::SpacingType spacing = itkImg->GetSpacing();
     ImageType4D::SpacingType spacing4;
     for(int i=0; i<3; i++)
       spacing4[i] = spacing[i];
     spacing4[3] = 1;
     img4->SetSpacing( spacing4 );   // Set the image spacing
 
-    ImageType::PointType origin = vecimg->GetOrigin();
+    ImageType::PointType origin = itkImg->GetOrigin();
     ImageType4D::PointType origin4;
     for(int i=0; i<3; i++)
       origin4[i] = origin[i];
     origin4[3] = 0;
     img4->SetOrigin( origin4 );     // Set the image origin
 
-    ImageType::DirectionType direction = vecimg->GetDirection();
+    ImageType::DirectionType direction = itkImg->GetDirection();
     ImageType4D::DirectionType direction4;
     for(int i=0; i<3; i++)
       for(int j=0; j<3; j++)
         direction4[i][j] = direction[i][j];
     for(int i=0; i<4; i++)
       direction4[i][3] = 0;
     for(int i=0; i<4; i++)
       direction4[3][i] = 0;
     direction4[3][3] = 1;
     img4->SetDirection( direction4 );  // Set the image direction
 
-    ImageType::RegionType region = vecimg->GetLargestPossibleRegion();
+    ImageType::RegionType region = itkImg->GetLargestPossibleRegion();
     ImageType4D::RegionType region4;
 
     ImageType::RegionType::SizeType size = region.GetSize();
     ImageType4D::RegionType::SizeType size4;
 
     for(int i=0; i<3; i++)
       size4[i] = size[i];
-    size4[3] = vecimg->GetVectorLength();
+    size4[3] = itkImg->GetVectorLength();
 
     ImageType::RegionType::IndexType index = region.GetIndex();
     ImageType4D::RegionType::IndexType index4;
     for(int i=0; i<3; i++)
       index4[i] = index[i];
     index4[3] = 0;
 
     region4.SetSize(size4);
     region4.SetIndex(index4);
     img4->SetRegions( region4 );
 
     img4->Allocate();
 
-    itk::ImageRegionIterator<ImageType>   it (vecimg, vecimg->GetLargestPossibleRegion() );
+    itk::ImageRegionIterator<ImageType>   it (itkImg, itkImg->GetLargestPossibleRegion() );
     typedef ImageType::PixelType VecPixType;
 
     for (it.GoToBegin(); !it.IsAtEnd(); ++it)
     {
       VecPixType vec = it.Get();
       ImageType::IndexType currentIndex = it.GetIndex();
       for(unsigned int ind=0; ind<vec.Size(); ind++)
       {
 
         for(int i=0; i<3; i++)
           index4[i] = currentIndex[i];
         index4[3] = ind;
         img4->SetPixel(index4, vec[ind]);
       }
     }
 
     // create copy of file with correct ending for mitk
     std::string fname3 = this->GetOutputLocation();
     std::string::iterator itend = fname3.end();
     if (ext == ".fsl")
       fname3.replace( itend-3, itend, "nii");
     else
       fname3.replace( itend-5, itend, "nii.gz");
 
     itk::NiftiImageIO::Pointer io4 = itk::NiftiImageIO::New();
 
     typedef itk::VectorImage<short,3> ImageType;
     typedef itk::ImageFileWriter<ImageType4D> WriterType4;
     WriterType4::Pointer nrrdWriter4 = WriterType4::New();
     nrrdWriter4->UseInputMetaDataDictionaryOn();
     nrrdWriter4->SetInput( img4 );
     nrrdWriter4->SetFileName(fname3);
     nrrdWriter4->UseCompressionOn();
     nrrdWriter4->SetImageIO(io4);
     try
     {
       nrrdWriter4->Update();
     }
     catch (itk::ExceptionObject e)
     {
       std::cout << e << std::endl;
       throw;
     }
 
     itksys::SystemTools::CopyAFile(fname3.c_str(), this->GetOutputLocation().c_str());
 
-    if(input->GetDirections()->Size())
+    if(mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size())
     {
       std::ofstream myfile;
       std::string fname = this->GetOutputLocation();
       fname += ".bvals";
       myfile.open (fname.c_str());
-      for(unsigned int i=0; i<input->GetDirections()->Size(); i++)
+      for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size(); i++)
       {
-        double twonorm = input->GetDirections()->ElementAt(i).two_norm();
-        myfile << input->GetReferenceBValue()*twonorm*twonorm << " ";
+        double twonorm = mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).two_norm();
+        myfile << mitk::DiffusionPropertyHelper::GetReferenceBValue(input)*twonorm*twonorm << " ";
       }
       myfile.close();
 
       std::ofstream myfile2;
       std::string fname2 = this->GetOutputLocation();
       fname2 += ".bvecs";
       myfile2.open (fname2.c_str());
       for(int j=0; j<3; j++)
       {
-        for(unsigned int i=0; i<input->GetDirections()->Size(); i++)
+        for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size(); i++)
         {
           //need to modify the length
-          mitk::DiffusionImage<short>::GradientDirectionContainerType::Pointer grads = input->GetDirections();
-          mitk::DiffusionImage<short>::GradientDirectionType direction = grads->ElementAt(i);
+          GradientDirectionContainerType::Pointer grads = mitk::DiffusionPropertyHelper::GetGradientContainer(input);
+          GradientDirectionType direction = grads->ElementAt(i);
           direction.normalize();
           myfile2 << direction.get(j) << " ";
           //myfile2 << input->GetDirections()->ElementAt(i).get(j) << " ";
         }
         myfile2 << std::endl;
       }
 
       std::ofstream myfile3;
       std::string fname4 = this->GetOutputLocation();
       fname4 += ".ttk";
       myfile3.open (fname4.c_str());
-      for(unsigned int i=0; i<input->GetDirections()->Size(); i++)
+      for(unsigned int i=0; i<mitk::DiffusionPropertyHelper::GetGradientContainer(input)->Size(); i++)
       {
         for(int j=0; j<3; j++)
         {
-          myfile3 << input->GetDirections()->ElementAt(i).get(j) << " ";
+          myfile3 << mitk::DiffusionPropertyHelper::GetGradientContainer(input)->ElementAt(i).get(j) << " ";
         }
         myfile3 << std::endl;
       }
     }
   }
   try
   {
     setlocale(LC_ALL, currLocale.c_str());
   }
   catch(...)
   {
     MITK_INFO << "Could not reset locale " << currLocale;
   }
 }
 
 mitk::NrrdDiffusionImageWriter* mitk::NrrdDiffusionImageWriter::Clone() const
 {
   return new NrrdDiffusionImageWriter(*this);
 }
 
 mitk::IFileWriter::ConfidenceLevel mitk::NrrdDiffusionImageWriter::GetConfidenceLevel() const
 {
-  InputType::ConstPointer input = dynamic_cast<const InputType*>(this->GetInput());
+  mitk::Image::ConstPointer input = dynamic_cast<const mitk::Image*>(this->GetInput());
   if (input.IsNull() )
   {
     return Unsupported;
   }
   else
   {
     return Supported;
   }
 }
 
 #endif //__mitkNrrdDiffusionImageWriter__cpp
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageWriter.h b/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageWriter.h
index 072621a361..1bedf714ce 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageWriter.h
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageWriter.h
@@ -1,55 +1,58 @@
 /*===================================================================
 
 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 _MITK_NRRDDIFFVOL_WRITER__H_
 #define _MITK_NRRDDIFFVOL_WRITER__H_
 
 #include <mitkAbstractFileWriter.h>
-#include <mitkDiffusionImage.h>
+#include <mitkDiffusionPropertyHelper.h>
 
 namespace mitk
 {
 
 /**
  * Writes diffusion volumes to a file
  * @ingroup Process
  */
 class NrrdDiffusionImageWriter : public mitk::AbstractFileWriter
 {
 public:
 
-    typedef mitk::DiffusionImage<short> InputType;
-
     NrrdDiffusionImageWriter();
     virtual ~NrrdDiffusionImageWriter();
 
     using AbstractFileWriter::Write;
     virtual void Write();
 
     virtual ConfidenceLevel GetConfidenceLevel() const;
 
+    typedef mitk::DiffusionPropertyHelper::ImageType                        VectorImageType;
+    typedef mitk::DiffusionPropertyHelper::GradientDirectionType            GradientDirectionType;
+    typedef mitk::DiffusionPropertyHelper::MeasurementFrameType             MeasurementFrameType;
+    typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType  GradientDirectionContainerType;
+
   protected:
 
     NrrdDiffusionImageWriter(const NrrdDiffusionImageWriter& other);
     virtual mitk::NrrdDiffusionImageWriter* Clone() const;
 
 
 };
 
 
 } // end of namespace mitk
 
 #endif
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.h
index aa56645ad8..c284489d44 100755
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.h
@@ -1,132 +1,131 @@
 /*===================================================================
 
 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 __itkTractsToDWIImageFilter_h__
 #define __itkTractsToDWIImageFilter_h__
 
 #include <mitkFiberBundleX.h>
 #include <itkVnlForwardFFTImageFilter.h>
 #include <itkVectorImage.h>
 #include <cmath>
 #include <mitkFiberfoxParameters.h>
 #include <itkTimeProbe.h>
 #include <mitkRawShModel.h>
-#include <mitkDiffusionImage.h>
 #include <itkAnalyticalDiffusionQballReconstructionImageFilter.h>
 
 namespace itk
 {
 
 /**
 * \brief Generates artificial diffusion weighted image volume from the input fiberbundle using a generic multicompartment model.
 * See "Fiberfox: Facilitating the creation of realistic white matter software phantoms" (DOI: 10.1002/mrm.25045) for details.
 */
 
 template< class PixelType >
 class TractsToDWIImageFilter : public ImageSource< itk::VectorImage< PixelType, 3 > >
 {
 
 public:
 
     typedef TractsToDWIImageFilter                          Self;
     typedef ImageSource< itk::VectorImage< PixelType, 3 > > Superclass;
     typedef SmartPointer< Self >                            Pointer;
     typedef SmartPointer< const Self >                      ConstPointer;
 
     typedef typename Superclass::OutputImageType                        OutputImageType;
     typedef itk::Image<double, 3>                                       ItkDoubleImgType;
     typedef itk::Image<unsigned char, 3>                                ItkUcharImgType;
     typedef mitk::FiberBundleX::Pointer                                 FiberBundleType;
     typedef itk::VectorImage< double, 3 >                               DoubleDwiType;
     typedef itk::Matrix<double, 3, 3>                                   MatrixType;
     typedef itk::Image< double, 2 >                                     SliceType;
     typedef itk::VnlForwardFFTImageFilter<SliceType>::OutputImageType   ComplexSliceType;
     typedef itk::Vector< double,3>                                      DoubleVectorType;
 
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
     itkTypeMacro( TractsToDWIImageFilter, ImageSource )
 
     /** Input */
     itkSetMacro( FiberBundle, FiberBundleType )             ///< Input fiber bundle
     itkSetMacro( UseConstantRandSeed, bool )                ///< Seed for random generator.
     void SetParameters( FiberfoxParameters<double> param )  ///< Simulation parameters.
     { m_Parameters = param; }
 
     /** Output */
     FiberfoxParameters<double> GetParameters(){ return m_Parameters; }
     std::vector< ItkDoubleImgType::Pointer > GetVolumeFractions() ///< one double image for each compartment containing the corresponding volume fraction per voxel
     { return m_VolumeFractions; }
     mitk::LevelWindow GetLevelWindow(){ return m_LevelWindow; }
     itkGetMacro( StatusText, std::string )
 
     void GenerateData();
 
 protected:
 
     TractsToDWIImageFilter();
     virtual ~TractsToDWIImageFilter();
     itk::Point<float, 3> GetItkPoint(double point[3]);
     itk::Vector<double, 3> GetItkVector(double point[3]);
     vnl_vector_fixed<double, 3> GetVnlVector(double point[3]);
     vnl_vector_fixed<double, 3> GetVnlVector(Vector< float, 3 >& vector);
     double RoundToNearest(double num);
     std::string GetTime();
 
     /** Transform generated image compartment by compartment, channel by channel and slice by slice using DFT and add k-space artifacts. */
     DoubleDwiType::Pointer DoKspaceStuff(std::vector< DoubleDwiType::Pointer >& images);
 
     /** Generate signal of non-fiber compartments. */
     void SimulateNonFiberSignal(ItkUcharImgType::IndexType index, double intraAxonalVolume, int g=-1);
 
     /** Move fibers to simulate headmotion */
     void SimulateMotion(int g=-1);
 
     // input
     mitk::FiberfoxParameters<double>            m_Parameters;
     FiberBundleType                             m_FiberBundle;
 
     // output
     mitk::LevelWindow                           m_LevelWindow;
     std::vector< ItkDoubleImgType::Pointer >    m_VolumeFractions;
     std::string                                 m_StatusText;
 
     // MISC
     itk::TimeProbe                              m_TimeProbe;
     bool                                        m_UseConstantRandSeed;
     bool                                        m_MaskImageSet;
     ofstream                                    m_Logfile;
 
     // signal generation
     FiberBundleType                             m_FiberBundleWorkingCopy;   ///< we work on an upsampled version of the input bundle
     FiberBundleType                             m_FiberBundleTransformed;   ///< transformed bundle simulating headmotion
     itk::Vector<double,3>                       m_UpsampledSpacing;
     itk::Point<double,3>                        m_UpsampledOrigin;
     ImageRegion<3>                              m_UpsampledImageRegion;
     double                                      m_VoxelVolume;
     std::vector< DoubleDwiType::Pointer >       m_CompartmentImages;
     ItkUcharImgType::Pointer                    m_MaskImage;                ///< copy of mask image (changes for each motion step)
     ItkUcharImgType::Pointer                    m_UpsampledMaskImage;       ///< helper image for motion simulation
     DoubleVectorType                            m_Rotation;
     DoubleVectorType                            m_Translation;
     itk::Statistics::MersenneTwisterRandomVariateGenerator::Pointer m_RandGen;
 };
 }
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkTractsToDWIImageFilter.cpp"
 #endif
 
 #endif
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.h b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.h
index 99f598474c..5cd056a4b6 100644
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.h
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.h
@@ -1,176 +1,177 @@
 /*===================================================================
 
 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 _MITK_FiberBundleX_H
 #define _MITK_FiberBundleX_H
 
 //includes for MITK datastructure
 #include <mitkBaseData.h>
 #include <MitkFiberTrackingExports.h>
 #include <mitkImage.h>
 
 
 //includes storing fiberdata
 #include <vtkSmartPointer.h>
 #include <vtkPolyData.h>
 #include <vtkPoints.h>
 #include <vtkDataSet.h>
 #include <vtkTransform.h>
 
 //#include <QStringList>
 
 #include <mitkPlanarFigure.h>
 #include <mitkPixelTypeTraits.h>
 #include <mitkPlanarFigureComposite.h>
 
+
 namespace mitk {
 
 /**
    * \brief Base Class for Fiber Bundles;   */
 class MitkFiberTracking_EXPORT FiberBundleX : public BaseData
 {
 public:
 
     typedef itk::Image<unsigned char, 3> ItkUcharImgType;
 
     // fiber colorcodings
     static const char* COLORCODING_ORIENTATION_BASED;
     static const char* COLORCODING_FA_BASED;
     static const char* COLORCODING_CUSTOM;
     static const char* FIBER_ID_ARRAY;
 
     virtual void UpdateOutputInformation();
     virtual void SetRequestedRegionToLargestPossibleRegion();
     virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
     virtual bool VerifyRequestedRegion();
     virtual void SetRequestedRegion(const itk::DataObject*);
 
     mitkClassMacro( FiberBundleX, BaseData )
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
     mitkNewMacro1Param(Self, vtkSmartPointer<vtkPolyData>) // custom constructor
 
     // colorcoding related methods
     void SetColorCoding(const char*);
     void SetFAMap(mitk::Image::Pointer);
     template <typename TPixel>
     void SetFAMap(const mitk::PixelType pixelType, mitk::Image::Pointer);
     void DoColorCodingOrientationBased();
     void DoColorCodingFaBased();
     void DoUseFaFiberOpacity();
     void ResetFiberOpacity();
 
     // fiber compression
     void Compress(float error = 0.0);
 
     // fiber resampling
     void ResampleSpline(float pointDistance=1);
     void ResampleSpline(float pointDistance, double tension, double continuity, double bias );
 
     bool RemoveShortFibers(float lengthInMM);
     bool RemoveLongFibers(float lengthInMM);
     bool ApplyCurvatureThreshold(float minRadius, bool deleteFibers);
     void MirrorFibers(unsigned int axis);
     void RotateAroundAxis(double x, double y, double z);
     void TranslateFibers(double x, double y, double z);
     void ScaleFibers(double x, double y, double z, bool subtractCenter=true);
     void TransformFibers(double rx, double ry, double rz, double tx, double ty, double tz);
     void RemoveDir(vnl_vector_fixed<double,3> dir, double threshold);
     itk::Point<float, 3> TransformPoint(vnl_vector_fixed< double, 3 > point, double rx, double ry, double rz, double tx, double ty, double tz);
     itk::Matrix< double, 3, 3 > TransformMatrix(itk::Matrix< double, 3, 3 > m, double rx, double ry, double rz);
 
     // add/subtract fibers
     FiberBundleX::Pointer AddBundle(FiberBundleX* fib);
     FiberBundleX::Pointer SubtractBundle(FiberBundleX* fib);
 
     // fiber subset extraction
     FiberBundleX::Pointer           ExtractFiberSubset(BaseData* roi);
     std::vector<long>               ExtractFiberIdSubset(BaseData* roi);
     FiberBundleX::Pointer           ExtractFiberSubset(ItkUcharImgType* mask, bool anyPoint, bool invert=false);
     FiberBundleX::Pointer           RemoveFibersOutside(ItkUcharImgType* mask, bool invert=false);
 
     vtkSmartPointer<vtkPolyData>    GeneratePolyDataByIds( std::vector<long> ); // TODO: make protected
     void                            GenerateFiberIds(); // TODO: make protected
 
     // get/set data
     void SetFiberPolyData(vtkSmartPointer<vtkPolyData>, bool updateGeometry = true);
     vtkSmartPointer<vtkPolyData> GetFiberPolyData() const;
     std::vector< std::string > GetAvailableColorCodings();
     char* GetCurrentColorCoding();
     itkGetMacro( NumFibers, int)
     //itkGetMacro( FiberSampling, int)
     int GetNumFibers() const {return m_NumFibers;}
     itkGetMacro( MinFiberLength, float )
     itkGetMacro( MaxFiberLength, float )
     itkGetMacro( MeanFiberLength, float )
     itkGetMacro( MedianFiberLength, float )
     itkGetMacro( LengthStDev, float )
     itkGetMacro( UpdateTime2D, itk::TimeStamp )
     itkGetMacro( UpdateTime3D, itk::TimeStamp )
     void RequestUpdate2D(){ m_UpdateTime2D.Modified(); }
     void RequestUpdate3D(){ m_UpdateTime3D.Modified(); }
 
     unsigned long GetNumberOfPoints();
 
     // copy fiber bundle
     mitk::FiberBundleX::Pointer GetDeepCopy();
 
     // compare fiber bundles
     bool Equals(FiberBundleX* fib, double eps=0.0001);
 
     itkSetMacro( ReferenceGeometry, mitk::BaseGeometry::Pointer )
     itkGetConstMacro( ReferenceGeometry, mitk::BaseGeometry::Pointer )
 
 protected:
 
     FiberBundleX( vtkPolyData* fiberPolyData = NULL );
     virtual ~FiberBundleX();
 
     itk::Point<float, 3> GetItkPoint(double point[3]);
 
     // calculate geometry from fiber extent
     void UpdateFiberGeometry();
 
     // calculate colorcoding values according to m_CurrentColorCoding
     void UpdateColorCoding();
 
 private:
 
     // actual fiber container
     vtkSmartPointer<vtkPolyData>  m_FiberPolyData;
 
     // contains fiber ids
     vtkSmartPointer<vtkDataSet>   m_FiberIdDataSet;
 
     char* m_CurrentColorCoding;
     int   m_NumFibers;
 
     std::vector< float > m_FiberLengths;
     float   m_MinFiberLength;
     float   m_MaxFiberLength;
     float   m_MeanFiberLength;
     float   m_MedianFiberLength;
     float   m_LengthStDev;
     int     m_FiberSampling;
     itk::TimeStamp m_UpdateTime2D;
     itk::TimeStamp m_UpdateTime3D;
     mitk::BaseGeometry::Pointer m_ReferenceGeometry;
 };
 
 } // namespace mitk
 
 #endif /*  _MITK_FiberBundleX_H */
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberfoxParameters.cpp b/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberfoxParameters.cpp
index f4db8d7de5..c10eec78d6 100644
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberfoxParameters.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberfoxParameters.cpp
@@ -1,723 +1,723 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include <boost/property_tree/ptree.hpp>
 #include <boost/property_tree/xml_parser.hpp>
 #include <boost/foreach.hpp>
 #include <boost/lexical_cast.hpp>
 
 #include <itkImageFileWriter.h>
 #include <itkImageFileReader.h>
 
 template< class ScalarType >
 mitk::FiberfoxParameters< ScalarType >::FiberfoxParameters()
     : m_NoiseModel(NULL)
 {
 
 }
 
 template< class ScalarType >
 mitk::FiberfoxParameters< ScalarType >::~FiberfoxParameters()
 {
     //    if (m_NoiseModel!=NULL)
     //        delete m_NoiseModel;
 }
 
 void mitk::SignalGenerationParameters::GenerateGradientHalfShell()
 {
     int NPoints = 2*m_NumGradients;
     m_GradientDirections.clear();
 
     m_NumBaseline = NPoints/20;
     if (m_NumBaseline==0)
         m_NumBaseline=1;
 
     GradientType g;
     g.Fill(0.0);
     for (unsigned int i=0; i<m_NumBaseline; i++)
         m_GradientDirections.push_back(g);
 
     if (NPoints==0)
         return;
 
     vnl_vector<double> theta; theta.set_size(NPoints);
     vnl_vector<double> phi; phi.set_size(NPoints);
     double C = sqrt(4*M_PI);
     phi(0) = 0.0;
     phi(NPoints-1) = 0.0;
     for(int i=0; i<NPoints; i++)
     {
         theta(i) = acos(-1.0+2.0*i/(NPoints-1.0)) - M_PI / 2.0;
         if( i>0 && i<NPoints-1)
         {
             phi(i) = (phi(i-1) + C /
                       sqrt(NPoints*(1-(-1.0+2.0*i/(NPoints-1.0))*(-1.0+2.0*i/(NPoints-1.0)))));
         }
     }
 
     for(int i=0; i<NPoints; i++)
     {
         g[2] = sin(theta(i));
         if (g[2]<0)
             continue;
         g[0] = cos(theta(i)) * cos(phi(i));
         g[1] = cos(theta(i)) * sin(phi(i));
         m_GradientDirections.push_back(g);
     }
 }
 
 std::vector< int > mitk::SignalGenerationParameters::GetBaselineIndices()
 {
     std::vector< int > result;
     for( unsigned int i=0; i<this->m_GradientDirections.size(); i++)
         if (m_GradientDirections.at(i).GetNorm()<0.0001)
             result.push_back(i);
     return result;
 }
 
 unsigned int mitk::SignalGenerationParameters::GetFirstBaselineIndex()
 {
     for( unsigned int i=0; i<this->m_GradientDirections.size(); i++)
         if (m_GradientDirections.at(i).GetNorm()<0.0001)
             return i;
     return -1;
 }
 
 bool mitk::SignalGenerationParameters::IsBaselineIndex(unsigned int idx)
 {
     if (m_GradientDirections.size()>idx && m_GradientDirections.at(idx).GetNorm()<0.0001)
         return true;
     return false;
 }
 
 unsigned int mitk::SignalGenerationParameters::GetNumWeightedVolumes()
 {
     return m_NumGradients;
 }
 
 unsigned int mitk::SignalGenerationParameters::GetNumBaselineVolumes()
 {
     return m_NumBaseline;
 }
 
 unsigned int mitk::SignalGenerationParameters::GetNumVolumes()
 {
     return m_GradientDirections.size();
 }
 
 mitk::SignalGenerationParameters::GradientListType mitk::SignalGenerationParameters::GetGradientDirections()
 {
     return m_GradientDirections;
 }
 
 mitk::SignalGenerationParameters::GradientType mitk::SignalGenerationParameters::GetGradientDirection(unsigned int i)
 {
     return m_GradientDirections.at(i);
 }
 
 void mitk::SignalGenerationParameters::SetNumWeightedVolumes(int numGradients)
 {
     m_NumGradients = numGradients;
     GenerateGradientHalfShell();
 }
 
 void mitk::SignalGenerationParameters::SetGradienDirections(GradientListType gradientList)
 {
     m_GradientDirections = gradientList;
     m_NumGradients = 0;
     m_NumBaseline = 0;
     for( unsigned int i=0; i<this->m_GradientDirections.size(); i++)
     {
         if (m_GradientDirections.at(i).GetNorm()>0.0001)
             m_NumGradients++;
         else
             m_NumBaseline++;
     }
 }
 
-void mitk::SignalGenerationParameters::SetGradienDirections(mitk::DiffusionImage<short>::GradientDirectionContainerType::Pointer gradientList)
+void mitk::SignalGenerationParameters::SetGradienDirections(mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer gradientList)
 {
     m_NumGradients = 0;
     m_NumBaseline = 0;
     m_GradientDirections.clear();
 
     for( unsigned int i=0; i<gradientList->Size(); i++)
     {
         GradientType g;
         g[0] = gradientList->at(i)[0];
         g[1] = gradientList->at(i)[1];
         g[2] = gradientList->at(i)[2];
         m_GradientDirections.push_back(g);
 
         if (m_GradientDirections.at(i).GetNorm()>0.0001)
             m_NumGradients++;
         else
             m_NumBaseline++;
     }
 }
 
 template< class ScalarType >
 void mitk::FiberfoxParameters< ScalarType >::SaveParameters(string filename)
 {
     if(filename.empty())
         return;
     if(".ffp"!=filename.substr(filename.size()-4, 4))
         filename += ".ffp";
 
     const std::string& locale = "C";
     const std::string& currLocale = setlocale( LC_ALL, NULL );
 
     if ( locale.compare(currLocale)!=0 )
     {
       try
       {
         setlocale(LC_ALL, locale.c_str());
       }
       catch(...)
       {
         MITK_INFO << "Could not set locale " << locale;
       }
     }
 
     boost::property_tree::ptree parameters;
 
     // fiber generation parameters
     parameters.put("fiberfox.fibers.distribution", m_FiberGen.m_Distribution);
     parameters.put("fiberfox.fibers.variance", m_FiberGen.m_Variance);
     parameters.put("fiberfox.fibers.density", m_FiberGen.m_Density);
     parameters.put("fiberfox.fibers.spline.sampling", m_FiberGen.m_Sampling);
     parameters.put("fiberfox.fibers.spline.tension", m_FiberGen.m_Tension);
     parameters.put("fiberfox.fibers.spline.continuity", m_FiberGen.m_Continuity);
     parameters.put("fiberfox.fibers.spline.bias", m_FiberGen.m_Bias);
     parameters.put("fiberfox.fibers.rotation.x", m_FiberGen.m_Rotation[0]);
     parameters.put("fiberfox.fibers.rotation.y", m_FiberGen.m_Rotation[1]);
     parameters.put("fiberfox.fibers.rotation.z", m_FiberGen.m_Rotation[2]);
     parameters.put("fiberfox.fibers.translation.x", m_FiberGen.m_Translation[0]);
     parameters.put("fiberfox.fibers.translation.y", m_FiberGen.m_Translation[1]);
     parameters.put("fiberfox.fibers.translation.z", m_FiberGen.m_Translation[2]);
     parameters.put("fiberfox.fibers.scale.x", m_FiberGen.m_Scale[0]);
     parameters.put("fiberfox.fibers.scale.y", m_FiberGen.m_Scale[1]);
     parameters.put("fiberfox.fibers.scale.z", m_FiberGen.m_Scale[2]);
 
     // image generation parameters
     parameters.put("fiberfox.image.basic.size.x", m_SignalGen.m_ImageRegion.GetSize(0));
     parameters.put("fiberfox.image.basic.size.y", m_SignalGen.m_ImageRegion.GetSize(1));
     parameters.put("fiberfox.image.basic.size.z", m_SignalGen.m_ImageRegion.GetSize(2));
     parameters.put("fiberfox.image.basic.spacing.x", m_SignalGen.m_ImageSpacing[0]);
     parameters.put("fiberfox.image.basic.spacing.y", m_SignalGen.m_ImageSpacing[1]);
     parameters.put("fiberfox.image.basic.spacing.z", m_SignalGen.m_ImageSpacing[2]);
     parameters.put("fiberfox.image.basic.origin.x", m_SignalGen.m_ImageOrigin[0]);
     parameters.put("fiberfox.image.basic.origin.y", m_SignalGen.m_ImageOrigin[1]);
     parameters.put("fiberfox.image.basic.origin.z", m_SignalGen.m_ImageOrigin[2]);
     parameters.put("fiberfox.image.basic.direction.1", m_SignalGen.m_ImageDirection[0][0]);
     parameters.put("fiberfox.image.basic.direction.2", m_SignalGen.m_ImageDirection[0][1]);
     parameters.put("fiberfox.image.basic.direction.3", m_SignalGen.m_ImageDirection[0][2]);
     parameters.put("fiberfox.image.basic.direction.4", m_SignalGen.m_ImageDirection[1][0]);
     parameters.put("fiberfox.image.basic.direction.5", m_SignalGen.m_ImageDirection[1][1]);
     parameters.put("fiberfox.image.basic.direction.6", m_SignalGen.m_ImageDirection[1][2]);
     parameters.put("fiberfox.image.basic.direction.7", m_SignalGen.m_ImageDirection[2][0]);
     parameters.put("fiberfox.image.basic.direction.8", m_SignalGen.m_ImageDirection[2][1]);
     parameters.put("fiberfox.image.basic.direction.9", m_SignalGen.m_ImageDirection[2][2]);
     parameters.put("fiberfox.image.basic.numgradients", m_SignalGen.GetNumWeightedVolumes());
     for( unsigned int i=0; i<this->m_SignalGen.GetNumVolumes(); i++)
     {
         parameters.put("fiberfox.image.gradients."+boost::lexical_cast<string>(i)+".x", m_SignalGen.GetGradientDirection(i)[0]);
         parameters.put("fiberfox.image.gradients."+boost::lexical_cast<string>(i)+".y", m_SignalGen.GetGradientDirection(i)[1]);
         parameters.put("fiberfox.image.gradients."+boost::lexical_cast<string>(i)+".z", m_SignalGen.GetGradientDirection(i)[2]);
     }
 
     parameters.put("fiberfox.image.signalScale", m_SignalGen.m_SignalScale);
     parameters.put("fiberfox.image.tEcho", m_SignalGen.m_tEcho);
     parameters.put("fiberfox.image.tLine", m_SignalGen.m_tLine);
     parameters.put("fiberfox.image.tInhom", m_SignalGen.m_tInhom);
     parameters.put("fiberfox.image.bvalue", m_SignalGen.m_Bvalue);
     parameters.put("fiberfox.image.simulatekspace", m_SignalGen.m_SimulateKspaceAcquisition);
     parameters.put("fiberfox.image.axonRadius", m_SignalGen.m_AxonRadius);
     parameters.put("fiberfox.image.diffusiondirectionmode", m_SignalGen.m_DiffusionDirectionMode);
     parameters.put("fiberfox.image.fiberseparationthreshold", m_SignalGen.m_FiberSeparationThreshold);
     parameters.put("fiberfox.image.doSimulateRelaxation", m_SignalGen.m_DoSimulateRelaxation);
     parameters.put("fiberfox.image.doDisablePartialVolume", m_SignalGen.m_DoDisablePartialVolume);
     parameters.put("fiberfox.image.artifacts.spikesnum", m_SignalGen.m_Spikes);
     parameters.put("fiberfox.image.artifacts.spikesscale", m_SignalGen.m_SpikeAmplitude);
     parameters.put("fiberfox.image.artifacts.kspaceLineOffset", m_SignalGen.m_KspaceLineOffset);
     parameters.put("fiberfox.image.artifacts.eddyStrength", m_SignalGen.m_EddyStrength);
     parameters.put("fiberfox.image.artifacts.eddyTau", m_SignalGen.m_Tau);
     parameters.put("fiberfox.image.artifacts.aliasingfactor", m_SignalGen.m_CroppingFactor);
     parameters.put("fiberfox.image.artifacts.addringing", m_SignalGen.m_DoAddGibbsRinging);
     parameters.put("fiberfox.image.artifacts.doAddMotion", m_SignalGen.m_DoAddMotion);
     parameters.put("fiberfox.image.artifacts.randomMotion", m_SignalGen.m_DoRandomizeMotion);
     parameters.put("fiberfox.image.artifacts.translation0", m_SignalGen.m_Translation[0]);
     parameters.put("fiberfox.image.artifacts.translation1", m_SignalGen.m_Translation[1]);
     parameters.put("fiberfox.image.artifacts.translation2", m_SignalGen.m_Translation[2]);
     parameters.put("fiberfox.image.artifacts.rotation0", m_SignalGen.m_Rotation[0]);
     parameters.put("fiberfox.image.artifacts.rotation1", m_SignalGen.m_Rotation[1]);
     parameters.put("fiberfox.image.artifacts.rotation2", m_SignalGen.m_Rotation[2]);
 
     parameters.put("fiberfox.image.artifacts.addnoise", m_Misc.m_CheckAddNoiseBox);
     parameters.put("fiberfox.image.artifacts.addghosts", m_Misc.m_CheckAddGhostsBox);
     parameters.put("fiberfox.image.artifacts.addaliasing", m_Misc.m_CheckAddAliasingBox);
     parameters.put("fiberfox.image.artifacts.addspikes", m_Misc.m_CheckAddSpikesBox);
     parameters.put("fiberfox.image.artifacts.addeddycurrents", m_Misc.m_CheckAddEddyCurrentsBox);
     parameters.put("fiberfox.image.artifacts.doAddDistortions", m_Misc.m_CheckAddDistortionsBox);
     parameters.put("fiberfox.image.outputvolumefractions", m_Misc.m_CheckOutputVolumeFractionsBox);
     parameters.put("fiberfox.image.showadvanced", m_Misc.m_CheckAdvancedSignalOptionsBox);
     parameters.put("fiberfox.image.signalmodelstring", m_Misc.m_SignalModelString);
     parameters.put("fiberfox.image.artifactmodelstring", m_Misc.m_ArtifactModelString);
     parameters.put("fiberfox.image.outpath", m_Misc.m_OutputPath);
     parameters.put("fiberfox.fibers.realtime", m_Misc.m_CheckRealTimeFibersBox);
     parameters.put("fiberfox.fibers.showadvanced", m_Misc.m_CheckAdvancedFiberOptionsBox);
     parameters.put("fiberfox.fibers.constantradius", m_Misc.m_CheckConstantRadiusBox);
     parameters.put("fiberfox.fibers.includeFiducials", m_Misc.m_CheckIncludeFiducialsBox);
 
     if (m_NoiseModel!=NULL)
     {
         parameters.put("fiberfox.image.artifacts.noisevariance", m_NoiseModel->GetNoiseVariance());
         if (dynamic_cast<mitk::RicianNoiseModel<ScalarType>*>(m_NoiseModel))
             parameters.put("fiberfox.image.artifacts.noisetype", "rice");
         else if (dynamic_cast<mitk::ChiSquareNoiseModel<ScalarType>*>(m_NoiseModel))
             parameters.put("fiberfox.image.artifacts.noisetype", "chisquare");
     }
 
     for (int i=0; i<m_FiberModelList.size()+m_NonFiberModelList.size(); i++)
     {
         mitk::DiffusionSignalModel<ScalarType>* signalModel = NULL;
         if (i<m_FiberModelList.size())
         {
             signalModel = m_FiberModelList.at(i);
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".type", "fiber");
         }
         else
         {
             signalModel = m_NonFiberModelList.at(i-m_FiberModelList.size());
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".type", "non-fiber");
         }
 
         if (dynamic_cast<mitk::StickModel<ScalarType>*>(signalModel))
         {
             mitk::StickModel<ScalarType>* model = dynamic_cast<mitk::StickModel<ScalarType>*>(signalModel);
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".model", "stick");
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".d", model->GetDiffusivity());
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".t2", model->GetT2());
         }
         else  if (dynamic_cast<mitk::TensorModel<ScalarType>*>(signalModel))
         {
             mitk::TensorModel<ScalarType>* model = dynamic_cast<mitk::TensorModel<ScalarType>*>(signalModel);
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".model", "tensor");
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".d1", model->GetDiffusivity1());
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".d2", model->GetDiffusivity2());
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".d3", model->GetDiffusivity3());
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".t2", model->GetT2());
         }
         else  if (dynamic_cast<mitk::RawShModel<ScalarType>*>(signalModel))
         {
             mitk::RawShModel<ScalarType>* model = dynamic_cast<mitk::RawShModel<ScalarType>*>(signalModel);
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".model", "prototype");
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".minFA", model->GetFaRange().first);
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".maxFA", model->GetFaRange().second);
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".minADC", model->GetAdcRange().first);
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".maxADC", model->GetAdcRange().second);
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".maxNumSamples", model->GetMaxNumKernels());
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".numSamples", model->GetNumberOfKernels());
             int shOrder = model->GetShOrder();
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".numCoeffs", (shOrder*shOrder + shOrder + 2)/2 + shOrder);
 
             for (unsigned int j=0; j<model->GetNumberOfKernels(); j++)
             {
                 vnl_vector< double > coeffs = model->GetCoefficients(j);
                 for (unsigned int k=0; k<coeffs.size(); k++)
                     parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".kernels."+boost::lexical_cast<string>(j)+".coeffs."+boost::lexical_cast<string>(k), coeffs[k]);
                 parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".kernels."+boost::lexical_cast<string>(j)+".B0", model->GetBaselineSignal(j));
             }
         }
         else  if (dynamic_cast<mitk::BallModel<ScalarType>*>(signalModel))
         {
             mitk::BallModel<ScalarType>* model = dynamic_cast<mitk::BallModel<ScalarType>*>(signalModel);
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".model", "ball");
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".d", model->GetDiffusivity());
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".t2", model->GetT2());
         }
         else  if (dynamic_cast<mitk::AstroStickModel<ScalarType>*>(signalModel))
         {
             mitk::AstroStickModel<ScalarType>* model = dynamic_cast<mitk::AstroStickModel<ScalarType>*>(signalModel);
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".model", "astrosticks");
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".d", model->GetDiffusivity());
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".t2", model->GetT2());
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".randomize", model->GetRandomizeSticks());
         }
         else  if (dynamic_cast<mitk::DotModel<ScalarType>*>(signalModel))
         {
             mitk::DotModel<ScalarType>* model = dynamic_cast<mitk::DotModel<ScalarType>*>(signalModel);
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".model", "dot");
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".t2", model->GetT2());
         }
 
         if (signalModel!=NULL)
         {
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".ID", signalModel->m_CompartmentId);
 
             if (signalModel->GetVolumeFractionImage().IsNotNull())
             {
                 try{
                     itk::ImageFileWriter<ItkDoubleImgType>::Pointer writer = itk::ImageFileWriter<ItkDoubleImgType>::New();
                     writer->SetFileName(filename+"_VOLUME"+boost::lexical_cast<string>(signalModel->m_CompartmentId)+".nrrd");
                     writer->SetInput(signalModel->GetVolumeFractionImage());
                     writer->Update();
                     MITK_INFO << "Volume fraction image for compartment "+boost::lexical_cast<string>(signalModel->m_CompartmentId)+" saved.";
                 }
                 catch(...)
                 {
                 }
             }
         }
     }
 
     boost::property_tree::xml_writer_settings<std::string> writerSettings(' ', 2);
     boost::property_tree::xml_parser::write_xml(filename, parameters, std::locale(), writerSettings);
 
     try{
         itk::ImageFileWriter<ItkDoubleImgType>::Pointer writer = itk::ImageFileWriter<ItkDoubleImgType>::New();
         writer->SetFileName(filename+"_FMAP.nrrd");
         writer->SetInput(m_SignalGen.m_FrequencyMap);
         writer->Update();
     }
     catch(...)
     {
         MITK_INFO << "No frequency map saved.";
     }
     try{
         itk::ImageFileWriter<ItkUcharImgType>::Pointer writer = itk::ImageFileWriter<ItkUcharImgType>::New();
         writer->SetFileName(filename+"_MASK.nrrd");
         writer->SetInput(m_SignalGen.m_MaskImage);
         writer->Update();
     }
     catch(...)
     {
         MITK_INFO << "No mask image saved.";
     }
 
     setlocale(LC_ALL, currLocale.c_str());
 }
 
 template< class ScalarType >
 void mitk::FiberfoxParameters< ScalarType >::LoadParameters(string filename)
 {
     if(filename.empty())
         return;
 
     const std::string& locale = "C";
     const std::string& currLocale = setlocale( LC_ALL, NULL );
 
     if ( locale.compare(currLocale)!=0 )
     {
       try
       {
         setlocale(LC_ALL, locale.c_str());
       }
       catch(...)
       {
         MITK_INFO << "Could not set locale " << locale;
       }
     }
 
     boost::property_tree::ptree parameterTree;
     boost::property_tree::xml_parser::read_xml(filename, parameterTree);
 
     m_FiberModelList.clear();
     m_NonFiberModelList.clear();
     if (m_NoiseModel!=NULL)
         delete m_NoiseModel;
 
     BOOST_FOREACH( boost::property_tree::ptree::value_type const& v1, parameterTree.get_child("fiberfox") )
     {
         if( v1.first == "fibers" )
         {
             m_Misc.m_CheckRealTimeFibersBox = v1.second.get<bool>("realtime", m_Misc.m_CheckRealTimeFibersBox);
             m_Misc.m_CheckAdvancedFiberOptionsBox = v1.second.get<bool>("showadvanced", m_Misc.m_CheckAdvancedFiberOptionsBox);
             m_Misc.m_CheckConstantRadiusBox = v1.second.get<bool>("constantradius", m_Misc.m_CheckConstantRadiusBox);
             m_Misc.m_CheckIncludeFiducialsBox = v1.second.get<bool>("includeFiducials", m_Misc.m_CheckIncludeFiducialsBox);
 
             switch (v1.second.get<unsigned int>("distribution", 0))
             {
             case 0:
                 m_FiberGen.m_Distribution = FiberGenerationParameters::DISTRIBUTE_UNIFORM;
                 break;
             case 1:
                 m_FiberGen.m_Distribution = FiberGenerationParameters::DISTRIBUTE_GAUSSIAN;
                 break;
             default:
                 m_FiberGen.m_Distribution = FiberGenerationParameters::DISTRIBUTE_UNIFORM;
             }
             m_FiberGen.m_Variance = v1.second.get<double>("variance", m_FiberGen.m_Variance);
             m_FiberGen.m_Density = v1.second.get<unsigned int>("density", m_FiberGen.m_Density);
             m_FiberGen.m_Sampling = v1.second.get<double>("spline.sampling", m_FiberGen.m_Sampling);
             m_FiberGen.m_Tension = v1.second.get<double>("spline.tension", m_FiberGen.m_Tension);
             m_FiberGen.m_Continuity = v1.second.get<double>("spline.continuity", m_FiberGen.m_Continuity);
             m_FiberGen.m_Bias = v1.second.get<double>("spline.bias", m_FiberGen.m_Bias);
             m_FiberGen.m_Rotation[0] = v1.second.get<double>("rotation.x", m_FiberGen.m_Rotation[0]);
             m_FiberGen.m_Rotation[1] = v1.second.get<double>("rotation.y", m_FiberGen.m_Rotation[1]);
             m_FiberGen.m_Rotation[2] = v1.second.get<double>("rotation.z", m_FiberGen.m_Rotation[2]);
             m_FiberGen.m_Translation[0] = v1.second.get<double>("translation.x", m_FiberGen.m_Translation[0]);
             m_FiberGen.m_Translation[1] = v1.second.get<double>("translation.y", m_FiberGen.m_Translation[1]);
             m_FiberGen.m_Translation[2] = v1.second.get<double>("translation.z", m_FiberGen.m_Translation[2]);
             m_FiberGen.m_Scale[0] = v1.second.get<double>("scale.x", m_FiberGen.m_Scale[0]);
             m_FiberGen.m_Scale[1] = v1.second.get<double>("scale.y", m_FiberGen.m_Scale[1]);
             m_FiberGen.m_Scale[2] = v1.second.get<double>("scale.z", m_FiberGen.m_Scale[2]);
         }
         else if ( v1.first == "image" )
         {
             m_Misc.m_SignalModelString = v1.second.get<string>("signalmodelstring", m_Misc.m_SignalModelString);
             m_Misc.m_ArtifactModelString = v1.second.get<string>("artifactmodelstring", m_Misc.m_ArtifactModelString);
             m_Misc.m_OutputPath = v1.second.get<string>("outpath", m_Misc.m_OutputPath);
             m_Misc.m_CheckOutputVolumeFractionsBox = v1.second.get<bool>("outputvolumefractions", m_Misc.m_CheckOutputVolumeFractionsBox);
             m_Misc.m_CheckAdvancedSignalOptionsBox = v1.second.get<bool>("showadvanced", m_Misc.m_CheckAdvancedSignalOptionsBox);
             m_Misc.m_CheckAddDistortionsBox = v1.second.get<bool>("artifacts.doAddDistortions", m_Misc.m_CheckAddDistortionsBox);
             m_Misc.m_CheckAddNoiseBox = v1.second.get<bool>("artifacts.addnoise", m_Misc.m_CheckAddNoiseBox);
             m_Misc.m_CheckAddGhostsBox = v1.second.get<bool>("artifacts.addghosts", m_Misc.m_CheckAddGhostsBox);
             m_Misc.m_CheckAddAliasingBox = v1.second.get<bool>("artifacts.addaliasing", m_Misc.m_CheckAddAliasingBox);
             m_Misc.m_CheckAddSpikesBox = v1.second.get<bool>("artifacts.addspikes", m_Misc.m_CheckAddSpikesBox);
             m_Misc.m_CheckAddEddyCurrentsBox = v1.second.get<bool>("artifacts.addeddycurrents", m_Misc.m_CheckAddEddyCurrentsBox);
 
             m_SignalGen.m_ImageRegion.SetSize(0, v1.second.get<int>("basic.size.x",m_SignalGen.m_ImageRegion.GetSize(0)));
             m_SignalGen.m_ImageRegion.SetSize(1, v1.second.get<int>("basic.size.y",m_SignalGen.m_ImageRegion.GetSize(1)));
             m_SignalGen.m_ImageRegion.SetSize(2, v1.second.get<int>("basic.size.z",m_SignalGen.m_ImageRegion.GetSize(2)));
             m_SignalGen.m_ImageSpacing[0] = v1.second.get<double>("basic.spacing.x",m_SignalGen.m_ImageSpacing[0]);
             m_SignalGen.m_ImageSpacing[1] = v1.second.get<double>("basic.spacing.y",m_SignalGen.m_ImageSpacing[1]);
             m_SignalGen.m_ImageSpacing[2] = v1.second.get<double>("basic.spacing.z",m_SignalGen.m_ImageSpacing[2]);
             m_SignalGen.m_ImageOrigin[0] = v1.second.get<double>("basic.origin.x",m_SignalGen.m_ImageOrigin[0]);
             m_SignalGen.m_ImageOrigin[1] = v1.second.get<double>("basic.origin.y",m_SignalGen.m_ImageOrigin[1]);
             m_SignalGen.m_ImageOrigin[2] = v1.second.get<double>("basic.origin.z",m_SignalGen.m_ImageOrigin[2]);
             m_SignalGen.m_ImageDirection[0][0] = v1.second.get<double>("basic.direction.1",m_SignalGen.m_ImageDirection[0][0]);
             m_SignalGen.m_ImageDirection[0][1] = v1.second.get<double>("basic.direction.2",m_SignalGen.m_ImageDirection[0][1]);
             m_SignalGen.m_ImageDirection[0][2] = v1.second.get<double>("basic.direction.3",m_SignalGen.m_ImageDirection[0][2]);
             m_SignalGen.m_ImageDirection[1][0] = v1.second.get<double>("basic.direction.4",m_SignalGen.m_ImageDirection[1][0]);
             m_SignalGen.m_ImageDirection[1][1] = v1.second.get<double>("basic.direction.5",m_SignalGen.m_ImageDirection[1][1]);
             m_SignalGen.m_ImageDirection[1][2] = v1.second.get<double>("basic.direction.6",m_SignalGen.m_ImageDirection[1][2]);
             m_SignalGen.m_ImageDirection[2][0] = v1.second.get<double>("basic.direction.7",m_SignalGen.m_ImageDirection[2][0]);
             m_SignalGen.m_ImageDirection[2][1] = v1.second.get<double>("basic.direction.8",m_SignalGen.m_ImageDirection[2][1]);
             m_SignalGen.m_ImageDirection[2][2] = v1.second.get<double>("basic.direction.9",m_SignalGen.m_ImageDirection[2][2]);
 
             m_SignalGen.m_SignalScale = v1.second.get<double>("signalScale", m_SignalGen.m_SignalScale);
             m_SignalGen.m_tEcho = v1.second.get<double>("tEcho", m_SignalGen.m_tEcho);
             m_SignalGen.m_tLine = v1.second.get<double>("tLine", m_SignalGen.m_tLine);
             m_SignalGen.m_tInhom = v1.second.get<double>("tInhom", m_SignalGen.m_tInhom);
             m_SignalGen.m_Bvalue = v1.second.get<double>("bvalue", m_SignalGen.m_Bvalue);
             m_SignalGen.m_SimulateKspaceAcquisition = v1.second.get<bool>("simulatekspace", m_SignalGen.m_SimulateKspaceAcquisition);
 
             m_SignalGen.m_AxonRadius = v1.second.get<double>("axonRadius", m_SignalGen.m_AxonRadius);
             switch (v1.second.get<int>("diffusiondirectionmode", 0))
             {
             case 0:
                 m_SignalGen.m_DiffusionDirectionMode = SignalGenerationParameters::FIBER_TANGENT_DIRECTIONS;
                 break;
             case 1:
                 m_SignalGen.m_DiffusionDirectionMode = SignalGenerationParameters::MAIN_FIBER_DIRECTIONS;
                 break;
             case 2:
                 m_SignalGen.m_DiffusionDirectionMode = SignalGenerationParameters::RANDOM_DIRECTIONS;
                 break;
             default:
                 m_SignalGen.m_DiffusionDirectionMode = SignalGenerationParameters::FIBER_TANGENT_DIRECTIONS;
             }
             m_SignalGen.m_FiberSeparationThreshold = v1.second.get<double>("fiberseparationthreshold", m_SignalGen.m_FiberSeparationThreshold);
             m_SignalGen.m_Spikes = v1.second.get<unsigned int>("artifacts.spikesnum", m_SignalGen.m_Spikes);
             m_SignalGen.m_SpikeAmplitude = v1.second.get<double>("artifacts.spikesscale", m_SignalGen.m_SpikeAmplitude);
             m_SignalGen.m_KspaceLineOffset = v1.second.get<double>("artifacts.kspaceLineOffset", m_SignalGen.m_KspaceLineOffset);
             m_SignalGen.m_EddyStrength = v1.second.get<double>("artifacts.eddyStrength", m_SignalGen.m_EddyStrength);
             m_SignalGen.m_Tau = v1.second.get<double>("artifacts.eddyTau", m_SignalGen.m_Tau);
             m_SignalGen.m_CroppingFactor = v1.second.get<double>("artifacts.aliasingfactor", m_SignalGen.m_CroppingFactor);
             m_SignalGen.m_DoAddGibbsRinging = v1.second.get<bool>("artifacts.addringing", m_SignalGen.m_DoAddGibbsRinging);
             m_SignalGen.m_DoSimulateRelaxation = v1.second.get<bool>("doSimulateRelaxation", m_SignalGen.m_DoSimulateRelaxation);
             m_SignalGen.m_DoDisablePartialVolume = v1.second.get<bool>("doDisablePartialVolume", m_SignalGen.m_DoDisablePartialVolume);
             m_SignalGen.m_DoAddMotion = v1.second.get<bool>("artifacts.doAddMotion", m_SignalGen.m_DoAddMotion);
             m_SignalGen.m_DoRandomizeMotion = v1.second.get<bool>("artifacts.randomMotion", m_SignalGen.m_DoRandomizeMotion);
             m_SignalGen.m_Translation[0] = v1.second.get<double>("artifacts.translation0", m_SignalGen.m_Translation[0]);
             m_SignalGen.m_Translation[1] = v1.second.get<double>("artifacts.translation1", m_SignalGen.m_Translation[1]);
             m_SignalGen.m_Translation[2] = v1.second.get<double>("artifacts.translation2", m_SignalGen.m_Translation[2]);
             m_SignalGen.m_Rotation[0] = v1.second.get<double>("artifacts.rotation0", m_SignalGen.m_Rotation[0]);
             m_SignalGen.m_Rotation[1] = v1.second.get<double>("artifacts.rotation1", m_SignalGen.m_Rotation[1]);
             m_SignalGen.m_Rotation[2] = v1.second.get<double>("artifacts.rotation2", m_SignalGen.m_Rotation[2]);
 //            m_SignalGen.SetNumWeightedVolumes(v1.second.get<unsigned int>("numgradients", m_SignalGen.GetNumWeightedVolumes()));
             SignalGenerationParameters::GradientListType gradients;
             BOOST_FOREACH( boost::property_tree::ptree::value_type const& v2, v1.second.get_child("gradients") )
             {
                 SignalGenerationParameters::GradientType g;
                 g[0] = v2.second.get<double>("x");
                 g[1] = v2.second.get<double>("y");
                 g[2] = v2.second.get<double>("z");
                 gradients.push_back(g);
             }
             m_SignalGen.SetGradienDirections(gradients);
 
             try
             {
                 if (v1.second.get<string>("artifacts.noisetype")=="rice")
                 {
                     m_NoiseModel = new mitk::RicianNoiseModel<ScalarType>();
                     m_NoiseModel->SetNoiseVariance(v1.second.get<double>("artifacts.noisevariance"));
                 }
             }
             catch(...) {}
             try
             {
                 if (v1.second.get<string>("artifacts.noisetype")=="chisquare")
                 {
                     m_NoiseModel = new mitk::ChiSquareNoiseModel<ScalarType>();
                     m_NoiseModel->SetNoiseVariance(v1.second.get<double>("artifacts.noisevariance"));
                 }
             }
             catch(...){ }
 
             BOOST_FOREACH( boost::property_tree::ptree::value_type const& v2, v1.second.get_child("compartments") )
             {
                 mitk::DiffusionSignalModel<ScalarType>* signalModel = NULL;
 
                 std::string model = v2.second.get<string>("model");
                 if (model=="stick")
                 {
                     mitk::StickModel<ScalarType>* model = new mitk::StickModel<ScalarType>();
                     model->SetDiffusivity(v2.second.get<double>("d"));
                     model->SetT2(v2.second.get<double>("t2"));
                     model->m_CompartmentId = v2.second.get<unsigned int>("ID");
                     if (v2.second.get<string>("type")=="fiber")
                         m_FiberModelList.push_back(model);
                     else if (v2.second.get<string>("type")=="non-fiber")
                         m_NonFiberModelList.push_back(model);
                     signalModel = model;
                 }
                 else if (model=="tensor")
                 {
                     mitk::TensorModel<ScalarType>* model = new mitk::TensorModel<ScalarType>();
                     model->SetDiffusivity1(v2.second.get<double>("d1"));
                     model->SetDiffusivity2(v2.second.get<double>("d2"));
                     model->SetDiffusivity3(v2.second.get<double>("d3"));
                     model->SetT2(v2.second.get<double>("t2"));
                     model->m_CompartmentId = v2.second.get<unsigned int>("ID");
                     if (v2.second.get<string>("type")=="fiber")
                         m_FiberModelList.push_back(model);
                     else if (v2.second.get<string>("type")=="non-fiber")
                         m_NonFiberModelList.push_back(model);
                     signalModel = model;
                 }
                 else if (model=="ball")
                 {
                     mitk::BallModel<ScalarType>* model = new mitk::BallModel<ScalarType>();
                     model->SetDiffusivity(v2.second.get<double>("d"));
                     model->SetT2(v2.second.get<double>("t2"));
                     model->m_CompartmentId = v2.second.get<unsigned int>("ID");
                     if (v2.second.get<string>("type")=="fiber")
                         m_FiberModelList.push_back(model);
                     else if (v2.second.get<string>("type")=="non-fiber")
                         m_NonFiberModelList.push_back(model);
                     signalModel = model;
                 }
                 else if (model=="astrosticks")
                 {
                     mitk::AstroStickModel<ScalarType>* model = new AstroStickModel<ScalarType>();
                     model->SetDiffusivity(v2.second.get<double>("d"));
                     model->SetT2(v2.second.get<double>("t2"));
                     model->SetRandomizeSticks(v2.second.get<bool>("randomize"));
                     model->m_CompartmentId = v2.second.get<unsigned int>("ID");
                     if (v2.second.get<string>("type")=="fiber")
                         m_FiberModelList.push_back(model);
                     else if (v2.second.get<string>("type")=="non-fiber")
                         m_NonFiberModelList.push_back(model);
                     signalModel = model;
                 }
                 else if (model=="dot")
                 {
                     mitk::DotModel<ScalarType>* model = new mitk::DotModel<ScalarType>();
                     model->SetT2(v2.second.get<double>("t2"));
                     model->m_CompartmentId = v2.second.get<unsigned int>("ID");
                     if (v2.second.get<string>("type")=="fiber")
                         m_FiberModelList.push_back(model);
                     else if (v2.second.get<string>("type")=="non-fiber")
                         m_NonFiberModelList.push_back(model);
                     signalModel = model;
                 }
                 else if (model=="prototype")
                 {
                     mitk::RawShModel<ScalarType>* model = new mitk::RawShModel<ScalarType>();
                     model->SetMaxNumKernels(v2.second.get<unsigned int>("maxNumSamples"));
                     model->SetFaRange(v2.second.get<double>("minFA"), v2.second.get<double>("maxFA"));
                     model->SetAdcRange(v2.second.get<double>("minADC"), v2.second.get<double>("maxADC"));
                     model->m_CompartmentId = v2.second.get<unsigned int>("ID");
                     unsigned int numCoeffs = v2.second.get<unsigned int>("numCoeffs");
                     unsigned int numSamples = v2.second.get<unsigned int>("numSamples");
 
                     for (unsigned int j=0; j<numSamples; j++)
                     {
                         vnl_vector< double > coeffs(numCoeffs);
                         for (unsigned int k=0; k<numCoeffs; k++)
                         {
                             coeffs[k] = v2.second.get<double>("kernels."+boost::lexical_cast<string>(j)+".coeffs."+boost::lexical_cast<string>(k));
                         }
                         model->SetShCoefficients( coeffs, v2.second.get<double>("kernels."+boost::lexical_cast<string>(j)+".B0") );
                     }
 
                     if (v2.second.get<string>("type")=="fiber")
                         m_FiberModelList.push_back(model);
                     else if (v2.second.get<string>("type")=="non-fiber")
                         m_NonFiberModelList.push_back(model);
                     signalModel = model;
                 }
 
                 if (signalModel!=NULL)
                 {
                     signalModel->SetGradientList(gradients);
                     try{
                         itk::ImageFileReader<ItkDoubleImgType>::Pointer reader = itk::ImageFileReader<ItkDoubleImgType>::New();
                         reader->SetFileName(filename+"_VOLUME"+v2.second.get<string>("ID")+".nrrd");
                         reader->Update();
                         signalModel->SetVolumeFractionImage(reader->GetOutput());
                     }
                     catch(...)
                     {
                     }
                 }
             }
         }
     }
 
     try{
         itk::ImageFileReader<ItkDoubleImgType>::Pointer reader = itk::ImageFileReader<ItkDoubleImgType>::New();
         reader->SetFileName(filename+"_FMAP.nrrd");
         reader->Update();
         m_SignalGen.m_FrequencyMap = reader->GetOutput();
     }
     catch(...)
     {
         MITK_INFO << "No frequency map saved.";
     }
 
     try{
         itk::ImageFileReader<ItkUcharImgType>::Pointer reader = itk::ImageFileReader<ItkUcharImgType>::New();
         reader->SetFileName(filename+"_MASK.nrrd");
         reader->Update();
         m_SignalGen.m_MaskImage = reader->GetOutput();
     }
     catch(...)
     {
         MITK_INFO << "No mask image saved.";
     }
 
     setlocale(LC_ALL, currLocale.c_str());
 }
 
 template< class ScalarType >
 void mitk::FiberfoxParameters< ScalarType >::PrintSelf()
 {
     MITK_INFO << "Not implemented :(";
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberfoxParameters.h b/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberfoxParameters.h
index 05370fdaac..e90e50c591 100644
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberfoxParameters.h
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberfoxParameters.h
@@ -1,321 +1,321 @@
 /*===================================================================
 
 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 _MITK_FiberfoxParameters_H
 #define _MITK_FiberfoxParameters_H
 
 #include <itkImageRegion.h>
 #include <itkMatrix.h>
 #include <mitkDiffusionNoiseModel.h>
 #include <mitkDiffusionSignalModel.h>
 #include <mitkDataNode.h>
 #include <mitkRicianNoiseModel.h>
 #include <mitkChiSquareNoiseModel.h>
-#include <mitkDiffusionImage.h>
+#include <mitkImage.h>
+#include <mitkDiffusionPropertyHelper.h>
 #include <mitkPlanarEllipse.h>
-
 #include <mitkStickModel.h>
 #include <mitkTensorModel.h>
 #include <mitkAstroStickModel.h>
 #include <mitkBallModel.h>
 #include <mitkDotModel.h>
 #include <mitkRawShModel.h>
 
 using namespace std;
 
 namespace mitk {
 
 /** Signal generation */
 class SignalGenerationParameters
 {
 public:
     typedef itk::Image<double, 3>                   ItkDoubleImgType;
     typedef itk::Image<unsigned char, 3>            ItkUcharImgType;
     typedef itk::Vector<double,3>                   GradientType;
     typedef std::vector<GradientType>               GradientListType;
 
     enum DiffusionDirectionMode {
         FIBER_TANGENT_DIRECTIONS,
         MAIN_FIBER_DIRECTIONS,
         RANDOM_DIRECTIONS
     };
 
     SignalGenerationParameters()
         : m_SignalScale(100)
         , m_tEcho(100)
         , m_tLine(1)
         , m_tInhom(50)
         , m_Bvalue(1000)
         , m_SimulateKspaceAcquisition(false)
         , m_AxonRadius(0)
         , m_DoDisablePartialVolume(false)
         , m_DiffusionDirectionMode(SignalGenerationParameters::FIBER_TANGENT_DIRECTIONS)
         , m_FiberSeparationThreshold(30)
         , m_Spikes(0)
         , m_SpikeAmplitude(1)
         , m_KspaceLineOffset(0)
         , m_EddyStrength(0)
         , m_Tau(70)
         , m_CroppingFactor(1)
         , m_DoAddGibbsRinging(false)
         , m_DoSimulateRelaxation(true)
         , m_DoAddMotion(false)
         , m_DoRandomizeMotion(true)
         , m_FrequencyMap(NULL)
         , m_MaskImage(NULL)
     {
         m_ImageRegion.SetSize(0, 12);
         m_ImageRegion.SetSize(1, 12);
         m_ImageRegion.SetSize(2, 3);
         m_ImageSpacing.Fill(2.0);
         m_ImageOrigin.Fill(0.0);
         m_ImageDirection.SetIdentity();
         m_Translation.Fill(0.0);
         m_Rotation.Fill(0.0);
         SetNumWeightedVolumes(6);
     }
 
     /** input/output image specifications */
     itk::ImageRegion<3>                 m_ImageRegion;              ///< Image size.
     itk::Vector<double,3>               m_ImageSpacing;             ///< Image voxel size.
     itk::Point<double,3>                m_ImageOrigin;              ///< Image origin.
     itk::Matrix<double, 3, 3>           m_ImageDirection;           ///< Image rotation matrix.
 
     /** Other acquisitions parameters */
     double                              m_SignalScale;              ///< Scaling factor for output signal (before noise is added).
     double                              m_tEcho;                    ///< Echo time TE.
     double                              m_tLine;                    ///< k-space line readout time.
     double                              m_tInhom;                   ///< T2'
     double                              m_Bvalue;                   ///< Acquisition b-value
     bool                                m_SimulateKspaceAcquisition;///< Flag to enable/disable k-space acquisition simulation
     double                              m_AxonRadius;               ///< Determines compartment volume fractions (0 == automatic axon radius estimation)
     bool                                m_DoDisablePartialVolume;   ///< Disable partial volume effects. Each voxel is either all fiber or all non-fiber.
     DiffusionDirectionMode              m_DiffusionDirectionMode;   ///< Determines how the main diffusion direction of the signal models is selected
     double                              m_FiberSeparationThreshold; ///< Used for random and and mein fiber deriction DiffusionDirectionMode
 
     /** Artifacts and other effects */
     unsigned int                        m_Spikes;                   ///< Number of spikes randomly appearing in the image
     double                              m_SpikeAmplitude;           ///< amplitude of spikes relative to the largest signal intensity (magnitude of complex)
     double                              m_KspaceLineOffset;         ///< Causes N/2 ghosts. Larger offset means stronger ghost.
     double                              m_EddyStrength;             ///< Strength of eddy current induced gradients in mT/m.
     double                              m_Tau;                      ///< Eddy current decay constant (in ms)
     double                              m_CroppingFactor;           ///< FOV size in y-direction is multiplied by this factor. Causes aliasing artifacts.
     bool                                m_DoAddGibbsRinging;        ///< Add Gibbs ringing artifact
     bool                                m_DoSimulateRelaxation;     ///< Add T2 relaxation effects
     bool                                m_DoAddMotion;              ///< Enable motion artifacts.
     bool                                m_DoRandomizeMotion;        ///< Toggles between random and linear motion.
     itk::Vector<double,3>               m_Translation;              ///< Maximum translational motion.
     itk::Vector<double,3>               m_Rotation;                 ///< Maximum rotational motion.
     ItkDoubleImgType::Pointer           m_FrequencyMap;             ///< If != NULL, distortions are added to the image using this frequency map.
     ItkUcharImgType::Pointer            m_MaskImage;                ///< Signal is only genrated inside of the mask image.
 
     inline void GenerateGradientHalfShell();                        ///< Generates half shell of gradient directions (with m_NumGradients non-zero directions)
     inline std::vector< int > GetBaselineIndices();                 ///< Returns list of nun-diffusion-weighted image volume indices
     inline unsigned int GetFirstBaselineIndex();                    ///< Returns index of first non-diffusion-weighted image volume
     inline bool IsBaselineIndex(unsigned int idx);                  ///< Checks if image volume with given index is non-diffusion-weighted volume or not.
     inline unsigned int GetNumWeightedVolumes();                    ///< Get number of diffusion-weighted image volumes
     inline unsigned int GetNumBaselineVolumes();                    ///< Get number of non-diffusion-weighted image volumes
     inline unsigned int GetNumVolumes();                            ///< Get number of baseline and diffusion-weighted image volumes
     inline GradientListType GetGradientDirections();                ///< Return gradient direction container
     inline GradientType GetGradientDirection(unsigned int i);
 
     inline void SetNumWeightedVolumes(int numGradients);            ///< Automaticall calls GenerateGradientHalfShell() afterwards.
     inline void SetGradienDirections(GradientListType gradientList);
-    inline void SetGradienDirections(mitk::DiffusionImage<short>::GradientDirectionContainerType::Pointer gradientList);
+    inline void SetGradienDirections(mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer gradientList);
 
 protected:
 
     unsigned int                        m_NumGradients;             ///< Number of diffusion-weighted image volumes.
     unsigned int                        m_NumBaseline;              ///< Number of non-diffusion-weighted image volumes.
     GradientListType                    m_GradientDirections;       ///< Total number of image volumes.
 };
 
 /** Fiber generation */
 class FiberGenerationParameters
 {
 public:
 
     enum FiberDistribution{
         DISTRIBUTE_UNIFORM, // distribute fibers uniformly in the ROIs
         DISTRIBUTE_GAUSSIAN // distribute fibers using a 2D gaussian
     };
 
     typedef vector< vector< mitk::PlanarEllipse::Pointer > >    FiducialListType;
     typedef vector< vector< unsigned int > >                    FlipListType;
 
     FiberGenerationParameters()
         : m_Distribution(DISTRIBUTE_UNIFORM)
         , m_Density(100)
         , m_Variance(100)
         , m_Sampling(1)
         , m_Tension(0)
         , m_Continuity(0)
         , m_Bias(0)
     {
         m_Rotation.Fill(0.0);
         m_Translation.Fill(0.0);
         m_Scale.Fill(1.0);
     }
 
     FiberDistribution   m_Distribution;
     unsigned int        m_Density;
     double              m_Variance;
     double              m_Sampling;
     double              m_Tension;
     double              m_Continuity;
     double              m_Bias;
     mitk::Vector3D      m_Rotation;
     mitk::Vector3D      m_Translation;
     mitk::Vector3D      m_Scale;
     FlipListType        m_FlipList;        ///< contains flags indicating a flip of the 2D fiber x-coordinates (needed to resolve some unwanted fiber twisting)
     FiducialListType    m_Fiducials;       ///< container of the planar ellipses used as fiducials for the fiber generation process
 };
 
 /** GUI persistence, input, output, ... */
 class MiscFiberfoxParameters
 {
 public:
     MiscFiberfoxParameters()
         : m_ResultNode(DataNode::New())
         , m_ParentNode(NULL)
         , m_SignalModelString("")
         , m_ArtifactModelString("")
         , m_OutputPath("")
         , m_CheckOutputVolumeFractionsBox(false)
         , m_CheckAdvancedSignalOptionsBox(false)
         , m_CheckAddNoiseBox(false)
         , m_CheckAddGhostsBox(false)
         , m_CheckAddAliasingBox(false)
         , m_CheckAddSpikesBox(false)
         , m_CheckAddEddyCurrentsBox(false)
         , m_CheckAddDistortionsBox(false)
         , m_CheckRealTimeFibersBox(true)
         , m_CheckAdvancedFiberOptionsBox(false)
         , m_CheckConstantRadiusBox(false)
         , m_CheckIncludeFiducialsBox(true)
     {}
 
     DataNode::Pointer   m_ResultNode;                       ///< Stores resulting image.
     DataNode::Pointer   m_ParentNode;                       ///< Parent node of result node.
     string              m_SignalModelString;                ///< Appendet to the name of the result node
     string              m_ArtifactModelString;              ///< Appendet to the name of the result node
     string              m_OutputPath;                       ///< Image is automatically saved to the specified folder after simulation is finished.
 
     /** member variables that store the check-state of GUI checkboxes */
     // image generation
     bool                m_CheckOutputVolumeFractionsBox;
     bool                m_CheckAdvancedSignalOptionsBox;
     bool                m_CheckAddNoiseBox;
     bool                m_CheckAddGhostsBox;
     bool                m_CheckAddAliasingBox;
     bool                m_CheckAddSpikesBox;
     bool                m_CheckAddEddyCurrentsBox;
     bool                m_CheckAddDistortionsBox;
     // fiber generation
     bool                m_CheckRealTimeFibersBox;
     bool                m_CheckAdvancedFiberOptionsBox;
     bool                m_CheckConstantRadiusBox;
     bool                m_CheckIncludeFiducialsBox;
 };
 
 /**
   * \brief Datastructure to manage the Fiberfox signal generation parameters.
   *
   */
 template< class ScalarType = double >
 class FiberfoxParameters
 {
 public:
 
     typedef itk::Image<double, 3>                           ItkDoubleImgType;
     typedef itk::Image<unsigned char, 3>                    ItkUcharImgType;
     typedef DiffusionSignalModel<ScalarType>                DiffusionModelType;
     typedef std::vector< DiffusionModelType* >              DiffusionModelListType;
     typedef DiffusionNoiseModel<ScalarType>                 NoiseModelType;
 
     FiberfoxParameters();
     ~FiberfoxParameters();
 
     /** Get same parameter object with different template parameter */
     template< class OutType >
     FiberfoxParameters< OutType > CopyParameters()
     {
         FiberfoxParameters< OutType > out;
 
         out.m_FiberGen = m_FiberGen;
         out.m_SignalGen = m_SignalGen;
         out.m_Misc = m_Misc;
 
         if (m_NoiseModel!=NULL)
         {
             if (dynamic_cast<mitk::RicianNoiseModel<ScalarType>*>(m_NoiseModel))
                 out.m_NoiseModel = new mitk::RicianNoiseModel<OutType>();
             else if (dynamic_cast<mitk::ChiSquareNoiseModel<ScalarType>*>(m_NoiseModel))
                 out.m_NoiseModel = new mitk::ChiSquareNoiseModel<OutType>();
             out.m_NoiseModel->SetNoiseVariance(m_NoiseModel->GetNoiseVariance());
         }
 
         for (unsigned int i=0; i<m_FiberModelList.size()+m_NonFiberModelList.size(); i++)
         {
             mitk::DiffusionSignalModel<OutType>* outModel = NULL;
             mitk::DiffusionSignalModel<ScalarType>* signalModel = NULL;
             if (i<m_FiberModelList.size())
                 signalModel = m_FiberModelList.at(i);
             else
                 signalModel = m_NonFiberModelList.at(i-m_FiberModelList.size());
 
             if (dynamic_cast<mitk::StickModel<ScalarType>*>(signalModel))
                 outModel = new mitk::StickModel<OutType>(dynamic_cast<mitk::StickModel<ScalarType>*>(signalModel));
             else  if (dynamic_cast<mitk::TensorModel<ScalarType>*>(signalModel))
                 outModel = new mitk::TensorModel<OutType>(dynamic_cast<mitk::TensorModel<ScalarType>*>(signalModel));
             else  if (dynamic_cast<mitk::RawShModel<ScalarType>*>(signalModel))
                 outModel = new mitk::RawShModel<OutType>(dynamic_cast<mitk::RawShModel<ScalarType>*>(signalModel));
             else  if (dynamic_cast<mitk::BallModel<ScalarType>*>(signalModel))
                 outModel = new mitk::BallModel<OutType>(dynamic_cast<mitk::BallModel<ScalarType>*>(signalModel));
             else if (dynamic_cast<mitk::AstroStickModel<ScalarType>*>(signalModel))
                 outModel = new mitk::AstroStickModel<OutType>(dynamic_cast<mitk::AstroStickModel<ScalarType>*>(signalModel));
             else  if (dynamic_cast<mitk::DotModel<ScalarType>*>(signalModel))
                 outModel = new mitk::DotModel<OutType>(dynamic_cast<mitk::DotModel<ScalarType>*>(signalModel));
 
             if (i<m_FiberModelList.size())
                 out.m_FiberModelList.push_back(outModel);
             else
                 out.m_NonFiberModelList.push_back(outModel);
         }
 
         return out;
     }
 
     /** Not templated parameters */
     FiberGenerationParameters           m_FiberGen;             ///< Fiber generation parameters
     SignalGenerationParameters          m_SignalGen;            ///< Signal generation parameters
     MiscFiberfoxParameters              m_Misc;                 ///< GUI realted and I/O parameters
 
     /** Templated parameters */
     DiffusionModelListType              m_FiberModelList;       ///< Intra- and inter-axonal compartments.
     DiffusionModelListType              m_NonFiberModelList;    ///< Extra-axonal compartments.
     NoiseModelType*                     m_NoiseModel;           ///< If != NULL, noise is added to the image.
 
     void PrintSelf();                           ///< Print parameters to stdout.
     void SaveParameters(string filename);       ///< Save image generation parameters to .ffp file.
     void LoadParameters(string filename);       ///< Load image generation parameters from .ffp file.
 };
 }
 
 #include "mitkFiberfoxParameters.cpp"
 
 #endif
 
diff --git a/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkRawShModel.cpp b/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkRawShModel.cpp
index 0d2302d1e7..e23724c631 100644
--- a/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkRawShModel.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkRawShModel.cpp
@@ -1,382 +1,390 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 #include <vnl/vnl_cross.h>
 #include <vnl/vnl_quaternion.h>
 #include <mitkRawShModel.h>
 #include <boost/math/special_functions.hpp>
 #include <itkOrientationDistributionFunction.h>
 #include <mitkFiberfoxParameters.h>
 #include <itkDiffusionTensor3DReconstructionImageFilter.h>
 #include <itkAdcImageFilter.h>
 #include <itkAnalyticalDiffusionQballReconstructionImageFilter.h>
+#include <mitkDiffusionPropertyHelper.h>
+#include <mitkImageCast.h>
+#include <mitkProperties.h>
 
 using namespace mitk;
 using namespace boost::math;
 
 template< class ScalarType >
 RawShModel< ScalarType >::RawShModel()
     : m_ShOrder(0)
     , m_ModelIndex(-1)
     , m_MaxNumKernels(1000)
 {
     this->m_RandGen = itk::Statistics::MersenneTwisterRandomVariateGenerator::New();
     this->m_RandGen->SetSeed();
     m_AdcRange.first = 0;
     m_AdcRange.second = 0.004;
     m_FaRange.first = 0;
     m_FaRange.second = 1;
 }
 
 template< class ScalarType >
 RawShModel< ScalarType >::~RawShModel()
 {
 
 }
 
 template< class ScalarType >
 void RawShModel< ScalarType >::Clear()
 {
     m_ShCoefficients.clear();
     m_PrototypeMaxDirection.clear();
     m_B0Signal.clear();
 }
 
 template< class ScalarType >
 void RawShModel< ScalarType >::RandomModel()
 {
     m_ModelIndex = this->m_RandGen->GetIntegerVariate(m_B0Signal.size()-1);
 }
 
 template< class ScalarType >
 unsigned int RawShModel< ScalarType >::GetNumberOfKernels()
 {
     return m_B0Signal.size();
 }
 
 template< class ScalarType >
-bool RawShModel< ScalarType >::SampleKernels(DiffusionImage<short>::Pointer diffImg, ItkUcharImageType::Pointer maskImage, TensorImageType::Pointer tensorImage, QballFilterType::CoefficientImageType::Pointer itkFeatureImage, ItkDoubleImageType::Pointer adcImage)
+bool RawShModel< ScalarType >::SampleKernels(Image::Pointer diffImg, ItkUcharImageType::Pointer maskImage, TensorImageType::Pointer tensorImage, QballFilterType::CoefficientImageType::Pointer itkFeatureImage, ItkDoubleImageType::Pointer adcImage)
 {
     if (diffImg.IsNull())
         return false;
 
+    typedef itk::VectorImage<short, 3> ITKDiffusionImageType;
+        ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
+  mitk::CastToItkImage(diffImg, itkVectorImagePointer);
+
     const int shOrder = 2;
 
     if (tensorImage.IsNull())
     {
         typedef itk::DiffusionTensor3DReconstructionImageFilter< short, short, double > TensorReconstructionImageFilterType;
+
         TensorReconstructionImageFilterType::Pointer filter = TensorReconstructionImageFilterType::New();
-        filter->SetGradientImage( diffImg->GetDirections(), diffImg->GetVectorImage() );
-        filter->SetBValue(diffImg->GetReferenceBValue());
+        filter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), itkVectorImagePointer );
+        filter->SetBValue(static_cast<mitk::FloatProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue());
         filter->Update();
         tensorImage = filter->GetOutput();
     }
 
     const int NumCoeffs = (shOrder*shOrder + shOrder + 2)/2 + shOrder;
     if (itkFeatureImage.IsNull())
     {
         QballFilterType::Pointer qballfilter = QballFilterType::New();
-        qballfilter->SetGradientImage( diffImg->GetDirections(), diffImg->GetVectorImage() );
-        qballfilter->SetBValue(diffImg->GetReferenceBValue());
+        qballfilter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), itkVectorImagePointer );
+        qballfilter->SetBValue(static_cast<mitk::FloatProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue());
         qballfilter->SetLambda(0.006);
         qballfilter->SetNormalizationMethod(QballFilterType::QBAR_RAW_SIGNAL);
         qballfilter->Update();
         itkFeatureImage = qballfilter->GetCoefficientImage();
     }
 
     if (adcImage.IsNull())
     {
         itk::AdcImageFilter< short, double >::Pointer adcFilter = itk::AdcImageFilter< short, double >::New();
-        adcFilter->SetInput(diffImg->GetVectorImage());
-        adcFilter->SetGradientDirections(diffImg->GetDirections());
-        adcFilter->SetB_value(diffImg->GetReferenceBValue());
+        adcFilter->SetInput(itkVectorImagePointer);
+        adcFilter->SetGradientDirections(static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer());
+        adcFilter->SetB_value(static_cast<mitk::FloatProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue());
         adcFilter->Update();
         adcImage = adcFilter->GetOutput();
     }
 
     int b0Index;
-    for (unsigned int i=0; i<diffImg->GetDirectionsWithoutMeasurementFrame()->Size(); i++)
-        if ( diffImg->GetDirectionsWithoutMeasurementFrame()->GetElement(i).magnitude()<0.001 )
+    for (unsigned int i=0; i<static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::ORIGINALGRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer()->Size(); i++)
+        if ( static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::ORIGINALGRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer()->GetElement(i).magnitude()<0.001 )
         {
             b0Index = i;
             break;
         }
 
     double max = 0;
     {
-        itk::ImageRegionIterator< itk::VectorImage< short, 3 > >  it(diffImg->GetVectorImage(), diffImg->GetVectorImage()->GetLargestPossibleRegion());
+        itk::ImageRegionIterator< itk::VectorImage< short, 3 > >  it(itkVectorImagePointer, itkVectorImagePointer->GetLargestPossibleRegion());
         while(!it.IsAtEnd())
         {
             if (maskImage.IsNotNull() && maskImage->GetPixel(it.GetIndex())<=0)
             {
                 ++it;
                 continue;
             }
             if (it.Get()[b0Index]>max)
                 max = it.Get()[b0Index];
             ++it;
         }
     }
 
     MITK_INFO << "Sampling signal kernels.";
     unsigned int count = 0;
     itk::ImageRegionIterator< itk::Image< itk::DiffusionTensor3D< double >, 3 > >  it(tensorImage, tensorImage->GetLargestPossibleRegion());
     while(!it.IsAtEnd())
     {
         bool skipPixel = false;
         if (maskImage.IsNotNull() && maskImage->GetPixel(it.GetIndex())<=0)
         {
             ++it;
             continue;
         }
-        for (unsigned int i=0; i<diffImg->GetDirections()->Size(); i++)
+        for (unsigned int i=0; i<static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer()->Size(); i++)
         {
-            if (diffImg->GetVectorImage()->GetPixel(it.GetIndex())[i]!=diffImg->GetVectorImage()->GetPixel(it.GetIndex())[i] || diffImg->GetVectorImage()->GetPixel(it.GetIndex())[i]<=0 || diffImg->GetVectorImage()->GetPixel(it.GetIndex())[i]>diffImg->GetVectorImage()->GetPixel(it.GetIndex())[b0Index])
+            if (itkVectorImagePointer->GetPixel(it.GetIndex())[i]!=itkVectorImagePointer->GetPixel(it.GetIndex())[i] || itkVectorImagePointer->GetPixel(it.GetIndex())[i]<=0 || itkVectorImagePointer->GetPixel(it.GetIndex())[i]>itkVectorImagePointer->GetPixel(it.GetIndex())[b0Index])
             {
                 skipPixel = true;
                 break;
             }
         }
         if (skipPixel)
         {
             ++it;
             continue;
         }
 
         typedef itk::DiffusionTensor3D<double>    TensorType;
         TensorType::EigenValuesArrayType eigenvalues;
         TensorType::EigenVectorsMatrixType eigenvectors;
         TensorType tensor = it.Get();
         double FA = tensor.GetFractionalAnisotropy();
         double ADC = adcImage->GetPixel(it.GetIndex());
         QballFilterType::CoefficientImageType::PixelType itkv = itkFeatureImage->GetPixel(it.GetIndex());
         vnl_vector_fixed< double, NumCoeffs > coeffs;
         for (unsigned int c=0; c<itkv.Size(); c++)
             coeffs[c] = itkv[c]/max;
 
         if ( this->GetMaxNumKernels()>this->GetNumberOfKernels() && FA>m_FaRange.first && FA<m_FaRange.second && ADC>m_AdcRange.first && ADC<m_AdcRange.second)
         {
-            if (this->SetShCoefficients( coeffs, (double)diffImg->GetVectorImage()->GetPixel(it.GetIndex())[b0Index]/max ))
+            if (this->SetShCoefficients( coeffs, (double)itkVectorImagePointer->GetPixel(it.GetIndex())[b0Index]/max ))
             {
                 tensor.ComputeEigenAnalysis(eigenvalues, eigenvectors);
                 itk::Vector<double,3> dir;
                 dir[0] = eigenvectors(2, 0);
                 dir[1] = eigenvectors(2, 1);
                 dir[2] = eigenvectors(2, 2);
                 m_PrototypeMaxDirection.push_back(dir);
                 count++;
                 MITK_INFO << "KERNEL: " << it.GetIndex() << " (" << count << ")";
             }
         }
         ++it;
     }
 
     if (m_ShCoefficients.size()>0)
         return true;
     return false;
 }
 
 // convert cartesian to spherical coordinates
 template< class ScalarType >
 void RawShModel< ScalarType >::Cart2Sph( GradientListType gradients )
 {
     m_SphCoords.set_size(gradients.size(), 2);
     m_SphCoords.fill(0.0);
 
     for (unsigned int i=0; i<gradients.size(); i++)
     {
         GradientType g = gradients[i];
         if( g.GetNorm() > 0.0001 )
         {
             gradients[i].Normalize();
             m_SphCoords(i,0) = acos(gradients[i][2]); // theta
             m_SphCoords(i,1) = atan2(gradients[i][1], gradients[i][0]); // phi
         }
     }
 }
 
 template< class ScalarType >
 void RawShModel< ScalarType >::SetFiberDirection(GradientType fiberDirection)
 {
     this->m_FiberDirection = fiberDirection;
     this->m_FiberDirection.Normalize();
 
     RandomModel();
     GradientType axis = itk::CrossProduct(this->m_FiberDirection, m_PrototypeMaxDirection.at(m_ModelIndex));
     axis.Normalize();
 
     vnl_quaternion<double> rotation(axis.GetVnlVector(), acos(dot_product(this->m_FiberDirection.GetVnlVector(), m_PrototypeMaxDirection.at(m_ModelIndex).GetVnlVector())));
     rotation.normalize();
 
     GradientListType gradients;
     for (unsigned int i=0; i<this->m_GradientList.size(); i++)
     {
         GradientType dir = this->m_GradientList.at(i);
         if( dir.GetNorm() > 0.0001 )
         {
             dir.Normalize();
             vnl_vector_fixed< double, 3 > vnlDir = rotation.rotate(dir.GetVnlVector());
             dir[0] = vnlDir[0]; dir[1] = vnlDir[1]; dir[2] = vnlDir[2];
             dir.Normalize();
         }
         gradients.push_back(dir);
     }
 
     Cart2Sph( gradients );
 }
 
 template< class ScalarType >
 bool RawShModel< ScalarType >::SetShCoefficients(vnl_vector< double > shCoefficients, double b0 )
 {
     m_ShOrder = 2;
     while ( (m_ShOrder*m_ShOrder + m_ShOrder + 2)/2 + m_ShOrder <= shCoefficients.size() )
         m_ShOrder += 2;
     m_ShOrder -= 2;
 
     m_ModelIndex = m_B0Signal.size();
     m_B0Signal.push_back(b0);
     m_ShCoefficients.push_back(shCoefficients);
 
     //    itk::OrientationDistributionFunction<double, 10000> odf;
     //    GradientListType gradients;
     //    for (unsigned int i=0; i<odf.GetNumberOfComponents(); i++)
     //    {
     //        GradientType dir; dir[0]=odf.GetDirection(i)[0]; dir[1]=odf.GetDirection(i)[1]; dir[2]=odf.GetDirection(i)[2];
     //        dir.Normalize();
     //        gradients.push_back(dir);
     //    }
     //    Cart2Sph( this->m_GradientList );
     //    PixelType signal = SimulateMeasurement();
 
     //    int minDirIdx = 0;
     //    double min = itk::NumericTraits<double>::max();
     //    for (unsigned int i=0; i<signal.GetSize(); i++)
     //    {
     //        if (signal[i]>b0 || signal[i]<0)
     //        {
     //            MITK_INFO << "Corrupted signal value detected. Kernel rejected.";
     //            m_B0Signal.pop_back();
     //            m_ShCoefficients.pop_back();
     //            return false;
     //        }
     //        if (signal[i]<min)
     //        {
     //            min = signal[i];
     //            minDirIdx = i;
     //        }
     //    }
     //    GradientType maxDir = this->m_GradientList.at(minDirIdx);
     //    maxDir.Normalize();
     //    m_PrototypeMaxDirection.push_back(maxDir);
 
     Cart2Sph( this->m_GradientList );
     m_ModelIndex = -1;
 
     return true;
 }
 
 template< class ScalarType >
 ScalarType RawShModel< ScalarType >::SimulateMeasurement(unsigned int dir)
 {
     ScalarType signal = 0;
 
     if (m_ModelIndex==-1)
         RandomModel();
 
     if (dir>=this->m_GradientList.size())
         return signal;
 
     int j, m; double mag, plm;
 
     if (this->m_GradientList[dir].GetNorm()>0.001)
     {
         j=0;
         for (int l=0; l<=m_ShOrder; l=l+2)
             for (m=-l; m<=l; m++)
             {
                 plm = legendre_p<double>(l,abs(m),cos(m_SphCoords(dir,0)));
                 mag = sqrt((double)(2*l+1)/(4.0*M_PI)*factorial<double>(l-abs(m))/factorial<double>(l+abs(m)))*plm;
                 double basis;
 
                 if (m<0)
                     basis = sqrt(2.0)*mag*cos(fabs((double)m)*m_SphCoords(dir,1));
                 else if (m==0)
                     basis = mag;
                 else
                     basis = pow(-1.0, m)*sqrt(2.0)*mag*sin(m*m_SphCoords(dir,1));
 
                 signal += m_ShCoefficients.at(m_ModelIndex)[j]*basis;
                 j++;
             }
     }
     else
         signal = m_B0Signal.at(m_ModelIndex);
 
     m_ModelIndex = -1;
 
     return signal;
 }
 
 template< class ScalarType >
 typename RawShModel< ScalarType >::PixelType RawShModel< ScalarType >::SimulateMeasurement()
 {
     if (m_ModelIndex==-1)
         RandomModel();
 
     PixelType signal;
     signal.SetSize(this->m_GradientList.size());
 
     int M = this->m_GradientList.size();
     int j, m; double mag, plm;
 
     vnl_matrix< double > shBasis;
     shBasis.set_size(M, m_ShCoefficients.at(m_ModelIndex).size());
     shBasis.fill(0.0);
 
     for (int p=0; p<M; p++)
     {
         if (this->m_GradientList[p].GetNorm()>0.001)
         {
             j=0;
             for (int l=0; l<=m_ShOrder; l=l+2)
                 for (m=-l; m<=l; m++)
                 {
                     plm = legendre_p<double>(l,abs(m),cos(m_SphCoords(p,0)));
                     mag = sqrt((double)(2*l+1)/(4.0*M_PI)*factorial<double>(l-abs(m))/factorial<double>(l+abs(m)))*plm;
 
                     if (m<0)
                         shBasis(p,j) = sqrt(2.0)*mag*cos(fabs((double)m)*m_SphCoords(p,1));
                     else if (m==0)
                         shBasis(p,j) = mag;
                     else
                         shBasis(p,j) = pow(-1.0, m)*sqrt(2.0)*mag*sin(m*m_SphCoords(p,1));
 
                     j++;
                 }
 
 
             double val = 0;
             for (unsigned int cidx=0; cidx<m_ShCoefficients.at(m_ModelIndex).size(); cidx++)
                 val += m_ShCoefficients.at(m_ModelIndex)[cidx]*shBasis(p,cidx);
             signal[p] = val;
         }
         else
             signal[p] = m_B0Signal.at(m_ModelIndex);
     }
 
     m_ModelIndex = -1;
 
     return signal;
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkRawShModel.h b/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkRawShModel.h
index 3fb5676395..1b03403ca7 100644
--- a/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkRawShModel.h
+++ b/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkRawShModel.h
@@ -1,114 +1,114 @@
 /*===================================================================
 
 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 _MITK_RawShModel_H
 #define _MITK_RawShModel_H
 
 #include <mitkDiffusionSignalModel.h>
-#include <mitkDiffusionImage.h>
+#include <mitkImage.h>
 #include <itkAnalyticalDiffusionQballReconstructionImageFilter.h>
 
 namespace mitk {
 
 /**
   * \brief The spherical harmonic representation of a prototype diffusion weighted MR signal is used to obtain the direction dependent signal.
   *
   */
 
 template< class ScalarType = double >
 class RawShModel : public DiffusionSignalModel< ScalarType >
 {
 public:
 
     RawShModel();
     template< class OtherType >RawShModel(RawShModel<OtherType>* model)
     {
         this->m_CompartmentId = model->m_CompartmentId;
         this->m_T2 = model->GetT2();
         this->m_FiberDirection = model->GetFiberDirection();
         this->m_GradientList = model->GetGradientList();
         this->m_VolumeFractionImage = model->GetVolumeFractionImage();
         this->m_RandGen = model->GetRandomGenerator();
 
         this->m_AdcRange = model->GetAdcRange();
         this->m_FaRange = model->GetFaRange();
         this->m_ShCoefficients = model->GetShCoefficients();
         this->m_B0Signal = model->GetB0Signals();
         this->m_SphCoords = model->GetSphericalCoordinates();
         this->m_ShOrder = model->GetShOrder();
         this->m_ModelIndex = model->GetModelIndex();
         this->m_MaxNumKernels = model->GetMaxNumKernels();
     }
     ~RawShModel();
 
     typedef itk::Image< double, 3 >                                         ItkDoubleImageType;
     typedef itk::Image< unsigned char, 3 >                                  ItkUcharImageType;
     typedef itk::Image< itk::DiffusionTensor3D< double >, 3 >               TensorImageType;
     typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,2,QBALL_ODFSIZE> QballFilterType;
     typedef typename DiffusionSignalModel< ScalarType >::PixelType          PixelType;
     typedef typename DiffusionSignalModel< ScalarType >::GradientType       GradientType;
     typedef typename DiffusionSignalModel< ScalarType >::GradientListType   GradientListType;
     typedef itk::Matrix< double, 3, 3 >                                     MatrixType;
 
     /** Actual signal generation **/
     PixelType SimulateMeasurement();
     ScalarType SimulateMeasurement(unsigned int dir);
 
     bool SetShCoefficients(vnl_vector< double > shCoefficients, double b0);
     void SetFiberDirection(GradientType fiberDirection);
     void SetGradientList(GradientListType gradientList) { this->m_GradientList = gradientList; }
     void SetFaRange(double min, double max){ m_FaRange.first = min; m_FaRange.second = max; }
     void SetAdcRange(double min, double max){ m_AdcRange.first = min; m_AdcRange.second = max; }
     void SetMaxNumKernels(unsigned int max){ m_MaxNumKernels = max; }
     unsigned int GetNumberOfKernels();
     std::pair< double, double > GetFaRange(){ return m_FaRange; }
     std::pair< double, double > GetAdcRange(){ return m_AdcRange; }
     unsigned int GetMaxNumKernels(){ return m_MaxNumKernels; }
     void Clear();
 
     std::vector< vnl_vector< double > > GetShCoefficients(){ return m_ShCoefficients; }
     std::vector< double > GetB0Signals(){ return m_B0Signal; }
     vnl_matrix<double> GetSphericalCoordinates(){ return m_SphCoords; }
     unsigned int GetShOrder(){ return m_ShOrder; }
     int GetModelIndex(){ return m_ModelIndex; }
 
     double GetBaselineSignal(int index){ return m_B0Signal.at(index); }
     vnl_vector< double > GetCoefficients(int listIndex){ return m_ShCoefficients.at(listIndex); }
 
-    bool SampleKernels(DiffusionImage<short>::Pointer diffImg, ItkUcharImageType::Pointer maskImage, TensorImageType::Pointer tensorImage=NULL, QballFilterType::CoefficientImageType::Pointer coeffImage=NULL, ItkDoubleImageType::Pointer adcImage=NULL);
+    bool SampleKernels(Image::Pointer diffImg, ItkUcharImageType::Pointer maskImage, TensorImageType::Pointer tensorImage=NULL, QballFilterType::CoefficientImageType::Pointer coeffImage=NULL, ItkDoubleImageType::Pointer adcImage=NULL);
 
 protected:
 
     void Cart2Sph( GradientListType gradients );
     void RandomModel();
 
     std::vector< vnl_vector< double > > m_ShCoefficients;
     std::vector< double >               m_B0Signal;
     std::vector< GradientType >         m_PrototypeMaxDirection;
     vnl_matrix<double>                  m_SphCoords;
     std::pair< double, double >         m_AdcRange;
     std::pair< double, double >         m_FaRange;
     unsigned int                        m_ShOrder;
     int                                 m_ModelIndex;
     unsigned int                        m_MaxNumKernels;
 };
 
 }
 
 #include "mitkRawShModel.cpp"
 
 #endif
 
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/CMakeLists.txt b/Modules/DiffusionImaging/FiberTracking/Testing/CMakeLists.txt
index 3b03f3f67d..c51a305cf8 100644
--- a/Modules/DiffusionImaging/FiberTracking/Testing/CMakeLists.txt
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/CMakeLists.txt
@@ -1,14 +1,14 @@
 MITK_CREATE_MODULE_TESTS()
 
 if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
 mitkAddCustomModuleTest(mitkFiberBundleXReaderWriterTest mitkFiberBundleXReaderWriterTest)
 mitkAddCustomModuleTest(mitkGibbsTrackingTest mitkGibbsTrackingTest ${MITK_DATA_DIR}/DiffusionImaging/qBallImage.qbi ${MITK_DATA_DIR}/DiffusionImaging/diffusionImageMask.nrrd ${MITK_DATA_DIR}/DiffusionImaging/gibbsTrackingParameters.gtp ${MITK_DATA_DIR}/DiffusionImaging/gibbsTractogram.fib)
 mitkAddCustomModuleTest(mitkStreamlineTrackingTest mitkStreamlineTrackingTest ${MITK_DATA_DIR}/DiffusionImaging/tensorImage.dti ${MITK_DATA_DIR}/DiffusionImaging/diffusionImageMask.nrrd ${MITK_DATA_DIR}/DiffusionImaging/streamlineTractogramInterpolated.fib)
 #mitkAddCustomModuleTest(mitkPeakExtractionTest mitkPeakExtractionTest ${MITK_DATA_DIR}/DiffusionImaging/qBallImage_SHCoeffs.nrrd ${MITK_DATA_DIR}/DiffusionImaging/diffusionImageMask.nrrd ${MITK_DATA_DIR}/DiffusionImaging/qBallImage_VectorField.fib)
 mitkAddCustomModuleTest(mitkLocalFiberPlausibilityTest mitkLocalFiberPlausibilityTest ${MITK_DATA_DIR}/DiffusionImaging/fiberBundleX.fib ${MITK_DATA_DIR}/DiffusionImaging/LDFP_GT_DIRECTION_0.nrrd ${MITK_DATA_DIR}/DiffusionImaging/LDFP_GT_DIRECTION_1.nrrd ${MITK_DATA_DIR}/DiffusionImaging/LDFP_ERROR_IMAGE.nrrd ${MITK_DATA_DIR}/DiffusionImaging/LDFP_NUM_DIRECTIONS.nrrd ${MITK_DATA_DIR}/DiffusionImaging/LDFP_VECTOR_FIELD.fib ${MITK_DATA_DIR}/DiffusionImaging/LDFP_ERROR_IMAGE_IGNORE.nrrd)
 mitkAddCustomModuleTest(mitkFiberTransformationTest mitkFiberTransformationTest ${MITK_DATA_DIR}/DiffusionImaging/fiberBundleX.fib ${MITK_DATA_DIR}/DiffusionImaging/fiberBundleX_transformed.fib)
 mitkAddCustomModuleTest(mitkFiberExtractionTest mitkFiberExtractionTest ${MITK_DATA_DIR}/DiffusionImaging/fiberBundleX.fib ${MITK_DATA_DIR}/DiffusionImaging/fiberBundleX_extracted.fib ${MITK_DATA_DIR}/DiffusionImaging/ROI1.pf ${MITK_DATA_DIR}/DiffusionImaging/ROI2.pf ${MITK_DATA_DIR}/DiffusionImaging/ROI3.pf ${MITK_DATA_DIR}/DiffusionImaging/ROIIMAGE.nrrd ${MITK_DATA_DIR}/DiffusionImaging/fiberBundleX_inside.fib ${MITK_DATA_DIR}/DiffusionImaging/fiberBundleX_outside.fib ${MITK_DATA_DIR}/DiffusionImaging/fiberBundleX_passing-mask.fib ${MITK_DATA_DIR}/DiffusionImaging/fiberBundleX_ending-in-mask.fib ${MITK_DATA_DIR}/DiffusionImaging/fiberBundleX_subtracted.fib ${MITK_DATA_DIR}/DiffusionImaging/fiberBundleX_added.fib)
 mitkAddCustomModuleTest(mitkFiberGenerationTest mitkFiberGenerationTest ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/Fiducial_0.pf ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/Fiducial_1.pf ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/Fiducial_2.pf ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/uniform.fib ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/gaussian.fib)
-mitkAddCustomModuleTest(mitkFiberfoxSignalGenerationTest mitkFiberfoxSignalGenerationTest ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/gaussian.fib ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/StickBall_RELAX.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/StickAstrosticks_RELAX.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/StickDot_RELAX.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/TensorBall_RELAX.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/StickTensorBall_RELAX.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/StickTensorBallAstrosticks_RELAX.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/gibbsringing.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/ghost.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/aliasing.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/eddy.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/linearmotion.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/randommotion.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/spikes.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/riciannoise.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/chisquarenoise.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/distortions.dwi ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/Fieldmap.nrrd)
+mitkAddCustomModuleTest(mitkFiberfoxSignalGenerationTest mitkFiberfoxSignalGenerationTest ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/gaussian.fib ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/StickBall_RELAX.nrrd ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/StickAstrosticks_RELAX.nrrd ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/StickDot_RELAX.nrrd ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/TensorBall_RELAX.nrrd ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/StickTensorBall_RELAX.nrrd ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/StickTensorBallAstrosticks_RELAX.nrrd ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/gibbsringing.nrrd ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/ghost.nrrd ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/aliasing.nrrd ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/eddy.nrrd ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/linearmotion.nrrd ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/randommotion.nrrd ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/spikes.nrrd ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/riciannoise.nrrd ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/chisquarenoise.nrrd ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/distortions.nrrd ${MITK_DATA_DIR}/DiffusionImaging/Fiberfox/Fieldmap.nrrd)
 mitkAddCustomModuleTest(mitkFiberfoxAddArtifactsToDwiTest mitkFiberfoxAddArtifactsToDwiTest)
 ENDIF()
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxAddArtifactsToDwiTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxAddArtifactsToDwiTest.cpp
index 5f991c3fc1..53622ec71b 100644
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxAddArtifactsToDwiTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxAddArtifactsToDwiTest.cpp
@@ -1,182 +1,199 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include <mitkTestingMacros.h>
 #include <mitkIOUtil.h>
 #include <mitkFiberBundleX.h>
 #include <itkAddArtifactsToDwiImageFilter.h>
 #include <mitkFiberfoxParameters.h>
 #include <mitkStickModel.h>
 #include <mitkTensorModel.h>
 #include <mitkBallModel.h>
 #include <mitkDotModel.h>
 #include <mitkAstroStickModel.h>
-#include <mitkDiffusionImage.h>
+#include <mitkImage.h>
 #include <itkTestingComparisonImageFilter.h>
 #include <itkImageRegionConstIterator.h>
 #include <mitkRicianNoiseModel.h>
 #include <mitkChiSquareNoiseModel.h>
 #include <mitkTestFixture.h>
+#include <mitkITKImageImport.h>
+#include <mitkProperties.h>
+#include <mitkImageCast.h>
+
+typedef itk::VectorImage<short, 3> ITKDiffusionImageType;
 
 /**Documentation
  * Test the Fiberfox simulation functions (diffusion weighted image -> diffusion weighted image)
  */
 class mitkFiberfoxAddArtifactsToDwiTestSuite : public mitk::TestFixture
 {
 
     CPPUNIT_TEST_SUITE(mitkFiberfoxAddArtifactsToDwiTestSuite);
     MITK_TEST(Spikes);
     MITK_TEST(GibbsRinging);
     MITK_TEST(Ghost);
     MITK_TEST(Aliasing);
     MITK_TEST(Eddy);
     MITK_TEST(RicianNoise);
     MITK_TEST(ChiSquareNoise);
     MITK_TEST(Distortions);
     CPPUNIT_TEST_SUITE_END();
 
 private:
 
-    mitk::DiffusionImage<short>::Pointer m_InputDwi;
+    mitk::Image::Pointer m_InputDwi;
     FiberfoxParameters<short> m_Parameters;
 
 public:
 
     void setUp()
     {
         // reference files
-        m_InputDwi = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(GetTestDataFilePath("DiffusionImaging/Fiberfox/StickBall_RELAX.dwi"))->GetData());
+        m_InputDwi = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(GetTestDataFilePath("DiffusionImaging/Fiberfox/StickBall_RELAX.dwi"))->GetData());
 
         // parameter setup
+
+        ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
+        mitk::CastToItkImage(m_InputDwi, itkVectorImagePointer);
+
         m_Parameters = FiberfoxParameters<short>();
-        m_Parameters.m_SignalGen.m_ImageRegion = m_InputDwi->GetVectorImage()->GetLargestPossibleRegion();
-        m_Parameters.m_SignalGen.m_ImageSpacing = m_InputDwi->GetVectorImage()->GetSpacing();
-        m_Parameters.m_SignalGen.m_ImageOrigin = m_InputDwi->GetVectorImage()->GetOrigin();
-        m_Parameters.m_SignalGen.m_ImageDirection = m_InputDwi->GetVectorImage()->GetDirection();
-        m_Parameters.m_SignalGen.m_Bvalue = m_InputDwi->GetReferenceBValue();
-        m_Parameters.m_SignalGen.SetGradienDirections(m_InputDwi->GetDirections());
+        m_Parameters.m_SignalGen.m_ImageRegion = itkVectorImagePointer->GetLargestPossibleRegion();
+        m_Parameters.m_SignalGen.m_ImageSpacing = itkVectorImagePointer->GetSpacing();
+        m_Parameters.m_SignalGen.m_ImageOrigin = itkVectorImagePointer->GetOrigin();
+        m_Parameters.m_SignalGen.m_ImageDirection = itkVectorImagePointer->GetDirection();
+        m_Parameters.m_SignalGen.m_Bvalue = static_cast<mitk::FloatProperty*>(m_InputDwi->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue();
+        m_Parameters.m_SignalGen.SetGradienDirections( static_cast<mitk::GradientDirectionsProperty*>( m_InputDwi->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() );
     }
 
     bool CompareDwi(itk::VectorImage< short, 3 >* dwi1, itk::VectorImage< short, 3 >* dwi2)
     {
         typedef itk::VectorImage< short, 3 > DwiImageType;
         try{
             itk::ImageRegionIterator< DwiImageType > it1(dwi1, dwi1->GetLargestPossibleRegion());
             itk::ImageRegionIterator< DwiImageType > it2(dwi2, dwi2->GetLargestPossibleRegion());
             while(!it1.IsAtEnd())
             {
                 if (it1.Get()!=it2.Get())
                     return false;
                 ++it1;
                 ++it2;
             }
         }
         catch(...)
         {
             return false;
         }
         return true;
     }
 
     void StartSimulation(string testFileName)
     {
-        mitk::DiffusionImage<short>::Pointer refImage = NULL;
+        mitk::Image::Pointer refImage = NULL;
         if (!testFileName.empty())
-            CPPUNIT_ASSERT(refImage = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(testFileName)->GetData()));
+            CPPUNIT_ASSERT(refImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(testFileName)->GetData()));
+
+        ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
+        mitk::CastToItkImage(m_InputDwi, itkVectorImagePointer);
 
         itk::AddArtifactsToDwiImageFilter< short >::Pointer artifactsToDwiFilter = itk::AddArtifactsToDwiImageFilter< short >::New();
         artifactsToDwiFilter->SetUseConstantRandSeed(true);
-        artifactsToDwiFilter->SetInput(m_InputDwi->GetVectorImage());
+        artifactsToDwiFilter->SetInput(itkVectorImagePointer);
         artifactsToDwiFilter->SetParameters(m_Parameters);
         CPPUNIT_ASSERT_NO_THROW(artifactsToDwiFilter->Update());
 
-        mitk::DiffusionImage<short>::Pointer testImage = mitk::DiffusionImage<short>::New();
-        testImage->SetVectorImage( artifactsToDwiFilter->GetOutput() );
-        testImage->SetReferenceBValue( m_Parameters.m_SignalGen.m_Bvalue);
-        testImage->SetDirections( m_Parameters.m_SignalGen.GetGradientDirections());
-        testImage->InitializeFromVectorImage();
+        mitk::Image::Pointer testImage = mitk::GrabItkImageMemory( artifactsToDwiFilter->GetOutput() );
+        testImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( m_Parameters.m_SignalGen.GetGradientDirections() ) );
+        testImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( m_Parameters.m_SignalGen.m_Bvalue ) );
+        mitk::DiffusionPropertyHelper propertyHelper( testImage );
+        propertyHelper.InitializeImage();
 
         if (refImage.IsNotNull())
         {
-            if (!CompareDwi(testImage->GetVectorImage(), refImage->GetVectorImage()))
-                mitk::IOUtil::SaveBaseData(testImage, mitk::IOUtil::GetTempPath()+"testImage.dwi");
-            CPPUNIT_ASSERT_MESSAGE(testFileName, CompareDwi(testImage->GetVectorImage(), refImage->GetVectorImage()));
+          ITKDiffusionImageType::Pointer itkTestVectorImagePointer = ITKDiffusionImageType::New();
+          mitk::CastToItkImage(testImage, itkTestVectorImagePointer);
+          ITKDiffusionImageType::Pointer itkRefVectorImagePointer = ITKDiffusionImageType::New();
+          mitk::CastToItkImage(refImage, itkRefVectorImagePointer);
+          if (!CompareDwi( itkTestVectorImagePointer, itkRefVectorImagePointer))
+              mitk::IOUtil::SaveBaseData(testImage, mitk::IOUtil::GetTempPath()+"testImage.dwi");
+
+          CPPUNIT_ASSERT_MESSAGE(testFileName, CompareDwi( itkTestVectorImagePointer, itkRefVectorImagePointer));
         }
     }
 
     void Spikes()
     {
         m_Parameters.m_SignalGen.m_Spikes = 5;
         m_Parameters.m_SignalGen.m_SpikeAmplitude = 1;
         StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/spikes2.dwi") );
     }
 
     void GibbsRinging()
     {
         m_Parameters.m_SignalGen.m_DoAddGibbsRinging = true;
         StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/gibbsringing2.dwi") );
     }
 
     void Ghost()
     {
         m_Parameters.m_SignalGen.m_KspaceLineOffset = 0.25;
         StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/ghost2.dwi") );
     }
 
     void Aliasing()
     {
         m_Parameters.m_SignalGen.m_CroppingFactor = 0.4;
         StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/aliasing2.dwi") );
     }
 
     void Eddy()
     {
         m_Parameters.m_SignalGen.m_EddyStrength = 0.05;
         StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/eddy2.dwi") );
     }
 
     void RicianNoise()
     {
         mitk::RicianNoiseModel<short>* ricianNoiseModel = new mitk::RicianNoiseModel<short>();
         ricianNoiseModel->SetNoiseVariance(1000000);
         ricianNoiseModel->SetSeed(0);
         m_Parameters.m_NoiseModel = ricianNoiseModel;
         StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/riciannoise2.dwi") );
         delete  m_Parameters.m_NoiseModel;
     }
 
     void ChiSquareNoise()
     {
         mitk::ChiSquareNoiseModel<short>* chiSquareNoiseModel = new mitk::ChiSquareNoiseModel<short>();
         chiSquareNoiseModel->SetNoiseVariance(1000000);
         chiSquareNoiseModel->SetSeed(0);
         m_Parameters.m_NoiseModel = chiSquareNoiseModel;
         StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/chisquarenoise2.dwi") );
         delete  m_Parameters.m_NoiseModel;
     }
 
     void Distortions()
     {
         mitk::Image::Pointer mitkFMap = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode( GetTestDataFilePath("DiffusionImaging/Fiberfox/Fieldmap.nrrd") )->GetData());
         typedef itk::Image<double, 3> ItkDoubleImgType;
         ItkDoubleImgType::Pointer fMap = ItkDoubleImgType::New();
         mitk::CastToItkImage(mitkFMap, fMap);
         m_Parameters.m_SignalGen.m_FrequencyMap = fMap;
         StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/distortions2.dwi") );
     }
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkFiberfoxAddArtifactsToDwi)
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxSignalGenerationTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxSignalGenerationTest.cpp
index 2e0ae2c4b5..1e73c01dce 100644
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxSignalGenerationTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxSignalGenerationTest.cpp
@@ -1,273 +1,293 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include <mitkTestingMacros.h>
 #include <mitkIOUtil.h>
 #include <mitkFiberBundleX.h>
 #include <itkTractsToDWIImageFilter.h>
 #include <mitkFiberfoxParameters.h>
 #include <mitkStickModel.h>
 #include <mitkTensorModel.h>
 #include <mitkBallModel.h>
 #include <mitkDotModel.h>
 #include <mitkAstroStickModel.h>
-#include <mitkDiffusionImage.h>
+#include <mitkImage.h>
 #include <itkTestingComparisonImageFilter.h>
 #include <itkImageRegionConstIterator.h>
 #include <mitkRicianNoiseModel.h>
 #include <mitkChiSquareNoiseModel.h>
 #include <mitkIOUtil.h>
+#include <mitkDiffusionPropertyHelper.h>
+#include <mitkProperties.h>
+#include <mitkITKImageImport.h>
+#include <mitkImageCast.h>
+
+#include <itkVectorImage.h>
+
+typedef itk::VectorImage< short, 3>   ItkDwiType;
 
 /**Documentation
  * Test the Fiberfox simulation functions (fiberBundle -> diffusion weighted image)
  */
 bool CompareDwi(itk::VectorImage< short, 3 >* dwi1, itk::VectorImage< short, 3 >* dwi2)
 {
     typedef itk::VectorImage< short, 3 > DwiImageType;
     try{
         itk::ImageRegionIterator< DwiImageType > it1(dwi1, dwi1->GetLargestPossibleRegion());
         itk::ImageRegionIterator< DwiImageType > it2(dwi2, dwi2->GetLargestPossibleRegion());
         while(!it1.IsAtEnd())
         {
             if (it1.Get()!=it2.Get())
                 return false;
             ++it1;
             ++it2;
         }
     }
     catch(...)
     {
         return false;
     }
     return true;
 }
 
-void StartSimulation(FiberfoxParameters<double> parameters, FiberBundleX::Pointer fiberBundle, mitk::DiffusionImage<short>::Pointer refImage, string message)
+void StartSimulation(FiberfoxParameters<double> parameters, FiberBundleX::Pointer fiberBundle, mitk::Image::Pointer refImage, string message)
 {
     itk::TractsToDWIImageFilter< short >::Pointer tractsToDwiFilter = itk::TractsToDWIImageFilter< short >::New();
     tractsToDwiFilter->SetUseConstantRandSeed(true);
     tractsToDwiFilter->SetParameters(parameters);
     tractsToDwiFilter->SetFiberBundle(fiberBundle);
     tractsToDwiFilter->Update();
 
-    mitk::DiffusionImage<short>::Pointer testImage = mitk::DiffusionImage<short>::New();
-    testImage->SetVectorImage( tractsToDwiFilter->GetOutput() );
-    testImage->SetReferenceBValue(parameters.m_SignalGen.m_Bvalue);
-    testImage->SetDirections(parameters.m_SignalGen.GetGradientDirections());
-    testImage->InitializeFromVectorImage();
+    mitk::Image::Pointer testImage = mitk::GrabItkImageMemory( tractsToDwiFilter->GetOutput() );
+    testImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( parameters.m_SignalGen.GetGradientDirections() ) );
+    testImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( parameters.m_SignalGen.m_Bvalue ) );
+
+    mitk::DiffusionPropertyHelper propertyHelper( testImage );
+    propertyHelper.InitializeImage();
 
     if (refImage.IsNotNull())
     {
-        bool cond = CompareDwi(testImage->GetVectorImage(), refImage->GetVectorImage());
+      if( static_cast<mitk::GradientDirectionsProperty*>( refImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer().IsNotNull() )
+      {
+        ItkDwiType::Pointer itkTestImagePointer = ItkDwiType::New();
+        mitk::CastToItkImage(testImage, itkTestImagePointer);
+        ItkDwiType::Pointer itkRefImagePointer = ItkDwiType::New();
+        mitk::CastToItkImage(refImage, itkRefImagePointer);
+
+        bool cond = CompareDwi(itkTestImagePointer, itkRefImagePointer);
         if (!cond)
         {
-            MITK_INFO << "Saving test and rference image to " << mitk::IOUtil::GetTempPath();
-            mitk::IOUtil::SaveBaseData(testImage, mitk::IOUtil::GetTempPath()+"testImage.dwi");
-            mitk::IOUtil::SaveBaseData(refImage, mitk::IOUtil::GetTempPath()+"refImage.dwi");
+          MITK_INFO << "Saving test and rference image to " << mitk::IOUtil::GetTempPath();
+          mitk::IOUtil::SaveBaseData(testImage, mitk::IOUtil::GetTempPath()+"testImage.nrrd");
+          mitk::IOUtil::SaveBaseData(refImage, mitk::IOUtil::GetTempPath()+"refImage.nrrd");
         }
         MITK_TEST_CONDITION_REQUIRED(cond, message);
+      }
     }
 }
 
 int mitkFiberfoxSignalGenerationTest(int argc, char* argv[])
 {
     MITK_TEST_BEGIN("mitkFiberfoxSignalGenerationTest");
 
     MITK_TEST_CONDITION_REQUIRED(argc>=19,"check for input data");
 
     // input fiber bundle
     FiberBundleX::Pointer fiberBundle = dynamic_cast<FiberBundleX*>(mitk::IOUtil::Load(argv[1])[0].GetPointer());
 
     // reference diffusion weighted images
-    mitk::DiffusionImage<short>::Pointer stickBall = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[2])->GetData());
-    mitk::DiffusionImage<short>::Pointer stickAstrosticks = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[3])->GetData());
-    mitk::DiffusionImage<short>::Pointer stickDot = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[4])->GetData());
-    mitk::DiffusionImage<short>::Pointer tensorBall = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[5])->GetData());
-    mitk::DiffusionImage<short>::Pointer stickTensorBall = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[6])->GetData());
-    mitk::DiffusionImage<short>::Pointer stickTensorBallAstrosticks = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[7])->GetData());
-    mitk::DiffusionImage<short>::Pointer gibbsringing = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[8])->GetData());
-    mitk::DiffusionImage<short>::Pointer ghost = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[9])->GetData());
-    mitk::DiffusionImage<short>::Pointer aliasing = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[10])->GetData());
-    mitk::DiffusionImage<short>::Pointer eddy = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[11])->GetData());
-    mitk::DiffusionImage<short>::Pointer linearmotion = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[12])->GetData());
-    mitk::DiffusionImage<short>::Pointer randommotion = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[13])->GetData());
-    mitk::DiffusionImage<short>::Pointer spikes = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[14])->GetData());
-    mitk::DiffusionImage<short>::Pointer riciannoise = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[15])->GetData());
-    mitk::DiffusionImage<short>::Pointer chisquarenoise = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[16])->GetData());
-    mitk::DiffusionImage<short>::Pointer distortions = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[17])->GetData());
+    mitk::Image::Pointer stickBall = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[2])->GetData());
+    mitk::Image::Pointer stickAstrosticks = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[3])->GetData());
+    mitk::Image::Pointer stickDot = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[4])->GetData());
+    mitk::Image::Pointer tensorBall = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[5])->GetData());
+    mitk::Image::Pointer stickTensorBall = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[6])->GetData());
+    mitk::Image::Pointer stickTensorBallAstrosticks = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[7])->GetData());
+    mitk::Image::Pointer gibbsringing = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[8])->GetData());
+    mitk::Image::Pointer ghost = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[9])->GetData());
+    mitk::Image::Pointer aliasing = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[10])->GetData());
+    mitk::Image::Pointer eddy = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[11])->GetData());
+    mitk::Image::Pointer linearmotion = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[12])->GetData());
+    mitk::Image::Pointer randommotion = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[13])->GetData());
+    mitk::Image::Pointer spikes = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[14])->GetData());
+    mitk::Image::Pointer riciannoise = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[15])->GetData());
+    mitk::Image::Pointer chisquarenoise = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[16])->GetData());
+    mitk::Image::Pointer distortions = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[17])->GetData());
     mitk::Image::Pointer mitkFMap = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[18])->GetData());
     typedef itk::Image<double, 3> ItkDoubleImgType;
     ItkDoubleImgType::Pointer fMap = ItkDoubleImgType::New();
     mitk::CastToItkImage(mitkFMap, fMap);
 
+    ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+  mitk::CastToItkImage(stickBall, itkVectorImagePointer);
+
     FiberfoxParameters<double> parameters;
     parameters.m_SignalGen.m_SimulateKspaceAcquisition = true;
     parameters.m_SignalGen.m_SignalScale = 10000;
-    parameters.m_SignalGen.m_ImageRegion = stickBall->GetVectorImage()->GetLargestPossibleRegion();
-    parameters.m_SignalGen.m_ImageSpacing = stickBall->GetVectorImage()->GetSpacing();
-    parameters.m_SignalGen.m_ImageOrigin = stickBall->GetVectorImage()->GetOrigin();
-    parameters.m_SignalGen.m_ImageDirection = stickBall->GetVectorImage()->GetDirection();
-    parameters.m_SignalGen.m_Bvalue = stickBall->GetReferenceBValue();
-    parameters.m_SignalGen.SetGradienDirections(stickBall->GetDirections());
+    parameters.m_SignalGen.m_ImageRegion = itkVectorImagePointer->GetLargestPossibleRegion();
+    parameters.m_SignalGen.m_ImageSpacing = itkVectorImagePointer->GetSpacing();
+    parameters.m_SignalGen.m_ImageOrigin = itkVectorImagePointer->GetOrigin();
+    parameters.m_SignalGen.m_ImageDirection = itkVectorImagePointer->GetDirection();
+    parameters.m_SignalGen.m_Bvalue = static_cast<mitk::FloatProperty*>(stickBall->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue();
+    parameters.m_SignalGen.SetGradienDirections( static_cast<mitk::GradientDirectionsProperty*>( stickBall->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() );
 
     // intra and inter axonal compartments
     mitk::StickModel<double> stickModel;
     stickModel.SetBvalue(parameters.m_SignalGen.m_Bvalue);
     stickModel.SetT2(110);
     stickModel.SetDiffusivity(0.001);
     stickModel.SetGradientList(parameters.m_SignalGen.GetGradientDirections());
 
     mitk::TensorModel<double> tensorModel;
     tensorModel.SetT2(110);
     stickModel.SetBvalue(parameters.m_SignalGen.m_Bvalue);
     tensorModel.SetDiffusivity1(0.001);
     tensorModel.SetDiffusivity2(0.00025);
     tensorModel.SetDiffusivity3(0.00025);
     tensorModel.SetGradientList(parameters.m_SignalGen.GetGradientDirections());
 
     // extra axonal compartment models
     mitk::BallModel<double> ballModel;
     ballModel.SetT2(80);
     ballModel.SetBvalue(parameters.m_SignalGen.m_Bvalue);
     ballModel.SetDiffusivity(0.001);
     ballModel.SetGradientList(parameters.m_SignalGen.GetGradientDirections());
 
     mitk::AstroStickModel<double> astrosticksModel;
     astrosticksModel.SetT2(80);
     astrosticksModel.SetBvalue(parameters.m_SignalGen.m_Bvalue);
     astrosticksModel.SetDiffusivity(0.001);
     astrosticksModel.SetRandomizeSticks(true);
     astrosticksModel.SetSeed(0);
     astrosticksModel.SetGradientList(parameters.m_SignalGen.GetGradientDirections());
 
     mitk::DotModel<double> dotModel;
     dotModel.SetT2(80);
     dotModel.SetGradientList(parameters.m_SignalGen.GetGradientDirections());
 
     // noise models
     mitk::RicianNoiseModel<double>* ricianNoiseModel = new mitk::RicianNoiseModel<double>();
     ricianNoiseModel->SetNoiseVariance(1000000);
     ricianNoiseModel->SetSeed(0);
 
     // Rician noise
     mitk::ChiSquareNoiseModel<double>* chiSquareNoiseModel = new mitk::ChiSquareNoiseModel<double>();
     chiSquareNoiseModel->SetNoiseVariance(1000000);
     chiSquareNoiseModel->SetSeed(0);
 
     try{
         // Stick-Ball
         parameters.m_FiberModelList.push_back(&stickModel);
         parameters.m_NonFiberModelList.push_back(&ballModel);
         StartSimulation(parameters, fiberBundle, stickBall, argv[2]);
 
         // Srick-Astrosticks
         parameters.m_NonFiberModelList.clear();
         parameters.m_NonFiberModelList.push_back(&astrosticksModel);
         StartSimulation(parameters, fiberBundle, stickAstrosticks, argv[3]);
 
         // Stick-Dot
         parameters.m_NonFiberModelList.clear();
         parameters.m_NonFiberModelList.push_back(&dotModel);
         StartSimulation(parameters, fiberBundle, stickDot, argv[4]);
 
         // Tensor-Ball
         parameters.m_FiberModelList.clear();
         parameters.m_FiberModelList.push_back(&tensorModel);
         parameters.m_NonFiberModelList.clear();
         parameters.m_NonFiberModelList.push_back(&ballModel);
         StartSimulation(parameters, fiberBundle, tensorBall, argv[5]);
 
         // Stick-Tensor-Ball
         parameters.m_FiberModelList.clear();
         parameters.m_FiberModelList.push_back(&stickModel);
         parameters.m_FiberModelList.push_back(&tensorModel);
         parameters.m_NonFiberModelList.clear();
         parameters.m_NonFiberModelList.push_back(&ballModel);
         StartSimulation(parameters, fiberBundle, stickTensorBall, argv[6]);
 
         // Stick-Tensor-Ball-Astrosticks
         parameters.m_NonFiberModelList.push_back(&astrosticksModel);
         StartSimulation(parameters, fiberBundle, stickTensorBallAstrosticks, argv[7]);
 
         // Gibbs ringing
         parameters.m_FiberModelList.clear();
         parameters.m_FiberModelList.push_back(&stickModel);
         parameters.m_NonFiberModelList.clear();
         parameters.m_NonFiberModelList.push_back(&ballModel);
         parameters.m_SignalGen.m_DoAddGibbsRinging = true;
         StartSimulation(parameters, fiberBundle, gibbsringing, argv[8]);
 
         // Ghost
         parameters.m_SignalGen.m_DoAddGibbsRinging = false;
         parameters.m_SignalGen.m_KspaceLineOffset = 0.25;
         StartSimulation(parameters, fiberBundle, ghost, argv[9]);
 
         // Aliasing
         parameters.m_SignalGen.m_KspaceLineOffset = 0;
         parameters.m_SignalGen.m_CroppingFactor = 0.4;
         parameters.m_SignalGen.m_SignalScale = 1000;
         StartSimulation(parameters, fiberBundle, aliasing, argv[10]);
 
         // Eddy currents
         parameters.m_SignalGen.m_CroppingFactor = 1;
         parameters.m_SignalGen.m_SignalScale = 10000;
         parameters.m_SignalGen.m_EddyStrength = 0.05;
         StartSimulation(parameters, fiberBundle, eddy, argv[11]);
 
         // Motion (linear)
         parameters.m_SignalGen.m_EddyStrength = 0.0;
         parameters.m_SignalGen.m_DoAddMotion = true;
         parameters.m_SignalGen.m_DoRandomizeMotion = false;
         parameters.m_SignalGen.m_Translation[1] = 10;
         parameters.m_SignalGen.m_Rotation[2] = 90;
         StartSimulation(parameters, fiberBundle, linearmotion, argv[12]);
 
         // Motion (random)
         parameters.m_SignalGen.m_DoRandomizeMotion = true;
         parameters.m_SignalGen.m_Translation[1] = 5;
         parameters.m_SignalGen.m_Rotation[2] = 45;
         StartSimulation(parameters, fiberBundle, randommotion, argv[13]);
 
         // Spikes
         parameters.m_SignalGen.m_DoAddMotion = false;
         parameters.m_SignalGen.m_Spikes = 5;
         parameters.m_SignalGen.m_SpikeAmplitude = 1;
         StartSimulation(parameters, fiberBundle, spikes, argv[14]);
 
         // Rician noise
         parameters.m_SignalGen.m_Spikes = 0;
         parameters.m_NoiseModel = ricianNoiseModel;
         StartSimulation(parameters, fiberBundle, riciannoise, argv[15]);
         delete parameters.m_NoiseModel;
 
         // Chi-square noise
         parameters.m_NoiseModel = chiSquareNoiseModel;
         StartSimulation(parameters, fiberBundle, chisquarenoise, argv[16]);
         delete parameters.m_NoiseModel;
 
         // Distortions
         parameters.m_NoiseModel = NULL;
         parameters.m_SignalGen.m_FrequencyMap = fMap;
         StartSimulation(parameters, fiberBundle, distortions, argv[17]);
     }
     catch (std::exception &e)
     {
         MITK_TEST_CONDITION_REQUIRED(false, e.what());
     }
 
     // always end with this!
     MITK_TEST_END();
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/mitkPeakExtractionTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkPeakExtractionTest.cpp
index 4ee5ff9d27..6110dc612f 100755
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkPeakExtractionTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkPeakExtractionTest.cpp
@@ -1,109 +1,108 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include <itkImageFileWriter.h>
 #include <itkResampleImageFilter.h>
 #include <itkFiniteDiffOdfMaximaExtractionFilter.h>
 
 #include <mitkBaseDataIOFactory.h>
-#include <mitkDiffusionImage.h>
 #include <mitkQBallImage.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <mitkTensorImage.h>
 
 #include <mitkCoreObjectFactory.h>
 #include <itkShCoefficientImageImporter.h>
 #include <itkFlipImageFilter.h>
 #include <boost/lexical_cast.hpp>
 #include <boost/algorithm/string.hpp>
 #include <mitkTestingMacros.h>
 #include <mitkIOUtil.h>
 
 using namespace std;
 
 int mitkPeakExtractionTest(int argc, char* argv[])
 {
     MITK_TEST_BEGIN("mitkStreamlineTrackingTest");
 
     MITK_TEST_CONDITION_REQUIRED(argc>3,"check for input data")
 
     string shCoeffFileName = argv[1];
     string maskFileName = argv[2];
     string referenceFileName = argv[3];
 
     MITK_INFO << "SH-coefficient file: " << shCoeffFileName;
     MITK_INFO << "Mask file: " << maskFileName;
     MITK_INFO << "Reference fiber file: " << referenceFileName;
 
     try
     {
         mitk::CoreObjectFactory::GetInstance();
 
         mitk::Image::Pointer image = mitk::IOUtil::LoadImage(shCoeffFileName);
         mitk::Image::Pointer mitkMaskImage = mitk::IOUtil::LoadImage(maskFileName);
 
         typedef itk::Image<unsigned char, 3>  ItkUcharImgType;
         typedef itk::FiniteDiffOdfMaximaExtractionFilter< float, 4, 20242 > MaximaExtractionFilterType;
         MaximaExtractionFilterType::Pointer filter = MaximaExtractionFilterType::New();
 
         MITK_INFO << "Casting mask image ...";
         ItkUcharImgType::Pointer itkMask = ItkUcharImgType::New();
         mitk::CastToItkImage(mitkMaskImage, itkMask);
         filter->SetMaskImage(itkMask);
 
         MITK_INFO << "Casting SH image ...";
         typedef mitk::ImageToItk< MaximaExtractionFilterType::CoefficientImageType > CasterType;
         CasterType::Pointer caster = CasterType::New();
         caster->SetInput(image);
         caster->Update();
         filter->SetInput(caster->GetOutput());
         filter->SetMaxNumPeaks(2);
         filter->SetPeakThreshold(0.4);
         filter->SetAbsolutePeakThreshold(0.01);
         filter->SetAngularThreshold(25);
         filter->SetNormalizationMethod(MaximaExtractionFilterType::MAX_VEC_NORM);
         filter->SetNumberOfThreads(1);
         MITK_INFO << "Starting extraction ...";
         filter->Update();
         mitk::FiberBundleX::Pointer fib1 = filter->GetOutputFiberBundle();
 
         MITK_INFO << "Loading reference ...";
         const std::string s1="", s2="";
         std::vector<mitk::BaseData::Pointer> infile = mitk::BaseDataIO::LoadBaseDataFromFile( referenceFileName, s1, s2, false );
         mitk::FiberBundleX::Pointer fib2 = dynamic_cast<mitk::FiberBundleX*>(infile.at(0).GetPointer());
 
         // TODO: reduce epsilon. strange issues with differing values between windows and linux.
         MITK_TEST_CONDITION_REQUIRED(fib1->Equals(fib2), "Check if tractograms are equal.");
     }
     catch (itk::ExceptionObject e)
     {
         MITK_INFO << e;
         return EXIT_FAILURE;
     }
     catch (std::exception e)
     {
         MITK_INFO << e.what();
         return EXIT_FAILURE;
     }
     catch (...)
     {
         MITK_INFO << "ERROR!?!";
         return EXIT_FAILURE;
     }
 
     MITK_TEST_END();
 }
diff --git a/Modules/DiffusionImaging/MiniApps/CopyGeometry.cpp b/Modules/DiffusionImaging/MiniApps/CopyGeometry.cpp
index de9023fb32..7fb1ae16ac 100755
--- a/Modules/DiffusionImaging/MiniApps/CopyGeometry.cpp
+++ b/Modules/DiffusionImaging/MiniApps/CopyGeometry.cpp
@@ -1,86 +1,81 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include <mitkImageCast.h>
-#include <mitkDiffusionImage.h>
+#include <mitkImage.h>
 #include <mitkBaseDataIOFactory.h>
 #include <mitkIOUtil.h>
 #include "mitkCommandLineParser.h"
 
 using namespace mitk;
 
 
 int main(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
 
     parser.setTitle("Copy Geometry");
     parser.setCategory("Preprocessing Tools");
     parser.setDescription("");
     parser.setContributor("MBI");
 
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("in", "i", mitkCommandLineParser::InputFile, "Input:", "input image", us::Any(), false);
     parser.addArgument("ref", "r", mitkCommandLineParser::InputFile, "Reference:", "reference image", us::Any(), false);
     parser.addArgument("out", "o", mitkCommandLineParser::OutputFile, "Output:", "output image", us::Any(), false);
 
     map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     // mandatory arguments
     string imageName = us::any_cast<string>(parsedArgs["in"]);
     string refImage = us::any_cast<string>(parsedArgs["ref"]);
     string outImage = us::any_cast<string>(parsedArgs["out"]);
 
     try
     {
         const std::string s1="", s2="";
         std::vector<BaseData::Pointer> infile = BaseDataIO::LoadBaseDataFromFile( refImage, s1, s2, false );
         Image::Pointer source = dynamic_cast<Image*>(infile.at(0).GetPointer());
         infile = BaseDataIO::LoadBaseDataFromFile( imageName, s1, s2, false );
         Image::Pointer target = dynamic_cast<Image*>(infile.at(0).GetPointer());
 
         mitk::BaseGeometry* s_geom = source->GetGeometry();
         mitk::BaseGeometry* t_geom = target->GetGeometry();
 
         t_geom->SetIndexToWorldTransform(s_geom->GetIndexToWorldTransform());
         target->SetGeometry(t_geom);
 
-        if ( dynamic_cast<DiffusionImage<short>*>(target.GetPointer()) )
-        {
-            mitk::IOUtil::Save(dynamic_cast<DiffusionImage<short>*>(target.GetPointer()), outImage.c_str());
-        }
-        else
-            mitk::IOUtil::SaveImage(target, outImage);
+        mitk::IOUtil::Save(target.GetPointer(), outImage.c_str());
     }
     catch (itk::ExceptionObject e)
     {
         std::cout << e;
         return EXIT_FAILURE;
     }
     catch (std::exception e)
     {
         std::cout << e.what();
         return EXIT_FAILURE;
     }
     catch (...)
     {
         std::cout << "ERROR!?!";
         return EXIT_FAILURE;
     }
     return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/MiniApps/DICOMLoader.cpp b/Modules/DiffusionImaging/MiniApps/DICOMLoader.cpp
index f62f43f2c2..e84237b798 100644
--- a/Modules/DiffusionImaging/MiniApps/DICOMLoader.cpp
+++ b/Modules/DiffusionImaging/MiniApps/DICOMLoader.cpp
@@ -1,272 +1,277 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include "mitkBaseDataIOFactory.h"
-#include "mitkDiffusionImage.h"
+#include "mitkImage.h"
 #include "mitkBaseData.h"
+#include <mitkDiffusionPropertyHelper.h>
+#include <mitkImageCast.h>
+#include <mitkITKImageImport.h>
 
 #include <itkImageFileWriter.h>
 #include <itkNrrdImageIO.h>
 #include "mitkCommandLineParser.h"
 #include <itksys/SystemTools.hxx>
 #include <itksys/Directory.hxx>
 
 #include "mitkDiffusionDICOMFileReader.h"
 #include "mitkDICOMTagBasedSorter.h"
 #include "mitkDICOMSortByTag.h"
 
 #include "itkMergeDiffusionImagesFilter.h"
 #include <mitkIOUtil.h>
 
 static mitk::StringList& GetInputFilenames()
 {
   static mitk::StringList inputs;
   return inputs;
 }
 
 void SetInputFileNames( std::string input_directory )
 {
   // I. Get all files in directory
   itksys::Directory input;
   input.Load( input_directory.c_str() );
 
   // II. Push back files
   mitk::StringList inputlist;//, mergedlist;
   for( unsigned long idx=0; idx<input.GetNumberOfFiles(); idx++)
   {
     if( ! itksys::SystemTools::FileIsDirectory( input.GetFile(idx)) )
     {
       std::string fullpath = input_directory + "/" + std::string( input.GetFile(idx) );
       inputlist.push_back(  itksys::SystemTools::ConvertToOutputPath( fullpath.c_str() ) );
 
       MITK_INFO("dicom.loader.inputdir.addfile") << input.GetFile(idx);
     }
   }
 
   /*mergedlist.reserve( GetInputFilenames().size() + inputlist.size() );
 
   mergedlist.insert( mergedlist.end(), GetInputFilenames().begin(), GetInputFilenames().end() );
   mergedlist.insert( mergedlist.end(), inputlist.begin(), inputlist.end() );*/
 
   GetInputFilenames() = inputlist;//mergedlist;
 
   MITK_INFO("dicom.loader.setinputfiles.end") << "[]";
 }
 
 
-mitk::DiffusionImage<short>::Pointer ReadInDICOMFiles( mitk::StringList& input_files, std::string output_file )
+mitk::Image::Pointer ReadInDICOMFiles( mitk::StringList& input_files, std::string output_file )
 {
   // repeat test with some more realistic sorting
   mitk::DiffusionDICOMFileReader::Pointer gdcmReader = mitk::DiffusionDICOMFileReader::New(); // this also tests destruction
   mitk::DICOMTagBasedSorter::Pointer tagSorter = mitk::DICOMTagBasedSorter::New();
 
   // Use tags as in Qmitk
   // all the things that split by tag in DicomSeriesReader
   tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0028, 0x0010) ); // Number of Rows
   tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0028, 0x0011) ); // Number of Columns
   tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0028, 0x0030) ); // Pixel Spacing
   tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0018, 0x1164) ); // Imager Pixel Spacing
   tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0020, 0x0037) ); // Image Orientation (Patient) // TODO add tolerance parameter (l. 1572 of original code)
   tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0018, 0x0050) ); // Slice Thickness
   tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0028, 0x0008) ); // Number of Frames
   tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0020, 0x0052) ); // Frame of Reference UID
 
   mitk::DICOMSortCriterion::ConstPointer sorting =
       mitk::DICOMSortByTag::New( mitk::DICOMTag(0x0020, 0x0013), // instance number
                                  mitk::DICOMSortByTag::New( mitk::DICOMTag(0x0020, 0x0012) //acquisition number
                                                             ).GetPointer()
                                  ).GetPointer();
   tagSorter->SetSortCriterion( sorting );
 
   MITK_INFO("dicom.loader.read.init") << "[]" ;
   MITK_INFO("dicom.loader.read.inputs") << " " << input_files.size();
 
   gdcmReader->SetInputFiles( input_files );
   gdcmReader->AddSortingElement( tagSorter );
   gdcmReader->AnalyzeInputFiles();
   gdcmReader->LoadImages();
 
   mitk::Image::Pointer loaded_image = gdcmReader->GetOutput(0).GetMitkImage();
 
-  mitk::DiffusionImage<short>::Pointer d_img = static_cast<mitk::DiffusionImage<short>*>( loaded_image.GetPointer() );
-
-  return d_img;
+  return loaded_image;
 }
 
 typedef short DiffusionPixelType;
 typedef itk::VectorImage<DiffusionPixelType,3>         DwiImageType;
 typedef DwiImageType::PixelType                        DwiPixelType;
 typedef DwiImageType::RegionType                       DwiRegionType;
 typedef std::vector< DwiImageType::Pointer >  DwiImageContainerType;
 
-typedef mitk::DiffusionImage<DiffusionPixelType>              DiffusionImageType;
-typedef DiffusionImageType::GradientDirectionContainerType    GradientContainerType;
+typedef mitk::Image          DiffusionImageType;
+typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType    GradientContainerType;
 typedef std::vector< GradientContainerType::Pointer >  GradientListContainerType;
 
 void SearchForInputInSubdirs( std::string root_directory, std::string subdir_prefix , std::vector<DiffusionImageType::Pointer>& output_container)
 {
   // I. Get all dirs in directory
   itksys::Directory rootdir;
   rootdir.Load( root_directory.c_str() );
 
   MITK_INFO("dicom.loader.setinputdirs.start") << "Prefix = " << subdir_prefix;
 
   for( unsigned int idx=0; idx<rootdir.GetNumberOfFiles(); idx++)
   {
     std::string current_path = rootdir.GetFile(idx);
 
     std::string directory_path = std::string(rootdir.GetPath()) + std::string("/") + current_path;
 
     MITK_INFO("dicom.loader.inputrootdir.test") << "ProbePath:   " << current_path;
     MITK_INFO("dicom.loader.inputrootdir.test") << "IsDirectory: " << itksys::SystemTools::FileIsDirectory( itksys::SystemTools::ConvertToOutputPath( directory_path.c_str() ).c_str() )
                                                 << " StartsWith: " << itksys::SystemTools::StringStartsWith( current_path.c_str(), subdir_prefix.c_str() );
 
     // test for prefix
     if(    itksys::SystemTools::FileIsDirectory( itksys::SystemTools::ConvertToOutputPath( directory_path.c_str() ).c_str() )
            && itksys::SystemTools::StringStartsWith( current_path.c_str(), subdir_prefix.c_str() )
            )
     {
 
       MITK_INFO("dicom.loader.inputrootdir.searchin") << directory_path;
       SetInputFileNames( itksys::SystemTools::ConvertToOutputPath( directory_path.c_str() ) );
 
       MITK_INFO("dicom.loader.inputrootdir.preload") << "[]" ;
       DiffusionImageType::Pointer dwi = ReadInDICOMFiles( GetInputFilenames(), "" );
 
       output_container.push_back( dwi );
 
 
     }
   }
 
   MITK_INFO("dicom.loader.setinputdirs.end") << "[]";
 }
 
 
 
 using namespace mitk;
 /**
  * Read DICOM Files through the new (refactored) Diffusion DICOM Loader. It serves also as a first test of the new functionality, it will replace the
  * current loading mechanism after the necessary parts are merged into the master branch.
  */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("inputdir", "i", mitkCommandLineParser::String, "Input Directory" ,"input directory containing dicom files", us::Any(), false);
   parser.addArgument("output", "o", mitkCommandLineParser::String, "Output File Name", "output file", us::Any(), false);
   parser.addArgument("dwprefix", "p", mitkCommandLineParser::String, "Recursive Scan Prefix", "prefix for subfolders search rootdir is specified by the 'inputdir' argument value", us::Any(), true);
   parser.addArgument("dryrun", "-s", mitkCommandLineParser::Bool, "Dry run","do not read, only look for input files ", us::Any(), true );
 
   map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
   {
     return EXIT_FAILURE;
   }
 
   std::string inputDirectory = us::any_cast<std::string>( parsedArgs["inputdir"] );
   MITK_INFO << "Loading data from directory: " << inputDirectory;
 
   // retrieve the prefix flag (if set)
   bool search_for_subdirs = false;
   std::string subdir_prefix;
   if( parsedArgs.count("dwprefix"))
   {
     MITK_INFO << "Prefix specified, will search for subdirs in the input directory!";
     subdir_prefix = us::any_cast<std::string>( parsedArgs["dwprefix"] );
     search_for_subdirs = true;
   }
 
   // retrieve the output
   std::string outputFile = us::any_cast< std::string >( parsedArgs["output"] );
 
   // if the executable is called with a single directory, just parse the given folder for files and read them into a diffusion image
   if( !search_for_subdirs )
   {
     SetInputFileNames( inputDirectory );
 
     MITK_INFO << "Got " << GetInputFilenames().size() << " input files.";
-    mitk::DiffusionImage<short>::Pointer d_img = ReadInDICOMFiles( GetInputFilenames(), outputFile );
+    mitk::Image::Pointer d_img = ReadInDICOMFiles( GetInputFilenames(), outputFile );
 
     try
     {
       mitk::IOUtil::Save(d_img, outputFile.c_str());
     }
     catch( const itk::ExceptionObject& e)
     {
       MITK_ERROR << "Failed to write out the output file. \n\t Reason : ITK Exception " << e.what();
     }
 
   }
   // if the --dwprefix flag is set, then we have to look for the directories, load each of them separately and afterwards merge the images
   else
   {
-    std::vector<mitk::DiffusionImage<DiffusionPixelType>::Pointer> output_container;
+    std::vector<mitk::Image::Pointer> output_container;
 
     SearchForInputInSubdirs( inputDirectory, subdir_prefix, output_container );
 
     // final output image
-    mitk::DiffusionImage<DiffusionPixelType>::Pointer image = mitk::DiffusionImage<DiffusionPixelType>::New();
+    mitk::Image::Pointer image = mitk::Image::New();
     if( output_container.size() > 1 )
     {
       DwiImageContainerType       imageContainer;
       GradientListContainerType   gradientListContainer;
       std::vector< double >       bValueContainer;
 
-      for ( std::vector< mitk::DiffusionImage<DiffusionPixelType>::Pointer >::iterator dwi = output_container.begin();
-            dwi != output_container.end(); ++dwi )
+      for ( std::vector< mitk::Image::Pointer >::iterator dwi = output_container.begin();
+        dwi != output_container.end(); ++dwi )
       {
-        imageContainer.push_back((*dwi)->GetVectorImage());
-        gradientListContainer.push_back((*dwi)->GetDirections());
-        bValueContainer.push_back((*dwi)->GetReferenceBValue());
+        mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
+        mitk::CastToItkImage(*dwi, itkVectorImagePointer);
+
+        imageContainer.push_back(itkVectorImagePointer);
+        gradientListContainer.push_back( mitk::DiffusionPropertyHelper::GetGradientContainer(*dwi));
+        bValueContainer.push_back( mitk::DiffusionPropertyHelper::GetReferenceBValue(*dwi));
       }
 
       typedef itk::MergeDiffusionImagesFilter<short> FilterType;
       FilterType::Pointer filter = FilterType::New();
       filter->SetImageVolumes(imageContainer);
       filter->SetGradientLists(gradientListContainer);
       filter->SetBValues(bValueContainer);
       filter->Update();
 
       vnl_matrix_fixed< double, 3, 3 > mf; mf.set_identity();
 
-      image->SetVectorImage( filter->GetOutput() );
-      image->SetReferenceBValue(filter->GetB_Value());
-      image->SetDirections(filter->GetOutputGradients());
-      image->SetMeasurementFrame(mf);
-      image->InitializeFromVectorImage();
+      image = mitk::GrabItkImageMemory( filter->GetOutput() );
+      image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( filter->GetOutputGradients() ) );
+      image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( filter->GetB_Value() ) );
+      image->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( mf ) );
+      mitk::DiffusionPropertyHelper propertyHelper( image );
+      propertyHelper.InitializeImage();
     }
     // just output the image if there was only one folder found
     else
     {
       image = output_container.at(0);
     }
 
     MITK_INFO("dicom.import.writeout") << " [OutputFile] " << outputFile.c_str();
 
     try
     {
       mitk::IOUtil::Save(image, outputFile.c_str());
     }
     catch( const itk::ExceptionObject& e)
     {
       MITK_ERROR << "Failed to write out the output file. \n\t Reason : ITK Exception " << e.what();
     }
 
   }
 
   return 1;
 }
diff --git a/Modules/DiffusionImaging/MiniApps/DwiDenoising.cpp b/Modules/DiffusionImaging/MiniApps/DwiDenoising.cpp
index 83f8f18544..f30bfd5189 100644
--- a/Modules/DiffusionImaging/MiniApps/DwiDenoising.cpp
+++ b/Modules/DiffusionImaging/MiniApps/DwiDenoising.cpp
@@ -1,156 +1,163 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include <mitkImageCast.h>
 #include <mitkBaseDataIOFactory.h>
 #include "mitkCommandLineParser.h"
 #include <boost/algorithm/string.hpp>
-#include <DiffusionWeightedImages/mitkDiffusionImage.h>
+#include <mitkImage.h>
 #include <itkNonLocalMeansDenoisingFilter.h>
 #include <itkImage.h>
 #include <mitkIOUtil.h>
+#include <mitkDiffusionPropertyHelper.h>
+#include <mitkImageCast.h>
+#include <mitkITKImageImport.h>
+#include <mitkProperties.h>
 
-typedef mitk::DiffusionImage<short> DiffusionImageType;
+typedef mitk::Image DiffusionImageType;
 typedef itk::Image<short, 3> ImageType;
 
 mitk::BaseData::Pointer LoadFile(std::string filename)
 {
   if( filename.empty() )
     return NULL;
 
   const std::string s1="", s2="";
   std::vector<mitk::BaseData::Pointer> infile = mitk::BaseDataIO::LoadBaseDataFromFile( filename, s1, s2, false );
   if( infile.empty() )
   {
     std::cout << "File " << filename << " could not be read!";
     return NULL;
   }
 
   mitk::BaseData::Pointer baseData = infile.at(0);
   return baseData;
 }
 
 /**
  * Denoises DWI using the Nonlocal - Means algorithm
  */
 int main(int argc, char* argv[])
 {
     std::cout << "DwiDenoising";
   mitkCommandLineParser parser;
 
   parser.setTitle("DWI Denoising");
   parser.setCategory("Preprocessing Tools");
   parser.setContributor("MBI");
   parser.setDescription("Denoising for diffusion weighted images using a non-local means algorithm.");
 
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input:", "input image (DWI)", us::Any(), false);
   parser.addArgument("variance", "v", mitkCommandLineParser::Float, "Variance:", "noise variance", us::Any(), false);
 
   parser.addArgument("mask", "m", mitkCommandLineParser::InputFile, "Mask:", "brainmask for input image", us::Any(), true);
   parser.addArgument("search", "s", mitkCommandLineParser::Int, "Search radius:", "search radius", us::Any(), true);
   parser.addArgument("compare", "c", mitkCommandLineParser::Int, "Comparison radius:", "comparison radius", us::Any(), true);
   parser.addArgument("joint", "j", mitkCommandLineParser::Bool, "Joint information:", "use joint information");
   parser.addArgument("rician", "r", mitkCommandLineParser::Bool, "Rician adaption:", "use rician adaption");
 
   parser.changeParameterGroup("Output", "Output of this miniapp");
 
   parser.addArgument("output", "o", mitkCommandLineParser::OutputFile, "Output:", "output image (DWI)", us::Any(), false);
 
   map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
       return EXIT_FAILURE;
 
   string inFileName = us::any_cast<string>(parsedArgs["input"]);
   double variance = static_cast<double>(us::any_cast<float>(parsedArgs["variance"]));
   string maskName;
   if (parsedArgs.count("mask"))
     maskName = us::any_cast<string>(parsedArgs["mask"]);
   string outFileName = us::any_cast<string>(parsedArgs["output"]);
 //  boost::algorithm::erase_all(outFileName, ".dwi");
   int search = 4;
   if (parsedArgs.count("search"))
     search = us::any_cast<int>(parsedArgs["search"]);
   int compare = 1;
   if (parsedArgs.count("compare"))
     compare = us::any_cast<int>(parsedArgs["compare"]);
   bool joint = false;
   if (parsedArgs.count("joint"))
     joint = true;
   bool rician = false;
   if (parsedArgs.count("rician"))
     rician = true;
 
   try
   {
 
     if( boost::algorithm::ends_with(inFileName, ".dwi"))
     {
 
       DiffusionImageType::Pointer dwi = dynamic_cast<DiffusionImageType*>(LoadFile(inFileName).GetPointer());
 
+      mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
+      mitk::CastToItkImage(dwi, itkVectorImagePointer);
+
       itk::NonLocalMeansDenoisingFilter<short>::Pointer filter = itk::NonLocalMeansDenoisingFilter<short>::New();
       filter->SetNumberOfThreads(12);
-      filter->SetInputImage(dwi->GetVectorImage());
+      filter->SetInputImage( itkVectorImagePointer );
 
       if (!maskName.empty())
       {
         mitk::Image::Pointer mask = dynamic_cast<mitk::Image*>(LoadFile(maskName).GetPointer());
         ImageType::Pointer itkMask = ImageType::New();
         mitk::CastToItkImage(mask, itkMask);
         filter->SetInputMask(itkMask);
       }
 
       filter->SetUseJointInformation(joint);
       filter->SetUseRicianAdaption(rician);
       filter->SetSearchRadius(search);
       filter->SetComparisonRadius(compare);
       filter->SetVariance(variance);
       filter->Update();
 
-      DiffusionImageType::Pointer output = DiffusionImageType::New();
-      output->SetVectorImage(filter->GetOutput());
-      output->SetReferenceBValue(dwi->GetReferenceBValue());
-      output->SetDirections(dwi->GetDirections());
-      output->InitializeFromVectorImage();
+      DiffusionImageType::Pointer output = mitk::GrabItkImageMemory( filter->GetOutput() );
+      output->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi) ) );
+      output->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi) ) );
+      mitk::DiffusionPropertyHelper propertyHelper( output );
+      propertyHelper.InitializeImage();
 
 //      std::stringstream name;
 //      name << outFileName << "_NLM_" << search << "-" << compare << "-" << variance << ".dwi";
 
       mitk::IOUtil::Save(output, outFileName.c_str());
     }
     else
     {
       std::cout << "Only supported for .dwi!";
     }
   }
   catch (itk::ExceptionObject e)
   {
       std::cout << e;
       return EXIT_FAILURE;
   }
   catch (std::exception e)
   {
       std::cout << e.what();
       return EXIT_FAILURE;
   }
   catch (...)
   {
       std::cout << "ERROR!?!";
       return EXIT_FAILURE;
   }
   return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/MiniApps/FiberDirectionExtraction.cpp b/Modules/DiffusionImaging/MiniApps/FiberDirectionExtraction.cpp
index 3bf5e834b8..c50a85159d 100755
--- a/Modules/DiffusionImaging/MiniApps/FiberDirectionExtraction.cpp
+++ b/Modules/DiffusionImaging/MiniApps/FiberDirectionExtraction.cpp
@@ -1,174 +1,174 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include <mitkBaseDataIOFactory.h>
 #include <mitkBaseData.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <metaCommand.h>
 #include "mitkCommandLineParser.h"
 #include <usAny.h>
 #include <itkImageFileWriter.h>
 #include <mitkIOUtil.h>
 #include <boost/lexical_cast.hpp>
 #include <itkEvaluateDirectionImagesFilter.h>
 #include <itkTractsToVectorImageFilter.h>
 #include <mitkCoreObjectFactory.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 int main(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
 
     parser.setTitle("Fiber Direction Extraction");
     parser.setCategory("Fiber Tracking and Processing Methods");
     parser.setDescription("");
     parser.setContributor("MBI");
 
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input:", "input tractogram (.fib/.trk)", us::Any(), false);
     parser.addArgument("out", "o", mitkCommandLineParser::OutputDirectory, "Output:", "output root", us::Any(), false);
     parser.addArgument("mask", "m", mitkCommandLineParser::InputFile, "Mask:", "mask image");
     parser.addArgument("athresh", "a", mitkCommandLineParser::Float, "Angular threshold:", "angular threshold in degrees. closer fiber directions are regarded as one direction and clustered together.", 25, true);
     parser.addArgument("peakthresh", "t", mitkCommandLineParser::Float, "Peak size threshold:", "peak size threshold relative to largest peak in voxel", 0.2, true);
     parser.addArgument("verbose", "v", mitkCommandLineParser::Bool, "Verbose:", "output optional and intermediate calculation results");
     parser.addArgument("numdirs", "d", mitkCommandLineParser::Int, "Max. num. directions:", "maximum number of fibers per voxel", 3, true);
     parser.addArgument("normalize", "n", mitkCommandLineParser::Bool, "Normalize:", "normalize vectors");
 
     map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     string fibFile = us::any_cast<string>(parsedArgs["input"]);
 
     string maskImage("");
     if (parsedArgs.count("mask"))
         maskImage = us::any_cast<string>(parsedArgs["mask"]);
 
     float peakThreshold = 0.2;
     if (parsedArgs.count("peakthresh"))
         peakThreshold = us::any_cast<float>(parsedArgs["peakthresh"]);
 
     float angularThreshold = 25;
     if (parsedArgs.count("athresh"))
         angularThreshold = us::any_cast<float>(parsedArgs["athresh"]);
 
     string outRoot = us::any_cast<string>(parsedArgs["out"]);
 
     bool verbose = false;
     if (parsedArgs.count("verbose"))
         verbose = us::any_cast<bool>(parsedArgs["verbose"]);
 
     int maxNumDirs = 3;
     if (parsedArgs.count("numdirs"))
         maxNumDirs = us::any_cast<int>(parsedArgs["numdirs"]);
 
     bool normalize = false;
     if (parsedArgs.count("normalize"))
         normalize = us::any_cast<bool>(parsedArgs["normalize"]);
 
     try
     {
         typedef itk::Image<unsigned char, 3>                                    ItkUcharImgType;
         typedef itk::Image< itk::Vector< float, 3>, 3 >                         ItkDirectionImage3DType;
         typedef itk::VectorContainer< unsigned int, ItkDirectionImage3DType::Pointer >   ItkDirectionImageContainerType;
 
         // load fiber bundle
         mitk::FiberBundleX::Pointer inputTractogram = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
 
         // load/create mask image
         ItkUcharImgType::Pointer itkMaskImage = NULL;
         if (maskImage.compare("")!=0)
         {
             std::cout << "Using mask image";
             itkMaskImage = ItkUcharImgType::New();
             mitk::Image::Pointer mitkMaskImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(maskImage)->GetData());
-            mitk::CastToItkImage<ItkUcharImgType>(mitkMaskImage, itkMaskImage);
+            mitk::CastToItkImage(mitkMaskImage, itkMaskImage);
         }
 
         // extract directions from fiber bundle
         itk::TractsToVectorImageFilter<float>::Pointer fOdfFilter = itk::TractsToVectorImageFilter<float>::New();
         fOdfFilter->SetFiberBundle(inputTractogram);
         fOdfFilter->SetMaskImage(itkMaskImage);
         fOdfFilter->SetAngularThreshold(cos(angularThreshold*M_PI/180));
         fOdfFilter->SetNormalizeVectors(normalize);
         fOdfFilter->SetUseWorkingCopy(false);
         fOdfFilter->SetSizeThreshold(peakThreshold);
         fOdfFilter->SetMaxNumDirections(maxNumDirs);
         fOdfFilter->Update();
         ItkDirectionImageContainerType::Pointer directionImageContainer = fOdfFilter->GetDirectionImageContainer();
 
         // write direction images
         for (unsigned int i=0; i<directionImageContainer->Size(); i++)
         {
             itk::TractsToVectorImageFilter<float>::ItkDirectionImageType::Pointer itkImg = directionImageContainer->GetElement(i);
             typedef itk::ImageFileWriter< itk::TractsToVectorImageFilter<float>::ItkDirectionImageType > WriterType;
             WriterType::Pointer writer = WriterType::New();
 
             string outfilename = outRoot;
             outfilename.append("_DIRECTION_");
             outfilename.append(boost::lexical_cast<string>(i));
             outfilename.append(".nrrd");
 
             writer->SetFileName(outfilename.c_str());
             writer->SetInput(itkImg);
             writer->Update();
         }
 
         if (verbose)
         {
             // write vector field
             mitk::FiberBundleX::Pointer directions = fOdfFilter->GetOutputFiberBundle();
 
             string outfilename = outRoot;
             outfilename.append("_VECTOR_FIELD.fib");
 
             mitk::IOUtil::SaveBaseData(directions.GetPointer(), outfilename );
 
             // write num direction image
             {
                 ItkUcharImgType::Pointer numDirImage = fOdfFilter->GetNumDirectionsImage();
                 typedef itk::ImageFileWriter< ItkUcharImgType > WriterType;
                 WriterType::Pointer writer = WriterType::New();
 
                 string outfilename = outRoot;
                 outfilename.append("_NUM_DIRECTIONS.nrrd");
 
                 writer->SetFileName(outfilename.c_str());
                 writer->SetInput(numDirImage);
                 writer->Update();
             }
         }
     }
     catch (itk::ExceptionObject e)
     {
         std::cout << e;
         return EXIT_FAILURE;
     }
     catch (std::exception e)
     {
         std::cout << e.what();
         return EXIT_FAILURE;
     }
     catch (...)
     {
         std::cout << "ERROR!?!";
         return EXIT_FAILURE;
     }
     return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/MiniApps/Fiberfox.cpp b/Modules/DiffusionImaging/MiniApps/Fiberfox.cpp
index e767f81004..324fecfba2 100755
--- a/Modules/DiffusionImaging/MiniApps/Fiberfox.cpp
+++ b/Modules/DiffusionImaging/MiniApps/Fiberfox.cpp
@@ -1,78 +1,80 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include <mitkImageCast.h>
-#include <mitkDiffusionImage.h>
+#include <mitkITKImageImport.h>
+#include <mitkProperties.h>
+#include <mitkImage.h>
 #include <mitkBaseDataIOFactory.h>
 #include <mitkIOUtil.h>
 #include <mitkFiberBundleX.h>
 #include <mitkFiberfoxParameters.h>
 #include "mitkCommandLineParser.h"
 
 #include <itkAddArtifactsToDwiImageFilter.h>
 #include <itkTractsToDWIImageFilter.h>
 
 #include "boost/property_tree/ptree.hpp"
 #include "boost/property_tree/xml_parser.hpp"
 #include "boost/foreach.hpp"
 
 /** TODO: Proritype signal komplett speichern oder bild mit speichern. */
 /** TODO: Tarball aus images und parametern? */
 /** TODO: Artefakte auf bild in miniapp */
 
 using namespace mitk;
 
 int main(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("out", "o", mitkCommandLineParser::OutputFile, "Output root:", "output root", us::Any(), false);
     parser.addArgument("parameters", "p", mitkCommandLineParser::InputFile, "Parameter file:", "fiberfox parameter file", us::Any(), false);
     parser.addArgument("fiberbundle", "f", mitkCommandLineParser::String, "Fiberbundle:", "", us::Any(), false);
 
     map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     string outName = us::any_cast<string>(parsedArgs["out"]);
     string paramName = us::any_cast<string>(parsedArgs["parameters"]);
 
     string fibFile = "";
     if (parsedArgs.count("fiberbundle"))
         fibFile = us::any_cast<string>(parsedArgs["fiberbundle"]);
 
     {
         FiberfoxParameters<double> parameters;
         parameters.LoadParameters(paramName);
 
         mitk::FiberBundleX::Pointer inputTractogram = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
 
         itk::TractsToDWIImageFilter< short >::Pointer tractsToDwiFilter = itk::TractsToDWIImageFilter< short >::New();
         tractsToDwiFilter->SetParameters(parameters);
         tractsToDwiFilter->SetFiberBundle(inputTractogram);
         tractsToDwiFilter->Update();
 
-        DiffusionImage<short>::Pointer image = DiffusionImage<short>::New();
-        image->SetVectorImage( tractsToDwiFilter->GetOutput() );
-        image->SetReferenceBValue( parameters.m_SignalGen.m_Bvalue );
-        image->SetDirections( parameters.m_SignalGen.GetGradientDirections() );
-        image->InitializeFromVectorImage();
+        mitk::Image::Pointer image = mitk::GrabItkImageMemory( tractsToDwiFilter->GetOutput() );
+        image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( parameters.m_SignalGen.GetGradientDirections() ) );
+        image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( parameters.m_SignalGen.m_Bvalue ) );
+        mitk::DiffusionPropertyHelper propertyHelper( image );
+        propertyHelper.InitializeImage();
 
         mitk::IOUtil::Save(image, outName.c_str());
     }
     return EXIT_SUCCESS;
 }
 
diff --git a/Modules/DiffusionImaging/MiniApps/ImageResampler.cpp b/Modules/DiffusionImaging/MiniApps/ImageResampler.cpp
index faff7c6965..a05ce2419b 100644
--- a/Modules/DiffusionImaging/MiniApps/ImageResampler.cpp
+++ b/Modules/DiffusionImaging/MiniApps/ImageResampler.cpp
@@ -1,326 +1,314 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 
 #include "mitkCommandLineParser.h"
 
 #include <mitkIOUtil.h>
 #include <mitkRegistrationWrapper.h>
 #include <mitkImage.h>
 #include <mitkImageCast.h>
 #include <mitkITKImageImport.h>
-#include <mitkDiffusionImage.h>
 #include <mitkImageTimeSelector.h>
+#include <mitkDiffusionPropertyHelper.h>
+#include <mitkProperties.h>
 
 // ITK
 #include <itksys/SystemTools.hxx>
 #include <itkDirectory.h>
 #include "itkLinearInterpolateImageFunction.h"
 #include "itkWindowedSincInterpolateImageFunction.h"
 #include "itkIdentityTransform.h"
 #include "itkResampleImageFilter.h"
 #include "itkResampleDwiImageFilter.h"
 
 typedef itk::Image<double, 3> InputImageType;
-typedef mitk::DiffusionImage<short> DiffusionImageType;
 
 
 static mitk::Image::Pointer TransformToReference(mitk::Image *reference, mitk::Image *moving, bool sincInterpol = false)
 {
   // Convert to itk Images
   InputImageType::Pointer itkReference = InputImageType::New();
   InputImageType::Pointer itkMoving = InputImageType::New();
   mitk::CastToItkImage(reference,itkReference);
   mitk::CastToItkImage(moving,itkMoving);
 
   // Identify Transform
   typedef itk::IdentityTransform<double, 3> T_Transform;
   T_Transform::Pointer _pTransform = T_Transform::New();
   _pTransform->SetIdentity();
 
   typedef itk::WindowedSincInterpolateImageFunction< InputImageType, 3> WindowedSincInterpolatorType;
   WindowedSincInterpolatorType::Pointer sinc_interpolator = WindowedSincInterpolatorType::New();
 
   typedef itk::ResampleImageFilter<InputImageType, InputImageType>  ResampleFilterType;
 
 
   ResampleFilterType::Pointer resampler = ResampleFilterType::New();
   resampler->SetInput(itkMoving);
   resampler->SetReferenceImage( itkReference );
   resampler->UseReferenceImageOn();
   resampler->SetTransform(_pTransform);
   resampler->SetInterpolator(sinc_interpolator);
   resampler->Update();
 
   // Convert back to mitk
   mitk::Image::Pointer result = mitk::Image::New();
   result->InitializeByItk(resampler->GetOutput());
   GrabItkImageMemory( resampler->GetOutput() , result );
   return result;
 }
 
 
 static std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems)
 {
   std::stringstream ss(s);
   std::string item;
   while (std::getline(ss, item, delim))
   {
     elems.push_back(item);
   }
   return elems;
 }
 
 static std::vector<std::string> split(const std::string &s, char delim)
 {
   std::vector < std::string > elems;
   return split(s, delim, elems);
 }
 
 
 static mitk::Image::Pointer ResampleBySpacing(mitk::Image *input, float *spacing, bool useLinInt = true)
 {
   InputImageType::Pointer itkImage = InputImageType::New();
   CastToItkImage(input,itkImage);
 
   /**
    * 1) Resampling
    *
    */
   // Identity transform.
   // We don't want any transform on our image except rescaling which is not
   // specified by a transform but by the input/output spacing as we will see
   // later.
   // So no transform will be specified.
   typedef itk::IdentityTransform<double, 3> T_Transform;
 
   // The resampler type itself.
   typedef itk::ResampleImageFilter<InputImageType, InputImageType>  T_ResampleFilter;
 
   // Prepare the resampler.
   // Instantiate the transform and specify it should be the id transform.
   T_Transform::Pointer _pTransform = T_Transform::New();
   _pTransform->SetIdentity();
 
   // Instantiate the resampler. Wire in the transform and the interpolator.
   T_ResampleFilter::Pointer _pResizeFilter = T_ResampleFilter::New();
 
   // Specify the input.
   _pResizeFilter->SetInput(itkImage);
 
   _pResizeFilter->SetTransform(_pTransform);
 
   // Set the output origin.
   _pResizeFilter->SetOutputOrigin(itkImage->GetOrigin());
 
   // Compute the size of the output.
   // The size (# of pixels) in the output is recomputed using
   // the ratio of the input and output sizes.
   InputImageType::SpacingType inputSpacing = itkImage->GetSpacing();
   InputImageType::SpacingType outputSpacing;
   const InputImageType::RegionType& inputSize = itkImage->GetLargestPossibleRegion();
 
   InputImageType::SizeType outputSize;
   typedef InputImageType::SizeType::SizeValueType SizeValueType;
 
   // Set the output spacing.
   outputSpacing[0] = spacing[0];
   outputSpacing[1] = spacing[1];
   outputSpacing[2] = spacing[2];
 
   outputSize[0] = static_cast<SizeValueType>(inputSize.GetSize()[0] * inputSpacing[0] / outputSpacing[0] + .5);
   outputSize[1] = static_cast<SizeValueType>(inputSize.GetSize()[1] * inputSpacing[1] / outputSpacing[1] + .5);
   outputSize[2] = static_cast<SizeValueType>(inputSize.GetSize()[2] * inputSpacing[2] / outputSpacing[2] + .5);
 
   _pResizeFilter->SetOutputSpacing(outputSpacing);
   _pResizeFilter->SetSize(outputSize);
 
   typedef itk::LinearInterpolateImageFunction< InputImageType > LinearInterpolatorType;
   LinearInterpolatorType::Pointer lin_interpolator = LinearInterpolatorType::New();
 
   typedef itk::WindowedSincInterpolateImageFunction< InputImageType, 4> WindowedSincInterpolatorType;
   WindowedSincInterpolatorType::Pointer sinc_interpolator = WindowedSincInterpolatorType::New();
 
   if (useLinInt)
     _pResizeFilter->SetInterpolator(lin_interpolator);
   else
     _pResizeFilter->SetInterpolator(sinc_interpolator);
 
   _pResizeFilter->Update();
 
   mitk::Image::Pointer image = mitk::Image::New();
   image->InitializeByItk(_pResizeFilter->GetOutput());
   mitk::GrabItkImageMemory( _pResizeFilter->GetOutput(), image);
   return image;
 }
 
 /// Save images according to file type
 static void SaveImage(std::string fileName, mitk::Image* image, std::string fileType )
 {
   std::cout << "----Save to " << fileName;
 
-  if (fileType == "dwi") // IOUtil does not handle dwi files properly Bug 15772
-  {
-    try
-    {
-      mitk::IOUtil::Save(dynamic_cast<mitk::DiffusionImage<short>*>(image), fileName.c_str());
-    }
-    catch( const itk::ExceptionObject& e)
-    {
-      MITK_ERROR << "Caught exception: " << e.what();
-      mitkThrow() << "Failed with exception from subprocess!";
-    }
-  }
-  else
-  {
-    mitk::IOUtil::SaveImage(image, fileName);
-  }
+  mitk::IOUtil::Save(image, fileName);
 }
 
-DiffusionImageType::Pointer ResampleDWIbySpacing(DiffusionImageType::Pointer input, float* spacing, bool useLinInt = true)
+mitk::Image::Pointer ResampleDWIbySpacing(mitk::Image::Pointer input, float* spacing, bool useLinInt = true)
 {
 
   itk::Vector<double, 3> spacingVector;
   spacingVector[0] = spacing[0];
   spacingVector[1] = spacing[1];
   spacingVector[2] = spacing[2];
 
   typedef itk::ResampleDwiImageFilter<short> ResampleFilterType;
 
+  mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
+  mitk::CastToItkImage(input, itkVectorImagePointer);
+
   ResampleFilterType::Pointer resampler = ResampleFilterType::New();
-  resampler->SetInput(input->GetVectorImage());
+  resampler->SetInput( itkVectorImagePointer );
   resampler->SetInterpolation(ResampleFilterType::Interpolate_Linear);
   resampler->SetNewSpacing(spacingVector);
   resampler->Update();
 
-  DiffusionImageType::Pointer output = DiffusionImageType::New();
-  output->SetVectorImage(resampler->GetOutput());
-  output->SetDirections(input->GetDirections());
-  output->SetReferenceBValue(input->GetReferenceBValue());
-  output->InitializeFromVectorImage();
+  mitk::Image::Pointer output = mitk::GrabItkImageMemory( resampler->GetOutput() );
+  output->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( mitk::DiffusionPropertyHelper::GetGradientContainer(input) ) );
+  output->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( mitk::DiffusionPropertyHelper::GetReferenceBValue(input) ) );
+  mitk::DiffusionPropertyHelper propertyHelper( output );
+  propertyHelper.InitializeImage();
 
   return output;
 }
 
 int main( int argc, char* argv[] )
 {
   mitkCommandLineParser parser;
   parser.setArgumentPrefix("--","-");
 
   parser.setTitle("Image Resampler");
   parser.setCategory("Preprocessing Tools");
   parser.setContributor("MBI");
   parser.setDescription("Resample an image to eigther a specific spacing or to a reference image.");
 
   // Add command line argument names
   parser.addArgument("help", "h",mitkCommandLineParser::Bool, "Show this help text");
   parser.addArgument("input", "i", mitkCommandLineParser::InputImage, "Input:", "Input file",us::Any(),false);
   parser.addArgument("output", "o", mitkCommandLineParser::OutputDirectory, "Output:", "Output folder (ending with /)",us::Any(),false);
   parser.addArgument("spacing", "s", mitkCommandLineParser::String, "Spacing:", "Resample provide x,y,z spacing in mm (e.g. -r 1,1,3), is not applied to tensor data",us::Any());
   parser.addArgument("reference", "r", mitkCommandLineParser::String, "Reference:", "Resample using supplied reference image. Also cuts image to same dimensions",us::Any());
   parser.addArgument("win-sinc", "w", mitkCommandLineParser::Bool, "Windowed-sinc interpolation:", "Use windowed-sinc interpolation (3) instead of linear interpolation ",us::Any());
 
 
   map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
 
   // Handle special arguments
   bool useSpacing = false;
   bool useLinearInterpol = true;
   {
     if (parsedArgs.size() == 0)
     {
       return EXIT_FAILURE;
     }
 
     if (parsedArgs.count("sinc-int"))
       useLinearInterpol = false;
 
     // Show a help message
     if ( parsedArgs.count("help") || parsedArgs.count("h"))
     {
       std::cout << parser.helpText();
       return EXIT_SUCCESS;
     }
    }
 
   std::string outputPath = us::any_cast<string>(parsedArgs["output"]);
   std::string inputFile = us::any_cast<string>(parsedArgs["input"]);
 
   std::vector<std::string> spacings;
   float spacing[3];
   if (parsedArgs.count("spacing"))
   {
     std::string arg =  us::any_cast<string>(parsedArgs["spacing"]);
     spacings = split(arg ,',');
     spacing[0] = atoi(spacings.at(0).c_str());
     spacing[1] = atoi(spacings.at(1).c_str());
     spacing[2] = atoi(spacings.at(2).c_str());
     useSpacing = true;
   }
 
   std::string refImageFile = "";
   if (parsedArgs.count("reference"))
   {
     refImageFile =  us::any_cast<string>(parsedArgs["reference"]);
   }
 
   if (refImageFile =="" && useSpacing == false)
   {
     MITK_ERROR << "No information how to resample is supplied. Use eigther --spacing or --reference !";
     return EXIT_FAILURE;
   }
 
 
   mitk::Image::Pointer refImage;
   if (!useSpacing)
       refImage = mitk::IOUtil::LoadImage(refImageFile);
 
-  DiffusionImageType::Pointer inputDWI = dynamic_cast<DiffusionImageType*>(mitk::IOUtil::LoadBaseData(inputFile).GetPointer());
-  if (inputDWI.IsNotNull())
+  mitk::Image::Pointer inputDWI = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadBaseData(inputFile).GetPointer());
+  if ( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(inputDWI))
   {
-    DiffusionImageType::Pointer outputImage;
+    mitk::Image::Pointer outputImage;
 
     if (useSpacing)
       outputImage = ResampleDWIbySpacing(inputDWI, spacing);
     else
     {
       MITK_WARN << "Not supported yet, to resample a DWI please set a new spacing.";
       return EXIT_FAILURE;
     }
 
     std::string fileStem = itksys::SystemTools::GetFilenameWithoutExtension(inputFile);
 
     std::string outName(outputPath + fileStem + "_res.dwi");
     mitk::IOUtil::Save(outputImage, outName.c_str());
 
     return EXIT_SUCCESS;
   }
   mitk::Image::Pointer inputImage = mitk::IOUtil::LoadImage(inputFile);
 
 
   mitk::Image::Pointer resultImage;
 
   if (useSpacing)
     resultImage = ResampleBySpacing(inputImage,spacing);
   else
     resultImage = TransformToReference(refImage,inputImage);
 
   std::string fileStem = itksys::SystemTools::GetFilenameWithoutExtension(inputFile);
 
   mitk::IOUtil::SaveImage(resultImage, outputPath + fileStem + "_res.nrrd");
 
   return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/MiniApps/MultishellMethods.cpp b/Modules/DiffusionImaging/MiniApps/MultishellMethods.cpp
index 687ed57bf1..bc81479de8 100644
--- a/Modules/DiffusionImaging/MiniApps/MultishellMethods.cpp
+++ b/Modules/DiffusionImaging/MiniApps/MultishellMethods.cpp
@@ -1,215 +1,219 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 #include <vector>
 #include <iostream>
 #include <fstream>
 #include <algorithm>
 #include <string>
 
 #include <itkImage.h>
 #include <itkImageFileReader.h>
 #include <itkExceptionObject.h>
 #include <itkImageFileWriter.h>
 #include <itkMetaDataObject.h>
 #include <itkVectorImage.h>
 #include <itkResampleImageFilter.h>
 
 #include <mitkBaseDataIOFactory.h>
-#include <mitkDiffusionImage.h>
+#include <mitkImage.h>
 #include <mitkQBallImage.h>
 #include <mitkBaseData.h>
 #include <mitkFiberBundleX.h>
 #include "mitkCommandLineParser.h"
 #include <boost/lexical_cast.hpp>
 
 #include <itkRadialMultishellToSingleshellImageFilter.h>
 #include <itkADCAverageFunctor.h>
 #include <itkBiExpFitFunctor.h>
 #include <itkKurtosisFitFunctor.h>
 #include <itkDwiGradientLengthCorrectionFilter.h>
 #include <mitkIOUtil.h>
+#include <mitkDiffusionPropertyHelper.h>
+#include <mitkProperties.h>
+#include <mitkImageCast.h>
+#include <mitkITKImageImport.h>
 
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Multishell Methods");
   parser.setCategory("Fiber Tracking and Processing Methods");
   parser.setDescription("");
   parser.setContributor("MBI");
 
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("in", "i", mitkCommandLineParser::InputFile, "Input:", "input file", us::Any(), false);
   parser.addArgument("out", "o", mitkCommandLineParser::OutputFile, "Output:", "output file", us::Any(), false);
   parser.addArgument("adc", "D", mitkCommandLineParser::Bool, "ADC:", "ADC Average", us::Any(), false);
   parser.addArgument("akc", "K", mitkCommandLineParser::Bool, "Kurtosis fit:", "Kurtosis Fit", us::Any(), false);
   parser.addArgument("biexp", "B", mitkCommandLineParser::Bool, "BiExp fit:", "BiExp fit", us::Any(), false);
   parser.addArgument("targetbvalue", "b", mitkCommandLineParser::String, "b Value:", "target bValue (mean, min, max)", us::Any(), false);
 
   map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   // mandatory arguments
   string inName = us::any_cast<string>(parsedArgs["in"]);
   string outName = us::any_cast<string>(parsedArgs["out"]);
   bool applyADC = us::any_cast<bool>(parsedArgs["adc"]);
   bool applyAKC = us::any_cast<bool>(parsedArgs["akc"]);
   bool applyBiExp = us::any_cast<bool>(parsedArgs["biexp"]);
   string targetType = us::any_cast<string>(parsedArgs["targetbvalue"]);
 
   try
   {
     std::cout << "Loading " << inName;
     const std::string s1="", s2="";
     std::vector<mitk::BaseData::Pointer> infile = mitk::BaseDataIO::LoadBaseDataFromFile( inName, s1, s2, false );
     mitk::BaseData::Pointer baseData = infile.at(0);
 
-    if ( dynamic_cast<mitk::DiffusionImage<short>*>(baseData.GetPointer()) )
+    if ( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image*>(baseData.GetPointer()) ) )
     {
-      mitk::DiffusionImage<short>::Pointer dwi = dynamic_cast<mitk::DiffusionImage<short>*>(baseData.GetPointer());
+      mitk::Image::Pointer dwi = dynamic_cast<mitk::Image*>(baseData.GetPointer());
       typedef itk::RadialMultishellToSingleshellImageFilter<short, short> FilterType;
 
       typedef itk::DwiGradientLengthCorrectionFilter  CorrectionFilterType;
 
       CorrectionFilterType::Pointer roundfilter = CorrectionFilterType::New();
       roundfilter->SetRoundingValue( 1000 );
-      roundfilter->SetReferenceBValue(dwi->GetReferenceBValue());
-      roundfilter->SetReferenceGradientDirectionContainer(dwi->GetDirections());
+      roundfilter->SetReferenceBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue( dwi ));
+      roundfilter->SetReferenceGradientDirectionContainer(mitk::DiffusionPropertyHelper::GetGradientContainer(dwi));
       roundfilter->Update();
 
-      dwi->SetReferenceBValue( roundfilter->GetNewBValue() );
-      dwi->SetDirections( roundfilter->GetOutputGradientDirectionContainer());
+      dwi->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( roundfilter->GetNewBValue()  ) );
+      dwi->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( roundfilter->GetOutputGradientDirectionContainer() ) );
 
       // filter input parameter
-      const mitk::DiffusionImage<short>::BValueMap
-          &originalShellMap  = dwi->GetBValueMap();
+      const mitk::DiffusionPropertyHelper::BValueMapType
+        &originalShellMap  = mitk::DiffusionPropertyHelper::GetBValueMap(dwi);
 
-      const mitk::DiffusionImage<short>::ImageType
-          *vectorImage       = dwi->GetVectorImage();
+      mitk::DiffusionPropertyHelper::ImageType::Pointer vectorImage = mitk::DiffusionPropertyHelper::ImageType::New();
+      mitk::CastToItkImage(dwi, vectorImage);
 
-      const mitk::DiffusionImage<short>::GradientDirectionContainerType::Pointer
-          gradientContainer = dwi->GetDirections();
+      const mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer
+          gradientContainer = mitk::DiffusionPropertyHelper::GetGradientContainer(dwi);
 
       const unsigned int
-          &bValue            = dwi->GetReferenceBValue();
+          &bValue            = mitk::DiffusionPropertyHelper::GetReferenceBValue( dwi );
 
       // filter call
 
 
       vnl_vector<double> bValueList(originalShellMap.size()-1);
       double targetBValue = bValueList.mean();
 
-      mitk::DiffusionImage<short>::BValueMap::const_iterator it = originalShellMap.begin();
+      mitk::DiffusionPropertyHelper::BValueMapType::const_iterator it = originalShellMap.begin();
       ++it; int i = 0 ;
       for(; it != originalShellMap.end(); ++it)
         bValueList.put(i++,it->first);
 
       if( targetType == "mean" )
         targetBValue = bValueList.mean();
       else if( targetType == "min" )
         targetBValue = bValueList.min_value();
       else if( targetType == "max" )
         targetBValue = bValueList.max_value();
 
       if(applyADC)
       {
         FilterType::Pointer filter = FilterType::New();
         filter->SetInput(vectorImage);
         filter->SetOriginalGradientDirections(gradientContainer);
         filter->SetOriginalBValueMap(originalShellMap);
         filter->SetOriginalBValue(bValue);
 
         itk::ADCAverageFunctor::Pointer functor = itk::ADCAverageFunctor::New();
         functor->setListOfBValues(bValueList);
         functor->setTargetBValue(targetBValue);
 
         filter->SetFunctor(functor);
         filter->Update();
         // create new DWI image
-        mitk::DiffusionImage<short>::Pointer outImage = mitk::DiffusionImage<short>::New();
-        outImage->SetVectorImage( filter->GetOutput() );
-        outImage->SetReferenceBValue( targetBValue );
-        outImage->SetDirections( filter->GetTargetGradientDirections() );
-        outImage->InitializeFromVectorImage();
+        mitk::Image::Pointer outImage = mitk::GrabItkImageMemory( filter->GetOutput() );
+        outImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( targetBValue  ) );
+        outImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( filter->GetTargetGradientDirections() ) );
+        mitk::DiffusionPropertyHelper propertyHelper( outImage );
+        propertyHelper.InitializeImage();
 
         mitk::IOUtil::Save(outImage, (outName + "_ADC.dwi").c_str());
       }
       if(applyAKC)
       {
         FilterType::Pointer filter = FilterType::New();
         filter->SetInput(vectorImage);
         filter->SetOriginalGradientDirections(gradientContainer);
         filter->SetOriginalBValueMap(originalShellMap);
         filter->SetOriginalBValue(bValue);
 
         itk::KurtosisFitFunctor::Pointer functor = itk::KurtosisFitFunctor::New();
         functor->setListOfBValues(bValueList);
         functor->setTargetBValue(targetBValue);
 
         filter->SetFunctor(functor);
         filter->Update();
         // create new DWI image
-        mitk::DiffusionImage<short>::Pointer outImage = mitk::DiffusionImage<short>::New();
-        outImage->SetVectorImage( filter->GetOutput() );
-        outImage->SetReferenceBValue( targetBValue );
-        outImage->SetDirections( filter->GetTargetGradientDirections() );
-        outImage->InitializeFromVectorImage();
+        mitk::Image::Pointer outImage = mitk::GrabItkImageMemory( filter->GetOutput() );
+        outImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( targetBValue  ) );
+        outImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( filter->GetTargetGradientDirections() ) );
+        mitk::DiffusionPropertyHelper propertyHelper( outImage );
+        propertyHelper.InitializeImage();
 
         mitk::IOUtil::Save(outImage, (string(outName) + "_AKC.dwi").c_str());
       }
       if(applyBiExp)
       {
         FilterType::Pointer filter = FilterType::New();
         filter->SetInput(vectorImage);
         filter->SetOriginalGradientDirections(gradientContainer);
         filter->SetOriginalBValueMap(originalShellMap);
         filter->SetOriginalBValue(bValue);
 
         itk::BiExpFitFunctor::Pointer functor = itk::BiExpFitFunctor::New();
         functor->setListOfBValues(bValueList);
         functor->setTargetBValue(targetBValue);
 
         filter->SetFunctor(functor);
         filter->Update();
         // create new DWI image
-        mitk::DiffusionImage<short>::Pointer outImage = mitk::DiffusionImage<short>::New();
-        outImage->SetVectorImage( filter->GetOutput() );
-        outImage->SetReferenceBValue( targetBValue );
-        outImage->SetDirections( filter->GetTargetGradientDirections() );
-        outImage->InitializeFromVectorImage();
+        mitk::Image::Pointer outImage = mitk::GrabItkImageMemory( filter->GetOutput() );
+        outImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( targetBValue  ) );
+        outImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( filter->GetTargetGradientDirections() ) );
+        mitk::DiffusionPropertyHelper propertyHelper( outImage );
+        propertyHelper.InitializeImage();
 
         mitk::IOUtil::Save(outImage, (string(outName) + "_BiExp.dwi").c_str());
       }
     }
   }
   catch (itk::ExceptionObject e)
   {
     std::cout << e;
     return EXIT_FAILURE;
   }
   catch (std::exception e)
   {
     std::cout << e.what();
     return EXIT_FAILURE;
   }
   catch (...)
   {
     std::cout << "ERROR!?!";
     return EXIT_FAILURE;
   }
   return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/MiniApps/NetworkStatistics.cpp b/Modules/DiffusionImaging/MiniApps/NetworkStatistics.cpp
index 1fe492899c..2d124f8659 100644
--- a/Modules/DiffusionImaging/MiniApps/NetworkStatistics.cpp
+++ b/Modules/DiffusionImaging/MiniApps/NetworkStatistics.cpp
@@ -1,515 +1,516 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // std includes
 #include <string>
 #include <sstream>
 #include <fstream>
 #include <vector>
 #include <map>
 #include <utility>
 
 // boost includes
 #include <boost/algorithm/string.hpp>
 
 // ITK includes
 #include <itkImageFileWriter.h>
 
 // CTK includes
 #include "mitkCommandLineParser.h"
 
 // MITK includes
 #include <mitkBaseDataIOFactory.h>
 #include <mitkConnectomicsStatisticsCalculator.h>
 #include <mitkConnectomicsNetworkThresholder.h>
 #include <itkConnectomicsNetworkToConnectivityMatrixImageFilter.h>
 
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
   parser.setArgumentPrefix("--", "-");
+
   parser.addArgument("inputNetwork", "i", mitkCommandLineParser::InputFile, "Input network", "input connectomics network (.cnf)", us::Any(), false);
   parser.addArgument("outputFile", "o", mitkCommandLineParser::OutputFile, "Output file", "name of output file", us::Any(), false);
 
   parser.addArgument("noGlobalStatistics", "g", mitkCommandLineParser::Bool, "No global statistics", "Do not calculate global statistics");
   parser.addArgument("createConnectivityMatriximage", "I", mitkCommandLineParser::Bool, "Write connectivity matrix image", "Write connectivity matrix image");
   parser.addArgument("binaryConnectivity", "b", mitkCommandLineParser::Bool, "Binary connectivity", "Whether to create a binary connectivity matrix");
   parser.addArgument("rescaleConnectivity", "r", mitkCommandLineParser::Bool, "Rescale connectivity", "Whether to rescale the connectivity matrix");
   parser.addArgument("localStatistics", "L", mitkCommandLineParser::StringList, "Local statistics", "Provide a list of node labels for local statistics", us::Any());
   parser.addArgument("regionList", "R", mitkCommandLineParser::StringList, "Region list", "A space separated list of regions. Each region has the format\n regionname;label1;label2;...;labelN", us::Any());
   parser.addArgument("granularity", "gr", mitkCommandLineParser::Int, "Granularity", "How finely to test the density range and how many thresholds to consider");
   parser.addArgument("startDensity", "d", mitkCommandLineParser::Float, "Start Density", "Largest density for the range");
   parser.addArgument("thresholdStepSize", "t", mitkCommandLineParser::Int, "Step size threshold", "Distance of two adjacent thresholds");
 
   parser.setCategory("Connectomics");
   parser.setTitle("Network Statistics");
   parser.setDescription("");
   parser.setContributor("MBI");
 
   map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   //default values
   bool noGlobalStatistics( false );
   bool binaryConnectivity( false );
   bool rescaleConnectivity( false );
   bool createConnectivityMatriximage( false );
   int granularity( 1 );
   double startDensity( 1.0 );
   int thresholdStepSize( 3 );
 
 
   // parse command line arguments
   std::string networkName = us::any_cast<std::string>(parsedArgs["inputNetwork"]);
   std::string outName = us::any_cast<std::string>(parsedArgs["outputFile"]);
 
   mitkCommandLineParser::StringContainerType localLabels;
 
   if(parsedArgs.count("localStatistics"))
   {
     localLabels = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["localStatistics"]);
   }
 
   mitkCommandLineParser::StringContainerType unparsedRegions;
   std::map< std::string, std::vector<std::string> > parsedRegions;
   std::map< std::string, std::vector<std::string> >::iterator parsedRegionsIterator;
 
   if(parsedArgs.count("regionList"))
   {
     unparsedRegions = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["regionList"]);
 
     for(unsigned int index(0); index < unparsedRegions.size(); index++ )
     {
       std::vector< std::string > tempRegionVector;
 
       boost::split(tempRegionVector, unparsedRegions.at(index), boost::is_any_of(";"));
 
       std::vector< std::string >::const_iterator begin = tempRegionVector.begin();
       std::vector< std::string >::const_iterator last = tempRegionVector.begin() + tempRegionVector.size();
       std::vector< std::string > insertRegionVector(begin + 1, last);
 
       if( parsedRegions.count( tempRegionVector.at(0) ) == 0 )
       {
         parsedRegions.insert( std::pair< std::string, std::vector<std::string>  >( tempRegionVector.at(0), insertRegionVector) );
       }
       else
       {
         MITK_ERROR << "Region already exists. Skipping second occurrence.";
       }
     }
   }
 
   if (parsedArgs.count("noGlobalStatistics"))
     noGlobalStatistics = us::any_cast<bool>(parsedArgs["noGlobalStatistics"]);
   if (parsedArgs.count("binaryConnectivity"))
     binaryConnectivity = us::any_cast<bool>(parsedArgs["binaryConnectivity"]);
   if (parsedArgs.count("rescaleConnectivity"))
     rescaleConnectivity = us::any_cast<bool>(parsedArgs["rescaleConnectivity"]);
   if (parsedArgs.count("createConnectivityMatriximage"))
     createConnectivityMatriximage = us::any_cast<bool>(parsedArgs["createConnectivityMatriximage"]);
   if (parsedArgs.count("granularity"))
     granularity = us::any_cast<int>(parsedArgs["granularity"]);
   if (parsedArgs.count("startDensity"))
     startDensity = us::any_cast<float>(parsedArgs["startDensity"]);
   if (parsedArgs.count("thresholdStepSize"))
     thresholdStepSize = us::any_cast<int>(parsedArgs["thresholdStepSize"]);
 
   try
   {
     const std::string s1="", s2="";
 
     // load network
     std::vector<mitk::BaseData::Pointer> networkFile =
       mitk::BaseDataIO::LoadBaseDataFromFile( networkName, s1, s2, false );
     if( networkFile.empty() )
     {
       std::string errorMessage = "File at " + networkName + " could not be read. Aborting.";
       MITK_ERROR << errorMessage;
       return EXIT_FAILURE;
     }
     mitk::BaseData* networkBaseData = networkFile.at(0);
     mitk::ConnectomicsNetwork* network = dynamic_cast<mitk::ConnectomicsNetwork*>( networkBaseData );
 
     if( !network )
     {
       std::string errorMessage = "Read file at " + networkName + " could not be recognized as network. Aborting.";
       MITK_ERROR << errorMessage;
       return EXIT_FAILURE;
     }
 
     // streams
     std::stringstream globalHeaderStream;
     globalHeaderStream  << "NumberOfVertices "
       << "NumberOfEdges "
       << "AverageDegree "
       << "ConnectionDensity "
       << "NumberOfConnectedComponents "
       << "AverageComponentSize "
       << "LargestComponentSize "
       << "RatioOfNodesInLargestComponent "
       << "HopPlotExponent "
       << "EffectiveHopDiameter "
       << "AverageClusteringCoefficientsC "
       << "AverageClusteringCoefficientsD "
       << "AverageClusteringCoefficientsE "
       << "AverageVertexBetweennessCentrality "
       << "AverageEdgeBetweennessCentrality "
       << "NumberOfIsolatedPoints "
       << "RatioOfIsolatedPoints "
       << "NumberOfEndPoints "
       << "RatioOfEndPoints "
       << "Diameter "
       << "Diameter90 "
       << "Radius "
       << "Radius90 "
       << "AverageEccentricity "
       << "AverageEccentricity90 "
       << "AveragePathLength "
       << "NumberOfCentralPoints "
       << "RatioOfCentralPoints "
       << "SpectralRadius "
       << "SecondLargestEigenValue "
       << "AdjacencyTrace "
       << "AdjacencyEnergy "
       << "LaplacianTrace "
       << "LaplacianEnergy "
       << "LaplacianSpectralGap "
       << "NormalizedLaplacianTrace "
       << "NormalizedLaplacianEnergy "
       << "NormalizedLaplacianNumberOf2s "
       << "NormalizedLaplacianNumberOf1s "
       << "NormalizedLaplacianNumberOf0s "
       << "NormalizedLaplacianLowerSlope "
       << "NormalizedLaplacianUpperSlope "
       << "SmallWorldness"
       << std::endl;
 
     std::stringstream localHeaderStream;
     std::stringstream regionalHeaderStream;
 
     std::stringstream globalDataStream;
     std::stringstream localDataStream;
     std::stringstream regionalDataStream;
 
     std::string globalOutName = outName + "_global.txt";
     std::string localOutName = outName + "_local.txt";
     std::string regionalOutName = outName + "_regional.txt";
 
     bool firstRun( true );
     // iterate over all three possible methods
     for(unsigned int method( 0 ); method < 3; method++)
     {
       // 0 - Random removal threshold
       // 1 - Largest density below threshold
       // 2 - Threshold based
 
       // iterate over possible targets
       for( unsigned int step( 0 ); step < granularity; step++ )
       {
         double targetValue( 0.0 );
         bool newStep( true );
 
         switch ( method )
         {
         case mitk::ConnectomicsNetworkThresholder::RandomRemovalOfWeakest :
         case mitk::ConnectomicsNetworkThresholder::LargestLowerThanDensity :
           targetValue = startDensity * (1 - static_cast<double>( step ) / ( granularity + 0.5 ) );
           break;
         case mitk::ConnectomicsNetworkThresholder::ThresholdBased :
           targetValue = static_cast<double>( thresholdStepSize * step );
           break;
         default:
           MITK_ERROR << "Invalid thresholding method called, aborting.";
           return EXIT_FAILURE;
           break;
         }
 
         mitk::ConnectomicsNetworkThresholder::Pointer thresholder = mitk::ConnectomicsNetworkThresholder::New();
         thresholder->SetNetwork( network );
         thresholder->SetTargetThreshold( targetValue );
         thresholder->SetTargetDensity( targetValue );
         thresholder->SetThresholdingScheme( static_cast<mitk::ConnectomicsNetworkThresholder::ThresholdingSchemes>(method) );
         mitk::ConnectomicsNetwork::Pointer thresholdedNetwork = thresholder->GetThresholdedNetwork();
 
         mitk::ConnectomicsStatisticsCalculator::Pointer statisticsCalculator = mitk::ConnectomicsStatisticsCalculator::New();
         statisticsCalculator->SetNetwork( thresholdedNetwork );
         statisticsCalculator->Update();
 
         // global statistics
         if( !noGlobalStatistics )
         {
           globalDataStream << statisticsCalculator->GetNumberOfVertices() << " "
             << statisticsCalculator->GetNumberOfEdges() << " "
             << statisticsCalculator->GetAverageDegree() << " "
             << statisticsCalculator->GetConnectionDensity() << " "
             << statisticsCalculator->GetNumberOfConnectedComponents() << " "
             << statisticsCalculator->GetAverageComponentSize() << " "
             << statisticsCalculator->GetLargestComponentSize() << " "
             << statisticsCalculator->GetRatioOfNodesInLargestComponent() << " "
             << statisticsCalculator->GetHopPlotExponent() << " "
             << statisticsCalculator->GetEffectiveHopDiameter() << " "
             << statisticsCalculator->GetAverageClusteringCoefficientsC() << " "
             << statisticsCalculator->GetAverageClusteringCoefficientsD() << " "
             << statisticsCalculator->GetAverageClusteringCoefficientsE() << " "
             << statisticsCalculator->GetAverageVertexBetweennessCentrality() << " "
             << statisticsCalculator->GetAverageEdgeBetweennessCentrality() << " "
             << statisticsCalculator->GetNumberOfIsolatedPoints() << " "
             << statisticsCalculator->GetRatioOfIsolatedPoints() << " "
             << statisticsCalculator->GetNumberOfEndPoints() << " "
             << statisticsCalculator->GetRatioOfEndPoints() << " "
             << statisticsCalculator->GetDiameter() << " "
             << statisticsCalculator->GetDiameter90() << " "
             << statisticsCalculator->GetRadius() << " "
             << statisticsCalculator->GetRadius90() << " "
             << statisticsCalculator->GetAverageEccentricity() << " "
             << statisticsCalculator->GetAverageEccentricity90() << " "
             << statisticsCalculator->GetAveragePathLength() << " "
             << statisticsCalculator->GetNumberOfCentralPoints() << " "
             << statisticsCalculator->GetRatioOfCentralPoints() << " "
             << statisticsCalculator->GetSpectralRadius() << " "
             << statisticsCalculator->GetSecondLargestEigenValue() << " "
             << statisticsCalculator->GetAdjacencyTrace() << " "
             << statisticsCalculator->GetAdjacencyEnergy() << " "
             << statisticsCalculator->GetLaplacianTrace() << " "
             << statisticsCalculator->GetLaplacianEnergy() << " "
             << statisticsCalculator->GetLaplacianSpectralGap() << " "
             << statisticsCalculator->GetNormalizedLaplacianTrace() << " "
             << statisticsCalculator->GetNormalizedLaplacianEnergy() << " "
             << statisticsCalculator->GetNormalizedLaplacianNumberOf2s() << " "
             << statisticsCalculator->GetNormalizedLaplacianNumberOf1s() << " "
             << statisticsCalculator->GetNormalizedLaplacianNumberOf0s() << " "
             << statisticsCalculator->GetNormalizedLaplacianLowerSlope() << " "
             << statisticsCalculator->GetNormalizedLaplacianUpperSlope() << " "
             << statisticsCalculator->GetSmallWorldness()
             << std::endl;
 
         } // end global statistics
 
         //create connectivity matrix png
         if( createConnectivityMatriximage )
         {
           std::string connectivity_png_postfix = "_connectivity";
           if( binaryConnectivity )
           {
             connectivity_png_postfix += "_binary";
           }
           else if( rescaleConnectivity )
           {
             connectivity_png_postfix += "_rescaled";
           }
           connectivity_png_postfix += ".png";
 
           /* File format
           * A png file depicting the binary connectivity matrix
           */
           itk::ConnectomicsNetworkToConnectivityMatrixImageFilter::Pointer filter = itk::ConnectomicsNetworkToConnectivityMatrixImageFilter::New();
           filter->SetInputNetwork( network );
           filter->SetBinaryConnectivity( binaryConnectivity );
           filter->SetRescaleConnectivity( rescaleConnectivity );
           filter->Update();
 
           typedef itk::ConnectomicsNetworkToConnectivityMatrixImageFilter::OutputImageType connectivityMatrixImageType;
 
           itk::ImageFileWriter< connectivityMatrixImageType >::Pointer connectivityWriter = itk::ImageFileWriter< connectivityMatrixImageType >::New();
 
           connectivityWriter->SetInput( filter->GetOutput() );
           connectivityWriter->SetFileName( outName + connectivity_png_postfix);
           connectivityWriter->Update();
 
           std::cout << "Connectivity matrix image written.";
         } // end create connectivity matrix png
 
         /*
          * We can either calculate local indices for specific nodes, or specific regions
          */
 
         // Create LabelToIndex translation
         std::map< std::string, int > labelToIdMap;
         std::vector< mitk::ConnectomicsNetwork::NetworkNode > nodeVector = thresholdedNetwork->GetVectorOfAllNodes();
         for(int loop(0); loop < nodeVector.size(); loop++)
         {
           labelToIdMap.insert( std::pair< std::string, int>(nodeVector.at(loop).label, nodeVector.at(loop).id) );
         }
 
         std::vector< int > degreeVector = thresholdedNetwork->GetDegreeOfNodes();
         std::vector< double > ccVector = thresholdedNetwork->GetLocalClusteringCoefficients( );
         std::vector< double > bcVector = thresholdedNetwork->GetNodeBetweennessVector( );
 
 
         // calculate local indices
 
         {
           // only add to header for the first step of the first method
           if( firstRun )
           {
             localHeaderStream << "Th_method " << "Th_target " << "density";
           }
 
           double density = statisticsCalculator->GetConnectionDensity();
 
           localDataStream << "\n"
             << method << " "
             << targetValue << " "
             << density;
 
           for(unsigned int loop(0); loop < localLabels.size(); loop++ )
           {
             if( network->CheckForLabel(localLabels.at( loop )) )
             {
               if( firstRun )
               {
                 localHeaderStream  << " "
                   << localLabels.at( loop ) << "_Degree "
                   << localLabels.at( loop ) << "_CC "
                   << localLabels.at( loop ) << "_BC";
               }
 
           localDataStream  << " " << degreeVector.at( labelToIdMap.find( localLabels.at( loop ) )->second )
             << " " << ccVector.at( labelToIdMap.find( localLabels.at( loop ) )->second )
             << " " << bcVector.at( labelToIdMap.find( localLabels.at( loop ) )->second );
             }
             else
             {
               MITK_ERROR << "Illegal label. Label: \"" << localLabels.at( loop ) << "\" not found.";
             }
           }
         }
 
         // calculate regional indices
 
         {
           // only add to header for the first step of the first method
           if( firstRun )
           {
             regionalHeaderStream << "Th_method " << "Th_target " << "density";
           }
 
           double density = statisticsCalculator->GetConnectionDensity();
 
           regionalDataStream << "\n"
             << method << " "
             << targetValue << " "
             << density;
 
           for( parsedRegionsIterator = parsedRegions.begin(); parsedRegionsIterator != parsedRegions.end(); parsedRegionsIterator++ )
           {
             std::vector<std::string> regionLabelsVector = parsedRegionsIterator->second;
             std::string regionName = parsedRegionsIterator->first;
 
             double sumDegree( 0 );
             double sumCC( 0 );
             double sumBC( 0 );
             double count( 0 );
 
             for( int loop(0); loop < regionLabelsVector.size(); loop++ )
             {
               if( thresholdedNetwork->CheckForLabel(regionLabelsVector.at( loop )) )
               {
                 sumDegree = sumDegree + degreeVector.at( labelToIdMap.find( regionLabelsVector.at( loop ) )->second );
                 sumCC = sumCC + ccVector.at( labelToIdMap.find( regionLabelsVector.at( loop ) )->second );
                 sumBC = sumBC + bcVector.at( labelToIdMap.find( regionLabelsVector.at( loop ) )->second );
                 count = count + 1;
               }
               else
               {
                 MITK_ERROR << "Illegal label. Label: \"" << regionLabelsVector.at( loop ) << "\" not found.";
               }
             }
 
             // only add to header for the first step of the first method
             if( firstRun )
             {
               regionalHeaderStream  << " " << regionName << "_LocalAverageDegree "
                 << regionName << "_LocalAverageCC "
                 << regionName << "_LocalAverageBC "
                 << regionName << "_NumberOfNodes";
             }
 
             regionalDataStream  << " " << sumDegree / count
               << " " << sumCC / count
               << " " << sumBC / count
               << " " << count;
           }
         }
 
         firstRun = false;
       }
 
     }// end calculate local averages
 
     if( !noGlobalStatistics )
     {
       std::cout << "Writing to " << globalOutName;
       std::ofstream glocalOutFile( globalOutName.c_str(), ios::out );
       if( ! glocalOutFile.is_open() )
       {
         std::string errorMessage = "Could not open " + globalOutName + " for writing.";
         MITK_ERROR << errorMessage;
         return EXIT_FAILURE;
       }
       glocalOutFile << globalHeaderStream.str() << globalDataStream.str();
       glocalOutFile.close();
     }
 
     if( localLabels.size() > 0 )
     {
       std::cout << "Writing to " << localOutName;
       std::ofstream localOutFile( localOutName.c_str(), ios::out );
       if( ! localOutFile.is_open() )
       {
         std::string errorMessage = "Could not open " + localOutName + " for writing.";
         MITK_ERROR << errorMessage;
         return EXIT_FAILURE;
       }
       localOutFile << localHeaderStream.str() << localDataStream.str();
       localOutFile.close();
     }
 
     if( parsedRegions.size() > 0 )
     {
       std::cout << "Writing to " << regionalOutName;
       std::ofstream regionalOutFile( regionalOutName.c_str(), ios::out );
       if( ! regionalOutFile.is_open() )
       {
         std::string errorMessage = "Could not open " + regionalOutName + " for writing.";
         MITK_ERROR << errorMessage;
         return EXIT_FAILURE;
       }
       regionalOutFile << regionalHeaderStream.str() << regionalDataStream.str();
       regionalOutFile.close();
     }
 
     return EXIT_SUCCESS;
   }
   catch (itk::ExceptionObject e)
   {
     std::cout << e;
     return EXIT_FAILURE;
   }
   catch (std::exception e)
   {
     std::cout << e.what();
     return EXIT_FAILURE;
   }
   catch (...)
   {
     std::cout << "ERROR!?!";
     return EXIT_FAILURE;
   }
   std::cout << "DONE";
   return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/MiniApps/PeakExtraction.cpp b/Modules/DiffusionImaging/MiniApps/PeakExtraction.cpp
index bebbbee478..7f8d7c47c0 100755
--- a/Modules/DiffusionImaging/MiniApps/PeakExtraction.cpp
+++ b/Modules/DiffusionImaging/MiniApps/PeakExtraction.cpp
@@ -1,374 +1,374 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include <itkImageFileWriter.h>
 #include <itkResampleImageFilter.h>
 #include <itkFiniteDiffOdfMaximaExtractionFilter.h>
 
 #include <mitkBaseDataIOFactory.h>
-#include <mitkDiffusionImage.h>
+#include <mitkImage.h>
 #include <mitkQBallImage.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <mitkTensorImage.h>
 
 #include <mitkCoreObjectFactory.h>
 #include "mitkCommandLineParser.h"
 #include <itkShCoefficientImageImporter.h>
 #include <itkFlipImageFilter.h>
 #include <boost/lexical_cast.hpp>
 #include <boost/algorithm/string.hpp>
 
 #include <mitkIOUtil.h>
 
 mitk::Image::Pointer LoadData(std::string filename)
 {
     if( filename.empty() )
         return NULL;
 
     const std::string s1="", s2="";
     std::vector<mitk::BaseData::Pointer> infile = mitk::BaseDataIO::LoadBaseDataFromFile( filename, s1, s2, false );
     if( infile.empty() )
     {
         std::cout << "File " << filename << " could not be read!";
         return NULL;
     }
 
     mitk::BaseData::Pointer baseData = infile.at(0);
     return dynamic_cast<mitk::Image*>(baseData.GetPointer());
 }
 
 
 template<int shOrder>
 int StartPeakExtraction(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("image", "i", mitkCommandLineParser::InputFile, "Input image", "sh coefficient image", us::Any(), false);
     parser.addArgument("outroot", "o", mitkCommandLineParser::OutputDirectory, "Output directory", "output root", us::Any(), false);
     parser.addArgument("mask", "m", mitkCommandLineParser::InputFile, "Mask", "mask image");
     parser.addArgument("normalization", "n", mitkCommandLineParser::Int, "Normalization", "0=no norm, 1=max norm, 2=single vec norm", 1, true);
     parser.addArgument("numpeaks", "p", mitkCommandLineParser::Int, "Max. number of peaks", "maximum number of extracted peaks", 2, true);
     parser.addArgument("peakthres", "r", mitkCommandLineParser::Float, "Peak threshold", "peak threshold relative to largest peak", 0.4, true);
     parser.addArgument("abspeakthres", "a", mitkCommandLineParser::Float, "Absolute peak threshold", "absolute peak threshold weighted with local GFA value", 0.06, true);
     parser.addArgument("shConvention", "s", mitkCommandLineParser::String, "Use specified SH-basis", "use specified SH-basis (MITK, FSL, MRtrix)", string("MITK"), true);
     parser.addArgument("noFlip", "f", mitkCommandLineParser::Bool, "No flip", "do not flip input image to match MITK coordinate convention");
 
     parser.setCategory("Preprocessing Tools");
     parser.setTitle("Peak Extraction");
     parser.setDescription("");
     parser.setContributor("MBI");
 
     map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     // mandatory arguments
     string imageName = us::any_cast<string>(parsedArgs["image"]);
     string outRoot = us::any_cast<string>(parsedArgs["outroot"]);
 
     // optional arguments
     string maskImageName("");
     if (parsedArgs.count("mask"))
         maskImageName = us::any_cast<string>(parsedArgs["mask"]);
 
     int normalization = 1;
     if (parsedArgs.count("normalization"))
         normalization = us::any_cast<int>(parsedArgs["normalization"]);
 
     int numPeaks = 2;
     if (parsedArgs.count("numpeaks"))
         numPeaks = us::any_cast<int>(parsedArgs["numpeaks"]);
 
     float peakThres = 0.4;
     if (parsedArgs.count("peakthres"))
         peakThres = us::any_cast<float>(parsedArgs["peakthres"]);
 
     float absPeakThres = 0.06;
     if (parsedArgs.count("abspeakthres"))
         absPeakThres = us::any_cast<float>(parsedArgs["abspeakthres"]);
 
     bool noFlip = false;
     if (parsedArgs.count("noFlip"))
         noFlip = us::any_cast<bool>(parsedArgs["noFlip"]);
 
     std::cout << "image: " << imageName;
     std::cout << "outroot: " << outRoot;
     if (!maskImageName.empty())
         std::cout << "mask: " << maskImageName;
     else
         std::cout << "no mask image selected";
     std::cout << "numpeaks: " << numPeaks;
     std::cout << "peakthres: " << peakThres;
     std::cout << "abspeakthres: " << absPeakThres;
     std::cout << "shOrder: " << shOrder;
 
     try
     {
         mitk::Image::Pointer image = LoadData(imageName);
         mitk::Image::Pointer mask = LoadData(maskImageName);
 
         typedef itk::Image<unsigned char, 3>  ItkUcharImgType;
         typedef itk::FiniteDiffOdfMaximaExtractionFilter< float, shOrder, 20242 > MaximaExtractionFilterType;
         typename MaximaExtractionFilterType::Pointer filter = MaximaExtractionFilterType::New();
 
         int toolkitConvention = 0;
 
         if (parsedArgs.count("shConvention"))
         {
             string convention = us::any_cast<string>(parsedArgs["shConvention"]).c_str();
             if ( boost::algorithm::equals(convention, "FSL") )
             {
                 toolkitConvention = 1;
                 std::cout << "Using FSL SH-basis";
             }
             else if ( boost::algorithm::equals(convention, "MRtrix") )
             {
                 toolkitConvention = 2;
                 std::cout << "Using MRtrix SH-basis";
             }
             else
                 std::cout << "Using MITK SH-basis";
         }
         else
             std::cout << "Using MITK SH-basis";
 
         ItkUcharImgType::Pointer itkMaskImage = NULL;
         if (mask.IsNotNull())
         {
             try{
                 itkMaskImage = ItkUcharImgType::New();
                 mitk::CastToItkImage(mask, itkMaskImage);
                 filter->SetMaskImage(itkMaskImage);
             }
             catch(...)
             {
 
             }
         }
 
         if (toolkitConvention>0)
         {
             std::cout << "Converting coefficient image to MITK format";
             typedef itk::ShCoefficientImageImporter< float, shOrder > ConverterType;
             typedef mitk::ImageToItk< itk::Image< float, 4 > > CasterType;
             CasterType::Pointer caster = CasterType::New();
             caster->SetInput(image);
             caster->Update();
             itk::Image< float, 4 >::Pointer itkImage = caster->GetOutput();
 
             typename ConverterType::Pointer converter = ConverterType::New();
 
             if (noFlip)
             {
                 converter->SetInputImage(itkImage);
             }
             else
             {
                 std::cout << "Flipping image";
                 itk::FixedArray<bool, 4> flipAxes;
                 flipAxes[0] = true;
                 flipAxes[1] = true;
                 flipAxes[2] = false;
                 flipAxes[3] = false;
                 itk::FlipImageFilter< itk::Image< float, 4 > >::Pointer flipper = itk::FlipImageFilter< itk::Image< float, 4 > >::New();
                 flipper->SetInput(itkImage);
                 flipper->SetFlipAxes(flipAxes);
                 flipper->Update();
                 itk::Image< float, 4 >::Pointer flipped = flipper->GetOutput();
                 itk::Matrix< double,4,4 > m = itkImage->GetDirection(); m[0][0] *= -1; m[1][1] *= -1;
                 flipped->SetDirection(m);
 
                 itk::Point< float, 4 > o = itkImage->GetOrigin();
                 o[0] -= (flipped->GetLargestPossibleRegion().GetSize(0)-1);
                 o[1] -= (flipped->GetLargestPossibleRegion().GetSize(1)-1);
                 flipped->SetOrigin(o);
                 converter->SetInputImage(flipped);
             }
 
             std::cout << "Starting conversion";
             switch (toolkitConvention)
             {
             case 1:
                 converter->SetToolkit(ConverterType::FSL);
                 filter->SetToolkit(MaximaExtractionFilterType::FSL);
                 break;
             case 2:
                 converter->SetToolkit(ConverterType::MRTRIX);
                 filter->SetToolkit(MaximaExtractionFilterType::MRTRIX);
                 break;
             default:
                 converter->SetToolkit(ConverterType::FSL);
                 filter->SetToolkit(MaximaExtractionFilterType::FSL);
                 break;
             }
             converter->GenerateData();
             filter->SetInput(converter->GetCoefficientImage());
         }
         else
         {
             try{
                 typedef mitk::ImageToItk< typename MaximaExtractionFilterType::CoefficientImageType > CasterType;
                 typename CasterType::Pointer caster = CasterType::New();
                 caster->SetInput(image);
                 caster->Update();
                 filter->SetInput(caster->GetOutput());
             }
             catch(...)
             {
                 std::cout << "wrong image type";
                 return EXIT_FAILURE;
             }
         }
 
         filter->SetMaxNumPeaks(numPeaks);
         filter->SetPeakThreshold(peakThres);
         filter->SetAbsolutePeakThreshold(absPeakThres);
         filter->SetAngularThreshold(1);
 
         switch (normalization)
         {
         case 0:
             filter->SetNormalizationMethod(MaximaExtractionFilterType::NO_NORM);
             break;
         case 1:
             filter->SetNormalizationMethod(MaximaExtractionFilterType::MAX_VEC_NORM);
             break;
         case 2:
             filter->SetNormalizationMethod(MaximaExtractionFilterType::SINGLE_VEC_NORM);
             break;
         }
 
         std::cout << "Starting extraction";
         filter->Update();
 
         // write direction images
         {
             typedef typename MaximaExtractionFilterType::ItkDirectionImageContainer ItkDirectionImageContainer;
             typename ItkDirectionImageContainer::Pointer container = filter->GetDirectionImageContainer();
             for (unsigned int i=0; i<container->Size(); i++)
             {
                 typename MaximaExtractionFilterType::ItkDirectionImage::Pointer itkImg = container->GetElement(i);
 
                 if (itkMaskImage.IsNotNull())
                 {
                     itkImg->SetDirection(itkMaskImage->GetDirection());
                     itkImg->SetOrigin(itkMaskImage->GetOrigin());
                 }
 
                 string outfilename = outRoot;
                 outfilename.append("_DIRECTION_");
                 outfilename.append(boost::lexical_cast<string>(i));
                 outfilename.append(".nrrd");
 
                 typedef itk::ImageFileWriter< typename MaximaExtractionFilterType::ItkDirectionImage > WriterType;
                 typename WriterType::Pointer writer = WriterType::New();
                 writer->SetFileName(outfilename);
                 writer->SetInput(itkImg);
                 writer->Update();
             }
         }
 
         // write num directions image
         {
             ItkUcharImgType::Pointer numDirImage = filter->GetNumDirectionsImage();
 
             if (itkMaskImage.IsNotNull())
             {
                 numDirImage->SetDirection(itkMaskImage->GetDirection());
                 numDirImage->SetOrigin(itkMaskImage->GetOrigin());
             }
 
             string outfilename = outRoot.c_str();
             outfilename.append("_NUM_DIRECTIONS.nrrd");
             typedef itk::ImageFileWriter< ItkUcharImgType > WriterType;
             WriterType::Pointer writer = WriterType::New();
             writer->SetFileName(outfilename);
             writer->SetInput(numDirImage);
             writer->Update();
         }
 
         // write vector field
         {
             mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle();
 
             string outfilename = outRoot.c_str();
             outfilename.append("_VECTOR_FIELD.fib");
             mitk::IOUtil::Save(directions.GetPointer(),outfilename.c_str());
         }
     }
     catch (itk::ExceptionObject e)
     {
         std::cout << e;
         return EXIT_FAILURE;
     }
     catch (std::exception e)
     {
         std::cout << e.what();
         return EXIT_FAILURE;
     }
     catch (...)
     {
         std::cout << "ERROR!?!";
         return EXIT_FAILURE;
     }
     return EXIT_SUCCESS;
 }
 
 int main(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("image", "i", mitkCommandLineParser::InputFile, "Input image", "sh coefficient image", us::Any(), false);
     parser.addArgument("shOrder", "sh", mitkCommandLineParser::Int, "Spherical harmonics order", "spherical harmonics order");
     parser.addArgument("outroot", "o", mitkCommandLineParser::OutputDirectory, "Output directory", "output root", us::Any(), false);
     parser.addArgument("mask", "m", mitkCommandLineParser::InputFile, "Mask", "mask image");
     parser.addArgument("normalization", "n", mitkCommandLineParser::Int, "Normalization", "0=no norm, 1=max norm, 2=single vec norm", 1, true);
     parser.addArgument("numpeaks", "p", mitkCommandLineParser::Int, "Max. number of peaks", "maximum number of extracted peaks", 2, true);
     parser.addArgument("peakthres", "r", mitkCommandLineParser::Float, "Peak threshold", "peak threshold relative to largest peak", 0.4, true);
     parser.addArgument("abspeakthres", "a", mitkCommandLineParser::Float, "Absolute peak threshold", "absolute peak threshold weighted with local GFA value", 0.06, true);
     parser.addArgument("shConvention", "s", mitkCommandLineParser::String, "Use specified SH-basis", "use specified SH-basis (MITK, FSL, MRtrix)", string("MITK"), true);
     parser.addArgument("noFlip", "f", mitkCommandLineParser::Bool, "No flip", "do not flip input image to match MITK coordinate convention");
 
     parser.setCategory("Preprocessing Tools");
     parser.setTitle("Peak Extraction");
     parser.setDescription("");
     parser.setContributor("MBI");
 
     map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
 
     int shOrder = -1;
     if (parsedArgs.count("shOrder"))
         shOrder = us::any_cast<int>(parsedArgs["shOrder"]);
 
     switch (shOrder)
     {
     case 4:
         return StartPeakExtraction<4>(argc, argv);
     case 6:
         return StartPeakExtraction<6>(argc, argv);
     case 8:
         return StartPeakExtraction<8>(argc, argv);
     case 10:
         return StartPeakExtraction<10>(argc, argv);
     case 12:
         return StartPeakExtraction<12>(argc, argv);
     }
     return EXIT_FAILURE;
 }
diff --git a/Modules/DiffusionImaging/MiniApps/QballReconstruction.cpp b/Modules/DiffusionImaging/MiniApps/QballReconstruction.cpp
index 65cb7e0e33..13ea2b526b 100644
--- a/Modules/DiffusionImaging/MiniApps/QballReconstruction.cpp
+++ b/Modules/DiffusionImaging/MiniApps/QballReconstruction.cpp
@@ -1,239 +1,263 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include "mitkBaseDataIOFactory.h"
 #include <mitkCoreObjectFactory.h>
-#include "mitkDiffusionImage.h"
+#include "mitkImage.h"
 #include "itkAnalyticalDiffusionQballReconstructionImageFilter.h"
 #include <boost/lexical_cast.hpp>
 #include "mitkCommandLineParser.h"
 #include <mitkIOUtil.h>
 #include <itksys/SystemTools.hxx>
+#include <mitkDiffusionPropertyHelper.h>
+#include <mitkITKImageImport.h>
+#include <mitkImageCast.h>
+#include <mitkProperties.h>
 
 using namespace mitk;
 
 /**
  * Perform Q-ball reconstruction using a spherical harmonics basis
  */
 int main(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input file", "input raw dwi (.dwi or .fsl/.fslgz)", us::Any(), false);
     parser.addArgument("outFile", "o", mitkCommandLineParser::OutputFile, "Output file", "output file", us::Any(), false);
     parser.addArgument("shOrder", "sh", mitkCommandLineParser::Int, "Spherical harmonics order", "spherical harmonics order", 4, true);
     parser.addArgument("b0Threshold", "t", mitkCommandLineParser::Int, "b0 threshold", "baseline image intensity threshold", 0, true);
     parser.addArgument("lambda", "r", mitkCommandLineParser::Float, "Lambda", "ragularization factor lambda", 0.006, true);
     parser.addArgument("csa", "csa", mitkCommandLineParser::Bool, "Constant solid angle consideration", "use constant solid angle consideration");
     parser.addArgument("outputCoeffs", "shc", mitkCommandLineParser::Bool, "Output coefficients", "output file containing the SH coefficients");
     parser.addArgument("mrtrix", "mb", mitkCommandLineParser::Bool, "MRtrix", "use MRtrix compatible spherical harmonics definition");
 
     parser.setCategory("Preprocessing Tools");
     parser.setTitle("Qball Reconstruction");
     parser.setDescription("");
     parser.setContributor("MBI");
 
     map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     std::string inFileName = us::any_cast<string>(parsedArgs["input"]);
     std::string outfilename = us::any_cast<string>(parsedArgs["outFile"]);
     outfilename = itksys::SystemTools::GetFilenamePath(outfilename)+"/"+itksys::SystemTools::GetFilenameWithoutExtension(outfilename);
 
     int threshold = 0;
     if (parsedArgs.count("b0Threshold"))
         threshold = us::any_cast<int>(parsedArgs["b0Threshold"]);
 
     int shOrder = 4;
     if (parsedArgs.count("shOrder"))
         shOrder = us::any_cast<int>(parsedArgs["shOrder"]);
 
     float lambda = 0.006;
     if (parsedArgs.count("lambda"))
         lambda = us::any_cast<float>(parsedArgs["lambda"]);
 
     int normalization = 0;
     if (parsedArgs.count("csa") && us::any_cast<bool>(parsedArgs["csa"]))
         normalization = 6;
 
     bool outCoeffs = false;
     if (parsedArgs.count("outputCoeffs"))
         outCoeffs = us::any_cast<bool>(parsedArgs["outputCoeffs"]);
 
     bool mrTrix = false;
     if (parsedArgs.count("mrtrix"))
         mrTrix = us::any_cast<bool>(parsedArgs["mrtrix"]);
 
     try
     {
         const std::string s1="", s2="";
         std::vector<BaseData::Pointer> infile = BaseDataIO::LoadBaseDataFromFile( inFileName, s1, s2, false );
-        DiffusionImage<short>::Pointer dwi = dynamic_cast<DiffusionImage<short>*>(infile.at(0).GetPointer());
-        dwi->AverageRedundantGradients(0.001);
+        Image::Pointer dwi = dynamic_cast<Image*>(infile.at(0).GetPointer());
+        mitk::DiffusionPropertyHelper propertyHelper(dwi);
+        propertyHelper.AverageRedundantGradients(0.001);
+        propertyHelper.InitializeImage();
 
         mitk::QBallImage::Pointer image = mitk::QBallImage::New();
         mitk::Image::Pointer coeffsImage = mitk::Image::New();
 
         std::cout << "SH order: " << shOrder;
         std::cout << "lambda: " << lambda;
         std::cout << "B0 threshold: " << threshold;
         switch ( shOrder )
         {
         case 4:
         {
             typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,4,QBALL_ODFSIZE> FilterType;
+            mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
+            mitk::CastToItkImage(dwi, itkVectorImagePointer);
+
             FilterType::Pointer filter = FilterType::New();
-            filter->SetGradientImage( dwi->GetDirections(), dwi->GetVectorImage() );
-            filter->SetBValue(dwi->GetReferenceBValue());
+            filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
+            filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi));
             filter->SetThreshold( threshold );
             filter->SetLambda(lambda);
             filter->SetUseMrtrixBasis(mrTrix);
             if (normalization==0)
                 filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
             else
                 filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
             filter->Update();
             image->InitializeByItk( filter->GetOutput() );
             image->SetVolume( filter->GetOutput()->GetBufferPointer() );
             coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
             coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
             break;
         }
         case 6:
         {
             typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,6,QBALL_ODFSIZE> FilterType;
+            mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
+            mitk::CastToItkImage(dwi, itkVectorImagePointer);
+
             FilterType::Pointer filter = FilterType::New();
-            filter->SetGradientImage( dwi->GetDirections(), dwi->GetVectorImage() );
-            filter->SetBValue(dwi->GetReferenceBValue());
+            filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
+            filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi));
             filter->SetThreshold( threshold );
             filter->SetLambda(lambda);
             filter->SetUseMrtrixBasis(mrTrix);
             if (normalization==0)
                 filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
             else
                 filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
             filter->Update();
             image->InitializeByItk( filter->GetOutput() );
             image->SetVolume( filter->GetOutput()->GetBufferPointer() );
             coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
             coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
             break;
         }
         case 8:
         {
             typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,8,QBALL_ODFSIZE> FilterType;
+            mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
+            mitk::CastToItkImage(dwi, itkVectorImagePointer);
+
             FilterType::Pointer filter = FilterType::New();
-            filter->SetGradientImage( dwi->GetDirections(), dwi->GetVectorImage() );
-            filter->SetBValue(dwi->GetReferenceBValue());
+            filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
+            filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi));
             filter->SetThreshold( threshold );
             filter->SetLambda(lambda);
             filter->SetUseMrtrixBasis(mrTrix);
             if (normalization==0)
                 filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
             else
                 filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
             filter->Update();
             image->InitializeByItk( filter->GetOutput() );
             image->SetVolume( filter->GetOutput()->GetBufferPointer() );
             coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
             coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
             break;
         }
         case 10:
         {
             typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,10,QBALL_ODFSIZE> FilterType;
+            mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
+            mitk::CastToItkImage(dwi, itkVectorImagePointer);
+
             FilterType::Pointer filter = FilterType::New();
-            filter->SetGradientImage( dwi->GetDirections(), dwi->GetVectorImage() );
-            filter->SetBValue(dwi->GetReferenceBValue());
+            filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
+            filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi));
             filter->SetThreshold( threshold );
             filter->SetLambda(lambda);
             filter->SetUseMrtrixBasis(mrTrix);
             if (normalization==0)
                 filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
             else
                 filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
             filter->Update();
             image->InitializeByItk( filter->GetOutput() );
             image->SetVolume( filter->GetOutput()->GetBufferPointer() );
             coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
             coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
             break;
         }
         case 12:
         {
             typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,12,QBALL_ODFSIZE> FilterType;
+            mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
+            mitk::CastToItkImage(dwi, itkVectorImagePointer);
+
             FilterType::Pointer filter = FilterType::New();
-            filter->SetGradientImage( dwi->GetDirections(), dwi->GetVectorImage() );
-            filter->SetBValue(dwi->GetReferenceBValue());
+            filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
+            filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi));
             filter->SetThreshold( threshold );
             filter->SetLambda(lambda);
             if (normalization==0)
                 filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
             else
                 filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
             filter->Update();
             image->InitializeByItk( filter->GetOutput() );
             image->SetVolume( filter->GetOutput()->GetBufferPointer() );
             coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
             coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
             break;
         }
         default:
         {
             std::cout << "Supplied SH order not supported. Using default order of 4.";
             typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,4,QBALL_ODFSIZE> FilterType;
+            mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
+            mitk::CastToItkImage(dwi, itkVectorImagePointer);
+
             FilterType::Pointer filter = FilterType::New();
-            filter->SetGradientImage( dwi->GetDirections(), dwi->GetVectorImage() );
-            filter->SetBValue(dwi->GetReferenceBValue());
+            filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
+            filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi));
             filter->SetThreshold( threshold );
             filter->SetLambda(lambda);
             filter->SetUseMrtrixBasis(mrTrix);
             if (normalization==0)
                 filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
             else
                 filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
             filter->Update();
             image->InitializeByItk( filter->GetOutput() );
             image->SetVolume( filter->GetOutput()->GetBufferPointer() );
             coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
             coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
         }
         }
 
         std::string coeffout = outfilename;
         coeffout += "_shcoeffs.nrrd";
 
         outfilename += ".qbi";
         mitk::IOUtil::SaveBaseData(image, outfilename);
 
         if (outCoeffs)
             mitk::IOUtil::SaveImage(coeffsImage, coeffout);
     }
     catch ( itk::ExceptionObject &err)
     {
         std::cout << "Exception: " << err;
     }
     catch ( std::exception err)
     {
         std::cout << "Exception: " << err.what();
     }
     catch ( ... )
     {
         std::cout << "Exception!";
     }
     return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/MiniApps/TensorDerivedMapsExtraction.cpp b/Modules/DiffusionImaging/MiniApps/TensorDerivedMapsExtraction.cpp
index 5f1b3a55db..ecbe39b53b 100644
--- a/Modules/DiffusionImaging/MiniApps/TensorDerivedMapsExtraction.cpp
+++ b/Modules/DiffusionImaging/MiniApps/TensorDerivedMapsExtraction.cpp
@@ -1,191 +1,190 @@
 /*===================================================================
 
  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.
 
  ===================================================================*/
 
 
 #include <mitkIOUtil.h>
 
 #include "mitkImage.h"
 #include <mitkImageCast.h>
 #include "mitkITKImageImport.h"
 #include <iostream>
 #include <fstream>
 #include <mitkTensorImage.h>
-#include <mitkDiffusionImage.h>
+#include <mitkImage.h>
+#include <mitkDiffusionPropertyHelper.h>
 
 #include "itkTensorDerivedMeasurementsFilter.h"
 #include "itkDiffusionTensor3DReconstructionImageFilter.h"
 #include "mitkCommandLineParser.h"
 
 #include <itkImageFileWriter.h>
 #include <itkNrrdImageIO.h>
 #include <itkDiffusionTensor3D.h>
 
 typedef short DiffusionPixelType;
 typedef double TTensorPixelType;
 
 static void ExtractMapsAndSave(mitk::TensorImage::Pointer tensorImage, std::string filename, std::string postfix = "")
 {
 
   mitk::Image* image = dynamic_cast<mitk::Image*> (tensorImage.GetPointer());
 
   typedef itk::DiffusionTensor3D< TTensorPixelType >  TensorPixelType;
   typedef itk::Image< TensorPixelType, 3 > TensorImageType;
 
   TensorImageType::Pointer itkvol = TensorImageType::New();
   mitk::CastToItkImage(image, itkvol);
 
   typedef itk::TensorDerivedMeasurementsFilter<TTensorPixelType> MeasurementsType;
 
   MeasurementsType::Pointer measurementsCalculator = MeasurementsType::New();
   measurementsCalculator->SetInput(itkvol.GetPointer() );
 
   mitk::Image::Pointer map = mitk::Image::New();
   // FA
   measurementsCalculator->SetMeasure(MeasurementsType::FA);
   measurementsCalculator->Update();
   map->InitializeByItk( measurementsCalculator->GetOutput() );
   map->SetVolume( measurementsCalculator->GetOutput()->GetBufferPointer() );
   mitk::IOUtil::SaveImage(map, filename + "_dti_FA" + postfix + ".nrrd");
 
   // MD
   measurementsCalculator->SetMeasure(MeasurementsType::MD);
   measurementsCalculator->Update();
   map->InitializeByItk( measurementsCalculator->GetOutput() );
   map->SetVolume( measurementsCalculator->GetOutput()->GetBufferPointer() );
   mitk::IOUtil::SaveImage(map, filename + "_dti_MD" + postfix + ".nrrd");
 
   // AD
   measurementsCalculator->SetMeasure(MeasurementsType::AD);
   measurementsCalculator->Update();
   map->InitializeByItk( measurementsCalculator->GetOutput() );
   map->SetVolume( measurementsCalculator->GetOutput()->GetBufferPointer() );
   mitk::IOUtil::SaveImage(map, filename + "_dti_AD" + postfix + ".nrrd");
 
 
   // CA
   measurementsCalculator->SetMeasure(MeasurementsType::CA);
   measurementsCalculator->Update();
   map->InitializeByItk( measurementsCalculator->GetOutput() );
   map->SetVolume( measurementsCalculator->GetOutput()->GetBufferPointer() );
   mitk::IOUtil::SaveImage(map, filename + "_dti_CA" + postfix + ".nrrd");
 
   // RA
   measurementsCalculator->SetMeasure(MeasurementsType::RA);
   measurementsCalculator->Update();
   map->InitializeByItk( measurementsCalculator->GetOutput() );
   map->SetVolume( measurementsCalculator->GetOutput()->GetBufferPointer() );
   mitk::IOUtil::SaveImage(map, filename + "_dti_RA" + postfix + ".nrrd");
 
   // RD
   measurementsCalculator->SetMeasure(MeasurementsType::RD);
   measurementsCalculator->Update();
   map->InitializeByItk( measurementsCalculator->GetOutput() );
   map->SetVolume( measurementsCalculator->GetOutput()->GetBufferPointer() );
   mitk::IOUtil::SaveImage(map, filename + "_dti_RD" + postfix + ".nrrd");
 
 }
 
 
 int main(int argc, char* argv[])
 {
 
     std::cout << "TensorDerivedMapsExtraction";
   mitkCommandLineParser parser;
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("help", "h", mitkCommandLineParser::String, "Help", "Show this help text");
   parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input file", "input dwi file", us::Any(),false);
   parser.addArgument("out", "o", mitkCommandLineParser::String, "Output folder", "output folder and base name, e.g. /tmp/outPatient1 ", us::Any(),false);
 
   parser.setCategory("Diffusion Related Measures");
   parser.setTitle("Tensor Derived Maps Extraction");
   parser.setDescription("");
   parser.setContributor("MBI");
 
   map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0 || parsedArgs.count("help") || parsedArgs.count("h"))
   {
     std::cout << "\n\nMiniApp Description: \nPerforms tensor reconstruction on DWI file," << endl;
     std::cout << "and computes tensor derived measures." << endl;
     std::cout << "\n\n For out parameter /tmp/outPatient1 it will produce :"<< endl;
     std::cout << " /tmp/outPatient1_dti.dti , /tmp/outPatient1_dti_FA.nrrd, ..."<< endl;
     std::cout << "\n\n Parameters:"<< endl;
     std::cout << parser.helpText();
     return EXIT_SUCCESS;
   }
 
 
 
   std::string inputFile = us::any_cast<string>(parsedArgs["input"]);
   std::string baseFileName = us::any_cast<string>(parsedArgs["out"]);
 
   std::string dtiFileName = "_dti.dti";
 
   std::cout << "BaseFileName: " << baseFileName;
 
 
-  mitk::Image::Pointer inputImage =  mitk::IOUtil::LoadImage(inputFile);
-  mitk::DiffusionImage<short>* diffusionImage =   static_cast<mitk::DiffusionImage<short>*>(inputImage.GetPointer());
-  if (diffusionImage == NULL) // does NULL pointer check make sense after static cast ?
+  mitk::Image::Pointer diffusionImage =  mitk::IOUtil::LoadImage(inputFile);
+
+  if (diffusionImage.IsNull() || !mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(diffusionImage)) // does NULL pointer check make sense after static cast ?
   {
     MITK_ERROR << "Invalid Input Image. Must be DWI. Aborting.";
     return -1;
   }
 
-  mitk::DiffusionImage<DiffusionPixelType>* vols = dynamic_cast <mitk::DiffusionImage<DiffusionPixelType>*> (inputImage.GetPointer());
-
   typedef itk::DiffusionTensor3DReconstructionImageFilter< DiffusionPixelType, DiffusionPixelType, TTensorPixelType > TensorReconstructionImageFilterType;
   TensorReconstructionImageFilterType::Pointer tensorReconstructionFilter = TensorReconstructionImageFilterType::New();
 
-  typedef mitk::DiffusionImage<DiffusionPixelType> DiffusionImageType;
-  typedef DiffusionImageType::GradientDirectionContainerType GradientDirectionContainerType;
-
-  GradientDirectionContainerType::Pointer gradientContainerCopy = GradientDirectionContainerType::New();
-  for(GradientDirectionContainerType::ConstIterator it = vols->GetDirections()->Begin(); it != vols->GetDirections()->End(); it++)
+  mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer gradientContainerCopy = mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::New();
+  for( mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::ConstIterator it = mitk::DiffusionPropertyHelper::GetGradientContainer(diffusionImage)->Begin(); it != mitk::DiffusionPropertyHelper::GetGradientContainer(diffusionImage)->End(); it++)
   {
     gradientContainerCopy->push_back(it.Value());
   }
 
-  tensorReconstructionFilter->SetGradientImage( gradientContainerCopy, vols->GetVectorImage() );
-  tensorReconstructionFilter->SetBValue(vols->GetReferenceBValue());
+  mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
+  mitk::CastToItkImage(diffusionImage, itkVectorImagePointer);
+
+  tensorReconstructionFilter->SetGradientImage( gradientContainerCopy, itkVectorImagePointer );
+  tensorReconstructionFilter->SetBValue( mitk::DiffusionPropertyHelper::GetReferenceBValue( diffusionImage ) );
   tensorReconstructionFilter->SetThreshold(50);
   tensorReconstructionFilter->Update();
 
   typedef itk::Image<itk::DiffusionTensor3D<TTensorPixelType>, 3> TensorImageType;
   TensorImageType::Pointer tensorImage = tensorReconstructionFilter->GetOutput();
-  tensorImage->SetDirection( vols->GetVectorImage()->GetDirection() );
+  tensorImage->SetDirection( itkVectorImagePointer->GetDirection() );
 
   mitk::TensorImage::Pointer tensorImageMitk = mitk::TensorImage::New();
   tensorImageMitk->InitializeByItk(tensorImage.GetPointer());
   tensorImageMitk->SetVolume( tensorImage->GetBufferPointer() );
 
 
 
   itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
   io->SetFileType( itk::ImageIOBase::Binary );
   io->UseCompressionOn();
 
   itk::ImageFileWriter< itk::Image< itk::DiffusionTensor3D< double >, 3 > >::Pointer writer = itk::ImageFileWriter< itk::Image< itk::DiffusionTensor3D< double >, 3 > >::New();
   writer->SetInput(tensorReconstructionFilter->GetOutput());
   writer->SetFileName(baseFileName + dtiFileName);
   writer->SetImageIO(io);
   writer->UseCompressionOn();
   writer->Update();
 
   ExtractMapsAndSave(tensorImageMitk,baseFileName);
 
   return EXIT_SUCCESS;
 
 }
diff --git a/Modules/DiffusionImaging/MiniApps/TensorReconstruction.cpp b/Modules/DiffusionImaging/MiniApps/TensorReconstruction.cpp
index 2b7968a1fd..a1b066cc54 100644
--- a/Modules/DiffusionImaging/MiniApps/TensorReconstruction.cpp
+++ b/Modules/DiffusionImaging/MiniApps/TensorReconstruction.cpp
@@ -1,98 +1,103 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include "mitkBaseDataIOFactory.h"
-#include "mitkDiffusionImage.h"
+#include "mitkImage.h"
+#include <mitkImageCast.h>
 #include "mitkBaseData.h"
+#include <mitkDiffusionPropertyHelper.h>
 
 #include <itkDiffusionTensor3DReconstructionImageFilter.h>
 #include <itkDiffusionTensor3D.h>
 #include <itkImageFileWriter.h>
 #include <itkNrrdImageIO.h>
 #include "mitkCommandLineParser.h"
 #include <itksys/SystemTools.hxx>
 
 using namespace mitk;
 /**
  * Convert files from one ending to the other
  */
 int main(int argc, char* argv[])
 {
     std::cout << "TensorReconstruction";
     mitkCommandLineParser parser;
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input file", "input raw dwi (.dwi or .fsl/.fslgz)", us::Any(), false);
     parser.addArgument("outFile", "o", mitkCommandLineParser::OutputFile, "Output file", "output file", us::Any(), false);
     parser.addArgument("b0Threshold", "t", mitkCommandLineParser::Int, "b0 threshold", "baseline image intensity threshold", 0, true);
 
     parser.setCategory("Preprocessing Tools");
     parser.setTitle("Tensor Reconstruction");
     parser.setDescription("");
     parser.setContributor("MBI");
 
     map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     std::string inFileName = us::any_cast<string>(parsedArgs["input"]);
     std::string outfilename = us::any_cast<string>(parsedArgs["outFile"]);
     outfilename = itksys::SystemTools::GetFilenamePath(outfilename)+"/"+itksys::SystemTools::GetFilenameWithoutExtension(outfilename);
     outfilename += ".dti";
 
     int threshold = 0;
     if (parsedArgs.count("b0Threshold"))
         threshold = us::any_cast<int>(parsedArgs["b0Threshold"]);
 
     try
     {
         const std::string s1="", s2="";
         std::vector<BaseData::Pointer> infile = BaseDataIO::LoadBaseDataFromFile( inFileName, s1, s2, false );
-        DiffusionImage<short>::Pointer dwi = dynamic_cast<DiffusionImage<short>*>(infile.at(0).GetPointer());
+        Image::Pointer dwi = dynamic_cast<Image*>(infile.at(0).GetPointer());
+
+        mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
+        mitk::CastToItkImage(dwi, itkVectorImagePointer);
 
         typedef itk::DiffusionTensor3DReconstructionImageFilter< short, short, float > TensorReconstructionImageFilterType;
         TensorReconstructionImageFilterType::Pointer filter = TensorReconstructionImageFilterType::New();
-        filter->SetGradientImage( dwi->GetDirections(), dwi->GetVectorImage() );
-        filter->SetBValue(dwi->GetReferenceBValue());
+        filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
+        filter->SetBValue( mitk::DiffusionPropertyHelper::GetReferenceBValue( dwi ));
         filter->SetThreshold(threshold);
         filter->Update();
 
         // Save tensor image
         itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
         io->SetFileType( itk::ImageIOBase::Binary );
         io->UseCompressionOn();
 
         itk::ImageFileWriter< itk::Image< itk::DiffusionTensor3D< float >, 3 > >::Pointer writer = itk::ImageFileWriter< itk::Image< itk::DiffusionTensor3D< float >, 3 > >::New();
         writer->SetInput(filter->GetOutput());
         writer->SetFileName(outfilename);
         writer->SetImageIO(io);
         writer->UseCompressionOn();
         writer->Update();
     }
     catch ( itk::ExceptionObject &err)
     {
         std::cout << "Exception: " << err;
     }
     catch ( std::exception err)
     {
         std::cout << "Exception: " << err.what();
     }
     catch ( ... )
     {
         std::cout << "Exception!";
     }
     return EXIT_SUCCESS;
 
 }
diff --git a/Modules/DiffusionImaging/MiniApps/mitkFileFormatConverter.cpp b/Modules/DiffusionImaging/MiniApps/mitkFileFormatConverter.cpp
index 1cac8e8832..f758f91601 100755
--- a/Modules/DiffusionImaging/MiniApps/mitkFileFormatConverter.cpp
+++ b/Modules/DiffusionImaging/MiniApps/mitkFileFormatConverter.cpp
@@ -1,84 +1,80 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include <mitkImageCast.h>
-#include <mitkDiffusionImage.h>
+#include <mitkImage.h>
 #include <mitkBaseDataIOFactory.h>
 #include <mitkIOUtil.h>
 #include <mitkFiberBundleX.h>
 #include "mitkCommandLineParser.h"
 
 using namespace mitk;
 
 int main(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
 
     parser.setTitle("Format Converter");
     parser.setCategory("Fiber Tracking and Processing Methods");
     parser.setDescription("");
     parser.setContributor("MBI");
 
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("in", "i", mitkCommandLineParser::InputFile, "Input:", "input file", us::Any(), false);
     parser.addArgument("out", "o", mitkCommandLineParser::OutputFile, "Output:", "output file", us::Any(), false);
 
     map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     // mandatory arguments
     string inName = us::any_cast<string>(parsedArgs["in"]);
     string outName = us::any_cast<string>(parsedArgs["out"]);
 
     try
     {
         const std::string s1="", s2="";
         std::vector<BaseData::Pointer> infile = BaseDataIO::LoadBaseDataFromFile( inName, s1, s2, false );
         mitk::BaseData::Pointer baseData = infile.at(0);
 
-        if ( dynamic_cast<DiffusionImage<short>*>(baseData.GetPointer()) )
-        {
-          mitk::IOUtil::Save(dynamic_cast<DiffusionImage<short>*>(baseData.GetPointer()), outName.c_str());
-        }
-        else if ( dynamic_cast<Image*>(baseData.GetPointer()) )
+        if ( dynamic_cast<Image*>(baseData.GetPointer()) )
         {
             mitk::IOUtil::Save(dynamic_cast<Image*>(baseData.GetPointer()), outName.c_str());
         }
         else if ( dynamic_cast<FiberBundleX*>(baseData.GetPointer()) )
         {
             mitk::IOUtil::Save(dynamic_cast<FiberBundleX*>(baseData.GetPointer()) ,outName.c_str());
         }
         else
             std::cout << "File type currently not supported!";
     }
     catch (itk::ExceptionObject e)
     {
         std::cout << e;
         return EXIT_FAILURE;
     }
     catch (std::exception e)
     {
         std::cout << e.what();
         return EXIT_FAILURE;
     }
     catch (...)
     {
         std::cout << "ERROR!?!";
         return EXIT_FAILURE;
     }
     return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/MiniApps/mitkRegistration.cpp b/Modules/DiffusionImaging/MiniApps/mitkRegistration.cpp
index d262915ba7..30077621d1 100644
--- a/Modules/DiffusionImaging/MiniApps/mitkRegistration.cpp
+++ b/Modules/DiffusionImaging/MiniApps/mitkRegistration.cpp
@@ -1,473 +1,457 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 
 // CTK
 #include "mitkCommandLineParser.h"
 
 #include <mitkIOUtil.h>
 #include <mitkRegistrationWrapper.h>
 #include <mitkImage.h>
 #include <mitkImageCast.h>
 #include <mitkITKImageImport.h>
-#include <mitkDiffusionImage.h>
 #include <mitkImageTimeSelector.h>
 // ITK
 #include <itksys/SystemTools.hxx>
 #include <itkDirectory.h>
 #include "itkLinearInterpolateImageFunction.h"
 #include "itkWindowedSincInterpolateImageFunction.h"
 #include "itkIdentityTransform.h"
 #include "itkResampleImageFilter.h"
 
 
 typedef std::vector<std::string> FileListType;
 typedef itk::Image<double, 3> InputImageType;
 
 static mitk::Image::Pointer ExtractFirstTS(mitk::Image* image, std::string fileType)
 {
   if (fileType == ".dwi")
     return image;
   mitk::ImageTimeSelector::Pointer selector = mitk::ImageTimeSelector::New();
   selector->SetInput(image);
   selector->SetTimeNr(0);
   selector->UpdateLargestPossibleRegion();
   mitk::Image::Pointer img =selector->GetOutput()->Clone();
   return img;
 }
 
 
 static std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems)
 {
   std::stringstream ss(s);
   std::string item;
   while (std::getline(ss, item, delim))
   {
     elems.push_back(item);
   }
   return elems;
 }
 
 static std::vector<std::string> split(const std::string &s, char delim)
 {
   std::vector < std::string > elems;
   return split(s, delim, elems);
 }
 
 /// Create list of all files in provided folder ending with same postfix
 static FileListType CreateFileList(std::string folder , std::string postfix)
 {
   itk::Directory::Pointer dir = itk::Directory::New();
   FileListType fileList;
 
   if( dir->Load(folder.c_str() ) )
   {
     int n = dir->GetNumberOfFiles();
     for(int r=0;r<n;r++)
     {
       std::string filename = dir->GetFile( r );
       if (filename == "." || filename == "..")
         continue;
       filename = folder + filename;
       if (!itksys::SystemTools::FileExists( filename.c_str()))
         continue;
       if (filename.substr(filename.length() -postfix.length() ) == postfix)
         fileList.push_back(filename);
     }
   }
   return fileList;
 }
 
 static std::string GetSavePath(std::string outputFolder, std::string fileName)
 {
   std::string fileType = itksys::SystemTools::GetFilenameExtension(fileName);
   std::string fileStem = itksys::SystemTools::GetFilenameWithoutExtension(fileName);
 
   std::string savePathAndFileName = outputFolder +fileStem + fileType;
 
   return savePathAndFileName;
 }
 
 
 static mitk::Image::Pointer ResampleBySpacing(mitk::Image *input, float *spacing, bool useLinInt = false)
 {
   InputImageType::Pointer itkImage = InputImageType::New();
   CastToItkImage(input,itkImage);
 
   /**
    * 1) Resampling
    *
    */
   // Identity transform.
   // We don't want any transform on our image except rescaling which is not
   // specified by a transform but by the input/output spacing as we will see
   // later.
   // So no transform will be specified.
   typedef itk::IdentityTransform<double, 3> T_Transform;
 
   // The resampler type itself.
   typedef itk::ResampleImageFilter<InputImageType, InputImageType>  T_ResampleFilter;
 
   // Prepare the resampler.
   // Instantiate the transform and specify it should be the id transform.
   T_Transform::Pointer _pTransform = T_Transform::New();
   _pTransform->SetIdentity();
 
   // Instantiate the resampler. Wire in the transform and the interpolator.
   T_ResampleFilter::Pointer _pResizeFilter = T_ResampleFilter::New();
   _pResizeFilter->SetTransform(_pTransform);
 
   // Set the output origin.
   _pResizeFilter->SetOutputOrigin(itkImage->GetOrigin());
 
   // Compute the size of the output.
   // The size (# of pixels) in the output is recomputed using
   // the ratio of the input and output sizes.
   InputImageType::SpacingType inputSpacing = itkImage->GetSpacing();
   InputImageType::SpacingType outputSpacing;
   const InputImageType::RegionType& inputSize = itkImage->GetLargestPossibleRegion();
 
   InputImageType::SizeType outputSize;
   typedef InputImageType::SizeType::SizeValueType SizeValueType;
 
   // Set the output spacing.
   outputSpacing[0] = spacing[0];
   outputSpacing[1] = spacing[1];
   outputSpacing[2] = spacing[2];
 
   outputSize[0] = static_cast<SizeValueType>(inputSize.GetSize()[0] * inputSpacing[0] / outputSpacing[0] + .5);
   outputSize[1] = static_cast<SizeValueType>(inputSize.GetSize()[1] * inputSpacing[1] / outputSpacing[1] + .5);
   outputSize[2] = static_cast<SizeValueType>(inputSize.GetSize()[2] * inputSpacing[2] / outputSpacing[2] + .5);
 
   _pResizeFilter->SetOutputSpacing(outputSpacing);
   _pResizeFilter->SetSize(outputSize);
 
 
   typedef itk::LinearInterpolateImageFunction< InputImageType > LinearInterpolatorType;
   LinearInterpolatorType::Pointer lin_interpolator = LinearInterpolatorType::New();
 
   typedef itk::Function::WelchWindowFunction<4> WelchWindowFunction;
   typedef itk::WindowedSincInterpolateImageFunction< InputImageType, 4,WelchWindowFunction> WindowedSincInterpolatorType;
   WindowedSincInterpolatorType::Pointer sinc_interpolator = WindowedSincInterpolatorType::New();
 
   if (useLinInt)
     _pResizeFilter->SetInterpolator(lin_interpolator);
   else
     _pResizeFilter->SetInterpolator(sinc_interpolator);
 
   // Specify the input.
   _pResizeFilter->SetInput(itkImage);
   _pResizeFilter->Update();
 
   mitk::Image::Pointer image = mitk::Image::New();
   image->InitializeByItk(_pResizeFilter->GetOutput());
   mitk::GrabItkImageMemory( _pResizeFilter->GetOutput(), image);
 
   return image;
 }
 
 
 
 /// Build a derived file name from moving images e.g. xxx_T2.nrrd becomes xxx_GTV.nrrd
 static FileListType CreateDerivedFileList(std::string baseFN, std::string baseSuffix, std::vector<std::string> derivedPatterns)
 {
   FileListType files;
   for (unsigned int i=0; i < derivedPatterns.size(); i++)
   {
     std::string derResourceSuffix =  derivedPatterns.at(i);
     std::string derivedResourceFilename = baseFN.substr(0,baseFN.length() -baseSuffix.length()) + derResourceSuffix;
     MITK_INFO <<" Looking for file: " << derivedResourceFilename;
 
     if (!itksys::SystemTools::FileExists(derivedResourceFilename.c_str()))
     {
       MITK_INFO << "CreateDerivedFileList: File does not exit. Skipping entry.";
       continue;
     }
     files.push_back(derivedResourceFilename);
   }
   return files;
 }
 
 /// Save images according to file type
 static void SaveImage(std::string fileName, mitk::Image* image, std::string fileType )
 {
   MITK_INFO << "----Save to " << fileName;
 
-  if (fileType == "dwi") // IOUtil does not handle dwi files properly Bug 15772
-  {
-    try
-    {
-      mitk::IOUtil::Save(dynamic_cast<mitk::DiffusionImage<short>*>(image), fileName.c_str());
-    }
-    catch( const itk::ExceptionObject& e)
-    {
-      MITK_ERROR << "Caught exception: " << e.what();
-      mitkThrow() << "Failed with exception from subprocess!";
-    }
-  }
-  else
-  {
-    mitk::IOUtil::SaveImage(image, fileName);
-  }
+  mitk::IOUtil::Save(image, fileName);
 }
 
 /// Copy derived resources from first time step. Append _reg tag, but leave data untouched.
 static void CopyResources(FileListType fileList, std::string outputPath)
 {
   for (unsigned int j=0; j < fileList.size(); j++)
   {
     std::string derivedResourceFilename = fileList.at(j);
     std::string fileType = itksys::SystemTools::GetFilenameExtension(derivedResourceFilename);
     std::string fileStem = itksys::SystemTools::GetFilenameWithoutExtension(derivedResourceFilename);
     std::string savePathAndFileName = outputPath +fileStem + "." + fileType;
     MITK_INFO << "Copy resource " << savePathAndFileName;
     mitk::Image::Pointer resImage = ExtractFirstTS(mitk::IOUtil::LoadImage(derivedResourceFilename), fileType);
     mitk::IOUtil::SaveImage(resImage, savePathAndFileName);
   }
 }
 
 int main( int argc, char* argv[] )
 {
   mitkCommandLineParser parser;
   parser.setArgumentPrefix("--","-");
 
   parser.setTitle("Folder Registraton");
   parser.setCategory("Preprocessing Tools");
   parser.setDescription("http://docs.mitk.org/nightly-qt4/DiffusionMiniApps.html");
   parser.setContributor("MBI");
 
   // Add command line argument names
   parser.addArgument("help", "h",mitkCommandLineParser::Bool, "Help", "Show this help text");
   //parser.addArgument("usemask", "u", QVariant::Bool, "Use segmentations (derived resources) to exclude areas from registration metrics");
   parser.addArgument("input", "i", mitkCommandLineParser::InputDirectory, "Input:", "Input folder",us::Any(),false);
   parser.addArgument("output", "o", mitkCommandLineParser::OutputDirectory, "Output:", "Output folder (ending with /)",us::Any(),false);
   parser.addArgument("fixed", "f", mitkCommandLineParser::String, "Fixed images:", "Suffix for fixed image (if none is supplied first file matching moving pattern is chosen)",us::Any(),true);
   parser.addArgument("moving", "m", mitkCommandLineParser::String, "Moving images:", "Suffix for moving images",us::Any(),false);
   parser.addArgument("derived", "d", mitkCommandLineParser::String, "Derived resources:", "Derived resources suffixes (replaces suffix for moving images); comma separated",us::Any(),true);
   parser.addArgument("silent", "s", mitkCommandLineParser::Bool, "Silent:" "No xml progress output.");
   parser.addArgument("resample", "r", mitkCommandLineParser::String, "Resample (x,y,z)mm:", "Resample provide x,y,z spacing in mm (e.g. -r 1,1,3), is not applied to tensor data",us::Any());
   parser.addArgument("binary", "b", mitkCommandLineParser::Bool, "Binary:", "Speficies that derived resource are binary (interpolation using nearest neighbor)",us::Any());
   parser.addArgument("correct-origin", "c", mitkCommandLineParser::Bool, "Origin correction:", "Correct for large origin displacement. Switch when you reveive:  Joint PDF summed to zero ",us::Any());
   parser.addArgument("sinc-int", "s", mitkCommandLineParser::Bool, "Windowed-sinc interpolation:", "Use windowed-sinc interpolation (3) instead of linear interpolation ",us::Any());
 
 
   map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
 
   // Handle special arguments
   bool silent = false;
   bool isBinary = false;
   bool alignOrigin = false;
   bool useLinearInterpol = true;
   {
     if (parsedArgs.size() == 0)
     {
       return EXIT_FAILURE;
     }
 
     if (parsedArgs.count("sinc-int"))
       useLinearInterpol = false;
 
     if (parsedArgs.count("silent"))
       silent = true;
 
     if (parsedArgs.count("binary"))
       isBinary = true;
 
     if (parsedArgs.count("correct-origin"))
       alignOrigin = true;
 
     // Show a help message
     if ( parsedArgs.count("help") || parsedArgs.count("h"))
     {
       std::cout << parser.helpText();
       return EXIT_SUCCESS;
     }
   }
   std::string refPattern = "";
   bool useFirstMoving = false;
   std::string movingImgPattern = us::any_cast<string>(parsedArgs["moving"]);
 
   if (parsedArgs.count("fixed"))
   {
     refPattern = us::any_cast<string>(parsedArgs["fixed"]);
   }
   else
   {
     useFirstMoving = true;
     refPattern = movingImgPattern;
   }
 
   std::string outputPath = us::any_cast<string>(parsedArgs["output"]);
 
   std::string inputPath = us::any_cast<string>(parsedArgs["input"]);
   //QString resampleReference = parsedArgs["resample"].toString();
   //bool maskTumor = parsedArgs["usemask"].toBool();
 
   // if derived sources pattern is provided, populate QStringList with possible filename postfixes
   std::vector<std::string> derPatterns;
 
   if (parsedArgs.count("derived") || parsedArgs.count("d") )
   {
     std::string arg =  us::any_cast<string>(parsedArgs["derived"]);
     derPatterns = split(arg ,',');
   }
 
 
   std::vector<std::string> spacings;
   float spacing[3];
   bool doResampling = false;
   if (parsedArgs.count("resample") || parsedArgs.count("d") )
   {
     std::string arg =  us::any_cast<string>(parsedArgs["resample"]);
     spacings = split(arg ,',');
     spacing[0] = atoi(spacings.at(0).c_str());
     spacing[1] = atoi(spacings.at(1).c_str());
     spacing[2] = atoi(spacings.at(2).c_str());
     doResampling = true;
   }
 
   MITK_INFO << "Input Folder : " << inputPath;
   MITK_INFO << "Looking for reference image ...";
   FileListType referenceFileList = CreateFileList(inputPath,refPattern);
 
   if ((!useFirstMoving && referenceFileList.size() != 1) || (useFirstMoving && referenceFileList.size() == 0))
   {
     MITK_ERROR << "None or more than one possible reference images (" << refPattern <<") found. Exiting." << referenceFileList.size();
     MITK_INFO  << "Choose a fixed arguement that is unique in the given folder!";
     return EXIT_FAILURE;
   }
 
   std::string referenceFileName = referenceFileList.at(0);
 
   MITK_INFO << "Loading Reference (fixed) image: " << referenceFileName;
   std::string fileType = itksys::SystemTools::GetFilenameExtension(referenceFileName);
   mitk::Image::Pointer refImage = ExtractFirstTS(mitk::IOUtil::LoadImage(referenceFileName), fileType);
   mitk::Image::Pointer resampleReference = NULL;
   if (doResampling)
   {
     refImage = ResampleBySpacing(refImage,spacing);
     resampleReference = refImage;
   }
 
   if (refImage.IsNull())
     MITK_ERROR << "Loaded fixed image is NULL";
 
   // Copy reference image to destination
   std::string savePathAndFileName = GetSavePath(outputPath, referenceFileName);
   mitk::IOUtil::SaveImage(refImage, savePathAndFileName);
 
   // Copy all derived resources also to output folder, adding _reg suffix
   referenceFileList = CreateDerivedFileList(referenceFileName, movingImgPattern,derPatterns);
   CopyResources(referenceFileList, outputPath);
 
   std::string derivedResourceFilename;
   mitk::Image::Pointer referenceMask = NULL; // union of all segmentations
 
   if (!silent)
   {
     // XML Output to report progress
     std::cout << "<filter-start>";
     std::cout << "<filter-name>Batched Registration</filter-name>";
     std::cout << "<filter-comment>Starting registration ... </filter-comment>";
     std::cout << "</filter-start>";
   }
 
   // Now iterate over all files and register them to the reference image,
   // also register derived resources based on file patterns
   // ------------------------------------------------------------------------------
 
   // Create File list
 
   FileListType movingImagesList = CreateFileList(inputPath, movingImgPattern);
 
 
   // TODO Reactivate Resampling Feature
   //  mitk::Image::Pointer resampleImage = NULL;
   //  if (QFileInfo(resampleReference).isFile())
   //  {
   //    resampleImage = mitk::IOUtil::LoadImage(resampleReference.toStdString());
   //  }
   for (unsigned int i =0; i < movingImagesList.size(); i++)
   {
     std::string fileMorphName = movingImagesList.at(i);
     if (fileMorphName == referenceFileName)
     {
 
       // do not process reference image again
       continue;
     }
     MITK_INFO << "Processing image " << fileMorphName;
 
     // 1 Register morphological file to reference image
 
     if (!itksys::SystemTools::FileExists(fileMorphName.c_str()))
     {
       MITK_WARN << "File does not exit. Skipping entry.";
       continue;
     }
     // Origin of images is cancelled
     // TODO make this optional!!
     double transf[6];
     double offset[3];
     {
       std::string fileType = itksys::SystemTools::GetFilenameExtension(fileMorphName);
       mitk::Image::Pointer movingImage = ExtractFirstTS(mitk::IOUtil::LoadImage(fileMorphName), fileType);
 
       if (movingImage.IsNull())
         MITK_ERROR << "Loaded moving image is NULL";
 
       // Store transformation,  apply it to morph file
       MITK_INFO << "----------Registering moving image to reference----------";
       mitk::RegistrationWrapper::GetTransformation(refImage, movingImage, transf, offset, alignOrigin, referenceMask);
       mitk::RegistrationWrapper::ApplyTransformationToImage(movingImage, transf,offset, resampleReference); // , resampleImage
 
       savePathAndFileName = GetSavePath(outputPath, fileMorphName);
       if (fileType == ".dwi")
         fileType = "dwi";
       SaveImage(savePathAndFileName,movingImage,fileType );
     }
 
     if (!silent)
     {
       std::cout << "<filter-progress-text progress=\"" <<
                    (float)i / (float)movingImagesList.size()
                 << "\" >.</filter-progress-text>";
     }
 
     // Now parse all derived resource and apply the above calculated transformation to them
     // ------------------------------------------------------------------------------------
 
     FileListType fList = CreateDerivedFileList(fileMorphName, movingImgPattern,derPatterns);
     if (fList.size() > 0)
       MITK_INFO << "----------DERIVED RESOURCES ---------";
     for (unsigned int j=0; j < fList.size(); j++)
     {
       derivedResourceFilename = fList.at(j);
       MITK_INFO << "----Processing derived resorce " << derivedResourceFilename << " ...";
       std::string fileType = itksys::SystemTools::GetFilenameExtension(derivedResourceFilename);
       mitk::Image::Pointer derivedMovingResource = ExtractFirstTS(mitk::IOUtil::LoadImage(derivedResourceFilename), fileType);
       // Apply transformation to derived resource, treat derived resource as binary
       mitk::RegistrationWrapper::ApplyTransformationToImage(derivedMovingResource, transf,offset, resampleReference,isBinary);
 
       savePathAndFileName = GetSavePath(outputPath, derivedResourceFilename);
       SaveImage(savePathAndFileName,derivedMovingResource,fileType );
     }
   }
 
   if (!silent)
     std::cout << "<filter-end/>";
   return EXIT_SUCCESS;
 }
diff --git a/Modules/LegacyIO/mitkItkImageFileReader.cpp b/Modules/LegacyIO/mitkItkImageFileReader.cpp
index 475610eaf1..3bdb8219ce 100644
--- a/Modules/LegacyIO/mitkItkImageFileReader.cpp
+++ b/Modules/LegacyIO/mitkItkImageFileReader.cpp
@@ -1,211 +1,237 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 
 #include "mitkItkImageFileReader.h"
 #include "mitkConfig.h"
 #include "mitkException.h"
 #include <mitkProportionalTimeGeometry.h>
 
 #include <itkImageFileReader.h>
 #include <itksys/SystemTools.hxx>
 #include <itksys/Directory.hxx>
 #include <itkImage.h>
 //#include <itkImageSeriesReader.h>
 #include <itkImageFileReader.h>
 #include <itkImageIOFactory.h>
 #include <itkImageIORegion.h>
+#include <itkMetaDataObject.h>
 //#include <itkImageSeriesReader.h>
 //#include <itkDICOMImageIO2.h>
 //#include <itkDICOMSeriesFileNames.h>
 //#include <itkGDCMImageIO.h>
 //#include <itkGDCMSeriesFileNames.h>
 //#include <itkNumericSeriesFileNames.h>
 
 
 void mitk::ItkImageFileReader::GenerateData()
 {
   const std::string& locale = "C";
   const std::string& currLocale = setlocale( LC_ALL, NULL );
 
   if ( locale.compare(currLocale)!=0 )
   {
     try
     {
       setlocale(LC_ALL, locale.c_str());
     }
     catch(...)
     {
       MITK_INFO("mitkItkImageFileReader") << "Could not set locale " << locale;
     }
   }
 
   mitk::Image::Pointer image = this->GetOutput();
 
   const unsigned int MINDIM = 2;
   const unsigned int MAXDIM = 4;
 
   MITK_INFO("mitkItkImageFileReader") << "loading " << m_FileName << " via itk::ImageIOFactory... " << std::endl;
 
   // Check to see if we can read the file given the name or prefix
   if ( m_FileName == "" )
   {
     mitkThrow() << "Empty filename in mitk::ItkImageFileReader ";
     return ;
   }
 
   itk::ImageIOBase::Pointer imageIO = itk::ImageIOFactory::CreateImageIO( m_FileName.c_str(), itk::ImageIOFactory::ReadMode );
   if ( imageIO.IsNull() )
   {
     //itkWarningMacro( << "File Type not supported!" );
     mitkThrow() << "Could not create itk::ImageIOBase object for filename " << m_FileName;
     return ;
   }
 
   // Got to allocate space for the image. Determine the characteristics of
   // the image.
   imageIO->SetFileName( m_FileName.c_str() );
   imageIO->ReadImageInformation();
 
   unsigned int ndim = imageIO->GetNumberOfDimensions();
   if ( ndim < MINDIM || ndim > MAXDIM )
   {
     itkWarningMacro( << "Sorry, only dimensions 2, 3 and 4 are supported. The given file has " << ndim << " dimensions! Reading as 4D." );
     ndim = MAXDIM;
   }
 
   itk::ImageIORegion ioRegion( ndim );
   itk::ImageIORegion::SizeType ioSize = ioRegion.GetSize();
   itk::ImageIORegion::IndexType ioStart = ioRegion.GetIndex();
 
   unsigned int dimensions[ MAXDIM ];
   dimensions[ 0 ] = 0;
   dimensions[ 1 ] = 0;
   dimensions[ 2 ] = 0;
   dimensions[ 3 ] = 0;
 
   ScalarType spacing[ MAXDIM ];
   spacing[ 0 ] = 1.0f;
   spacing[ 1 ] = 1.0f;
   spacing[ 2 ] = 1.0f;
   spacing[ 3 ] = 1.0f;
 
   Point3D origin;
   origin.Fill(0);
 
   unsigned int i;
   for ( i = 0; i < ndim ; ++i )
   {
     ioStart[ i ] = 0;
     ioSize[ i ] = imageIO->GetDimensions( i );
     if(i<MAXDIM)
     {
       dimensions[ i ] = imageIO->GetDimensions( i );
       spacing[ i ] = imageIO->GetSpacing( i );
       if(spacing[ i ] <= 0)
         spacing[ i ] = 1.0f;
     }
     if(i<3)
     {
       origin[ i ] = imageIO->GetOrigin( i );
     }
   }
 
   ioRegion.SetSize( ioSize );
   ioRegion.SetIndex( ioStart );
 
   MITK_INFO("mitkItkImageFileReader") << "ioRegion: " << ioRegion << std::endl;
   imageIO->SetIORegion( ioRegion );
   void* buffer = new unsigned char[imageIO->GetImageSizeInBytes()];
   imageIO->Read( buffer );
 
   image->Initialize( MakePixelType(imageIO), ndim, dimensions );
   image->SetImportChannel( buffer, 0, Image::ManageMemory );
 
   // access direction of itk::Image and include spacing
   mitk::Matrix3D matrix;
   matrix.SetIdentity();
   unsigned int j, itkDimMax3 = (ndim >= 3? 3 : ndim);
   for ( i=0; i < itkDimMax3; ++i)
     for( j=0; j < itkDimMax3; ++j )
       matrix[i][j] = imageIO->GetDirection(j)[i];
 
   // re-initialize PlaneGeometry with origin and direction
   PlaneGeometry* planeGeometry = static_cast<PlaneGeometry*>(image->GetSlicedGeometry(0)->GetPlaneGeometry(0));
   planeGeometry->SetOrigin(origin);
   planeGeometry->GetIndexToWorldTransform()->SetMatrix(matrix);
 
   // re-initialize SlicedGeometry3D
   SlicedGeometry3D* slicedGeometry = image->GetSlicedGeometry(0);
   slicedGeometry->InitializeEvenlySpaced(planeGeometry, image->GetDimension(2));
   slicedGeometry->SetSpacing(spacing);
 
   MITK_INFO("mitkItkImageFileReader") << slicedGeometry->GetCornerPoint(false,false,false);
   MITK_INFO("mitkItkImageFileReader") << slicedGeometry->GetCornerPoint(true,true,true);
 
   // re-initialize TimeGeometry
   ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
   timeGeometry->Initialize(slicedGeometry, image->GetDimension(3));
   image->SetTimeGeometry(timeGeometry);
 
   buffer = NULL;
   MITK_INFO("mitkItkImageFileReader") << "number of image components: "<< image->GetPixelType().GetNumberOfComponents() << std::endl;
 //  mitk::DataNode::Pointer node = this->GetOutput();
 //  node->SetData( image );
 
   // add level-window property
   //if ( image->GetPixelType().GetNumberOfComponents() == 1 )
   //{
   //  SetDefaultImageProperties( node );
   //}
   MITK_INFO("mitkItkImageFileReader") << "...finished!" << std::endl;
 
   try
   {
     setlocale(LC_ALL, currLocale.c_str());
   }
   catch(...)
   {
     MITK_INFO("mitkItkImageFileReader") << "Could not reset locale " << currLocale;
   }
 }
 
 
 bool mitk::ItkImageFileReader::CanReadFile(const std::string filename, const std::string filePrefix, const std::string filePattern)
 {
   // First check the extension
   if(  filename == "" )
     return false;
 
   // check if image is serie
   if( filePattern != "" && filePrefix != "" )
     return false;
 
   itk::ImageIOBase::Pointer imageIO = itk::ImageIOFactory::CreateImageIO( filename.c_str(), itk::ImageIOFactory::ReadMode );
   if ( imageIO.IsNull() )
     return false;
 
+  try
+  {
+    imageIO->SetFileName( filename.c_str() );
+    imageIO->ReadImageInformation();
+    itk::MetaDataDictionary imgMetaDictionary = imageIO->GetMetaDataDictionary();
+    std::vector<std::string> imgMetaKeys = imgMetaDictionary.GetKeys();
+    std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin();
+    std::string metaString;
+
+    for (; itKey != imgMetaKeys.end(); itKey ++)
+    {
+      itk::ExposeMetaData<std::string> (imgMetaDictionary, *itKey, metaString);
+      if (itKey->find("modality") != std::string::npos)
+      {
+        if (metaString.find("DWMRI") != std::string::npos)
+        {
+          return false; // DiffusionImageReader should handle this
+        }
+      }
+    }
+  }catch(...)
+  {
+    MITK_INFO("mitkItkImageFileReader") << "Could not read ImageInformation ";
+  }
+
   return true;
 }
 
 mitk::ItkImageFileReader::ItkImageFileReader()
     : m_FileName(""), m_FilePrefix(""), m_FilePattern("")
 {
 }
 
 mitk::ItkImageFileReader::~ItkImageFileReader()
 {
 }
diff --git a/Modules/SceneSerializationBase/Testing/mitkPropertySerializationTest.cpp b/Modules/SceneSerializationBase/Testing/mitkPropertySerializationTest.cpp
index 1beccf113c..74b2a1df02 100644
--- a/Modules/SceneSerializationBase/Testing/mitkPropertySerializationTest.cpp
+++ b/Modules/SceneSerializationBase/Testing/mitkPropertySerializationTest.cpp
@@ -1,265 +1,264 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include "mitkTestingMacros.h"
 
 #include "mitkCoreObjectFactory.h"
 
 #include "mitkBaseProperty.h"
 #include "mitkProperties.h"
 #include <mitkAnnotationProperty.h>
 #include <mitkClippingProperty.h>
 #include <mitkColorProperty.h>
 #include <mitkEnumerationProperty.h>
 /*
 #include <mitkGridRepresentationProperty.h>
 #include <mitkGridVolumeMapperProperty.h>
 #include <mitkOrganTypeProperty.h>
 */
 #include <mitkModalityProperty.h>
 //#include <mitkOdfNormalizationMethodProperty.h>
 //#include <mitkOdfScaleByProperty.h>
 #include <mitkPlaneOrientationProperty.h>
 #include <mitkShaderProperty.h>
 #include <mitkVtkInterpolationProperty.h>
 #include <mitkVtkRepresentationProperty.h>
 #include <mitkVtkResliceInterpolationProperty.h>
 #include <mitkVtkScalarModeProperty.h>
 #include <mitkVtkVolumeRenderingProperty.h>
 #include <mitkGroupTagProperty.h>
 #include <mitkLevelWindowProperty.h>
 #include <mitkLookupTableProperty.h>
 #include <mitkStringProperty.h>
 #include <mitkTransferFunctionProperty.h>
 
 #include "mitkPropertyList.h"
 #include "mitkPropertyListSerializer.h"
 #include "mitkBasePropertySerializer.h"
 
 #include <mitkPointSet.h>
 #include <mitkImage.h>
 #include <mitkSurface.h>
 #include <mitkVtkWidgetRendering.h>
 
 /*
 #include <mitkContour.h>
 #include <mitkContourSet.h>
 #include <mitkMesh.h>
 #include <mitkCone.h>
 #include <mitkCuboid.h>
 #include <mitkCylinder.h>
 #include <mitkEllipsoid.h>
 #include <mitkExtrudedContour.h>
 #include <mitkPlane.h>
 #include <mitkUnstructuredGrid.h>
 */
 
 void TestAllProperties(const mitk::PropertyList* propList);
 
 /**Documentation
 * \brief Test for all PropertySerializer classes.
 *
 */
 int mitkPropertySerializationTest(int /* argc */, char* /*argv*/[])
 {
   MITK_TEST_BEGIN("PropertySerializationTest");
 
   mitk::PropertyListSerializer::Pointer serializer = mitk::PropertyListSerializer::New(); // make sure something from the lib is actually used (registration of serializers)
 
   /* build list of properties that will be serialized and deserialized */
   mitk::PropertyList::Pointer propList = mitk::PropertyList::New();
   propList->SetProperty("booltrue", mitk::BoolProperty::New(true));
   propList->SetProperty("boolfalse", mitk::BoolProperty::New(false));
   propList->SetProperty("int", mitk::IntProperty::New(-32));
   propList->SetProperty("float", mitk::FloatProperty::New(-31.337));
   propList->SetProperty("double", mitk::DoubleProperty::New(-31.337));
   propList->SetProperty("string", mitk::StringProperty::New("Hello MITK"));
   mitk::Point3D p3d;
   mitk::FillVector3D(p3d, 1.0, 2.2, -3.3);
   propList->SetProperty("p3d", mitk::Point3dProperty::New(p3d));
   mitk::Point3I p3i;
   mitk::FillVector3D(p3i, 1, 2, -3);
   propList->SetProperty("p3i", mitk::Point3iProperty::New(p3i));
   mitk::Point4D p4d;
   mitk::FillVector4D(p4d, 1.5, 2.6, -3.7, 4.44);
   propList->SetProperty("p4d", mitk::Point4dProperty::New(p4d));
   mitk::Vector3D v3d;
   mitk::FillVector3D(v3d, 1.0, 2.2, -3.3);
   propList->SetProperty("v3d", mitk::Vector3DProperty::New(v3d));
   propList->SetProperty("annotation", mitk::AnnotationProperty::New("My Annotation", p3d));
   propList->SetProperty("clipping", mitk::ClippingProperty::New(p3d, v3d));
   propList->SetProperty("color", mitk::ColorProperty::New(1.0, 0.2, 0.2));
   //mitk::EnumerationProperty::Pointer en = mitk::EnumerationProperty::New();
   //en->AddEnum("PC", 1); en->AddEnum("Playstation", 2); en->AddEnum("Wii", 111); en->AddEnum("XBox", 7);
   //en->SetValue("XBox");
   //propList->SetProperty("enum", en);
   /*
   propList->SetProperty("gridrep", mitk::GridRepresentationProperty::New(2));
   propList->SetProperty("gridvol", mitk::GridVolumeMapperProperty::New(0));
   propList->SetProperty("OrganTypeProperty", mitk::OrganTypeProperty::New("Larynx"));
   */
   propList->SetProperty("modality", mitk::ModalityProperty::New("Color Doppler"));
   //propList->SetProperty("OdfNormalizationMethodProperty", mitk::OdfNormalizationMethodProperty::New("Global Maximum"));
   //propList->SetProperty("OdfScaleByProperty", mitk::OdfScaleByProperty::New("Principal Curvature"));
   propList->SetProperty("PlaneOrientationProperty", mitk::PlaneOrientationProperty::New("Arrows in positive direction"));
   propList->SetProperty("ShaderProperty", mitk::ShaderProperty::New("fixed"));
   propList->SetProperty("VtkInterpolationProperty", mitk::VtkInterpolationProperty::New("Gouraud"));
   propList->SetProperty("VtkRepresentationProperty", mitk::VtkRepresentationProperty::New("Surface"));
   propList->SetProperty("VtkResliceInterpolationProperty", mitk::VtkResliceInterpolationProperty::New("Cubic"));
   propList->SetProperty("VtkScalarModeProperty", mitk::VtkScalarModeProperty::New("PointFieldData"));
   propList->SetProperty("VtkVolumeRenderingProperty", mitk::VtkVolumeRenderingProperty::New("COMPOSITE"));
   mitk::BoolLookupTable blt;
   blt.SetTableValue(0, true);  blt.SetTableValue(1, false);  blt.SetTableValue(2, true);
   propList->SetProperty("BoolLookupTableProperty", mitk::BoolLookupTableProperty::New(blt));
   mitk::FloatLookupTable flt;
   flt.SetTableValue(0, 3.1);  flt.SetTableValue(1, 3.3);  flt.SetTableValue(2, 7.0);
   propList->SetProperty("FloatLookupTableProperty", mitk::FloatLookupTableProperty::New(flt));
   mitk::IntLookupTable ilt;
   ilt.SetTableValue(0, 3);  ilt.SetTableValue(1, 2);  ilt.SetTableValue(2, 11);
   propList->SetProperty("IntLookupTableProperty", mitk::IntLookupTableProperty::New(ilt));
   mitk::StringLookupTable slt;
   slt.SetTableValue(0, "Hello");  slt.SetTableValue(1, "MITK");  slt.SetTableValue(2, "world");
   propList->SetProperty("StringLookupTableProperty", mitk::StringLookupTableProperty::New(slt));
   propList->SetProperty("GroupTagProperty", mitk::GroupTagProperty::New());
   propList->SetProperty("LevelWindowProperty", mitk::LevelWindowProperty::New(mitk::LevelWindow(100.0, 50.0)));
   mitk::LookupTable::Pointer lt = mitk::LookupTable::New();
   lt->ChangeOpacityForAll(0.25);
   lt->ChangeOpacity(17, 0.88);
   propList->SetProperty("LookupTableProperty", mitk::LookupTableProperty::New(lt));
   propList->SetProperty("StringProperty", mitk::StringProperty::New("Oh why, gruel world"));
   //mitk::TransferFunction::Pointer tf = mitk::TransferFunction::New();
   //tf->SetTransferFunctionMode(1);
   //propList->SetProperty("TransferFunctionProperty", mitk::TransferFunctionProperty::New(tf));
 
 
   MITK_TEST_CONDITION_REQUIRED(propList->GetMap()->size() > 0, "Initialize PropertyList");
 
   TestAllProperties(propList);
 
   /* test default property lists of basedata objects */
   // activate the following tests after MaterialProperty is deleted
 
   mitk::DataNode::Pointer node = mitk::DataNode::New();
   node->SetData(mitk::PointSet::New());
   TestAllProperties(node->GetPropertyList());
   node->SetData(mitk::Image::New());
   TestAllProperties(node->GetPropertyList());
   node->SetData(mitk::Surface::New());
   TestAllProperties(node->GetPropertyList());
   node->SetData(mitk::VtkWidgetRendering::New());
   TestAllProperties(node->GetPropertyList());
 
   /*
   node->SetData(mitk::Contour::New());
   TestAllProperties(node->GetPropertyList());
   node->SetData(mitk::ContourSet::New());
   TestAllProperties(node->GetPropertyList());
   node->SetData(mitk::Mesh::New());
   TestAllProperties(node->GetPropertyList());
   node->SetData(mitk::Cone::New());
   TestAllProperties(node->GetPropertyList());
   node->SetData(mitk::Cuboid::New());
   TestAllProperties(node->GetPropertyList());
   node->SetData(mitk::Cylinder::New());
   TestAllProperties(node->GetPropertyList());
   node->SetData(mitk::Ellipsoid::New());
   TestAllProperties(node->GetPropertyList());
   node->SetData(mitk::ExtrudedContour::New());
   TestAllProperties(node->GetPropertyList());
   node->SetData(mitk::Plane::New());
   TestAllProperties(node->GetPropertyList());
   //node->SetData(mitk::TrackingVolume::New());  // TrackingVolume is in IGT Module, it does not have special properties, therefore we skip it here
   //TestAllProperties(node->GetPropertyList());
   node->SetData(mitk::UnstructuredGrid::New());
   TestAllProperties(node->GetPropertyList());
   */
 
 /* untested base data types:
   BaseDataTestImplementation
   RenderWindowFrame
-  mitk::DiffusionImage< TPixelType >
   GeometryData
   mitk::PlaneGeometryData
   GradientBackground
   ItkBaseDataAdapter
   ManufacturerLogo
   SlicedData
   QBallImage
   SeedsImage
   TensorImage
   BoundingObject
   BoundingObjectGroup
   */
 
   MITK_TEST_END();
 }
 
 void TestAllProperties(const mitk::PropertyList* propList)
 {
   assert(propList);
 
   /* try to serialize each property in the list, then deserialize again and check for equality */
   for (mitk::PropertyList::PropertyMap::const_iterator it = propList->GetMap()->begin(); it != propList->GetMap()->end(); ++it)
   {
     const mitk::BaseProperty* prop = it->second;
     // construct name of serializer class
     std::string serializername = std::string(prop->GetNameOfClass()) + "Serializer";
     std::list<itk::LightObject::Pointer> allSerializers = itk::ObjectFactoryBase::CreateAllInstance(serializername.c_str());
     MITK_TEST_CONDITION(allSerializers.size() > 0, std::string("Creating serializers for ") + serializername);
     if (allSerializers.size() == 0)
     {
       MITK_TEST_OUTPUT( << "serialization not possible, skipping " << prop->GetNameOfClass());
       continue;
     }
     if (allSerializers.size() > 1)
     {
       MITK_TEST_OUTPUT (<< "Warning: " << allSerializers.size() << " serializers found for " << prop->GetNameOfClass() << "testing only the first one.");
     }
     mitk::BasePropertySerializer* serializer = dynamic_cast<mitk::BasePropertySerializer*>( allSerializers.begin()->GetPointer());
     MITK_TEST_CONDITION(serializer != NULL, serializername + std::string(" is valid"));
     if (serializer != NULL)
     {
       serializer->SetProperty(prop);
       TiXmlElement* valueelement = NULL;
       try
       {
         valueelement = serializer->Serialize();
       }
       catch (...)
       {
       }
       MITK_TEST_CONDITION(valueelement != NULL, std::string("Serialize property with ") + serializername);
 
       if (valueelement == NULL)
       {
         MITK_TEST_OUTPUT( << "serialization failed, skipping deserialization");
         continue;
       }
 
       mitk::BaseProperty::Pointer deserializedProp = serializer->Deserialize( valueelement );
       MITK_TEST_CONDITION(deserializedProp.IsNotNull(), "serializer created valid property");
       if (deserializedProp.IsNotNull())
       {
         MITK_TEST_CONDITION(*(deserializedProp.GetPointer()) == *prop, "deserialized property equals initial property for type " << prop->GetNameOfClass());
       }
 
     }
     else
     {
       MITK_TEST_OUTPUT( << "created serializer object is of class " << allSerializers.begin()->GetPointer()->GetNameOfClass())
     }
   } // for all properties
 }
diff --git a/Plugins/org.mitk.diffusionimaging/src/internal/mitkDiffusionImagingActivator.cpp b/Plugins/org.mitk.diffusionimaging/src/internal/mitkDiffusionImagingActivator.cpp
index 40d92b2cdf..210aa03fc6 100644
--- a/Plugins/org.mitk.diffusionimaging/src/internal/mitkDiffusionImagingActivator.cpp
+++ b/Plugins/org.mitk.diffusionimaging/src/internal/mitkDiffusionImagingActivator.cpp
@@ -1,61 +1,64 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include "mitkDiffusionImagingActivator.h"
 
 #include "QmitkNodeDescriptorManager.h"
 #include "mitkNodePredicateDataType.h"
+#include "mitkNodePredicateProperty.h"
+#include "mitkNodePredicateIsDWI.h"
+#include <mitkDiffusionPropertyHelper.h>
 
 #include <QtPlugin>
 
 void
 mitk::DiffusionImagingActivator::start(ctkPluginContext* context)
 {
   Q_UNUSED(context)
 
   QmitkNodeDescriptorManager* manager =
     QmitkNodeDescriptorManager::GetInstance();
 
-  mitk::NodePredicateDataType::Pointer isDiffusionImage = mitk::NodePredicateDataType::New("DiffusionImage");
+  mitk::NodePredicateIsDWI::Pointer isDiffusionImage = mitk::NodePredicateIsDWI::New();
   QmitkNodeDescriptor* desc = new QmitkNodeDescriptor(QObject::tr("DiffusionImage"), QString(":/QmitkDiffusionImaging/QBallData24.png"), isDiffusionImage, manager);
   manager->AddDescriptor(desc);
 
   mitk::NodePredicateDataType::Pointer isTensorImage = mitk::NodePredicateDataType::New("TensorImage");
   manager->AddDescriptor(new QmitkNodeDescriptor(QObject::tr("TensorImage"), QString(":/QmitkDiffusionImaging/recontensor.png"), isTensorImage, manager));
 
   mitk::NodePredicateDataType::Pointer isQBallImage = mitk::NodePredicateDataType::New("QBallImage");
   manager->AddDescriptor(new QmitkNodeDescriptor(QObject::tr("QBallImage"), QString(":/QmitkDiffusionImaging/reconodf.png"), isQBallImage, manager));
 
   mitk::NodePredicateDataType::Pointer isFiberBundle = mitk::NodePredicateDataType::New("FiberBundle");
   manager->AddDescriptor(new QmitkNodeDescriptor(QObject::tr("FiberBundle"), QString(":/QmitkDiffusionImaging/FiberBundle.png"), isFiberBundle, manager));
 
   mitk::NodePredicateDataType::Pointer isFiberBundleX = mitk::NodePredicateDataType::New("FiberBundleX");
   manager->AddDescriptor(new QmitkNodeDescriptor(QObject::tr("FiberBundleX"), QString(":/QmitkDiffusionImaging/FiberBundleX.png"), isFiberBundleX, manager));
 
   mitk::NodePredicateDataType::Pointer isConnectomicsNetwork = mitk::NodePredicateDataType::New("ConnectomicsNetwork");
   manager->AddDescriptor(new QmitkNodeDescriptor(QObject::tr("ConnectomicsNetwork"), QString(":/QmitkDiffusionImaging/ConnectomicsNetwork.png"), isConnectomicsNetwork, manager));
 
 }
 
 void
 mitk::DiffusionImagingActivator::stop(ctkPluginContext* context)
 {
   Q_UNUSED(context)
 }
 
 #if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
   Q_EXPORT_PLUGIN2(org_mitk_diffusionimaging, mitk::DiffusionImagingActivator)
 #endif
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
index c9059bb39f..50cfe086bc 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
@@ -1,1829 +1,1839 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include "QmitkControlVisualizationPropertiesView.h"
 
 #include "mitkNodePredicateDataType.h"
 #include "mitkDataNodeObject.h"
 #include "mitkOdfNormalizationMethodProperty.h"
 #include "mitkOdfScaleByProperty.h"
 #include "mitkResliceMethodProperty.h"
 #include "mitkRenderingManager.h"
 
 #include "mitkTbssImage.h"
 #include "mitkPlanarFigure.h"
 #include "mitkFiberBundleX.h"
 #include "QmitkDataStorageComboBox.h"
 #include "QmitkStdMultiWidget.h"
 #include "mitkFiberBundleInteractor.h"
 #include "mitkPlanarFigureInteractor.h"
 #include <mitkQBallImage.h>
 #include <mitkTensorImage.h>
-#include <mitkDiffusionImage.h>
+#include <mitkImage.h>
+#include <mitkDiffusionPropertyHelper.h>
 #include <mitkConnectomicsNetwork.h>
 #include "mitkGlobalInteraction.h"
 #include "usModuleRegistry.h"
 
 #include "mitkPlaneGeometry.h"
 
 #include "berryIWorkbenchWindow.h"
 #include "berryIWorkbenchPage.h"
 #include "berryISelectionService.h"
 #include "berryConstants.h"
 #include "berryPlatformUI.h"
 
 #include "itkRGBAPixel.h"
 #include <itkTractDensityImageFilter.h>
 
 #include "qwidgetaction.h"
 #include "qcolordialog.h"
 #include <itkMultiThreader.h>
 
 #define ROUND(a) ((a)>0 ? (int)((a)+0.5) : -(int)(0.5-(a)))
 
 static bool DetermineAffectedImageSlice( const mitk::Image* image, const mitk::PlaneGeometry* plane, int& affectedDimension, int& affectedSlice )
 {
   assert(image);
   assert(plane);
 
   // compare normal of plane to the three axis vectors of the image
   mitk::Vector3D normal       = plane->GetNormal();
   mitk::Vector3D imageNormal0 = image->GetSlicedGeometry()->GetAxisVector(0);
   mitk::Vector3D imageNormal1 = image->GetSlicedGeometry()->GetAxisVector(1);
   mitk::Vector3D imageNormal2 = image->GetSlicedGeometry()->GetAxisVector(2);
 
   normal.Normalize();
   imageNormal0.Normalize();
   imageNormal1.Normalize();
   imageNormal2.Normalize();
 
   imageNormal0.SetVnlVector( vnl_cross_3d<mitk::ScalarType>(normal.GetVnlVector(),imageNormal0.GetVnlVector()) );
   imageNormal1.SetVnlVector( vnl_cross_3d<mitk::ScalarType>(normal.GetVnlVector(),imageNormal1.GetVnlVector()) );
   imageNormal2.SetVnlVector( vnl_cross_3d<mitk::ScalarType>(normal.GetVnlVector(),imageNormal2.GetVnlVector()) );
 
   double eps( 0.00001 );
   // axial
   if ( imageNormal2.GetNorm() <= eps )
   {
     affectedDimension = 2;
   }
   // sagittal
   else if ( imageNormal1.GetNorm() <= eps )
   {
     affectedDimension = 1;
   }
   // frontal
   else if ( imageNormal0.GetNorm() <= eps )
   {
     affectedDimension = 0;
   }
   else
   {
     affectedDimension = -1; // no idea
     return false;
   }
 
   // determine slice number in image
   mitk::BaseGeometry* imageGeometry = image->GetGeometry(0);
   mitk::Point3D testPoint = imageGeometry->GetCenter();
   mitk::Point3D projectedPoint;
   plane->Project( testPoint, projectedPoint );
 
   mitk::Point3D indexPoint;
 
   imageGeometry->WorldToIndex( projectedPoint, indexPoint );
   affectedSlice = ROUND( indexPoint[affectedDimension] );
   MITK_DEBUG << "indexPoint " << indexPoint << " affectedDimension " << affectedDimension << " affectedSlice " << affectedSlice;
 
   // check if this index is still within the image
   if ( affectedSlice < 0 || affectedSlice >= static_cast<int>(image->GetDimension(affectedDimension)) ) return false;
 
   return true;
 }
 
 const std::string QmitkControlVisualizationPropertiesView::VIEW_ID = "org.mitk.views.controlvisualizationpropertiesview";
 
 using namespace berry;
 
 struct CvpSelListener : ISelectionListener
 {
 
   berryObjectMacro(CvpSelListener);
 
   CvpSelListener(QmitkControlVisualizationPropertiesView* view)
   {
     m_View = view;
   }
 
   void ApplySettings(mitk::DataNode::Pointer node)
   {
     bool tex_int;
     node->GetBoolProperty("texture interpolation", tex_int);
     if(tex_int)
     {
       m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexON);
       m_View->m_Controls->m_TextureIntON->setChecked(true);
       m_View->m_TexIsOn = true;
     }
     else
     {
       m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexOFF);
       m_View->m_Controls->m_TextureIntON->setChecked(false);
       m_View->m_TexIsOn = false;
     }
 
     int val;
     node->GetIntProperty("ShowMaxNumber", val);
     m_View->m_Controls->m_ShowMaxNumber->setValue(val);
 
     m_View->m_Controls->m_NormalizationDropdown->setCurrentIndex(dynamic_cast<mitk::EnumerationProperty*>(node->GetProperty("Normalization"))->GetValueAsId());
 
     float fval;
     node->GetFloatProperty("Scaling",fval);
     m_View->m_Controls->m_ScalingFactor->setValue(fval);
 
     m_View->m_Controls->m_AdditionalScaling->setCurrentIndex(dynamic_cast<mitk::EnumerationProperty*>(node->GetProperty("ScaleBy"))->GetValueAsId());
 
     node->GetFloatProperty("IndexParam1",fval);
     m_View->m_Controls->m_IndexParam1->setValue(fval);
 
     node->GetFloatProperty("IndexParam2",fval);
     m_View->m_Controls->m_IndexParam2->setValue(fval);
   }
 
   void DoSelectionChanged(ISelection::ConstPointer selection)
   {
     // save current selection in member variable
     m_View->m_CurrentSelection = selection.Cast<const IStructuredSelection>();
 
     m_View->m_Controls->m_VisibleOdfsON_T->setVisible(false);
     m_View->m_Controls->m_VisibleOdfsON_S->setVisible(false);
     m_View->m_Controls->m_VisibleOdfsON_C->setVisible(false);
     m_View->m_Controls->m_TextureIntON->setVisible(false);
 
     m_View->m_Controls->m_ImageControlsFrame->setVisible(false);
     m_View->m_Controls->m_PlanarFigureControlsFrame->setVisible(false);
     m_View->m_Controls->m_BundleControlsFrame->setVisible(false);
     m_View->m_SelectedNode = 0;
 
     if(m_View->m_CurrentSelection.IsNull())
       return;
 
     if(m_View->m_CurrentSelection->Size() == 1)
     {
       mitk::DataNodeObject::Pointer nodeObj = m_View->m_CurrentSelection->Begin()->Cast<mitk::DataNodeObject>();
       if(nodeObj.IsNotNull())
       {
         mitk::DataNode::Pointer node = nodeObj->GetDataNode();
 
         // check if node has data,
         // if some helper nodes are shown in the DataManager, the GetData() returns 0x0 which would lead to SIGSEV
         mitk::BaseData* nodeData = node->GetData();
 
         if(nodeData != NULL )
         {
           if(dynamic_cast<mitk::PlanarFigure*>(nodeData) != 0)
           {
             m_View->m_Controls->m_PlanarFigureControlsFrame->setVisible(true);
             m_View->m_SelectedNode = node;
 
             float val;
             node->GetFloatProperty("planarfigure.line.width", val);
             m_View->m_Controls->m_PFWidth->setValue((int)(val*10.0));
 
             QString label = "Width %1";
             label = label.arg(val);
             m_View->m_Controls->label_pfwidth->setText(label);
 
             float color[3];
             node->GetColor( color, NULL, "planarfigure.default.line.color");
             QString styleSheet = "background-color:rgb(";
             styleSheet.append(QString::number(color[0]*255.0));
             styleSheet.append(",");
             styleSheet.append(QString::number(color[1]*255.0));
             styleSheet.append(",");
             styleSheet.append(QString::number(color[2]*255.0));
             styleSheet.append(")");
             m_View->m_Controls->m_PFColor->setAutoFillBackground(true);
             m_View->m_Controls->m_PFColor->setStyleSheet(styleSheet);
 
             node->GetColor( color, NULL, "color");
             styleSheet = "background-color:rgb(";
             styleSheet.append(QString::number(color[0]*255.0));
             styleSheet.append(",");
             styleSheet.append(QString::number(color[1]*255.0));
             styleSheet.append(",");
             styleSheet.append(QString::number(color[2]*255.0));
             styleSheet.append(")");
 
             m_View->PlanarFigureFocus();
           }
 
           if(dynamic_cast<mitk::FiberBundleX*>(nodeData) != 0)
           {
             m_View->m_Controls->m_BundleControlsFrame->setVisible(true);
             m_View->m_SelectedNode = node;
 
             if(m_View->m_CurrentPickingNode != 0 && node.GetPointer() != m_View->m_CurrentPickingNode)
             {
               m_View->m_Controls->m_Crosshair->setEnabled(false);
             }
             else
             {
               m_View->m_Controls->m_Crosshair->setEnabled(true);
             }
 
             int width;
             node->GetIntProperty("LineWidth", width);
             m_View->m_Controls->m_LineWidth->setValue(width);
 
             float range;
             node->GetFloatProperty("Fiber2DSliceThickness",range);
             mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
             mitk::BaseGeometry::Pointer geo = fib->GetGeometry();
             mitk::ScalarType max = geo->GetExtentInMM(0);
             max = std::max(max, geo->GetExtentInMM(1));
             max = std::max(max, geo->GetExtentInMM(2));
 
             m_View->m_Controls->m_FiberThicknessSlider->setMaximum(max * 10);
 
             m_View->m_Controls->m_FiberThicknessSlider->setValue(range * 10);
 
           }
 
         } // check node data != NULL
       }
     }
 
     if(m_View->m_CurrentSelection->Size() > 0 && m_View->m_SelectedNode == 0)
     {
       m_View->m_Controls->m_ImageControlsFrame->setVisible(true);
 
       bool foundDiffusionImage = false;
       bool foundQBIVolume = false;
       bool foundTensorVolume = false;
       bool foundImage = false;
       bool foundMultipleOdfImages = false;
       bool foundRGBAImage = false;
       bool foundTbssImage = false;
 
       // do something with the selected items
       if(m_View->m_CurrentSelection)
       {
         // iterate selection
         for (IStructuredSelection::iterator i = m_View->m_CurrentSelection->Begin();
           i != m_View->m_CurrentSelection->End(); ++i)
         {
 
           // extract datatree node
           if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
           {
             mitk::DataNode::Pointer node = nodeObj->GetDataNode();
 
             mitk::BaseData* nodeData = node->GetData();
 
             if(nodeData != NULL )
             {
               // only look at interesting types
               if(QString("DiffusionImage").compare(nodeData->GetNameOfClass())==0)
               {
                 foundDiffusionImage = true;
                 bool tex_int;
                 node->GetBoolProperty("texture interpolation", tex_int);
                 if(tex_int)
                 {
                   m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexON);
                   m_View->m_Controls->m_TextureIntON->setChecked(true);
                   m_View->m_TexIsOn = true;
                 }
                 else
                 {
                   m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexOFF);
                   m_View->m_Controls->m_TextureIntON->setChecked(false);
                   m_View->m_TexIsOn = false;
                 }
                 int val;
                 node->GetIntProperty("DisplayChannel", val);
                 m_View->m_Controls->m_DisplayIndex->setValue(val);
                 m_View->m_Controls->m_DisplayIndexSpinBox->setValue(val);
 
                 QString label = "Channel %1";
                 label = label.arg(val);
                 m_View->m_Controls->label_channel->setText(label);
 
-                int maxVal = (dynamic_cast<mitk::DiffusionImage<short>* >(nodeData))->GetVectorImage()->GetVectorLength();
+                mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
+                mitk::CastToItkImage(dynamic_cast<mitk::Image*>(nodeData), itkVectorImagePointer);
+
+                int maxVal = itkVectorImagePointer->GetVectorLength();
                 m_View->m_Controls->m_DisplayIndex->setMaximum(maxVal-1);
                 m_View->m_Controls->m_DisplayIndexSpinBox->setMaximum(maxVal-1);
               }
 
               if(QString("TbssImage").compare(nodeData->GetNameOfClass())==0)
               {
                 foundTbssImage = true;
                 bool tex_int;
                 node->GetBoolProperty("texture interpolation", tex_int);
                 if(tex_int)
                 {
                   m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexON);
                   m_View->m_Controls->m_TextureIntON->setChecked(true);
                   m_View->m_TexIsOn = true;
                 }
                 else
                 {
                   m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexOFF);
                   m_View->m_Controls->m_TextureIntON->setChecked(false);
                   m_View->m_TexIsOn = false;
                 }
                 int val;
                 node->GetIntProperty("DisplayChannel", val);
                 m_View->m_Controls->m_DisplayIndex->setValue(val);
                 m_View->m_Controls->m_DisplayIndexSpinBox->setValue(val);
 
                 QString label = "Channel %1";
                 label = label.arg(val);
                 m_View->m_Controls->label_channel->setText(label);
 
                 int maxVal = (dynamic_cast<mitk::TbssImage* >(nodeData))->GetImage()->GetVectorLength();
                 m_View->m_Controls->m_DisplayIndex->setMaximum(maxVal-1);
                 m_View->m_Controls->m_DisplayIndexSpinBox->setMaximum(maxVal-1);
               }
 
 
               else if(QString("QBallImage").compare(nodeData->GetNameOfClass())==0)
               {
                 foundMultipleOdfImages = foundQBIVolume || foundTensorVolume;
                 foundQBIVolume = true;
                 ApplySettings(node);
               }
 
               else if(QString("TensorImage").compare(nodeData->GetNameOfClass())==0)
               {
                 foundMultipleOdfImages = foundQBIVolume || foundTensorVolume;
                 foundTensorVolume = true;
                 ApplySettings(node);
               }
 
               else if(QString("Image").compare(nodeData->GetNameOfClass())==0)
               {
                 foundImage = true;
                 mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(nodeData);
                 if(img.IsNotNull()
                   && img->GetPixelType().GetPixelType() == itk::ImageIOBase::RGBA
                   && img->GetPixelType().GetComponentType() == itk::ImageIOBase::UCHAR )
                 {
                   foundRGBAImage = true;
                 }
 
                 bool tex_int;
                 node->GetBoolProperty("texture interpolation", tex_int);
                 if(tex_int)
                 {
                   m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexON);
                   m_View->m_Controls->m_TextureIntON->setChecked(true);
                   m_View->m_TexIsOn = true;
                 }
                 else
                 {
                   m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexOFF);
                   m_View->m_Controls->m_TextureIntON->setChecked(false);
                   m_View->m_TexIsOn = false;
                 }
               }
 
             } // END CHECK node != NULL
           }
         }
       }
 
       m_View->m_FoundSingleOdfImage = (foundQBIVolume || foundTensorVolume)
         && !foundMultipleOdfImages;
       m_View->m_Controls->m_NumberGlyphsFrame->setVisible(m_View->m_FoundSingleOdfImage);
 
       m_View->m_Controls->m_NormalizationDropdown->setVisible(m_View->m_FoundSingleOdfImage);
       m_View->m_Controls->label->setVisible(m_View->m_FoundSingleOdfImage);
       m_View->m_Controls->m_ScalingFactor->setVisible(m_View->m_FoundSingleOdfImage);
       m_View->m_Controls->m_AdditionalScaling->setVisible(m_View->m_FoundSingleOdfImage);
       m_View->m_Controls->m_NormalizationScalingFrame->setVisible(m_View->m_FoundSingleOdfImage);
 
       m_View->m_Controls->OpacMinFrame->setVisible(foundRGBAImage || m_View->m_FoundSingleOdfImage);
 
       // changed for SPIE paper, Principle curvature scaling
       //m_View->m_Controls->params_frame->setVisible(m_View->m_FoundSingleOdfImage);
       m_View->m_Controls->params_frame->setVisible(false);
 
       m_View->m_Controls->m_VisibleOdfsON_T->setVisible(m_View->m_FoundSingleOdfImage);
       m_View->m_Controls->m_VisibleOdfsON_S->setVisible(m_View->m_FoundSingleOdfImage);
       m_View->m_Controls->m_VisibleOdfsON_C->setVisible(m_View->m_FoundSingleOdfImage);
 
       bool foundAnyImage = foundDiffusionImage ||
         foundQBIVolume || foundTensorVolume || foundImage || foundTbssImage;
 
       m_View->m_Controls->m_Reinit->setVisible(foundAnyImage);
       m_View->m_Controls->m_TextureIntON->setVisible(foundAnyImage);
       m_View->m_Controls->m_TSMenu->setVisible(foundAnyImage);
 
     }
   }
 
   void SelectionChanged(IWorkbenchPart::Pointer part, ISelection::ConstPointer selection)
   {
     // check, if selection comes from datamanager
     if (part)
     {
       QString partname(part->GetPartName().c_str());
       if(partname.compare("Data Manager")==0)
       {
 
         // apply selection
         DoSelectionChanged(selection);
 
       }
     }
   }
 
   QmitkControlVisualizationPropertiesView* m_View;
 };
 
 QmitkControlVisualizationPropertiesView::QmitkControlVisualizationPropertiesView()
   : QmitkFunctionality(),
   m_Controls(NULL),
   m_MultiWidget(NULL),
   m_NodeUsedForOdfVisualization(NULL),
   m_IconTexOFF(new QIcon(":/QmitkDiffusionImaging/texIntOFFIcon.png")),
   m_IconTexON(new QIcon(":/QmitkDiffusionImaging/texIntONIcon.png")),
   m_IconGlyOFF_T(new QIcon(":/QmitkDiffusionImaging/glyphsoff_T.png")),
   m_IconGlyON_T(new QIcon(":/QmitkDiffusionImaging/glyphson_T.png")),
   m_IconGlyOFF_C(new QIcon(":/QmitkDiffusionImaging/glyphsoff_C.png")),
   m_IconGlyON_C(new QIcon(":/QmitkDiffusionImaging/glyphson_C.png")),
   m_IconGlyOFF_S(new QIcon(":/QmitkDiffusionImaging/glyphsoff_S.png")),
   m_IconGlyON_S(new QIcon(":/QmitkDiffusionImaging/glyphson_S.png")),
   m_CurrentSelection(0),
   m_CurrentPickingNode(0),
   m_GlyIsOn_S(false),
   m_GlyIsOn_C(false),
   m_GlyIsOn_T(false),
   m_FiberBundleObserverTag(0),
   m_Color(NULL)
 {
   currentThickSlicesMode = 1;
   m_MyMenu = NULL;
   int numThread = itk::MultiThreader::GetGlobalMaximumNumberOfThreads();
   if (numThread > 12)
     numThread = 12;
   itk::MultiThreader::SetGlobalDefaultNumberOfThreads(numThread);
 }
 
 QmitkControlVisualizationPropertiesView::QmitkControlVisualizationPropertiesView(const QmitkControlVisualizationPropertiesView& other)
 {
   Q_UNUSED(other)
     throw std::runtime_error("Copy constructor not implemented");
 }
 
 QmitkControlVisualizationPropertiesView::~QmitkControlVisualizationPropertiesView()
 {
   if(m_SlicesRotationObserverTag1 )
   {
     mitk::SlicesCoordinator::Pointer coordinator = m_MultiWidget->GetSlicesRotator();
     if( coordinator.IsNotNull() )
       coordinator->RemoveObserver(m_SlicesRotationObserverTag1);
   }
   if( m_SlicesRotationObserverTag2)
   {
     mitk::SlicesCoordinator::Pointer coordinator = m_MultiWidget->GetSlicesRotator();
     if( coordinator.IsNotNull() )
       coordinator->RemoveObserver(m_SlicesRotationObserverTag1);
   }
 
   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->RemovePostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
 }
 
 void QmitkControlVisualizationPropertiesView::OnThickSlicesModeSelected( QAction* action )
 {
   currentThickSlicesMode = action->data().toInt();
 
   switch(currentThickSlicesMode)
   {
   default:
   case 1:
     this->m_Controls->m_TSMenu->setText("MIP");
     break;
   case 2:
     this->m_Controls->m_TSMenu->setText("SUM");
     break;
   case 3:
     this->m_Controls->m_TSMenu->setText("WEIGH");
     break;
   }
 
   mitk::DataNode* n;
   n = this->m_MultiWidget->GetWidgetPlane1(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
   n = this->m_MultiWidget->GetWidgetPlane2(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
   n = this->m_MultiWidget->GetWidgetPlane3(); if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
 
   mitk::BaseRenderer::Pointer renderer =
     this->GetActiveStdMultiWidget()->GetRenderWindow1()->GetRenderer();
   if(renderer.IsNotNull())
   {
     renderer->SendUpdateSlice();
   }
   renderer = this->GetActiveStdMultiWidget()->GetRenderWindow2()->GetRenderer();
   if(renderer.IsNotNull())
   {
     renderer->SendUpdateSlice();
   }
   renderer = this->GetActiveStdMultiWidget()->GetRenderWindow3()->GetRenderer();
   if(renderer.IsNotNull())
   {
     renderer->SendUpdateSlice();
   }
   renderer->GetRenderingManager()->RequestUpdateAll();
 }
 
 void QmitkControlVisualizationPropertiesView::OnTSNumChanged(int num)
 {
   if(num==0)
   {
     mitk::DataNode* n;
     n = this->m_MultiWidget->GetWidgetPlane1();
     if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) );
     if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
     if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( false ) );
 
     n = this->m_MultiWidget->GetWidgetPlane2();
     if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) );
     if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
     if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( false ) );
 
     n = this->m_MultiWidget->GetWidgetPlane3();
     if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) );
     if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
     if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( false ) );
   }
   else
   {
     mitk::DataNode* n;
     n = this->m_MultiWidget->GetWidgetPlane1();
     if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
     if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
     if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( (num>0) ) );
 
     n = this->m_MultiWidget->GetWidgetPlane2();
     if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
     if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
     if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( (num>0) ) );
 
     n = this->m_MultiWidget->GetWidgetPlane3();
     if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
     if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
     if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( (num>0) ) );
   }
 
   m_TSLabel->setText(QString::number(num*2+1));
 
   mitk::BaseRenderer::Pointer renderer = this->GetActiveStdMultiWidget()->GetRenderWindow1()->GetRenderer();
   if(renderer.IsNotNull())
     renderer->SendUpdateSlice();
 
   renderer = this->GetActiveStdMultiWidget()->GetRenderWindow2()->GetRenderer();
   if(renderer.IsNotNull())
     renderer->SendUpdateSlice();
 
   renderer = this->GetActiveStdMultiWidget()->GetRenderWindow3()->GetRenderer();
   if(renderer.IsNotNull())
     renderer->SendUpdateSlice();
 
   renderer->GetRenderingManager()->RequestUpdateAll(mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS);
 }
 
 void QmitkControlVisualizationPropertiesView::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkControlVisualizationPropertiesViewControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
 
     // hide warning (ODFs in rotated planes)
     m_Controls->m_lblRotatedPlanesWarning->hide();
 
     m_MyMenu = new QMenu(parent);
 
     // button for changing rotation mode
     m_Controls->m_TSMenu->setMenu( m_MyMenu );
     //m_CrosshairModeButton->setIcon( QIcon( iconCrosshairMode_xpm ) );
 
     m_Controls->params_frame->setVisible(false);
 
     QIcon icon5(":/QmitkDiffusionImaging/Refresh_48.png");
     m_Controls->m_Reinit->setIcon(icon5);
     m_Controls->m_Focus->setIcon(icon5);
 
     QIcon iconColor(":/QmitkDiffusionImaging/color24.gif");
     m_Controls->m_PFColor->setIcon(iconColor);
     m_Controls->m_Color->setIcon(iconColor);
 
     QIcon iconReset(":/QmitkDiffusionImaging/reset.png");
     m_Controls->m_ResetColoring->setIcon(iconReset);
 
     m_Controls->m_PFColor->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
 
     QIcon iconCrosshair(":/QmitkDiffusionImaging/crosshair.png");
     m_Controls->m_Crosshair->setIcon(iconCrosshair);
     // was is los
     QIcon iconPaint(":/QmitkDiffusionImaging/paint2.png");
     m_Controls->m_TDI->setIcon(iconPaint);
 
     QIcon iconFiberFade(":/QmitkDiffusionImaging/MapperEfx2D.png");
     m_Controls->m_FiberFading2D->setIcon(iconFiberFade);
 
     m_Controls->m_TextureIntON->setCheckable(true);
 
 #ifndef DIFFUSION_IMAGING_EXTENDED
     int size = m_Controls->m_AdditionalScaling->count();
     for(int t=0; t<size; t++)
     {
       if(m_Controls->m_AdditionalScaling->itemText(t).toStdString() == "Scale by ASR")
       {
           m_Controls->m_AdditionalScaling->removeItem(t);
       }
     }
 #endif
 
     m_Controls->m_OpacitySlider->setRange(0.0,1.0);
     m_Controls->m_OpacitySlider->setMinimumValue(0.0);
     m_Controls->m_OpacitySlider->setMaximumValue(0.0);
 
     m_Controls->m_ScalingFrame->setVisible(false);
     m_Controls->m_NormalizationFrame->setVisible(false);
   }
 
   m_IsInitialized = false;
   m_SelListener = berry::ISelectionListener::Pointer(new CvpSelListener(this));
   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddPostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
   berry::ISelection::ConstPointer sel(
     this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
   m_CurrentSelection = sel.Cast<const IStructuredSelection>();
   m_SelListener.Cast<CvpSelListener>()->DoSelectionChanged(sel);
   m_IsInitialized = true;
 }
 
 void QmitkControlVisualizationPropertiesView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
   m_MultiWidget = &stdMultiWidget;
 
   if (m_MultiWidget)
   {
     mitk::SlicesCoordinator* coordinator = m_MultiWidget->GetSlicesRotator();
     if (coordinator)
     {
       itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::Pointer command2 = itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::New();
       command2->SetCallbackFunction( this, &QmitkControlVisualizationPropertiesView::SliceRotation );
       m_SlicesRotationObserverTag1 = coordinator->AddObserver( mitk::SliceRotationEvent(), command2 );
     }
 
     coordinator = m_MultiWidget->GetSlicesSwiveller();
     if (coordinator)
     {
       itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::Pointer command2 = itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::New();
       command2->SetCallbackFunction( this, &QmitkControlVisualizationPropertiesView::SliceRotation );
       m_SlicesRotationObserverTag2 = coordinator->AddObserver( mitk::SliceRotationEvent(), command2 );
     }
   }
 }
 
 void QmitkControlVisualizationPropertiesView::SliceRotation(const itk::EventObject&)
 {
   // test if plane rotated
   if( m_GlyIsOn_T || m_GlyIsOn_C || m_GlyIsOn_S )
   {
     if( this->IsPlaneRotated() )
     {
       // show label
       m_Controls->m_lblRotatedPlanesWarning->show();
     }
     else
     {
       //hide label
       m_Controls->m_lblRotatedPlanesWarning->hide();
     }
   }
 }
 
 
 void QmitkControlVisualizationPropertiesView::StdMultiWidgetNotAvailable()
 {
   m_MultiWidget = NULL;
 }
 
 void QmitkControlVisualizationPropertiesView::NodeRemoved(const mitk::DataNode* node)
 {
 }
 
 #include <mitkMessage.h>
 void QmitkControlVisualizationPropertiesView::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_DisplayIndex), SIGNAL(valueChanged(int)), this, SLOT(DisplayIndexChanged(int)) );
     connect( (QObject*)(m_Controls->m_DisplayIndexSpinBox), SIGNAL(valueChanged(int)), this, SLOT(DisplayIndexChanged(int)) );
     connect( (QObject*)(m_Controls->m_TextureIntON), SIGNAL(clicked()), this, SLOT(TextIntON()) );
     connect( (QObject*)(m_Controls->m_Reinit), SIGNAL(clicked()), this, SLOT(Reinit()) );
     connect( (QObject*)(m_Controls->m_VisibleOdfsON_T), SIGNAL(clicked()), this, SLOT(VisibleOdfsON_T()) );
     connect( (QObject*)(m_Controls->m_VisibleOdfsON_S), SIGNAL(clicked()), this, SLOT(VisibleOdfsON_S()) );
     connect( (QObject*)(m_Controls->m_VisibleOdfsON_C), SIGNAL(clicked()), this, SLOT(VisibleOdfsON_C()) );
     connect( (QObject*)(m_Controls->m_ShowMaxNumber), SIGNAL(editingFinished()), this, SLOT(ShowMaxNumberChanged()) );
     connect( (QObject*)(m_Controls->m_NormalizationDropdown), SIGNAL(currentIndexChanged(int)), this, SLOT(NormalizationDropdownChanged(int)) );
     connect( (QObject*)(m_Controls->m_ScalingFactor), SIGNAL(valueChanged(double)), this, SLOT(ScalingFactorChanged(double)) );
     connect( (QObject*)(m_Controls->m_AdditionalScaling), SIGNAL(currentIndexChanged(int)), this, SLOT(AdditionalScaling(int)) );
     connect( (QObject*)(m_Controls->m_IndexParam1), SIGNAL(valueChanged(double)), this, SLOT(IndexParam1Changed(double)) );
     connect( (QObject*)(m_Controls->m_IndexParam2), SIGNAL(valueChanged(double)), this, SLOT(IndexParam2Changed(double)) );
     connect( (QObject*)(m_Controls->m_ScalingCheckbox), SIGNAL(clicked()), this, SLOT(ScalingCheckbox()) );
     connect( (QObject*)(m_Controls->m_OpacitySlider), SIGNAL(spanChanged(double,double)), this, SLOT(OpacityChanged(double,double)) );
     connect((QObject*) m_Controls->m_Color, SIGNAL(clicked()), (QObject*) this, SLOT(BundleRepresentationColor()));
     connect((QObject*) m_Controls->m_ResetColoring, SIGNAL(clicked()), (QObject*) this, SLOT(BundleRepresentationResetColoring()));
     connect((QObject*) m_Controls->m_Focus, SIGNAL(clicked()), (QObject*) this, SLOT(PlanarFigureFocus()));
     connect((QObject*) m_Controls->m_FiberFading2D, SIGNAL(clicked()), (QObject*) this, SLOT( Fiber2DfadingEFX() ) );
     connect((QObject*) m_Controls->m_FiberThicknessSlider, SIGNAL(sliderReleased()), (QObject*) this, SLOT( FiberSlicingThickness2D() ) );
     connect((QObject*) m_Controls->m_FiberThicknessSlider, SIGNAL(valueChanged(int)), (QObject*) this, SLOT( FiberSlicingUpdateLabel(int) ));
     connect((QObject*) m_Controls->m_Crosshair, SIGNAL(clicked()), (QObject*) this, SLOT(SetInteractor()));
     connect((QObject*) m_Controls->m_PFWidth, SIGNAL(valueChanged(int)), (QObject*) this, SLOT(PFWidth(int)));
     connect((QObject*) m_Controls->m_PFColor, SIGNAL(clicked()), (QObject*) this, SLOT(PFColor()));
     connect((QObject*) m_Controls->m_TDI, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateTdi()));
     connect((QObject*) m_Controls->m_LineWidth, SIGNAL(editingFinished()), (QObject*) this, SLOT(LineWidthChanged()));
   }
 }
 
 void QmitkControlVisualizationPropertiesView::Activated()
 {
   berry::ISelection::ConstPointer sel(
     this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
   m_CurrentSelection = sel.Cast<const IStructuredSelection>();
   m_SelListener.Cast<CvpSelListener>()->DoSelectionChanged(sel);
   QmitkFunctionality::Activated();
 }
 
 void QmitkControlVisualizationPropertiesView::Deactivated()
 {
   QmitkFunctionality::Deactivated();
 }
 
 int QmitkControlVisualizationPropertiesView::GetSizeFlags(bool width)
 {
   if(!width)
   {
     return berry::Constants::MIN | berry::Constants::MAX | berry::Constants::FILL;
   }
   else
   {
     return 0;
   }
 }
 
 int QmitkControlVisualizationPropertiesView::ComputePreferredSize(bool width, int /*availableParallel*/, int /*availablePerpendicular*/, int preferredResult)
 {
   if(width==false)
   {
     return m_FoundSingleOdfImage ? 120 : 80;
   }
   else
   {
     return preferredResult;
   }
 }
 
 // set diffusion image channel to b0 volume
 void QmitkControlVisualizationPropertiesView::NodeAdded(const mitk::DataNode *node)
 {
   mitk::DataNode* notConst = const_cast<mitk::DataNode*>(node);
-  if (dynamic_cast<mitk::DiffusionImage<short>*>(notConst->GetData()))
+
+  bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData())) );
+
+  if (isDiffusionImage)
   {
-    mitk::DiffusionImage<short>::Pointer dimg = dynamic_cast<mitk::DiffusionImage<short>*>(notConst->GetData());
+    mitk::Image::Pointer dimg = dynamic_cast<mitk::Image*>(notConst->GetData());
 
     // if there is no b0 image in the dataset, the GetB0Indices() returns a vector of size 0
     // and hence we cannot set the Property directly to .front()
     int displayChannelPropertyValue = 0;
-    mitk::DiffusionImage<short>::BValueMap map = dimg->GetBValueMap();
+    mitk::BValueMapProperty* bmapproperty = static_cast<mitk::BValueMapProperty*>(dimg->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() );
+    mitk::DiffusionPropertyHelper::BValueMapType map = bmapproperty->GetBValueMap();
     if( map[0].size() > 0)
       displayChannelPropertyValue = map[0].front();
 
     notConst->SetIntProperty("DisplayChannel", displayChannelPropertyValue );
   }
 }
 
 /* OnSelectionChanged is registered to SelectionService, therefore no need to
 implement SelectionService Listener explicitly */
 void QmitkControlVisualizationPropertiesView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
 
   // deactivate channel slider if no diffusion weighted image or tbss image is selected
   m_Controls->m_DisplayIndex->setVisible(false);
   m_Controls->m_DisplayIndexSpinBox->setVisible(false);
   m_Controls->label_channel->setVisible(false);
 
   for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
   {
     mitk::DataNode::Pointer node = *it;
 
     // check if node has data,
     // if some helper nodes are shown in the DataManager, the GetData() returns 0x0 which would lead to SIGSEV
     mitk::BaseData* nodeData = node->GetData();
     if(nodeData == NULL)
       continue;
 
+    bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData())) );
+
+
     if (node.IsNotNull() && (dynamic_cast<mitk::TbssImage*>(nodeData) ||
-      dynamic_cast<mitk::DiffusionImage<short>*>(nodeData)))
+      isDiffusionImage))
     {
       m_Controls->m_DisplayIndex->setVisible(true);
       m_Controls->m_DisplayIndexSpinBox->setVisible(true);
       m_Controls->label_channel->setVisible(true);
     }
     else if (node.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(node->GetData()))
     {
       if (m_Color.IsNotNull())
         m_Color->RemoveObserver(m_FiberBundleObserverTag);
 
       itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::Pointer command = itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::New();
       command->SetCallbackFunction( this, &QmitkControlVisualizationPropertiesView::SetFiberBundleCustomColor );
       m_Color = dynamic_cast<mitk::ColorProperty*>(node->GetProperty("color", NULL));
       if (m_Color.IsNotNull())
         m_FiberBundleObserverTag = m_Color->AddObserver( itk::ModifiedEvent(), command );
     }
   }
 
   for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
   {
     mitk::DataNode::Pointer node = *it;
 
     // check if node has data,
     // if some helper nodes are shown in the DataManager, the GetData() returns 0x0 which would lead to SIGSEV
     mitk::BaseData* nodeData = node->GetData();
     if(nodeData == NULL)
       continue;
 
     if( node.IsNotNull() && (dynamic_cast<mitk::QBallImage*>(nodeData) || dynamic_cast<mitk::TensorImage*>(nodeData)) )
     {
       if(m_NodeUsedForOdfVisualization.IsNotNull())
       {
         m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_S", false);
         m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_C", false);
         m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_T", false);
       }
       m_NodeUsedForOdfVisualization = node;
       m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_S", m_GlyIsOn_S);
       m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_C", m_GlyIsOn_C);
       m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_T", m_GlyIsOn_T);
       if(m_MultiWidget)
         m_MultiWidget->RequestUpdate();
 
       m_Controls->m_TSMenu->setVisible(false);  // deactivate mip etc. for tensor and q-ball images
       break;
     }
     else if( node.IsNotNull() && dynamic_cast<mitk::ConnectomicsNetwork*>(nodeData) )
       m_Controls->m_TSMenu->setVisible(false);
     else
       m_Controls->m_TSMenu->setVisible(true);
   }
 
   // if selection changes, set the current selction member and call SellListener::DoSelectionChanged
   berry::ISelection::ConstPointer sel(
     this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
   m_CurrentSelection = sel.Cast<const IStructuredSelection>();
   m_SelListener.Cast<CvpSelListener>()->DoSelectionChanged(sel);
 
   // adapt thick slice controls
   // THICK SLICE SUPPORT
 
   if( nodes.size() < 1)
     return;
 
   mitk::DataNode::Pointer node = nodes.at(0);
 
   if( node.IsNull() )
     return;
 
   QMenu *myMenu = m_MyMenu;
   myMenu->clear();
 
   QActionGroup* thickSlicesActionGroup = new QActionGroup(myMenu);
   thickSlicesActionGroup->setExclusive(true);
 
   int currentTSMode = 0;
   {
     mitk::ResliceMethodProperty::Pointer m = dynamic_cast<mitk::ResliceMethodProperty*>(node->GetProperty( "reslice.thickslices" ));
     if( m.IsNotNull() )
       currentTSMode = m->GetValueAsId();
   }
 
   int maxTS = 30;
 
   for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
   {
     mitk::Image* image = dynamic_cast<mitk::Image*>((*it)->GetData());
     if (image)
     {
       int size = std::max(image->GetDimension(0), std::max(image->GetDimension(1), image->GetDimension(2)));
       if (size>maxTS)
         maxTS=size;
     }
   }
   maxTS /= 2;
 
   int currentNum = 0;
   {
     mitk::IntProperty::Pointer m = dynamic_cast<mitk::IntProperty*>(node->GetProperty( "reslice.thickslices.num" ));
     if( m.IsNotNull() )
     {
       currentNum = m->GetValue();
       if(currentNum < 0) currentNum = 0;
       if(currentNum > maxTS) currentNum = maxTS;
     }
   }
 
   if(currentTSMode==0)
     currentNum=0;
 
   QSlider *m_TSSlider = new QSlider(myMenu);
   m_TSSlider->setMinimum(0);
   m_TSSlider->setMaximum(maxTS-1);
   m_TSSlider->setValue(currentNum);
 
   m_TSSlider->setOrientation(Qt::Horizontal);
 
   connect( m_TSSlider, SIGNAL( valueChanged(int) ), this, SLOT( OnTSNumChanged(int) ) );
 
   QHBoxLayout* _TSLayout = new QHBoxLayout;
   _TSLayout->setContentsMargins(4,4,4,4);
   _TSLayout->addWidget(m_TSSlider);
   _TSLayout->addWidget(m_TSLabel=new QLabel(QString::number(currentNum*2+1),myMenu));
 
   QWidget* _TSWidget = new QWidget;
   _TSWidget->setLayout(_TSLayout);
 
   QActionGroup* thickSliceModeActionGroup = new QActionGroup(myMenu);
   thickSliceModeActionGroup->setExclusive(true);
 
   QWidgetAction *m_TSSliderAction = new QWidgetAction(myMenu);
   m_TSSliderAction->setDefaultWidget(_TSWidget);
   myMenu->addAction(m_TSSliderAction);
 
   QAction* mipThickSlicesAction = new QAction(myMenu);
   mipThickSlicesAction->setActionGroup(thickSliceModeActionGroup);
   mipThickSlicesAction->setText("MIP (max. intensity proj.)");
   mipThickSlicesAction->setCheckable(true);
   mipThickSlicesAction->setChecked(currentThickSlicesMode==1);
   mipThickSlicesAction->setData(1);
   myMenu->addAction( mipThickSlicesAction );
 
   QAction* sumThickSlicesAction = new QAction(myMenu);
   sumThickSlicesAction->setActionGroup(thickSliceModeActionGroup);
   sumThickSlicesAction->setText("SUM (sum intensity proj.)");
   sumThickSlicesAction->setCheckable(true);
   sumThickSlicesAction->setChecked(currentThickSlicesMode==2);
   sumThickSlicesAction->setData(2);
   myMenu->addAction( sumThickSlicesAction );
 
   QAction* weightedThickSlicesAction = new QAction(myMenu);
   weightedThickSlicesAction->setActionGroup(thickSliceModeActionGroup);
   weightedThickSlicesAction->setText("WEIGHTED (gaussian proj.)");
   weightedThickSlicesAction->setCheckable(true);
   weightedThickSlicesAction->setChecked(currentThickSlicesMode==3);
   weightedThickSlicesAction->setData(3);
   myMenu->addAction( weightedThickSlicesAction );
 
   connect( thickSliceModeActionGroup, SIGNAL(triggered(QAction*)), this, SLOT(OnThickSlicesModeSelected(QAction*)) );
 
 }
 
 mitk::DataStorage::SetOfObjects::Pointer
   QmitkControlVisualizationPropertiesView::ActiveSet(std::string classname)
 {
   if (m_CurrentSelection)
   {
     mitk::DataStorage::SetOfObjects::Pointer set =
       mitk::DataStorage::SetOfObjects::New();
 
     int at = 0;
     for (IStructuredSelection::iterator i = m_CurrentSelection->Begin();
       i != m_CurrentSelection->End();
       ++i)
     {
 
       if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
       {
         mitk::DataNode::Pointer node = nodeObj->GetDataNode();
 
         // check if node has data,
         // if some helper nodes are shown in the DataManager, the GetData() returns 0x0 which would lead to SIGSEV
         const mitk::BaseData* nodeData = node->GetData();
         if(nodeData == NULL)
           continue;
 
         if(QString(classname.c_str()).compare(nodeData->GetNameOfClass())==0)
         {
           set->InsertElement(at++, node);
         }
       }
     }
 
     return set;
   }
 
   return 0;
 }
 
 void QmitkControlVisualizationPropertiesView::SetBoolProp(
   mitk::DataStorage::SetOfObjects::Pointer set,
   std::string name, bool value)
 {
   if(set.IsNotNull())
   {
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetBoolProperty(name.c_str(), value);
       ++itemiter;
     }
   }
 }
 
 void QmitkControlVisualizationPropertiesView::SetIntProp(
   mitk::DataStorage::SetOfObjects::Pointer set,
   std::string name, int value)
 {
   if(set.IsNotNull())
   {
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetIntProperty(name.c_str(), value);
       ++itemiter;
     }
   }
 }
 
 void QmitkControlVisualizationPropertiesView::SetFloatProp(
   mitk::DataStorage::SetOfObjects::Pointer set,
   std::string name, float value)
 {
   if(set.IsNotNull())
   {
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetFloatProperty(name.c_str(), value);
       ++itemiter;
     }
   }
 }
 
 void QmitkControlVisualizationPropertiesView::SetLevelWindowProp(
   mitk::DataStorage::SetOfObjects::Pointer set,
   std::string name, mitk::LevelWindow value)
 {
   if(set.IsNotNull())
   {
 
     mitk::LevelWindowProperty::Pointer prop = mitk::LevelWindowProperty::New(value);
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetProperty(name.c_str(), prop);
       ++itemiter;
     }
   }
 }
 
 void QmitkControlVisualizationPropertiesView::SetEnumProp(
   mitk::DataStorage::SetOfObjects::Pointer set,
   std::string name, mitk::EnumerationProperty::Pointer value)
 {
   if(set.IsNotNull())
   {
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetProperty(name.c_str(), value);
       ++itemiter;
     }
   }
 }
 
 
 
 void QmitkControlVisualizationPropertiesView::DisplayIndexChanged(int dispIndex)
 {
 
   m_Controls->m_DisplayIndex->setValue(dispIndex);
   m_Controls->m_DisplayIndexSpinBox->setValue(dispIndex);
 
   QString label = "Channel %1";
   label = label.arg(dispIndex);
   m_Controls->label_channel->setText(label);
 
   std::vector<std::string> sets;
-  sets.push_back("DiffusionImage");
   sets.push_back("TbssImage");
 
   std::vector<std::string>::iterator it = sets.begin();
   while(it != sets.end())
   {
     std::string s = *it;
     mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet(s);
 
     if(set.IsNotNull())
     {
 
       mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
       mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
       while ( itemiter != itemiterend )
       {
         (*itemiter)->SetIntProperty("DisplayChannel", dispIndex);
         ++itemiter;
       }
 
       //m_MultiWidget->RequestUpdate();
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 
     it++;
   }
 
 
 }
 
 void QmitkControlVisualizationPropertiesView::Reinit()
 {
   if (m_CurrentSelection)
   {
     mitk::DataNodeObject::Pointer nodeObj =
       m_CurrentSelection->Begin()->Cast<mitk::DataNodeObject>();
     mitk::DataNode::Pointer node = nodeObj->GetDataNode();
     mitk::BaseData::Pointer basedata = node->GetData();
     if (basedata.IsNotNull())
     {
       mitk::RenderingManager::GetInstance()->InitializeViews(
         basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
   }
 }
 
 void QmitkControlVisualizationPropertiesView::TextIntON()
 {
   if(m_TexIsOn)
   {
     m_Controls->m_TextureIntON->setIcon(*m_IconTexOFF);
   }
   else
   {
     m_Controls->m_TextureIntON->setIcon(*m_IconTexON);
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
     ActiveSet("DiffusionImage");
   SetBoolProp(set,"texture interpolation", !m_TexIsOn);
 
   set = ActiveSet("TensorImage");
   SetBoolProp(set,"texture interpolation", !m_TexIsOn);
 
   set = ActiveSet("QBallImage");
   SetBoolProp(set,"texture interpolation", !m_TexIsOn);
 
   set = ActiveSet("Image");
   SetBoolProp(set,"texture interpolation", !m_TexIsOn);
 
   m_TexIsOn = !m_TexIsOn;
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkControlVisualizationPropertiesView::VisibleOdfsON_S()
 {
   m_GlyIsOn_S = m_Controls->m_VisibleOdfsON_S->isChecked();
   if (m_NodeUsedForOdfVisualization.IsNull())
   {
     MITK_WARN << "ODF visualization activated but m_NodeUsedForOdfVisualization is NULL";
     return;
   }
   m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_S", m_GlyIsOn_S);
   VisibleOdfsON(0);
 }
 
 void QmitkControlVisualizationPropertiesView::VisibleOdfsON_T()
 {
   m_GlyIsOn_T = m_Controls->m_VisibleOdfsON_T->isChecked();
   if (m_NodeUsedForOdfVisualization.IsNull())
   {
     MITK_WARN << "ODF visualization activated but m_NodeUsedForOdfVisualization is NULL";
     return;
   }
   m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_T", m_GlyIsOn_T);
   VisibleOdfsON(1);
 }
 
 void QmitkControlVisualizationPropertiesView::VisibleOdfsON_C()
 {
   m_GlyIsOn_C = m_Controls->m_VisibleOdfsON_C->isChecked();
   if (m_NodeUsedForOdfVisualization.IsNull())
   {
     MITK_WARN << "ODF visualization activated but m_NodeUsedForOdfVisualization is NULL";
     return;
   }
   m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_C", m_GlyIsOn_C);
   VisibleOdfsON(2);
 }
 
 bool QmitkControlVisualizationPropertiesView::IsPlaneRotated()
 {
 
   // for all 2D renderwindows of m_MultiWidget check alignment
   mitk::PlaneGeometry::ConstPointer displayPlane = dynamic_cast<const mitk::PlaneGeometry*>( m_MultiWidget->GetRenderWindow1()->GetRenderer()->GetCurrentWorldGeometry2D() );
   if (displayPlane.IsNull()) return false;
 
   mitk::Image* currentImage = dynamic_cast<mitk::Image* >( m_NodeUsedForOdfVisualization->GetData() );
   if( currentImage == NULL )
   {
     MITK_ERROR << " Casting problems. Returning false";
     return false;
   }
 
   int affectedDimension(-1);
   int affectedSlice(-1);
   return !(DetermineAffectedImageSlice( currentImage, displayPlane, affectedDimension, affectedSlice ));
 
 }
 
 void QmitkControlVisualizationPropertiesView::VisibleOdfsON(int view)
 {
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkControlVisualizationPropertiesView::ShowMaxNumberChanged()
 {
   int maxNr = m_Controls->m_ShowMaxNumber->value();
   if ( maxNr < 1 )
   {
     m_Controls->m_ShowMaxNumber->setValue( 1 );
     maxNr = 1;
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
     ActiveSet("QBallImage");
   SetIntProp(set,"ShowMaxNumber", maxNr);
 
   set = ActiveSet("TensorImage");
   SetIntProp(set,"ShowMaxNumber", maxNr);
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkControlVisualizationPropertiesView::NormalizationDropdownChanged(int normDropdown)
 {
   typedef mitk::OdfNormalizationMethodProperty PropType;
   PropType::Pointer normMeth = PropType::New();
 
   switch(normDropdown)
   {
   case 0:
     normMeth->SetNormalizationToMinMax();
     break;
   case 1:
     normMeth->SetNormalizationToMax();
     break;
   case 2:
     normMeth->SetNormalizationToNone();
     break;
   case 3:
     normMeth->SetNormalizationToGlobalMax();
     break;
   default:
     normMeth->SetNormalizationToMinMax();
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
     ActiveSet("QBallImage");
   SetEnumProp(set,"Normalization", normMeth.GetPointer());
 
   set = ActiveSet("TensorImage");
   SetEnumProp(set,"Normalization", normMeth.GetPointer());
 
   //  if(m_MultiWidget)
   //    m_MultiWidget->RequestUpdate();
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkControlVisualizationPropertiesView::ScalingFactorChanged(double scalingFactor)
 {
 
   mitk::DataStorage::SetOfObjects::Pointer set =
     ActiveSet("QBallImage");
   SetFloatProp(set,"Scaling", scalingFactor);
 
   set = ActiveSet("TensorImage");
   SetFloatProp(set,"Scaling", scalingFactor);
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkControlVisualizationPropertiesView::AdditionalScaling(int additionalScaling)
 {
 
   typedef mitk::OdfScaleByProperty PropType;
   PropType::Pointer scaleBy = PropType::New();
 
   switch(additionalScaling)
   {
   case 0:
     scaleBy->SetScaleByNothing();
     break;
   case 1:
     scaleBy->SetScaleByGFA();
     //m_Controls->params_frame->setVisible(true);
     break;
 #ifdef DIFFUSION_IMAGING_EXTENDED
   case 2:
     scaleBy->SetScaleByPrincipalCurvature();
     // commented in for SPIE paper, Principle curvature scaling
     //m_Controls->params_frame->setVisible(true);
     break;
 #endif
   default:
     scaleBy->SetScaleByNothing();
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
     ActiveSet("QBallImage");
   SetEnumProp(set,"ScaleBy", scaleBy.GetPointer());
 
   set = ActiveSet("TensorImage");
   SetEnumProp(set,"ScaleBy", scaleBy.GetPointer());
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkControlVisualizationPropertiesView::IndexParam1Changed(double param1)
 {
   mitk::DataStorage::SetOfObjects::Pointer set =
     ActiveSet("QBallImage");
   SetFloatProp(set,"IndexParam1", param1);
 
   set = ActiveSet("TensorImage");
   SetFloatProp(set,"IndexParam1", param1);
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 }
 
 void QmitkControlVisualizationPropertiesView::IndexParam2Changed(double param2)
 {
   mitk::DataStorage::SetOfObjects::Pointer set =
     ActiveSet("QBallImage");
   SetFloatProp(set,"IndexParam2", param2);
 
   set = ActiveSet("TensorImage");
   SetFloatProp(set,"IndexParam2", param2);
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 }
 
 void QmitkControlVisualizationPropertiesView::OpacityChanged(double l, double u)
 {
   mitk::LevelWindow olw;
   olw.SetRangeMinMax(l*255, u*255);
 
   mitk::DataStorage::SetOfObjects::Pointer set =
     ActiveSet("QBallImage");
   SetLevelWindowProp(set,"opaclevelwindow", olw);
 
   set = ActiveSet("TensorImage");
   SetLevelWindowProp(set,"opaclevelwindow", olw);
 
   set = ActiveSet("Image");
   SetLevelWindowProp(set,"opaclevelwindow", olw);
 
   m_Controls->m_OpacityMinFaLabel->setText(QString::number(l,'f',2) + " : " + QString::number(u,'f',2));
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkControlVisualizationPropertiesView::ScalingCheckbox()
 {
   m_Controls->m_ScalingFrame->setVisible(
     m_Controls->m_ScalingCheckbox->isChecked());
 
   if(!m_Controls->m_ScalingCheckbox->isChecked())
   {
     m_Controls->m_AdditionalScaling->setCurrentIndex(0);
     m_Controls->m_ScalingFactor->setValue(1.0);
   }
 }
 
 void QmitkControlVisualizationPropertiesView::Fiber2DfadingEFX()
 {
   if (m_SelectedNode && dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData()) )
   {
     bool currentMode;
     m_SelectedNode->GetBoolProperty("Fiber2DfadeEFX", currentMode);
     m_SelectedNode->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(!currentMode));
     dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData())->RequestUpdate2D();
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
   }
 
 }
 
 void QmitkControlVisualizationPropertiesView::FiberSlicingThickness2D()
 {
   if (m_SelectedNode && dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData()))
   {
     float fibThickness = m_Controls->m_FiberThicknessSlider->value() * 0.1;
     float currentThickness = 0;
     m_SelectedNode->GetFloatProperty("Fiber2DSliceThickness", currentThickness);
     if (fabs(fibThickness-currentThickness)<0.001)
       return;
     m_SelectedNode->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(fibThickness));
     dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData())->RequestUpdate2D();
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
   }
 }
 
 void QmitkControlVisualizationPropertiesView::FiberSlicingUpdateLabel(int value)
 {
   QString label = "Range %1 mm";
   label = label.arg(value * 0.1);
   m_Controls->label_range->setText(label);
   this->FiberSlicingThickness2D();
 }
 
 void QmitkControlVisualizationPropertiesView::SetFiberBundleCustomColor(const itk::EventObject& /*e*/)
 {
   float color[3];
   m_SelectedNode->GetColor(color);
   m_Controls->m_Color->setAutoFillBackground(true);
   QString styleSheet = "background-color:rgb(";
   styleSheet.append(QString::number(color[0]*255.0));
   styleSheet.append(",");
   styleSheet.append(QString::number(color[1]*255.0));
   styleSheet.append(",");
   styleSheet.append(QString::number(color[2]*255.0));
   styleSheet.append(")");
   m_Controls->m_Color->setStyleSheet(styleSheet);
 
   m_SelectedNode->SetProperty("color",mitk::ColorProperty::New(color[0], color[1], color[2]));
   mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData());
   fib->SetColorCoding(mitk::FiberBundleX::COLORCODING_CUSTOM);
   mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
 }
 
 void QmitkControlVisualizationPropertiesView::BundleRepresentationColor()
 {
   if(m_SelectedNode)
   {
     QColor color = QColorDialog::getColor();
     if (!color.isValid())
       return;
 
     m_Controls->m_Color->setAutoFillBackground(true);
     QString styleSheet = "background-color:rgb(";
     styleSheet.append(QString::number(color.red()));
     styleSheet.append(",");
     styleSheet.append(QString::number(color.green()));
     styleSheet.append(",");
     styleSheet.append(QString::number(color.blue()));
     styleSheet.append(")");
     m_Controls->m_Color->setStyleSheet(styleSheet);
 
     m_SelectedNode->SetProperty("color",mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
     mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData());
     fib->SetColorCoding(mitk::FiberBundleX::COLORCODING_CUSTOM);
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
   }
 }
 
 void QmitkControlVisualizationPropertiesView::BundleRepresentationResetColoring()
 {
   if(m_SelectedNode)
   {
     MITK_INFO << "reset colorcoding to oBased";
     m_Controls->m_Color->setAutoFillBackground(true);
     QString styleSheet = "background-color:rgb(255,255,255)";
     m_Controls->m_Color->setStyleSheet(styleSheet);
     //    m_SelectedNode->SetProperty("color",NULL);
     m_SelectedNode->SetProperty("color",mitk::ColorProperty::New(1.0, 1.0, 1.0));
 
     mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData());
     fib->SetColorCoding(mitk::FiberBundleX::COLORCODING_ORIENTATION_BASED);
     fib->DoColorCodingOrientationBased();
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
   }
 }
 
 void QmitkControlVisualizationPropertiesView::PlanarFigureFocus()
 {
   if(m_SelectedNode)
   {
     mitk::PlanarFigure* _PlanarFigure = 0;
     _PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (m_SelectedNode->GetData());
 
     if (_PlanarFigure && _PlanarFigure->GetPlaneGeometry())
     {
 
       QmitkRenderWindow* selectedRenderWindow = 0;
       bool PlanarFigureInitializedWindow = false;
 
       QmitkRenderWindow* RenderWindow1 =
         this->GetActiveStdMultiWidget()->GetRenderWindow1();
 
       if (m_SelectedNode->GetBoolProperty("PlanarFigureInitializedWindow",
         PlanarFigureInitializedWindow, RenderWindow1->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow1;
       }
 
       QmitkRenderWindow* RenderWindow2 =
         this->GetActiveStdMultiWidget()->GetRenderWindow2();
 
       if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
         "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
         RenderWindow2->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow2;
       }
 
       QmitkRenderWindow* RenderWindow3 =
         this->GetActiveStdMultiWidget()->GetRenderWindow3();
 
       if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
         "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
         RenderWindow3->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow3;
       }
 
       QmitkRenderWindow* RenderWindow4 =
         this->GetActiveStdMultiWidget()->GetRenderWindow4();
 
       if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
         "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
         RenderWindow4->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow4;
       }
 
       const mitk::PlaneGeometry* _PlaneGeometry = _PlanarFigure->GetPlaneGeometry();
 
       mitk::VnlVector normal = _PlaneGeometry->GetNormalVnl();
 
       mitk::Geometry2D::ConstPointer worldGeometry1 =
         RenderWindow1->GetRenderer()->GetCurrentWorldGeometry2D();
       mitk::PlaneGeometry::ConstPointer _Plane1 =
         dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry1.GetPointer() );
       mitk::VnlVector normal1 = _Plane1->GetNormalVnl();
 
       mitk::Geometry2D::ConstPointer worldGeometry2 =
         RenderWindow2->GetRenderer()->GetCurrentWorldGeometry2D();
       mitk::PlaneGeometry::ConstPointer _Plane2 =
         dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry2.GetPointer() );
       mitk::VnlVector normal2 = _Plane2->GetNormalVnl();
 
       mitk::Geometry2D::ConstPointer worldGeometry3 =
         RenderWindow3->GetRenderer()->GetCurrentWorldGeometry2D();
       mitk::PlaneGeometry::ConstPointer _Plane3 =
         dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry3.GetPointer() );
       mitk::VnlVector normal3 = _Plane3->GetNormalVnl();
 
       normal[0]  = fabs(normal[0]);  normal[1]  = fabs(normal[1]);  normal[2]  = fabs(normal[2]);
       normal1[0] = fabs(normal1[0]); normal1[1] = fabs(normal1[1]); normal1[2] = fabs(normal1[2]);
       normal2[0] = fabs(normal2[0]); normal2[1] = fabs(normal2[1]); normal2[2] = fabs(normal2[2]);
       normal3[0] = fabs(normal3[0]); normal3[1] = fabs(normal3[1]); normal3[2] = fabs(normal3[2]);
 
       double ang1 = angle(normal, normal1);
       double ang2 = angle(normal, normal2);
       double ang3 = angle(normal, normal3);
 
       if(ang1 < ang2 && ang1 < ang3)
       {
         selectedRenderWindow = RenderWindow1;
       }
       else
       {
         if(ang2 < ang3)
         {
           selectedRenderWindow = RenderWindow2;
         }
         else
         {
           selectedRenderWindow = RenderWindow3;
         }
       }
 
       // make node visible
       if (selectedRenderWindow)
       {
         const mitk::Point3D& centerP = _PlaneGeometry->GetOrigin();
         selectedRenderWindow->GetSliceNavigationController()->ReorientSlices(
           centerP, _PlaneGeometry->GetNormal());
       }
     }
 
     // set interactor for new node (if not already set)
     mitk::PlanarFigureInteractor::Pointer figureInteractor
       = dynamic_cast<mitk::PlanarFigureInteractor*>(m_SelectedNode->GetDataInteractor().GetPointer());
 
     if(figureInteractor.IsNull())
     {
       figureInteractor = mitk::PlanarFigureInteractor::New();
       us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "MitkPlanarFigure" );
       figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
       figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
       figureInteractor->SetDataNode( m_SelectedNode );
     }
 
     m_SelectedNode->SetProperty("planarfigure.iseditable",mitk::BoolProperty::New(true));
   }
 }
 
 void QmitkControlVisualizationPropertiesView::SetInteractor()
 {
   typedef std::vector<mitk::DataNode*> Container;
   Container _NodeSet = this->GetDataManagerSelection();
   mitk::DataNode* node = 0;
   mitk::FiberBundleX* bundle = 0;
   mitk::FiberBundleInteractor::Pointer bundleInteractor = 0;
 
   // finally add all nodes to the model
   for(Container::const_iterator it=_NodeSet.begin(); it!=_NodeSet.end()
     ; it++)
   {
     node = const_cast<mitk::DataNode*>(*it);
     bundle = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
 
     if(bundle)
     {
       bundleInteractor = dynamic_cast<mitk::FiberBundleInteractor*>(node->GetInteractor());
 
       if(bundleInteractor.IsNotNull())
         mitk::GlobalInteraction::GetInstance()->RemoveInteractor(bundleInteractor);
 
       if(!m_Controls->m_Crosshair->isChecked())
       {
         m_Controls->m_Crosshair->setChecked(false);
         this->GetActiveStdMultiWidget()->GetRenderWindow4()->setCursor(Qt::ArrowCursor);
         m_CurrentPickingNode = 0;
       }
       else
       {
         m_Controls->m_Crosshair->setChecked(true);
         bundleInteractor = mitk::FiberBundleInteractor::New("FiberBundleInteractor", node);
         mitk::GlobalInteraction::GetInstance()->AddInteractor(bundleInteractor);
         this->GetActiveStdMultiWidget()->GetRenderWindow4()->setCursor(Qt::CrossCursor);
         m_CurrentPickingNode = node;
       }
 
     }
   }
 
 }
 
 void QmitkControlVisualizationPropertiesView::PFWidth(int w)
 {
 
   double width = w/10.0;
   m_SelectedNode->SetProperty("planarfigure.line.width", mitk::FloatProperty::New(width) );
   m_SelectedNode->SetProperty("planarfigure.shadow.widthmodifier", mitk::FloatProperty::New(width) );
   m_SelectedNode->SetProperty("planarfigure.outline.width", mitk::FloatProperty::New(width) );
   m_SelectedNode->SetProperty("planarfigure.helperline.width", mitk::FloatProperty::New(width) );
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   QString label = "Width %1";
   label = label.arg(width);
   m_Controls->label_pfwidth->setText(label);
 
 }
 
 void QmitkControlVisualizationPropertiesView::PFColor()
 {
 
   QColor color = QColorDialog::getColor();
   if (!color.isValid())
     return;
 
   m_Controls->m_PFColor->setAutoFillBackground(true);
   QString styleSheet = "background-color:rgb(";
   styleSheet.append(QString::number(color.red()));
   styleSheet.append(",");
   styleSheet.append(QString::number(color.green()));
   styleSheet.append(",");
   styleSheet.append(QString::number(color.blue()));
   styleSheet.append(")");
   m_Controls->m_PFColor->setStyleSheet(styleSheet);
 
   m_SelectedNode->SetProperty( "planarfigure.default.line.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
   m_SelectedNode->SetProperty( "planarfigure.default.outline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
   m_SelectedNode->SetProperty( "planarfigure.default.helperline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
   m_SelectedNode->SetProperty( "planarfigure.default.markerline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
   m_SelectedNode->SetProperty( "planarfigure.default.marker.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
 
   m_SelectedNode->SetProperty( "planarfigure.hover.line.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0)  );
   m_SelectedNode->SetProperty( "planarfigure.hover.outline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0)  );
   m_SelectedNode->SetProperty( "planarfigure.hover.helperline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0)  );
   m_SelectedNode->SetProperty( "color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkControlVisualizationPropertiesView::GenerateTdi()
 {
   if(m_SelectedNode)
   {
     mitk::FiberBundleX* bundle = dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData());
     if(!bundle)
       return;
 
     typedef float OutPixType;
     typedef itk::Image<OutPixType, 3> OutImageType;
 
     // run generator
     itk::TractDensityImageFilter< OutImageType >::Pointer generator = itk::TractDensityImageFilter< OutImageType >::New();
     generator->SetFiberBundle(bundle);
     generator->SetOutputAbsoluteValues(true);
     generator->SetUpsamplingFactor(1);
     generator->Update();
 
     // get result
     OutImageType::Pointer outImg = generator->GetOutput();
 
     mitk::Image::Pointer img = mitk::Image::New();
     img->InitializeByItk(outImg.GetPointer());
     img->SetVolume(outImg->GetBufferPointer());
 
     // to datastorage
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData(img);
     QString name(m_SelectedNode->GetName().c_str());
     name += "_TDI";
     node->SetName(name.toStdString());
     node->SetVisibility(true);
 
     GetDataStorage()->Add(node);
   }
 }
 
 void QmitkControlVisualizationPropertiesView::LineWidthChanged()
 {
   if(m_SelectedNode && dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData()))
   {
     int newWidth = m_Controls->m_LineWidth->value();
     int currentWidth = 0;
     m_SelectedNode->GetIntProperty("LineWidth", currentWidth);
     if (currentWidth==newWidth)
       return;
     m_SelectedNode->SetIntProperty("LineWidth", newWidth);
     dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData())->RequestUpdate2D();
     dynamic_cast<mitk::FiberBundleX*>(m_SelectedNode->GetData())->RequestUpdate3D();
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
   }
 }
 
 void QmitkControlVisualizationPropertiesView::Welcome()
 {
   berry::PlatformUI::GetWorkbench()->GetIntroManager()->ShowIntro(
     GetSite()->GetWorkbenchWindow(), false);
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDenoisingView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDenoisingView.cpp
index 6ccec586f7..77dee17b43 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDenoisingView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDenoisingView.cpp
@@ -1,508 +1,525 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkDenoisingView.h"
 #include <mitkImageCast.h>
 #include <mitkProgressBar.h>
+#include <mitkDiffusionPropertyHelper.h>
+#include <mitkITKImageImport.h>
 
 QmitkDenoisingWorker::QmitkDenoisingWorker(QmitkDenoisingView *view)
   : m_View(view)
 {
 }
 
 void QmitkDenoisingWorker::run()
 {
   if (m_View->m_ImageNode.IsNotNull())
   {
     switch (m_View->m_SelectedFilter)
     {
       case QmitkDenoisingView::NOFILTERSELECTED:
       case QmitkDenoisingView::GAUSS:
       {
         break;
       }
       case QmitkDenoisingView::NLM:
       {
         try
         {
           m_View->m_CompletedCalculation = true;
           m_View->m_NonLocalMeansFilter->Update();
         }
         catch (itk::ExceptionObject& e)
         {
           m_View->m_CompletedCalculation = false;
           MITK_ERROR << e.what();
         }
           break;
       }
     }
     m_View->m_DenoisingThread.quit();
   }
 }
 
 const std::string QmitkDenoisingView::VIEW_ID = "org.mitk.views.denoisingview";
 
 QmitkDenoisingView::QmitkDenoisingView()
   : QmitkFunctionality()
   , m_Controls( 0 )
   , m_ImageNode(NULL)
   , m_BrainMaskNode(NULL)
   , m_DenoisingWorker(this)
   , m_ThreadIsRunning(false)
   , m_NonLocalMeansFilter(NULL)
   , m_InputImage(NULL)
   , m_LastProgressCount(0)
   , m_MaxProgressCount(0)
   , m_SelectedFilter(NOFILTERSELECTED)
 {
   m_DenoisingWorker.moveToThread(&m_DenoisingThread);
   connect(&m_DenoisingThread, SIGNAL(started()), this, SLOT(BeforeThread()));
   connect(&m_DenoisingThread, SIGNAL(started()), &m_DenoisingWorker, SLOT(run()));
   connect(&m_DenoisingThread, SIGNAL(finished()), this, SLOT(AfterThread()));
   connect(&m_DenoisingThread, SIGNAL(terminated()), this, SLOT(AfterThread()));
   m_DenoisingTimer = new QTimer(this);
 }
 
 QmitkDenoisingView::~QmitkDenoisingView()
 {
   delete m_DenoisingTimer;
 }
 
 void QmitkDenoisingView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkDenoisingViewControls;
     m_Controls->setupUi( parent );
     CreateConnections();
     ResetParameterPanel();
   }
 }
 
 void QmitkDenoisingView::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_ApplyButton), SIGNAL(clicked()), this, SLOT(StartDenoising()));
     connect( (QObject*)(m_Controls->m_SelectFilterComboBox), SIGNAL(activated(int)), this, SLOT(SelectFilter(int)));
     connect( m_DenoisingTimer, SIGNAL(timeout()), this, SLOT(UpdateProgress()));
   }
 }
 
 void QmitkDenoisingView::Activated()
 {
   QmitkFunctionality::Activated();
 
   m_Controls->m_SelectFilterComboBox->clear();
   m_Controls->m_SelectFilterComboBox->insertItem(NOFILTERSELECTED, "Please select a filter");
   m_Controls->m_SelectFilterComboBox->insertItem(NLM, "Non-local means filter");
   m_Controls->m_SelectFilterComboBox->insertItem(GAUSS, "Discrete gaussian filter");
 }
 
 void QmitkDenoisingView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
   if (m_ThreadIsRunning)
     return;
 
   if (m_SelectedFilter != NOFILTERSELECTED)
   {
     m_Controls->m_InputImageLabel->setText("<font color='red'>mandatory</font>");
   }
   else
   {
     m_Controls->m_InputImageLabel->setText("mandatory");
   }
   m_Controls->m_InputBrainMaskLabel->setText("optional");
   m_Controls->m_ApplyButton->setEnabled(false);
 
   m_ImageNode = NULL;
   m_BrainMaskNode = NULL;
 
   // iterate selection
   for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
   {
     mitk::DataNode::Pointer node = *it;
 
-    if( node.IsNotNull() && dynamic_cast<DiffusionImageType*>(node->GetData()))
+    bool isDiffusionImage(false);
+    if(node.IsNotNull())
+    {
+      isDiffusionImage = mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData()));
+    }
+
+    if( node.IsNotNull() && isDiffusionImage)
     {
       m_Controls->m_InputImageLabel->setText(node->GetName().c_str());
       m_ImageNode = node;
     }
 
     bool isBinary = false;
     node->GetBoolProperty("binary", isBinary);
     // look for a brainmask in selection
     if( node.IsNotNull() && static_cast<mitk::Image*>(node->GetData()) && isBinary)
     {
         m_Controls->m_InputBrainMaskLabel->setText(node->GetName().c_str());
         m_BrainMaskNode = node;
     }
   }
 
   // Preparation of GUI to start denoising if a filter is selected
   if (m_ImageNode.IsNotNull() && m_SelectedFilter != NOFILTERSELECTED)
   {
     m_Controls->m_ApplyButton->setEnabled(true);
   }
 }
 
 void QmitkDenoisingView::StartDenoising()
 {
   if (!m_ThreadIsRunning)
   {
     if (m_ImageNode.IsNotNull())
     {
       m_LastProgressCount = 0;
       switch (m_SelectedFilter)
       {
         case NOFILTERSELECTED:
         {
           break;
         }
         case NLM:
         {
           // initialize NLM
-          m_InputImage = dynamic_cast<DiffusionImageType*> (m_ImageNode->GetData());
+          m_InputImage = dynamic_cast<mitk::Image*> (m_ImageNode->GetData());
           m_NonLocalMeansFilter = NonLocalMeansDenoisingFilterType::New();
 
           if (m_BrainMaskNode.IsNotNull())
           {
             // use brainmask if set
             m_ImageMask = dynamic_cast<mitk::Image*>(m_BrainMaskNode->GetData());
             itk::Image<DiffusionPixelType, 3>::Pointer itkMask;
             mitk::CastToItkImage(m_ImageMask, itkMask);
             m_NonLocalMeansFilter->SetInputMask(itkMask);
 
             itk::ImageRegionIterator< itk::Image<DiffusionPixelType, 3> > mit(itkMask, itkMask->GetLargestPossibleRegion());
             mit.GoToBegin();
             itk::Image<DiffusionPixelType, 3>::IndexType minIndex;
             itk::Image<DiffusionPixelType, 3>::IndexType maxIndex;
             minIndex.Fill(10000);
             maxIndex.Fill(0);
             while (!mit.IsAtEnd())
             {
               if (mit.Get())
               {
                 // calculation of the start & end index of the smallest masked region
                 minIndex[0] = minIndex[0] < mit.GetIndex()[0] ? minIndex[0] : mit.GetIndex()[0];
                 minIndex[1] = minIndex[1] < mit.GetIndex()[1] ? minIndex[1] : mit.GetIndex()[1];
                 minIndex[2] = minIndex[2] < mit.GetIndex()[2] ? minIndex[2] : mit.GetIndex()[2];
 
                 maxIndex[0] = maxIndex[0] > mit.GetIndex()[0] ? maxIndex[0] : mit.GetIndex()[0];
                 maxIndex[1] = maxIndex[1] > mit.GetIndex()[1] ? maxIndex[1] : mit.GetIndex()[1];
                 maxIndex[2] = maxIndex[2] > mit.GetIndex()[2] ? maxIndex[2] : mit.GetIndex()[2];
               }
               ++mit;
             }
             itk::Image<DiffusionPixelType, 3>::SizeType size;
             size[0] = maxIndex[0] - minIndex[0] + 1;
             size[1] = maxIndex[1] - minIndex[1] + 1;
             size[2] = maxIndex[2] - minIndex[2] + 1;
 
             m_MaxProgressCount = size[0] * size[1] * size[2];
           }
           else
           {
             // initialize the progressbar
             m_MaxProgressCount = m_InputImage->GetDimension(0) * m_InputImage->GetDimension(1) * m_InputImage->GetDimension(2);
           }
 
 
           mitk::ProgressBar::GetInstance()->AddStepsToDo(m_MaxProgressCount);
 
+          ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
+  mitk::CastToItkImage(m_InputImage, itkVectorImagePointer);
 
-          m_NonLocalMeansFilter->SetInputImage(m_InputImage->GetVectorImage());
+          m_NonLocalMeansFilter->SetInputImage( itkVectorImagePointer );
           m_NonLocalMeansFilter->SetUseRicianAdaption(m_Controls->m_RicianCheckbox->isChecked());
           m_NonLocalMeansFilter->SetUseJointInformation(m_Controls->m_JointInformationCheckbox->isChecked());
           m_NonLocalMeansFilter->SetSearchRadius(m_Controls->m_SpinBoxParameter1->value());
           m_NonLocalMeansFilter->SetComparisonRadius(m_Controls->m_SpinBoxParameter2->value());
           m_NonLocalMeansFilter->SetVariance(m_Controls->m_DoubleSpinBoxParameter3->value());
 
 
 
 
 
           // start denoising in detached thread
           m_DenoisingThread.start(QThread::HighestPriority);
 
           break;
         }
         case GAUSS:
         {
           // initialize GAUSS and run
-          m_InputImage = dynamic_cast<DiffusionImageType*> (m_ImageNode->GetData());
+          m_InputImage = dynamic_cast<mitk::Image*> (m_ImageNode->GetData());
+
+          ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
+          mitk::CastToItkImage(m_InputImage, itkVectorImagePointer);
 
           ExtractFilterType::Pointer extractor = ExtractFilterType::New();
-          extractor->SetInput(m_InputImage->GetVectorImage());
+          extractor->SetInput( itkVectorImagePointer );
           ComposeFilterType::Pointer composer = ComposeFilterType::New();
 
-          for (unsigned int i = 0; i < m_InputImage->GetVectorImage()->GetVectorLength(); ++i)
+          for (unsigned int i = 0; i < itkVectorImagePointer->GetVectorLength(); ++i)
           {
             extractor->SetIndex(i);
             extractor->Update();
 
             m_GaussianFilter = GaussianFilterType::New();
             m_GaussianFilter->SetVariance(m_Controls->m_SpinBoxParameter1->value());
 
             if (m_BrainMaskNode.IsNotNull())
             {
               m_ImageMask = dynamic_cast<mitk::Image*>(m_BrainMaskNode->GetData());
               itk::Image<DiffusionPixelType, 3>::Pointer itkMask = itk::Image<DiffusionPixelType, 3>::New();
               mitk::CastToItkImage(m_ImageMask, itkMask);
 
               itk::MaskImageFilter<itk::Image<DiffusionPixelType, 3> , itk::Image<DiffusionPixelType, 3> >::Pointer maskImageFilter = itk::MaskImageFilter<itk::Image<DiffusionPixelType, 3> , itk::Image<DiffusionPixelType, 3> >::New();
               maskImageFilter->SetInput(extractor->GetOutput());
               maskImageFilter->SetMaskImage(itkMask);
               maskImageFilter->Update();
               m_GaussianFilter->SetInput(maskImageFilter->GetOutput());
             }
             else
             {
               m_GaussianFilter->SetInput(extractor->GetOutput());
             }
             m_GaussianFilter->Update();
 
             composer->SetInput(i, m_GaussianFilter->GetOutput());
           }
           composer->Update();
 
 
-          DiffusionImageType::Pointer image = DiffusionImageType::New();
-          image->SetVectorImage(composer->GetOutput());
-          image->SetReferenceBValue(m_InputImage->GetReferenceBValue());
-          image->SetDirections(m_InputImage->GetDirections());
-          image->InitializeFromVectorImage();
+          mitk::Image::Pointer image = mitk::GrabItkImageMemory(composer->GetOutput());
+
+          image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( static_cast<mitk::GradientDirectionsProperty*>( m_InputImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() ) );
+          image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>(m_InputImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() ) );
+
+          mitk::DiffusionPropertyHelper propertyHelper( image );
+          propertyHelper.InitializeImage();
+
           mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
           imageNode->SetData( image );
           QString name = m_ImageNode->GetName().c_str();
 
           imageNode->SetName((name+"_gauss_"+QString::number(m_Controls->m_SpinBoxParameter1->value())).toStdString().c_str());
           GetDefaultDataStorage()->Add(imageNode);
 
           break;
         }
       }
     }
   }
 
   else
   {
     m_NonLocalMeansFilter->AbortGenerateDataOn();
     m_CompletedCalculation = false;
   }
 }
 
 void QmitkDenoisingView::ResetParameterPanel()
 {
   m_Controls->m_DwiLabel->setEnabled(false);
   m_Controls->m_InputImageLabel->setEnabled(false);
   m_Controls->m_BrainMaskLabel->setEnabled(false);
   m_Controls->m_InputBrainMaskLabel->setEnabled(false);
   m_Controls->m_ParameterBox->hide();
   m_Controls->m_LabelParameter_1->hide();
   m_Controls->m_LabelParameter_2->hide();
   m_Controls->m_LabelParameter_3->hide();
   m_Controls->m_SpinBoxParameter1->hide();
   m_Controls->m_SpinBoxParameter2->hide();
   m_Controls->m_DoubleSpinBoxParameter3->hide();
   m_Controls->m_RicianLabel->hide();
   m_Controls->m_RicianCheckbox->hide();
   m_Controls->m_JointInformationLabel->hide();
   m_Controls->m_JointInformationCheckbox->hide();
   m_Controls->m_ApplyButton->setEnabled(false);
 }
 
 void QmitkDenoisingView::SelectFilter(int filter)
 {
   if (m_ThreadIsRunning)
     return;
 
   //Prepare GUI
   this->ResetParameterPanel();
 
   switch (filter)
   {
     case 0:
     {
       m_SelectedFilter = NOFILTERSELECTED;
 
       break;
     }
 
     case 1:
     {
       m_SelectedFilter = NLM;
       m_Controls->m_DwiLabel->setEnabled(true);
       m_Controls->m_InputImageLabel->setEnabled(true);
       m_Controls->m_BrainMaskLabel->setEnabled(true);
       m_Controls->m_InputBrainMaskLabel->setEnabled(true);
       m_Controls->m_ParameterBox->show();
       m_Controls->m_LabelParameter_1->show();
       m_Controls->m_LabelParameter_1->setText("Search Radius:");
       m_Controls->m_LabelParameter_2->show();
       m_Controls->m_LabelParameter_2->setText("Comparision Radius:");
       m_Controls->m_LabelParameter_3->show();
       m_Controls->m_LabelParameter_3->setText("Noise variance:");
       m_Controls->m_SpinBoxParameter1->show();
       m_Controls->m_SpinBoxParameter1->setValue(4);
       m_Controls->m_SpinBoxParameter2->show();
       m_Controls->m_SpinBoxParameter2->setValue(1);
       m_Controls->m_DoubleSpinBoxParameter3->show();
       m_Controls->m_DoubleSpinBoxParameter3->setValue(1.0);
       m_Controls->m_RicianLabel->show();
       m_Controls->m_RicianCheckbox->show();
       m_Controls->m_RicianCheckbox->setChecked(true);
       m_Controls->m_JointInformationLabel->show();
       m_Controls->m_JointInformationCheckbox->show();
       m_Controls->m_JointInformationCheckbox->setChecked(false);
 
       break;
     }
 
     case 2:
     {
       m_SelectedFilter = GAUSS;
       m_Controls->m_DwiLabel->setEnabled(true);
       m_Controls->m_InputImageLabel->setEnabled(true);
       m_Controls->m_BrainMaskLabel->setEnabled(true);
       m_Controls->m_InputBrainMaskLabel->setEnabled(true);
       m_Controls->m_ParameterBox->show();
       m_Controls->m_LabelParameter_1->show();
       m_Controls->m_LabelParameter_1->setText("Variance:");
       m_Controls->m_SpinBoxParameter1->show();
       m_Controls->m_SpinBoxParameter1->setValue(2);
 
       break;
     }
   }
 
   if (m_ImageNode.IsNull())
   {
     if (m_SelectedFilter != NOFILTERSELECTED)
       m_Controls->m_InputImageLabel->setText("<font color='red'>mandatory</font>");
     else
       m_Controls->m_InputImageLabel->setText("mandatory");
   }
 
   if (m_ImageNode.IsNotNull())
   {
     m_Controls->m_ApplyButton->setEnabled(false);
     switch(filter)
     {
       case NOFILTERSELECTED:
       {
         break;
       }
       case NLM:
       case GAUSS:
       {
         m_Controls->m_ApplyButton->setEnabled(true);
         break;
       }
     }
   }
 }
 
 void QmitkDenoisingView::BeforeThread()
 {
   m_ThreadIsRunning = true;
 
   // initialize timer to update the progressbar at each timestep
   m_DenoisingTimer->start(500);
   m_Controls->m_ParameterBox->setEnabled(false);
   m_Controls->m_ApplyButton->setText("Abort");
 }
 
 void QmitkDenoisingView::AfterThread()
 {
   m_ThreadIsRunning = false;
   // stop timer to stop updates of progressbar
   m_DenoisingTimer->stop();
   // make sure progressbar is finished
   mitk::ProgressBar::GetInstance()->Progress(m_MaxProgressCount);
   if (m_CompletedCalculation)
   {
     switch (m_SelectedFilter)
     {
       case NOFILTERSELECTED:
       case GAUSS:
       {
         break;
       }
 
       case NLM:
-      {
-        DiffusionImageType::Pointer image = DiffusionImageType::New();
-        image->SetVectorImage(m_NonLocalMeansFilter->GetOutput());
-        image->SetReferenceBValue(m_InputImage->GetReferenceBValue());
-        image->SetDirections(m_InputImage->GetDirections());
-        image->InitializeFromVectorImage();
-        mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
-        imageNode->SetData( image );
+        {
+          mitk::Image::Pointer image = mitk::GrabItkImageMemory( m_NonLocalMeansFilter->GetOutput() );
+          image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( static_cast<mitk::GradientDirectionsProperty*>( m_InputImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() ) );
+          image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>(m_InputImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() ) );
+          mitk::DiffusionPropertyHelper propertyHelper( image );
+          propertyHelper.InitializeImage();
+
+          mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+          imageNode->SetData( image );
         QString name = m_ImageNode->GetName().c_str();
 
         //TODO: Rician adaption & joint information in name
         if (m_Controls->m_RicianCheckbox->isChecked() && !m_Controls->m_JointInformationCheckbox->isChecked())
         {
           imageNode->SetName((name+"_NLMr_"+QString::number(m_Controls->m_SpinBoxParameter1->value())+"-"+QString::number(m_Controls->m_SpinBoxParameter2->value())).toStdString().c_str());
         }
         else if(!m_Controls->m_RicianCheckbox->isChecked() && m_Controls->m_JointInformationCheckbox->isChecked())
         {
           imageNode->SetName((name+"_NLMv_"+QString::number(m_Controls->m_SpinBoxParameter1->value())+"-"+QString::number(m_Controls->m_SpinBoxParameter2->value())).toStdString().c_str());
         }
         else if(m_Controls->m_RicianCheckbox->isChecked() && m_Controls->m_JointInformationCheckbox->isChecked())
         {
           imageNode->SetName((name+"_NLMvr_"+QString::number(m_Controls->m_SpinBoxParameter1->value())+"-"+QString::number(m_Controls->m_SpinBoxParameter2->value())).toStdString().c_str());
         }
         else
         {
           imageNode->SetName((name+"_NLM_"+QString::number(m_Controls->m_SpinBoxParameter1->value())+"-"+QString::number(m_Controls->m_SpinBoxParameter2->value())).toStdString().c_str());
         }
         GetDefaultDataStorage()->Add(imageNode);
         break;
       }
     }
   }
 
   m_Controls->m_ParameterBox->setEnabled(true);
   m_Controls->m_ApplyButton->setText("Apply");
 }
 
 void QmitkDenoisingView::UpdateProgress()
 {
   switch (m_SelectedFilter)
   {
     case NOFILTERSELECTED:
     case GAUSS:
     {
       break;
     }
     case NLM:
     {
       unsigned int currentProgressCount = m_NonLocalMeansFilter->GetCurrentVoxelCount();
       mitk::ProgressBar::GetInstance()->Progress(currentProgressCount-m_LastProgressCount);
       m_LastProgressCount = currentProgressCount;
       break;
     }
   }
-}
\ No newline at end of file
+}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDenoisingView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDenoisingView.h
index ba63e1a8b3..172b39bd38 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDenoisingView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDenoisingView.h
@@ -1,133 +1,134 @@
 /*===================================================================
 
 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 _QMITKQmitkDenoisingView_H_INCLUDED
 #define _QMITKQmitkDenoisingView_H_INCLUDED
 
 #include <berryISelectionListener.h>
 
 #include <QmitkFunctionality.h>
 
 #include "ui_QmitkDenoisingViewControls.h"
 
 #include <itkVectorImage.h>
 #include <itkImage.h>
-#include <mitkDiffusionImage.h>
+#include <mitkImage.h>
 #include <itkNonLocalMeansDenoisingFilter.h>
 #include <itkMaskImageFilter.h>
 #include <itkDiscreteGaussianImageFilter.h>
 #include <itkVectorImageToImageFilter.h>
 #include <itkComposeImageFilter.h>
 #include <QThread>
 #include <QTimer>
 
 /**
  * \class QmitkDenoisingView
  * \brief View displaying details to denoise diffusionweighted images.
  *
  * \sa QmitkFunctionality
  * \ingroup Functionalities
  */
 class QmitkDenoisingView;
 
 class QmitkDenoisingWorker : public QObject
 {
   Q_OBJECT
 
 public:
 
   QmitkDenoisingWorker(QmitkDenoisingView* view);
 
 public slots:
 
   void run();
 
 private:
 
   QmitkDenoisingView* m_View;
 };
 
 
 class QmitkDenoisingView : public QmitkFunctionality
 {
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
 
   static const std::string VIEW_ID;
 
   QmitkDenoisingView();
   virtual ~QmitkDenoisingView();
 
   /** Typedefs */
   typedef short                                                                                                         DiffusionPixelType;
-  typedef mitk::DiffusionImage< DiffusionPixelType >                                                                    DiffusionImageType;
   typedef mitk::Image                                                                                                   MaskImageType;
   typedef itk::NonLocalMeansDenoisingFilter< DiffusionPixelType >                                                       NonLocalMeansDenoisingFilterType;
   typedef itk::DiscreteGaussianImageFilter < itk::Image< DiffusionPixelType, 3>, itk::Image< DiffusionPixelType, 3> >   GaussianFilterType;
   typedef itk::VectorImageToImageFilter < DiffusionPixelType >                                                          ExtractFilterType;
   typedef itk::ComposeImageFilter < itk::Image<DiffusionPixelType, 3> >                                                 ComposeFilterType;
+  typedef itk::VectorImage<DiffusionPixelType, 3>
+    ITKDiffusionImageType;
 
   virtual void CreateQtPartControl(QWidget *parent);
 
   /// \brief Creation of the connections of main and control widget
   virtual void CreateConnections();
   /// \brief Creation of the connections of the FilterComboBox
   virtual void Activated();
 
 private slots:
 
   void StartDenoising();                  //< prepares filter condition and starts thread for denoising
   void SelectFilter(int filter);          //< updates which filter is selected
   void BeforeThread();                    //< starts timer & disables all buttons while denoising
   void AfterThread();                     //< stops timer & creates a new datanode of the denoised image
   void UpdateProgress();                  //< updates the progressbar each timestep
 
 private:
 
   /// \brief called by QmitkFunctionality when DataManager's selection has changed
   virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes );
   void ResetParameterPanel();
 
   Ui::QmitkDenoisingViewControls*  m_Controls;
   mitk::DataNode::Pointer m_ImageNode;
   mitk::DataNode::Pointer m_BrainMaskNode;
   QmitkDenoisingWorker m_DenoisingWorker;
   QThread m_DenoisingThread;
   bool m_ThreadIsRunning;
   bool m_CompletedCalculation;
   NonLocalMeansDenoisingFilterType::Pointer m_NonLocalMeansFilter;
   GaussianFilterType::Pointer m_GaussianFilter;
-  DiffusionImageType::Pointer m_InputImage;
+  mitk::Image::Pointer m_InputImage;
   MaskImageType::Pointer m_ImageMask;
   QTimer* m_DenoisingTimer;
   unsigned int m_LastProgressCount;
   unsigned int m_MaxProgressCount;
 
   enum FilterType {
     NOFILTERSELECTED,
     NLM,
     GAUSS
   }m_SelectedFilter;
 
   friend class QmitkDenoisingWorker;
 };
 
 
 
 #endif // _QmitkDenoisingView_H_INCLUDED
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.cpp
index 4ae704a475..6930ce34df 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.cpp
@@ -1,558 +1,558 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include "QmitkDiffusionDicomImportView.h"
 
 // qt includes
 #include <QFileDialog>
 
 // itk includes
 #include "itkTimeProbesCollectorBase.h"
 #include "itkGDCMSeriesFileNames.h"
 #include "itksys/SystemTools.hxx"
 
 // mitk includes
 #include "mitkProgressBar.h"
 #include "mitkStatusBar.h"
 #include "mitkProperties.h"
 #include "mitkRenderingManager.h"
 #include "mitkMemoryUtilities.h"
 #include "mitkIOUtil.h"
 
 // diffusion module includes
 #include "mitkDicomDiffusionImageHeaderReader.h"
 #include "mitkDicomDiffusionImageReader.h"
-#include "mitkDiffusionImage.h"
+#include "mitkImage.h"
+#include <mitkDiffusionPropertyHelper.h>
 
 #include "mitkDiffusionDICOMFileReader.h"
 #include "mitkDICOMTagBasedSorter.h"
 #include "mitkDICOMSortByTag.h"
 #include "mitkSortByImagePositionPatient.h"
 
 #include "gdcmDirectory.h"
 #include "gdcmScanner.h"
 #include "gdcmSorter.h"
 #include "gdcmIPPSorter.h"
 #include "gdcmAttribute.h"
 #include "gdcmVersion.h"
 
 #include <itksys/SystemTools.hxx>
 #include <itksys/Directory.hxx>
 
 #include <QMessageBox>
 
 const std::string QmitkDiffusionDicomImport::VIEW_ID = "org.mitk.views.diffusiondicomimport";
 
 
 QmitkDiffusionDicomImport::QmitkDiffusionDicomImport(QObject* /*parent*/, const char* /*name*/)
   : QmitkFunctionality(), m_Controls(NULL), m_MultiWidget(NULL),
     m_OutputFolderName(""), m_OutputFolderNameSet(false)
 {
 }
 
 QmitkDiffusionDicomImport::QmitkDiffusionDicomImport(const QmitkDiffusionDicomImport& other)
 {
   Q_UNUSED(other)
   throw std::runtime_error("Copy constructor not implemented");
 }
 
 QmitkDiffusionDicomImport::~QmitkDiffusionDicomImport()
 {}
 
 void QmitkDiffusionDicomImport::CreateQtPartControl(QWidget *parent)
 {
   m_Parent = parent;
   if (m_Controls == NULL)
   {
     m_Controls = new Ui::QmitkDiffusionDicomImportControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
 
     m_Controls->m_DicomLoadRecursiveCheckbox->setChecked(false);
     m_Controls->m_DicomLoadAverageDuplicatesCheckbox->setChecked(false);
 
     m_Controls->m_DicomLoadRecursiveCheckbox->setVisible(true);
     m_Controls->m_OverrideOptionCheckbox->setVisible(false);
     m_Controls->m_SubdirPrefixLineEdit->setVisible(false);
     m_Controls->m_SetPrefixButton->setVisible(false);
     m_Controls->m_ResetPrefixButton->setVisible(false);
 
     AverageClicked();
   }
 }
 
 
 
 void QmitkDiffusionDicomImport::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( m_Controls->m_AddFoldersButton, SIGNAL(clicked()), this, SLOT(DicomLoadAddFolderNames()) );
     connect( m_Controls->m_DeleteFoldersButton, SIGNAL(clicked()), this, SLOT(DicomLoadDeleteFolderNames()) );
     //connect( m_Controls->m_DicomLoadStartLoadButton, SIGNAL(clicked()), this, SLOT(DicomLoadStartLoad()) );
     connect( m_Controls->m_DicomLoadStartLoadButton, SIGNAL(clicked()), this, SLOT(NewDicomLoadStartLoad()) );
     connect( m_Controls->m_DicomLoadAverageDuplicatesCheckbox, SIGNAL(clicked()), this, SLOT(AverageClicked()) );
     connect( m_Controls->m_OutputSetButton, SIGNAL(clicked()), this, SLOT(OutputSet()) );
     connect( m_Controls->m_OutputClearButton, SIGNAL(clicked()), this, SLOT(OutputClear()) );
     connect( m_Controls->m_Remove, SIGNAL(clicked()), this, SLOT(Remove()) );
     connect( m_Controls->m_SetPrefixButton, SIGNAL(clicked()), this, SLOT(SetPrefixButtonPushed()));
     connect( m_Controls->m_ResetPrefixButton, SIGNAL(clicked()), this, SLOT(ResetPrefixButtonPushed()));
     connect( m_Controls->m_DicomLoadRecursiveCheckbox, SIGNAL(clicked()), this, SLOT(RecursiveSettingsChanged()) );
   }
 }
 
 void QmitkDiffusionDicomImport::RecursiveSettingsChanged()
 {
   m_Controls->m_SubdirPrefixLineEdit->setVisible( m_Controls->m_DicomLoadRecursiveCheckbox->isChecked() );
   m_Controls->m_SetPrefixButton->setVisible( m_Controls->m_DicomLoadRecursiveCheckbox->isChecked() );
   m_Controls->m_SubdirPrefixLineEdit->clear();
   this->m_Controls->m_SubdirPrefixLineEdit->setEnabled(true);
 }
 
 void QmitkDiffusionDicomImport::SetPrefixButtonPushed()
 {
   m_Prefix = this->m_Controls->m_SubdirPrefixLineEdit->text().toStdString();
   if( !this->m_Controls->m_ResetPrefixButton->isVisible() )
     this->m_Controls->m_ResetPrefixButton->setVisible(true);
 
   this->m_Controls->m_SubdirPrefixLineEdit->setEnabled(false);
   this->m_Controls->m_ResetPrefixButton->setEnabled(true);
   this->m_Controls->m_SetPrefixButton->setEnabled(false);
 }
 
 void QmitkDiffusionDicomImport::ResetPrefixButtonPushed()
 {
   m_Controls->m_SubdirPrefixLineEdit->clear();
 
   this->m_Controls->m_SubdirPrefixLineEdit->setEnabled(true);
 
   this->m_Controls->m_ResetPrefixButton->setEnabled(false);
   this->m_Controls->m_SetPrefixButton->setEnabled(true);
 }
 
 void QmitkDiffusionDicomImport::Remove()
 {
   int i = m_Controls->listWidget->currentRow();
   m_Controls->listWidget->takeItem(i);
 }
 
 void QmitkDiffusionDicomImport::OutputSet()
 {
   // SELECT FOLDER DIALOG
   QFileDialog* w = new QFileDialog( m_Parent, QString("Select folders containing DWI data") );
   w->setFileMode( QFileDialog::Directory );
 
   // RETRIEVE SELECTION
   if ( w->exec() != QDialog::Accepted )
     return;
 
   m_OutputFolderName = w->selectedFiles()[0];
   m_OutputFolderNameSet = true;
   m_Controls->m_OutputLabel->setText(m_OutputFolderName);
 
   // show file override option checkbox
   m_Controls->m_OverrideOptionCheckbox->setVisible(true);
 }
 
 void QmitkDiffusionDicomImport::OutputClear()
 {
   m_OutputFolderName = "";
   m_OutputFolderNameSet = false;
   m_Controls->m_OutputLabel->setText("... optional out-folder ...");
 
   // hide file override option checkbox - no output specified
   m_Controls->m_OverrideOptionCheckbox->setVisible(false);
 }
 
 void QmitkDiffusionDicomImport::AverageClicked()
 {
   m_Controls->m_Blur->setEnabled(m_Controls->m_DicomLoadAverageDuplicatesCheckbox->isChecked());
 }
 
 void QmitkDiffusionDicomImport::Activated()
 {
   QmitkFunctionality::Activated();
 }
 
 void QmitkDiffusionDicomImport::DicomLoadDeleteFolderNames()
 {
   m_Controls->listWidget->clear();
 }
 
 void QmitkDiffusionDicomImport::DicomLoadAddFolderNames()
 {
   // SELECT FOLDER DIALOG
   QFileDialog* w = new QFileDialog( m_Parent, QString("Select folders containing DWI data") );
   w->setFileMode( QFileDialog::Directory );
 
   // RETRIEVE SELECTION
   if ( w->exec() != QDialog::Accepted )
     return;
 
   m_Controls->listWidget->addItems(w->selectedFiles());
 }
 
 bool SortBySeriesUID(gdcm::DataSet const & ds1, gdcm::DataSet const & ds2 )
 {
   gdcm::Attribute<0x0020,0x000e> at1;
   at1.Set( ds1 );
   gdcm::Attribute<0x0020,0x000e> at2;
   at2.Set( ds2 );
   return at1 < at2;
 }
 
 bool SortByAcquisitionNumber(gdcm::DataSet const & ds1, gdcm::DataSet const & ds2 )
 {
   gdcm::Attribute<0x0020,0x0012> at1;
   at1.Set( ds1 );
   gdcm::Attribute<0x0020,0x0012> at2;
   at2.Set( ds2 );
   return at1 < at2;
 }
 
 bool SortBySeqName(gdcm::DataSet const & ds1, gdcm::DataSet const & ds2 )
 {
   gdcm::Attribute<0x0018, 0x0024> at1;
   at1.Set( ds1 );
   gdcm::Attribute<0x0018, 0x0024> at2;
   at2.Set( ds2 );
 
   std::string str1 = at1.GetValue().Trim();
   std::string str2 = at2.GetValue().Trim();
   return std::lexicographical_compare(str1.begin(), str1.end(),
                                       str2.begin(), str2.end() );
 }
 
 void QmitkDiffusionDicomImport::Status(QString status)
 {
   mitk::StatusBar::GetInstance()->DisplayText(status.toLatin1());
   MITK_INFO << status.toStdString().c_str();
 }
 
 void QmitkDiffusionDicomImport::Status(std::string status)
 {
   mitk::StatusBar::GetInstance()->DisplayText(status.c_str());
   MITK_INFO << status.c_str();
 }
 
 void QmitkDiffusionDicomImport::Status(const char* status)
 {
   mitk::StatusBar::GetInstance()->DisplayText(status);
   MITK_INFO << status;
 }
 
 void QmitkDiffusionDicomImport::Error(QString status)
 {
   mitk::StatusBar::GetInstance()->DisplayErrorText(status.toLatin1());
   MITK_ERROR << status.toStdString().c_str();
 }
 
 void QmitkDiffusionDicomImport::Error(std::string status)
 {
   mitk::StatusBar::GetInstance()->DisplayErrorText(status.c_str());
   MITK_ERROR << status.c_str();
 }
 
 void QmitkDiffusionDicomImport::Error(const char* status)
 {
   mitk::StatusBar::GetInstance()->DisplayErrorText(status);
   MITK_ERROR << status;
 }
 
 void QmitkDiffusionDicomImport::PrintMemoryUsage()
 {
   size_t processSize = mitk::MemoryUtilities::GetProcessMemoryUsage();
   size_t totalSize =  mitk::MemoryUtilities::GetTotalSizeOfPhysicalRam();
   float percentage = ( (float) processSize / (float) totalSize ) * 100.0;
   MITK_INFO << "Current memory usage: " << GetMemoryDescription( processSize, percentage );
 }
 
 std::string QmitkDiffusionDicomImport::FormatMemorySize( size_t size )
 {
   double val = size;
   std::string descriptor("B");
   if ( val >= 1000.0 )
   {
     val /= 1024.0;
     descriptor = "KB";
   }
   if ( val >= 1000.0 )
   {
     val /= 1024.0;
     descriptor = "MB";
   }
   if ( val >= 1000.0 )
   {
     val /= 1024.0;
     descriptor = "GB";
   }
   std::ostringstream str;
   str << std::fixed << std::setprecision(2) << val << " " << descriptor;
   return str.str();
 }
 
 std::string QmitkDiffusionDicomImport::FormatPercentage( double val )
 {
   std::ostringstream str;
   str << std::fixed << std::setprecision(2) << val << " " << "%";
   return str.str();
 }
 
 std::string QmitkDiffusionDicomImport::GetMemoryDescription( size_t processSize, float percentage )
 {
   std::ostringstream str;
   str << FormatMemorySize(processSize) << " (" << FormatPercentage( percentage ) <<")" ;
   return str.str();
 }
 
 void QmitkDiffusionDicomImport::NewDicomLoadStartLoad()
 {
   itk::TimeProbesCollectorBase clock;
   bool imageSuccessfullySaved = true;
 
   bool has_prefix = true;
 
   try
   {
     const std::string& locale = "C";
     const std::string& currLocale = setlocale( LC_ALL, NULL );
 
     if ( locale.compare(currLocale)!=0 )
     {
       try
       {
         MITK_INFO << " ** Changing locale from " << setlocale(LC_ALL, NULL) << " to '" << locale << "'";
         setlocale(LC_ALL, locale.c_str());
       }
       catch(...)
       {
         MITK_INFO << "Could not set locale " << locale;
       }
     }
 
     int nrFolders = m_Controls->listWidget->count();
 
     if(!nrFolders)
     {
       Error(QString("No input folders were selected. ABORTING."));
       return;
     }
 
     Status(QString("GDCM %1 used for DICOM parsing and sorting!").arg(gdcm::Version::GetVersion()));
 
     PrintMemoryUsage();
     QString status;
     mitk::DataNode::Pointer node;
     mitk::ProgressBar::GetInstance()->AddStepsToDo(2*nrFolders);
 
     gdcm::Directory::FilenamesType complete_list;
     while(m_Controls->listWidget->count())
     {
       // RETREIVE FOLDERNAME
       QListWidgetItem * item  = m_Controls->listWidget->takeItem(0);
       QString folderName = item->text();
 
 
       if( this->m_Controls->m_DicomLoadRecursiveCheckbox->isChecked() )
       {
 
         std::string subdir_prefix = "";
         if( has_prefix )
         {
           subdir_prefix = this->m_Prefix;
         }
 
         itksys::Directory rootdir;
         rootdir.Load( folderName.toStdString().c_str() );
 
         for( unsigned int idx=0; idx<rootdir.GetNumberOfFiles(); idx++)
         {
           std::string current_path = rootdir.GetFile(idx);
           std::string directory_path = std::string(rootdir.GetPath()) + std::string("/") + current_path;
 
           MITK_INFO("dicom.loader.inputrootdir.test") << "ProbePath:   " << current_path;
           MITK_INFO("dicom.loader.inputrootdir.test") << "IsDirectory: " << itksys::SystemTools::FileIsDirectory( itksys::SystemTools::ConvertToOutputPath( directory_path.c_str() ).c_str() )
                                                       << " StartsWith: " << itksys::SystemTools::StringStartsWith( current_path.c_str(), subdir_prefix.c_str() );
 
           // test for prefix
           if(    itksys::SystemTools::FileIsDirectory( itksys::SystemTools::ConvertToOutputPath( directory_path.c_str() ).c_str() )
                  && itksys::SystemTools::StringStartsWith( current_path.c_str(), subdir_prefix.c_str() )
                  )
           {
 
             gdcm::Directory d;
             d.Load( itksys::SystemTools::ConvertToOutputPath( directory_path.c_str() ) , false);
 
             MITK_INFO("dicom.load.subdir.attempt") << "In directory " << itksys::SystemTools::ConvertToOutputPath( directory_path.c_str() );
 
             const gdcm::Directory::FilenamesType &l1 = d.GetFilenames();
             const unsigned int ntotalfiles = l1.size();
             Status(QString(" ... found %1 different files").arg(ntotalfiles));
 
             for( unsigned int i=0; i< ntotalfiles; i++)
             {
               complete_list.push_back( l1.at(i) );
             }
 
 
           }
 
         }
       }
       else
       {
         gdcm::Directory d;
         d.Load( folderName.toStdString().c_str(), this->m_Controls->m_DicomLoadRecursiveCheckbox->isChecked() ); // recursive !
         const gdcm::Directory::FilenamesType &l1 = d.GetFilenames();
         const unsigned int ntotalfiles = l1.size();
         Status(QString(" ... found %1 different files").arg(ntotalfiles));
 
         for( unsigned int i=0; i< ntotalfiles; i++)
         {
           complete_list.push_back( l1.at(i) );
         }
 
       }
 
 
 
     }
 
     {
       mitk::DiffusionDICOMFileReader::Pointer gdcmReader = mitk::DiffusionDICOMFileReader::New();
       mitk::DICOMTagBasedSorter::Pointer tagSorter = mitk::DICOMTagBasedSorter::New();
 
       // Use tags as in Qmitk
       // all the things that split by tag in DicomSeriesReader
       tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0028, 0x0010) ); // Number of Rows
       tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0028, 0x0011) ); // Number of Columns
       tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0028, 0x0030) ); // Pixel Spacing
       tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0018, 0x1164) ); // Imager Pixel Spacing
       tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0020, 0x0037) ); // Image Orientation (Patient) // TODO add tolerance parameter (l. 1572 of original code)
       // TODO handle as real vectors! cluster with configurable errors!
       tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0020, 0x000e) ); // Series Instance UID
       tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0018, 0x0050) ); // Slice Thickness
       tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0028, 0x0008) ); // Number of Frames
       //tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0020, 0x0052) ); // Frame of Reference UID
 
       // gdcmReader->AddSortingElement( tagSorter );
       //mitk::DICOMFileReaderTestHelper::TestOutputsContainInputs( gdcmReader );
 
       mitk::DICOMSortCriterion::ConstPointer sorting =
         mitk::SortByImagePositionPatient::New(  // Image Position (Patient)
           //mitk::DICOMSortByTag::New( mitk::DICOMTag(0x0020, 0x0013), // instance number
              mitk::DICOMSortByTag::New( mitk::DICOMTag(0x0020, 0x0012), // aqcuisition number
                 mitk::DICOMSortByTag::New( mitk::DICOMTag(0x0008, 0x0032), // aqcuisition time
                    mitk::DICOMSortByTag::New( mitk::DICOMTag(0x0018, 0x1060), // trigger time
                       mitk::DICOMSortByTag::New( mitk::DICOMTag(0x0008, 0x0018) // SOP instance UID (last resort, not really meaningful but decides clearly)
                     ).GetPointer()
                   ).GetPointer()
                 ).GetPointer()
              ).GetPointer()
         // ).GetPointer()
         ).GetPointer();
       tagSorter->SetSortCriterion( sorting );
 
       // mosaic
       gdcmReader->SetResolveMosaic( this->m_Controls->m_SplitMosaicCheckBox->isChecked() );
       gdcmReader->AddSortingElement( tagSorter );
       gdcmReader->SetInputFiles( complete_list );
       try
       {
         gdcmReader->AnalyzeInputFiles();
       }
       catch( const itk::ExceptionObject &e)
       {
         MITK_ERROR << "Failed to analyze data. " << e.what();
       }
       catch( const std::exception &se)
       {
         MITK_ERROR << "Std Exception " << se.what();
       }
 
       gdcmReader->LoadImages();
 
       for( int o = 0; o < gdcmReader->GetNumberOfOutputs(); o++ )
       {
         mitk::Image::Pointer loaded_image = gdcmReader->GetOutput(o).GetMitkImage();
-        mitk::DiffusionImage<short>::Pointer d_img = static_cast<mitk::DiffusionImage<short>*>( loaded_image.GetPointer() );
 
         std::stringstream ss;
         ss << "ImportedData_" << o;
 
         node = mitk::DataNode::New();
-        node->SetData( d_img );
+        node->SetData( loaded_image );
         std::string outname;
-        d_img->GetPropertyList()->GetStringProperty("diffusion.dicom.importname", outname );
+        loaded_image->GetPropertyList()->GetStringProperty("diffusion.dicom.importname", outname );
 
         node->SetName( outname.c_str() );
 
         GetDefaultDataStorage()->Add(node);
         //SetDwiNodeProperties(node, ss.str() );
         //Status(QString("Image %1 added to datastorage").arg(descr));
       }
 
 
 
     }
 
     Status("Timing information");
     clock.Report();
 
     if(!m_OutputFolderNameSet && node.IsNotNull())
     {
       mitk::BaseData::Pointer basedata = node->GetData();
       if (basedata.IsNotNull())
       {
         mitk::RenderingManager::GetInstance()->InitializeViews(
               basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
       }
     }
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
     try
     {
       MITK_INFO << " ** Changing locale back from " << setlocale(LC_ALL, NULL) << " to '" << currLocale << "'";
       setlocale(LC_ALL, currLocale.c_str());
     }
     catch(...)
     {
       MITK_INFO << "Could not reset locale " << currLocale;
     }
   }
   catch (itk::ExceptionObject &ex)
   {
     Error(QString("%1\n%2\n%3\n%4\n%5\n%6").arg(ex.GetNameOfClass()).arg(ex.GetFile()).arg(ex.GetLine()).arg(ex.GetLocation()).arg(ex.what()).arg(ex.GetDescription()));
     return ;
   }
 
   if (!imageSuccessfullySaved)
     QMessageBox::warning(NULL,"WARNING","One or more files could not be saved! The according files where moved to the datastorage.");
   Status(QString("Finished import with memory:"));
 
   PrintMemoryUsage();
 }
 
 void QmitkDiffusionDicomImport::SetDwiNodeProperties(mitk::DataNode::Pointer node, std::string name)
 {
 
   node->SetProperty( "IsDWIRawVolume", mitk::BoolProperty::New( true ) );
 
   // set foldername as string property
   mitk::StringProperty::Pointer nameProp = mitk::StringProperty::New( name );
   node->SetProperty( "name", nameProp );
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionRegistrationView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionRegistrationView.cpp
index 7b71f5bbe4..a99cb6032d 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionRegistrationView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionRegistrationView.cpp
@@ -1,482 +1,488 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 //misc
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkDiffusionRegistrationView.h"
 #include <QmitkStdMultiWidget.h>
 
 // MITK
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkProgressBar.h>
 #include <mitkIOUtil.h>
+#include <mitkDiffusionPropertyHelper.h>
 
 // Qt
 #include <QMessageBox>
 #include <QFileDialog>
 #include <QDir>
 #include <QDirIterator>
 
 
 #include <mitkDWIHeadMotionCorrectionFilter.h>
 
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 QmitkRegistrationWorker::QmitkRegistrationWorker(QmitkDiffusionRegistrationView* view)
   : m_View(view)
 {
 
 }
 
 void QmitkRegistrationWorker::run()
 {
 
-  typedef mitk::DiffusionImage<DiffusionPixelType>              DiffusionImageType;
-  typedef DiffusionImageType::BValueMap BValueMap;
+  typedef mitk::DiffusionPropertyHelper::BValueMapType BValueMap;
 
   unsigned int totalImagesCount;
   if( !m_View->m_IsBatch )
   {
     totalImagesCount = m_View->m_SelectedDiffusionNodes.size();
   }
   else
   {
     totalImagesCount = m_View->m_BatchList.size();
   }
   m_View->m_TotalFiles = totalImagesCount;
 
   QString inputPath = m_View->m_Controls->m_InputFolderTextbox->text();
   QString outputPath = m_View->m_Controls->m_OutputFolderTextbox->text();
 
 
   for(unsigned int i=0; i< totalImagesCount; i++)
   {
     if(m_View->m_IsAborted){
       m_View->m_RegistrationThread.quit();
       return;
     }
 
     m_View->m_CurrentFile = i+1;
     m_View->m_GlobalRegisterer = QmitkDiffusionRegistrationView::DWIHeadMotionCorrectionFilterType::New();
 
     //mitk::DataNode::Pointer node = m_View->m_SelectedDiffusionNodes.at(i);
-    DiffusionImageType::Pointer inImage;
+    mitk::Image::Pointer inImage;
     mitk::DataNode::Pointer node;
 
     if( !m_View->m_IsBatch )
     {
       node = m_View->m_SelectedDiffusionNodes.at(i);
-      inImage = dynamic_cast<mitk::DiffusionImage<short>*>(node->GetData());
+      inImage = dynamic_cast<mitk::Image*>(node->GetData());
     }
     else
     {
-      mitk::Image::Pointer inputImage = mitk::IOUtil::LoadImage( m_View->m_BatchList.at(i).toStdString() );
-      inImage = static_cast<DiffusionImageType*>( inputImage.GetPointer() );
+      mitk::Image::Pointer inImage = mitk::IOUtil::LoadImage( m_View->m_BatchList.at(i).toStdString() );
+      mitk::GradientDirectionsProperty::Pointer gradDir = static_cast<mitk::GradientDirectionsProperty*>(inImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer());
     }
 
+    bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( inImage ) );
 
-    if(inImage.IsNull())
+    if(!isDiffusionImage)
     {
       MITK_ERROR << "Error occured: can't get input image. \nAborting";
       return;
     }
 
 
     m_View->m_GlobalRegisterer->SetInput(inImage);
 
     try
     {
       m_View->m_GlobalRegisterer->Update();
     }
     catch( mitk::Exception e )
     {
       MITK_ERROR << "Internal error occured: " <<  e.what() << "\nAborting";
     }
 
     if( m_View->m_GlobalRegisterer->GetIsInValidState() )
     {
-
       if(! m_View->m_IsBatch)
       {
-        DiffusionImageType::Pointer image = m_View->m_GlobalRegisterer->GetOutput();
+        mitk::Image::Pointer image = m_View->m_GlobalRegisterer->GetOutput();
         mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
         imageNode->SetData( image );
         QString name = node->GetName().c_str();
         imageNode->SetName((name+"_MC").toStdString().c_str());
         m_View->GetDataStorage()->Add(imageNode);
       }
       else
       {
         QString name = m_View->m_BatchList.at(i);
         name = name.replace(".dwi", "_MC.dwi", Qt::CaseInsensitive);
         name = name.replace(inputPath, outputPath, Qt::CaseInsensitive);
 
         try
         {
           mitk::IOUtil::Save(m_View->m_GlobalRegisterer->GetOutput(), name.toStdString().c_str());
         }
         catch( const itk::ExceptionObject& e)
         {
           MITK_ERROR << "Catched exception: " << e.what();
           mitkThrow() << "Failed with exception from subprocess!";
         }
       }
     }
 
   }
   m_View->m_RegistrationThread.quit();
 }
 
 
 const std::string QmitkDiffusionRegistrationView::VIEW_ID = "org.mitk.views.diffusionregistrationview";
 
 QmitkDiffusionRegistrationView::QmitkDiffusionRegistrationView()
   : QmitkAbstractView()
   , m_Controls( 0 )
   , m_DiffusionImage( NULL )
   , m_ThreadIsRunning(false)
   , m_Steps(100)
   , m_LastStep(0)
   , m_GlobalRegisterer(NULL)
   , m_RegistrationWorker(this)
 
 {
 
   m_RegistrationWorker.moveToThread(&m_RegistrationThread);
   connect(&m_RegistrationThread, SIGNAL(started()), this, SLOT(BeforeThread()));
   connect(&m_RegistrationThread, SIGNAL(started()), &m_RegistrationWorker, SLOT(run()));
   connect(&m_RegistrationThread, SIGNAL(finished()), this, SLOT(AfterThread()));
   connect(&m_RegistrationThread, SIGNAL(terminated()), this, SLOT(AfterThread()));
   m_RegistrationTimer = new QTimer(this);
 
 }
 
 // Destructor
 QmitkDiffusionRegistrationView::~QmitkDiffusionRegistrationView()
 {
   delete m_RegistrationTimer;
 }
 
 // update Registration status and generate fiber bundle
 void QmitkDiffusionRegistrationView::TimerUpdate()
 {
   int currentStep = m_GlobalRegisterer->GetCurrentStep();
 
   mitk::ProgressBar::GetInstance()->Progress(currentStep-m_LastStep);
   UpdateRegistrationStatus();
 
   m_LastStep = currentStep;
 }
 
 // update gui elements after registration is finished
 void QmitkDiffusionRegistrationView::AfterThread()
 {
 
   m_ThreadIsRunning = false;
   m_RegistrationTimer->stop();
 
   mitk::ProgressBar::GetInstance()->Progress(m_GlobalRegisterer->GetSteps()-m_LastStep+1);
   UpdateGUI();
 
 
   if( !m_GlobalRegisterer->GetIsInValidState() )
   {
     QMessageBox::critical( NULL,  "Registration", "An internal error occured, or user canceled the Registration.\n Please check the log for details." );
     return;
   }
 
   UpdateRegistrationStatus();
 
 
   m_GlobalRegisterer = 0;
 
 }
 
 // start Registration timer and update gui elements before Registration is started
 void QmitkDiffusionRegistrationView::BeforeThread()
 {
   m_ThreadIsRunning = true;
   m_RegistrationTime = QTime::currentTime();
   m_ElapsedTime = 0;
   m_RegistrationTimer->start(1000);
   m_LastStep = 0;
 
   UpdateGUI();
 }
 
 
 void QmitkDiffusionRegistrationView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkDiffusionRegistrationViewControls;
     m_Controls->setupUi( parent );
 
     AdvancedSettings();
 
     connect( m_RegistrationTimer, SIGNAL(timeout()), this, SLOT(TimerUpdate()) );
     connect( m_Controls->m_RegistrationStopButton, SIGNAL(clicked()), this, SLOT(StopRegistration()) );
     connect( m_Controls->m_RegistrationStartButton, SIGNAL(clicked()), this, SLOT(StartRegistration()) );
     connect( m_Controls->m_AdvancedSettingsCheckbox, SIGNAL(clicked()), this, SLOT(AdvancedSettings()) );
     connect( m_Controls->m_SelectInputButton, SIGNAL(clicked()), this, SLOT(AddInputFolderName()) );
     connect( m_Controls->m_SelectOutputButton, SIGNAL(clicked()), this, SLOT(AddOutputFolderName()) );
     connect( m_Controls->m_StartBatchButton, SIGNAL(clicked()), this, SLOT(StartBatch()) );
 
     this->m_Parent = parent;
   }
 }
 
 // show/hide advanced settings frame
 void QmitkDiffusionRegistrationView::AdvancedSettings()
 {
   m_Controls->m_AdvancedFrame->setVisible(m_Controls->m_AdvancedSettingsCheckbox->isChecked());
 }
 
 
 void QmitkDiffusionRegistrationView::OnSelectionChanged( berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>& nodes )
 {
 
   if (m_ThreadIsRunning)
     return;
 
   bool foundDwiVolume = false;
   QString tempSelectedNames = "";
   m_DiffusionImage = NULL;
   m_SelectedDiffusionNodes.clear();
 
   // iterate selection
   for( int i=0; i<nodes.size(); i++)
   {
     mitk::DataNode::Pointer node = nodes.at(i);
 
-    if( node.IsNotNull() && dynamic_cast<mitk::DiffusionImage<short>*>(node->GetData()) )
+    bool isDiffusionImage(false);
+    if( node.IsNotNull() )
+    {
+      isDiffusionImage = mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData()));
+    }
+
+    if( isDiffusionImage )
     {
       foundDwiVolume = true;
       m_SelectedDiffusionNodes.push_back(node);
 
       if(m_SelectedDiffusionNodes.size() > 0){tempSelectedNames += "\n";}
       tempSelectedNames += (node->GetName().c_str());
     }
 
   }
 
 
   m_Controls->m_RegistrationStartButton->setEnabled(foundDwiVolume);
 
   if (foundDwiVolume)
   {
     m_Controls->m_DiffusionImageLabel->setText(tempSelectedNames);
     m_Controls->m_InputData->setTitle("Input Data");
   }
   else
   {
     m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
     m_Controls->m_InputData->setTitle("Please Select Input Data");
   }
 
   UpdateGUI();
 
 }
 
 
 // update gui elements displaying Registrations status
 void QmitkDiffusionRegistrationView::UpdateRegistrationStatus()
 {
   if (m_GlobalRegisterer.IsNull())
     return;
 
   m_ElapsedTime += m_RegistrationTime.elapsed()/1000;
   m_RegistrationTime.restart();
   unsigned long hours = m_ElapsedTime/3600;
   unsigned long minutes = (m_ElapsedTime%3600)/60;
   unsigned long seconds = m_ElapsedTime%60;
 
   m_Controls->m_RegistrationTimeLabel->setText( QString::number(hours)+QString("h ")+QString::number(minutes)+QString("m ")+QString::number(seconds)+QString("s") );
   m_Controls->m_CurrentStepLabel->setText( QString::number((int)(100*(float)(m_GlobalRegisterer->GetCurrentStep()-1)/m_GlobalRegisterer->GetSteps()))+"%" );
   m_Controls->m_CurrentFileLabel->setText( QString::number(m_CurrentFile)+" / "+QString::number(m_TotalFiles) );
 }
 
 void QmitkDiffusionRegistrationView::UpdateGUI()
 {
 
   if (!m_ThreadIsRunning && (m_SelectedDiffusionNodes.size() > 0) )
   {
     m_Controls->m_RegistrationStopButton->setEnabled(false);
     m_Controls->m_RegistrationStartButton->setEnabled(true);
     m_Controls->m_StartBatchButton->setEnabled(true);
     m_Controls->m_AdvancedFrame->setEnabled(true);
     m_Controls->m_RegistrationStopButton->setText("Stop");
     m_Controls->m_RegistrationStartButton->setToolTip("Start Registration");
     m_Controls->m_RegistrationStopButton->setToolTip("");
   }
   else if (!m_ThreadIsRunning)
   {
     m_Controls->m_RegistrationStopButton->setEnabled(false);
     m_Controls->m_RegistrationStartButton->setEnabled(false);
     m_Controls->m_StartBatchButton->setEnabled(true);
     m_Controls->m_AdvancedFrame->setEnabled(true);
     m_Controls->m_RegistrationStopButton->setText("Stop");
     m_Controls->m_RegistrationStartButton->setToolTip("No Diffusion image selected.");
     m_Controls->m_RegistrationStopButton->setToolTip("");
   }
   else
   {
     m_Controls->m_RegistrationStopButton->setEnabled(true);
     m_Controls->m_RegistrationStartButton->setEnabled(false);
     m_Controls->m_StartBatchButton->setEnabled(false);
     m_Controls->m_AdvancedFrame->setEnabled(false);
     m_Controls->m_RegistrationStartButton->setToolTip("Registration in progress.");
     m_Controls->m_RegistrationStopButton->setToolTip("Cancel Registration");
   }
 
 
 }
 
 void QmitkDiffusionRegistrationView::SetFocus()
 {
   m_Controls->m_RegistrationStartButton->setFocus();
 }
 
 
 void QmitkDiffusionRegistrationView::StartRegistration()
 {
 
   if(m_ThreadIsRunning)
   {
     MITK_WARN("QmitkDiffusionRegistrationView")<<"Thread already running!";
     return;
   }
   m_GlobalRegisterer = NULL;
 
   if (m_SelectedDiffusionNodes.size()<1)
   {
     QMessageBox::information( NULL, "Warning", "Please load and select a diffusion image before starting image processing.");
     return;
   }
 
   m_IsBatch = false;
   m_IsAborted = false;
 
   m_Controls->m_RegistrationStartButton->setEnabled(false);
   m_Controls->m_StartBatchButton->setEnabled(false);
 
   // start worker thread
   m_RegistrationThread.start(QThread::NormalPriority);
 
   return;
 }
 
 void QmitkDiffusionRegistrationView::StopRegistration()
 {
 
   if (m_GlobalRegisterer.IsNull())
     return;
 
   m_IsAborted = true;
   m_GlobalRegisterer->SetAbortRegistration(true);
   m_Controls->m_RegistrationStopButton->setEnabled(false);
   m_Controls->m_RegistrationStopButton->setText("Stopping ...");
 
   return;
 }
 
 void QmitkDiffusionRegistrationView::AddInputFolderName()
 {
 
   // SELECT FOLDER DIALOG
   QFileDialog* w = new QFileDialog( m_Parent, QString("Select the input folder with DWI files within") );
   w->setFileMode( QFileDialog::Directory );
 
   // RETRIEVE SELECTION
   if ( w->exec() != QDialog::Accepted )
     return;
 
   m_Controls->m_InputFolderTextbox->setText(w->selectedFiles()[0]);
 }
 
 void QmitkDiffusionRegistrationView::AddOutputFolderName()
 {
   // SELECT FOLDER DIALOG
   QFileDialog* w = new QFileDialog( m_Parent, QString("Select the output folder") );
   w->setFileMode( QFileDialog::Directory );
 
   // RETRIEVE SELECTION
   if ( w->exec() != QDialog::Accepted )
     return;
 
   m_Controls->m_OutputFolderTextbox->setText(w->selectedFiles()[0]);
 }
 
 void QmitkDiffusionRegistrationView::StartBatch()
 {
   QString inputPath = m_Controls->m_InputFolderTextbox->text();
   QString outputPath = m_Controls->m_OutputFolderTextbox->text();
 
   if(inputPath == outputPath){
     QMessageBox::information( NULL, "Error", "Input and Output folders can't be the same");
     return;
   }
 
   QStringList list, filters;
   filters<<"*.dwi";
   QDirIterator dirIterator(inputPath,
                            filters,
                            QDir::Files|QDir::NoSymLinks);
 
   while (dirIterator.hasNext())
   {
     dirIterator.next();
 
     list.append(dirIterator.fileInfo().absoluteFilePath());
     std::cout << dirIterator.fileInfo().absoluteFilePath().toStdString() << endl;
     m_BatchList = list;
 
     m_IsBatch = true;
     m_IsAborted = false;
 
     if(m_ThreadIsRunning)
     {
       MITK_WARN("QmitkDiffusionRegistrationView")<<"Thread already running!";
       return;
     }
     m_GlobalRegisterer = NULL;
 
     if (m_BatchList.size()<1)
     {
       QMessageBox::information( NULL, "Error", "No diffusion images were found in the selected input folder.");
       return;
     }
 
     m_Controls->m_RegistrationStartButton->setEnabled(false);
     m_Controls->m_StartBatchButton->setEnabled(false);
 
     // start worker thread
     m_RegistrationThread.start(QThread::NormalPriority);
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionRegistrationView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionRegistrationView.h
index e21ca6bb75..1efcb21dff 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionRegistrationView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionRegistrationView.h
@@ -1,135 +1,135 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 
 
 #include <berryISelectionListener.h>
 #include <berryIStructuredSelection.h>
 
 #include <QmitkAbstractView.h>
 #include "ui_QmitkDiffusionRegistrationViewControls.h"
 
-#include "mitkDiffusionImage.h"
+#include <mitkImage.h>
 #include <mitkDWIHeadMotionCorrectionFilter.h>
 
 #include <QThread>
 #include <QTime>
 
 typedef short DiffusionPixelType;
 
 /*!
 \brief View for diffusion image registration / head motion correction
 
 \sa QmitkFunctionality
 \ingroup Functionalities
 */
 
 // Forward Qt class declarations
 
 using namespace std;
 
 class QmitkDiffusionRegistrationView;
 
 class QmitkRegistrationWorker : public QObject
 {
   Q_OBJECT
 
 public:
 
   QmitkRegistrationWorker(QmitkDiffusionRegistrationView* view);
 
   public slots:
 
     void run();
 
 private:
 
   QmitkDiffusionRegistrationView* m_View;
 };
 
 
 class QmitkDiffusionRegistrationView : public QmitkAbstractView
 {
 
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
 
   static const string VIEW_ID;
 
   QmitkDiffusionRegistrationView();
   virtual ~QmitkDiffusionRegistrationView();
 
   virtual void CreateQtPartControl(QWidget *parent);
   void SetFocus();
 
-  typedef mitk::DWIHeadMotionCorrectionFilter< DiffusionPixelType >       DWIHeadMotionCorrectionFilterType;
+  typedef mitk::DWIHeadMotionCorrectionFilter       DWIHeadMotionCorrectionFilterType;
 
 protected slots:
 
     void StartRegistration();
     void StopRegistration();
 
     void AfterThread();                       ///< update gui etc. after registrations has finished
     void BeforeThread();                      ///< start timer etc.
     void TimerUpdate();
 
     void AddInputFolderName();
     void AddOutputFolderName();
     void StartBatch();
 
     void AdvancedSettings();
 
 
 protected:
 
   /// \brief called by QmitkFunctionality when DataManager's selection has changed
   virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>&);
 
   Ui::QmitkDiffusionRegistrationViewControls* m_Controls;
 
-  mitk::DiffusionImage<DiffusionPixelType>::Pointer m_DiffusionImage;
+  mitk::Image::Pointer m_DiffusionImage;
   std::vector< mitk::DataNode::Pointer >            m_SelectedDiffusionNodes;
 
 private:
 
   void UpdateRegistrationStatus();  ///< update textual status display of the Registration process
   void UpdateGUI();             ///< update button activity etc. dpending on current datamanager selection
 
   /** flags etc. */
   bool            m_IsBatch, m_IsAborted;
   QStringList     m_BatchList;
   bool            m_ThreadIsRunning;
   QTimer*         m_RegistrationTimer;
   QTime           m_RegistrationTime;
   unsigned long   m_ElapsedTime;
   unsigned long   m_Steps;
   int             m_LastStep;
   unsigned int    m_CurrentFile;
   unsigned int    m_TotalFiles;
 
   // the Qt parent of our GUI (NOT of this object)
   QWidget* m_Parent;
 
   /** global Registerer and friends */
   itk::SmartPointer<DWIHeadMotionCorrectionFilterType> m_GlobalRegisterer;
   QmitkRegistrationWorker m_RegistrationWorker;
   QThread m_RegistrationThread;
   friend class QmitkRegistrationWorker;
 
 };
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDwiSoftwarePhantomView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDwiSoftwarePhantomView.cpp
index f644ca9fbc..ff342de343 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDwiSoftwarePhantomView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDwiSoftwarePhantomView.cpp
@@ -1,496 +1,499 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // Qmitk
 #include "QmitkDwiSoftwarePhantomView.h"
 
 // MITK
-#include <mitkDiffusionImage.h>
+#include <mitkImage.h>
+#include <mitkDiffusionPropertyHelper.h>
+#include <mitkITKImageImport.h>
 #include <mitkImageToItk.h>
 #include <mitkImageCast.h>
 #include <itkDwiPhantomGenerationFilter.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 const std::string QmitkDwiSoftwarePhantomView::VIEW_ID = "org.mitk.views.dwisoftwarephantomview";
 
 QmitkDwiSoftwarePhantomView::QmitkDwiSoftwarePhantomView()
     : QmitkFunctionality()
     , m_Controls( 0 )
     , m_MultiWidget( NULL )
 {
 
 }
 
 // Destructor
 QmitkDwiSoftwarePhantomView::~QmitkDwiSoftwarePhantomView()
 {
 
 }
 
 
 void QmitkDwiSoftwarePhantomView::CreateQtPartControl( QWidget *parent )
 {
     // build up qt view, unless already done
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkDwiSoftwarePhantomViewControls;
         m_Controls->setupUi( parent );
         m_Controls->m_SignalRegionBox->setVisible(false);
 
         connect((QObject*) m_Controls->m_GeneratePhantomButton, SIGNAL(clicked()), (QObject*) this, SLOT(GeneratePhantom()));
         connect((QObject*) m_Controls->m_SimulateBaseline, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnSimulateBaselineToggle(int)));
     }
 }
 
 QmitkDwiSoftwarePhantomView::GradientListType QmitkDwiSoftwarePhantomView::GenerateHalfShell(int NPoints)
 {
     NPoints *= 2;
     vnl_vector<double> theta; theta.set_size(NPoints);
 
     vnl_vector<double> phi; phi.set_size(NPoints);
 
     double C = sqrt(4*M_PI);
 
     phi(0) = 0.0;
     phi(NPoints-1) = 0.0;
 
     for(int i=0; i<NPoints; i++)
     {
         theta(i) = acos(-1.0+2.0*i/(NPoints-1.0)) - M_PI / 2.0;
         if( i>0 && i<NPoints-1)
         {
             phi(i) = (phi(i-1) + C /
                       sqrt(NPoints*(1-(-1.0+2.0*i/(NPoints-1.0))*(-1.0+2.0*i/(NPoints-1.0)))));
             // % (2*DIST_POINTSHELL_PI);
         }
     }
 
     GradientListType pointshell;
 
     int numB0 = NPoints/10;
     if (numB0==0)
         numB0=1;
     GradientType g;
     g.Fill(0.0);
     for (int i=0; i<numB0; i++)
         pointshell.push_back(g);
 
     for(int i=0; i<NPoints; i++)
     {
         g[2] = sin(theta(i));
         if (g[2]<0)
             continue;
         g[0] = cos(theta(i)) * cos(phi(i));
         g[1] = cos(theta(i)) * sin(phi(i));
         pointshell.push_back(g);
     }
 
     return pointshell;
 }
 
 template<int ndirs>
 std::vector<itk::Vector<double,3> > QmitkDwiSoftwarePhantomView::MakeGradientList()
 {
     std::vector<itk::Vector<double,3> > retval;
     vnl_matrix_fixed<double, 3, ndirs>* U =
             itk::PointShell<ndirs, vnl_matrix_fixed<double, 3, ndirs> >::DistributePointShell();
 
 
     // Add 0 vector for B0
     int numB0 = ndirs/10;
     if (numB0==0)
         numB0=1;
     itk::Vector<double,3> v;
     v.Fill(0.0);
     for (int i=0; i<numB0; i++)
     {
         retval.push_back(v);
     }
 
     for(int i=0; i<ndirs;i++)
     {
         itk::Vector<double,3> v;
         v[0] = U->get(0,i); v[1] = U->get(1,i); v[2] = U->get(2,i);
         retval.push_back(v);
     }
 
     return retval;
 }
 
 void QmitkDwiSoftwarePhantomView::OnSimulateBaselineToggle(int state)
 {
     if (state)
     {
         m_Controls->m_NoiseLabel->setText("Noise Variance:");
         m_Controls->m_NoiseLevel->setValue(1.0/(m_Controls->m_NoiseLevel->value()*m_Controls->m_NoiseLevel->value()));
         m_Controls->m_NoiseLevel->setToolTip("Variance of Rician noise.");
     }
     else
     {
         m_Controls->m_NoiseLabel->setText("SNR:");
         if (m_Controls->m_NoiseLevel->value()>0)
             m_Controls->m_NoiseLevel->setValue(1.0/(sqrt(m_Controls->m_NoiseLevel->value())));
         else
             m_Controls->m_NoiseLevel->setValue(0.0001);
         m_Controls->m_NoiseLevel->setToolTip("Signal to noise ratio (for values > 99, no noise at all is added to the image).");
     }
 }
 
 void QmitkDwiSoftwarePhantomView::GeneratePhantom()
 {
     typedef itk::DwiPhantomGenerationFilter< short > FilterType;
     FilterType::GradientListType gradientList;
 
     m_SignalRegions.clear();
     for (int i=0; i<m_SignalRegionNodes.size(); i++)
     {
         mitk::Image::Pointer mitkBinaryImg = dynamic_cast<mitk::Image*>(m_SignalRegionNodes.at(i)->GetData());
         ItkUcharImgType::Pointer signalRegion = ItkUcharImgType::New();
         mitk::CastToItkImage(mitkBinaryImg, signalRegion);
         m_SignalRegions.push_back(signalRegion);
     }
 
     gradientList = GenerateHalfShell(m_Controls->m_NumGradientsBox->value());
 
     //    switch(m_Controls->m_NumGradientsBox->value())
     //    {
     //    case 0:
     //        gradientList = MakeGradientList<12>();
     //        break;
     //    case 1:
     //        gradientList = MakeGradientList<42>();
     //        break;
     //    case 2:
     //        gradientList = MakeGradientList<92>();
     //        break;
     //    case 3:
     //        gradientList = MakeGradientList<162>();
     //        break;
     //    case 4:
     //        gradientList = MakeGradientList<252>();
     //        break;
     //    case 5:
     //        gradientList = MakeGradientList<362>();
     //        break;
     //    case 6:
     //        gradientList = MakeGradientList<492>();
     //        break;
     //    case 7:
     //        gradientList = MakeGradientList<642>();
     //        break;
     //    case 8:
     //        gradientList = MakeGradientList<812>();
     //        break;
     //    case 9:
     //        gradientList = MakeGradientList<1002>();
     //        break;
     //    default:
     //        gradientList = MakeGradientList<92>();
     //    }
 
     double bVal = m_Controls->m_TensorsToDWIBValueEdit->value();
     itk::ImageRegion<3> imageRegion;
     imageRegion.SetSize(0, m_Controls->m_SizeX->value());
     imageRegion.SetSize(1, m_Controls->m_SizeY->value());
     imageRegion.SetSize(2, m_Controls->m_SizeZ->value());
     mitk::Vector3D spacing;
     spacing[0] = m_Controls->m_SpacingX->value();
     spacing[1] = m_Controls->m_SpacingY->value();
     spacing[2] = m_Controls->m_SpacingZ->value();
 
     FilterType::Pointer filter = FilterType::New();
     filter->SetGradientList(gradientList);
     filter->SetBValue(bVal);
     filter->SetNoiseVariance(m_Controls->m_NoiseLevel->value());
     filter->SetImageRegion(imageRegion);
     filter->SetSpacing(spacing);
     filter->SetSignalRegions(m_SignalRegions);
     filter->SetGreyMatterAdc(m_Controls->m_GmAdc->value());
 
     std::vector< float >                            tensorFA;
     std::vector< float >                            tensorADC;
     std::vector< float >                            tensorWeight;
     std::vector< vnl_vector_fixed<double, 3> >      tensorDirection;
     for (int i=0; i<m_SpinFa.size(); i++)
     {
         tensorFA.push_back(m_SpinFa.at(i)->value());
         tensorADC.push_back(m_SpinAdc.at(i)->value());
         vnl_vector_fixed<double, 3> dir;
         dir[0] = m_SpinX.at(i)->value();
         dir[1] = m_SpinY.at(i)->value();
         dir[2] = m_SpinZ.at(i)->value();
         dir.normalize();
         tensorDirection.push_back(dir);
         tensorWeight.push_back(m_SpinWeight.at(i)->value());
     }
     filter->SetTensorFA(tensorFA);
     filter->SetTensorADC(tensorADC);
     filter->SetTensorWeight(tensorWeight);
     filter->SetTensorDirection(tensorDirection);
     if (!m_Controls->m_SimulateBaseline->isChecked())
         filter->SetSimulateBaseline(false);
     else
         filter->SetSimulateBaseline(true);
     filter->Update();
 
-    mitk::DiffusionImage<short>::Pointer image = mitk::DiffusionImage<short>::New();
-    image->SetVectorImage( filter->GetOutput() );
-    image->SetReferenceBValue(bVal);
-    image->SetDirections(gradientList);
-    image->InitializeFromVectorImage();
+    mitk::Image::Pointer image = mitk::GrabItkImageMemory(filter->GetOutput());
+    image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( gradientList ) );
+    image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( bVal ) );
+    mitk::DiffusionPropertyHelper propertyHelper( image );
+    propertyHelper.InitializeImage();
+
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData( image );
     node->SetName(m_Controls->m_ImageName->text().toStdString());
     GetDataStorage()->Add(node);
 
     mitk::BaseData::Pointer basedata = node->GetData();
     if (basedata.IsNotNull())
     {
         mitk::RenderingManager::GetInstance()->InitializeViews(
                     basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 
     if (m_Controls->m_OutputNumDirectionsBox->isChecked())
     {
         ItkUcharImgType::Pointer numDirImage = filter->GetNumDirectionsImage();
         mitk::Image::Pointer image = mitk::Image::New();
         image->InitializeByItk( numDirImage.GetPointer() );
         image->SetVolume( numDirImage->GetBufferPointer() );
         mitk::DataNode::Pointer node2 = mitk::DataNode::New();
         node2->SetData(image);
         QString name(m_Controls->m_ImageName->text());
         name += "_NumDirections";
         node2->SetName(name.toStdString().c_str());
         GetDataStorage()->Add(node2);
     }
 
     if (m_Controls->m_OutputSnrImageBox->isChecked())
     {
         ItkFloatImgType::Pointer snrImage = filter->GetSNRImage();
         mitk::Image::Pointer image = mitk::Image::New();
         image->InitializeByItk( snrImage.GetPointer() );
         image->SetVolume( snrImage->GetBufferPointer() );
         mitk::DataNode::Pointer node2 = mitk::DataNode::New();
         node2->SetData(image);
         QString name(m_Controls->m_ImageName->text());
         name += "_SNR";
         node2->SetName(name.toStdString().c_str());
         GetDataStorage()->Add(node2);
     }
 
     if (m_SignalRegionNodes.size()==0)
         return;
 
     if (m_Controls->m_OutputDirectionImagesBox->isChecked())
     {
         typedef FilterType::ItkDirectionImageContainer ItkDirectionImageContainer;
         ItkDirectionImageContainer::Pointer container = filter->GetDirectionImageContainer();
         for (int i=0; i<container->Size(); i++)
         {
             FilterType::ItkDirectionImage::Pointer itkImg = container->GetElement(i);
             mitk::Image::Pointer img = mitk::Image::New();
             img->InitializeByItk( itkImg.GetPointer() );
             img->SetVolume( itkImg->GetBufferPointer() );
             mitk::DataNode::Pointer node = mitk::DataNode::New();
             node->SetData(img);
             QString name(m_Controls->m_ImageName->text());
             name += "_Direction";
             name += QString::number(i+1);
             node->SetName(name.toStdString().c_str());
             GetDataStorage()->Add(node);
         }
     }
 
     if (m_Controls->m_OutputVectorFieldBox->isChecked())
     {
         mitk::BaseGeometry::Pointer geometry = image->GetGeometry();
         mitk::Vector3D outImageSpacing = geometry->GetSpacing();
         float minSpacing = 1;
         if(outImageSpacing[0]<outImageSpacing[1] && outImageSpacing[0]<outImageSpacing[2])
             minSpacing = outImageSpacing[0];
         else if (outImageSpacing[1] < outImageSpacing[2])
             minSpacing = outImageSpacing[1];
         else
             minSpacing = outImageSpacing[2];
 
         mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle();
         directions->SetGeometry(geometry);
         mitk::DataNode::Pointer node = mitk::DataNode::New();
         node->SetData(directions);
         QString name(m_Controls->m_ImageName->text());
         name += "_VectorField";
         node->SetName(name.toStdString().c_str());
         node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(minSpacing));
         node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
         GetDataStorage()->Add(node);
     }
 }
 
 void QmitkDwiSoftwarePhantomView::UpdateGui()
 {
     if (!m_SignalRegionNodes.empty())
     {
         m_Controls->m_SignalRegionBox->setVisible(true);
         m_Controls->m_Instruction->setVisible(false);
     }
     else
     {
         m_Controls->m_SignalRegionBox->setVisible(false);
         m_Controls->m_Instruction->setVisible(true);
     }
 
     QLayout* layout = m_Controls->m_SignalRegionBox->layout();
 
     for (int i=0; i<m_Labels.size(); i++)
     {
         delete m_Labels.at(i);
     }
     for (int i=0; i<m_SpinFa.size(); i++)
     {
         delete m_SpinFa.at(i);
         delete m_SpinAdc.at(i);
         delete m_SpinX.at(i);
         delete m_SpinY.at(i);
         delete m_SpinZ.at(i);
         delete m_SpinWeight.at(i);
     }
     m_Labels.clear();
     m_SpinFa.clear();
     m_SpinAdc.clear();
     m_SpinX.clear();
     m_SpinY.clear();
     m_SpinZ.clear();
     m_SpinWeight.clear();
 
     if (layout)
         delete layout;
 
     QGridLayout* newlayout = new QGridLayout();
 
     m_Controls->m_SignalRegionBox->setLayout(newlayout);
 
     if (!m_SignalRegionNodes.empty())
     {
         QLabel* label1 = new QLabel("Image");
         newlayout->addWidget(label1,0,0);
         m_Labels.push_back(label1);
         QLabel* label2 = new QLabel("FA");
         newlayout->addWidget(label2,0,1);
         m_Labels.push_back(label2);
         QLabel* label3 = new QLabel("ADC");
         newlayout->addWidget(label3,0,2);
         m_Labels.push_back(label3);
         QLabel* label4 = new QLabel("X");
         newlayout->addWidget(label4,0,03);
         m_Labels.push_back(label4);
         QLabel* label5 = new QLabel("Y");
         newlayout->addWidget(label5,0,4);
         m_Labels.push_back(label5);
         QLabel* label6 = new QLabel("Z");
         newlayout->addWidget(label6,0,5);
         m_Labels.push_back(label6);
         QLabel* label7 = new QLabel("Weight");
         newlayout->addWidget(label7,0,6);
         m_Labels.push_back(label7);
     }
     for (int i=0; i<m_SignalRegionNodes.size(); i++)
     {
         QLabel* label = new QLabel(m_SignalRegionNodes.at(i)->GetName().c_str());
         newlayout->addWidget(label,i+1,0);
         m_Labels.push_back(label);
 
         QDoubleSpinBox* spinFa = new QDoubleSpinBox();
         spinFa->setValue(0.7);
         spinFa->setMinimum(0);
         spinFa->setMaximum(1);
         spinFa->setSingleStep(0.1);
         newlayout->addWidget(spinFa,i+1,1);
         m_SpinFa.push_back(spinFa);
 
         QDoubleSpinBox* spinAdc = new QDoubleSpinBox();
         newlayout->addWidget(spinAdc,i+1,2);
         spinAdc->setMinimum(0);
         spinAdc->setMaximum(1);
         spinAdc->setSingleStep(0.001);
         spinAdc->setDecimals(3);
         spinAdc->setValue(0.001); ///// ???????????????????????????
         m_SpinAdc.push_back(spinAdc);
 
         QDoubleSpinBox* spinX = new QDoubleSpinBox();
         newlayout->addWidget(spinX,i+1,3);
         spinX->setValue(1);
         spinX->setMinimum(-1);
         spinX->setMaximum(1);
         spinX->setSingleStep(0.1);
         m_SpinX.push_back(spinX);
 
         QDoubleSpinBox* spinY = new QDoubleSpinBox();
         newlayout->addWidget(spinY,i+1,4);
         spinY->setMinimum(-1);
         spinY->setMaximum(1);
         spinY->setSingleStep(0.1);
         m_SpinY.push_back(spinY);
 
         QDoubleSpinBox* spinZ = new QDoubleSpinBox();
         newlayout->addWidget(spinZ,i+1,5);
         spinZ->setMinimum(-1);
         spinZ->setMaximum(1);
         spinZ->setSingleStep(0.1);
         m_SpinZ.push_back(spinZ);
 
         QDoubleSpinBox* spinWeight = new QDoubleSpinBox();
         newlayout->addWidget(spinWeight,i+1,6);
         spinWeight->setMinimum(0);
         spinWeight->setMaximum(1);
         spinWeight->setSingleStep(0.1);
         spinWeight->setValue(1.0);
         m_SpinWeight.push_back(spinWeight);
     }
 }
 
 void QmitkDwiSoftwarePhantomView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
     m_MultiWidget = &stdMultiWidget;
 }
 
 void QmitkDwiSoftwarePhantomView::StdMultiWidgetNotAvailable()
 {
     m_MultiWidget = NULL;
 }
 
 void QmitkDwiSoftwarePhantomView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
     m_SignalRegionNodes.clear();
 
     // iterate all selected objects, adjust warning visibility
     for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
     {
         mitk::DataNode::Pointer node = *it;
 
         if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
         {
             bool isBinary = false;
             node->GetPropertyValue<bool>("binary", isBinary);
             if (isBinary)
                 m_SignalRegionNodes.push_back(node);
         }
     }
     UpdateGui();
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.cpp
index 8e16a7bbd6..f959406314 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.cpp
@@ -1,1471 +1,1470 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkFiberProcessingView.h"
 #include <QmitkStdMultiWidget.h>
 
 // Qt
 #include <QMessageBox>
 
 // MITK
 #include <mitkNodePredicateProperty.h>
 #include <mitkImageCast.h>
 #include <mitkPointSet.h>
 #include <mitkPlanarCircle.h>
 #include <mitkPlanarPolygon.h>
 #include <mitkPlanarRectangle.h>
 #include <mitkPlanarFigureInteractor.h>
 #include <mitkGlobalInteraction.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkDataNodeObject.h>
-#include <mitkDiffusionImage.h>
 #include <mitkTensorImage.h>
 #include "usModuleRegistry.h"
 #include <itkFiberCurvatureFilter.h>
 
 #include "mitkNodePredicateDataType.h"
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateOr.h>
 
 // ITK
 #include <itkResampleImageFilter.h>
 #include <itkGaussianInterpolateImageFunction.h>
 #include <itkImageRegionIteratorWithIndex.h>
 #include <itkTractsToFiberEndingsImageFilter.h>
 #include <itkTractDensityImageFilter.h>
 #include <itkImageRegion.h>
 #include <itkTractsToRgbaImageFilter.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 
 const std::string QmitkFiberProcessingView::VIEW_ID = "org.mitk.views.fiberprocessing";
 const std::string id_DataManager = "org.mitk.views.datamanager";
 using namespace mitk;
 
 QmitkFiberProcessingView::QmitkFiberProcessingView()
     : QmitkFunctionality()
     , m_Controls( 0 )
     , m_MultiWidget( NULL )
     , m_CircleCounter(0)
     , m_PolygonCounter(0)
     , m_UpsamplingFactor(1)
 {
 
 }
 
 // Destructor
 QmitkFiberProcessingView::~QmitkFiberProcessingView()
 {
 
 }
 
 void QmitkFiberProcessingView::CreateQtPartControl( QWidget *parent )
 {
     // build up qt view, unless already done
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkFiberProcessingViewControls;
         m_Controls->setupUi( parent );
 
         connect( m_Controls->m_CircleButton, SIGNAL( clicked() ), this, SLOT( OnDrawCircle() ) );
         connect( m_Controls->m_PolygonButton, SIGNAL( clicked() ), this, SLOT( OnDrawPolygon() ) );
         connect(m_Controls->PFCompoANDButton, SIGNAL(clicked()), this, SLOT(GenerateAndComposite()) );
         connect(m_Controls->PFCompoORButton, SIGNAL(clicked()), this, SLOT(GenerateOrComposite()) );
         connect(m_Controls->PFCompoNOTButton, SIGNAL(clicked()), this, SLOT(GenerateNotComposite()) );
         connect(m_Controls->m_GenerateRoiImage, SIGNAL(clicked()), this, SLOT(GenerateRoiImage()) );
 
         connect(m_Controls->m_JoinBundles, SIGNAL(clicked()), this, SLOT(JoinBundles()) );
         connect(m_Controls->m_SubstractBundles, SIGNAL(clicked()), this, SLOT(SubstractBundles()) );
 
         connect(m_Controls->m_ExtractFibersButton, SIGNAL(clicked()), this, SLOT(Extract()));
         connect(m_Controls->m_RemoveButton, SIGNAL(clicked()), this, SLOT(Remove()));
         connect(m_Controls->m_ModifyButton, SIGNAL(clicked()), this, SLOT(Modify()));
 
         connect(m_Controls->m_ExtractionMethodBox, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateGui()));
         connect(m_Controls->m_RemovalMethodBox, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateGui()));
         connect(m_Controls->m_ModificationMethodBox, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateGui()));
 
         m_Controls->m_ColorMapBox->SetDataStorage(this->GetDataStorage());
         mitk::TNodePredicateDataType<mitk::Image>::Pointer isMitkImage = mitk::TNodePredicateDataType<mitk::Image>::New();
         mitk::NodePredicateDataType::Pointer isDwi = mitk::NodePredicateDataType::New("DiffusionImage");
         mitk::NodePredicateDataType::Pointer isDti = mitk::NodePredicateDataType::New("TensorImage");
         mitk::NodePredicateDataType::Pointer isQbi = mitk::NodePredicateDataType::New("QBallImage");
         mitk::NodePredicateOr::Pointer isDiffusionImage = mitk::NodePredicateOr::New(isDwi, isDti);
         isDiffusionImage = mitk::NodePredicateOr::New(isDiffusionImage, isQbi);
         mitk::NodePredicateNot::Pointer noDiffusionImage = mitk::NodePredicateNot::New(isDiffusionImage);
         mitk::NodePredicateAnd::Pointer finalPredicate = mitk::NodePredicateAnd::New(isMitkImage, noDiffusionImage);
         m_Controls->m_ColorMapBox->SetPredicate(finalPredicate);
     }
 
     UpdateGui();
 }
 
 void QmitkFiberProcessingView::Modify()
 {
     switch (m_Controls->m_ModificationMethodBox->currentIndex())
     {
     case 0:
     {
         ResampleSelectedBundles();
         break;
     }
     case 1:
     {
         CompressSelectedBundles();
         break;
     }
     case 2:
     {
         DoImageColorCoding();
         break;
     }
     case 3:
     {
         MirrorFibers();
         break;
     }
     }
 }
 
 void QmitkFiberProcessingView::Remove()
 {
     switch (m_Controls->m_RemovalMethodBox->currentIndex())
     {
     case 0:
     {
         RemoveDir();
         break;
     }
     case 1:
     {
         PruneBundle();
         break;
     }
     case 2:
     {
         ApplyCurvatureThreshold();
         break;
     }
     case 3:
     {
         RemoveWithMask(false);
         break;
     }
     case 4:
     {
         RemoveWithMask(true);
         break;
     }
     }
 }
 
 void QmitkFiberProcessingView::Extract()
 {
     switch (m_Controls->m_ExtractionMethodBox->currentIndex())
     {
     case 0:
     {
         ExtractWithPlanarFigure();
         break;
     }
     case 1:
     {
         switch (m_Controls->m_ExtractionBoxMask->currentIndex())
         {
         {
         case 0:
             ExtractWithMask(true, false);
             break;
         }
         {
         case 1:
             ExtractWithMask(true, true);
             break;
         }
         {
         case 2:
             ExtractWithMask(false, false);
             break;
         }
         {
         case 3:
             ExtractWithMask(false, true);
             break;
         }
         }
         break;
     }
     }
 }
 
 void QmitkFiberProcessingView::PruneBundle()
 {
     int minLength = this->m_Controls->m_PruneFibersMinBox->value();
     int maxLength = this->m_Controls->m_PruneFibersMaxBox->value();
     for (int i=0; i<m_SelectedFB.size(); i++)
     {
         mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
         if (!fib->RemoveShortFibers(minLength))
             QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
         else if (!fib->RemoveLongFibers(maxLength))
             QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
     }
     RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberProcessingView::ApplyCurvatureThreshold()
 {
     int angle = this->m_Controls->m_CurvSpinBox->value();
     int dist = this->m_Controls->m_CurvDistanceSpinBox->value();
     std::vector< DataNode::Pointer > nodes = m_SelectedFB;
     for (int i=0; i<nodes.size(); i++)
     {
         mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(nodes.at(i)->GetData());
 
         itk::FiberCurvatureFilter::Pointer filter = itk::FiberCurvatureFilter::New();
         filter->SetInputFiberBundle(fib);
         filter->SetAngularDeviation(angle);
         filter->SetDistance(dist);
         filter->SetRemoveFibers(m_Controls->m_RemoveCurvedFibersBox->isChecked());
         filter->Update();
         mitk::FiberBundleX::Pointer newFib = filter->GetOutputFiberBundle();
         if (newFib->GetNumFibers()>0)
         {
             nodes.at(i)->SetVisibility(false);
             DataNode::Pointer newNode = DataNode::New();
             newNode->SetData(newFib);
             newNode->SetName(nodes.at(i)->GetName()+"_Curvature");
             GetDefaultDataStorage()->Add(newNode, nodes.at(i));
         }
         else
             QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
 //        if (!fib->ApplyCurvatureThreshold(mm, this->m_Controls->m_RemoveCurvedFibersBox->isChecked()))
 //            QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
     }
     RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberProcessingView::RemoveDir()
 {
     for (unsigned int i=0; i<m_SelectedFB.size(); i++)
     {
         mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
         vnl_vector_fixed<double,3> dir;
         dir[0] = m_Controls->m_ExtractDirX->value();
         dir[1] = m_Controls->m_ExtractDirY->value();
         dir[2] = m_Controls->m_ExtractDirZ->value();
         fib->RemoveDir(dir,cos((float)m_Controls->m_ExtractAngle->value()*M_PI/180));
     }
     RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberProcessingView::RemoveWithMask(bool removeInside)
 {
     if (m_MaskImageNode.IsNull())
         return;
 
     mitk::Image::Pointer mitkMask = dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData());
     for (unsigned int i=0; i<m_SelectedFB.size(); i++)
     {
         mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
         QString name(m_SelectedFB.at(i)->GetName().c_str());
 
         itkUCharImageType::Pointer mask = itkUCharImageType::New();
         mitk::CastToItkImage(mitkMask, mask);
         mitk::FiberBundleX::Pointer newFib = fib->RemoveFibersOutside(mask, removeInside);
         if (newFib->GetNumFibers()<=0)
         {
             QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
             continue;
         }
         DataNode::Pointer newNode = DataNode::New();
         newNode->SetData(newFib);
         if (removeInside)
             name += "_Inside";
         else
             name += "_Outside";
         newNode->SetName(name.toStdString());
         GetDefaultDataStorage()->Add(newNode);
         m_SelectedFB.at(i)->SetVisibility(false);
     }
 }
 
 void QmitkFiberProcessingView::ExtractWithMask(bool onlyEnds, bool invert)
 {
     if (m_MaskImageNode.IsNull())
         return;
 
     mitk::Image::Pointer mitkMask = dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData());
     for (unsigned int i=0; i<m_SelectedFB.size(); i++)
     {
         mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
         QString name(m_SelectedFB.at(i)->GetName().c_str());
 
         itkUCharImageType::Pointer mask = itkUCharImageType::New();
         mitk::CastToItkImage(mitkMask, mask);
         mitk::FiberBundleX::Pointer newFib = fib->ExtractFiberSubset(mask, onlyEnds, invert);
         if (newFib->GetNumFibers()<=0)
         {
             QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
             continue;
         }
 
         DataNode::Pointer newNode = DataNode::New();
         newNode->SetData(newFib);
 
         if (invert)
         {
             name += "_not";
 
             if (onlyEnds)
                 name += "-ending-in-mask";
             else
                 name += "-passing-mask";
         }
         else
         {
             if (onlyEnds)
                 name += "_ending-in-mask";
             else
                 name += "_passing-mask";
         }
 
         newNode->SetName(name.toStdString());
         GetDefaultDataStorage()->Add(newNode);
         m_SelectedFB.at(i)->SetVisibility(false);
     }
 }
 
 void QmitkFiberProcessingView::GenerateRoiImage()
 {
     if (m_SelectedPF.empty())
         return;
 
     mitk::BaseGeometry::Pointer geometry;
     if (!m_SelectedFB.empty())
     {
         mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.front()->GetData());
         geometry = fib->GetGeometry();
     }
     else if (m_SelectedImage)
         geometry = m_SelectedImage->GetGeometry();
     else
         return;
 
     itk::Vector<double,3> spacing = geometry->GetSpacing();
     spacing /= m_UpsamplingFactor;
 
     mitk::Point3D newOrigin = geometry->GetOrigin();
     mitk::Geometry3D::BoundsArrayType bounds = geometry->GetBounds();
     newOrigin[0] += bounds.GetElement(0);
     newOrigin[1] += bounds.GetElement(2);
     newOrigin[2] += bounds.GetElement(4);
 
     itk::Matrix<double, 3, 3> direction;
     itk::ImageRegion<3> imageRegion;
     for (int i=0; i<3; i++)
         for (int j=0; j<3; j++)
             direction[j][i] = geometry->GetMatrixColumn(i)[j]/spacing[j];
     imageRegion.SetSize(0, geometry->GetExtent(0)*m_UpsamplingFactor);
     imageRegion.SetSize(1, geometry->GetExtent(1)*m_UpsamplingFactor);
     imageRegion.SetSize(2, geometry->GetExtent(2)*m_UpsamplingFactor);
 
     m_PlanarFigureImage = itkUCharImageType::New();
     m_PlanarFigureImage->SetSpacing( spacing );   // Set the image spacing
     m_PlanarFigureImage->SetOrigin( newOrigin );     // Set the image origin
     m_PlanarFigureImage->SetDirection( direction );  // Set the image direction
     m_PlanarFigureImage->SetRegions( imageRegion );
     m_PlanarFigureImage->Allocate();
     m_PlanarFigureImage->FillBuffer( 0 );
 
     Image::Pointer tmpImage = Image::New();
     tmpImage->InitializeByItk(m_PlanarFigureImage.GetPointer());
     tmpImage->SetVolume(m_PlanarFigureImage->GetBufferPointer());
 
     std::string name = m_SelectedPF.at(0)->GetName();
     WritePfToImage(m_SelectedPF.at(0), tmpImage);
     for (unsigned int i=1; i<m_SelectedPF.size(); i++)
     {
         name += "+";
         name += m_SelectedPF.at(i)->GetName();
         WritePfToImage(m_SelectedPF.at(i), tmpImage);
     }
 
     DataNode::Pointer node = DataNode::New();
     tmpImage = Image::New();
     tmpImage->InitializeByItk(m_PlanarFigureImage.GetPointer());
     tmpImage->SetVolume(m_PlanarFigureImage->GetBufferPointer());
     node->SetData(tmpImage);
     node->SetName(name);
     this->GetDefaultDataStorage()->Add(node);
 }
 
 void QmitkFiberProcessingView::WritePfToImage(mitk::DataNode::Pointer node, mitk::Image* image)
 {
     if (dynamic_cast<mitk::PlanarFigure*>(node->GetData()))
     {
         m_PlanarFigure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
         AccessFixedDimensionByItk_2(
                     image,
                     InternalReorientImagePlane, 3,
                     m_PlanarFigure->GetGeometry(), -1);
 
         AccessFixedDimensionByItk_2(
                     m_InternalImage,
                     InternalCalculateMaskFromPlanarFigure,
                     3, 2, node->GetName() );
     }
     else if (dynamic_cast<mitk::PlanarFigureComposite*>(node->GetData()))
     {
         mitk::PlanarFigureComposite* pfc = dynamic_cast<mitk::PlanarFigureComposite*>(node->GetData());
         for (int j=0; j<pfc->getNumberOfChildren(); j++)
         {
             WritePfToImage(pfc->getDataNodeAt(j), image);
         }
     }
 }
 
 template < typename TPixel, unsigned int VImageDimension >
 void QmitkFiberProcessingView::InternalReorientImagePlane( const itk::Image< TPixel, VImageDimension > *image, mitk::BaseGeometry* planegeo3D, int additionalIndex )
 {
     typedef itk::Image< TPixel, VImageDimension > ImageType;
     typedef itk::Image< float, VImageDimension > FloatImageType;
 
     typedef itk::ResampleImageFilter<ImageType, FloatImageType, double> ResamplerType;
     typename ResamplerType::Pointer resampler = ResamplerType::New();
 
     mitk::PlaneGeometry* planegeo = dynamic_cast<mitk::PlaneGeometry*>(planegeo3D);
 
     float upsamp = m_UpsamplingFactor;
     float gausssigma = 0.5;
 
     // Spacing
     typename ResamplerType::SpacingType spacing = planegeo->GetSpacing();
     spacing[0] = image->GetSpacing()[0] / upsamp;
     spacing[1] = image->GetSpacing()[1] / upsamp;
     spacing[2] = image->GetSpacing()[2];
     resampler->SetOutputSpacing( spacing );
 
     // Size
     typename ResamplerType::SizeType size;
     size[0] = planegeo->GetExtentInMM(0) / spacing[0];
     size[1] = planegeo->GetExtentInMM(1) / spacing[1];
     size[2] = 1;
     resampler->SetSize( size );
 
     // Origin
     typename mitk::Point3D orig = planegeo->GetOrigin();
     typename mitk::Point3D corrorig;
     planegeo3D->WorldToIndex(orig,corrorig);
     corrorig[0] += 0.5/upsamp;
     corrorig[1] += 0.5/upsamp;
     corrorig[2] += 0;
     planegeo3D->IndexToWorld(corrorig,corrorig);
     resampler->SetOutputOrigin(corrorig );
 
     // Direction
     typename ResamplerType::DirectionType direction;
     typename mitk::AffineTransform3D::MatrixType matrix = planegeo->GetIndexToWorldTransform()->GetMatrix();
     for(int c=0; c<matrix.ColumnDimensions; c++)
     {
         double sum = 0;
         for(int r=0; r<matrix.RowDimensions; r++)
             sum += matrix(r,c)*matrix(r,c);
         for(int r=0; r<matrix.RowDimensions; r++)
             direction(r,c) = matrix(r,c)/sqrt(sum);
     }
     resampler->SetOutputDirection( direction );
 
     // Gaussian interpolation
     if(gausssigma != 0)
     {
         double sigma[3];
         for( unsigned int d = 0; d < 3; d++ )
             sigma[d] = gausssigma * image->GetSpacing()[d];
         double alpha = 2.0;
         typedef itk::GaussianInterpolateImageFunction<ImageType, double> GaussianInterpolatorType;
         typename GaussianInterpolatorType::Pointer interpolator = GaussianInterpolatorType::New();
         interpolator->SetInputImage( image );
         interpolator->SetParameters( sigma, alpha );
         resampler->SetInterpolator( interpolator );
     }
     else
     {
         typedef typename itk::LinearInterpolateImageFunction<ImageType, double> InterpolatorType;
         typename InterpolatorType::Pointer interpolator = InterpolatorType::New();
         interpolator->SetInputImage( image );
         resampler->SetInterpolator( interpolator );
     }
 
     resampler->SetInput( image );
     resampler->SetDefaultPixelValue(0);
     resampler->Update();
 
     if(additionalIndex < 0)
     {
         this->m_InternalImage = mitk::Image::New();
         this->m_InternalImage->InitializeByItk( resampler->GetOutput() );
         this->m_InternalImage->SetVolume( resampler->GetOutput()->GetBufferPointer() );
     }
 }
 
 template < typename TPixel, unsigned int VImageDimension >
 void QmitkFiberProcessingView::InternalCalculateMaskFromPlanarFigure( itk::Image< TPixel, VImageDimension > *image, unsigned int axis, std::string )
 {
     typedef itk::Image< TPixel, VImageDimension > ImageType;
     typedef itk::CastImageFilter< ImageType, itkUCharImageType > CastFilterType;
 
     // Generate mask image as new image with same header as input image and
     // initialize with "1".
     itkUCharImageType::Pointer newMaskImage = itkUCharImageType::New();
     newMaskImage->SetSpacing( image->GetSpacing() );   // Set the image spacing
     newMaskImage->SetOrigin( image->GetOrigin() );     // Set the image origin
     newMaskImage->SetDirection( image->GetDirection() );  // Set the image direction
     newMaskImage->SetRegions( image->GetLargestPossibleRegion() );
     newMaskImage->Allocate();
     newMaskImage->FillBuffer( 1 );
 
     // Generate VTK polygon from (closed) PlanarFigure polyline
     // (The polyline points are shifted by -0.5 in z-direction to make sure
     // that the extrusion filter, which afterwards elevates all points by +0.5
     // in z-direction, creates a 3D object which is cut by the the plane z=0)
     const PlaneGeometry *planarFigurePlaneGeometry = m_PlanarFigure->GetPlaneGeometry();
     const PlanarFigure::PolyLineType planarFigurePolyline = m_PlanarFigure->GetPolyLine( 0 );
     const BaseGeometry *imageGeometry3D = m_InternalImage->GetGeometry( 0 );
 
     vtkPolyData *polyline = vtkPolyData::New();
     polyline->Allocate( 1, 1 );
 
     // Determine x- and y-dimensions depending on principal axis
     int i0, i1;
     switch ( axis )
     {
     case 0:
         i0 = 1;
         i1 = 2;
         break;
     case 1:
         i0 = 0;
         i1 = 2;
         break;
     case 2:
     default:
         i0 = 0;
         i1 = 1;
         break;
     }
 
     // Create VTK polydata object of polyline contour
     vtkPoints *points = vtkPoints::New();
     PlanarFigure::PolyLineType::const_iterator it;
     unsigned int numberOfPoints = 0;
 
     for ( it = planarFigurePolyline.begin(); it != planarFigurePolyline.end(); ++it )
     {
         Point3D point3D;
 
         // Convert 2D point back to the local index coordinates of the selected image
         Point2D point2D = *it;
         planarFigurePlaneGeometry->WorldToIndex(point2D, point2D);
         point2D[0] -= 0.5/m_UpsamplingFactor;
         point2D[1] -= 0.5/m_UpsamplingFactor;
         planarFigurePlaneGeometry->IndexToWorld(point2D, point2D);
         planarFigurePlaneGeometry->Map( point2D, point3D );
 
         // Polygons (partially) outside of the image bounds can not be processed further due to a bug in vtkPolyDataToImageStencil
         if ( !imageGeometry3D->IsInside( point3D ) )
         {
             float bounds[2] = {0,0};
             bounds[0] =
                     this->m_InternalImage->GetLargestPossibleRegion().GetSize().GetElement(i0);
             bounds[1] =
                     this->m_InternalImage->GetLargestPossibleRegion().GetSize().GetElement(i1);
 
             imageGeometry3D->WorldToIndex( point3D, point3D );
 
             if (point3D[i0]<0)
                 point3D[i0] = 0.0;
             else if (point3D[i0]>bounds[0])
                 point3D[i0] = bounds[0]-0.001;
 
             if (point3D[i1]<0)
                 point3D[i1] = 0.0;
             else if (point3D[i1]>bounds[1])
                 point3D[i1] = bounds[1]-0.001;
 
             points->InsertNextPoint( point3D[i0], point3D[i1], -0.5 );
             numberOfPoints++;
         }
         else
         {
             imageGeometry3D->WorldToIndex( point3D, point3D );
             // Add point to polyline array
             points->InsertNextPoint( point3D[i0], point3D[i1], -0.5 );
             numberOfPoints++;
         }
     }
     polyline->SetPoints( points );
     points->Delete();
 
     vtkIdType *ptIds = new vtkIdType[numberOfPoints];
     for ( vtkIdType i = 0; i < numberOfPoints; ++i )
         ptIds[i] = i;
     polyline->InsertNextCell( VTK_POLY_LINE, numberOfPoints, ptIds );
 
     // Extrude the generated contour polygon
     vtkLinearExtrusionFilter *extrudeFilter = vtkLinearExtrusionFilter::New();
     extrudeFilter->SetInputData( polyline );
     extrudeFilter->SetScaleFactor( 1 );
     extrudeFilter->SetExtrusionTypeToNormalExtrusion();
     extrudeFilter->SetVector( 0.0, 0.0, 1.0 );
 
     // Make a stencil from the extruded polygon
     vtkPolyDataToImageStencil *polyDataToImageStencil = vtkPolyDataToImageStencil::New();
     polyDataToImageStencil->SetInputConnection( extrudeFilter->GetOutputPort() );
 
     // Export from ITK to VTK (to use a VTK filter)
     typedef itk::VTKImageImport< itkUCharImageType > ImageImportType;
     typedef itk::VTKImageExport< itkUCharImageType > ImageExportType;
 
     typename ImageExportType::Pointer itkExporter = ImageExportType::New();
     itkExporter->SetInput( newMaskImage );
 
     vtkImageImport *vtkImporter = vtkImageImport::New();
     this->ConnectPipelines( itkExporter, vtkImporter );
     vtkImporter->Update();
 
     // Apply the generated image stencil to the input image
     vtkImageStencil *imageStencilFilter = vtkImageStencil::New();
     imageStencilFilter->SetInputConnection( vtkImporter->GetOutputPort() );
     imageStencilFilter->SetStencilConnection(polyDataToImageStencil->GetOutputPort() );
     imageStencilFilter->ReverseStencilOff();
     imageStencilFilter->SetBackgroundValue( 0 );
     imageStencilFilter->Update();
 
     // Export from VTK back to ITK
     vtkImageExport *vtkExporter = vtkImageExport::New();
     vtkExporter->SetInputConnection( imageStencilFilter->GetOutputPort() );
     vtkExporter->Update();
 
     typename ImageImportType::Pointer itkImporter = ImageImportType::New();
     this->ConnectPipelines( vtkExporter, itkImporter );
     itkImporter->Update();
 
     // calculate cropping bounding box
     m_InternalImageMask3D = itkImporter->GetOutput();
     m_InternalImageMask3D->SetDirection(image->GetDirection());
 
     itk::ImageRegionConstIterator<itkUCharImageType>
             itmask(m_InternalImageMask3D, m_InternalImageMask3D->GetLargestPossibleRegion());
     itk::ImageRegionIterator<ImageType>
             itimage(image, image->GetLargestPossibleRegion());
 
     itmask.GoToBegin();
     itimage.GoToBegin();
 
     typename ImageType::SizeType lowersize = {{9999999999,9999999999,9999999999}};
     typename ImageType::SizeType uppersize = {{0,0,0}};
     while( !itmask.IsAtEnd() )
     {
         if(itmask.Get() == 0)
             itimage.Set(0);
         else
         {
             typename ImageType::IndexType index = itimage.GetIndex();
             typename ImageType::SizeType signedindex;
             signedindex[0] = index[0];
             signedindex[1] = index[1];
             signedindex[2] = index[2];
 
             lowersize[0] = signedindex[0] < lowersize[0] ? signedindex[0] : lowersize[0];
             lowersize[1] = signedindex[1] < lowersize[1] ? signedindex[1] : lowersize[1];
             lowersize[2] = signedindex[2] < lowersize[2] ? signedindex[2] : lowersize[2];
 
             uppersize[0] = signedindex[0] > uppersize[0] ? signedindex[0] : uppersize[0];
             uppersize[1] = signedindex[1] > uppersize[1] ? signedindex[1] : uppersize[1];
             uppersize[2] = signedindex[2] > uppersize[2] ? signedindex[2] : uppersize[2];
         }
 
         ++itmask;
         ++itimage;
     }
 
     typename ImageType::IndexType index;
     index[0] = lowersize[0];
     index[1] = lowersize[1];
     index[2] = lowersize[2];
 
     typename ImageType::SizeType size;
     size[0] = uppersize[0] - lowersize[0] + 1;
     size[1] = uppersize[1] - lowersize[1] + 1;
     size[2] = uppersize[2] - lowersize[2] + 1;
 
     itk::ImageRegion<3> cropRegion = itk::ImageRegion<3>(index, size);
 
     // crop internal mask
     typedef itk::RegionOfInterestImageFilter< itkUCharImageType, itkUCharImageType > ROIMaskFilterType;
     typename ROIMaskFilterType::Pointer roi2 = ROIMaskFilterType::New();
     roi2->SetRegionOfInterest(cropRegion);
     roi2->SetInput(m_InternalImageMask3D);
     roi2->Update();
     m_InternalImageMask3D = roi2->GetOutput();
 
     Image::Pointer tmpImage = Image::New();
     tmpImage->InitializeByItk(m_InternalImageMask3D.GetPointer());
     tmpImage->SetVolume(m_InternalImageMask3D->GetBufferPointer());
 
     Image::Pointer tmpImage2 = Image::New();
     tmpImage2->InitializeByItk(m_PlanarFigureImage.GetPointer());
     const BaseGeometry *pfImageGeometry3D = tmpImage2->GetGeometry( 0 );
 
     const BaseGeometry *intImageGeometry3D = tmpImage->GetGeometry( 0 );
 
     typedef itk::ImageRegionIteratorWithIndex<itkUCharImageType> IteratorType;
     IteratorType imageIterator (m_InternalImageMask3D, m_InternalImageMask3D->GetRequestedRegion());
     imageIterator.GoToBegin();
     while ( !imageIterator.IsAtEnd() )
     {
         unsigned char val = imageIterator.Value();
         if (val>0)
         {
             itk::Index<3> index = imageIterator.GetIndex();
             Point3D point;
             point[0] = index[0];
             point[1] = index[1];
             point[2] = index[2];
 
             intImageGeometry3D->IndexToWorld(point, point);
             pfImageGeometry3D->WorldToIndex(point, point);
 
             point[i0] += 0.5;
             point[i1] += 0.5;
 
             index[0] = point[0];
             index[1] = point[1];
             index[2] = point[2];
 
             if (pfImageGeometry3D->IsIndexInside(index))
                 m_PlanarFigureImage->SetPixel(index, 1);
         }
         ++imageIterator;
     }
 
     // Clean up VTK objects
     polyline->Delete();
     extrudeFilter->Delete();
     polyDataToImageStencil->Delete();
     vtkImporter->Delete();
     imageStencilFilter->Delete();
     //vtkExporter->Delete(); // TODO: crashes when outcommented; memory leak??
     delete[] ptIds;
 }
 
 void QmitkFiberProcessingView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
     m_MultiWidget = &stdMultiWidget;
 }
 
 void QmitkFiberProcessingView::StdMultiWidgetNotAvailable()
 {
     m_MultiWidget = NULL;
 }
 
 void QmitkFiberProcessingView::UpdateGui()
 {
     m_Controls->m_FibLabel->setText("<font color='red'>mandatory</font>");
     m_Controls->m_PfLabel->setText("<font color='grey'>needed for extraction</font>");
     m_Controls->m_InputData->setTitle("Please Select Input Data");
 
     m_Controls->m_RemoveButton->setEnabled(false);
 
     m_Controls->m_PlanarFigureButtonsFrame->setEnabled(false);
     m_Controls->PFCompoANDButton->setEnabled(false);
     m_Controls->PFCompoORButton->setEnabled(false);
     m_Controls->PFCompoNOTButton->setEnabled(false);
 
     m_Controls->m_GenerateRoiImage->setEnabled(false);
     m_Controls->m_ExtractFibersButton->setEnabled(false);
     m_Controls->m_ModifyButton->setEnabled(false);
 
     m_Controls->m_JoinBundles->setEnabled(false);
     m_Controls->m_SubstractBundles->setEnabled(false);
 
     // disable alle frames
     m_Controls->m_ExtractionBoxMask->setVisible(false);
     m_Controls->m_ExtactionFramePF->setVisible(false);
     m_Controls->m_RemoveDirectionFrame->setVisible(false);
     m_Controls->m_RemoveLengthFrame->setVisible(false);
     m_Controls->m_RemoveCurvatureFrame->setVisible(false);
     m_Controls->m_SmoothFibersFrame->setVisible(false);
     m_Controls->m_CompressFibersFrame->setVisible(false);
     m_Controls->m_ColorFibersFrame->setVisible(false);
     m_Controls->m_MirrorFibersFrame->setVisible(false);
 
     bool pfSelected = !m_SelectedPF.empty();
     bool fibSelected = !m_SelectedFB.empty();
     bool multipleFibsSelected = (m_SelectedFB.size()>1);
     bool maskSelected = m_MaskImageNode.IsNotNull();
     bool imageSelected = m_SelectedImage.IsNotNull();
 
     // toggle visibility of elements according to selected method
     switch ( m_Controls->m_ExtractionMethodBox->currentIndex() )
     {
     case 0:
         m_Controls->m_ExtactionFramePF->setVisible(true);
         break;
     case 1:
         m_Controls->m_ExtractionBoxMask->setVisible(true);
         break;
     }
 
     switch ( m_Controls->m_RemovalMethodBox->currentIndex() )
     {
     case 0:
         m_Controls->m_RemoveDirectionFrame->setVisible(true);
         if ( fibSelected )
             m_Controls->m_RemoveButton->setEnabled(true);
         break;
     case 1:
         m_Controls->m_RemoveLengthFrame->setVisible(true);
         if ( fibSelected )
             m_Controls->m_RemoveButton->setEnabled(true);
         break;
     case 2:
         m_Controls->m_RemoveCurvatureFrame->setVisible(true);
         if ( fibSelected )
             m_Controls->m_RemoveButton->setEnabled(true);
         break;
     case 3:
         break;
     case 4:
         break;
     }
 
     switch ( m_Controls->m_ModificationMethodBox->currentIndex() )
     {
     case 0:
         m_Controls->m_SmoothFibersFrame->setVisible(true);
         break;
     case 1:
         m_Controls->m_CompressFibersFrame->setVisible(true);
         break;
     case 2:
         m_Controls->m_ColorFibersFrame->setVisible(true);
         break;
     case 3:
         m_Controls->m_MirrorFibersFrame->setVisible(true);
         break;
     }
 
     // are fiber bundles selected?
     if ( fibSelected )
     {
         m_Controls->m_ModifyButton->setEnabled(true);
         m_Controls->m_PlanarFigureButtonsFrame->setEnabled(true);
         m_Controls->m_FibLabel->setText(QString(m_SelectedFB.at(0)->GetName().c_str()));
 
         // one bundle and one planar figure needed to extract fibers
         if (pfSelected)
         {
             m_Controls->m_InputData->setTitle("Input Data");
             m_Controls->m_PfLabel->setText(QString(m_SelectedPF.at(0)->GetName().c_str()));
             m_Controls->m_ExtractFibersButton->setEnabled(true);
         }
 
         // more than two bundles needed to join/subtract
         if (multipleFibsSelected)
         {
             m_Controls->m_FibLabel->setText("multiple bundles selected");
 
             m_Controls->m_JoinBundles->setEnabled(true);
             m_Controls->m_SubstractBundles->setEnabled(true);
         }
 
         if (maskSelected)
         {
             m_Controls->m_RemoveButton->setEnabled(true);
             m_Controls->m_ExtractFibersButton->setEnabled(true);
         }
     }
 
     // are planar figures selected?
     if (pfSelected)
     {
         if ( fibSelected || m_SelectedImage.IsNotNull())
             m_Controls->m_GenerateRoiImage->setEnabled(true);
 
         if (m_SelectedPF.size() > 1)
         {
             m_Controls->PFCompoANDButton->setEnabled(true);
             m_Controls->PFCompoORButton->setEnabled(true);
         }
         else
             m_Controls->PFCompoNOTButton->setEnabled(true);
     }
 
     // is image selected
     if (imageSelected || maskSelected)
     {
         m_Controls->m_PlanarFigureButtonsFrame->setEnabled(true);
     }
 }
 
 void QmitkFiberProcessingView::NodeRemoved(const mitk::DataNode* node)
 {
     std::vector<mitk::DataNode*> nodes;
     OnSelectionChanged(nodes);
 }
 
 void QmitkFiberProcessingView::NodeAdded(const mitk::DataNode* node)
 {
     std::vector<mitk::DataNode*> nodes;
     OnSelectionChanged(nodes);
 }
 
 void QmitkFiberProcessingView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
     //reset existing Vectors containing FiberBundles and PlanarFigures from a previous selection
     m_SelectedFB.clear();
     m_SelectedPF.clear();
     m_SelectedSurfaces.clear();
     m_SelectedImage = NULL;
     m_MaskImageNode = NULL;
 
     for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
     {
         mitk::DataNode::Pointer node = *it;
         if ( dynamic_cast<mitk::FiberBundleX*>(node->GetData()) )
             m_SelectedFB.push_back(node);
         else if (dynamic_cast<mitk::PlanarPolygon*>(node->GetData()) || dynamic_cast<mitk::PlanarFigureComposite*>(node->GetData()) || dynamic_cast<mitk::PlanarCircle*>(node->GetData()))
             m_SelectedPF.push_back(node);
         else if (dynamic_cast<mitk::Image*>(node->GetData()))
         {
             m_SelectedImage = dynamic_cast<mitk::Image*>(node->GetData());
             bool isBinary = false;
             node->GetPropertyValue<bool>("binary", isBinary);
             if (isBinary)
                 m_MaskImageNode = node;
         }
         else if (dynamic_cast<mitk::Surface*>(node->GetData()))
             m_SelectedSurfaces.push_back(dynamic_cast<mitk::Surface*>(node->GetData()));
     }
 
     if (m_SelectedFB.empty())
     {
         int maxLayer = 0;
         itk::VectorContainer<unsigned int, mitk::DataNode::Pointer>::ConstPointer nodes = this->GetDefaultDataStorage()->GetAll();
         for (unsigned int i=0; i<nodes->Size(); i++)
             if (dynamic_cast<mitk::FiberBundleX*>(nodes->at(i)->GetData()))
             {
                 mitk::DataStorage::SetOfObjects::ConstPointer sources = GetDataStorage()->GetSources(nodes->at(i));
                 if (sources->Size()>0)
                     continue;
 
                 int layer = 0;
                 nodes->at(i)->GetPropertyValue("layer", layer);
                 if (layer>=maxLayer)
                 {
                     maxLayer = layer;
                     m_SelectedFB.clear();
                     m_SelectedFB.push_back(nodes->at(i));
                 }
             }
     }
 
     if (m_SelectedPF.empty())
     {
         int maxLayer = 0;
         itk::VectorContainer<unsigned int, mitk::DataNode::Pointer>::ConstPointer nodes = this->GetDefaultDataStorage()->GetAll();
         for (unsigned int i=0; i<nodes->Size(); i++)
             if (dynamic_cast<mitk::PlanarPolygon*>(nodes->at(i)->GetData()) || dynamic_cast<mitk::PlanarFigureComposite*>(nodes->at(i)->GetData()) || dynamic_cast<mitk::PlanarCircle*>(nodes->at(i)->GetData()))
             {
                 mitk::DataStorage::SetOfObjects::ConstPointer sources = GetDataStorage()->GetSources(nodes->at(i));
                 if (sources->Size()>0)
                     continue;
 
                 int layer = 0;
                 nodes->at(i)->GetPropertyValue("layer", layer);
                 if (layer>=maxLayer)
                 {
                     maxLayer = layer;
                     m_SelectedPF.clear();
                     m_SelectedPF.push_back(nodes->at(i));
                 }
             }
     }
 
     UpdateGui();
 }
 
 void QmitkFiberProcessingView::OnDrawPolygon()
 {
     mitk::PlanarPolygon::Pointer figure = mitk::PlanarPolygon::New();
     figure->ClosedOn();
     this->AddFigureToDataStorage(figure, QString("Polygon%1").arg(++m_PolygonCounter));
 }
 
 void QmitkFiberProcessingView::OnDrawCircle()
 {
     mitk::PlanarCircle::Pointer figure = mitk::PlanarCircle::New();
     this->AddFigureToDataStorage(figure, QString("Circle%1").arg(++m_CircleCounter));
 }
 
 void QmitkFiberProcessingView::Activated()
 {
 
 }
 
 void QmitkFiberProcessingView::AddFigureToDataStorage(mitk::PlanarFigure* figure, const QString& name, const char *, mitk::BaseProperty* )
 {
     // initialize figure's geometry with empty geometry
     mitk::PlaneGeometry::Pointer emptygeometry = mitk::PlaneGeometry::New();
     figure->SetPlaneGeometry( emptygeometry );
 
     //set desired data to DataNode where Planarfigure is stored
     mitk::DataNode::Pointer newNode = mitk::DataNode::New();
     newNode->SetName(name.toStdString());
     newNode->SetData(figure);
     newNode->SetBoolProperty("planarfigure.3drendering", true);
 
     mitk::PlanarFigureInteractor::Pointer figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(newNode->GetDataInteractor().GetPointer());
     if(figureInteractor.IsNull())
     {
         figureInteractor = mitk::PlanarFigureInteractor::New();
         us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "MitkPlanarFigure" );
         figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
         figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
         figureInteractor->SetDataNode(newNode);
     }
 
     // figure drawn on the topmost layer / image
     GetDataStorage()->Add(newNode );
 
     for(unsigned int i = 0; i < m_SelectedPF.size(); i++)
         m_SelectedPF[i]->SetSelected(false);
 
     newNode->SetSelected(true);
     m_SelectedPF.clear();
     m_SelectedPF.push_back(newNode);
     UpdateGui();
 }
 
 void QmitkFiberProcessingView::ExtractWithPlanarFigure()
 {
     if ( m_SelectedFB.empty() || m_SelectedPF.empty() ){
         QMessageBox::information( NULL, "Warning", "No fibe bundle selected!");
         return;
     }
 
     std::vector<mitk::DataNode::Pointer> fiberBundles = m_SelectedFB;
     mitk::DataNode::Pointer planarFigure = m_SelectedPF.at(0);
     for (unsigned int i=0; i<fiberBundles.size(); i++)
     {
         mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(fiberBundles.at(i)->GetData());
         mitk::BaseData::Pointer roi = planarFigure->GetData();
 
         mitk::FiberBundleX::Pointer extFB = fib->ExtractFiberSubset(roi);
         if (extFB->GetNumFibers()<=0)
         {
             QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
             continue;
         }
 
         mitk::DataNode::Pointer node;
         node = mitk::DataNode::New();
         node->SetData(extFB);
         QString name(fiberBundles.at(i)->GetName().c_str());
         name += "_";
         name += planarFigure->GetName().c_str();
         node->SetName(name.toStdString());
         fiberBundles.at(i)->SetVisibility(false);
         GetDataStorage()->Add(node);
     }
 }
 
 void QmitkFiberProcessingView::GenerateAndComposite()
 {
     mitk::PlanarFigureComposite::Pointer PFCAnd = mitk::PlanarFigureComposite::New();
     PFCAnd->setOperationType(mitk::PFCOMPOSITION_AND_OPERATION);
     for( std::vector<mitk::DataNode::Pointer>::iterator it = m_SelectedPF.begin(); it != m_SelectedPF.end(); ++it )
     {
         mitk::DataNode::Pointer nodePF = *it;
         PFCAnd->addPlanarFigure( nodePF->GetData() );
         PFCAnd->addDataNode( nodePF );
         PFCAnd->setDisplayName("AND");
     }
     AddCompositeToDatastorage(PFCAnd);
 }
 
 void QmitkFiberProcessingView::GenerateOrComposite()
 {
     mitk::PlanarFigureComposite::Pointer PFCOr = mitk::PlanarFigureComposite::New();
     PFCOr->setOperationType(mitk::PFCOMPOSITION_OR_OPERATION);
     for( std::vector<mitk::DataNode::Pointer>::iterator it = m_SelectedPF.begin(); it != m_SelectedPF.end(); ++it )
     {
         mitk::DataNode::Pointer nodePF = *it;
         PFCOr->addPlanarFigure( nodePF->GetData() );
         PFCOr->addDataNode( nodePF );
         PFCOr->setDisplayName("OR");
     }
     AddCompositeToDatastorage(PFCOr);
 }
 
 void QmitkFiberProcessingView::GenerateNotComposite()
 {
     mitk::PlanarFigureComposite::Pointer PFCNot = mitk::PlanarFigureComposite::New();
     PFCNot->setOperationType(mitk::PFCOMPOSITION_NOT_OPERATION);
     for( std::vector<mitk::DataNode::Pointer>::iterator it = m_SelectedPF.begin(); it != m_SelectedPF.end(); ++it )
     {
         mitk::DataNode::Pointer nodePF = *it;
         PFCNot->addPlanarFigure( nodePF->GetData() );
         PFCNot->addDataNode( nodePF );
         PFCNot->setDisplayName("NOT");
     }
     AddCompositeToDatastorage(PFCNot);
 }
 
 /* CLEANUP NEEDED */
 void QmitkFiberProcessingView::AddCompositeToDatastorage(mitk::PlanarFigureComposite::Pointer pfc, mitk::DataNode::Pointer parentNode )
 {
     mitk::DataNode::Pointer newPFCNode;
     newPFCNode = mitk::DataNode::New();
     newPFCNode->SetName( pfc->getDisplayName() );
     newPFCNode->SetData(pfc);
 
     switch (pfc->getOperationType()) {
     case 0:
     {
         if (parentNode.IsNotNull())
             GetDataStorage()->Add(newPFCNode, parentNode);
         else
             GetDataStorage()->Add(newPFCNode);
 
         //iterate through its childs
         for(int i=0; i<pfc->getNumberOfChildren(); ++i)
         {
             mitk::BaseData::Pointer tmpPFchild = pfc->getChildAt(i);
             mitk::DataNode::Pointer savedPFchildNode = pfc->getDataNodeAt(i);
 
             mitk::PlanarFigureComposite::Pointer pfcompcast= dynamic_cast<mitk::PlanarFigureComposite*>(tmpPFchild.GetPointer());
             if ( pfcompcast.IsNotNull() )
             {
                 // child is of type planar Figure composite
                 // make new node of the child, cuz later the child has to be removed of its old position in datamanager
                 // feed new dataNode with information of the savedDataNode, which is gonna be removed soon
                 mitk::DataNode::Pointer newChildPFCNode;
                 newChildPFCNode = mitk::DataNode::New();
                 newChildPFCNode->SetData(tmpPFchild);
                 newChildPFCNode->SetName( savedPFchildNode->GetName() );
                 pfcompcast->setDisplayName(  savedPFchildNode->GetName()  ); //name might be changed in DataManager by user
 
                 //update inside vector the dataNodePointer
                 pfc->replaceDataNodeAt(i, newChildPFCNode);
 
                 AddCompositeToDatastorage(pfcompcast, newPFCNode); //the current PFCNode becomes the childs parent
 
                 // remove savedNode here, cuz otherwise its children will change their position in the dataNodeManager
                 // without having its parent anymore
                 GetDataStorage()->Remove(savedPFchildNode);
             }
             else
             {
                 // child is not of type PlanarFigureComposite, so its one of the planarFigures
                 // create new dataNode containing the data of the old dataNode, but position in dataManager will be
                 // modified cuz we re setting a (new) parent.
                 mitk::DataNode::Pointer newPFchildNode = mitk::DataNode::New();
                 newPFchildNode->SetName(savedPFchildNode->GetName() );
                 newPFchildNode->SetData(tmpPFchild);
                 newPFchildNode->SetVisibility(true);
                 newPFchildNode->SetBoolProperty("planarfigure.3drendering", true);
 
                 // replace the dataNode in PFComp DataNodeVector
                 pfc->replaceDataNodeAt(i, newPFchildNode);
 
                 // remove old child position in dataStorage
                 GetDataStorage()->Remove(savedPFchildNode);
 
                 //add new child to datamanager with its new position as child of newPFCNode parent
                 GetDataStorage()->Add(newPFchildNode, newPFCNode);
             }
         }
         break;
     }
     case 1:
     {
         if (!parentNode.IsNull())
             GetDataStorage()->Add(newPFCNode, parentNode);
         else
             GetDataStorage()->Add(newPFCNode);
 
         for(int i=0; i<pfc->getNumberOfChildren(); ++i)
         {
             mitk::BaseData::Pointer tmpPFchild = pfc->getChildAt(i);
             mitk::DataNode::Pointer savedPFchildNode = pfc->getDataNodeAt(i);
             mitk::PlanarFigureComposite::Pointer pfcompcast= dynamic_cast<mitk::PlanarFigureComposite*>(tmpPFchild.GetPointer());
             if ( !pfcompcast.IsNull() )
             {
                 // child is of type planar Figure composite
                 // make new node of the child, cuz later the child has to be removed of its old position in datamanager
                 // feed new dataNode with information of the savedDataNode, which is gonna be removed soon
                 mitk::DataNode::Pointer newChildPFCNode;
                 newChildPFCNode = mitk::DataNode::New();
                 newChildPFCNode->SetData(tmpPFchild);
                 newChildPFCNode->SetName( savedPFchildNode->GetName() );
                 pfcompcast->setDisplayName(  savedPFchildNode->GetName()  ); //name might be changed in DataManager by user
 
                 //update inside vector the dataNodePointer
                 pfc->replaceDataNodeAt(i, newChildPFCNode);
 
                 AddCompositeToDatastorage(pfcompcast, newPFCNode); //the current PFCNode becomes the childs parent
 
                 // remove old child position in dataStorage
                 GetDataStorage()->Remove(savedPFchildNode);
             }
             else
             {
                 // child is not of type PlanarFigureComposite, so its one of the planarFigures
                 // create new dataNode containing the data of the old dataNode, but position in dataManager will be
                 // modified cuz we re setting a (new) parent.
                 mitk::DataNode::Pointer newPFchildNode = mitk::DataNode::New();
                 newPFchildNode->SetName(savedPFchildNode->GetName() );
                 newPFchildNode->SetData(tmpPFchild);
                 newPFchildNode->SetVisibility(true);
                 newPFchildNode->SetBoolProperty("planarfigure.3drendering", true);
 
                 // replace the dataNode in PFComp DataNodeVector
                 pfc->replaceDataNodeAt(i, newPFchildNode);
 
                 // remove old child position in dataStorage
                 GetDataStorage()->Remove(savedPFchildNode);
 
                 //add new child to datamanager with its new position as child of newPFCNode parent
                 GetDataStorage()->Add(newPFchildNode, newPFCNode);
             }
         }
         break;
     }
     case 2:
     {
         if (!parentNode.IsNull())
             GetDataStorage()->Add(newPFCNode, parentNode);
         else
             GetDataStorage()->Add(newPFCNode);
 
         //iterate through its childs
         for(int i=0; i<pfc->getNumberOfChildren(); ++i)
         {
             mitk::BaseData::Pointer tmpPFchild = pfc->getChildAt(i);
             mitk::DataNode::Pointer savedPFchildNode = pfc->getDataNodeAt(i);
 
             mitk::PlanarFigureComposite::Pointer pfcompcast= dynamic_cast<mitk::PlanarFigureComposite*>(tmpPFchild.GetPointer());
             if ( !pfcompcast.IsNull() )
             { // child is of type planar Figure composite
                 // makeRemoveBundle new node of the child, cuz later the child has to be removed of its old position in datamanager
                 // feed new dataNode with information of the savedDataNode, which is gonna be removed soon
                 mitk::DataNode::Pointer newChildPFCNode;
                 newChildPFCNode = mitk::DataNode::New();
                 newChildPFCNode->SetData(tmpPFchild);
                 newChildPFCNode->SetName( savedPFchildNode->GetName() );
                 pfcompcast->setDisplayName( savedPFchildNode->GetName() ); //name might be changed in DataManager by user
 
                 //update inside vector the dataNodePointer
                 pfc->replaceDataNodeAt(i, newChildPFCNode);
 
                 AddCompositeToDatastorage(pfcompcast, newPFCNode); //the current PFCNode becomes the childs parent
 
                 // remove old child position in dataStorage
                 GetDataStorage()->Remove(savedPFchildNode);
             }
             else
             {
                 // child is not of type PlanarFigureComposite, so its one of the planarFigures
                 // create new dataNode containing the data of the old dataNode, but position in dataManager will be
                 // modified cuz we re setting a (new) parent.
                 mitk::DataNode::Pointer newPFchildNode = mitk::DataNode::New();
                 newPFchildNode->SetName(savedPFchildNode->GetName() );
                 newPFchildNode->SetData(tmpPFchild);
                 newPFchildNode->SetVisibility(true);
                 newPFchildNode->SetBoolProperty("planarfigure.3drendering", true);
 
                 // replace the dataNode in PFComp DataNodeVector
                 pfc->replaceDataNodeAt(i, newPFchildNode);
 
                 // remove old child position in dataStorage
                 GetDataStorage()->Remove(savedPFchildNode);
 
                 //add new child to datamanager with its new position as child of newPFCNode parent
                 GetDataStorage()->Add(newPFchildNode, newPFCNode);
             }
         }
         break;
     }
     default:
         MITK_DEBUG << "we have an UNDEFINED composition... ERROR" ;
         break;
     }
 
     for(unsigned int i = 0; i < m_SelectedPF.size(); i++)
         m_SelectedPF[i]->SetSelected(false);
 
     newPFCNode->SetSelected(true);
     m_SelectedPF.clear();
     m_SelectedPF.push_back(newPFCNode);
     UpdateGui();
 }
 
 void QmitkFiberProcessingView::JoinBundles()
 {
     if ( m_SelectedFB.size()<2 ){
         QMessageBox::information( NULL, "Warning", "Select at least two fiber bundles!");
         MITK_WARN("QmitkFiberProcessingView") << "Select at least two fiber bundles!";
         return;
     }
 
     mitk::FiberBundleX::Pointer newBundle = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(0)->GetData());
     m_SelectedFB.at(0)->SetVisibility(false);
     QString name("");
     name += QString(m_SelectedFB.at(0)->GetName().c_str());
     for (unsigned int i=1; i<m_SelectedFB.size(); i++)
     {
         newBundle = newBundle->AddBundle(dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData()));
         name += "+"+QString(m_SelectedFB.at(i)->GetName().c_str());
         m_SelectedFB.at(i)->SetVisibility(false);
     }
 
     mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
     fbNode->SetData(newBundle);
     fbNode->SetName(name.toStdString());
     fbNode->SetVisibility(true);
     GetDataStorage()->Add(fbNode);
 }
 
 void QmitkFiberProcessingView::SubstractBundles()
 {
     if ( m_SelectedFB.size()<2 ){
         QMessageBox::information( NULL, "Warning", "Select at least two fiber bundles!");
         MITK_WARN("QmitkFiberProcessingView") << "Select at least two fiber bundles!";
         return;
     }
 
     mitk::FiberBundleX::Pointer newBundle = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(0)->GetData());
     m_SelectedFB.at(0)->SetVisibility(false);
     QString name("");
     name += QString(m_SelectedFB.at(0)->GetName().c_str());
     for (unsigned int i=1; i<m_SelectedFB.size(); i++)
     {
         newBundle = newBundle->SubtractBundle(dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData()));
         if (newBundle.IsNull())
             break;
         name += "-"+QString(m_SelectedFB.at(i)->GetName().c_str());
         m_SelectedFB.at(i)->SetVisibility(false);
     }
     if (newBundle.IsNull())
     {
         QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers. Did you select the fiber bundles in the correct order? X-Y is not equal to Y-X!");
         return;
     }
 
     mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
     fbNode->SetData(newBundle);
     fbNode->SetName(name.toStdString());
     fbNode->SetVisibility(true);
     GetDataStorage()->Add(fbNode);
 }
 
 void QmitkFiberProcessingView::ResampleSelectedBundles()
 {
     double factor = this->m_Controls->m_SmoothFibersBox->value();
     for (unsigned int i=0; i<m_SelectedFB.size(); i++)
     {
         mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
         fib->ResampleSpline(factor);
     }
     RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberProcessingView::CompressSelectedBundles()
 {
     double factor = this->m_Controls->m_ErrorThresholdBox->value();
     for (unsigned int i=0; i<m_SelectedFB.size(); i++)
     {
         mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
         fib->Compress(factor);
     }
     RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberProcessingView::DoImageColorCoding()
 {
     if (m_Controls->m_ColorMapBox->GetSelectedNode().IsNull())
     {
         QMessageBox::information(NULL, "Bundle coloring aborted:", "No image providing the scalar values for coloring the selected bundle available.");
         return;
     }
 
     for(unsigned int i=0; i<m_SelectedFB.size(); i++ )
     {
         mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
         fib->SetFAMap(dynamic_cast<mitk::Image*>(m_Controls->m_ColorMapBox->GetSelectedNode()->GetData()));
         fib->SetColorCoding(mitk::FiberBundleX::COLORCODING_FA_BASED);
         fib->DoColorCodingFaBased();
     }
 
     if(m_MultiWidget)
         m_MultiWidget->RequestUpdate();
 }
 
 
 void QmitkFiberProcessingView::MirrorFibers()
 {
     unsigned int axis = this->m_Controls->m_MirrorFibersBox->currentIndex();
     for (int i=0; i<m_SelectedFB.size(); i++)
     {
         mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
         fib->MirrorFibers(axis);
     }
 
     if (m_SelectedSurfaces.size()>0)
     {
         for (int i=0; i<m_SelectedSurfaces.size(); i++)
         {
             mitk::Surface::Pointer surf = m_SelectedSurfaces.at(i);
             vtkSmartPointer<vtkPolyData> poly = surf->GetVtkPolyData();
             vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
 
             for (int i=0; i<poly->GetNumberOfPoints(); i++)
             {
                 double* point = poly->GetPoint(i);
                 point[axis] *= -1;
                 vtkNewPoints->InsertNextPoint(point);
             }
             poly->SetPoints(vtkNewPoints);
             surf->CalculateBoundingBox();
         }
     }
 
     RenderingManager::GetInstance()->RequestUpdateAll();
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberQuantificationView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberQuantificationView.cpp
index 3aaec4a69d..e12f09e205 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberQuantificationView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberQuantificationView.cpp
@@ -1,443 +1,442 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkFiberQuantificationView.h"
 #include <QmitkStdMultiWidget.h>
 
 // Qt
 #include <QMessageBox>
 
 // MITK
 #include <mitkNodePredicateProperty.h>
 #include <mitkImageCast.h>
 #include <mitkPointSet.h>
 #include <mitkPlanarCircle.h>
 #include <mitkPlanarPolygon.h>
 #include <mitkPlanarRectangle.h>
 #include <mitkPlanarFigureInteractor.h>
 #include <mitkGlobalInteraction.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkDataNodeObject.h>
-#include <mitkDiffusionImage.h>
 #include <mitkTensorImage.h>
 
 // ITK
 #include <itkResampleImageFilter.h>
 #include <itkGaussianInterpolateImageFunction.h>
 #include <itkImageRegionIteratorWithIndex.h>
 #include <itkTractsToFiberEndingsImageFilter.h>
 #include <itkTractDensityImageFilter.h>
 #include <itkImageRegion.h>
 #include <itkTractsToRgbaImageFilter.h>
 #include <itkTractsToVectorImageFilter.h>
 
 #include <math.h>
 #include <boost/lexical_cast.hpp>
 
 const std::string QmitkFiberQuantificationView::VIEW_ID = "org.mitk.views.fiberquantification";
 const std::string id_DataManager = "org.mitk.views.datamanager";
 using namespace mitk;
 
 QmitkFiberQuantificationView::QmitkFiberQuantificationView()
     : QmitkFunctionality()
     , m_Controls( 0 )
     , m_MultiWidget( NULL )
     , m_UpsamplingFactor(5)
 {
 
 }
 
 // Destructor
 QmitkFiberQuantificationView::~QmitkFiberQuantificationView()
 {
 
 }
 
 void QmitkFiberQuantificationView::CreateQtPartControl( QWidget *parent )
 {
     // build up qt view, unless already done
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkFiberQuantificationViewControls;
         m_Controls->setupUi( parent );
 
         connect( m_Controls->m_ProcessFiberBundleButton, SIGNAL(clicked()), this, SLOT(ProcessSelectedBundles()) );
         connect( m_Controls->m_ExtractFiberPeaks, SIGNAL(clicked()), this, SLOT(CalculateFiberDirections()) );
     }
 }
 
 void QmitkFiberQuantificationView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
     m_MultiWidget = &stdMultiWidget;
 }
 
 
 void QmitkFiberQuantificationView::StdMultiWidgetNotAvailable()
 {
     m_MultiWidget = NULL;
 }
 
 void QmitkFiberQuantificationView::CalculateFiberDirections()
 {
     typedef itk::Image<unsigned char, 3>                                            ItkUcharImgType;
     typedef itk::Image< itk::Vector< float, 3>, 3 >                                 ItkDirectionImage3DType;
     typedef itk::VectorContainer< unsigned int, ItkDirectionImage3DType::Pointer >  ItkDirectionImageContainerType;
 
     // load fiber bundle
     mitk::FiberBundleX::Pointer inputTractogram = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.back()->GetData());
 
     itk::TractsToVectorImageFilter<float>::Pointer fOdfFilter = itk::TractsToVectorImageFilter<float>::New();
     if (m_SelectedImage.IsNotNull())
     {
         ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
         mitk::CastToItkImage<ItkUcharImgType>(m_SelectedImage, itkMaskImage);
         fOdfFilter->SetMaskImage(itkMaskImage);
     }
 
     // extract directions from fiber bundle
     fOdfFilter->SetFiberBundle(inputTractogram);
     fOdfFilter->SetAngularThreshold(cos(m_Controls->m_AngularThreshold->value()*M_PI/180));
     fOdfFilter->SetNormalizeVectors(m_Controls->m_NormalizeDirectionsBox->isChecked());
     fOdfFilter->SetUseWorkingCopy(true);
     fOdfFilter->SetCreateDirectionImages(m_Controls->m_DirectionImagesBox->isChecked());
     fOdfFilter->SetSizeThreshold(m_Controls->m_PeakThreshold->value());
     fOdfFilter->SetMaxNumDirections(m_Controls->m_MaxNumDirections->value());
     fOdfFilter->Update();
 
     QString name = m_SelectedFB.back()->GetName().c_str();
 
     if (m_Controls->m_VectorFieldBox->isChecked())
     {
         float minSpacing = 1;
         if (m_SelectedImage.IsNotNull())
         {
             mitk::Vector3D outImageSpacing = m_SelectedImage->GetGeometry()->GetSpacing();
 
             if(outImageSpacing[0]<outImageSpacing[1] && outImageSpacing[0]<outImageSpacing[2])
                 minSpacing = outImageSpacing[0];
             else if (outImageSpacing[1] < outImageSpacing[2])
                 minSpacing = outImageSpacing[1];
             else
                 minSpacing = outImageSpacing[2];
         }
 
         mitk::FiberBundleX::Pointer directions = fOdfFilter->GetOutputFiberBundle();
         mitk::DataNode::Pointer node = mitk::DataNode::New();
         node->SetData(directions);
         node->SetName((name+"_vectorfield").toStdString().c_str());
         node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(minSpacing));
         node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
         node->SetProperty("color", mitk::ColorProperty::New(1.0f, 1.0f, 1.0f));
 
         GetDefaultDataStorage()->Add(node, m_SelectedFB.back());
     }
 
     if (m_Controls->m_NumDirectionsBox->isChecked())
     {
         mitk::Image::Pointer mitkImage = mitk::Image::New();
         mitkImage->InitializeByItk( fOdfFilter->GetNumDirectionsImage().GetPointer() );
         mitkImage->SetVolume( fOdfFilter->GetNumDirectionsImage()->GetBufferPointer() );
 
         mitk::DataNode::Pointer node = mitk::DataNode::New();
         node->SetData(mitkImage);
         node->SetName((name+"_numdirections").toStdString().c_str());
         GetDefaultDataStorage()->Add(node, m_SelectedFB.back());
     }
 
     if (m_Controls->m_DirectionImagesBox->isChecked())
     {
         ItkDirectionImageContainerType::Pointer directionImageContainer = fOdfFilter->GetDirectionImageContainer();
         for (unsigned int i=0; i<directionImageContainer->Size(); i++)
         {
             itk::TractsToVectorImageFilter<float>::ItkDirectionImageType::Pointer itkImg = directionImageContainer->GetElement(i);
 
             if (itkImg.IsNull())
                 return;
 
             mitk::Image::Pointer mitkImage = mitk::Image::New();
             mitkImage->InitializeByItk( itkImg.GetPointer() );
             mitkImage->SetVolume( itkImg->GetBufferPointer() );
 
             mitk::DataNode::Pointer node = mitk::DataNode::New();
             node->SetData(mitkImage);
             node->SetName( (name+"_direction_"+boost::lexical_cast<std::string>(i).c_str()).toStdString().c_str());
             node->SetVisibility(false);
             GetDefaultDataStorage()->Add(node, m_SelectedFB.back());
         }
     }
 }
 
 void QmitkFiberQuantificationView::UpdateGui()
 {
     m_Controls->m_ProcessFiberBundleButton->setEnabled(!m_SelectedFB.empty());
     m_Controls->m_ExtractFiberPeaks->setEnabled(!m_SelectedFB.empty());
 }
 
 void QmitkFiberQuantificationView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
     //reset existing Vectors containing FiberBundles and PlanarFigures from a previous selection
     m_SelectedFB.clear();
     m_SelectedSurfaces.clear();
     m_SelectedImage = NULL;
 
     for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
     {
         mitk::DataNode::Pointer node = *it;
         if ( dynamic_cast<mitk::FiberBundleX*>(node->GetData()) )
         {
             m_SelectedFB.push_back(node);
         }
         else if (dynamic_cast<mitk::Image*>(node->GetData()))
             m_SelectedImage = dynamic_cast<mitk::Image*>(node->GetData());
         else if (dynamic_cast<mitk::Surface*>(node->GetData()))
         {
             m_SelectedSurfaces.push_back(dynamic_cast<mitk::Surface*>(node->GetData()));
         }
     }
     UpdateGui();
     GenerateStats();
 }
 
 void QmitkFiberQuantificationView::Activated()
 {
 
 }
 
 void QmitkFiberQuantificationView::GenerateStats()
 {
     if ( m_SelectedFB.empty() )
         return;
 
     QString stats("");
 
     for( int i=0; i<m_SelectedFB.size(); i++ )
     {
         mitk::DataNode::Pointer node = m_SelectedFB[i];
         if (node.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(node->GetData()))
         {
             if (i>0)
                 stats += "\n-----------------------------\n";
             stats += QString(node->GetName().c_str()) + "\n";
             mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
             stats += "Number of fibers: "+ QString::number(fib->GetNumFibers()) + "\n";
             stats += "Number of points: "+ QString::number(fib->GetNumberOfPoints()) + "\n";
             stats += "Min. length:         "+ QString::number(fib->GetMinFiberLength(),'f',1) + " mm\n";
             stats += "Max. length:         "+ QString::number(fib->GetMaxFiberLength(),'f',1) + " mm\n";
             stats += "Mean length:         "+ QString::number(fib->GetMeanFiberLength(),'f',1) + " mm\n";
             stats += "Median length:       "+ QString::number(fib->GetMedianFiberLength(),'f',1) + " mm\n";
             stats += "Standard deviation:  "+ QString::number(fib->GetLengthStDev(),'f',1) + " mm\n";
         }
     }
     this->m_Controls->m_StatsTextEdit->setText(stats);
 }
 
 void QmitkFiberQuantificationView::ProcessSelectedBundles()
 {
     if ( m_SelectedFB.empty() ){
         QMessageBox::information( NULL, "Warning", "No fibe bundle selected!");
         MITK_WARN("QmitkFiberQuantificationView") << "no fibe bundle selected";
         return;
     }
 
     int generationMethod = m_Controls->m_GenerationBox->currentIndex();
 
     for( int i=0; i<m_SelectedFB.size(); i++ )
     {
         mitk::DataNode::Pointer node = m_SelectedFB[i];
         if (node.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(node->GetData()))
         {
             mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
             QString name(node->GetName().c_str());
             DataNode::Pointer newNode = NULL;
             switch(generationMethod){
             case 0:
                 newNode = GenerateTractDensityImage(fib, false, true);
                 name += "_TDI";
                 break;
             case 1:
                 newNode = GenerateTractDensityImage(fib, false, false);
                 name += "_TDI";
                 break;
             case 2:
                 newNode = GenerateTractDensityImage(fib, true, false);
                 name += "_envelope";
                 break;
             case 3:
                 newNode = GenerateColorHeatmap(fib);
                 break;
             case 4:
                 newNode = GenerateFiberEndingsImage(fib);
                 name += "_fiber_endings";
                 break;
             case 5:
                 newNode = GenerateFiberEndingsPointSet(fib);
                 name += "_fiber_endings";
                 break;
             }
             if (newNode.IsNotNull())
             {
                 newNode->SetName(name.toStdString());
                 GetDataStorage()->Add(newNode);
             }
         }
     }
 }
 
 // generate pointset displaying the fiber endings
 mitk::DataNode::Pointer QmitkFiberQuantificationView::GenerateFiberEndingsPointSet(mitk::FiberBundleX::Pointer fib)
 {
     mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
     vtkSmartPointer<vtkPolyData> fiberPolyData = fib->GetFiberPolyData();
     vtkSmartPointer<vtkCellArray> vLines = fiberPolyData->GetLines();
     vLines->InitTraversal();
 
     int count = 0;
     int numFibers = fib->GetNumFibers();
     for( int i=0; i<numFibers; i++ )
     {
         vtkIdType   numPoints(0);
         vtkIdType*  points(NULL);
         vLines->GetNextCell ( numPoints, points );
 
         if (numPoints>0)
         {
             double* point = fiberPolyData->GetPoint(points[0]);
             itk::Point<float,3> itkPoint;
             itkPoint[0] = point[0];
             itkPoint[1] = point[1];
             itkPoint[2] = point[2];
             pointSet->InsertPoint(count, itkPoint);
             count++;
         }
         if (numPoints>2)
         {
             double* point = fiberPolyData->GetPoint(points[numPoints-1]);
             itk::Point<float,3> itkPoint;
             itkPoint[0] = point[0];
             itkPoint[1] = point[1];
             itkPoint[2] = point[2];
             pointSet->InsertPoint(count, itkPoint);
             count++;
         }
     }
 
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData( pointSet );
     return node;
 }
 
 // generate image displaying the fiber endings
 mitk::DataNode::Pointer QmitkFiberQuantificationView::GenerateFiberEndingsImage(mitk::FiberBundleX::Pointer fib)
 {
     typedef unsigned char OutPixType;
     typedef itk::Image<OutPixType,3> OutImageType;
 
     typedef itk::TractsToFiberEndingsImageFilter< OutImageType > ImageGeneratorType;
     ImageGeneratorType::Pointer generator = ImageGeneratorType::New();
     generator->SetFiberBundle(fib);
     generator->SetUpsamplingFactor(m_Controls->m_UpsamplingSpinBox->value());
     if (m_SelectedImage.IsNotNull())
     {
         OutImageType::Pointer itkImage = OutImageType::New();
         CastToItkImage(m_SelectedImage, itkImage);
         generator->SetInputImage(itkImage);
         generator->SetUseImageGeometry(true);
     }
     generator->Update();
 
     // get output image
     OutImageType::Pointer outImg = generator->GetOutput();
     mitk::Image::Pointer img = mitk::Image::New();
     img->InitializeByItk(outImg.GetPointer());
     img->SetVolume(outImg->GetBufferPointer());
 
     // init data node
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData(img);
     return node;
 }
 
 // generate rgba heatmap from fiber bundle
 mitk::DataNode::Pointer QmitkFiberQuantificationView::GenerateColorHeatmap(mitk::FiberBundleX::Pointer fib)
 {
     typedef itk::RGBAPixel<unsigned char> OutPixType;
     typedef itk::Image<OutPixType, 3> OutImageType;
     typedef itk::TractsToRgbaImageFilter< OutImageType > ImageGeneratorType;
     ImageGeneratorType::Pointer generator = ImageGeneratorType::New();
     generator->SetFiberBundle(fib);
     generator->SetUpsamplingFactor(m_Controls->m_UpsamplingSpinBox->value());
     if (m_SelectedImage.IsNotNull())
     {
         itk::Image<unsigned char, 3>::Pointer itkImage = itk::Image<unsigned char, 3>::New();
         CastToItkImage(m_SelectedImage, itkImage);
         generator->SetInputImage(itkImage);
         generator->SetUseImageGeometry(true);
     }
     generator->Update();
 
     // get output image
     typedef itk::Image<OutPixType,3> OutType;
     OutType::Pointer outImg = generator->GetOutput();
     mitk::Image::Pointer img = mitk::Image::New();
     img->InitializeByItk(outImg.GetPointer());
     img->SetVolume(outImg->GetBufferPointer());
 
     // init data node
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData(img);
     return node;
 }
 
 // generate tract density image from fiber bundle
 mitk::DataNode::Pointer QmitkFiberQuantificationView::GenerateTractDensityImage(mitk::FiberBundleX::Pointer fib, bool binary, bool absolute)
 {
     typedef float OutPixType;
     typedef itk::Image<OutPixType, 3> OutImageType;
 
     itk::TractDensityImageFilter< OutImageType >::Pointer generator = itk::TractDensityImageFilter< OutImageType >::New();
     generator->SetFiberBundle(fib);
     generator->SetBinaryOutput(binary);
     generator->SetOutputAbsoluteValues(absolute);
     generator->SetUpsamplingFactor(m_Controls->m_UpsamplingSpinBox->value());
     if (m_SelectedImage.IsNotNull())
     {
         OutImageType::Pointer itkImage = OutImageType::New();
         CastToItkImage(m_SelectedImage, itkImage);
         generator->SetInputImage(itkImage);
         generator->SetUseImageGeometry(true);
 
     }
     generator->Update();
 
     // get output image
     typedef itk::Image<OutPixType,3> OutType;
     OutType::Pointer outImg = generator->GetOutput();
     mitk::Image::Pointer img = mitk::Image::New();
     img->InitializeByItk(outImg.GetPointer());
     img->SetVolume(outImg->GetBufferPointer());
 
     // init data node
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData(img);
     return node;
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp
index 5c48643290..fd750f32f1 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp
@@ -1,2659 +1,2694 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 //misc
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkFiberfoxView.h"
 
 // MITK
 #include <mitkImage.h>
-#include <mitkDiffusionImage.h>
 #include <mitkImageToItk.h>
 #include <mitkImageCast.h>
 #include <mitkProperties.h>
 #include <mitkPlanarFigureInteractor.h>
 #include <mitkDataStorage.h>
 #include <itkFibersFromPlanarFiguresFilter.h>
 #include <itkTractsToDWIImageFilter.h>
 #include <mitkTensorImage.h>
 #include <mitkILinkedRenderWindowPart.h>
 #include <mitkGlobalInteraction.h>
 #include <mitkImageToItk.h>
 #include <mitkImageCast.h>
 #include <mitkImageGenerator.h>
 #include <mitkNodePredicateDataType.h>
 #include <itkScalableAffineTransform.h>
 #include <mitkLevelWindowProperty.h>
 #include <mitkNodePredicateOr.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
+#include <mitkNodePredicateProperty.h>
+#include <mitkNodePredicateIsDWI.h>
 #include <boost/property_tree/ptree.hpp>
 #include <boost/property_tree/xml_parser.hpp>
 #include <boost/foreach.hpp>
 #include <QFileDialog>
 #include <QMessageBox>
 #include "usModuleRegistry.h"
 #include <mitkChiSquareNoiseModel.h>
 #include <itksys/SystemTools.hxx>
 #include <mitkIOUtil.h>
 #include <QScrollBar>
 #include <itkInvertIntensityImageFilter.h>
 #include <QDialogButtonBox>
 #include <itkAdcImageFilter.h>
 #include <itkShiftScaleImageFilter.h>
+#include <mitkITKImageImport.h>
 
 #include "mitkNodePredicateDataType.h"
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateOr.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 QmitkFiberfoxWorker::QmitkFiberfoxWorker(QmitkFiberfoxView* view)
     : m_View(view)
 {
 
 }
 
 void QmitkFiberfoxWorker::run()
 {
     try{
         switch (m_FilterType)
         {
         case 0:
             m_View->m_TractsToDwiFilter->Update();
             break;
         case 1:
             m_View->m_ArtifactsToDwiFilter->Update();
             break;
         }
     }
     catch( ... )
     {
 
     }
     m_View->m_Thread.quit();
 }
 
 const std::string QmitkFiberfoxView::VIEW_ID = "org.mitk.views.fiberfoxview";
 
 QmitkFiberfoxView::QmitkFiberfoxView()
     : QmitkAbstractView()
     , m_Controls( 0 )
     , m_SelectedImage( NULL )
     , m_Worker(this)
     , m_ThreadIsRunning(false)
 {
     m_Worker.moveToThread(&m_Thread);
     connect(&m_Thread, SIGNAL(started()), this, SLOT(BeforeThread()));
     connect(&m_Thread, SIGNAL(started()), &m_Worker, SLOT(run()));
     connect(&m_Thread, SIGNAL(finished()), this, SLOT(AfterThread()));
     connect(&m_Thread, SIGNAL(terminated()), this, SLOT(AfterThread()));
     m_SimulationTimer = new QTimer(this);
 }
 
 void QmitkFiberfoxView::KillThread()
 {
     MITK_INFO << "Aborting DWI simulation.";
     switch (m_Worker.m_FilterType)
     {
     case 0:
         m_TractsToDwiFilter->SetAbortGenerateData(true);
         break;
     case 1:
         m_ArtifactsToDwiFilter->SetAbortGenerateData(true);
         break;
     }
     m_Controls->m_AbortSimulationButton->setEnabled(false);
     m_Controls->m_AbortSimulationButton->setText("Aborting simulation ...");
 }
 
 void QmitkFiberfoxView::BeforeThread()
 {
     m_SimulationTime = QTime::currentTime();
     m_SimulationTimer->start(100);
     m_Controls->m_AbortSimulationButton->setVisible(true);
     m_Controls->m_GenerateImageButton->setVisible(false);
     m_Controls->m_SimulationStatusText->setVisible(true);
     m_ThreadIsRunning = true;
 }
 
 void QmitkFiberfoxView::AfterThread()
 {
     UpdateSimulationStatus();
     m_SimulationTimer->stop();
     m_Controls->m_AbortSimulationButton->setVisible(false);
     m_Controls->m_AbortSimulationButton->setEnabled(true);
     m_Controls->m_AbortSimulationButton->setText("Abort simulation");
     m_Controls->m_GenerateImageButton->setVisible(true);
     m_ThreadIsRunning = false;
 
     QString statusText;
     FiberfoxParameters<double> parameters;
-    mitk::DiffusionImage<short>::Pointer mitkImage = mitk::DiffusionImage<short>::New();
+    mitk::Image::Pointer mitkImage = mitk::Image::New();
     switch (m_Worker.m_FilterType)
     {
     case 0:
     {
         statusText = QString(m_TractsToDwiFilter->GetStatusText().c_str());
         if (m_TractsToDwiFilter->GetAbortGenerateData())
         {
             MITK_INFO << "Simulation aborted.";
             return;
         }
 
         parameters = m_TractsToDwiFilter->GetParameters();
 
-        mitkImage->SetVectorImage( m_TractsToDwiFilter->GetOutput() );
-        mitkImage->SetReferenceBValue(parameters.m_SignalGen.m_Bvalue);
-        mitkImage->SetDirections(parameters.m_SignalGen.GetGradientDirections());
-        mitkImage->InitializeFromVectorImage();
+        mitkImage = mitk::GrabItkImageMemory( m_TractsToDwiFilter->GetOutput() );
+        mitkImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New(  parameters.m_SignalGen.GetGradientDirections()  ));
+        mitkImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( parameters.m_SignalGen.m_Bvalue ));
+        mitk::DiffusionPropertyHelper propertyHelper( mitkImage );
+        propertyHelper.InitializeImage();
         parameters.m_Misc.m_ResultNode->SetData( mitkImage );
 
         parameters.m_Misc.m_ResultNode->SetName(parameters.m_Misc.m_ParentNode->GetName()
                                                 +"_D"+QString::number(parameters.m_SignalGen.m_ImageRegion.GetSize(0)).toStdString()
                                                 +"-"+QString::number(parameters.m_SignalGen.m_ImageRegion.GetSize(1)).toStdString()
                                                 +"-"+QString::number(parameters.m_SignalGen.m_ImageRegion.GetSize(2)).toStdString()
                                                 +"_S"+QString::number(parameters.m_SignalGen.m_ImageSpacing[0]).toStdString()
                 +"-"+QString::number(parameters.m_SignalGen.m_ImageSpacing[1]).toStdString()
                 +"-"+QString::number(parameters.m_SignalGen.m_ImageSpacing[2]).toStdString()
                 +"_b"+QString::number(parameters.m_SignalGen.m_Bvalue).toStdString()
                 +"_"+parameters.m_Misc.m_SignalModelString
                 +parameters.m_Misc.m_ArtifactModelString);
 
         GetDataStorage()->Add(parameters.m_Misc.m_ResultNode, parameters.m_Misc.m_ParentNode);
 
         parameters.m_Misc.m_ResultNode->SetProperty( "levelwindow", mitk::LevelWindowProperty::New(m_TractsToDwiFilter->GetLevelWindow()) );
 
         if (m_Controls->m_VolumeFractionsBox->isChecked())
         {
             std::vector< itk::TractsToDWIImageFilter< short >::ItkDoubleImgType::Pointer > volumeFractions = m_TractsToDwiFilter->GetVolumeFractions();
             for (unsigned int k=0; k<volumeFractions.size(); k++)
             {
                 mitk::Image::Pointer image = mitk::Image::New();
                 image->InitializeByItk(volumeFractions.at(k).GetPointer());
                 image->SetVolume(volumeFractions.at(k)->GetBufferPointer());
 
                 mitk::DataNode::Pointer node = mitk::DataNode::New();
                 node->SetData( image );
                 node->SetName(parameters.m_Misc.m_ParentNode->GetName()+"_CompartmentVolume-"+QString::number(k).toStdString());
                 GetDataStorage()->Add(node, parameters.m_Misc.m_ParentNode);
             }
         }
         m_TractsToDwiFilter = NULL;
         break;
     }
     case 1:
     {
         statusText = QString(m_ArtifactsToDwiFilter->GetStatusText().c_str());
         if (m_ArtifactsToDwiFilter->GetAbortGenerateData())
         {
             MITK_INFO << "Simulation aborted.";
             return;
         }
 
         parameters = m_ArtifactsToDwiFilter->GetParameters().CopyParameters<double>();
 
-        mitk::DiffusionImage<short>::Pointer diffImg = dynamic_cast<mitk::DiffusionImage<short>*>(parameters.m_Misc.m_ParentNode->GetData());
-        mitkImage = mitk::DiffusionImage<short>::New();
-        mitkImage->SetVectorImage( m_ArtifactsToDwiFilter->GetOutput() );
-        mitkImage->SetReferenceBValue(diffImg->GetReferenceBValue());
-        mitkImage->SetDirections(diffImg->GetDirections());
-        mitkImage->InitializeFromVectorImage();
+        mitk::Image::Pointer diffImg = dynamic_cast<mitk::Image*>(parameters.m_Misc.m_ParentNode->GetData());
+        mitkImage = mitk::GrabItkImageMemory( m_ArtifactsToDwiFilter->GetOutput() );
+
+        mitkImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() ) );
+        mitkImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() ) );
+        mitk::DiffusionPropertyHelper propertyHelper( mitkImage );
+        propertyHelper.InitializeImage();
+
         parameters.m_Misc.m_ResultNode->SetData( mitkImage );
         parameters.m_Misc.m_ResultNode->SetName(parameters.m_Misc.m_ParentNode->GetName()+parameters.m_Misc.m_ArtifactModelString);
         GetDataStorage()->Add(parameters.m_Misc.m_ResultNode, parameters.m_Misc.m_ParentNode);
         m_ArtifactsToDwiFilter = NULL;
         break;
     }
     }
 
     mitk::BaseData::Pointer basedata = parameters.m_Misc.m_ResultNode->GetData();
     if (basedata.IsNotNull())
     {
         mitk::RenderingManager::GetInstance()->InitializeViews(
                     basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 
     if (!parameters.m_Misc.m_OutputPath.empty())
     {
         try{
             QString outputFileName(parameters.m_Misc.m_OutputPath.c_str());
             outputFileName += parameters.m_Misc.m_ResultNode->GetName().c_str();
             outputFileName.replace(QString("."), QString("_"));
             outputFileName += ".dwi";
             QString status("Saving output image to ");
             status += outputFileName;
             m_Controls->m_SimulationStatusText->append(status);
             mitk::IOUtil::SaveBaseData(mitkImage, outputFileName.toStdString());
             m_Controls->m_SimulationStatusText->append("File saved successfully.");
         }
         catch (itk::ExceptionObject &e)
         {
             QString status("Exception during DWI writing: ");
             status += e.GetDescription();
             m_Controls->m_SimulationStatusText->append(status);
         }
         catch (...)
         {
             m_Controls->m_SimulationStatusText->append("Unknown exception during DWI writing!");
         }
     }
     parameters.m_SignalGen.m_FrequencyMap = NULL;
 }
 
 void QmitkFiberfoxView::UpdateSimulationStatus()
 {
     QString statusText;
     switch (m_Worker.m_FilterType)
     {
     case 0:
         statusText = QString(m_TractsToDwiFilter->GetStatusText().c_str());
         break;
     case 1:
         statusText = QString(m_ArtifactsToDwiFilter->GetStatusText().c_str());
         break;
     }
 
     if (QString::compare(m_SimulationStatusText,statusText)!=0)
     {
         m_Controls->m_SimulationStatusText->clear();
         statusText = "<pre>"+statusText+"</pre>";
         m_Controls->m_SimulationStatusText->setText(statusText);
         QScrollBar *vScrollBar = m_Controls->m_SimulationStatusText->verticalScrollBar();
         vScrollBar->triggerAction(QScrollBar::SliderToMaximum);
     }
 }
 
 // Destructor
 QmitkFiberfoxView::~QmitkFiberfoxView()
 {
     delete m_SimulationTimer;
 }
 
 void QmitkFiberfoxView::CreateQtPartControl( QWidget *parent )
 {
     // build up qt view, unless already done
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkFiberfoxViewControls;
         m_Controls->setupUi( parent );
 
         // commented out
         m_Controls->m_DiffusionDirectionBox->setVisible(false);
         m_Controls->label_3->setVisible(false);
         m_Controls->m_SeparationAngleBox->setVisible(false);
         m_Controls->label_4->setVisible(false);
         //
 
         m_Controls->m_StickWidget1->setVisible(true);
         m_Controls->m_StickWidget2->setVisible(false);
         m_Controls->m_ZeppelinWidget1->setVisible(false);
         m_Controls->m_ZeppelinWidget2->setVisible(false);
         m_Controls->m_TensorWidget1->setVisible(false);
         m_Controls->m_TensorWidget2->setVisible(false);
 
         m_Controls->m_BallWidget1->setVisible(true);
         m_Controls->m_BallWidget2->setVisible(false);
         m_Controls->m_AstrosticksWidget1->setVisible(false);
         m_Controls->m_AstrosticksWidget2->setVisible(false);
         m_Controls->m_DotWidget1->setVisible(false);
         m_Controls->m_DotWidget2->setVisible(false);
 
         m_Controls->m_PrototypeWidget1->setVisible(false);
         m_Controls->m_PrototypeWidget2->setVisible(false);
         m_Controls->m_PrototypeWidget3->setVisible(false);
         m_Controls->m_PrototypeWidget4->setVisible(false);
 
         m_Controls->m_PrototypeWidget3->SetMinFa(0.0);
         m_Controls->m_PrototypeWidget3->SetMaxFa(0.15);
         m_Controls->m_PrototypeWidget4->SetMinFa(0.0);
         m_Controls->m_PrototypeWidget4->SetMaxFa(0.15);
         m_Controls->m_PrototypeWidget3->SetMinAdc(0.0);
         m_Controls->m_PrototypeWidget3->SetMaxAdc(0.001);
         m_Controls->m_PrototypeWidget4->SetMinAdc(0.003);
         m_Controls->m_PrototypeWidget4->SetMaxAdc(0.004);
 
         m_Controls->m_Comp4FractionFrame->setVisible(false);
         m_Controls->m_DiffusionPropsMessage->setVisible(false);
         m_Controls->m_GeometryMessage->setVisible(false);
         m_Controls->m_AdvancedSignalOptionsFrame->setVisible(false);
         m_Controls->m_AdvancedFiberOptionsFrame->setVisible(false);
         m_Controls->m_VarianceBox->setVisible(false);
         m_Controls->m_NoiseFrame->setVisible(false);
         m_Controls->m_GhostFrame->setVisible(false);
         m_Controls->m_DistortionsFrame->setVisible(false);
         m_Controls->m_EddyFrame->setVisible(false);
         m_Controls->m_SpikeFrame->setVisible(false);
         m_Controls->m_AliasingFrame->setVisible(false);
         m_Controls->m_MotionArtifactFrame->setVisible(false);
         m_ParameterFile = QDir::currentPath()+"/param.ffp";
 
         m_Controls->m_AbortSimulationButton->setVisible(false);
         m_Controls->m_SimulationStatusText->setVisible(false);
 
         m_Controls->m_FrequencyMapBox->SetDataStorage(this->GetDataStorage());
         m_Controls->m_Comp4VolumeFraction->SetDataStorage(this->GetDataStorage());
         m_Controls->m_MaskComboBox->SetDataStorage(this->GetDataStorage());
         m_Controls->m_TemplateComboBox->SetDataStorage(this->GetDataStorage());
         m_Controls->m_FiberBundleComboBox->SetDataStorage(this->GetDataStorage());
 
         mitk::TNodePredicateDataType<mitk::FiberBundleX>::Pointer isFiberBundle = mitk::TNodePredicateDataType<mitk::FiberBundleX>::New();
         mitk::TNodePredicateDataType<mitk::Image>::Pointer isMitkImage = mitk::TNodePredicateDataType<mitk::Image>::New();
-        mitk::NodePredicateDataType::Pointer isDwi = mitk::NodePredicateDataType::New("DiffusionImage");
+        mitk::NodePredicateIsDWI::Pointer isDwi = mitk::NodePredicateIsDWI::New( );
         mitk::NodePredicateDataType::Pointer isDti = mitk::NodePredicateDataType::New("TensorImage");
         mitk::NodePredicateDataType::Pointer isQbi = mitk::NodePredicateDataType::New("QBallImage");
         mitk::NodePredicateOr::Pointer isDiffusionImage = mitk::NodePredicateOr::New(isDwi, isDti);
         isDiffusionImage = mitk::NodePredicateOr::New(isDiffusionImage, isQbi);
         mitk::NodePredicateNot::Pointer noDiffusionImage = mitk::NodePredicateNot::New(isDiffusionImage);
         mitk::NodePredicateAnd::Pointer isNonDiffMitkImage = mitk::NodePredicateAnd::New(isMitkImage, noDiffusionImage);
         mitk::NodePredicateProperty::Pointer isBinaryPredicate = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
         mitk::NodePredicateAnd::Pointer isBinaryMitkImage = mitk::NodePredicateAnd::New( isNonDiffMitkImage, isBinaryPredicate );
 
         m_Controls->m_FrequencyMapBox->SetPredicate(isNonDiffMitkImage);
         m_Controls->m_Comp4VolumeFraction->SetPredicate(isNonDiffMitkImage);
         m_Controls->m_MaskComboBox->SetPredicate(isBinaryMitkImage);
         m_Controls->m_MaskComboBox->SetZeroEntryText("--");
         m_Controls->m_TemplateComboBox->SetPredicate(isMitkImage);
         m_Controls->m_TemplateComboBox->SetZeroEntryText("--");
         m_Controls->m_FiberBundleComboBox->SetPredicate(isFiberBundle);
         m_Controls->m_FiberBundleComboBox->SetZeroEntryText("--");
 
 //        mitk::NodePredicateDimension::Pointer dimensionPredicate = mitk::NodePredicateDimension::New(3);
 
         connect( m_SimulationTimer, SIGNAL(timeout()), this, SLOT(UpdateSimulationStatus()) );
         connect((QObject*) m_Controls->m_AbortSimulationButton, SIGNAL(clicked()), (QObject*) this, SLOT(KillThread()));
         connect((QObject*) m_Controls->m_GenerateImageButton, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateImage()));
         connect((QObject*) m_Controls->m_GenerateFibersButton, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateFibers()));
         connect((QObject*) m_Controls->m_CircleButton, SIGNAL(clicked()), (QObject*) this, SLOT(OnDrawROI()));
         connect((QObject*) m_Controls->m_FlipButton, SIGNAL(clicked()), (QObject*) this, SLOT(OnFlipButton()));
         connect((QObject*) m_Controls->m_JoinBundlesButton, SIGNAL(clicked()), (QObject*) this, SLOT(JoinBundles()));
         connect((QObject*) m_Controls->m_VarianceBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnVarianceChanged(double)));
         connect((QObject*) m_Controls->m_DistributionBox, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(OnDistributionChanged(int)));
         connect((QObject*) m_Controls->m_FiberDensityBox, SIGNAL(valueChanged(int)), (QObject*) this, SLOT(OnFiberDensityChanged(int)));
         connect((QObject*) m_Controls->m_FiberSamplingBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnFiberSamplingChanged(double)));
         connect((QObject*) m_Controls->m_TensionBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnTensionChanged(double)));
         connect((QObject*) m_Controls->m_ContinuityBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnContinuityChanged(double)));
         connect((QObject*) m_Controls->m_BiasBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnBiasChanged(double)));
         connect((QObject*) m_Controls->m_AddNoise, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddNoise(int)));
         connect((QObject*) m_Controls->m_AddGhosts, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddGhosts(int)));
         connect((QObject*) m_Controls->m_AddDistortions, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddDistortions(int)));
         connect((QObject*) m_Controls->m_AddEddy, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddEddy(int)));
         connect((QObject*) m_Controls->m_AddSpikes, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddSpikes(int)));
         connect((QObject*) m_Controls->m_AddAliasing, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddAliasing(int)));
         connect((QObject*) m_Controls->m_AddMotion, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddMotion(int)));
 
         connect((QObject*) m_Controls->m_ConstantRadiusBox, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnConstantRadius(int)));
         connect((QObject*) m_Controls->m_CopyBundlesButton, SIGNAL(clicked()), (QObject*) this, SLOT(CopyBundles()));
         connect((QObject*) m_Controls->m_TransformBundlesButton, SIGNAL(clicked()), (QObject*) this, SLOT(ApplyTransform()));
         connect((QObject*) m_Controls->m_AlignOnGrid, SIGNAL(clicked()), (QObject*) this, SLOT(AlignOnGrid()));
 
         connect((QObject*) m_Controls->m_Compartment1Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp1ModelFrameVisibility(int)));
         connect((QObject*) m_Controls->m_Compartment2Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp2ModelFrameVisibility(int)));
         connect((QObject*) m_Controls->m_Compartment3Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp3ModelFrameVisibility(int)));
         connect((QObject*) m_Controls->m_Compartment4Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp4ModelFrameVisibility(int)));
 
         connect((QObject*) m_Controls->m_AdvancedOptionsBox, SIGNAL( stateChanged(int)), (QObject*) this, SLOT(ShowAdvancedOptions(int)));
         connect((QObject*) m_Controls->m_AdvancedOptionsBox_2, SIGNAL( stateChanged(int)), (QObject*) this, SLOT(ShowAdvancedOptions(int)));
 
         connect((QObject*) m_Controls->m_SaveParametersButton, SIGNAL(clicked()), (QObject*) this, SLOT(SaveParameters()));
         connect((QObject*) m_Controls->m_LoadParametersButton, SIGNAL(clicked()), (QObject*) this, SLOT(LoadParameters()));
         connect((QObject*) m_Controls->m_OutputPathButton, SIGNAL(clicked()), (QObject*) this, SLOT(SetOutputPath()));
 
         connect((QObject*) m_Controls->m_MaskComboBox, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(OnMaskSelected(int)));
         connect((QObject*) m_Controls->m_TemplateComboBox, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(OnTemplateSelected(int)));
         connect((QObject*) m_Controls->m_FiberBundleComboBox, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(OnFibSelected(int)));
     }
 }
 
 void QmitkFiberfoxView::OnMaskSelected(int value)
 {
     UpdateGui();
 }
 
 void QmitkFiberfoxView::OnTemplateSelected(int value)
 {
     UpdateGui();
 }
 
 void QmitkFiberfoxView::OnFibSelected(int value)
 {
     UpdateGui();
 }
 
 template< class ScalarType >
 FiberfoxParameters< ScalarType > QmitkFiberfoxView::UpdateImageParameters()
 {
     FiberfoxParameters< ScalarType > parameters;
     parameters.m_Misc.m_OutputPath = "";
     parameters.m_Misc.m_CheckAdvancedFiberOptionsBox = m_Controls->m_AdvancedOptionsBox->isChecked();
     parameters.m_Misc.m_CheckAdvancedSignalOptionsBox = m_Controls->m_AdvancedOptionsBox_2->isChecked();
     parameters.m_Misc.m_CheckOutputVolumeFractionsBox = m_Controls->m_VolumeFractionsBox->isChecked();
 
     string outputPath = m_Controls->m_SavePathEdit->text().toStdString();
     if (outputPath.compare("-")!=0)
     {
         parameters.m_Misc.m_OutputPath = outputPath;
         parameters.m_Misc.m_OutputPath += "/";
     }
 
     if (m_Controls->m_MaskComboBox->GetSelectedNode().IsNotNull())
     {
         mitk::Image::Pointer mitkMaskImage = dynamic_cast<mitk::Image*>(m_Controls->m_MaskComboBox->GetSelectedNode()->GetData());
         mitk::CastToItkImage<ItkUcharImgType>(mitkMaskImage, parameters.m_SignalGen.m_MaskImage);
         itk::ImageDuplicator<ItkUcharImgType>::Pointer duplicator = itk::ImageDuplicator<ItkUcharImgType>::New();
         duplicator->SetInputImage(parameters.m_SignalGen.m_MaskImage);
         duplicator->Update();
         parameters.m_SignalGen.m_MaskImage = duplicator->GetOutput();
     }
 
-    if (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull() && dynamic_cast<mitk::DiffusionImage<short>*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData()))  // use parameters of selected DWI
+    if (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull() && mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData())))  // use parameters of selected DWI
     {
-        mitk::DiffusionImage<short>::Pointer dwi = dynamic_cast<mitk::DiffusionImage<short>*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData());
-        parameters.m_SignalGen.m_ImageRegion = dwi->GetVectorImage()->GetLargestPossibleRegion();
-        parameters.m_SignalGen.m_ImageSpacing = dwi->GetVectorImage()->GetSpacing();
-        parameters.m_SignalGen.m_ImageOrigin = dwi->GetVectorImage()->GetOrigin();
-        parameters.m_SignalGen.m_ImageDirection = dwi->GetVectorImage()->GetDirection();
-        parameters.m_SignalGen.m_Bvalue = dwi->GetReferenceBValue();
-        parameters.m_SignalGen.SetGradienDirections(dwi->GetDirections());
+        mitk::Image::Pointer dwi = dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData());
+
+        ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+        mitk::CastToItkImage(dwi, itkVectorImagePointer);
+
+        parameters.m_SignalGen.m_ImageRegion = itkVectorImagePointer->GetLargestPossibleRegion();
+        parameters.m_SignalGen.m_ImageSpacing = itkVectorImagePointer->GetSpacing();
+        parameters.m_SignalGen.m_ImageOrigin = itkVectorImagePointer->GetOrigin();
+        parameters.m_SignalGen.m_ImageDirection = itkVectorImagePointer->GetDirection();
+        parameters.m_SignalGen.m_Bvalue = static_cast<mitk::FloatProperty*>(dwi->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue();
+        parameters.m_SignalGen.SetGradienDirections(static_cast<mitk::GradientDirectionsProperty*>( dwi->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer());
     }
     else if (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull())   // use geometry of selected image
     {
         mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData());
         itk::Image< float, 3 >::Pointer itkImg = itk::Image< float, 3 >::New();
         CastToItkImage< itk::Image< float, 3 > >(img, itkImg);
 
         parameters.m_SignalGen.m_ImageRegion = itkImg->GetLargestPossibleRegion();
         parameters.m_SignalGen.m_ImageSpacing = itkImg->GetSpacing();
         parameters.m_SignalGen.m_ImageOrigin = itkImg->GetOrigin();
         parameters.m_SignalGen.m_ImageDirection = itkImg->GetDirection();
         parameters.m_SignalGen.SetNumWeightedVolumes(m_Controls->m_NumGradientsBox->value());
         parameters.m_SignalGen.m_Bvalue = m_Controls->m_BvalueBox->value();
     }
     else    // use GUI parameters
     {
         parameters.m_SignalGen.m_ImageRegion.SetSize(0, m_Controls->m_SizeX->value());
         parameters.m_SignalGen.m_ImageRegion.SetSize(1, m_Controls->m_SizeY->value());
         parameters.m_SignalGen.m_ImageRegion.SetSize(2, m_Controls->m_SizeZ->value());
         parameters.m_SignalGen.m_ImageSpacing[0] = m_Controls->m_SpacingX->value();
         parameters.m_SignalGen.m_ImageSpacing[1] = m_Controls->m_SpacingY->value();
         parameters.m_SignalGen.m_ImageSpacing[2] = m_Controls->m_SpacingZ->value();
         parameters.m_SignalGen.m_ImageOrigin[0] = parameters.m_SignalGen.m_ImageSpacing[0]/2;
         parameters.m_SignalGen.m_ImageOrigin[1] = parameters.m_SignalGen.m_ImageSpacing[1]/2;
         parameters.m_SignalGen.m_ImageOrigin[2] = parameters.m_SignalGen.m_ImageSpacing[2]/2;
         parameters.m_SignalGen.m_ImageDirection.SetIdentity();
         parameters.m_SignalGen.SetNumWeightedVolumes(m_Controls->m_NumGradientsBox->value());
         parameters.m_SignalGen.m_Bvalue = m_Controls->m_BvalueBox->value();
         parameters.m_SignalGen.GenerateGradientHalfShell();
     }
 
     // signal relaxation
     parameters.m_SignalGen.m_DoSimulateRelaxation = m_Controls->m_RelaxationBox->isChecked();
     parameters.m_SignalGen.m_SimulateKspaceAcquisition = parameters.m_SignalGen.m_DoSimulateRelaxation;
     if (parameters.m_SignalGen.m_DoSimulateRelaxation && m_Controls->m_FiberBundleComboBox->GetSelectedNode().IsNotNull() )
         parameters.m_Misc.m_ArtifactModelString += "_RELAX";
 
     // N/2 ghosts
     parameters.m_Misc.m_CheckAddGhostsBox = m_Controls->m_AddGhosts->isChecked();
     if (m_Controls->m_AddGhosts->isChecked())
     {
         parameters.m_SignalGen.m_SimulateKspaceAcquisition = true;
         parameters.m_Misc.m_ArtifactModelString += "_GHOST";
         parameters.m_SignalGen.m_KspaceLineOffset = m_Controls->m_kOffsetBox->value();
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Ghost", DoubleProperty::New(parameters.m_SignalGen.m_KspaceLineOffset));
     }
     else
         parameters.m_SignalGen.m_KspaceLineOffset = 0;
 
     // Aliasing
     parameters.m_Misc.m_CheckAddAliasingBox = m_Controls->m_AddAliasing->isChecked();
     if (m_Controls->m_AddAliasing->isChecked())
     {
         parameters.m_SignalGen.m_SimulateKspaceAcquisition = true;
         parameters.m_Misc.m_ArtifactModelString += "_ALIASING";
         parameters.m_SignalGen.m_CroppingFactor = (100-m_Controls->m_WrapBox->value())/100;
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Aliasing", DoubleProperty::New(m_Controls->m_WrapBox->value()));
     }
 
     // Spikes
     parameters.m_Misc.m_CheckAddSpikesBox = m_Controls->m_AddSpikes->isChecked();
     if (m_Controls->m_AddSpikes->isChecked())
     {
         parameters.m_SignalGen.m_SimulateKspaceAcquisition = true;
         parameters.m_SignalGen.m_Spikes = m_Controls->m_SpikeNumBox->value();
         parameters.m_SignalGen.m_SpikeAmplitude = m_Controls->m_SpikeScaleBox->value();
         parameters.m_Misc.m_ArtifactModelString += "_SPIKES";
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Spikes.Number", IntProperty::New(parameters.m_SignalGen.m_Spikes));
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Spikes.Amplitude", DoubleProperty::New(parameters.m_SignalGen.m_SpikeAmplitude));
     }
 
     // gibbs ringing
     parameters.m_SignalGen.m_DoAddGibbsRinging = m_Controls->m_AddGibbsRinging->isChecked();
     if (m_Controls->m_AddGibbsRinging->isChecked())
     {
         parameters.m_SignalGen.m_SimulateKspaceAcquisition = true;
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Ringing", BoolProperty::New(true));
         parameters.m_Misc.m_ArtifactModelString += "_RINGING";
     }
 
     // add distortions
     parameters.m_Misc.m_CheckAddDistortionsBox = m_Controls->m_AddDistortions->isChecked();
     if (m_Controls->m_AddDistortions->isChecked() && m_Controls->m_FrequencyMapBox->GetSelectedNode().IsNotNull())
     {
         mitk::DataNode::Pointer fMapNode = m_Controls->m_FrequencyMapBox->GetSelectedNode();
         mitk::Image* img = dynamic_cast<mitk::Image*>(fMapNode->GetData());
         ItkDoubleImgType::Pointer itkImg = ItkDoubleImgType::New();
         CastToItkImage< ItkDoubleImgType >(img, itkImg);
 
         if (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNull())   // use geometry of frequency map
         {
             parameters.m_SignalGen.m_ImageRegion = itkImg->GetLargestPossibleRegion();
             parameters.m_SignalGen.m_ImageSpacing = itkImg->GetSpacing();
             parameters.m_SignalGen.m_ImageOrigin = itkImg->GetOrigin();
             parameters.m_SignalGen.m_ImageDirection = itkImg->GetDirection();
         }
 
         if (parameters.m_SignalGen.m_ImageRegion.GetSize(0)==itkImg->GetLargestPossibleRegion().GetSize(0) &&
                 parameters.m_SignalGen.m_ImageRegion.GetSize(1)==itkImg->GetLargestPossibleRegion().GetSize(1) &&
                 parameters.m_SignalGen.m_ImageRegion.GetSize(2)==itkImg->GetLargestPossibleRegion().GetSize(2))
         {
             parameters.m_SignalGen.m_SimulateKspaceAcquisition = true;
             itk::ImageDuplicator<ItkDoubleImgType>::Pointer duplicator = itk::ImageDuplicator<ItkDoubleImgType>::New();
             duplicator->SetInputImage(itkImg);
             duplicator->Update();
             parameters.m_SignalGen.m_FrequencyMap = duplicator->GetOutput();
             parameters.m_Misc.m_ArtifactModelString += "_DISTORTED";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Distortions", BoolProperty::New(true));
         }
     }
 
     parameters.m_SignalGen.m_EddyStrength = 0;
     parameters.m_Misc.m_CheckAddEddyCurrentsBox = m_Controls->m_AddEddy->isChecked();
     if (m_Controls->m_AddEddy->isChecked())
     {
         parameters.m_SignalGen.m_EddyStrength = m_Controls->m_EddyGradientStrength->value();
         parameters.m_Misc.m_ArtifactModelString += "_EDDY";
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Eddy-strength", DoubleProperty::New(parameters.m_SignalGen.m_EddyStrength));
     }
 
     // Motion
     parameters.m_SignalGen.m_DoAddMotion = m_Controls->m_AddMotion->isChecked();
     parameters.m_SignalGen.m_DoRandomizeMotion = m_Controls->m_RandomMotion->isChecked();
     parameters.m_SignalGen.m_Translation[0] = m_Controls->m_MaxTranslationBoxX->value();
     parameters.m_SignalGen.m_Translation[1] = m_Controls->m_MaxTranslationBoxY->value();
     parameters.m_SignalGen.m_Translation[2] = m_Controls->m_MaxTranslationBoxZ->value();
     parameters.m_SignalGen.m_Rotation[0] = m_Controls->m_MaxRotationBoxX->value();
     parameters.m_SignalGen.m_Rotation[1] = m_Controls->m_MaxRotationBoxY->value();
     parameters.m_SignalGen.m_Rotation[2] = m_Controls->m_MaxRotationBoxZ->value();
     if ( m_Controls->m_AddMotion->isChecked() && m_Controls->m_FiberBundleComboBox->GetSelectedNode().IsNotNull() )
     {
         parameters.m_Misc.m_ArtifactModelString += "_MOTION";
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Random", BoolProperty::New(parameters.m_SignalGen.m_DoRandomizeMotion));
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Translation-x", DoubleProperty::New(parameters.m_SignalGen.m_Translation[0]));
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Translation-y", DoubleProperty::New(parameters.m_SignalGen.m_Translation[1]));
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Translation-z", DoubleProperty::New(parameters.m_SignalGen.m_Translation[2]));
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Rotation-x", DoubleProperty::New(parameters.m_SignalGen.m_Rotation[0]));
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Rotation-y", DoubleProperty::New(parameters.m_SignalGen.m_Rotation[1]));
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Rotation-z", DoubleProperty::New(parameters.m_SignalGen.m_Rotation[2]));
     }
 
     // other imaging parameters
     parameters.m_SignalGen.m_tLine = m_Controls->m_LineReadoutTimeBox->value();
     parameters.m_SignalGen.m_tInhom = m_Controls->m_T2starBox->value();
     parameters.m_SignalGen.m_tEcho = m_Controls->m_TEbox->value();
     parameters.m_SignalGen.m_DoDisablePartialVolume = m_Controls->m_EnforcePureFiberVoxelsBox->isChecked();
     parameters.m_SignalGen.m_AxonRadius = m_Controls->m_FiberRadius->value();
     parameters.m_SignalGen.m_SignalScale = m_Controls->m_SignalScaleBox->value();
 
     // adjust echo time if needed
     if ( parameters.m_SignalGen.m_tEcho < parameters.m_SignalGen.m_ImageRegion.GetSize(1)*parameters.m_SignalGen.m_tLine )
     {
         this->m_Controls->m_TEbox->setValue( parameters.m_SignalGen.m_ImageRegion.GetSize(1)*parameters.m_SignalGen.m_tLine );
         parameters.m_SignalGen.m_tEcho = m_Controls->m_TEbox->value();
         QMessageBox::information( NULL, "Warning", "Echo time is too short! Time not sufficient to read slice. Automaticall adjusted to "+QString::number(parameters.m_SignalGen.m_tEcho)+" ms");
     }
 
     // Noise
     parameters.m_Misc.m_CheckAddNoiseBox = m_Controls->m_AddNoise->isChecked();
     if (m_Controls->m_AddNoise->isChecked())
     {
         double noiseVariance = m_Controls->m_NoiseLevel->value();
         {
             switch (m_Controls->m_NoiseDistributionBox->currentIndex())
             {
             case 0:
             {
                 parameters.m_NoiseModel = new mitk::RicianNoiseModel<ScalarType>();
                 parameters.m_Misc.m_ArtifactModelString += "_RICIAN-";
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Noise-Distribution", StringProperty::New("Rician"));
                 break;
             }
             case 1:
             {
                 parameters.m_NoiseModel = new mitk::ChiSquareNoiseModel<ScalarType>();
                 parameters.m_Misc.m_ArtifactModelString += "_CHISQUARED-";
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Noise-Distribution", StringProperty::New("Chi-squared"));
                 break;
             }
             default:
             {
                 parameters.m_NoiseModel = new mitk::RicianNoiseModel<ScalarType>();
                 parameters.m_Misc.m_ArtifactModelString += "_RICIAN-";
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Noise-Distribution", StringProperty::New("Rician"));
             }
             }
         }
         parameters.m_NoiseModel->SetNoiseVariance(noiseVariance);
         parameters.m_Misc.m_ArtifactModelString += QString::number(noiseVariance).toStdString();
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Noise-Variance", DoubleProperty::New(noiseVariance));
     }
 
     // adjusting line readout time to the adapted image size needed for the DFT
     unsigned int y = parameters.m_SignalGen.m_ImageRegion.GetSize(1);
     y += y%2;
     if ( y>parameters.m_SignalGen.m_ImageRegion.GetSize(1) )
         parameters.m_SignalGen.m_tLine *= (double)parameters.m_SignalGen.m_ImageRegion.GetSize(1)/y;
 
     // signal models
     {
         // compartment 1
         switch (m_Controls->m_Compartment1Box->currentIndex())
         {
         case 0:
         {
             mitk::StickModel<ScalarType>* model = new mitk::StickModel<ScalarType>();
             model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
             model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
             model->SetDiffusivity(m_Controls->m_StickWidget1->GetD());
             model->SetT2(m_Controls->m_StickWidget1->GetT2());
             model->m_CompartmentId = 1;
             parameters.m_FiberModelList.push_back(model);
             parameters.m_Misc.m_SignalModelString += "Stick";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Stick") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.D", DoubleProperty::New(m_Controls->m_StickWidget1->GetD()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.T2", DoubleProperty::New(model->GetT2()) );
             break;
         }
         case 1:
         {
             mitk::TensorModel<ScalarType>* model = new mitk::TensorModel<ScalarType>();
             model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
             model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
             model->SetDiffusivity1(m_Controls->m_ZeppelinWidget1->GetD1());
             model->SetDiffusivity2(m_Controls->m_ZeppelinWidget1->GetD2());
             model->SetDiffusivity3(m_Controls->m_ZeppelinWidget1->GetD2());
             model->SetT2(m_Controls->m_ZeppelinWidget1->GetT2());
             model->m_CompartmentId = 1;
             parameters.m_FiberModelList.push_back(model);
             parameters.m_Misc.m_SignalModelString += "Zeppelin";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Zeppelin") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.D1", DoubleProperty::New(m_Controls->m_ZeppelinWidget1->GetD1()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.D2", DoubleProperty::New(m_Controls->m_ZeppelinWidget1->GetD2()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.T2", DoubleProperty::New(model->GetT2()) );
             break;
         }
         case 2:
         {
             mitk::TensorModel<ScalarType>* model = new mitk::TensorModel<ScalarType>();
             model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
             model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
             model->SetDiffusivity1(m_Controls->m_TensorWidget1->GetD1());
             model->SetDiffusivity2(m_Controls->m_TensorWidget1->GetD2());
             model->SetDiffusivity3(m_Controls->m_TensorWidget1->GetD3());
             model->SetT2(m_Controls->m_TensorWidget1->GetT2());
             model->m_CompartmentId = 1;
             parameters.m_FiberModelList.push_back(model);
             parameters.m_Misc.m_SignalModelString += "Tensor";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Tensor") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.D1", DoubleProperty::New(m_Controls->m_TensorWidget1->GetD1()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.D2", DoubleProperty::New(m_Controls->m_TensorWidget1->GetD2()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.D3", DoubleProperty::New(m_Controls->m_TensorWidget1->GetD3()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.T2", DoubleProperty::New(model->GetT2()) );
             break;
         }
         case 3:
         {
             mitk::RawShModel<ScalarType>* model = new mitk::RawShModel<ScalarType>();
             parameters.m_SignalGen.m_DoSimulateRelaxation = false;
             model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
             model->SetMaxNumKernels(m_Controls->m_PrototypeWidget1->GetNumberOfSamples());
             model->SetFaRange(m_Controls->m_PrototypeWidget1->GetMinFa(), m_Controls->m_PrototypeWidget1->GetMaxFa());
             model->SetAdcRange(m_Controls->m_PrototypeWidget1->GetMinAdc(), m_Controls->m_PrototypeWidget1->GetMaxAdc());
             model->m_CompartmentId = 1;
             parameters.m_FiberModelList.push_back(model);
             parameters.m_Misc.m_SignalModelString += "Prototype";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Prototype") );
             break;
         }
         }
 
         // compartment 2
         switch (m_Controls->m_Compartment2Box->currentIndex())
         {
         case 0:
             break;
         case 1:
         {
             mitk::StickModel<ScalarType>* model = new mitk::StickModel<ScalarType>();
             model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
             model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
             model->SetDiffusivity(m_Controls->m_StickWidget2->GetD());
             model->SetT2(m_Controls->m_StickWidget2->GetT2());
             model->m_CompartmentId = 2;
             parameters.m_FiberModelList.push_back(model);
             parameters.m_Misc.m_SignalModelString += "Stick";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.Description", StringProperty::New("Inter-axonal compartment") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.Model", StringProperty::New("Stick") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.D", DoubleProperty::New(m_Controls->m_StickWidget2->GetD()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.T2", DoubleProperty::New(model->GetT2()) );
             break;
         }
         case 2:
         {
             mitk::TensorModel<ScalarType>* model = new mitk::TensorModel<ScalarType>();
             model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
             model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
             model->SetDiffusivity1(m_Controls->m_ZeppelinWidget2->GetD1());
             model->SetDiffusivity2(m_Controls->m_ZeppelinWidget2->GetD2());
             model->SetDiffusivity3(m_Controls->m_ZeppelinWidget2->GetD2());
             model->SetT2(m_Controls->m_ZeppelinWidget2->GetT2());
             model->m_CompartmentId = 2;
             parameters.m_FiberModelList.push_back(model);
             parameters.m_Misc.m_SignalModelString += "Zeppelin";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.Description", StringProperty::New("Inter-axonal compartment") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.Model", StringProperty::New("Zeppelin") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.D1", DoubleProperty::New(m_Controls->m_ZeppelinWidget2->GetD1()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.D2", DoubleProperty::New(m_Controls->m_ZeppelinWidget2->GetD2()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.T2", DoubleProperty::New(model->GetT2()) );
             break;
         }
         case 3:
         {
             mitk::TensorModel<ScalarType>* model = new mitk::TensorModel<ScalarType>();
             model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
             model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
             model->SetDiffusivity1(m_Controls->m_TensorWidget2->GetD1());
             model->SetDiffusivity2(m_Controls->m_TensorWidget2->GetD2());
             model->SetDiffusivity3(m_Controls->m_TensorWidget2->GetD3());
             model->SetT2(m_Controls->m_TensorWidget2->GetT2());
             model->m_CompartmentId = 2;
             parameters.m_FiberModelList.push_back(model);
             parameters.m_Misc.m_SignalModelString += "Tensor";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.Description", StringProperty::New("Inter-axonal compartment") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.Model", StringProperty::New("Tensor") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.D1", DoubleProperty::New(m_Controls->m_TensorWidget2->GetD1()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.D2", DoubleProperty::New(m_Controls->m_TensorWidget2->GetD2()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.D3", DoubleProperty::New(m_Controls->m_TensorWidget2->GetD3()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.T2", DoubleProperty::New(model->GetT2()) );
             break;
         }
         }
 
         // compartment 3
         switch (m_Controls->m_Compartment3Box->currentIndex())
         {
         case 0:
         {
             mitk::BallModel<ScalarType>* model = new mitk::BallModel<ScalarType>();
             model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
             model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
             model->SetDiffusivity(m_Controls->m_BallWidget1->GetD());
             model->SetT2(m_Controls->m_BallWidget1->GetT2());
             model->m_CompartmentId = 3;
             parameters.m_NonFiberModelList.push_back(model);
             parameters.m_Misc.m_SignalModelString += "Ball";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Ball") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.D", DoubleProperty::New(m_Controls->m_BallWidget1->GetD()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.T2", DoubleProperty::New(model->GetT2()) );
             break;
         }
         case 1:
         {
             mitk::AstroStickModel<ScalarType>* model = new mitk::AstroStickModel<ScalarType>();
             model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
             model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
             model->SetDiffusivity(m_Controls->m_AstrosticksWidget1->GetD());
             model->SetT2(m_Controls->m_AstrosticksWidget1->GetT2());
             model->SetRandomizeSticks(m_Controls->m_AstrosticksWidget1->GetRandomizeSticks());
             model->m_CompartmentId = 3;
             parameters.m_NonFiberModelList.push_back(model);
             parameters.m_Misc.m_SignalModelString += "Astrosticks";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Astrosticks") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.D", DoubleProperty::New(m_Controls->m_AstrosticksWidget1->GetD()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.T2", DoubleProperty::New(model->GetT2()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.RandomSticks", BoolProperty::New(m_Controls->m_AstrosticksWidget1->GetRandomizeSticks()) );
             break;
         }
         case 2:
         {
             mitk::DotModel<ScalarType>* model = new mitk::DotModel<ScalarType>();
             model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
             model->SetT2(m_Controls->m_DotWidget1->GetT2());
             model->m_CompartmentId = 3;
             parameters.m_NonFiberModelList.push_back(model);
             parameters.m_Misc.m_SignalModelString += "Dot";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Dot") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.T2", DoubleProperty::New(model->GetT2()) );
             break;
         }
         case 3:
         {
             mitk::RawShModel<ScalarType>* model = new mitk::RawShModel<ScalarType>();
             parameters.m_SignalGen.m_DoSimulateRelaxation = false;
             model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
             model->SetMaxNumKernels(m_Controls->m_PrototypeWidget3->GetNumberOfSamples());
             model->SetFaRange(m_Controls->m_PrototypeWidget3->GetMinFa(), m_Controls->m_PrototypeWidget3->GetMaxFa());
             model->SetAdcRange(m_Controls->m_PrototypeWidget3->GetMinAdc(), m_Controls->m_PrototypeWidget3->GetMaxAdc());
             model->m_CompartmentId = 3;
             parameters.m_NonFiberModelList.push_back(model);
             parameters.m_Misc.m_SignalModelString += "Prototype";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Prototype") );
             break;
         }
         }
 
         // compartment 4
         ItkDoubleImgType::Pointer comp4VolumeImage = NULL;
         ItkDoubleImgType::Pointer comp3VolumeImage = NULL;
         if (m_Controls->m_Compartment4Box->currentIndex()>0)
         {
             mitk::DataNode::Pointer volumeNode = m_Controls->m_Comp4VolumeFraction->GetSelectedNode();
             if (volumeNode.IsNull())
             {
                 QMessageBox::information( NULL, "Information", "No volume fraction image selected! Second extra-axonal compartment has been disabled for this simultation.");
                 MITK_WARN << "No volume fraction image selected! Second extra-axonal compartment has been disabled.";
             }
             else
             {
                 MITK_INFO << "Rescaling volume fraction image...";
                 comp4VolumeImage = ItkDoubleImgType::New();
                 mitk::Image* img = dynamic_cast<mitk::Image*>(volumeNode->GetData());
                 CastToItkImage< ItkDoubleImgType >(img, comp4VolumeImage);
 
                 double max = itk::NumericTraits<double>::min();
                 double min = itk::NumericTraits<double>::max();
 
                 itk::ImageRegionIterator< ItkDoubleImgType > it(comp4VolumeImage, comp4VolumeImage->GetLargestPossibleRegion());
                 while(!it.IsAtEnd())
                 {
                     if (parameters.m_SignalGen.m_MaskImage.IsNotNull() && parameters.m_SignalGen.m_MaskImage->GetPixel(it.GetIndex())<=0)
                     {
                         it.Set(0.0);
                         ++it;
                         continue;
                     }
                     if (it.Get()>900)
                         it.Set(900);
 
                     if (it.Get()>max)
                         max = it.Get();
                     if (it.Get()<min)
                         min = it.Get();
                     ++it;
                 }
                 itk::ShiftScaleImageFilter< ItkDoubleImgType, ItkDoubleImgType >::Pointer scaler = itk::ShiftScaleImageFilter< ItkDoubleImgType, ItkDoubleImgType >::New();
                 scaler->SetInput(comp4VolumeImage);
                 scaler->SetShift(-min);
                 scaler->SetScale(1.0/(max-min));
                 scaler->Update();
                 comp4VolumeImage = scaler->GetOutput();
 
 //                itk::ImageFileWriter< ItkDoubleImgType >::Pointer wr = itk::ImageFileWriter< ItkDoubleImgType >::New();
 //                wr->SetInput(comp4VolumeImage);
 //                wr->SetFileName("/local/comp4.nrrd");
 //                wr->Update();
 
                 //            if (max>1 || min<0) // are volume fractions between 0 and 1?
                 //            {
                 //                itk::RescaleIntensityImageFilter<ItkDoubleImgType,ItkDoubleImgType>::Pointer rescaler = itk::RescaleIntensityImageFilter<ItkDoubleImgType,ItkDoubleImgType>::New();
                 //                rescaler->SetInput(0, comp4VolumeImage);
                 //                rescaler->SetOutputMaximum(1);
                 //                rescaler->SetOutputMinimum(0);
                 //                rescaler->Update();
                 //                comp4VolumeImage = rescaler->GetOutput();
                 //            }
 
                 itk::InvertIntensityImageFilter< ItkDoubleImgType, ItkDoubleImgType >::Pointer inverter = itk::InvertIntensityImageFilter< ItkDoubleImgType, ItkDoubleImgType >::New();
                 inverter->SetMaximum(1.0);
                 inverter->SetInput(comp4VolumeImage);
                 inverter->Update();
                 comp3VolumeImage = inverter->GetOutput();
             }
         }
 
         if (comp4VolumeImage.IsNotNull())
         {
             switch (m_Controls->m_Compartment4Box->currentIndex())
             {
             case 0:
                 break;
             case 1:
             {
                 mitk::BallModel<ScalarType>* model = new mitk::BallModel<ScalarType>();
                 model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
                 model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
                 model->SetDiffusivity(m_Controls->m_BallWidget2->GetD());
                 model->SetT2(m_Controls->m_BallWidget2->GetT2());
                 model->SetVolumeFractionImage(comp4VolumeImage);
                 model->m_CompartmentId = 4;
                 parameters.m_NonFiberModelList.back()->SetVolumeFractionImage(comp3VolumeImage);
                 parameters.m_NonFiberModelList.push_back(model);
                 parameters.m_Misc.m_SignalModelString += "Ball";
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Ball") );
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.D", DoubleProperty::New(m_Controls->m_BallWidget2->GetD()) );
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.T2", DoubleProperty::New(model->GetT2()) );
                 break;
             }
             case 2:
             {
                 mitk::AstroStickModel<ScalarType>* model = new mitk::AstroStickModel<ScalarType>();
                 model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
                 model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
                 model->SetDiffusivity(m_Controls->m_AstrosticksWidget2->GetD());
                 model->SetT2(m_Controls->m_AstrosticksWidget2->GetT2());
                 model->SetRandomizeSticks(m_Controls->m_AstrosticksWidget2->GetRandomizeSticks());
                 parameters.m_NonFiberModelList.back()->SetVolumeFractionImage(comp3VolumeImage);
                 model->SetVolumeFractionImage(comp4VolumeImage);
                 model->m_CompartmentId = 4;
                 parameters.m_NonFiberModelList.push_back(model);
                 parameters.m_Misc.m_SignalModelString += "Astrosticks";
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Astrosticks") );
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.D", DoubleProperty::New(m_Controls->m_AstrosticksWidget2->GetD()) );
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.T2", DoubleProperty::New(model->GetT2()) );
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.RandomSticks", BoolProperty::New(m_Controls->m_AstrosticksWidget2->GetRandomizeSticks()) );
                 break;
             }
             case 3:
             {
                 mitk::DotModel<ScalarType>* model = new mitk::DotModel<ScalarType>();
                 model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
                 model->SetT2(m_Controls->m_DotWidget2->GetT2());
                 model->SetVolumeFractionImage(comp4VolumeImage);
                 model->m_CompartmentId = 4;
                 parameters.m_NonFiberModelList.back()->SetVolumeFractionImage(comp3VolumeImage);
                 parameters.m_NonFiberModelList.push_back(model);
                 parameters.m_Misc.m_SignalModelString += "Dot";
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Dot") );
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.T2", DoubleProperty::New(model->GetT2()) );
                 break;
             }
             case 4:
             {
                 mitk::RawShModel<ScalarType>* model = new mitk::RawShModel<ScalarType>();
                 parameters.m_SignalGen.m_DoSimulateRelaxation = false;
                 model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
                 model->SetMaxNumKernels(m_Controls->m_PrototypeWidget4->GetNumberOfSamples());
                 model->SetFaRange(m_Controls->m_PrototypeWidget4->GetMinFa(), m_Controls->m_PrototypeWidget4->GetMaxFa());
                 model->SetAdcRange(m_Controls->m_PrototypeWidget4->GetMinAdc(), m_Controls->m_PrototypeWidget4->GetMaxAdc());
                 model->SetVolumeFractionImage(comp4VolumeImage);
                 model->m_CompartmentId = 4;
                 parameters.m_NonFiberModelList.back()->SetVolumeFractionImage(comp3VolumeImage);
                 parameters.m_NonFiberModelList.push_back(model);
                 parameters.m_Misc.m_SignalModelString += "Prototype";
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Prototype") );
                 break;
             }
             }
         }
     }
 
     parameters.m_SignalGen.m_FiberSeparationThreshold = m_Controls->m_SeparationAngleBox->value();
     switch (m_Controls->m_DiffusionDirectionBox->currentIndex())
     {
     case 0:
         parameters.m_SignalGen.m_DiffusionDirectionMode = SignalGenerationParameters::FIBER_TANGENT_DIRECTIONS;
         break;
     case 1:
         parameters.m_SignalGen.m_DiffusionDirectionMode = SignalGenerationParameters::MAIN_FIBER_DIRECTIONS;
         break;
     case 2:
         parameters.m_SignalGen.m_DiffusionDirectionMode = SignalGenerationParameters::RANDOM_DIRECTIONS;
         parameters.m_SignalGen.m_DoAddMotion = false;
         parameters.m_SignalGen.m_DoAddGibbsRinging = false;
         parameters.m_SignalGen.m_KspaceLineOffset = 0.0;
         parameters.m_SignalGen.m_FrequencyMap = NULL;
         parameters.m_SignalGen.m_CroppingFactor = 1.0;
         parameters.m_SignalGen.m_EddyStrength = 0;
         break;
     default:
         parameters.m_SignalGen.m_DiffusionDirectionMode = SignalGenerationParameters::FIBER_TANGENT_DIRECTIONS;
     }
 
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.SignalScale", IntProperty::New(parameters.m_SignalGen.m_SignalScale));
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.FiberRadius", IntProperty::New(parameters.m_SignalGen.m_AxonRadius));
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Tinhom", DoubleProperty::New(parameters.m_SignalGen.m_tInhom));
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Tline", DoubleProperty::New(parameters.m_SignalGen.m_tLine));
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.TE", DoubleProperty::New(parameters.m_SignalGen.m_tEcho));
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.b-value", DoubleProperty::New(parameters.m_SignalGen.m_Bvalue));
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.NoPartialVolume", BoolProperty::New(parameters.m_SignalGen.m_DoDisablePartialVolume));
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Relaxation", BoolProperty::New(parameters.m_SignalGen.m_DoSimulateRelaxation));
     parameters.m_Misc.m_ResultNode->AddProperty("binary", BoolProperty::New(false));
 
     parameters.m_Misc.m_CheckRealTimeFibersBox = m_Controls->m_RealTimeFibers->isChecked();
     parameters.m_Misc.m_CheckAdvancedFiberOptionsBox = m_Controls->m_AdvancedOptionsBox->isChecked();
     parameters.m_Misc.m_CheckIncludeFiducialsBox = m_Controls->m_IncludeFiducials->isChecked();
     parameters.m_Misc.m_CheckConstantRadiusBox = m_Controls->m_ConstantRadiusBox->isChecked();
 
     switch(m_Controls->m_DistributionBox->currentIndex())
     {
     case 0:
         parameters.m_FiberGen.m_Distribution = FiberGenerationParameters::DISTRIBUTE_UNIFORM;
         break;
     case 1:
         parameters.m_FiberGen.m_Distribution = FiberGenerationParameters::DISTRIBUTE_GAUSSIAN;
         break;
     default:
         parameters.m_FiberGen.m_Distribution = FiberGenerationParameters::DISTRIBUTE_UNIFORM;
     }
     parameters.m_FiberGen.m_Variance = m_Controls->m_VarianceBox->value();
     parameters.m_FiberGen.m_Density = m_Controls->m_FiberDensityBox->value();
     parameters.m_FiberGen.m_Sampling = m_Controls->m_FiberSamplingBox->value();
     parameters.m_FiberGen.m_Tension = m_Controls->m_TensionBox->value();
     parameters.m_FiberGen.m_Continuity = m_Controls->m_ContinuityBox->value();
     parameters.m_FiberGen.m_Bias = m_Controls->m_BiasBox->value();
     parameters.m_FiberGen.m_Rotation[0] = m_Controls->m_XrotBox->value();
     parameters.m_FiberGen.m_Rotation[1] = m_Controls->m_YrotBox->value();
     parameters.m_FiberGen.m_Rotation[2] = m_Controls->m_ZrotBox->value();
     parameters.m_FiberGen.m_Translation[0] = m_Controls->m_XtransBox->value();
     parameters.m_FiberGen.m_Translation[1] = m_Controls->m_YtransBox->value();
     parameters.m_FiberGen.m_Translation[2] = m_Controls->m_ZtransBox->value();
     parameters.m_FiberGen.m_Scale[0] = m_Controls->m_XscaleBox->value();
     parameters.m_FiberGen.m_Scale[1] = m_Controls->m_YscaleBox->value();
     parameters.m_FiberGen.m_Scale[2] = m_Controls->m_ZscaleBox->value();
 
     return parameters;
 }
 
 void QmitkFiberfoxView::SaveParameters()
 {
     FiberfoxParameters<> ffParamaters = UpdateImageParameters<double>();
 
     QString filename = QFileDialog::getSaveFileName(
                 0,
                 tr("Save Parameters"),
                 m_ParameterFile,
                 tr("Fiberfox Parameters (*.ffp)") );
 
     bool ok = true;
     bool first = true;
     bool dosampling = false;
-    mitk::DiffusionImage<short>::Pointer diffImg = NULL;
+    mitk::Image::Pointer diffImg = NULL;
     itk::Image< itk::DiffusionTensor3D< double >, 3 >::Pointer tensorImage = NULL;
     const int shOrder = 2;
     typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,shOrder,QBALL_ODFSIZE> QballFilterType;
     QballFilterType::CoefficientImageType::Pointer itkFeatureImage = NULL;
     ItkDoubleImgType::Pointer adcImage = NULL;
 
     for (unsigned int i=0; i<ffParamaters.m_FiberModelList.size()+ffParamaters.m_NonFiberModelList.size(); i++)
     {
         mitk::RawShModel<>* model = NULL;
         if (i<ffParamaters.m_FiberModelList.size())
             model = dynamic_cast<  mitk::RawShModel<>* >(ffParamaters.m_FiberModelList.at(i));
         else
             model = dynamic_cast<  mitk::RawShModel<>* >(ffParamaters.m_NonFiberModelList.at(i-ffParamaters.m_FiberModelList.size()));
 
         if (model!=0 && model->GetNumberOfKernels()<=0)
         {
             if (first==true)
             {
                 if (QMessageBox::question(NULL, "Prototype signal sampling", "Do you want to sample prototype signals from the selected diffusion-weighted imag and save them?",QMessageBox::Yes,QMessageBox::No)==QMessageBox::Yes)
                     dosampling = true;
 
                 first = false;
-                if (dosampling && (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNull() || !dynamic_cast<mitk::DiffusionImage<short>*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData())))
+                if (dosampling && (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNull() || !mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData()))))
                 {
                     QMessageBox::information(NULL, "Parameter file not saved", "No diffusion-weighted image selected to sample signal from.");
                     return;
                 }
                 else if (dosampling)
                 {
-                    diffImg = dynamic_cast<mitk::DiffusionImage<short>*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData());
-
-                    typedef itk::DiffusionTensor3DReconstructionImageFilter< short, short, double > TensorReconstructionImageFilterType;
-                    TensorReconstructionImageFilterType::Pointer filter = TensorReconstructionImageFilterType::New();
-                    filter->SetGradientImage( diffImg->GetDirections(), diffImg->GetVectorImage() );
-                    filter->SetBValue(diffImg->GetReferenceBValue());
-                    filter->Update();
-                    tensorImage = filter->GetOutput();
-
-                    const int NumCoeffs = (shOrder*shOrder + shOrder + 2)/2 + shOrder;
-                    QballFilterType::Pointer qballfilter = QballFilterType::New();
-                    qballfilter->SetGradientImage( diffImg->GetDirections(), diffImg->GetVectorImage() );
-                    qballfilter->SetBValue(diffImg->GetReferenceBValue());
-                    qballfilter->SetLambda(0.006);
-                    qballfilter->SetNormalizationMethod(QballFilterType::QBAR_RAW_SIGNAL);
-                    qballfilter->Update();
-                    itkFeatureImage = qballfilter->GetCoefficientImage();
-
-                    itk::AdcImageFilter< short, double >::Pointer adcFilter = itk::AdcImageFilter< short, double >::New();
-                    adcFilter->SetInput(diffImg->GetVectorImage());
-                    adcFilter->SetGradientDirections(diffImg->GetDirections());
-                    adcFilter->SetB_value(diffImg->GetReferenceBValue());
-                    adcFilter->Update();
-                    adcImage = adcFilter->GetOutput();
+                  diffImg = dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData());
+
+                  typedef itk::DiffusionTensor3DReconstructionImageFilter< short, short, double > TensorReconstructionImageFilterType;
+                  TensorReconstructionImageFilterType::Pointer filter = TensorReconstructionImageFilterType::New();
+                  ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+                  mitk::CastToItkImage(diffImg, itkVectorImagePointer);
+                  filter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), itkVectorImagePointer );
+                  filter->SetBValue( static_cast<mitk::FloatProperty*>(diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
+
+                  filter->Update();
+                  tensorImage = filter->GetOutput();
+
+                  const int NumCoeffs = (shOrder*shOrder + shOrder + 2)/2 + shOrder;
+                  QballFilterType::Pointer qballfilter = QballFilterType::New();
+                  qballfilter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), itkVectorImagePointer );
+                  qballfilter->SetBValue( static_cast<mitk::FloatProperty*>(diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
+                  qballfilter->SetLambda(0.006);
+                  qballfilter->SetNormalizationMethod(QballFilterType::QBAR_RAW_SIGNAL);
+                  qballfilter->Update();
+                  itkFeatureImage = qballfilter->GetCoefficientImage();
+
+                  itk::AdcImageFilter< short, double >::Pointer adcFilter = itk::AdcImageFilter< short, double >::New();
+                  adcFilter->SetInput( itkVectorImagePointer );
+                  adcFilter->SetGradientDirections( static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() );
+                  adcFilter->SetB_value( static_cast<mitk::FloatProperty*>(diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
+                  adcFilter->Update();
+                  adcImage = adcFilter->GetOutput();
                 }
             }
 
             if (dosampling && diffImg.IsNotNull())
             {
                 ok = model->SampleKernels(diffImg, ffParamaters.m_SignalGen.m_MaskImage, tensorImage, itkFeatureImage, adcImage);
                 if (!ok)
                 {
                     QMessageBox::information( NULL, "Parameter file not saved", "No valid prototype signals could be sampled.");
                     return;
                 }
             }
         }
     }
 
     ffParamaters.SaveParameters(filename.toStdString());
     m_ParameterFile = filename;
 }
 
 void QmitkFiberfoxView::LoadParameters()
 {
     QString filename = QFileDialog::getOpenFileName(0, tr("Load Parameters"), QString(itksys::SystemTools::GetFilenamePath(m_ParameterFile.toStdString()).c_str()), tr("Fiberfox Parameters (*.ffp)") );
     if(filename.isEmpty() || filename.isNull())
         return;
 
     m_ParameterFile = filename;
 
     FiberfoxParameters<> parameters;
     parameters.LoadParameters(filename.toStdString());
 
     m_Controls->m_RealTimeFibers->setChecked(parameters.m_Misc.m_CheckRealTimeFibersBox);
     m_Controls->m_AdvancedOptionsBox->setChecked(parameters.m_Misc.m_CheckAdvancedFiberOptionsBox);
     m_Controls->m_IncludeFiducials->setChecked(parameters.m_Misc.m_CheckIncludeFiducialsBox);
     m_Controls->m_ConstantRadiusBox->setChecked(parameters.m_Misc.m_CheckConstantRadiusBox);
 
     m_Controls->m_DistributionBox->setCurrentIndex(parameters.m_FiberGen.m_Distribution);
     m_Controls->m_VarianceBox->setValue(parameters.m_FiberGen.m_Variance);
     m_Controls->m_FiberDensityBox->setValue(parameters.m_FiberGen.m_Density);
     m_Controls->m_FiberSamplingBox->setValue(parameters.m_FiberGen.m_Sampling);
     m_Controls->m_TensionBox->setValue(parameters.m_FiberGen.m_Tension);
     m_Controls->m_ContinuityBox->setValue(parameters.m_FiberGen.m_Continuity);
     m_Controls->m_BiasBox->setValue(parameters.m_FiberGen.m_Bias);
     m_Controls->m_XrotBox->setValue(parameters.m_FiberGen.m_Rotation[0]);
     m_Controls->m_YrotBox->setValue(parameters.m_FiberGen.m_Rotation[1]);
     m_Controls->m_ZrotBox->setValue(parameters.m_FiberGen.m_Rotation[2]);
     m_Controls->m_XtransBox->setValue(parameters.m_FiberGen.m_Translation[0]);
     m_Controls->m_YtransBox->setValue(parameters.m_FiberGen.m_Translation[1]);
     m_Controls->m_ZtransBox->setValue(parameters.m_FiberGen.m_Translation[2]);
     m_Controls->m_XscaleBox->setValue(parameters.m_FiberGen.m_Scale[0]);
     m_Controls->m_YscaleBox->setValue(parameters.m_FiberGen.m_Scale[1]);
     m_Controls->m_ZscaleBox->setValue(parameters.m_FiberGen.m_Scale[2]);
 
     // image generation parameters
     m_Controls->m_SizeX->setValue(parameters.m_SignalGen.m_ImageRegion.GetSize(0));
     m_Controls->m_SizeY->setValue(parameters.m_SignalGen.m_ImageRegion.GetSize(1));
     m_Controls->m_SizeZ->setValue(parameters.m_SignalGen.m_ImageRegion.GetSize(2));
     m_Controls->m_SpacingX->setValue(parameters.m_SignalGen.m_ImageSpacing[0]);
     m_Controls->m_SpacingY->setValue(parameters.m_SignalGen.m_ImageSpacing[1]);
     m_Controls->m_SpacingZ->setValue(parameters.m_SignalGen.m_ImageSpacing[2]);
     m_Controls->m_NumGradientsBox->setValue(parameters.m_SignalGen.GetNumWeightedVolumes());
     m_Controls->m_BvalueBox->setValue(parameters.m_SignalGen.m_Bvalue);
     m_Controls->m_SignalScaleBox->setValue(parameters.m_SignalGen.m_SignalScale);
     m_Controls->m_TEbox->setValue(parameters.m_SignalGen.m_tEcho);
     m_Controls->m_LineReadoutTimeBox->setValue(parameters.m_SignalGen.m_tLine);
     m_Controls->m_T2starBox->setValue(parameters.m_SignalGen.m_tInhom);
     m_Controls->m_FiberRadius->setValue(parameters.m_SignalGen.m_AxonRadius);
     m_Controls->m_RelaxationBox->setChecked(parameters.m_SignalGen.m_DoSimulateRelaxation);
     m_Controls->m_EnforcePureFiberVoxelsBox->setChecked(parameters.m_SignalGen.m_DoDisablePartialVolume);
 
     if (parameters.m_NoiseModel!=NULL)
     {
         m_Controls->m_AddNoise->setChecked(parameters.m_Misc.m_CheckAddNoiseBox);
         if (dynamic_cast<mitk::RicianNoiseModel<double>*>(parameters.m_NoiseModel))
             m_Controls->m_NoiseDistributionBox->setCurrentIndex(0);
         else if (dynamic_cast<mitk::ChiSquareNoiseModel<double>*>(parameters.m_NoiseModel))
             m_Controls->m_NoiseDistributionBox->setCurrentIndex(1);
         m_Controls->m_NoiseLevel->setValue(parameters.m_NoiseModel->GetNoiseVariance());
     }
     else
         m_Controls->m_AddNoise->setChecked(false);
 
     m_Controls->m_VolumeFractionsBox->setChecked(parameters.m_Misc.m_CheckOutputVolumeFractionsBox);
     m_Controls->m_AdvancedOptionsBox_2->setChecked(parameters.m_Misc.m_CheckAdvancedSignalOptionsBox);
     m_Controls->m_AddGhosts->setChecked(parameters.m_Misc.m_CheckAddGhostsBox);
     m_Controls->m_AddAliasing->setChecked(parameters.m_Misc.m_CheckAddAliasingBox);
     m_Controls->m_AddDistortions->setChecked(parameters.m_Misc.m_CheckAddDistortionsBox);
     m_Controls->m_AddSpikes->setChecked(parameters.m_Misc.m_CheckAddSpikesBox);
     m_Controls->m_AddEddy->setChecked(parameters.m_Misc.m_CheckAddEddyCurrentsBox);
 
     m_Controls->m_kOffsetBox->setValue(parameters.m_SignalGen.m_KspaceLineOffset);
     m_Controls->m_WrapBox->setValue(100*(1-parameters.m_SignalGen.m_CroppingFactor));
     m_Controls->m_SpikeNumBox->setValue(parameters.m_SignalGen.m_Spikes);
     m_Controls->m_SpikeScaleBox->setValue(parameters.m_SignalGen.m_SpikeAmplitude);
     m_Controls->m_EddyGradientStrength->setValue(parameters.m_SignalGen.m_EddyStrength);
     m_Controls->m_AddGibbsRinging->setChecked(parameters.m_SignalGen.m_DoAddGibbsRinging);
     m_Controls->m_AddMotion->setChecked(parameters.m_SignalGen.m_DoAddMotion);
     m_Controls->m_RandomMotion->setChecked(parameters.m_SignalGen.m_DoRandomizeMotion);
     m_Controls->m_MaxTranslationBoxX->setValue(parameters.m_SignalGen.m_Translation[0]);
     m_Controls->m_MaxTranslationBoxY->setValue(parameters.m_SignalGen.m_Translation[1]);
     m_Controls->m_MaxTranslationBoxZ->setValue(parameters.m_SignalGen.m_Translation[2]);
     m_Controls->m_MaxRotationBoxX->setValue(parameters.m_SignalGen.m_Rotation[0]);
     m_Controls->m_MaxRotationBoxY->setValue(parameters.m_SignalGen.m_Rotation[1]);
     m_Controls->m_MaxRotationBoxZ->setValue(parameters.m_SignalGen.m_Rotation[2]);
     m_Controls->m_DiffusionDirectionBox->setCurrentIndex(parameters.m_SignalGen.m_DiffusionDirectionMode);
     m_Controls->m_SeparationAngleBox->setValue(parameters.m_SignalGen.m_FiberSeparationThreshold);
 
     m_Controls->m_Compartment1Box->setCurrentIndex(0);
     m_Controls->m_Compartment2Box->setCurrentIndex(0);
     m_Controls->m_Compartment3Box->setCurrentIndex(0);
     m_Controls->m_Compartment4Box->setCurrentIndex(0);
 
     for (unsigned int i=0; i<parameters.m_FiberModelList.size()+parameters.m_NonFiberModelList.size(); i++)
     {
         mitk::DiffusionSignalModel<ScalarType>* signalModel = NULL;
         if (i<parameters.m_FiberModelList.size())
             signalModel = parameters.m_FiberModelList.at(i);
         else
             signalModel = parameters.m_NonFiberModelList.at(i-parameters.m_FiberModelList.size());
 
         switch (signalModel->m_CompartmentId)
         {
         case 1:
         {
             if (dynamic_cast<mitk::StickModel<>*>(signalModel))
             {
                 mitk::StickModel<>* model = dynamic_cast<mitk::StickModel<>*>(signalModel);
                 m_Controls->m_StickWidget1->SetT2(model->GetT2());
                 m_Controls->m_StickWidget1->SetD(model->GetDiffusivity());
                 m_Controls->m_Compartment1Box->setCurrentIndex(0);
                 break;
             }
             else if (dynamic_cast<mitk::TensorModel<>*>(signalModel))
             {
                 mitk::TensorModel<>* model = dynamic_cast<mitk::TensorModel<>*>(signalModel);
                 m_Controls->m_TensorWidget1->SetT2(model->GetT2());
                 m_Controls->m_TensorWidget1->SetD1(model->GetDiffusivity1());
                 m_Controls->m_TensorWidget1->SetD2(model->GetDiffusivity2());
                 m_Controls->m_TensorWidget1->SetD3(model->GetDiffusivity3());
                 m_Controls->m_Compartment1Box->setCurrentIndex(2);
                 break;
             }
             else if (dynamic_cast<mitk::RawShModel<>*>(signalModel))
             {
                 mitk::RawShModel<>* model = dynamic_cast<mitk::RawShModel<>*>(signalModel);
                 m_Controls->m_PrototypeWidget1->SetNumberOfSamples(model->GetMaxNumKernels());
                 m_Controls->m_PrototypeWidget1->SetMinFa(model->GetFaRange().first);
                 m_Controls->m_PrototypeWidget1->SetMaxFa(model->GetFaRange().second);
                 m_Controls->m_PrototypeWidget1->SetMinAdc(model->GetAdcRange().first);
                 m_Controls->m_PrototypeWidget1->SetMaxAdc(model->GetAdcRange().second);
                 m_Controls->m_Compartment1Box->setCurrentIndex(3);
                 break;
             }
             break;
         }
         case 2:
         {
             if (dynamic_cast<mitk::StickModel<>*>(signalModel))
             {
                 mitk::StickModel<>* model = dynamic_cast<mitk::StickModel<>*>(signalModel);
                 m_Controls->m_StickWidget2->SetT2(model->GetT2());
                 m_Controls->m_StickWidget2->SetD(model->GetDiffusivity());
                 m_Controls->m_Compartment2Box->setCurrentIndex(1);
                 break;
             }
             else if (dynamic_cast<mitk::TensorModel<>*>(signalModel))
             {
                 mitk::TensorModel<>* model = dynamic_cast<mitk::TensorModel<>*>(signalModel);
                 m_Controls->m_TensorWidget2->SetT2(model->GetT2());
                 m_Controls->m_TensorWidget2->SetD1(model->GetDiffusivity1());
                 m_Controls->m_TensorWidget2->SetD2(model->GetDiffusivity2());
                 m_Controls->m_TensorWidget2->SetD3(model->GetDiffusivity3());
                 m_Controls->m_Compartment2Box->setCurrentIndex(3);
                 break;
             }
             break;
         }
         case 3:
         {
             if (dynamic_cast<mitk::BallModel<>*>(signalModel))
             {
                 mitk::BallModel<>* model = dynamic_cast<mitk::BallModel<>*>(signalModel);
                 m_Controls->m_BallWidget1->SetT2(model->GetT2());
                 m_Controls->m_BallWidget1->SetD(model->GetDiffusivity());
                 m_Controls->m_Compartment3Box->setCurrentIndex(0);
                 break;
             }
             else if (dynamic_cast<mitk::AstroStickModel<>*>(signalModel))
             {
                 mitk::AstroStickModel<>* model = dynamic_cast<mitk::AstroStickModel<>*>(signalModel);
                 m_Controls->m_AstrosticksWidget1->SetT2(model->GetT2());
                 m_Controls->m_AstrosticksWidget1->SetD(model->GetDiffusivity());
                 m_Controls->m_AstrosticksWidget1->SetRandomizeSticks(model->GetRandomizeSticks());
                 m_Controls->m_Compartment3Box->setCurrentIndex(1);
                 break;
             }
             else if (dynamic_cast<mitk::DotModel<>*>(signalModel))
             {
                 mitk::DotModel<>* model = dynamic_cast<mitk::DotModel<>*>(signalModel);
                 m_Controls->m_DotWidget1->SetT2(model->GetT2());
                 m_Controls->m_Compartment3Box->setCurrentIndex(2);
                 break;
             }
             else if (dynamic_cast<mitk::RawShModel<>*>(signalModel))
             {
                 mitk::RawShModel<>* model = dynamic_cast<mitk::RawShModel<>*>(signalModel);
                 m_Controls->m_PrototypeWidget3->SetNumberOfSamples(model->GetMaxNumKernels());
                 m_Controls->m_PrototypeWidget3->SetMinFa(model->GetFaRange().first);
                 m_Controls->m_PrototypeWidget3->SetMaxFa(model->GetFaRange().second);
                 m_Controls->m_PrototypeWidget3->SetMinAdc(model->GetAdcRange().first);
                 m_Controls->m_PrototypeWidget3->SetMaxAdc(model->GetAdcRange().second);
                 m_Controls->m_Compartment3Box->setCurrentIndex(3);
                 break;
             }
             break;
         }
         case 4:
         {
             if (dynamic_cast<mitk::BallModel<>*>(signalModel))
             {
                 mitk::BallModel<>* model = dynamic_cast<mitk::BallModel<>*>(signalModel);
                 m_Controls->m_BallWidget2->SetT2(model->GetT2());
                 m_Controls->m_BallWidget2->SetD(model->GetDiffusivity());
                 m_Controls->m_Compartment4Box->setCurrentIndex(1);
                 break;
             }
             else if (dynamic_cast<mitk::AstroStickModel<>*>(signalModel))
             {
                 mitk::AstroStickModel<>* model = dynamic_cast<mitk::AstroStickModel<>*>(signalModel);
                 m_Controls->m_AstrosticksWidget2->SetT2(model->GetT2());
                 m_Controls->m_AstrosticksWidget2->SetD(model->GetDiffusivity());
                 m_Controls->m_AstrosticksWidget2->SetRandomizeSticks(model->GetRandomizeSticks());
                 m_Controls->m_Compartment4Box->setCurrentIndex(2);
                 break;
             }
             else if (dynamic_cast<mitk::DotModel<>*>(signalModel))
             {
                 mitk::DotModel<>* model = dynamic_cast<mitk::DotModel<>*>(signalModel);
                 m_Controls->m_DotWidget2->SetT2(model->GetT2());
                 m_Controls->m_Compartment4Box->setCurrentIndex(3);
                 break;
             }
             else if (dynamic_cast<mitk::RawShModel<>*>(signalModel))
             {
                 mitk::RawShModel<>* model = dynamic_cast<mitk::RawShModel<>*>(signalModel);
                 m_Controls->m_PrototypeWidget4->SetNumberOfSamples(model->GetMaxNumKernels());
                 m_Controls->m_PrototypeWidget4->SetMinFa(model->GetFaRange().first);
                 m_Controls->m_PrototypeWidget4->SetMaxFa(model->GetFaRange().second);
                 m_Controls->m_PrototypeWidget4->SetMinAdc(model->GetAdcRange().first);
                 m_Controls->m_PrototypeWidget4->SetMaxAdc(model->GetAdcRange().second);
                 m_Controls->m_Compartment4Box->setCurrentIndex(4);
                 break;
             }
             break;
         }
         }
     }
 }
 
 void QmitkFiberfoxView::ShowAdvancedOptions(int state)
 {
     if (state)
     {
         m_Controls->m_AdvancedFiberOptionsFrame->setVisible(true);
         m_Controls->m_AdvancedSignalOptionsFrame->setVisible(true);
         m_Controls->m_AdvancedOptionsBox->setChecked(true);
         m_Controls->m_AdvancedOptionsBox_2->setChecked(true);
     }
     else
     {
         m_Controls->m_AdvancedFiberOptionsFrame->setVisible(false);
         m_Controls->m_AdvancedSignalOptionsFrame->setVisible(false);
         m_Controls->m_AdvancedOptionsBox->setChecked(false);
         m_Controls->m_AdvancedOptionsBox_2->setChecked(false);
     }
 }
 
 void QmitkFiberfoxView::Comp1ModelFrameVisibility(int index)
 {
     m_Controls->m_StickWidget1->setVisible(false);
     m_Controls->m_ZeppelinWidget1->setVisible(false);
     m_Controls->m_TensorWidget1->setVisible(false);
     m_Controls->m_PrototypeWidget1->setVisible(false);
 
     switch (index)
     {
     case 0:
         m_Controls->m_StickWidget1->setVisible(true);
         break;
     case 1:
         m_Controls->m_ZeppelinWidget1->setVisible(true);
         break;
     case 2:
         m_Controls->m_TensorWidget1->setVisible(true);
         break;
     case 3:
         m_Controls->m_PrototypeWidget1->setVisible(true);
         break;
     }
 }
 
 void QmitkFiberfoxView::Comp2ModelFrameVisibility(int index)
 {
     m_Controls->m_StickWidget2->setVisible(false);
     m_Controls->m_ZeppelinWidget2->setVisible(false);
     m_Controls->m_TensorWidget2->setVisible(false);
 
     switch (index)
     {
     case 0:
         break;
     case 1:
         m_Controls->m_StickWidget2->setVisible(true);
         break;
     case 2:
         m_Controls->m_ZeppelinWidget2->setVisible(true);
         break;
     case 3:
         m_Controls->m_TensorWidget2->setVisible(true);
         break;
     }
 }
 
 void QmitkFiberfoxView::Comp3ModelFrameVisibility(int index)
 {
     m_Controls->m_BallWidget1->setVisible(false);
     m_Controls->m_AstrosticksWidget1->setVisible(false);
     m_Controls->m_DotWidget1->setVisible(false);
     m_Controls->m_PrototypeWidget3->setVisible(false);
 
     switch (index)
     {
     case 0:
         m_Controls->m_BallWidget1->setVisible(true);
         break;
     case 1:
         m_Controls->m_AstrosticksWidget1->setVisible(true);
         break;
     case 2:
         m_Controls->m_DotWidget1->setVisible(true);
         break;
     case 3:
         m_Controls->m_PrototypeWidget3->setVisible(true);
         break;
     }
 }
 
 void QmitkFiberfoxView::Comp4ModelFrameVisibility(int index)
 {
     m_Controls->m_BallWidget2->setVisible(false);
     m_Controls->m_AstrosticksWidget2->setVisible(false);
     m_Controls->m_DotWidget2->setVisible(false);
     m_Controls->m_PrototypeWidget4->setVisible(false);
     m_Controls->m_Comp4FractionFrame->setVisible(false);
 
     switch (index)
     {
     case 0:
         break;
     case 1:
         m_Controls->m_BallWidget2->setVisible(true);
         m_Controls->m_Comp4FractionFrame->setVisible(true);
         break;
     case 2:
         m_Controls->m_AstrosticksWidget2->setVisible(true);
         m_Controls->m_Comp4FractionFrame->setVisible(true);
         break;
     case 3:
         m_Controls->m_DotWidget2->setVisible(true);
         m_Controls->m_Comp4FractionFrame->setVisible(true);
         break;
     case 4:
         m_Controls->m_PrototypeWidget4->setVisible(true);
         m_Controls->m_Comp4FractionFrame->setVisible(true);
         break;
     }
 }
 
 void QmitkFiberfoxView::OnConstantRadius(int value)
 {
     if (value>0 && m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnAddMotion(int value)
 {
     if (value>0)
         m_Controls->m_MotionArtifactFrame->setVisible(true);
     else
         m_Controls->m_MotionArtifactFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddAliasing(int value)
 {
     if (value>0)
         m_Controls->m_AliasingFrame->setVisible(true);
     else
         m_Controls->m_AliasingFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddSpikes(int value)
 {
     if (value>0)
         m_Controls->m_SpikeFrame->setVisible(true);
     else
         m_Controls->m_SpikeFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddEddy(int value)
 {
     if (value>0)
         m_Controls->m_EddyFrame->setVisible(true);
     else
         m_Controls->m_EddyFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddDistortions(int value)
 {
     if (value>0)
         m_Controls->m_DistortionsFrame->setVisible(true);
     else
         m_Controls->m_DistortionsFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddGhosts(int value)
 {
     if (value>0)
         m_Controls->m_GhostFrame->setVisible(true);
     else
         m_Controls->m_GhostFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddNoise(int value)
 {
     if (value>0)
         m_Controls->m_NoiseFrame->setVisible(true);
     else
         m_Controls->m_NoiseFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnDistributionChanged(int value)
 {
     if (value==1)
         m_Controls->m_VarianceBox->setVisible(true);
     else
         m_Controls->m_VarianceBox->setVisible(false);
 
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnVarianceChanged(double)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnFiberDensityChanged(int)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnFiberSamplingChanged(double)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnTensionChanged(double)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnContinuityChanged(double)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnBiasChanged(double)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::AlignOnGrid()
 {
     for (unsigned int i=0; i<m_SelectedFiducials.size(); i++)
     {
         mitk::PlanarEllipse::Pointer pe = dynamic_cast<mitk::PlanarEllipse*>(m_SelectedFiducials.at(i)->GetData());
         mitk::Point3D wc0 = pe->GetWorldControlPoint(0);
 
         mitk::DataStorage::SetOfObjects::ConstPointer parentFibs = GetDataStorage()->GetSources(m_SelectedFiducials.at(i));
         for( mitk::DataStorage::SetOfObjects::const_iterator it = parentFibs->begin(); it != parentFibs->end(); ++it )
         {
             mitk::DataNode::Pointer pFibNode = *it;
             if ( pFibNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(pFibNode->GetData()) )
             {
                 mitk::DataStorage::SetOfObjects::ConstPointer parentImgs = GetDataStorage()->GetSources(pFibNode);
                 for( mitk::DataStorage::SetOfObjects::const_iterator it2 = parentImgs->begin(); it2 != parentImgs->end(); ++it2 )
                 {
                     mitk::DataNode::Pointer pImgNode = *it2;
                     if ( pImgNode.IsNotNull() && dynamic_cast<mitk::Image*>(pImgNode->GetData()) )
                     {
                         mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(pImgNode->GetData());
                         mitk::BaseGeometry::Pointer geom = img->GetGeometry();
                         itk::Index<3> idx;
                         geom->WorldToIndex(wc0, idx);
 
                         mitk::Point3D cIdx; cIdx[0]=idx[0]; cIdx[1]=idx[1]; cIdx[2]=idx[2];
                         mitk::Point3D world;
                         geom->IndexToWorld(cIdx,world);
 
                         mitk::Vector3D trans = world - wc0;
                         pe->GetGeometry()->Translate(trans);
 
                         break;
                     }
                 }
                 break;
             }
         }
     }
 
     for(unsigned int i=0; i<m_SelectedBundles2.size(); i++ )
     {
         mitk::DataNode::Pointer fibNode = m_SelectedBundles2.at(i);
 
         mitk::DataStorage::SetOfObjects::ConstPointer sources = GetDataStorage()->GetSources(fibNode);
         for( mitk::DataStorage::SetOfObjects::const_iterator it = sources->begin(); it != sources->end(); ++it )
         {
             mitk::DataNode::Pointer imgNode = *it;
             if ( imgNode.IsNotNull() && dynamic_cast<mitk::Image*>(imgNode->GetData()) )
             {
                 mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(fibNode);
                 for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations->begin(); it2 != derivations->end(); ++it2 )
                 {
                     mitk::DataNode::Pointer fiducialNode = *it2;
                     if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
                     {
                         mitk::PlanarEllipse::Pointer pe = dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData());
                         mitk::Point3D wc0 = pe->GetWorldControlPoint(0);
 
                         mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(imgNode->GetData());
                         mitk::BaseGeometry::Pointer geom = img->GetGeometry();
                         itk::Index<3> idx;
                         geom->WorldToIndex(wc0, idx);
                         mitk::Point3D cIdx; cIdx[0]=idx[0]; cIdx[1]=idx[1]; cIdx[2]=idx[2];
                         mitk::Point3D world;
                         geom->IndexToWorld(cIdx,world);
 
                         mitk::Vector3D trans = world - wc0;
                         pe->GetGeometry()->Translate(trans);
                     }
                 }
 
                 break;
             }
         }
     }
 
     for(unsigned int i=0; i<m_SelectedImages.size(); i++ )
     {
         mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(m_SelectedImages.at(i)->GetData());
 
         mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(m_SelectedImages.at(i));
         for( mitk::DataStorage::SetOfObjects::const_iterator it = derivations->begin(); it != derivations->end(); ++it )
         {
             mitk::DataNode::Pointer fibNode = *it;
             if ( fibNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(fibNode->GetData()) )
             {
                 mitk::DataStorage::SetOfObjects::ConstPointer derivations2 = GetDataStorage()->GetDerivations(fibNode);
                 for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations2->begin(); it2 != derivations2->end(); ++it2 )
                 {
                     mitk::DataNode::Pointer fiducialNode = *it2;
                     if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
                     {
                         mitk::PlanarEllipse::Pointer pe = dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData());
                         mitk::Point3D wc0 = pe->GetWorldControlPoint(0);
 
                         mitk::BaseGeometry::Pointer geom = img->GetGeometry();
                         itk::Index<3> idx;
                         geom->WorldToIndex(wc0, idx);
                         mitk::Point3D cIdx; cIdx[0]=idx[0]; cIdx[1]=idx[1]; cIdx[2]=idx[2];
                         mitk::Point3D world;
                         geom->IndexToWorld(cIdx,world);
 
                         mitk::Vector3D trans = world - wc0;
                         pe->GetGeometry()->Translate(trans);
                     }
                 }
             }
         }
     }
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnFlipButton()
 {
     if (m_SelectedFiducial.IsNull())
         return;
 
     std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it = m_DataNodeToPlanarFigureData.find(m_SelectedFiducial.GetPointer());
     if( it != m_DataNodeToPlanarFigureData.end() )
     {
         QmitkPlanarFigureData& data = it->second;
         data.m_Flipped += 1;
         data.m_Flipped %= 2;
     }
 
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 QmitkFiberfoxView::GradientListType QmitkFiberfoxView::GenerateHalfShell(int NPoints)
 {
     NPoints *= 2;
     GradientListType pointshell;
 
     int numB0 = NPoints/20;
     if (numB0==0)
         numB0=1;
     GradientType g;
     g.Fill(0.0);
     for (int i=0; i<numB0; i++)
         pointshell.push_back(g);
 
     if (NPoints==0)
         return pointshell;
 
     vnl_vector<double> theta; theta.set_size(NPoints);
     vnl_vector<double> phi; phi.set_size(NPoints);
     double C = sqrt(4*M_PI);
     phi(0) = 0.0;
     phi(NPoints-1) = 0.0;
     for(int i=0; i<NPoints; i++)
     {
         theta(i) = acos(-1.0+2.0*i/(NPoints-1.0)) - M_PI / 2.0;
         if( i>0 && i<NPoints-1)
         {
             phi(i) = (phi(i-1) + C /
                       sqrt(NPoints*(1-(-1.0+2.0*i/(NPoints-1.0))*(-1.0+2.0*i/(NPoints-1.0)))));
             // % (2*DIST_POINTSHELL_PI);
         }
     }
 
     for(int i=0; i<NPoints; i++)
     {
         g[2] = sin(theta(i));
         if (g[2]<0)
             continue;
         g[0] = cos(theta(i)) * cos(phi(i));
         g[1] = cos(theta(i)) * sin(phi(i));
         pointshell.push_back(g);
     }
 
     return pointshell;
 }
 
 template<int ndirs>
 std::vector<itk::Vector<double,3> > QmitkFiberfoxView::MakeGradientList()
 {
     std::vector<itk::Vector<double,3> > retval;
     vnl_matrix_fixed<double, 3, ndirs>* U =
             itk::PointShell<ndirs, vnl_matrix_fixed<double, 3, ndirs> >::DistributePointShell();
 
 
     // Add 0 vector for B0
     int numB0 = ndirs/10;
     if (numB0==0)
         numB0=1;
     itk::Vector<double,3> v;
     v.Fill(0.0);
     for (int i=0; i<numB0; i++)
     {
         retval.push_back(v);
     }
 
     for(int i=0; i<ndirs;i++)
     {
         itk::Vector<double,3> v;
         v[0] = U->get(0,i); v[1] = U->get(1,i); v[2] = U->get(2,i);
         retval.push_back(v);
     }
 
     return retval;
 }
 
 void QmitkFiberfoxView::OnAddBundle()
 {
     if (m_SelectedImage.IsNull())
         return;
 
     mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_SelectedImage);
 
     mitk::FiberBundleX::Pointer bundle = mitk::FiberBundleX::New();
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData( bundle );
     QString name = QString("Bundle_%1").arg(children->size());
     node->SetName(name.toStdString());
     m_SelectedBundles.push_back(node);
     UpdateGui();
 
     GetDataStorage()->Add(node, m_SelectedImage);
 }
 
 void QmitkFiberfoxView::OnDrawROI()
 {
     if (m_SelectedBundles.empty())
         OnAddBundle();
     if (m_SelectedBundles.empty())
         return;
 
     mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_SelectedBundles.at(0));
 
     mitk::PlanarEllipse::Pointer figure = mitk::PlanarEllipse::New();
 
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData( figure );
     node->SetBoolProperty("planarfigure.3drendering", true);
 
     QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
     for( int i=0; i<nodes.size(); i++)
         nodes.at(i)->SetSelected(false);
 
     m_SelectedFiducial = node;
 
     QString name = QString("Fiducial_%1").arg(children->size());
     node->SetName(name.toStdString());
     node->SetSelected(true);
 
     this->DisableCrosshairNavigation();
 
     mitk::PlanarFigureInteractor::Pointer figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer());
     if(figureInteractor.IsNull())
     {
         figureInteractor = mitk::PlanarFigureInteractor::New();
         us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "MitkPlanarFigure" );
         figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
         figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
         figureInteractor->SetDataNode( node );
     }
 
     UpdateGui();
     GetDataStorage()->Add(node, m_SelectedBundles.at(0));
 }
 
 bool CompareLayer(mitk::DataNode::Pointer i,mitk::DataNode::Pointer j)
 {
     int li = -1;
     i->GetPropertyValue("layer", li);
     int lj = -1;
     j->GetPropertyValue("layer", lj);
     return li<lj;
 }
 
 void QmitkFiberfoxView::GenerateFibers()
 {
     if (m_SelectedBundles.empty())
     {
         if (m_SelectedFiducial.IsNull())
             return;
 
         mitk::DataStorage::SetOfObjects::ConstPointer parents = GetDataStorage()->GetSources(m_SelectedFiducial);
         for( mitk::DataStorage::SetOfObjects::const_iterator it = parents->begin(); it != parents->end(); ++it )
             if(dynamic_cast<mitk::FiberBundleX*>((*it)->GetData()))
                 m_SelectedBundles.push_back(*it);
 
         if (m_SelectedBundles.empty())
             return;
     }
 
     FiberfoxParameters<double> parameters = UpdateImageParameters<double>();
 
     for (unsigned int i=0; i<m_SelectedBundles.size(); i++)
     {
         mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_SelectedBundles.at(i));
         std::vector< mitk::DataNode::Pointer > childVector;
         for( mitk::DataStorage::SetOfObjects::const_iterator it = children->begin(); it != children->end(); ++it )
             childVector.push_back(*it);
         sort(childVector.begin(), childVector.end(), CompareLayer);
 
         vector< mitk::PlanarEllipse::Pointer > fib;
         vector< unsigned int > flip;
         float radius = 1;
         int count = 0;
         for( std::vector< mitk::DataNode::Pointer >::const_iterator it = childVector.begin(); it != childVector.end(); ++it )
         {
             mitk::DataNode::Pointer node = *it;
 
             if ( node.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(node->GetData()) )
             {
                 mitk::PlanarEllipse* ellipse = dynamic_cast<mitk::PlanarEllipse*>(node->GetData());
                 if (m_Controls->m_ConstantRadiusBox->isChecked())
                 {
                     ellipse->SetTreatAsCircle(true);
                     mitk::Point2D c = ellipse->GetControlPoint(0);
                     mitk::Point2D p = ellipse->GetControlPoint(1);
                     mitk::Vector2D v = p-c;
                     if (count==0)
                     {
                         radius = v.GetVnlVector().magnitude();
                         ellipse->SetControlPoint(1, p);
                         ellipse->Modified();
                     }
                     else
                     {
                         v.Normalize();
                         v *= radius;
                         ellipse->SetControlPoint(1, c+v);
                         ellipse->Modified();
                     }
                 }
                 fib.push_back(ellipse);
 
                 std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it = m_DataNodeToPlanarFigureData.find(node.GetPointer());
                 if( it != m_DataNodeToPlanarFigureData.end() )
                 {
                     QmitkPlanarFigureData& data = it->second;
                     flip.push_back(data.m_Flipped);
                 }
                 else
                     flip.push_back(0);
             }
             count++;
         }
         if (fib.size()>1)
         {
             parameters.m_FiberGen.m_Fiducials.push_back(fib);
             parameters.m_FiberGen.m_FlipList.push_back(flip);
         }
         else if (fib.size()>0)
             m_SelectedBundles.at(i)->SetData( mitk::FiberBundleX::New() );
 
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 
     itk::FibersFromPlanarFiguresFilter::Pointer filter = itk::FibersFromPlanarFiguresFilter::New();
     filter->SetParameters(parameters.m_FiberGen);
     filter->Update();
     vector< mitk::FiberBundleX::Pointer > fiberBundles = filter->GetFiberBundles();
 
     for (unsigned int i=0; i<fiberBundles.size(); i++)
     {
         m_SelectedBundles.at(i)->SetData( fiberBundles.at(i) );
         if (fiberBundles.at(i)->GetNumFibers()>50000)
             m_SelectedBundles.at(i)->SetVisibility(false);
     }
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberfoxView::GenerateImage()
 {
     if (m_Controls->m_FiberBundleComboBox->GetSelectedNode().IsNull() && m_Controls->m_TemplateComboBox->GetSelectedNode().IsNull())
     {
         mitk::Image::Pointer image = mitk::ImageGenerator::GenerateGradientImage<unsigned int>(
                     m_Controls->m_SizeX->value(),
                     m_Controls->m_SizeY->value(),
                     m_Controls->m_SizeZ->value(),
                     m_Controls->m_SpacingX->value(),
                     m_Controls->m_SpacingY->value(),
                     m_Controls->m_SpacingZ->value());
 
         mitk::DataNode::Pointer node = mitk::DataNode::New();
         node->SetData( image );
         node->SetName("Dummy");
         unsigned int window = m_Controls->m_SizeX->value()*m_Controls->m_SizeY->value()*m_Controls->m_SizeZ->value();
         unsigned int level = window/2;
         mitk::LevelWindow lw; lw.SetLevelWindow(level, window);
         node->SetProperty( "levelwindow", mitk::LevelWindowProperty::New( lw ) );
         GetDataStorage()->Add(node);
         m_SelectedImage = node;
 
         mitk::BaseData::Pointer basedata = node->GetData();
         if (basedata.IsNotNull())
         {
             mitk::RenderingManager::GetInstance()->InitializeViews( basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
             mitk::RenderingManager::GetInstance()->RequestUpdateAll();
         }
         UpdateGui();
     }
     else if (m_Controls->m_FiberBundleComboBox->GetSelectedNode().IsNotNull())
         SimulateImageFromFibers(m_Controls->m_FiberBundleComboBox->GetSelectedNode());
     else if ( m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull() )
         SimulateForExistingDwi(m_Controls->m_TemplateComboBox->GetSelectedNode());
 }
 
 void QmitkFiberfoxView::SimulateForExistingDwi(mitk::DataNode* imageNode)
 {
-    if (!dynamic_cast<mitk::DiffusionImage<short>*>(imageNode->GetData()))
-        return;
+  bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(imageNode->GetData())) );
+  if ( !isDiffusionImage )
+  {
+    return;
+  }
 
     FiberfoxParameters<short> parameters = UpdateImageParameters<short>();
 
     if (parameters.m_NoiseModel==NULL &&
             parameters.m_SignalGen.m_Spikes==0 &&
             parameters.m_SignalGen.m_FrequencyMap.IsNull() &&
             parameters.m_SignalGen.m_KspaceLineOffset<=0.000001 &&
             !parameters.m_SignalGen.m_DoAddGibbsRinging &&
             !(parameters.m_SignalGen.m_EddyStrength>0) &&
             parameters.m_SignalGen.m_CroppingFactor>0.999)
     {
         QMessageBox::information( NULL, "Simulation cancelled", "No valid artifact enabled! Motion artifacts and relaxation effects can NOT be added to an existing diffusion weighted image.");
         return;
     }
 
-    mitk::DiffusionImage<short>::Pointer diffImg = dynamic_cast<mitk::DiffusionImage<short>*>(imageNode->GetData());
+    mitk::Image::Pointer diffImg = dynamic_cast<mitk::Image*>(imageNode->GetData());
+
+    ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+    mitk::CastToItkImage(diffImg, itkVectorImagePointer);
+
     m_ArtifactsToDwiFilter = itk::AddArtifactsToDwiImageFilter< short >::New();
-    m_ArtifactsToDwiFilter->SetInput(diffImg->GetVectorImage());
+    m_ArtifactsToDwiFilter->SetInput(itkVectorImagePointer);
     parameters.m_Misc.m_ParentNode = imageNode;
     m_ArtifactsToDwiFilter->SetParameters(parameters);
     m_Worker.m_FilterType = 1;
     m_Thread.start(QThread::LowestPriority);
 }
 
 void QmitkFiberfoxView::SimulateImageFromFibers(mitk::DataNode* fiberNode)
 {
     mitk::FiberBundleX::Pointer fiberBundle = dynamic_cast<mitk::FiberBundleX*>(fiberNode->GetData());
     if (fiberBundle->GetNumFibers()<=0)
         return;
 
     FiberfoxParameters<double> parameters = UpdateImageParameters<double>();
 
     m_TractsToDwiFilter = itk::TractsToDWIImageFilter< short >::New();
     parameters.m_Misc.m_ParentNode = fiberNode;
-    if (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull() && dynamic_cast<mitk::DiffusionImage<short>*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData()))
+    if (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull() && mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData())))
     {
         bool first = true;
         bool ok = true;
-        mitk::DiffusionImage<short>::Pointer diffImg = dynamic_cast<mitk::DiffusionImage<short>*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData());
+        mitk::Image::Pointer diffImg = dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData());
         itk::Image< itk::DiffusionTensor3D< double >, 3 >::Pointer tensorImage = NULL;
         const int shOrder = 2;
         typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,shOrder,QBALL_ODFSIZE> QballFilterType;
         QballFilterType::CoefficientImageType::Pointer itkFeatureImage = NULL;
         ItkDoubleImgType::Pointer adcImage = NULL;
 
         for (unsigned int i=0; i<parameters.m_FiberModelList.size()+parameters.m_NonFiberModelList.size(); i++)
         {
             mitk::RawShModel<>* model = NULL;
             if (i<parameters.m_FiberModelList.size())
                 model = dynamic_cast<  mitk::RawShModel<>* >(parameters.m_FiberModelList.at(i));
             else
                 model = dynamic_cast<  mitk::RawShModel<>* >(parameters.m_NonFiberModelList.at(i-parameters.m_FiberModelList.size()));
 
             if (model!=0 && model->GetNumberOfKernels()<=0)
             {
                 if (first==true)
                 {
+                  ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+                  mitk::CastToItkImage(diffImg, itkVectorImagePointer);
+
                     typedef itk::DiffusionTensor3DReconstructionImageFilter< short, short, double > TensorReconstructionImageFilterType;
                     TensorReconstructionImageFilterType::Pointer filter = TensorReconstructionImageFilterType::New();
-                    filter->SetGradientImage( diffImg->GetDirections(), diffImg->GetVectorImage() );
-                    filter->SetBValue(diffImg->GetReferenceBValue());
+                    filter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), itkVectorImagePointer );
+                    filter->SetBValue( static_cast<mitk::FloatProperty*>(diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
                     filter->Update();
                     tensorImage = filter->GetOutput();
 
                     const int NumCoeffs = (shOrder*shOrder + shOrder + 2)/2 + shOrder;
                     QballFilterType::Pointer qballfilter = QballFilterType::New();
-                    qballfilter->SetGradientImage( diffImg->GetDirections(), diffImg->GetVectorImage() );
-                    qballfilter->SetBValue(diffImg->GetReferenceBValue());
+                    qballfilter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), itkVectorImagePointer );
+                    qballfilter->SetBValue( static_cast<mitk::FloatProperty*>(diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
                     qballfilter->SetLambda(0.006);
                     qballfilter->SetNormalizationMethod(QballFilterType::QBAR_RAW_SIGNAL);
                     qballfilter->Update();
                     itkFeatureImage = qballfilter->GetCoefficientImage();
 
                     itk::AdcImageFilter< short, double >::Pointer adcFilter = itk::AdcImageFilter< short, double >::New();
-                    adcFilter->SetInput(diffImg->GetVectorImage());
-                    adcFilter->SetGradientDirections(diffImg->GetDirections());
-                    adcFilter->SetB_value(diffImg->GetReferenceBValue());
+                    adcFilter->SetInput( itkVectorImagePointer );
+                    adcFilter->SetGradientDirections( static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() );
+                    adcFilter->SetB_value( static_cast<mitk::FloatProperty*>(diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
                     adcFilter->Update();
                     adcImage = adcFilter->GetOutput();
                 }
                 ok = model->SampleKernels(diffImg, parameters.m_SignalGen.m_MaskImage, tensorImage, itkFeatureImage, adcImage);
                 if (!ok)
                     break;
             }
         }
 
         if (!ok)
         {
             QMessageBox::information( NULL, "Simulation cancelled", "No valid prototype signals could be sampled.");
             return;
         }
     }
     else if ( m_Controls->m_Compartment1Box->currentIndex()==3 || m_Controls->m_Compartment3Box->currentIndex()==3 || m_Controls->m_Compartment4Box->currentIndex()==4 )
     {
         QMessageBox::information( NULL, "Simulation cancelled", "Prototype signal but no diffusion-weighted image selected to sample signal from.");
         return;
     }
 
     m_TractsToDwiFilter->SetParameters(parameters);
     m_TractsToDwiFilter->SetFiberBundle(fiberBundle);
     m_Worker.m_FilterType = 0;
     m_Thread.start(QThread::LowestPriority);
 }
 
 void QmitkFiberfoxView::ApplyTransform()
 {
     vector< mitk::DataNode::Pointer > selectedBundles;
     for(unsigned int i=0; i<m_SelectedImages.size(); i++ )
     {
         mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(m_SelectedImages.at(i));
         for( mitk::DataStorage::SetOfObjects::const_iterator it = derivations->begin(); it != derivations->end(); ++it )
         {
             mitk::DataNode::Pointer fibNode = *it;
             if ( fibNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(fibNode->GetData()) )
                 selectedBundles.push_back(fibNode);
         }
     }
     if (selectedBundles.empty())
         selectedBundles = m_SelectedBundles2;
 
     if (!selectedBundles.empty())
     {
         for (std::vector<mitk::DataNode::Pointer>::const_iterator it = selectedBundles.begin(); it!=selectedBundles.end(); ++it)
         {
             mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>((*it)->GetData());
             fib->RotateAroundAxis(m_Controls->m_XrotBox->value(), m_Controls->m_YrotBox->value(), m_Controls->m_ZrotBox->value());
             fib->TranslateFibers(m_Controls->m_XtransBox->value(), m_Controls->m_YtransBox->value(), m_Controls->m_ZtransBox->value());
             fib->ScaleFibers(m_Controls->m_XscaleBox->value(), m_Controls->m_YscaleBox->value(), m_Controls->m_ZscaleBox->value());
 
             // handle child fiducials
             if (m_Controls->m_IncludeFiducials->isChecked())
             {
                 mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(*it);
                 for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations->begin(); it2 != derivations->end(); ++it2 )
                 {
                     mitk::DataNode::Pointer fiducialNode = *it2;
                     if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
                     {
                         mitk::PlanarEllipse* pe = dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData());
                         mitk::BaseGeometry* geom = pe->GetGeometry();
 
                         // translate
                         mitk::Vector3D world;
                         world[0] = m_Controls->m_XtransBox->value();
                         world[1] = m_Controls->m_YtransBox->value();
                         world[2] = m_Controls->m_ZtransBox->value();
                         geom->Translate(world);
 
                         // calculate rotation matrix
                         double x = m_Controls->m_XrotBox->value()*M_PI/180;
                         double y = m_Controls->m_YrotBox->value()*M_PI/180;
                         double z = m_Controls->m_ZrotBox->value()*M_PI/180;
 
                         itk::Matrix< double, 3, 3 > rotX; rotX.SetIdentity();
                         rotX[1][1] = cos(x);
                         rotX[2][2] = rotX[1][1];
                         rotX[1][2] = -sin(x);
                         rotX[2][1] = -rotX[1][2];
 
                         itk::Matrix< double, 3, 3 > rotY; rotY.SetIdentity();
                         rotY[0][0] = cos(y);
                         rotY[2][2] = rotY[0][0];
                         rotY[0][2] = sin(y);
                         rotY[2][0] = -rotY[0][2];
 
                         itk::Matrix< double, 3, 3 > rotZ; rotZ.SetIdentity();
                         rotZ[0][0] = cos(z);
                         rotZ[1][1] = rotZ[0][0];
                         rotZ[0][1] = -sin(z);
                         rotZ[1][0] = -rotZ[0][1];
 
                         itk::Matrix< double, 3, 3 > rot = rotZ*rotY*rotX;
 
                         // transform control point coordinate into geometry translation
                         geom->SetOrigin(pe->GetWorldControlPoint(0));
                         mitk::Point2D cp; cp.Fill(0.0);
                         pe->SetControlPoint(0, cp);
 
                         // rotate fiducial
                         geom->GetIndexToWorldTransform()->SetMatrix(rot*geom->GetIndexToWorldTransform()->GetMatrix());
 
                         // implicit translation
                         mitk::Vector3D trans;
                         trans[0] = geom->GetOrigin()[0]-fib->GetGeometry()->GetCenter()[0];
                         trans[1] = geom->GetOrigin()[1]-fib->GetGeometry()->GetCenter()[1];
                         trans[2] = geom->GetOrigin()[2]-fib->GetGeometry()->GetCenter()[2];
                         mitk::Vector3D newWc = rot*trans;
                         newWc = newWc-trans;
                         geom->Translate(newWc);
 
                         pe->Modified();
                     }
                 }
             }
         }
     }
     else
     {
         for (unsigned int i=0; i<m_SelectedFiducials.size(); i++)
         {
             mitk::PlanarEllipse* pe = dynamic_cast<mitk::PlanarEllipse*>(m_SelectedFiducials.at(i)->GetData());
             mitk::BaseGeometry* geom = pe->GetGeometry();
 
             // translate
             mitk::Vector3D world;
             world[0] = m_Controls->m_XtransBox->value();
             world[1] = m_Controls->m_YtransBox->value();
             world[2] = m_Controls->m_ZtransBox->value();
             geom->Translate(world);
 
             // calculate rotation matrix
             double x = m_Controls->m_XrotBox->value()*M_PI/180;
             double y = m_Controls->m_YrotBox->value()*M_PI/180;
             double z = m_Controls->m_ZrotBox->value()*M_PI/180;
             itk::Matrix< double, 3, 3 > rotX; rotX.SetIdentity();
             rotX[1][1] = cos(x);
             rotX[2][2] = rotX[1][1];
             rotX[1][2] = -sin(x);
             rotX[2][1] = -rotX[1][2];
             itk::Matrix< double, 3, 3 > rotY; rotY.SetIdentity();
             rotY[0][0] = cos(y);
             rotY[2][2] = rotY[0][0];
             rotY[0][2] = sin(y);
             rotY[2][0] = -rotY[0][2];
             itk::Matrix< double, 3, 3 > rotZ; rotZ.SetIdentity();
             rotZ[0][0] = cos(z);
             rotZ[1][1] = rotZ[0][0];
             rotZ[0][1] = -sin(z);
             rotZ[1][0] = -rotZ[0][1];
             itk::Matrix< double, 3, 3 > rot = rotZ*rotY*rotX;
 
             // transform control point coordinate into geometry translation
             geom->SetOrigin(pe->GetWorldControlPoint(0));
             mitk::Point2D cp; cp.Fill(0.0);
             pe->SetControlPoint(0, cp);
 
             // rotate fiducial
             geom->GetIndexToWorldTransform()->SetMatrix(rot*geom->GetIndexToWorldTransform()->GetMatrix());
             pe->Modified();
         }
         if (m_Controls->m_RealTimeFibers->isChecked())
             GenerateFibers();
     }
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberfoxView::CopyBundles()
 {
     if ( m_SelectedBundles.size()<1 ){
         QMessageBox::information( NULL, "Warning", "Select at least one fiber bundle!");
         MITK_WARN("QmitkFiberFoxView") << "Select at least one fiber bundle!";
         return;
     }
 
     for (std::vector<mitk::DataNode::Pointer>::const_iterator it = m_SelectedBundles.begin(); it!=m_SelectedBundles.end(); ++it)
     {
         // find parent image
         mitk::DataNode::Pointer parentNode;
         mitk::DataStorage::SetOfObjects::ConstPointer parentImgs = GetDataStorage()->GetSources(*it);
         for( mitk::DataStorage::SetOfObjects::const_iterator it2 = parentImgs->begin(); it2 != parentImgs->end(); ++it2 )
         {
             mitk::DataNode::Pointer pImgNode = *it2;
             if ( pImgNode.IsNotNull() && dynamic_cast<mitk::Image*>(pImgNode->GetData()) )
             {
                 parentNode = pImgNode;
                 break;
             }
         }
 
         mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>((*it)->GetData());
         mitk::FiberBundleX::Pointer newBundle = fib->GetDeepCopy();
         QString name((*it)->GetName().c_str());
         name += "_copy";
 
         mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
         fbNode->SetData(newBundle);
         fbNode->SetName(name.toStdString());
         fbNode->SetVisibility(true);
         if (parentNode.IsNotNull())
             GetDataStorage()->Add(fbNode, parentNode);
         else
             GetDataStorage()->Add(fbNode);
 
         // copy child fiducials
         if (m_Controls->m_IncludeFiducials->isChecked())
         {
             mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(*it);
             for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations->begin(); it2 != derivations->end(); ++it2 )
             {
                 mitk::DataNode::Pointer fiducialNode = *it2;
                 if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
                 {
                     mitk::PlanarEllipse::Pointer pe = dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData())->Clone();
                     mitk::DataNode::Pointer newNode = mitk::DataNode::New();
                     newNode->SetData(pe);
                     newNode->SetName(fiducialNode->GetName());
                     newNode->SetBoolProperty("planarfigure.3drendering", true);
                     GetDataStorage()->Add(newNode, fbNode);
 
                 }
             }
         }
     }
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberfoxView::JoinBundles()
 {
     if ( m_SelectedBundles.size()<2 ){
         QMessageBox::information( NULL, "Warning", "Select at least two fiber bundles!");
         MITK_WARN("QmitkFiberFoxView") << "Select at least two fiber bundles!";
         return;
     }
 
     std::vector<mitk::DataNode::Pointer>::const_iterator it = m_SelectedBundles.begin();
     mitk::FiberBundleX::Pointer newBundle = dynamic_cast<mitk::FiberBundleX*>((*it)->GetData());
     QString name("");
     name += QString((*it)->GetName().c_str());
     ++it;
     for (; it!=m_SelectedBundles.end(); ++it)
     {
         newBundle = newBundle->AddBundle(dynamic_cast<mitk::FiberBundleX*>((*it)->GetData()));
         name += "+"+QString((*it)->GetName().c_str());
     }
 
     mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
     fbNode->SetData(newBundle);
     fbNode->SetName(name.toStdString());
     fbNode->SetVisibility(true);
     GetDataStorage()->Add(fbNode);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberfoxView::UpdateGui()
 {
     m_Controls->m_GeometryFrame->setEnabled(true);
     m_Controls->m_GeometryMessage->setVisible(false);
     m_Controls->m_DiffusionPropsMessage->setVisible(false);
     m_Controls->m_FiberGenMessage->setVisible(true);
 
     m_Controls->m_TransformBundlesButton->setEnabled(false);
     m_Controls->m_CopyBundlesButton->setEnabled(false);
     m_Controls->m_GenerateFibersButton->setEnabled(false);
     m_Controls->m_FlipButton->setEnabled(false);
     m_Controls->m_CircleButton->setEnabled(false);
     m_Controls->m_BvalueBox->setEnabled(true);
     m_Controls->m_NumGradientsBox->setEnabled(true);
     m_Controls->m_JoinBundlesButton->setEnabled(false);
     m_Controls->m_AlignOnGrid->setEnabled(false);
 
     // Fiber generation gui
     if (m_SelectedFiducial.IsNotNull())
     {
         m_Controls->m_TransformBundlesButton->setEnabled(true);
         m_Controls->m_FlipButton->setEnabled(true);
         m_Controls->m_AlignOnGrid->setEnabled(true);
     }
 
     if (m_SelectedImage.IsNotNull() || !m_SelectedBundles.empty())
     {
         m_Controls->m_CircleButton->setEnabled(true);
         m_Controls->m_FiberGenMessage->setVisible(false);
     }
     if (m_SelectedImage.IsNotNull() && !m_SelectedBundles.empty())
         m_Controls->m_AlignOnGrid->setEnabled(true);
 
     if (!m_SelectedBundles.empty())
     {
         m_Controls->m_TransformBundlesButton->setEnabled(true);
         m_Controls->m_CopyBundlesButton->setEnabled(true);
         m_Controls->m_GenerateFibersButton->setEnabled(true);
 
         if (m_SelectedBundles.size()>1)
             m_Controls->m_JoinBundlesButton->setEnabled(true);
     }
 
     // Signal generation gui
     if (m_Controls->m_MaskComboBox->GetSelectedNode().IsNotNull() || m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull())
     {
         m_Controls->m_GeometryMessage->setVisible(true);
         m_Controls->m_GeometryFrame->setEnabled(false);
     }
 
-    if (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull() && dynamic_cast<mitk::DiffusionImage<short>*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData()))
+    if (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull() && mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData())))
     {
         m_Controls->m_DiffusionPropsMessage->setVisible(true);
         m_Controls->m_BvalueBox->setEnabled(false);
         m_Controls->m_NumGradientsBox->setEnabled(false);
         m_Controls->m_GeometryMessage->setVisible(true);
         m_Controls->m_GeometryFrame->setEnabled(false);
     }
 }
 
 void QmitkFiberfoxView::OnSelectionChanged( berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>& nodes )
 {
     m_SelectedBundles2.clear();
     m_SelectedImages.clear();
     m_SelectedFiducials.clear();
     m_SelectedFiducial = NULL;
     m_SelectedBundles.clear();
     m_SelectedImage = NULL;
 
     // iterate all selected objects, adjust warning visibility
     for( int i=0; i<nodes.size(); i++)
     {
         mitk::DataNode::Pointer node = nodes.at(i);
 
+//        bool isDiffusionImage(false);
+//        if ( node.IsNotNull() )
+//        {
+//          isDiffusionImage = mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData()));
+//        }
+
+//        if ( node.IsNotNull() && isDiffusionImage )
+//        {
+//            m_SelectedDWI = node;
+//            m_SelectedImage = node;
+//            m_SelectedImages.push_back(node);
+//        }
+
         if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
         {
             m_SelectedImages.push_back(node);
             m_SelectedImage = node;
         }
         else if ( node.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(node->GetData()) )
         {
             m_SelectedBundles2.push_back(node);
             if (m_Controls->m_RealTimeFibers->isChecked())
             {
                 m_SelectedBundles.push_back(node);
                 mitk::FiberBundleX::Pointer newFib = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
                 if (newFib->GetNumFibers()!=m_Controls->m_FiberDensityBox->value())
                     GenerateFibers();
             }
             else
                 m_SelectedBundles.push_back(node);
         }
         else if ( node.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(node->GetData()) )
         {
             m_SelectedFiducials.push_back(node);
             m_SelectedFiducial = node;
             m_SelectedBundles.clear();
             mitk::DataStorage::SetOfObjects::ConstPointer parents = GetDataStorage()->GetSources(node);
             for( mitk::DataStorage::SetOfObjects::const_iterator it = parents->begin(); it != parents->end(); ++it )
             {
                 mitk::DataNode::Pointer pNode = *it;
                 if ( pNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(pNode->GetData()) )
                     m_SelectedBundles.push_back(pNode);
             }
         }
     }
     UpdateGui();
 }
 
 
 void QmitkFiberfoxView::EnableCrosshairNavigation()
 {
     MITK_DEBUG << "EnableCrosshairNavigation";
 
     // enable the crosshair navigation
     if (mitk::ILinkedRenderWindowPart* linkedRenderWindow =
             dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart()))
     {
         MITK_DEBUG << "enabling linked navigation";
         linkedRenderWindow->EnableLinkedNavigation(true);
         //        linkedRenderWindow->EnableSlicingPlanes(true);
     }
 
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::DisableCrosshairNavigation()
 {
     MITK_DEBUG << "DisableCrosshairNavigation";
 
     // disable the crosshair navigation during the drawing
     if (mitk::ILinkedRenderWindowPart* linkedRenderWindow =
             dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart()))
     {
         MITK_DEBUG << "disabling linked navigation";
         linkedRenderWindow->EnableLinkedNavigation(false);
         //        linkedRenderWindow->EnableSlicingPlanes(false);
     }
 }
 
 void QmitkFiberfoxView::NodeRemoved(const mitk::DataNode* node)
 {
     mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>(node);
     std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it = m_DataNodeToPlanarFigureData.find(nonConstNode);
 
     if (dynamic_cast<FiberBundleX*>(node->GetData()))
     {
         m_SelectedBundles.clear();
         m_SelectedBundles2.clear();
     }
     else if (dynamic_cast<Image*>(node->GetData()))
         m_SelectedImages.clear();
 
     if( it != m_DataNodeToPlanarFigureData.end() )
     {
         QmitkPlanarFigureData& data = it->second;
 
         // remove observers
         data.m_Figure->RemoveObserver( data.m_EndPlacementObserverTag );
         data.m_Figure->RemoveObserver( data.m_SelectObserverTag );
         data.m_Figure->RemoveObserver( data.m_StartInteractionObserverTag );
         data.m_Figure->RemoveObserver( data.m_EndInteractionObserverTag );
 
         m_DataNodeToPlanarFigureData.erase( it );
     }
 }
 
 void QmitkFiberfoxView::NodeAdded( const mitk::DataNode* node )
 {
     // add observer for selection in renderwindow
     mitk::PlanarFigure* figure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
     bool isPositionMarker (false);
     node->GetBoolProperty("isContourMarker", isPositionMarker);
     if( figure && !isPositionMarker )
     {
         MITK_DEBUG << "figure added. will add interactor if needed.";
         mitk::PlanarFigureInteractor::Pointer figureInteractor
                 = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer());
 
         mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>( node );
         if(figureInteractor.IsNull())
         {
             figureInteractor = mitk::PlanarFigureInteractor::New();
             us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "MitkPlanarFigure" );
             figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
             figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
             figureInteractor->SetDataNode( nonConstNode );
         }
 
         MITK_DEBUG << "will now add observers for planarfigure";
         QmitkPlanarFigureData data;
         data.m_Figure = figure;
 
         //        // add observer for event when figure has been placed
         typedef itk::SimpleMemberCommand< QmitkFiberfoxView > SimpleCommandType;
         //        SimpleCommandType::Pointer initializationCommand = SimpleCommandType::New();
         //        initializationCommand->SetCallbackFunction( this, &QmitkFiberfoxView::PlanarFigureInitialized );
         //        data.m_EndPlacementObserverTag = figure->AddObserver( mitk::EndPlacementPlanarFigureEvent(), initializationCommand );
 
         // add observer for event when figure is picked (selected)
         typedef itk::MemberCommand< QmitkFiberfoxView > MemberCommandType;
         MemberCommandType::Pointer selectCommand = MemberCommandType::New();
         selectCommand->SetCallbackFunction( this, &QmitkFiberfoxView::PlanarFigureSelected );
         data.m_SelectObserverTag = figure->AddObserver( mitk::SelectPlanarFigureEvent(), selectCommand );
 
         // add observer for event when interaction with figure starts
         SimpleCommandType::Pointer startInteractionCommand = SimpleCommandType::New();
         startInteractionCommand->SetCallbackFunction( this, &QmitkFiberfoxView::DisableCrosshairNavigation);
         data.m_StartInteractionObserverTag = figure->AddObserver( mitk::StartInteractionPlanarFigureEvent(), startInteractionCommand );
 
         // add observer for event when interaction with figure starts
         SimpleCommandType::Pointer endInteractionCommand = SimpleCommandType::New();
         endInteractionCommand->SetCallbackFunction( this, &QmitkFiberfoxView::EnableCrosshairNavigation);
         data.m_EndInteractionObserverTag = figure->AddObserver( mitk::EndInteractionPlanarFigureEvent(), endInteractionCommand );
 
         m_DataNodeToPlanarFigureData[nonConstNode] = data;
     }
 }
 
 void QmitkFiberfoxView::PlanarFigureSelected( itk::Object* object, const itk::EventObject& )
 {
     mitk::TNodePredicateDataType<mitk::PlanarFigure>::Pointer isPf = mitk::TNodePredicateDataType<mitk::PlanarFigure>::New();
 
     mitk::DataStorage::SetOfObjects::ConstPointer allPfs = this->GetDataStorage()->GetSubset( isPf );
     for ( mitk::DataStorage::SetOfObjects::const_iterator it = allPfs->begin(); it!=allPfs->end(); ++it)
     {
         mitk::DataNode* node = *it;
 
         if( node->GetData() == object )
         {
             node->SetSelected(true);
             m_SelectedFiducial = node;
         }
         else
             node->SetSelected(false);
     }
     UpdateGui();
     this->RequestRenderWindowUpdate();
 }
 
 void QmitkFiberfoxView::SetFocus()
 {
     m_Controls->m_CircleButton->setFocus();
 }
 
 
 void QmitkFiberfoxView::SetOutputPath()
 {
     // SELECT FOLDER DIALOG
 
     string outputPath = QFileDialog::getExistingDirectory(NULL, "Save images to...", QString(outputPath.c_str())).toStdString();
 
     if (outputPath.empty())
         m_Controls->m_SavePathEdit->setText("-");
     else
     {
         outputPath += "/";
         m_Controls->m_SavePathEdit->setText(QString(outputPath.c_str()));
     }
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.h
index a4e48967ec..edff70dd72 100755
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.h
@@ -1,210 +1,214 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 
 
 #include <berryISelectionListener.h>
 #include <berryIStructuredSelection.h>
 
 #include <QmitkAbstractView.h>
 #include "ui_QmitkFiberfoxViewControls.h"
 #include <itkVectorImage.h>
 #include <itkVectorContainer.h>
 #include <itkOrientationDistributionFunction.h>
 #include <mitkFiberBundleX.h>
 #include <mitkPlanarEllipse.h>
 #include <mitkDiffusionNoiseModel.h>
 #include <mitkDiffusionSignalModel.h>
 #include <mitkRicianNoiseModel.h>
 #include <itkTractsToDWIImageFilter.h>
 #include <itkAddArtifactsToDwiImageFilter.h>
 #include <mitkTensorModel.h>
 #include <mitkBallModel.h>
 #include <mitkStickModel.h>
 #include <mitkAstroStickModel.h>
 #include <mitkDotModel.h>
 #include <QThread>
 #include <QObject>
 #include <QTimer>
 #include <QTime>
 #include <mitkFiberfoxParameters.h>
 #include <itkStatisticsImageFilter.h>
+#include <mitkDiffusionPropertyHelper.h>
 
 /*!
 \brief View for fiber based diffusion software phantoms (Fiberfox). See "Fiberfox: Facilitating the creation of realistic white matter software phantoms" (DOI: 10.1002/mrm.25045) for details.
 \sa QmitkFunctionality
 \ingroup Functionalities
 */
 
 // Forward Qt class declarations
 
 using namespace std;
 
 class QmitkFiberfoxView;
 
 class QmitkFiberfoxWorker : public QObject
 {
     Q_OBJECT
 
 public:
 
     QmitkFiberfoxWorker(QmitkFiberfoxView* view);
     int m_FilterType;
 
 public slots:
 
     void run();
 
 private:
 
     QmitkFiberfoxView*                  m_View;
 };
 
 class QmitkFiberfoxView : public QmitkAbstractView
 {
 
     // this is needed for all Qt objects that should have a Qt meta-object
     // (everything that derives from QObject and wants to have signal/slots)
     Q_OBJECT
 
 public:
 
     static const string VIEW_ID;
 
     QmitkFiberfoxView();
     virtual ~QmitkFiberfoxView();
 
     virtual void CreateQtPartControl(QWidget *parent);
     void SetFocus();
 
-    typedef itk::Image<double, 3>           ItkDoubleImgType;
-    typedef itk::Image<unsigned char, 3>    ItkUcharImgType;
+    typedef mitk::DiffusionPropertyHelper::GradientDirectionType            GradientDirectionType;
+    typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType  GradientDirectionContainerType;
     typedef itk::Vector<double,3>           GradientType;
     typedef vector<GradientType>            GradientListType;
+    typedef itk::VectorImage< short, 3 >                                    ItkDwiType;
+    typedef itk::Image<double, 3>           ItkDoubleImgType;
+    typedef itk::Image<unsigned char, 3>    ItkUcharImgType;
 
     template<int ndirs> vector<itk::Vector<double,3> > MakeGradientList();
 
 protected slots:
 
     void SetOutputPath();           ///< path where image is automatically saved to after the simulation is finished
     void LoadParameters();          ///< load fiberfox parameters
     void SaveParameters();          ///< save fiberfox parameters
 
     void BeforeThread();
     void AfterThread();
     void KillThread();              ///< abort simulation
     void UpdateSimulationStatus();  ///< print simulation progress and satus messages
 
     void OnDrawROI();               ///< adds new ROI, handles interactors etc.
     void OnAddBundle();             ///< adds new fiber bundle to datastorage
     void OnFlipButton();            ///< negate one coordinate of the fiber waypoints in the selcted planar figure. needed in case of unresolvable twists
     void GenerateFibers();          ///< generate fibers from the selected ROIs
     void GenerateImage();           ///< start image simulation
     void JoinBundles();             ///< merges selcted fiber bundles into one
     void CopyBundles();             ///< add copy of the selected bundle to the datamanager
     void ApplyTransform();          ///< rotate and shift selected bundles
     void AlignOnGrid();             ///< shift selected fiducials to nearest voxel center
     void Comp1ModelFrameVisibility(int index);  ///< only show parameters of selected signal model for compartment 1
     void Comp2ModelFrameVisibility(int index);  ///< only show parameters of selected signal model for compartment 2
     void Comp3ModelFrameVisibility(int index);  ///< only show parameters of selected signal model for compartment 3
     void Comp4ModelFrameVisibility(int index);  ///< only show parameters of selected signal model for compartment 4
     void ShowAdvancedOptions(int state);
 
     /** update fibers if any parameter changes */
     void OnFiberDensityChanged(int value);
     void OnFiberSamplingChanged(double value);
     void OnTensionChanged(double value);
     void OnContinuityChanged(double value);
     void OnBiasChanged(double value);
     void OnVarianceChanged(double value);
     void OnDistributionChanged(int value);
     void OnConstantRadius(int value);
 
     /** update GUI elements */
     void OnAddNoise(int value);
     void OnAddGhosts(int value);
     void OnAddDistortions(int value);
     void OnAddEddy(int value);
     void OnAddSpikes(int value);
     void OnAddAliasing(int value);
     void OnAddMotion(int value);
     void OnMaskSelected(int value);
     void OnFibSelected(int value);
     void OnTemplateSelected(int value);
 
 protected:
 
     /// \brief called by QmitkFunctionality when DataManager's selection has changed
     virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>&);
 
     GradientListType GenerateHalfShell(int NPoints);    ///< generate vectors distributed over the halfsphere
 
     Ui::QmitkFiberfoxViewControls* m_Controls;
 
     void SimulateForExistingDwi(mitk::DataNode* imageNode);     ///< add artifacts to existing diffusion weighted image
     void SimulateImageFromFibers(mitk::DataNode* fiberNode);    ///< simulate new diffusion weighted image
     template< class ScalarType > FiberfoxParameters< ScalarType > UpdateImageParameters();  ///< update fiberfox paramater object (template parameter defines noise model type)
     void UpdateGui();                                           ///< enable/disbale buttons etc. according to current datamanager selection
     void PlanarFigureSelected( itk::Object* object, const itk::EventObject& );
     void EnableCrosshairNavigation();               ///< enable crosshair navigation if planar figure interaction ends
     void DisableCrosshairNavigation();              ///< disable crosshair navigation if planar figure interaction starts
     void NodeAdded( const mitk::DataNode* node );   ///< add observers
     void NodeRemoved(const mitk::DataNode* node);   ///< remove observers
 
     /** structure to keep track of planar figures and observers */
     struct QmitkPlanarFigureData
     {
         QmitkPlanarFigureData()
             : m_Figure(0)
             , m_EndPlacementObserverTag(0)
             , m_SelectObserverTag(0)
             , m_StartInteractionObserverTag(0)
             , m_EndInteractionObserverTag(0)
             , m_Flipped(0)
         {
         }
         mitk::PlanarFigure* m_Figure;
         unsigned int m_EndPlacementObserverTag;
         unsigned int m_SelectObserverTag;
         unsigned int m_StartInteractionObserverTag;
         unsigned int m_EndInteractionObserverTag;
         unsigned int m_Flipped;
     };
 
     std::map<mitk::DataNode*, QmitkPlanarFigureData>    m_DataNodeToPlanarFigureData;   ///< map each planar figure uniquely to a QmitkPlanarFigureData
     mitk::DataNode::Pointer                             m_SelectedFiducial;             ///< selected planar ellipse
     mitk::DataNode::Pointer                             m_SelectedImage;
     vector< mitk::DataNode::Pointer >                   m_SelectedBundles;
     vector< mitk::DataNode::Pointer >                   m_SelectedBundles2;
     vector< mitk::DataNode::Pointer >                   m_SelectedFiducials;
     vector< mitk::DataNode::Pointer >                   m_SelectedImages;
 
     QString m_ParameterFile;    ///< parameter file name
 
     // GUI thread
     QmitkFiberfoxWorker     m_Worker;   ///< runs filter
     QThread                 m_Thread;   ///< worker thread
     bool                    m_ThreadIsRunning;
     QTimer*                 m_SimulationTimer;
     QTime                   m_SimulationTime;
     QString                 m_SimulationStatusText;
 
     /** Image filters that do all the simulations. */
     itk::TractsToDWIImageFilter< short >::Pointer           m_TractsToDwiFilter;
     itk::AddArtifactsToDwiImageFilter< short >::Pointer     m_ArtifactsToDwiFilter;
 
     friend class QmitkFiberfoxWorker;
 };
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.cpp
index d7a48764db..ca203d8df9 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.cpp
@@ -1,826 +1,832 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkIVIMView.h"
 #include "QmitkStdMultiWidget.h"
 
 // qt
 #include "qmessagebox.h"
 #include "qclipboard.h"
 
 // mitk
-#include "mitkDiffusionImage.h"
+#include "mitkImage.h"
 #include "mitkImageCast.h"
 
 // itk
 #include "itkScalarImageToHistogramGenerator.h"
 #include "itkRegionOfInterestImageFilter.h"
 #include "itkImageRegionConstIteratorWithIndex.h"
 
 // itk/mitk
 #include "itkDiffusionIntravoxelIncoherentMotionReconstructionImageFilter.h"
 #include "itkRegularizedIVIMReconstructionFilter.h"
 #include "mitkImageCast.h"
 
 const std::string QmitkIVIMView::VIEW_ID = "org.mitk.views.ivim";
 
 QmitkIVIMView::QmitkIVIMView()
     : QmitkFunctionality()
     , m_Controls( 0 )
     , m_MultiWidget( NULL )
     , m_SliceObserverTag1(0), m_SliceObserverTag2(0), m_SliceObserverTag3(0)
     , m_DiffusionImageNode(NULL)
     , m_MaskImageNode(NULL)
     , m_Active(false)
 {
 }
 
 QmitkIVIMView::~QmitkIVIMView()
 {
 //    QmitkStdMultiWidget* MultiWidget = this->GetActiveStdMultiWidget(false);
 
 //    if(MultiWidget)
 //    {
 //        //unregister observers when view is destroyed
 //        if( MultiWidget->mitkWidget1 != NULL && m_SliceObserverTag1 != 0)
 //        {
 //            mitk::SliceNavigationController* slicer = MultiWidget->mitkWidget1->GetSliceNavigationController();
 //            slicer->RemoveObserver( m_SliceObserverTag1 );
 //        }
 
 //        if( MultiWidget->mitkWidget2 != NULL && m_SliceObserverTag2 != 0)
 //        {
 //            mitk::SliceNavigationController* slicer = MultiWidget->mitkWidget2->GetSliceNavigationController();
 //            slicer->RemoveObserver( m_SliceObserverTag2 );
 //        }
 
 //        if( MultiWidget->mitkWidget3!= NULL && m_SliceObserverTag3 != 0)
 //        {
 //            mitk::SliceNavigationController* slicer = MultiWidget->mitkWidget3->GetSliceNavigationController();
 //            slicer->RemoveObserver( m_SliceObserverTag3 );
 //        }
 //    }
 }
 
 void QmitkIVIMView::CreateQtPartControl( QWidget *parent )
 {
 
     // build up qt view, unless already done
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkIVIMViewControls;
         m_Controls->setupUi( parent );
 
         connect( m_Controls->m_ButtonStart, SIGNAL(clicked()), this, SLOT(FittIVIMStart()) );
         connect( m_Controls->m_ButtonAutoThres, SIGNAL(clicked()), this, SLOT(AutoThreshold()) );
 
         connect( m_Controls->m_MethodCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(MethodCombo(int)) );
 
         connect( m_Controls->m_DStarSlider, SIGNAL(valueChanged(int)), this, SLOT(DStarSlider(int)) );
         connect( m_Controls->m_BThreshSlider, SIGNAL(valueChanged(int)), this, SLOT(BThreshSlider(int)) );
         connect( m_Controls->m_S0ThreshSlider, SIGNAL(valueChanged(int)), this, SLOT(S0ThreshSlider(int)) );
         connect( m_Controls->m_NumItSlider, SIGNAL(valueChanged(int)), this, SLOT(NumItsSlider(int)) );
         connect( m_Controls->m_LambdaSlider, SIGNAL(valueChanged(int)), this, SLOT(LambdaSlider(int)) );
 
         connect( m_Controls->m_CheckDStar, SIGNAL(clicked()), this, SLOT(Checkbox()) );
         connect( m_Controls->m_CheckD, SIGNAL(clicked()), this, SLOT(Checkbox()) );
         connect( m_Controls->m_Checkf, SIGNAL(clicked()), this, SLOT(Checkbox()) );
 
         connect( m_Controls->m_ChooseMethod, SIGNAL(clicked()), this, SLOT(ChooseMethod()) );
         connect( m_Controls->m_CurveClipboard, SIGNAL(clicked()), this, SLOT(ClipboardCurveButtonClicked()) );
         connect( m_Controls->m_ValuesClipboard, SIGNAL(clicked()), this, SLOT(ClipboardStatisticsButtonClicked()) );
 
     }
 
     QString dstar = QString::number(m_Controls->m_DStarSlider->value()/1000.0);
     m_Controls->m_DStarLabel->setText(dstar);
 
     QString bthresh = QString::number(m_Controls->m_BThreshSlider->value()*5.0);
     m_Controls->m_BThreshLabel->setText(bthresh);
 
     QString s0thresh = QString::number(m_Controls->m_S0ThreshSlider->value()*0.5);
     m_Controls->m_S0ThreshLabel->setText(s0thresh);
 
     QString numits = QString::number(m_Controls->m_NumItSlider->value());
     m_Controls->m_NumItsLabel->setText(numits);
 
     QString lambda = QString::number(m_Controls->m_LambdaSlider->value()*.00001);
     m_Controls->m_LambdaLabel->setText(lambda);
 
     m_Controls->m_MethodCombo->setVisible(m_Controls->m_ChooseMethod->isChecked());
     m_Controls->m_Warning->setVisible(false);
 
     MethodCombo(m_Controls->m_MethodCombo->currentIndex());
 
 }
 
 void QmitkIVIMView::Checkbox()
 {
     itk::StartEvent dummy;
     OnSliceChanged(dummy);
 }
 
 void QmitkIVIMView::MethodCombo(int val)
 {
     switch(val)
     {
     case 0:
         m_Controls->m_DstarFrame->setVisible(false);
         m_Controls->m_NeglSiFrame->setVisible(true);
         m_Controls->m_NeglBframe->setVisible(false);
         m_Controls->m_IterationsFrame->setVisible(false);
         m_Controls->m_LambdaFrame->setVisible(false);
         break;
     case 1:
         m_Controls->m_DstarFrame->setVisible(true);
         m_Controls->m_NeglSiFrame->setVisible(true);
         m_Controls->m_NeglBframe->setVisible(false);
         m_Controls->m_IterationsFrame->setVisible(false);
         m_Controls->m_LambdaFrame->setVisible(false);
         break;
     case 2:
         m_Controls->m_DstarFrame->setVisible(false);
         m_Controls->m_NeglSiFrame->setVisible(true);
         m_Controls->m_NeglBframe->setVisible(true);
         m_Controls->m_IterationsFrame->setVisible(false);
         m_Controls->m_LambdaFrame->setVisible(false);
         break;
     case 3:
         m_Controls->m_DstarFrame->setVisible(false);
         m_Controls->m_NeglSiFrame->setVisible(true);
         m_Controls->m_NeglBframe->setVisible(true);
         m_Controls->m_IterationsFrame->setVisible(false);
         m_Controls->m_LambdaFrame->setVisible(false);
         break;
     case 4:
         m_Controls->m_DstarFrame->setVisible(false);
         m_Controls->m_NeglSiFrame->setVisible(false);
         m_Controls->m_NeglBframe->setVisible(false);
         m_Controls->m_IterationsFrame->setVisible(false);
         m_Controls->m_LambdaFrame->setVisible(false);
         break;
     }
 
     itk::StartEvent dummy;
     OnSliceChanged(dummy);
 }
 
 void QmitkIVIMView::DStarSlider (int val)
 {
     QString sval = QString::number(val/1000.0);
     m_Controls->m_DStarLabel->setText(sval);
 
     itk::StartEvent dummy;
     OnSliceChanged(dummy);
 }
 
 void QmitkIVIMView::BThreshSlider (int val)
 {
     QString sval = QString::number(val*5.0);
     m_Controls->m_BThreshLabel->setText(sval);
 
     itk::StartEvent dummy;
     OnSliceChanged(dummy);
 }
 
 void QmitkIVIMView::S0ThreshSlider (int val)
 {
     QString sval = QString::number(val*0.5);
     m_Controls->m_S0ThreshLabel->setText(sval);
 
     itk::StartEvent dummy;
     OnSliceChanged(dummy);
 }
 
 void QmitkIVIMView::NumItsSlider (int val)
 {
     QString sval = QString::number(val);
     m_Controls->m_NumItsLabel->setText(sval);
 
     itk::StartEvent dummy;
     OnSliceChanged(dummy);
 }
 
 void QmitkIVIMView::LambdaSlider (int val)
 {
     QString sval = QString::number(val*.00001);
     m_Controls->m_LambdaLabel->setText(sval);
 
     itk::StartEvent dummy;
     OnSliceChanged(dummy);
 }
 
 void QmitkIVIMView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
     m_MultiWidget = &stdMultiWidget;
 
     {
         mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
         itk::ReceptorMemberCommand<QmitkIVIMView>::Pointer command = itk::ReceptorMemberCommand<QmitkIVIMView>::New();
         command->SetCallbackFunction( this, &QmitkIVIMView::OnSliceChanged );
         m_SliceObserverTag1 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
     }
 
     {
         mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
         itk::ReceptorMemberCommand<QmitkIVIMView>::Pointer command = itk::ReceptorMemberCommand<QmitkIVIMView>::New();
         command->SetCallbackFunction( this, &QmitkIVIMView::OnSliceChanged );
         m_SliceObserverTag2 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
     }
 
     {
         mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
         itk::ReceptorMemberCommand<QmitkIVIMView>::Pointer command = itk::ReceptorMemberCommand<QmitkIVIMView>::New();
         command->SetCallbackFunction( this, &QmitkIVIMView::OnSliceChanged );
         m_SliceObserverTag3 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
     }
 
 }
 
 void QmitkIVIMView::StdMultiWidgetNotAvailable()
 {
 
     {
         mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
         slicer->RemoveObserver( m_SliceObserverTag1 );
     }
 
     {
         mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
         slicer->RemoveObserver( m_SliceObserverTag2 );
     }
 
     {
         mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
         slicer->RemoveObserver( m_SliceObserverTag3 );
     }
 
     m_MultiWidget = NULL;
 }
 
 void QmitkIVIMView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
     bool foundOneDiffusionImage = false;
     m_Controls->m_InputData->setTitle("Please Select Input Data");
     m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
     m_Controls->m_MaskImageLabel->setText("<font color='grey'>optional</font>");
     m_MaskImageNode = NULL;
     m_DiffusionImageNode = NULL;
 
     // iterate all selected objects, adjust warning visibility
     for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
     {
         mitk::DataNode::Pointer node = *it;
 
         if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
         {
-            if( dynamic_cast<mitk::DiffusionImage<short>*>(node->GetData()) )
+          bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData())) );
+
+            if( isDiffusionImage )
             {
                 m_DiffusionImageNode = node;
                 foundOneDiffusionImage = true;
                 m_Controls->m_DiffusionImageLabel->setText(node->GetName().c_str());
             }
             else
             {
                 bool isBinary = false;
                 node->GetPropertyValue<bool>("binary", isBinary);
                 if (isBinary)
                 {
                     m_MaskImageNode = node;
                     m_Controls->m_MaskImageLabel->setText(node->GetName().c_str());
                 }
             }
         }
     }
 
     if (m_DiffusionImageNode.IsNotNull())
     {
         m_Controls->m_VisualizeResultsWidget->setVisible(true);
         m_Controls->m_InputData->setTitle("Input Data");
     }
     else
     {
         m_Controls->m_VisualizeResultsWidget->setVisible(false);
         m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
     }
 
     m_Controls->m_ButtonStart->setEnabled( foundOneDiffusionImage );
     m_Controls->m_ButtonAutoThres->setEnabled( foundOneDiffusionImage );
 
     m_Controls->m_ControlsFrame->setEnabled( foundOneDiffusionImage );
     m_Controls->m_BottomControlsFrame->setEnabled( foundOneDiffusionImage );
 
     itk::StartEvent dummy;
     OnSliceChanged(dummy);
 }
 
 void QmitkIVIMView::AutoThreshold()
 {
     std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
     if (nodes.empty()) return;
 
     if (!nodes.front())
     {
         // Nothing selected. Inform the user and return
         QMessageBox::information( NULL, "Template", "Please load and select a diffusion image before starting image processing.");
         return;
     }
 
-    typedef mitk::DiffusionImage<short> DiffImgType;
-    DiffImgType* dimg = dynamic_cast<DiffImgType*>(nodes.front()->GetData());
+    mitk::Image* dimg = dynamic_cast<mitk::Image*>(nodes.front()->GetData());
 
     if (!dimg)
     {
         // Nothing selected. Inform the user and return
         QMessageBox::information( NULL, "Template", "No valid diffusion image was found.");
         return;
     }
 
     // find bzero index
     int index = -1;
-    DiffImgType::GradientDirectionContainerType::Pointer directions = dimg->GetDirections();
-    for(DiffImgType::GradientDirectionContainerType::ConstIterator it = directions->Begin();
+    DirContainerType::Pointer directions = static_cast<mitk::GradientDirectionsProperty*>( dimg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
+    for(DirContainerType::ConstIterator it = directions->Begin();
         it != directions->End(); ++it)
     {
         index++;
-        DiffImgType::GradientDirectionType g = it.Value();
+        GradientDirectionType g = it.Value();
         if(g[0] == 0 && g[1] == 0 && g[2] == 0 )
             break;
     }
 
-    typedef itk::VectorImage<short,3> VecImgType;
-    VecImgType::Pointer vecimg = dimg->GetVectorImage();
+    VecImgType::Pointer vecimg = VecImgType::New();
+    mitk::CastToItkImage(dimg, vecimg);
 
     int vecLength = vecimg->GetVectorLength();
     index = index > vecLength-1 ? vecLength-1 : index;
 
     MITK_INFO << "Performing Histogram Analysis on Channel" << index;
 
     typedef itk::Image<short,3> ImgType;
     ImgType::Pointer img = ImgType::New();
     mitk::CastToItkImage(dimg, img);
 
     itk::ImageRegionIterator<ImgType> itw (img, img->GetLargestPossibleRegion() );
     itw.GoToBegin();
 
     itk::ImageRegionConstIterator<VecImgType> itr (vecimg, vecimg->GetLargestPossibleRegion() );
     itr.GoToBegin();
 
     while(!itr.IsAtEnd())
     {
         itw.Set(itr.Get().GetElement(index));
         ++itr;
         ++itw;
     }
 
     typedef itk::Statistics::ScalarImageToHistogramGenerator< ImgType >
             HistogramGeneratorType;
     typedef HistogramGeneratorType::HistogramType HistogramType;
 
     HistogramGeneratorType::Pointer histogramGenerator = HistogramGeneratorType::New();
     histogramGenerator->SetInput( img );
     histogramGenerator->SetMarginalScale( 10 ); // Defines y-margin width of histogram
     histogramGenerator->SetNumberOfBins( 100 ); // CT range [-1024, +2048] --> bin size 4 values
     histogramGenerator->SetHistogramMin(  dimg->GetScalarValueMin() );
     histogramGenerator->SetHistogramMax(  dimg->GetScalarValueMax() * .5 );
     histogramGenerator->Compute();
 
     HistogramType::ConstIterator iter = histogramGenerator->GetOutput()->Begin();
     float maxFreq = 0;
     float maxValue = 0;
     while ( iter != histogramGenerator->GetOutput()->End() )
     {
         if(iter.GetFrequency() > maxFreq)
         {
             maxFreq = iter.GetFrequency();
             maxValue = iter.GetMeasurementVector()[0];
         }
         ++iter;
     }
 
     maxValue *= 2;
 
     int sliderPos = maxValue * 2;
     m_Controls->m_S0ThreshSlider->setValue(sliderPos);
     S0ThreshSlider(sliderPos);
 }
 
 void QmitkIVIMView::FittIVIMStart()
 {
 
     std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
 
-    mitk::DiffusionImage<short>* img = 0;
+    mitk::Image* img = 0;
     for ( unsigned int i=0; i<nodes.size(); i++ )
     {
-        img = dynamic_cast<mitk::DiffusionImage<short>*>(nodes.at(i)->GetData());
-        if (img)
+        img = dynamic_cast<mitk::Image*>(nodes.at(i)->GetData());
+
+        bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(nodes.at(i)->GetData())) );
+
+        if (img && isDiffusionImage)
             break;
     }
+
     if (!img)
     {
         QMessageBox::information( NULL, "Template", "No valid diffusion image was found.");
         return;
     }
 
-    typedef itk::VectorImage<short,3> VecImgType;
-    VecImgType::Pointer vecimg = img->GetVectorImage();
+
+    VecImgType::Pointer vecimg = VecImgType::New();
+    mitk::CastToItkImage(img, vecimg);
 
     OutImgType::IndexType dummy;
 
-    FittIVIM(vecimg, img->GetDirections(), img->GetReferenceBValue(), true, dummy);
+    FittIVIM(vecimg, static_cast<mitk::GradientDirectionsProperty*>( img->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), static_cast<mitk::FloatProperty*>(img->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue(), true, dummy);
     OutputToDatastorage(nodes);
 }
 
 void QmitkIVIMView::OnSliceChanged(const itk::EventObject& /*e*/)
 {
     if(!m_Visible)
         return;
 
     m_Controls->m_Warning->setVisible(false);
     if(!m_Controls || m_DiffusionImageNode.IsNull())
         return;
 
     m_Controls->m_VisualizeResultsWidget->setVisible(false);
 
-    mitk::DiffusionImage<short>::Pointer diffusionImg = dynamic_cast<mitk::DiffusionImage<short>*>(m_DiffusionImageNode->GetData());
+    mitk::Image::Pointer diffusionImg = dynamic_cast<mitk::Image*>(m_DiffusionImageNode->GetData());
     mitk::Image::Pointer maskImg = NULL;
     if (m_MaskImageNode.IsNotNull())
         maskImg = dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData());
 
     if (!m_MultiWidget) return;
 
-    typedef itk::VectorImage<short,3> VecImgType;
-    VecImgType::Pointer vecimg = (VecImgType*)diffusionImg->GetVectorImage().GetPointer();
+    VecImgType::Pointer vecimg = VecImgType::New();
+    mitk::CastToItkImage(diffusionImg, vecimg);
 
     VecImgType::Pointer roiImage = VecImgType::New();
 
     bool success = false;
     if(maskImg.IsNull())
     {
         int roisize = 0;
         if(m_Controls->m_MethodCombo->currentIndex() == 4)
             roisize = 5;
 
         mitk::Point3D pos = m_MultiWidget->GetCrossPosition();
 
         VecImgType::IndexType crosspos;
         diffusionImg->GetGeometry()->WorldToIndex(pos, crosspos);
         if (!vecimg->GetLargestPossibleRegion().IsInside(crosspos))
         {
             m_Controls->m_Warning->setText(QString("Crosshair position not inside of selected diffusion weighted image. Reinit needed!"));
             m_Controls->m_Warning->setVisible(true);
             return;
         }
         else
             m_Controls->m_Warning->setVisible(false);
 
         VecImgType::IndexType index;
         index[0] = crosspos[0] - roisize; index[0] = index[0] < 0 ? 0 : index[0];
         index[1] = crosspos[1] - roisize; index[1] = index[1] < 0 ? 0 : index[1];
         index[2] = crosspos[2] - roisize; index[2] = index[2] < 0 ? 0 : index[2];
 
         VecImgType::SizeType size;
         size[0] = roisize*2+1;
         size[1] = roisize*2+1;
         size[2] = roisize*2+1;
 
         VecImgType::SizeType maxSize = vecimg->GetLargestPossibleRegion().GetSize();
         size[0] = index[0]+size[0] > maxSize[0] ? maxSize[0]-index[0] : size[0];
         size[1] = index[1]+size[1] > maxSize[1] ? maxSize[1]-index[1] : size[1];
         size[2] = index[2]+size[2] > maxSize[2] ? maxSize[2]-index[2] : size[2];
 
         VecImgType::RegionType region;
         region.SetSize( size );
         region.SetIndex( index );
         vecimg->SetRequestedRegion( region );
 
         VecImgType::IndexType  newstart;
         newstart.Fill(0);
 
         VecImgType::RegionType newregion;
         newregion.SetSize( size );
         newregion.SetIndex( newstart );
 
         roiImage->CopyInformation( vecimg );
         roiImage->SetRegions( newregion );
         roiImage->SetOrigin( pos );
         roiImage->Allocate();
         roiImage->SetPixel(newstart, vecimg->GetPixel(index));
 
-        success = FittIVIM(roiImage, diffusionImg->GetDirections(), diffusionImg->GetReferenceBValue(), false, crosspos);
+        success = FittIVIM(roiImage, static_cast<mitk::GradientDirectionsProperty*>( diffusionImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), static_cast<mitk::FloatProperty*>(diffusionImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue(), false, crosspos);
     }
     else
     {
         typedef itk::Image<float,3> MaskImgType;
 
         MaskImgType::Pointer maskItk;
         CastToItkImage( maskImg, maskItk );
 
         mitk::Point3D pos;
         pos[0] = 0;
         pos[1] = 0;
         pos[2] = 0;
 
         VecImgType::IndexType index;
         index[0] = 0;
         index[1] = 0;
         index[2] = 0;
 
         VecImgType::SizeType size;
         size[0] = 1;
         size[1] = 1;
         size[2] = 1;
 
         VecImgType::RegionType region;
         region.SetSize( size );
         region.SetIndex( index );
         vecimg->SetRequestedRegion( region );
 
         // iterators over output and input
         itk::ImageRegionConstIteratorWithIndex<VecImgType>
                 vecit(vecimg, vecimg->GetLargestPossibleRegion());
 
         itk::VariableLengthVector<double> avg(vecimg->GetVectorLength());
         avg.Fill(0);
 
         float numPixels = 0;
         while ( ! vecit.IsAtEnd() )
         {
             VecImgType::PointType point;
             vecimg->TransformIndexToPhysicalPoint(vecit.GetIndex(), point);
 
             MaskImgType::IndexType index;
             maskItk->TransformPhysicalPointToIndex(point, index);
 
             if(maskItk->GetPixel(index) != 0)
             {
                 avg += vecit.Get();
                 numPixels += 1.0;
             }
 
             // update iterators
             ++vecit;
 
         }
 
         avg /= numPixels;
 
         m_Controls->m_Warning->setText(QString("Averaging ")+QString::number((int)numPixels)+QString(" voxels!"));
         m_Controls->m_Warning->setVisible(true);
 
         roiImage->CopyInformation( vecimg );
         roiImage->SetRegions( region );
         roiImage->SetOrigin( pos );
         roiImage->Allocate();
         roiImage->SetPixel(index, avg);
 
-        success = FittIVIM(roiImage, diffusionImg->GetDirections(), diffusionImg->GetReferenceBValue(), false, index);
+        success = FittIVIM(roiImage, static_cast<mitk::GradientDirectionsProperty*>( diffusionImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), static_cast<mitk::FloatProperty*>(diffusionImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue(), false, index);
     }
 
     vecimg->SetRegions( vecimg->GetLargestPossibleRegion() );
 
     if (success)
     {
         m_Controls->m_VisualizeResultsWidget->setVisible(true);
         m_Controls->m_VisualizeResultsWidget->SetParameters(m_Snap);
     }
 }
 
 bool QmitkIVIMView::FittIVIM(itk::VectorImage<short,3>* vecimg, DirContainerType* dirs, float bval, bool multivoxel, OutImgType::IndexType &crosspos)
 {
     IVIMFilterType::Pointer filter = IVIMFilterType::New();
     filter->SetInput(vecimg);
     filter->SetGradientDirections(dirs);
     filter->SetBValue(bval);
 
     switch(m_Controls->m_MethodCombo->currentIndex())
     {
 
     case 0:
         filter->SetMethod(IVIMFilterType::IVIM_FIT_ALL);
         filter->SetS0Thres(m_Controls->m_S0ThreshLabel->text().toDouble());
         break;
 
     case 1:
         filter->SetMethod(IVIMFilterType::IVIM_DSTAR_FIX);
         filter->SetDStar(m_Controls->m_DStarLabel->text().toDouble());
         filter->SetS0Thres(m_Controls->m_S0ThreshLabel->text().toDouble());
         break;
 
     case 2:
         filter->SetMethod(IVIMFilterType::IVIM_D_THEN_DSTAR);
         filter->SetBThres(m_Controls->m_BThreshLabel->text().toDouble());
         filter->SetS0Thres(m_Controls->m_S0ThreshLabel->text().toDouble());
         filter->SetFitDStar(m_Controls->m_CheckDStar->isChecked());
         break;
 
     case 3:
         filter->SetMethod(IVIMFilterType::IVIM_LINEAR_D_THEN_F);
         filter->SetBThres(m_Controls->m_BThreshLabel->text().toDouble());
         filter->SetS0Thres(m_Controls->m_S0ThreshLabel->text().toDouble());
         filter->SetFitDStar(m_Controls->m_CheckDStar->isChecked());
         break;
 
     case 4:
         filter->SetMethod(IVIMFilterType::IVIM_REGULARIZED);
         filter->SetBThres(m_Controls->m_BThreshLabel->text().toDouble());
         filter->SetS0Thres(m_Controls->m_S0ThreshLabel->text().toDouble());
         filter->SetNumberIterations(m_Controls->m_NumItsLabel->text().toInt());
         filter->SetLambda(m_Controls->m_LambdaLabel->text().toDouble());
         filter->SetFitDStar(m_Controls->m_CheckDStar->isChecked());
         break;
     }
 
     if(!multivoxel)
     {
         filter->SetFitDStar(true);
     }
 
     filter->SetNumberOfThreads(1);
     filter->SetVerbose(false);
     filter->SetCrossPosition(crosspos);
 
     try{
         filter->Update();
         m_Snap = filter->GetSnapshot();
         m_DStarMap = filter->GetOutput(2);
         m_DMap = filter->GetOutput(1);
         m_fMap = filter->GetOutput();
     }
     catch (itk::ExceptionObject &ex)
     {
         MITK_INFO << ex ;
         m_Controls->m_Warning->setText(QString("IVIM fit not possible: ")+ex.GetDescription());
         m_Controls->m_Warning->setVisible(true);
         return false;
     }
     return true;
 }
 
 void QmitkIVIMView::OutputToDatastorage(std::vector<mitk::DataNode*> nodes)
 {
     // Outputs to Datastorage
     QString basename(nodes.front()->GetName().c_str());
 
     if(m_Controls->m_CheckDStar->isChecked())
     {
         mitk::Image::Pointer dstarimage = mitk::Image::New();
         dstarimage->InitializeByItk(m_DStarMap.GetPointer());
         dstarimage->SetVolume(m_DStarMap->GetBufferPointer());
         QString newname2 = basename; newname2 = newname2.append("_DStarMap_%1").arg(m_Controls->m_MethodCombo->currentText());
         mitk::DataNode::Pointer node2=mitk::DataNode::New();
         node2->SetData( dstarimage );
         node2->SetName(newname2.toLatin1());
         GetDefaultDataStorage()->Add(node2);
     }
 
     if(m_Controls->m_CheckD->isChecked())
     {
         mitk::Image::Pointer dimage = mitk::Image::New();
         dimage->InitializeByItk(m_DMap.GetPointer());
         dimage->SetVolume(m_DMap->GetBufferPointer());
         QString newname1 = basename; newname1 = newname1.append("_DMap_%1").arg(m_Controls->m_MethodCombo->currentText());
         mitk::DataNode::Pointer node1=mitk::DataNode::New();
         node1->SetData( dimage );
         node1->SetName(newname1.toLatin1());
         GetDefaultDataStorage()->Add(node1);
     }
 
     if(m_Controls->m_Checkf->isChecked())
     {
         mitk::Image::Pointer image = mitk::Image::New();
         image->InitializeByItk(m_fMap.GetPointer());
         image->SetVolume(m_fMap->GetBufferPointer());
         QString newname0 = basename; newname0 = newname0.append("_fMap_%1").arg(m_Controls->m_MethodCombo->currentText());
         mitk::DataNode::Pointer node=mitk::DataNode::New();
         node->SetData( image );
         node->SetName(newname0.toLatin1());
         GetDefaultDataStorage()->Add(node);
     }
 
     m_MultiWidget->RequestUpdate();
 
     // reset the data node labels, the selection in DataManager is lost after adding
     // a new node -> we cannot directly proceed twice, the DWI ( and MASK) image have to be selected again
     m_Controls->m_InputData->setTitle("Please Select Input Data");
     m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
     m_Controls->m_MaskImageLabel->setText("<font color='grey'>optional</font>");
     m_MaskImageNode = NULL;
     m_DiffusionImageNode = NULL;
 
 }
 
 void QmitkIVIMView::ChooseMethod()
 {
     m_Controls->m_MethodCombo->setVisible(m_Controls->m_ChooseMethod->isChecked());
 }
 
 void QmitkIVIMView::ClipboardCurveButtonClicked()
 {
     if(true)
     {
 
         QString clipboard("Measurement Points\n");
         for ( unsigned int i=0; i<m_Snap.bvalues.size(); i++)
         {
             clipboard = clipboard.append( "%L1 \t" )
                     .arg( m_Snap.bvalues[i], 0, 'f', 2 );
         }
         clipboard = clipboard.append( "\n" );
 
         for ( unsigned int i=0; i<m_Snap.allmeas.size(); i++)
         {
             clipboard = clipboard.append( "%L1 \t" )
                     .arg( m_Snap.allmeas[i], 0, 'f', 2 );
         }
         clipboard = clipboard.append( "\n" );
 
 
         clipboard = clipboard.append( "1st Linear Fit of D and f \n" );
         double maxb = m_Snap.bvalues.max_value();
         clipboard = clipboard.append( "%L1 \t %L2 \n %L3 \t %L4 \n" )
                 .arg( (float) 0, 0, 'f', 2 )
                 .arg( maxb, 0, 'f', 2 )
                 .arg(1-m_Snap.currentFunceiled, 0, 'f', 2 )
                 .arg((1-m_Snap.currentFunceiled)*exp(-maxb * m_Snap.currentD), 0, 'f', 2 );
 
 
         int nsampling = 50;
         double f = 1-m_Snap.currentFunceiled;
         clipboard = clipboard.append("Final Model\n");
         for(int i=0; i<nsampling; i++)
         {
             double x = (((1.0)*i)/(1.0*nsampling))*maxb;
             clipboard = clipboard.append( "%L1 \t" )
                     .arg( x, 0, 'f', 2 );
         }
         clipboard = clipboard.append( "\n" );
 
         for(int i=0; i<nsampling; i++)
         {
             double x = (((1.0)*i)/(1.0*nsampling))*maxb;
             double y = f*exp(- x * m_Snap.currentD) + (1-f)*exp(- x * (m_Snap.currentD+m_Snap.currentDStar));
             clipboard = clipboard.append( "%L1 \t" )
                     .arg( y, 0, 'f', 2 );
         }
         clipboard = clipboard.append( "\n" );
 
         QApplication::clipboard()->setText(
                     clipboard, QClipboard::Clipboard );
     }
     else
     {
         QApplication::clipboard()->clear();
     }
 }
 
 
 void QmitkIVIMView::ClipboardStatisticsButtonClicked()
 {
     if ( true )
     {
 
         QString clipboard( "f \t D \t D* \n" );
         clipboard = clipboard.append( "%L1 \t %L2 \t %L3" )
                 .arg( m_Snap.currentF, 0, 'f', 10 )
                 .arg( m_Snap.currentD, 0, 'f', 10 )
                 .arg( m_Snap.currentDStar, 0, 'f', 10 ) ;
 
         QApplication::clipboard()->setText(
                     clipboard, QClipboard::Clipboard );
     }
     else
     {
         QApplication::clipboard()->clear();
     }
 }
 
 void QmitkIVIMView::Activated()
 {
     m_Active = true;
 }
 
 void QmitkIVIMView::Deactivated()
 {
     m_Active = false;
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.h
index bfbf10044d..0ed0a8d7a0 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.h
@@ -1,115 +1,117 @@
 /*===================================================================
 
 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 _QMITKIVIMVIEW_H_INCLUDED
 #define _QMITKIVIMVIEW_H_INCLUDED
 
 #include <berryISelectionListener.h>
 
 #include <QmitkFunctionality.h>
 
 #include "ui_QmitkIVIMViewControls.h"
 
 #include "itkVectorImage.h"
 #include "itkImage.h"
 
-#include "mitkDiffusionImage.h"
+#include <mitkDiffusionPropertyHelper.h>
 #include "itkDiffusionIntravoxelIncoherentMotionReconstructionImageFilter.h"
 
 /*!
   \brief QmitkIVIMView
 
   \warning  This application module is not yet documented. Use "svn blame/praise/annotate" and ask the author to provide basic documentation.
 
   \sa QmitkFunctionality
   \ingroup Functionalities
 */
 
 class QmitkIVIMView : public QmitkFunctionality
 {
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
 
   static const std::string VIEW_ID;
 
   QmitkIVIMView();
   virtual ~QmitkIVIMView();
 
-  typedef mitk::DiffusionImage<short>::GradientDirectionContainerType DirContainerType;
+  typedef mitk::DiffusionPropertyHelper::GradientDirectionType GradientDirectionType;
+  typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType DirContainerType;
   typedef itk::DiffusionIntravoxelIncoherentMotionReconstructionImageFilter<short, float> IVIMFilterType;
+  typedef itk::VectorImage<short,3> VecImgType;
   typedef itk::Image<float,3> OutImgType;
 
   virtual void CreateQtPartControl(QWidget *parent);
 
   virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
   virtual void StdMultiWidgetNotAvailable();
 
   void OnSliceChanged(const itk::EventObject& e);
   void OutputToDatastorage(std::vector<mitk::DataNode*> nodes);
   bool FittIVIM(itk::VectorImage<short,3>* vecimg, DirContainerType* dirs, float bval, bool multivoxel, OutImgType::IndexType &crosspos);
 
   void Activated();
   void Deactivated();
 
 protected slots:
 
   /// \brief Called when the user clicks the GUI button
   void FittIVIMStart();
   void AutoThreshold();
 
   void MethodCombo(int val);
   void Checkbox();
 
   void DStarSlider(int val);
   void BThreshSlider(int val);
   void S0ThreshSlider(int val);
   void NumItsSlider(int val);
   void LambdaSlider(int val);
   void ChooseMethod();
   void ClipboardStatisticsButtonClicked();
   void ClipboardCurveButtonClicked();
 
 protected:
 
   /// \brief called by QmitkFunctionality when DataManager's selection has changed
   virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes );
 
   Ui::QmitkIVIMViewControls* m_Controls;
 
   QmitkStdMultiWidget* m_MultiWidget;
   int m_SliceObserverTag1;
   int m_SliceObserverTag2;
   int m_SliceObserverTag3;
 
   OutImgType::Pointer m_DStarMap;
   OutImgType::Pointer m_DMap;
   OutImgType::Pointer m_fMap;
 
   IVIMFilterType::IVIMSnapshot m_Snap;
 
   mitk::DataNode::Pointer m_DiffusionImageNode;
   mitk::DataNode::Pointer m_MaskImageNode;
 
   bool m_Active;
 };
 
 
 
 #endif // _QMITKIVIMVIEW_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkODFDetailsView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkODFDetailsView.h
index b4386d9a92..437a3bb34b 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkODFDetailsView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkODFDetailsView.h
@@ -1,119 +1,118 @@
 /*===================================================================
 
 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 _QMITKQmitkODFDetailsView_H_INCLUDED
 #define _QMITKQmitkODFDetailsView_H_INCLUDED
 
 #include <berryISelectionListener.h>
 
 #include <QmitkAbstractView.h>
 #include "mitkILifecycleAwarePart.h"
 
 #include "ui_QmitkODFDetailsViewControls.h"
 
 #include <itkVectorImage.h>
 #include <itkImage.h>
-#include <mitkDiffusionImage.h>
 #include <itkOrientationDistributionFunction.h>
 #include <mitkQBallImage.h>
 #include <vtkTransform.h>
 #include <vtkDoubleArray.h>
 #include <vtkOdfSource.h>
 #include <vtkSmartPointer.h>
 #include <QmitkRenderWindow.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkRenderer.h>
 #include <vtkCamera.h>
 #include <itkDiffusionTensor3D.h>
 
 /*!
   \brief View displaying details of the orientation distribution function in the voxel at the current crosshair position.
 
   \sa QmitkFunctionality
   \ingroup Functionalities
 */
 
 class QmitkODFDetailsView : public QmitkAbstractView, public mitk::ILifecycleAwarePart
 {
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
 
   static const std::string VIEW_ID;
 
   QmitkODFDetailsView();
   virtual ~QmitkODFDetailsView();
 
   typedef float TOdfPixelType;
   typedef itk::Vector<TOdfPixelType,QBALL_ODFSIZE> OdfVectorType;
   typedef itk::Image<OdfVectorType,3> OdfVectorImgType;
 
   typedef itk::DiffusionTensor3D< TOdfPixelType >  TensorPixelType;
   typedef itk::Image< TensorPixelType, 3 >         TensorImageType;
 
   virtual void CreateQtPartControl(QWidget *parent);
 
   void OnSliceChanged(const itk::EventObject& e);
 
 protected slots:
 
 protected:
 
   /// \brief called by QmitkFunctionality when DataManager's selection has changed
   virtual void OnSelectionChanged( berry::IWorkbenchPart::Pointer source,
     const QList<mitk::DataNode::Pointer>& nodes );
 
   virtual void SetFocus();
   void Visible();
   void Hidden();
   void Activated();
   void Deactivated();
 
   void UpdateOdf(); ///< called if slice position or datamanager selection has changed
 
   Ui::QmitkODFDetailsViewControls*  m_Controls;
 
   /** observer flags */
   int m_SliceObserverTag1;
   int m_SliceObserverTag2;
   int m_SliceObserverTag3;
   int m_PropertyObserverTag;
 
   /** ODF related variables like mesh structure, values etc. */
   vtkPolyData*                      m_TemplateOdf;  ///< spherical base mesh
   vtkSmartPointer<vtkTransform>     m_OdfTransform;
   vtkSmartPointer<vtkDoubleArray>   m_OdfVals;
   vtkSmartPointer<vtkOdfSource>     m_OdfSource;
 
   int                               m_OdfNormalization; ///< normalization method defined in the visualization view
 
   /** rendering of the ODF */
   vtkActor*                     m_VtkActor;
   vtkPolyDataMapper*            m_VtkMapper;
   vtkRenderer*                  m_Renderer;
   vtkRenderWindow*              m_VtkRenderWindow;
   vtkRenderWindowInteractor*    m_RenderWindowInteractor;
   vtkCamera*                    m_Camera;
 
   mitk::DataNode::Pointer m_ImageNode;
 };
 
 
 
 #endif // _QmitkODFDetailsView_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkOdfMaximaExtractionView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkOdfMaximaExtractionView.cpp
index 55a298ba1d..c928cfe266 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkOdfMaximaExtractionView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkOdfMaximaExtractionView.cpp
@@ -1,779 +1,778 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 //misc
 #define _USE_MATH_DEFINES
 #include <math.h>
 #include <QFileDialog>
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkOdfMaximaExtractionView.h"
 
 // MITK
 #include <mitkImageCast.h>
 #include <mitkFiberBundleX.h>
 #include <mitkImage.h>
-#include <mitkDiffusionImage.h>
 #include <mitkImageToItk.h>
 #include <mitkTensorImage.h>
 
 // ITK
 #include <itkVectorImage.h>
 #include <itkOdfMaximaExtractionFilter.h>
 #include <itkFiniteDiffOdfMaximaExtractionFilter.h>
 #include <itkMrtrixPeakImageConverter.h>
 #include <itkFslPeakImageConverter.h>
 #include <itkShCoefficientImageImporter.h>
 #include <itkDiffusionTensorPrincipalDirectionImageFilter.h>
 
 // Qt
 #include <QMessageBox>
 
 const std::string QmitkOdfMaximaExtractionView::VIEW_ID = "org.mitk.views.odfmaximaextractionview";
 using namespace mitk;
 
 QmitkOdfMaximaExtractionView::QmitkOdfMaximaExtractionView()
     : QmitkFunctionality()
     , m_Controls( 0 )
     , m_MultiWidget( NULL )
 {
 
 }
 
 // Destructor
 QmitkOdfMaximaExtractionView::~QmitkOdfMaximaExtractionView()
 {
 
 }
 
 
 void QmitkOdfMaximaExtractionView::CreateQtPartControl( QWidget *parent )
 {
     // build up qt view, unless already done
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkOdfMaximaExtractionViewControls;
         m_Controls->setupUi( parent );
 
         connect((QObject*) m_Controls->m_StartTensor, SIGNAL(clicked()), (QObject*) this, SLOT(StartTensor()));
         connect((QObject*) m_Controls->m_StartFiniteDiff, SIGNAL(clicked()), (QObject*) this, SLOT(StartFiniteDiff()));
         connect((QObject*) m_Controls->m_GenerateImageButton, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateImage()));
         connect((QObject*) m_Controls->m_ImportPeaks, SIGNAL(clicked()), (QObject*) this, SLOT(ConvertPeaks()));
         connect((QObject*) m_Controls->m_ImportShCoeffs, SIGNAL(clicked()), (QObject*) this, SLOT(ConvertShCoeffs()));
     }
 }
 
 void QmitkOdfMaximaExtractionView::UpdateGui()
 {
     m_Controls->m_GenerateImageButton->setEnabled(false);
     m_Controls->m_StartFiniteDiff->setEnabled(false);
     m_Controls->m_StartTensor->setEnabled(false);
     m_Controls->m_CoeffImageFrame->setEnabled(false);
 
     if (!m_ImageNodes.empty() || !m_TensorImageNodes.empty())
     {
         m_Controls->m_InputData->setTitle("Input Data");
 
         if (!m_TensorImageNodes.empty())
         {
             m_Controls->m_DwiFibLabel->setText(m_TensorImageNodes.front()->GetName().c_str());
             m_Controls->m_StartTensor->setEnabled(true);
         }
         else
         {
             m_Controls->m_DwiFibLabel->setText(m_ImageNodes.front()->GetName().c_str());
             m_Controls->m_StartFiniteDiff->setEnabled(true);
             m_Controls->m_GenerateImageButton->setEnabled(true);
             m_Controls->m_CoeffImageFrame->setEnabled(true);
             m_Controls->m_ShOrderBox->setEnabled(true);
             m_Controls->m_MaxNumPeaksBox->setEnabled(true);
             m_Controls->m_PeakThresholdBox->setEnabled(true);
             m_Controls->m_AbsoluteThresholdBox->setEnabled(true);
         }
     }
     else
         m_Controls->m_DwiFibLabel->setText("<font color='red'>mandatory</font>");
 
 
     if (m_ImageNodes.empty())
     {
         m_Controls->m_ImportPeaks->setEnabled(false);
         m_Controls->m_ImportShCoeffs->setEnabled(false);
     }
     else
     {
         m_Controls->m_ImportPeaks->setEnabled(true);
         m_Controls->m_ImportShCoeffs->setEnabled(true);
     }
 
     if (!m_BinaryImageNodes.empty())
     {
         m_Controls->m_MaskLabel->setText(m_BinaryImageNodes.front()->GetName().c_str());
     }
     else
     {
         m_Controls->m_MaskLabel->setText("<font color='grey'>optional</font>");
     }
 }
 
 template<int shOrder>
 void QmitkOdfMaximaExtractionView::TemplatedConvertShCoeffs(mitk::Image* mitkImg)
 {
     typedef itk::ShCoefficientImageImporter< float, shOrder > FilterType;
     typedef mitk::ImageToItk< itk::Image< float, 4 > > CasterType;
     CasterType::Pointer caster = CasterType::New();
     caster->SetInput(mitkImg);
     caster->Update();
 
     typename FilterType::Pointer filter = FilterType::New();
 
     switch (m_Controls->m_ToolkitBox->currentIndex())
     {
     case 0:
         filter->SetToolkit(FilterType::FSL);
         break;
     case 1:
         filter->SetToolkit(FilterType::MRTRIX);
         break;
     default:
         filter->SetToolkit(FilterType::FSL);
     }
 
     filter->SetInputImage(caster->GetOutput());
     filter->GenerateData();
     typename FilterType::QballImageType::Pointer itkQbi = filter->GetQballImage();
     typename FilterType::CoefficientImageType::Pointer itkCi = filter->GetCoefficientImage();
 
     {
         mitk::Image::Pointer img = mitk::Image::New();
         img->InitializeByItk( itkCi.GetPointer() );
         img->SetVolume( itkCi->GetBufferPointer() );
         DataNode::Pointer node = DataNode::New();
         node->SetData(img);
         node->SetName("_ShCoefficientImage");
         node->SetVisibility(false);
         GetDataStorage()->Add(node);
     }
 
     {
         mitk::QBallImage::Pointer img = mitk::QBallImage::New();
         img->InitializeByItk( itkQbi.GetPointer() );
         img->SetVolume( itkQbi->GetBufferPointer() );
         DataNode::Pointer node = DataNode::New();
         node->SetData(img);
         node->SetName("_QballImage");
         GetDataStorage()->Add(node);
     }
 }
 
 void QmitkOdfMaximaExtractionView::ConvertShCoeffs()
 {
     if (m_ImageNodes.empty())
         return;
     mitk::Image::Pointer mitkImg = dynamic_cast<mitk::Image*>(m_ImageNodes.at(0)->GetData());
     if (mitkImg->GetDimension()!=4)
     {
         MITK_INFO << "wrong image type (need 4 dimensions)";
         return;
     }
 
     int nrCoeffs = mitkImg->GetLargestPossibleRegion().GetSize()[3];
     // solve bx² + cx + d = 0 = shOrder² + 2*shOrder + 2-2*neededCoeffs;
     int c=3, d=2-2*nrCoeffs;
     double D = c*c-4*d;
     int shOrder;
     if (D>0)
     {
         shOrder = (-c+sqrt(D))/2.0;
         if (shOrder<0)
             shOrder = (-c-sqrt(D))/2.0;
     }
     else if (D==0)
         shOrder = -c/2.0;
 
     MITK_INFO << "using SH-order " << shOrder;
 
     switch (shOrder)
     {
     case 2:
         TemplatedConvertShCoeffs<2>(mitkImg);
         break;
     case 4:
         TemplatedConvertShCoeffs<4>(mitkImg);
         break;
     case 6:
         TemplatedConvertShCoeffs<6>(mitkImg);
         break;
     case 8:
         TemplatedConvertShCoeffs<8>(mitkImg);
         break;
     case 10:
         TemplatedConvertShCoeffs<10>(mitkImg);
         break;
     case 12:
         TemplatedConvertShCoeffs<12>(mitkImg);
         break;
     default:
         MITK_INFO << "SH-order " << shOrder << " not supported";
     }
 }
 
 void QmitkOdfMaximaExtractionView::ConvertPeaks()
 {
     if (m_ImageNodes.empty())
         return;
 
     switch (m_Controls->m_ToolkitBox->currentIndex())
     {
     case 0:
     {
         typedef itk::Image< float, 4 > ItkImageType;
         typedef itk::FslPeakImageConverter< float > FilterType;
         FilterType::Pointer filter = FilterType::New();
         FilterType::InputType::Pointer inputVec = FilterType::InputType::New();
         mitk::BaseGeometry::Pointer geom;
 
         for (int i=0; i<m_ImageNodes.size(); i++)
         {
             mitk::Image::Pointer mitkImg = dynamic_cast<mitk::Image*>(m_ImageNodes.at(i)->GetData());
             geom = mitkImg->GetGeometry();
             typedef mitk::ImageToItk< FilterType::InputImageType > CasterType;
             CasterType::Pointer caster = CasterType::New();
             caster->SetInput(mitkImg);
             caster->Update();
             FilterType::InputImageType::Pointer itkImg = caster->GetOutput();
             inputVec->InsertElement(inputVec->Size(), itkImg);
         }
 
         filter->SetInputImages(inputVec);
         filter->GenerateData();
 
         mitk::Vector3D outImageSpacing = geom->GetSpacing();
         float maxSpacing = 1;
         if(outImageSpacing[0]>outImageSpacing[1] && outImageSpacing[0]>outImageSpacing[2])
             maxSpacing = outImageSpacing[0];
         else if (outImageSpacing[1] > outImageSpacing[2])
             maxSpacing = outImageSpacing[1];
         else
             maxSpacing = outImageSpacing[2];
 
         mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle();
         // directions->SetGeometry(geom);
         DataNode::Pointer node = DataNode::New();
         node->SetData(directions);
         node->SetName("_VectorField");
         node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(maxSpacing));
         node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
         GetDataStorage()->Add(node);
 
         typedef FilterType::DirectionImageContainerType DirectionImageContainerType;
         DirectionImageContainerType::Pointer container = filter->GetDirectionImageContainer();
         for (int i=0; i<container->Size(); i++)
         {
             ItkDirectionImage3DType::Pointer itkImg = container->GetElement(i);
             mitk::Image::Pointer img = mitk::Image::New();
             img->InitializeByItk( itkImg.GetPointer() );
             img->SetVolume( itkImg->GetBufferPointer() );
             DataNode::Pointer node = DataNode::New();
             node->SetData(img);
             QString name(m_ImageNodes.at(i)->GetName().c_str());
             name += "_Direction";
             name += QString::number(i+1);
             node->SetName(name.toStdString().c_str());
             node->SetVisibility(false);
             GetDataStorage()->Add(node);
         }
         break;
     }
     case 1:
     {
         typedef itk::Image< float, 4 > ItkImageType;
         typedef itk::MrtrixPeakImageConverter< float > FilterType;
         FilterType::Pointer filter = FilterType::New();
 
         // cast to itk
         mitk::Image::Pointer mitkImg = dynamic_cast<mitk::Image*>(m_ImageNodes.at(0)->GetData());
         mitk::BaseGeometry::Pointer geom = mitkImg->GetGeometry();
         typedef mitk::ImageToItk< FilterType::InputImageType > CasterType;
         CasterType::Pointer caster = CasterType::New();
         caster->SetInput(mitkImg);
         caster->Update();
         FilterType::InputImageType::Pointer itkImg = caster->GetOutput();
 
         filter->SetInputImage(itkImg);
         filter->GenerateData();
 
         mitk::Vector3D outImageSpacing = geom->GetSpacing();
         float maxSpacing = 1;
         if(outImageSpacing[0]>outImageSpacing[1] && outImageSpacing[0]>outImageSpacing[2])
             maxSpacing = outImageSpacing[0];
         else if (outImageSpacing[1] > outImageSpacing[2])
             maxSpacing = outImageSpacing[1];
         else
             maxSpacing = outImageSpacing[2];
 
         mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle();
         //directions->SetGeometry(geom);
         DataNode::Pointer node = DataNode::New();
         node->SetData(directions);
         QString name(m_ImageNodes.at(0)->GetName().c_str());
         name += "_VectorField";
         node->SetName(name.toStdString().c_str());
         node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(maxSpacing));
         node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
         GetDataStorage()->Add(node);
 
         {
             ItkUcharImgType::Pointer numDirImage = filter->GetNumDirectionsImage();
             mitk::Image::Pointer image2 = mitk::Image::New();
             image2->InitializeByItk( numDirImage.GetPointer() );
             image2->SetVolume( numDirImage->GetBufferPointer() );
             DataNode::Pointer node2 = DataNode::New();
             node2->SetData(image2);
             QString name(m_ImageNodes.at(0)->GetName().c_str());
             name += "_NumDirections";
             node2->SetName(name.toStdString().c_str());
             GetDataStorage()->Add(node2);
         }
 
         typedef FilterType::DirectionImageContainerType DirectionImageContainerType;
         DirectionImageContainerType::Pointer container = filter->GetDirectionImageContainer();
         for (int i=0; i<container->Size(); i++)
         {
             ItkDirectionImage3DType::Pointer itkImg = container->GetElement(i);
             mitk::Image::Pointer img = mitk::Image::New();
             img->InitializeByItk( itkImg.GetPointer() );
             img->SetVolume( itkImg->GetBufferPointer() );
             DataNode::Pointer node = DataNode::New();
             node->SetData(img);
             QString name(m_ImageNodes.at(0)->GetName().c_str());
             name += "_Direction";
             name += QString::number(i+1);
             node->SetName(name.toStdString().c_str());
             node->SetVisibility(false);
             GetDataStorage()->Add(node);
         }
         break;
     }
     }
 }
 
 void QmitkOdfMaximaExtractionView::GenerateImage()
 {
     if (!m_ImageNodes.empty())
         GenerateDataFromDwi();
 }
 
 void QmitkOdfMaximaExtractionView::StartTensor()
 {
     if (m_TensorImageNodes.empty())
         return;
 
     typedef itk::DiffusionTensorPrincipalDirectionImageFilter< float, float > MaximaExtractionFilterType;
     MaximaExtractionFilterType::Pointer filter = MaximaExtractionFilterType::New();
 
     mitk::BaseGeometry::Pointer geometry;
     try{
         TensorImage::Pointer img = dynamic_cast<TensorImage*>(m_TensorImageNodes.at(0)->GetData());
         ItkTensorImage::Pointer itkImage = ItkTensorImage::New();
         CastToItkImage(img, itkImage);
         filter->SetInput(itkImage);
         geometry = img->GetGeometry();
     }
     catch(itk::ExceptionObject &e)
     {
         MITK_INFO << "wrong image type: " << e.what();
         QMessageBox::warning( NULL, "Wrong pixel type", "Could not perform Tensor Principal Direction Extraction due to Image has wrong pixel type.", QMessageBox::Ok );
         return;
         //throw e;
     }
 
     if (!m_BinaryImageNodes.empty())
     {
         ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
         Image::Pointer mitkMaskImg = dynamic_cast<Image*>(m_BinaryImageNodes.at(0)->GetData());
         CastToItkImage(mitkMaskImg, itkMaskImage);
         filter->SetMaskImage(itkMaskImage);
     }
 
     if (m_Controls->m_NormalizationBox->currentIndex()==0)
         filter->SetNormalizeVectors(false);
 
     filter->Update();
 
     if (m_Controls->m_OutputDirectionImagesBox->isChecked())
     {
         MaximaExtractionFilterType::OutputImageType::Pointer itkImg = filter->GetOutput();
         mitk::Image::Pointer img = mitk::Image::New();
         img->InitializeByItk( itkImg.GetPointer() );
         img->SetVolume( itkImg->GetBufferPointer() );
         DataNode::Pointer node = DataNode::New();
         node->SetData(img);
         QString name(m_TensorImageNodes.at(0)->GetName().c_str());
         name += "_PrincipalDirection";
         node->SetName(name.toStdString().c_str());
         node->SetVisibility(false);
         GetDataStorage()->Add(node);
     }
 
     if (m_Controls->m_OutputNumDirectionsBox->isChecked())
     {
         ItkUcharImgType::Pointer numDirImage = filter->GetNumDirectionsImage();
         mitk::Image::Pointer image2 = mitk::Image::New();
         image2->InitializeByItk( numDirImage.GetPointer() );
         image2->SetVolume( numDirImage->GetBufferPointer() );
         DataNode::Pointer node2 = DataNode::New();
         node2->SetData(image2);
         QString name(m_TensorImageNodes.at(0)->GetName().c_str());
         name += "_NumDirections";
         node2->SetName(name.toStdString().c_str());
         GetDataStorage()->Add(node2);
     }
 
     if (m_Controls->m_OutputVectorFieldBox->isChecked())
     {
         mitk::Vector3D outImageSpacing = geometry->GetSpacing();
         float minSpacing = 1;
         if(outImageSpacing[0]<outImageSpacing[1] && outImageSpacing[0]<outImageSpacing[2])
             minSpacing = outImageSpacing[0];
         else if (outImageSpacing[1] < outImageSpacing[2])
             minSpacing = outImageSpacing[1];
         else
             minSpacing = outImageSpacing[2];
 
         mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle();
         // directions->SetGeometry(geometry);
         DataNode::Pointer node = DataNode::New();
         node->SetData(directions);
         QString name(m_TensorImageNodes.at(0)->GetName().c_str());
         name += "_VectorField";
         node->SetName(name.toStdString().c_str());
         node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(minSpacing));
         node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
         GetDataStorage()->Add(node);
     }
 }
 
 template<int shOrder>
 void QmitkOdfMaximaExtractionView::StartMaximaExtraction()
 {
     typedef itk::FiniteDiffOdfMaximaExtractionFilter< float, shOrder, 20242 > MaximaExtractionFilterType;
     typename MaximaExtractionFilterType::Pointer filter = MaximaExtractionFilterType::New();
 
     switch (m_Controls->m_ToolkitBox->currentIndex())
     {
     case 0:
         filter->SetToolkit(MaximaExtractionFilterType::FSL);
         break;
     case 1:
         filter->SetToolkit(MaximaExtractionFilterType::MRTRIX);
         break;
     default:
         filter->SetToolkit(MaximaExtractionFilterType::FSL);
     }
 
     mitk::BaseGeometry::Pointer geometry;
     try{
         Image::Pointer img = dynamic_cast<Image*>(m_ImageNodes.at(0)->GetData());
         typedef ImageToItk< typename MaximaExtractionFilterType::CoefficientImageType > CasterType;
         typename CasterType::Pointer caster = CasterType::New();
         caster->SetInput(img);
         caster->Update();
         filter->SetInput(caster->GetOutput());
         geometry = img->GetGeometry();
     }
     catch(itk::ExceptionObject &e)
     {
         MITK_INFO << "wrong image type: " << e.what();
         QMessageBox::warning( NULL, "Wrong pixel type", "Could not perform Finite Differences Extraction due to Image has wrong pixel type.", QMessageBox::Ok );
         return;
         //throw;
     }
 
     filter->SetAngularThreshold(cos((float)m_Controls->m_AngularThreshold->value()*M_PI/180));
     filter->SetClusteringThreshold(cos((float)m_Controls->m_ClusteringAngleBox->value()*M_PI/180));
     filter->SetMaxNumPeaks(m_Controls->m_MaxNumPeaksBox->value());
     filter->SetPeakThreshold(m_Controls->m_PeakThresholdBox->value());
     filter->SetAbsolutePeakThreshold(m_Controls->m_AbsoluteThresholdBox->value());
 
     if (!m_BinaryImageNodes.empty())
     {
         ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
         Image::Pointer mitkMaskImg = dynamic_cast<Image*>(m_BinaryImageNodes.at(0)->GetData());
         CastToItkImage(mitkMaskImg, itkMaskImage);
         filter->SetMaskImage(itkMaskImage);
     }
 
     switch (m_Controls->m_NormalizationBox->currentIndex())
     {
     case 0:
         filter->SetNormalizationMethod(MaximaExtractionFilterType::NO_NORM);
         break;
     case 1:
         filter->SetNormalizationMethod(MaximaExtractionFilterType::MAX_VEC_NORM);
         break;
     case 2:
         filter->SetNormalizationMethod(MaximaExtractionFilterType::SINGLE_VEC_NORM);
         break;
     }
 
     filter->Update();
 
     if (m_Controls->m_OutputDirectionImagesBox->isChecked())
     {
         typedef typename MaximaExtractionFilterType::ItkDirectionImageContainer ItkDirectionImageContainer;
         typename ItkDirectionImageContainer::Pointer container = filter->GetDirectionImageContainer();
         for (int i=0; i<container->Size(); i++)
         {
             typename MaximaExtractionFilterType::ItkDirectionImage::Pointer itkImg = container->GetElement(i);
             mitk::Image::Pointer img = mitk::Image::New();
             img->InitializeByItk( itkImg.GetPointer() );
             img->SetVolume( itkImg->GetBufferPointer() );
             DataNode::Pointer node = DataNode::New();
             node->SetData(img);
             QString name(m_ImageNodes.at(0)->GetName().c_str());
             name += "_Direction";
             name += QString::number(i+1);
             node->SetName(name.toStdString().c_str());
             node->SetVisibility(false);
             GetDataStorage()->Add(node);
         }
     }
 
     if (m_Controls->m_OutputNumDirectionsBox->isChecked())
     {
         ItkUcharImgType::Pointer numDirImage = filter->GetNumDirectionsImage();
         mitk::Image::Pointer image2 = mitk::Image::New();
         image2->InitializeByItk( numDirImage.GetPointer() );
         image2->SetVolume( numDirImage->GetBufferPointer() );
         DataNode::Pointer node2 = DataNode::New();
         node2->SetData(image2);
         QString name(m_ImageNodes.at(0)->GetName().c_str());
         name += "_NumDirections";
         node2->SetName(name.toStdString().c_str());
         GetDataStorage()->Add(node2);
     }
 
     if (m_Controls->m_OutputVectorFieldBox->isChecked())
     {
         mitk::Vector3D outImageSpacing = geometry->GetSpacing();
         float minSpacing = 1;
         if(outImageSpacing[0]<outImageSpacing[1] && outImageSpacing[0]<outImageSpacing[2])
             minSpacing = outImageSpacing[0];
         else if (outImageSpacing[1] < outImageSpacing[2])
             minSpacing = outImageSpacing[1];
         else
             minSpacing = outImageSpacing[2];
 
         mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle();
         // directions->SetGeometry(geometry);
         DataNode::Pointer node = DataNode::New();
         node->SetData(directions);
         QString name(m_ImageNodes.at(0)->GetName().c_str());
         name += "_VectorField";
         node->SetName(name.toStdString().c_str());
         node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(minSpacing));
         node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
         GetDataStorage()->Add(node);
     }
 }
 
 void QmitkOdfMaximaExtractionView::StartFiniteDiff()
 {
     if (m_ImageNodes.empty())
         return;
 
     switch (m_Controls->m_ShOrderBox->currentIndex())
     {
     case 0:
         StartMaximaExtraction<2>();
         break;
     case 1:
         StartMaximaExtraction<4>();
         break;
     case 2:
         StartMaximaExtraction<6>();
         break;
     case 3:
         StartMaximaExtraction<8>();
         break;
     case 4:
         StartMaximaExtraction<10>();
         break;
     case 5:
         StartMaximaExtraction<12>();
         break;
     }
 }
 
 void QmitkOdfMaximaExtractionView::GenerateDataFromDwi()
 {
     typedef itk::OdfMaximaExtractionFilter< float > MaximaExtractionFilterType;
     MaximaExtractionFilterType::Pointer filter = MaximaExtractionFilterType::New();
 
     mitk::BaseGeometry::Pointer geometry;
     if (!m_ImageNodes.empty())
     {
         try{
             Image::Pointer img = dynamic_cast<Image*>(m_ImageNodes.at(0)->GetData());
             typedef ImageToItk< MaximaExtractionFilterType::CoefficientImageType > CasterType;
             CasterType::Pointer caster = CasterType::New();
             caster->SetInput(img);
             caster->Update();
             filter->SetShCoeffImage(caster->GetOutput());
             geometry = img->GetGeometry();
         }
         catch(itk::ExceptionObject &e)
         {
             MITK_INFO << "wrong image type: " << e.what();
             return;
         }
     }
     else
         return;
 
     filter->SetMaxNumPeaks(m_Controls->m_MaxNumPeaksBox->value());
     filter->SetPeakThreshold(m_Controls->m_PeakThresholdBox->value());
 
     if (!m_BinaryImageNodes.empty())
     {
         ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
         Image::Pointer mitkMaskImg = dynamic_cast<Image*>(m_BinaryImageNodes.at(0)->GetData());
         CastToItkImage(mitkMaskImg, itkMaskImage);
         filter->SetMaskImage(itkMaskImage);
     }
 
     switch (m_Controls->m_NormalizationBox->currentIndex())
     {
     case 0:
         filter->SetNormalizationMethod(MaximaExtractionFilterType::NO_NORM);
         break;
     case 1:
         filter->SetNormalizationMethod(MaximaExtractionFilterType::MAX_VEC_NORM);
         break;
     case 2:
         filter->SetNormalizationMethod(MaximaExtractionFilterType::SINGLE_VEC_NORM);
         break;
     }
 
     filter->GenerateData();
 
     ItkUcharImgType::Pointer numDirImage = filter->GetNumDirectionsImage();
 
     if (m_Controls->m_OutputDirectionImagesBox->isChecked())
     {
         typedef MaximaExtractionFilterType::ItkDirectionImageContainer ItkDirectionImageContainer;
         ItkDirectionImageContainer::Pointer container = filter->GetDirectionImageContainer();
         for (int i=0; i<container->Size(); i++)
         {
             MaximaExtractionFilterType::ItkDirectionImage::Pointer itkImg = container->GetElement(i);
             mitk::Image::Pointer img = mitk::Image::New();
             img->InitializeByItk( itkImg.GetPointer() );
             img->SetVolume( itkImg->GetBufferPointer() );
             DataNode::Pointer node = DataNode::New();
             node->SetData(img);
             QString name(m_ImageNodes.at(0)->GetName().c_str());
             name += "_Direction";
             name += QString::number(i+1);
             node->SetName(name.toStdString().c_str());
             GetDataStorage()->Add(node);
         }
     }
 
     if (m_Controls->m_OutputNumDirectionsBox->isChecked())
     {
         mitk::Image::Pointer image2 = mitk::Image::New();
         image2->InitializeByItk( numDirImage.GetPointer() );
         image2->SetVolume( numDirImage->GetBufferPointer() );
         DataNode::Pointer node = DataNode::New();
         node->SetData(image2);
         QString name(m_ImageNodes.at(0)->GetName().c_str());
         name += "_NumDirections";
         node->SetName(name.toStdString().c_str());
         GetDataStorage()->Add(node);
     }
 
     if (m_Controls->m_OutputVectorFieldBox->isChecked())
     {
         mitk::Vector3D outImageSpacing = geometry->GetSpacing();
         float minSpacing = 1;
         if(outImageSpacing[0]<outImageSpacing[1] && outImageSpacing[0]<outImageSpacing[2])
             minSpacing = outImageSpacing[0];
         else if (outImageSpacing[1] < outImageSpacing[2])
             minSpacing = outImageSpacing[1];
         else
             minSpacing = outImageSpacing[2];
 
         mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle();
         // directions->SetGeometry(geometry);
         DataNode::Pointer node = DataNode::New();
         node->SetData(directions);
         QString name(m_ImageNodes.at(0)->GetName().c_str());
         name += "_VectorField";
         node->SetName(name.toStdString().c_str());
         node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(minSpacing));
         node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
         GetDataStorage()->Add(node);
     }
 }
 
 void QmitkOdfMaximaExtractionView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
     m_MultiWidget = &stdMultiWidget;
 }
 
 void QmitkOdfMaximaExtractionView::StdMultiWidgetNotAvailable()
 {
     m_MultiWidget = NULL;
 }
 
 void QmitkOdfMaximaExtractionView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
     m_Controls->m_InputData->setTitle("Please Select Input Data");
     m_Controls->m_DwiFibLabel->setText("<font color='red'>mandatory</font>");
     m_Controls->m_MaskLabel->setText("<font color='grey'>optional</font>");
 
     m_BinaryImageNodes.clear();
     m_ImageNodes.clear();
     m_TensorImageNodes.clear();
 
     // iterate all selected objects, adjust warning visibility
     for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
     {
         mitk::DataNode::Pointer node = *it;
 
         if ( node.IsNotNull() && dynamic_cast<mitk::TensorImage*>(node->GetData()) )
         {
             m_TensorImageNodes.push_back(node);
         }
         else if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
         {
             bool isBinary = false;
             node->GetPropertyValue<bool>("binary", isBinary);
             if (isBinary)
                 m_BinaryImageNodes.push_back(node);
             else
                 m_ImageNodes.push_back(node);
         }
     }
 
     UpdateGui();
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPartialVolumeAnalysisView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPartialVolumeAnalysisView.cpp
index c873ab9b97..f4b2c87f7d 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPartialVolumeAnalysisView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPartialVolumeAnalysisView.cpp
@@ -1,2168 +1,2167 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include "QmitkPartialVolumeAnalysisView.h"
 
 #include <limits>
 
 #include <qlabel.h>
 #include <qspinbox.h>
 #include <qpushbutton.h>
 #include <qcheckbox.h>
 #include <qgroupbox.h>
 #include <qradiobutton.h>
 #include <qlineedit.h>
 #include <qclipboard.h>
 #include <qfiledialog.h>
 
 #include <berryIEditorPart.h>
 #include <berryIWorkbenchPage.h>
 #include <berryPlatform.h>
 
 
 #include "QmitkStdMultiWidget.h"
 #include "QmitkStdMultiWidgetEditor.h"
 #include "QmitkSliderNavigatorWidget.h"
 #include <QMessageBox>
 
 #include "mitkNodePredicateDataType.h"
 #include "mitkNodePredicateOr.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkProperties.h"
 #include "mitkProgressBar.h"
 #include "mitkImageCast.h"
 #include "mitkImageToItk.h"
 #include "mitkITKImageImport.h"
 #include "mitkDataNodeObject.h"
 #include "mitkNodePredicateData.h"
 #include "mitkPlanarFigureInteractor.h"
 #include "mitkGlobalInteraction.h"
 #include "mitkTensorImage.h"
 #include "mitkPlanarCircle.h"
 #include "mitkPlanarRectangle.h"
 #include "mitkPlanarPolygon.h"
 #include "mitkPartialVolumeAnalysisClusteringCalculator.h"
-#include "mitkDiffusionImage.h"
 #include "usModuleRegistry.h"
 
 #include <itkVectorImage.h>
 #include "itkTensorDerivedMeasurementsFilter.h"
 #include "itkDiffusionTensor3D.h"
 #include "itkCartesianToPolarVectorImageFilter.h"
 #include "itkPolarToCartesianVectorImageFilter.h"
 #include "itkBinaryThresholdImageFilter.h"
 #include "itkMaskImageFilter.h"
 #include "itkCastImageFilter.h"
 #include "itkImageMomentsCalculator.h"
 #include <itkResampleImageFilter.h>
 #include <itkGaussianInterpolateImageFunction.h>
 #include <itkNearestNeighborInterpolateImageFunction.h>
 
 #include <vnl/vnl_vector.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 #define PVA_PI M_PI
 
 const std::string QmitkPartialVolumeAnalysisView::VIEW_ID =
         "org.mitk.views.partialvolumeanalysisview";
 
 class QmitkRequestStatisticsUpdateEvent : public QEvent
 {
 public:
     enum Type
     {
         StatisticsUpdateRequest = QEvent::MaxUser - 1025
     };
 
     QmitkRequestStatisticsUpdateEvent()
         : QEvent( (QEvent::Type) StatisticsUpdateRequest ) {};
 };
 
 
 
 typedef itk::Image<short, 3>                 ImageType;
 typedef itk::Image<float, 3>                 FloatImageType;
 typedef itk::Image<itk::Vector<float,3>, 3>  VectorImageType;
 
 inline bool my_isnan(float x)
 {
     volatile float d = x;
 
     if(d!=d)
         return true;
 
     if(d==d)
         return false;
     return d != d;
 
 }
 
 QmitkPartialVolumeAnalysisView::QmitkPartialVolumeAnalysisView(QObject * /*parent*/, const char * /*name*/)
     : //QmitkFunctionality(),
       m_Controls( NULL ),
       m_TimeStepperAdapter( NULL ),
       m_MeasurementInfoRenderer(0),
       m_MeasurementInfoAnnotation(0),
       m_SelectedImageNodes(  ),
       m_SelectedImage( NULL ),
       m_SelectedMaskNode( NULL ),
       m_SelectedImageMask( NULL ),
       m_SelectedPlanarFigureNodes(0),
       m_SelectedPlanarFigure( NULL ),
       m_IsTensorImage(false),
       m_FAImage(0),
       m_RDImage(0),
       m_ADImage(0),
       m_MDImage(0),
       m_CAImage(0),
       //  m_DirectionImage(0),
       m_DirectionComp1Image(0),
       m_DirectionComp2Image(0),
       m_AngularErrorImage(0),
       m_SelectedRenderWindow(NULL),
       m_LastRenderWindow(NULL),
       m_ImageObserverTag( -1 ),
       m_ImageMaskObserverTag( -1 ),
       m_PlanarFigureObserverTag( -1 ),
       m_CurrentStatisticsValid( false ),
       m_StatisticsUpdatePending( false ),
       m_GaussianSigmaChangedSliding(false),
       m_NumberBinsSliding(false),
       m_UpsamplingChangedSliding(false),
       m_ClusteringResult(NULL),
       m_EllipseCounter(0),
       m_RectangleCounter(0),
       m_PolygonCounter(0),
       m_CurrentFigureNodeInitialized(false),
       m_QuantifyClass(2),
       m_IconTexOFF(new QIcon(":/QmitkPartialVolumeAnalysisView/texIntOFFIcon.png")),
       m_IconTexON(new QIcon(":/QmitkPartialVolumeAnalysisView/texIntONIcon.png")),
       m_TexIsOn(true),
       m_Visible(false)
 {
 
 }
 
 
 QmitkPartialVolumeAnalysisView::~QmitkPartialVolumeAnalysisView()
 {
     if ( m_SelectedImage.IsNotNull() )
         m_SelectedImage->RemoveObserver( m_ImageObserverTag );
     if ( m_SelectedImageMask.IsNotNull() )
         m_SelectedImageMask->RemoveObserver( m_ImageMaskObserverTag );
     if ( m_SelectedPlanarFigure.IsNotNull() )
     {
         m_SelectedPlanarFigure->RemoveObserver( m_PlanarFigureObserverTag );
         m_SelectedPlanarFigure->RemoveObserver( m_InitializedObserverTag );
     }
 
     this->GetDataStorage()->AddNodeEvent -= mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
             , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeAddedInDataStorage );
 
     m_SelectedPlanarFigureNodes->NodeChanged.RemoveListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                              , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeChanged ) );
 
     m_SelectedPlanarFigureNodes->NodeRemoved.RemoveListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                              , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeRemoved ) );
 
     m_SelectedPlanarFigureNodes->PropertyChanged.RemoveListener( mitk::MessageDelegate2<QmitkPartialVolumeAnalysisView
                                                                  , const mitk::DataNode*, const mitk::BaseProperty*>( this, &QmitkPartialVolumeAnalysisView::PropertyChanged ) );
 
     m_SelectedImageNodes->NodeChanged.RemoveListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                       , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeChanged ) );
 
     m_SelectedImageNodes->NodeRemoved.RemoveListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                       , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeRemoved ) );
 
     m_SelectedImageNodes->PropertyChanged.RemoveListener( mitk::MessageDelegate2<QmitkPartialVolumeAnalysisView
                                                           , const mitk::DataNode*, const mitk::BaseProperty*>( this, &QmitkPartialVolumeAnalysisView::PropertyChanged ) );
 }
 
 
 void QmitkPartialVolumeAnalysisView::CreateQtPartControl(QWidget *parent)
 {
     if (m_Controls == NULL)
     {
         m_Controls = new Ui::QmitkPartialVolumeAnalysisViewControls;
         m_Controls->setupUi(parent);
         this->CreateConnections();
     }
 
     SetHistogramVisibility();
 
     m_Controls->m_TextureIntON->setIcon(*m_IconTexON);
 
     m_Controls->m_SimilarAnglesFrame->setVisible(false);
     m_Controls->m_SimilarAnglesLabel->setVisible(false);
 
     vtkTextProperty *textProp = vtkTextProperty::New();
     textProp->SetColor(1.0, 1.0, 1.0);
 
     m_MeasurementInfoAnnotation = vtkCornerAnnotation::New();
     m_MeasurementInfoAnnotation->SetMaximumFontSize(12);
     m_MeasurementInfoAnnotation->SetTextProperty(textProp);
 
     m_MeasurementInfoRenderer = vtkRenderer::New();
     m_MeasurementInfoRenderer->AddActor(m_MeasurementInfoAnnotation);
 
     m_SelectedPlanarFigureNodes = mitk::DataStorageSelection::New(this->GetDataStorage(), false);
 
     m_SelectedPlanarFigureNodes->NodeChanged.AddListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                           , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeChanged ) );
 
     m_SelectedPlanarFigureNodes->NodeRemoved.AddListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                           , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeRemoved ) );
 
     m_SelectedPlanarFigureNodes->PropertyChanged.AddListener( mitk::MessageDelegate2<QmitkPartialVolumeAnalysisView
                                                               , const mitk::DataNode*, const mitk::BaseProperty*>( this, &QmitkPartialVolumeAnalysisView::PropertyChanged ) );
 
     m_SelectedImageNodes = mitk::DataStorageSelection::New(this->GetDataStorage(), false);
 
     m_SelectedImageNodes->PropertyChanged.AddListener( mitk::MessageDelegate2<QmitkPartialVolumeAnalysisView
                                                        , const mitk::DataNode*, const mitk::BaseProperty*>( this, &QmitkPartialVolumeAnalysisView::PropertyChanged ) );
 
     m_SelectedImageNodes->NodeChanged.AddListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                    , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeChanged ) );
 
     m_SelectedImageNodes->NodeRemoved.AddListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                    , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeRemoved ) );
 
     this->GetDataStorage()->AddNodeEvent.AddListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                       , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeAddedInDataStorage ) );
 
     Select(NULL,true,true);
 
     SetAdvancedVisibility();
 }
 
 void QmitkPartialVolumeAnalysisView::SetHistogramVisibility()
 {
     m_Controls->m_HistogramWidget->setVisible(m_Controls->m_DisplayHistogramCheckbox->isChecked());
 }
 
 void QmitkPartialVolumeAnalysisView::SetAdvancedVisibility()
 {
     m_Controls->frame_7->setVisible(m_Controls->m_AdvancedCheckbox->isChecked());
 }
 
 void QmitkPartialVolumeAnalysisView::CreateConnections()
 {
     if ( m_Controls )
     {
 
         connect( m_Controls->m_DisplayHistogramCheckbox, SIGNAL( clicked() )
                  , this, SLOT( SetHistogramVisibility() ) );
 
         connect( m_Controls->m_AdvancedCheckbox, SIGNAL( clicked() )
                  , this, SLOT( SetAdvancedVisibility() ) );
 
 
         connect( m_Controls->m_NumberBinsSlider, SIGNAL( sliderReleased () ),
                  this, SLOT( NumberBinsReleasedSlider( ) ) );
         connect( m_Controls->m_UpsamplingSlider, SIGNAL( sliderReleased(  ) ),
                  this, SLOT( UpsamplingReleasedSlider( ) ) );
         connect( m_Controls->m_GaussianSigmaSlider, SIGNAL( sliderReleased(  ) ),
                  this, SLOT( GaussianSigmaReleasedSlider(  ) ) );
         connect( m_Controls->m_SimilarAnglesSlider, SIGNAL( sliderReleased(  ) ),
                  this, SLOT( SimilarAnglesReleasedSlider(  ) ) );
 
         connect( m_Controls->m_NumberBinsSlider, SIGNAL( valueChanged (int) ),
                  this, SLOT( NumberBinsChangedSlider( int ) ) );
         connect( m_Controls->m_UpsamplingSlider, SIGNAL( valueChanged( int ) ),
                  this, SLOT( UpsamplingChangedSlider( int ) ) );
         connect( m_Controls->m_GaussianSigmaSlider, SIGNAL( valueChanged( int ) ),
                  this, SLOT( GaussianSigmaChangedSlider( int ) ) );
         connect( m_Controls->m_SimilarAnglesSlider, SIGNAL( valueChanged( int ) ),
                  this, SLOT( SimilarAnglesChangedSlider(int) ) );
 
         connect( m_Controls->m_OpacitySlider, SIGNAL( valueChanged( int ) ),
                  this, SLOT( OpacityChangedSlider(int) ) );
 
         connect( (QObject*)(m_Controls->m_ButtonCopyHistogramToClipboard), SIGNAL(clicked()),(QObject*) this, SLOT(ToClipBoard()));
 
         connect( m_Controls->m_CircleButton, SIGNAL( clicked() )
                  , this, SLOT( ActionDrawEllipseTriggered() ) );
 
         connect( m_Controls->m_RectangleButton, SIGNAL( clicked() )
                  , this, SLOT( ActionDrawRectangleTriggered() ) );
 
         connect( m_Controls->m_PolygonButton, SIGNAL( clicked() )
                  , this, SLOT( ActionDrawPolygonTriggered() ) );
 
         connect( m_Controls->m_GreenRadio, SIGNAL( clicked(bool) )
                  , this, SLOT( GreenRadio(bool) ) );
 
         connect( m_Controls->m_PartialVolumeRadio, SIGNAL( clicked(bool) )
                  , this, SLOT( PartialVolumeRadio(bool) ) );
 
         connect( m_Controls->m_BlueRadio, SIGNAL( clicked(bool) )
                  , this, SLOT( BlueRadio(bool) ) );
 
         connect( m_Controls->m_AllRadio, SIGNAL( clicked(bool) )
                  , this, SLOT( AllRadio(bool) ) );
 
         connect( m_Controls->m_EstimateCircle, SIGNAL( clicked() )
                  , this, SLOT( EstimateCircle() ) );
 
         connect( (QObject*)(m_Controls->m_TextureIntON), SIGNAL(clicked()), this, SLOT(TextIntON()) );
 
         connect( m_Controls->m_ExportClusteringResultsButton, SIGNAL(clicked()), this, SLOT(ExportClusteringResults()));
     }
 }
 
 void QmitkPartialVolumeAnalysisView::ExportClusteringResults()
 {
     if (m_ClusteringResult.IsNull() || m_SelectedImage.IsNull())
         return;
 
     mitk::BaseGeometry* geometry = m_SelectedImage->GetGeometry();
 
     itk::Image< short, 3>::Pointer referenceImage = itk::Image< short, 3>::New();
 
     itk::Vector<double,3> newSpacing = geometry->GetSpacing();
     mitk::Point3D newOrigin = geometry->GetOrigin();
     mitk::Geometry3D::BoundsArrayType bounds = geometry->GetBounds();
     newOrigin[0] += bounds.GetElement(0);
     newOrigin[1] += bounds.GetElement(2);
     newOrigin[2] += bounds.GetElement(4);
     itk::Matrix<double, 3, 3> newDirection;
     itk::ImageRegion<3> imageRegion;
     for (int i=0; i<3; i++)
         for (int j=0; j<3; j++)
             newDirection[j][i] = geometry->GetMatrixColumn(i)[j]/newSpacing[j];
     imageRegion.SetSize(0, geometry->GetExtent(0));
     imageRegion.SetSize(1, geometry->GetExtent(1));
     imageRegion.SetSize(2, geometry->GetExtent(2));
 
     // apply new image parameters
     referenceImage->SetSpacing( newSpacing );
     referenceImage->SetOrigin( newOrigin );
     referenceImage->SetDirection( newDirection );
     referenceImage->SetRegions( imageRegion );
     referenceImage->Allocate();
 
     typedef itk::Image< float, 3 > OutType;
     mitk::Image::Pointer mitkInImage = dynamic_cast<mitk::Image*>(m_ClusteringResult->GetData());
 
     typedef itk::Image< itk::RGBAPixel<unsigned char>, 3 > ItkRgbaImageType;
     typedef mitk::ImageToItk< ItkRgbaImageType > CasterType;
 
     CasterType::Pointer caster = CasterType::New();
     caster->SetInput(mitkInImage);
     caster->Update();
     ItkRgbaImageType::Pointer itkInImage = caster->GetOutput();
 
     typedef itk::ExtractChannelFromRgbaImageFilter< itk::Image< short, 3>, OutType > ExtractionFilterType;
     ExtractionFilterType::Pointer filter = ExtractionFilterType::New();
     filter->SetInput(itkInImage);
     filter->SetChannel(ExtractionFilterType::ALPHA);
     filter->SetReferenceImage(referenceImage);
     filter->Update();
     OutType::Pointer outImg = filter->GetOutput();
 
     mitk::Image::Pointer img = mitk::Image::New();  img->InitializeByItk(outImg.GetPointer());
     img->SetVolume(outImg->GetBufferPointer());
 
     // init data node
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData(img);
     node->SetName("Clustering Result");
     GetDataStorage()->Add(node);
 }
 
 void QmitkPartialVolumeAnalysisView::EstimateCircle()
 {
     typedef itk::Image<unsigned char, 3> SegImageType;
     SegImageType::Pointer mask_itk = SegImageType::New();
 
     typedef mitk::ImageToItk<SegImageType> CastType;
     CastType::Pointer caster = CastType::New();
     caster->SetInput(m_SelectedImageMask);
     caster->Update();
 
     typedef itk::ImageMomentsCalculator< SegImageType > MomentsType;
     MomentsType::Pointer momentsCalc = MomentsType::New();
     momentsCalc->SetImage(caster->GetOutput());
     momentsCalc->Compute();
     MomentsType::VectorType cog = momentsCalc->GetCenterOfGravity();
     MomentsType::MatrixType axes = momentsCalc->GetPrincipalAxes();
     MomentsType::VectorType moments = momentsCalc->GetPrincipalMoments();
 
     // moments-coord conversion
     // third coordinate min oder max?
 
     // max-min = extent
 
     MomentsType::AffineTransformPointer trafo = momentsCalc->GetPhysicalAxesToPrincipalAxesTransform();
 
     itk::ImageRegionIterator<SegImageType>
             itimage(caster->GetOutput(), caster->GetOutput()->GetLargestPossibleRegion());
     itimage = itimage.Begin();
 
     double max = -9999999999.0;
     double min =  9999999999.0;
 
     while( !itimage.IsAtEnd() )
     {
         if(itimage.Get())
         {
             ImageType::IndexType index = itimage.GetIndex();
 
             itk::Point<float,3> point;
             caster->GetOutput()->TransformIndexToPhysicalPoint(index,point);
 
             itk::Point<float,3> newPoint;
             newPoint = trafo->TransformPoint(point);
 
             if(newPoint[2]<min)
                 min = newPoint[2];
 
             if(newPoint[2]>max)
                 max = newPoint[2];
         }
         ++itimage;
     }
 
     double extent = max - min;
     MITK_DEBUG << "EXTENT = " << extent;
 
     mitk::Point3D origin;
     mitk::Vector3D right, bottom, normal;
 
     double factor = 1000.0;
     mitk::FillVector3D(origin, cog[0]-factor*axes[1][0]-factor*axes[2][0],
                        cog[1]-factor*axes[1][1]-factor*axes[2][1],
                        cog[2]-factor*axes[1][2]-factor*axes[2][2]);
     //          mitk::FillVector3D(normal, axis[0][0],axis[0][1],axis[0][2]);
     mitk::FillVector3D(bottom, 2*factor*axes[1][0], 2*factor*axes[1][1], 2*factor*axes[1][2]);
     mitk::FillVector3D(right,  2*factor*axes[2][0], 2*factor*axes[2][1], 2*factor*axes[2][2]);
 
     mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New();
     planegeometry->InitializeStandardPlane(right.Get_vnl_vector(), bottom.Get_vnl_vector());
     planegeometry->SetOrigin(origin);
 
     double len1 = sqrt(axes[1][0]*axes[1][0] + axes[1][1]*axes[1][1] + axes[1][2]*axes[1][2]);
     double len2 = sqrt(axes[2][0]*axes[2][0] + axes[2][1]*axes[2][1] + axes[2][2]*axes[2][2]);
 
     mitk::Point2D point1;
     point1[0] = factor*len1;
     point1[1] = factor*len2;
 
     mitk::Point2D point2;
     point2[0] = factor*len1+extent*.5;
     point2[1] = factor*len2;
 
     mitk::PlanarCircle::Pointer circle = mitk::PlanarCircle::New();
     circle->SetPlaneGeometry(planegeometry);
     circle->PlaceFigure( point1 );
     circle->SetControlPoint(0,point1);
     circle->SetControlPoint(1,point2);
     //circle->SetCurrentControlPoint( point2 );
 
     mitk::PlanarFigure::PolyLineType polyline = circle->GetPolyLine( 0 );
     MITK_DEBUG << "SIZE of planar figure polyline: " << polyline.size();
 
     AddFigureToDataStorage(circle, "Circle");
 
 }
 
 bool QmitkPartialVolumeAnalysisView::AssertDrawingIsPossible(bool checked)
 {
     if (m_SelectedImageNodes->GetNode().IsNull())
     {
         checked = false;
         this->HandleException("Please select an image!", dynamic_cast<QWidget *>(this->parent()), true);
         return false;
     }
 
     //this->GetActiveStdMultiWidget()->SetWidgetPlanesVisibility(false);
 
     return checked;
 }
 
 void QmitkPartialVolumeAnalysisView::ActionDrawEllipseTriggered()
 {
     bool checked = m_Controls->m_CircleButton->isChecked();
     if(!this->AssertDrawingIsPossible(checked))
         return;
 
     mitk::PlanarCircle::Pointer figure = mitk::PlanarCircle::New();
     // using PV_ prefix for planar figures from this view
     // to distinguish them from that ones created throught the measurement view
     this->AddFigureToDataStorage(figure, QString("PV_Circle%1").arg(++m_EllipseCounter));
 
     MITK_DEBUG << "PlanarCircle created ...";
 }
 
 void QmitkPartialVolumeAnalysisView::ActionDrawRectangleTriggered()
 {
     bool checked = m_Controls->m_RectangleButton->isChecked();
     if(!this->AssertDrawingIsPossible(checked))
         return;
 
     mitk::PlanarRectangle::Pointer figure = mitk::PlanarRectangle::New();
     // using PV_ prefix for planar figures from this view
     // to distinguish them from that ones created throught the measurement view
     this->AddFigureToDataStorage(figure, QString("PV_Rectangle%1").arg(++m_RectangleCounter));
 
     MITK_DEBUG << "PlanarRectangle created ...";
 }
 
 void QmitkPartialVolumeAnalysisView::ActionDrawPolygonTriggered()
 {
     bool checked = m_Controls->m_PolygonButton->isChecked();
     if(!this->AssertDrawingIsPossible(checked))
         return;
 
     mitk::PlanarPolygon::Pointer figure = mitk::PlanarPolygon::New();
     figure->ClosedOn();
     // using PV_ prefix for planar figures from this view
     // to distinguish them from that ones created throught the measurement view
     this->AddFigureToDataStorage(figure, QString("PV_Polygon%1").arg(++m_PolygonCounter));
 
     MITK_DEBUG << "PlanarPolygon created ...";
 }
 
 void QmitkPartialVolumeAnalysisView::AddFigureToDataStorage(mitk::PlanarFigure* figure, const QString& name,
                                                             const char *propertyKey, mitk::BaseProperty *property )
 {
 
     mitk::DataNode::Pointer newNode = mitk::DataNode::New();
     newNode->SetName(name.toStdString());
     newNode->SetData(figure);
 
     // Add custom property, if available
     if ( (propertyKey != NULL) && (property != NULL) )
     {
         newNode->AddProperty( propertyKey, property );
     }
 
     // figure drawn on the topmost layer / image
     this->GetDataStorage()->Add(newNode, m_SelectedImageNodes->GetNode() );
 
     QList<mitk::DataNode::Pointer> selectedNodes = this->GetDataManagerSelection();
     for(unsigned int i = 0; i < selectedNodes.size(); i++)
     {
         selectedNodes[i]->SetSelected(false);
     }
 
     std::vector<mitk::DataNode *> selectedPFNodes = m_SelectedPlanarFigureNodes->GetNodes();
     for(unsigned int i = 0; i < selectedPFNodes.size(); i++)
     {
         selectedPFNodes[i]->SetSelected(false);
     }
     newNode->SetSelected(true);
 
     Select(newNode);
 }
 
 void QmitkPartialVolumeAnalysisView::PlanarFigureInitialized()
 {
     if(m_SelectedPlanarFigureNodes->GetNode().IsNull())
         return;
 
     m_CurrentFigureNodeInitialized = true;
 
     this->Select(m_SelectedPlanarFigureNodes->GetNode());
 
     m_Controls->m_CircleButton->setChecked(false);
     m_Controls->m_RectangleButton->setChecked(false);
     m_Controls->m_PolygonButton->setChecked(false);
 
     //this->GetActiveStdMultiWidget()->SetWidgetPlanesVisibility(true);
     this->RequestStatisticsUpdate();
 
 }
 
 void QmitkPartialVolumeAnalysisView::PlanarFigureFocus(mitk::DataNode* node)
 {
     mitk::PlanarFigure* _PlanarFigure = 0;
     _PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (node->GetData());
 
     if (_PlanarFigure)
     {
 
         FindRenderWindow(node);
 
         const mitk::PlaneGeometry* _PlaneGeometry = _PlanarFigure->GetPlaneGeometry();
 
         // make node visible
         if (m_SelectedRenderWindow)
         {
             mitk::Point3D centerP = _PlaneGeometry->GetOrigin();
             m_SelectedRenderWindow->GetSliceNavigationController()->ReorientSlices(
                         centerP, _PlaneGeometry->GetNormal());
             m_SelectedRenderWindow->GetSliceNavigationController()->SelectSliceByPoint(
                         centerP);
         }
     }
 }
 
 void QmitkPartialVolumeAnalysisView::FindRenderWindow(mitk::DataNode* node)
 {
     if (node && dynamic_cast<mitk::PlanarFigure*> (node->GetData()))
     {
         m_SelectedRenderWindow = 0;
         bool PlanarFigureInitializedWindow = false;
 
         foreach(QmitkRenderWindow * window, this->GetRenderWindowPart()->GetQmitkRenderWindows().values())
         {
             if (!m_SelectedRenderWindow && node->GetBoolProperty("PlanarFigureInitializedWindow", PlanarFigureInitializedWindow, window->GetRenderer()))
             {
                 m_SelectedRenderWindow = window;
             }
         }
     }
 }
 
 
 void QmitkPartialVolumeAnalysisView::OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer> &nodes)
 {
     m_Controls->m_InputData->setTitle("Please Select Input Data");
 
     if (!m_Visible)
         return;
 
     if ( nodes.empty() )
     {
         if (m_ClusteringResult.IsNotNull())
         {
             this->GetDataStorage()->Remove(m_ClusteringResult);
             mitk::RenderingManager::GetInstance()->RequestUpdateAll();
         }
 
         Select(NULL, true, true);
     }
 
     for (int i=0; i<nodes.size(); i++)
         Select(nodes.at(i));
 }
 
 void QmitkPartialVolumeAnalysisView::Select( mitk::DataNode::Pointer node, bool clearMaskOnFirstArgNULL, bool clearImageOnFirstArgNULL )
 {
     // Clear any unreferenced images
     this->RemoveOrphanImages();
 
     bool somethingChanged = false;
     if(node.IsNull())
     {
         somethingChanged = true;
 
         if(clearMaskOnFirstArgNULL)
         {
             if ( (m_SelectedImageMask.IsNotNull()) && (m_ImageMaskObserverTag >= 0) )
             {
                 m_SelectedImageMask->RemoveObserver( m_ImageMaskObserverTag );
                 m_ImageMaskObserverTag = -1;
             }
 
             if ( (m_SelectedPlanarFigure.IsNotNull()) && (m_PlanarFigureObserverTag >= 0) )
             {
                 m_SelectedPlanarFigure->RemoveObserver( m_PlanarFigureObserverTag );
                 m_PlanarFigureObserverTag = -1;
             }
 
             if ( (m_SelectedPlanarFigure.IsNotNull()) && (m_InitializedObserverTag >= 0) )
             {
                 m_SelectedPlanarFigure->RemoveObserver( m_InitializedObserverTag );
                 m_InitializedObserverTag = -1;
             }
 
             m_SelectedPlanarFigure = NULL;
             m_SelectedPlanarFigureNodes->RemoveAllNodes();
             m_CurrentFigureNodeInitialized = false;
             m_SelectedRenderWindow = 0;
 
             m_SelectedMaskNode = NULL;
             m_SelectedImageMask = NULL;
 
         }
 
         if(clearImageOnFirstArgNULL)
         {
             if ( (m_SelectedImage.IsNotNull()) && (m_ImageObserverTag >= 0) )
             {
                 m_SelectedImage->RemoveObserver( m_ImageObserverTag );
                 m_ImageObserverTag = -1;
             }
 
             m_SelectedImageNodes->RemoveAllNodes();
             m_SelectedImage = NULL;
 
             m_IsTensorImage = false;
             m_FAImage = NULL;
             m_RDImage = NULL;
             m_ADImage = NULL;
             m_MDImage = NULL;
             m_CAImage = NULL;
             m_DirectionComp1Image = NULL;
             m_DirectionComp2Image = NULL;
             m_AngularErrorImage = NULL;
 
             m_Controls->m_SimilarAnglesFrame->setVisible(false);
             m_Controls->m_SimilarAnglesLabel->setVisible(false);
         }
     }
     else
     {
         typedef itk::SimpleMemberCommand< QmitkPartialVolumeAnalysisView > ITKCommandType;
         ITKCommandType::Pointer changeListener;
         changeListener = ITKCommandType::New();
         changeListener->SetCallbackFunction( this, &QmitkPartialVolumeAnalysisView::RequestStatisticsUpdate );
 
         // Get selected element
         mitk::TensorImage *selectedTensorImage = dynamic_cast< mitk::TensorImage * >( node->GetData() );
         mitk::Image *selectedImage = dynamic_cast< mitk::Image * >( node->GetData() );
         mitk::PlanarFigure *selectedPlanar = dynamic_cast< mitk::PlanarFigure * >( node->GetData() );
 
         bool isMask = false;
         bool isImage = false;
         bool isPlanar = false;
         bool isTensorImage = false;
 
         if (selectedTensorImage != NULL)
         {
             isTensorImage = true;
         }
         else if(selectedImage != NULL)
         {
             node->GetPropertyValue("binary", isMask);
             isImage = !isMask;
         }
         else if ( (selectedPlanar != NULL) )
         {
             isPlanar = true;
         }
 
         // image
         if(isImage && selectedImage->GetDimension()==3)
         {
             if(selectedImage != m_SelectedImage.GetPointer())
             {
                 somethingChanged = true;
 
                 if ( (m_SelectedImage.IsNotNull()) && (m_ImageObserverTag >= 0) )
                 {
                     m_SelectedImage->RemoveObserver( m_ImageObserverTag );
                     m_ImageObserverTag = -1;
                 }
 
                 *m_SelectedImageNodes = node;
                 m_SelectedImage = selectedImage;
                 m_IsTensorImage = false;
                 m_FAImage = NULL;
                 m_RDImage = NULL;
                 m_ADImage = NULL;
                 m_MDImage = NULL;
                 m_CAImage = NULL;
                 m_DirectionComp1Image = NULL;
                 m_DirectionComp2Image = NULL;
                 m_AngularErrorImage = NULL;
 
                 // Add change listeners to selected objects
                 m_ImageObserverTag = m_SelectedImage->AddObserver(
                             itk::ModifiedEvent(), changeListener );
 
                 m_Controls->m_SimilarAnglesFrame->setVisible(false);
                 m_Controls->m_SimilarAnglesLabel->setVisible(false);
 
                 m_Controls->m_SelectedImageLabel->setText( m_SelectedImageNodes->GetNode()->GetName().c_str() );
             }
         }
 
         //planar
         if(isPlanar)
         {
             if(selectedPlanar != m_SelectedPlanarFigure.GetPointer())
             {
                 MITK_DEBUG << "Planar selection changed";
                 somethingChanged = true;
 
                 // Possibly previous change listeners
                 if ( (m_SelectedPlanarFigure.IsNotNull()) && (m_PlanarFigureObserverTag >= 0) )
                 {
                     m_SelectedPlanarFigure->RemoveObserver( m_PlanarFigureObserverTag );
                     m_PlanarFigureObserverTag = -1;
                 }
 
                 if ( (m_SelectedPlanarFigure.IsNotNull()) && (m_InitializedObserverTag >= 0) )
                 {
                     m_SelectedPlanarFigure->RemoveObserver( m_InitializedObserverTag );
                     m_InitializedObserverTag = -1;
                 }
 
                 m_SelectedPlanarFigure = selectedPlanar;
                 *m_SelectedPlanarFigureNodes = node;
                 m_CurrentFigureNodeInitialized = selectedPlanar->IsPlaced();
 
                 m_SelectedMaskNode = NULL;
                 m_SelectedImageMask = NULL;
 
                 m_PlanarFigureObserverTag = m_SelectedPlanarFigure->AddObserver(
                             mitk::EndInteractionPlanarFigureEvent(), changeListener );
 
                 if(!m_CurrentFigureNodeInitialized)
                 {
                     typedef itk::SimpleMemberCommand< QmitkPartialVolumeAnalysisView > ITKCommandType;
                     ITKCommandType::Pointer initializationCommand;
                     initializationCommand = ITKCommandType::New();
 
                     // set the callback function of the member command
                     initializationCommand->SetCallbackFunction( this, &QmitkPartialVolumeAnalysisView::PlanarFigureInitialized );
 
                     // add an observer
                     m_InitializedObserverTag = selectedPlanar->AddObserver( mitk::EndPlacementPlanarFigureEvent(), initializationCommand );
 
                 }
 
                 m_Controls->m_SelectedMaskLabel->setText( m_SelectedPlanarFigureNodes->GetNode()->GetName().c_str() );
                 PlanarFigureFocus(node);
             }
         }
 
         //mask
         this->m_Controls->m_EstimateCircle->setEnabled(isMask && selectedImage->GetDimension()==3);
         if(isMask && selectedImage->GetDimension()==3)
         {
             if(selectedImage != m_SelectedImage.GetPointer())
             {
                 somethingChanged = true;
 
                 if ( (m_SelectedImageMask.IsNotNull()) && (m_ImageMaskObserverTag >= 0) )
                 {
                     m_SelectedImageMask->RemoveObserver( m_ImageMaskObserverTag );
                     m_ImageMaskObserverTag = -1;
                 }
 
                 m_SelectedMaskNode = node;
                 m_SelectedImageMask = selectedImage;
                 m_SelectedPlanarFigure = NULL;
                 m_SelectedPlanarFigureNodes->RemoveAllNodes();
 
                 m_ImageMaskObserverTag = m_SelectedImageMask->AddObserver(
                             itk::ModifiedEvent(), changeListener );
 
                 m_Controls->m_SelectedMaskLabel->setText( m_SelectedMaskNode->GetName().c_str() );
 
             }
         }
 
         //tensor image
         if(isTensorImage && selectedTensorImage->GetDimension()==3)
         {
             if(selectedImage != m_SelectedImage.GetPointer())
             {
                 somethingChanged = true;
 
                 if ( (m_SelectedImage.IsNotNull()) && (m_ImageObserverTag >= 0) )
                 {
                     m_SelectedImage->RemoveObserver( m_ImageObserverTag );
                     m_ImageObserverTag = -1;
                 }
 
                 *m_SelectedImageNodes = node;
                 m_SelectedImage = selectedImage;
 
                 m_IsTensorImage = true;
 
                 ExtractTensorImages(selectedImage);
 
                 // Add change listeners to selected objects
                 m_ImageObserverTag = m_SelectedImage->AddObserver(
                             itk::ModifiedEvent(), changeListener );
 
                 m_Controls->m_SimilarAnglesFrame->setVisible(true);
                 m_Controls->m_SimilarAnglesLabel->setVisible(true);
 
                 m_Controls->m_SelectedImageLabel->setText( m_SelectedImageNodes->GetNode()->GetName().c_str() );
             }
         }
     }
 
     if(somethingChanged)
     {
         this->SetMeasurementInfoToRenderWindow("");
 
         if(m_SelectedPlanarFigure.IsNull() && m_SelectedImageMask.IsNull() )
         {
             m_Controls->m_SelectedMaskLabel->setText("<font color='red'>mandatory</font>");
             m_Controls->m_ResampleOptionsFrame->setEnabled(false);
             m_Controls->m_HistogramWidget->setEnabled(false);
             m_Controls->m_ClassSelector->setEnabled(false);
             m_Controls->m_DisplayHistogramCheckbox->setEnabled(false);
             m_Controls->m_AdvancedCheckbox->setEnabled(false);
             m_Controls->frame_7->setEnabled(false);
         }
         else
         {
             m_Controls->m_ResampleOptionsFrame->setEnabled(true);
             m_Controls->m_HistogramWidget->setEnabled(true);
             m_Controls->m_ClassSelector->setEnabled(true);
             m_Controls->m_DisplayHistogramCheckbox->setEnabled(true);
             m_Controls->m_AdvancedCheckbox->setEnabled(true);
             m_Controls->frame_7->setEnabled(true);
         }
 
         // Clear statistics / histogram GUI if nothing is selected
         if ( m_SelectedImage.IsNull() )
         {
             m_Controls->m_PlanarFigureButtonsFrame->setEnabled(false);
             m_Controls->m_OpacityFrame->setEnabled(false);
             m_Controls->m_SelectedImageLabel->setText("<font color='red'>mandatory</font>");
         }
         else
         {
             m_Controls->m_PlanarFigureButtonsFrame->setEnabled(true);
             m_Controls->m_OpacityFrame->setEnabled(true);
         }
 
         if( !m_Visible || m_SelectedImage.IsNull()
                 || (m_SelectedPlanarFigure.IsNull() && m_SelectedImageMask.IsNull()) )
         {
             m_Controls->m_InputData->setTitle("Please Select Input Data");
             m_Controls->m_HistogramWidget->ClearItemModel();
             m_CurrentStatisticsValid = false;
         }
         else
         {
             m_Controls->m_InputData->setTitle("Input Data");
             this->RequestStatisticsUpdate();
         }
     }
 }
 
 
 void QmitkPartialVolumeAnalysisView::ShowClusteringResults()
 {
 
     typedef itk::Image<unsigned char, 3> MaskImageType;
     mitk::Image::Pointer mask = 0;
     MaskImageType::Pointer itkmask = 0;
 
     if(m_IsTensorImage && m_Controls->m_SimilarAnglesSlider->value() != 0)
     {
         typedef itk::Image<float, 3> AngularErrorImageType;
         typedef mitk::ImageToItk<AngularErrorImageType> CastType;
         CastType::Pointer caster = CastType::New();
         caster->SetInput(m_AngularErrorImage);
         caster->Update();
 
         typedef itk::BinaryThresholdImageFilter< AngularErrorImageType, MaskImageType > ThreshType;
         ThreshType::Pointer thresh = ThreshType::New();
         thresh->SetUpperThreshold((90-m_Controls->m_SimilarAnglesSlider->value())*(PVA_PI/180.0));
         thresh->SetInsideValue(1.0);
         thresh->SetInput(caster->GetOutput());
         thresh->Update();
         itkmask = thresh->GetOutput();
 
         mask = mitk::Image::New();
         mask->InitializeByItk(itkmask.GetPointer());
         mask->SetVolume(itkmask->GetBufferPointer());
 
         //    GetDefaultDataStorage()->Remove(m_newnode);
         //    m_newnode = mitk::DataNode::New();
         //    m_newnode->SetData(mask);
         //    m_newnode->SetName("masking node");
         //    m_newnode->SetIntProperty( "layer", 1002 );
         //    GetDefaultDataStorage()->Add(m_newnode, m_SelectedImageNodes->GetNode());
 
     }
 
     mitk::Image::Pointer clusteredImage;
     ClusteringType::Pointer clusterer = ClusteringType::New();
 
     if(m_QuantifyClass==3)
     {
 
         if(m_IsTensorImage)
         {
             double *green_fa, *green_rd, *green_ad, *green_md;
             //double *greengray_fa, *greengray_rd, *greengray_ad, *greengray_md;
             double *gray_fa, *gray_rd, *gray_ad, *gray_md;
             //double *redgray_fa, *redgray_rd, *redgray_ad, *redgray_md;
             double *red_fa, *red_rd, *red_ad, *red_md;
 
             mitk::Image* tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(0);
             mitk::Image::ConstPointer imgToCluster = tmpImg;
 
             red_fa   = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->r, mask);
             green_fa = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->g, mask);
             gray_fa  = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->b, mask);
 
             tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(3);
             mitk::Image::ConstPointer imgToCluster3 = tmpImg;
 
             red_rd   = clusterer->PerformQuantification(imgToCluster3, m_CurrentRGBClusteringResults->rgbChannels->r, mask);
             green_rd = clusterer->PerformQuantification(imgToCluster3, m_CurrentRGBClusteringResults->rgbChannels->g, mask);
             gray_rd  = clusterer->PerformQuantification(imgToCluster3, m_CurrentRGBClusteringResults->rgbChannels->b, mask);
 
             tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(4);
             mitk::Image::ConstPointer imgToCluster4 = tmpImg;
 
             red_ad   = clusterer->PerformQuantification(imgToCluster4, m_CurrentRGBClusteringResults->rgbChannels->r, mask);
             green_ad = clusterer->PerformQuantification(imgToCluster4, m_CurrentRGBClusteringResults->rgbChannels->g, mask);
             gray_ad  = clusterer->PerformQuantification(imgToCluster4, m_CurrentRGBClusteringResults->rgbChannels->b, mask);
 
             tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(5);
             mitk::Image::ConstPointer imgToCluster5 = tmpImg;
 
             red_md   = clusterer->PerformQuantification(imgToCluster5, m_CurrentRGBClusteringResults->rgbChannels->r, mask);
             green_md = clusterer->PerformQuantification(imgToCluster5, m_CurrentRGBClusteringResults->rgbChannels->g, mask);
             gray_md  = clusterer->PerformQuantification(imgToCluster5, m_CurrentRGBClusteringResults->rgbChannels->b, mask);
 
             // clipboard
             QString clipboardText("FA\t%1\t%2\t\t%3\t%4\t\t%5\t%6\t");
             clipboardText = clipboardText
                     .arg(red_fa[0]).arg(red_fa[1])
                     .arg(gray_fa[0]).arg(gray_fa[1])
                     .arg(green_fa[0]).arg(green_fa[1]);
             QString clipboardText3("RD\t%1\t%2\t\t%3\t%4\t\t%5\t%6\t");
             clipboardText3 = clipboardText3
                     .arg(red_rd[0]).arg(red_rd[1])
                     .arg(gray_rd[0]).arg(gray_rd[1])
                     .arg(green_rd[0]).arg(green_rd[1]);
             QString clipboardText4("AD\t%1\t%2\t\t%3\t%4\t\t%5\t%6\t");
             clipboardText4 = clipboardText4
                     .arg(red_ad[0]).arg(red_ad[1])
                     .arg(gray_ad[0]).arg(gray_ad[1])
                     .arg(green_ad[0]).arg(green_ad[1]);
             QString clipboardText5("MD\t%1\t%2\t\t%3\t%4\t\t%5\t%6");
             clipboardText5 = clipboardText5
                     .arg(red_md[0]).arg(red_md[1])
                     .arg(gray_md[0]).arg(gray_md[1])
                     .arg(green_md[0]).arg(green_md[1]);
 
             QApplication::clipboard()->setText(clipboardText+clipboardText3+clipboardText4+clipboardText5, QClipboard::Clipboard);
 
             // now paint infos also on renderwindow
             QString plainInfoText("%1  %2  %3        \n");
             plainInfoText = plainInfoText
                     .arg("Red  ", 20)
                     .arg("Gray ", 20)
                     .arg("Green", 20);
 
             QString plainInfoText0("FA:%1 ± %2%3 ± %4%5 ± %6\n");
             plainInfoText0 = plainInfoText0
                     .arg(red_fa[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(red_fa[1], -10, 'g', 2, QLatin1Char( ' ' ))
                     .arg(gray_fa[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(gray_fa[1], -10, 'g', 2, QLatin1Char( ' ' ))
                     .arg(green_fa[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(green_fa[1], -10, 'g', 2, QLatin1Char( ' ' ));
 
             QString plainInfoText3("RDx10³:%1 ± %2%3 ± %4%5 ± %6\n");
             plainInfoText3 = plainInfoText3
                     .arg(1000.0 * red_rd[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_rd[1], -10, 'g', 2, QLatin1Char( ' ' ))
                     .arg(1000.0 * gray_rd[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * gray_rd[1], -10, 'g', 2, QLatin1Char( ' ' ))
                     .arg(1000.0 * green_rd[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * green_rd[1], -10, 'g', 2, QLatin1Char( ' ' ));
 
             QString plainInfoText4("ADx10³:%1 ± %2%3 ± %4%5 ± %6\n");
             plainInfoText4 = plainInfoText4
                     .arg(1000.0 * red_ad[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_ad[1], -10, 'g', 2, QLatin1Char( ' ' ))
                     .arg(1000.0 * gray_ad[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * gray_ad[1], -10, 'g', 2, QLatin1Char( ' ' ))
                     .arg(1000.0 * green_ad[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * green_ad[1], -10, 'g', 2, QLatin1Char( ' ' ));
 
             QString plainInfoText5("MDx10³:%1 ± %2%3 ± %4%5 ± %6");
             plainInfoText5 = plainInfoText5
                     .arg(1000.0 * red_md[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_md[1], -10, 'g', 2, QLatin1Char( ' ' ))
                     .arg(1000.0 * gray_md[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * gray_md[1], -10, 'g', 2, QLatin1Char( ' ' ))
                     .arg(1000.0 * green_md[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * green_md[1], -10, 'g', 2, QLatin1Char( ' ' ));
 
             this->SetMeasurementInfoToRenderWindow(plainInfoText+plainInfoText0+plainInfoText3+plainInfoText4+plainInfoText5);
 
         }
         else
         {
             double* green;
             double* gray;
             double* red;
 
             mitk::Image* tmpImg = m_CurrentStatisticsCalculator->GetInternalImage();
             mitk::Image::ConstPointer imgToCluster = tmpImg;
 
             red = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->r);
             green = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->g);
             gray = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->b);
 
             // clipboard
             QString clipboardText("%1\t%2\t\t%3\t%4\t\t%5\t%6");
             clipboardText = clipboardText.arg(red[0]).arg(red[1])
                     .arg(gray[0]).arg(gray[1])
                     .arg(green[0]).arg(green[1]);
             QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
 
             // now paint infos also on renderwindow
             QString plainInfoText("Red: %1 ± %2\nGray: %3 ± %4\nGreen: %5 ± %6");
             plainInfoText = plainInfoText.arg(red[0]).arg(red[1])
                     .arg(gray[0]).arg(gray[1])
                     .arg(green[0]).arg(green[1]);
 
             this->SetMeasurementInfoToRenderWindow(plainInfoText);
 
         }
 
 
         clusteredImage = m_CurrentRGBClusteringResults->rgb;
 
     }
     else
     {
         if(m_IsTensorImage)
         {
             double *red_fa, *red_rd, *red_ad, *red_md;
 
             mitk::Image* tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(0);
             mitk::Image::ConstPointer imgToCluster = tmpImg;
             red_fa = clusterer->PerformQuantification(imgToCluster, m_CurrentPerformClusteringResults->clusteredImage, mask);
 
             tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(3);
             mitk::Image::ConstPointer imgToCluster3 = tmpImg;
             red_rd = clusterer->PerformQuantification(imgToCluster3, m_CurrentPerformClusteringResults->clusteredImage, mask);
 
             tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(4);
             mitk::Image::ConstPointer imgToCluster4 = tmpImg;
             red_ad = clusterer->PerformQuantification(imgToCluster4, m_CurrentPerformClusteringResults->clusteredImage, mask);
 
             tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(5);
             mitk::Image::ConstPointer imgToCluster5 = tmpImg;
             red_md = clusterer->PerformQuantification(imgToCluster5, m_CurrentPerformClusteringResults->clusteredImage, mask);
 
             // clipboard
             QString clipboardText("FA\t%1\t%2\t");
             clipboardText = clipboardText
                     .arg(red_fa[0]).arg(red_fa[1]);
             QString clipboardText3("RD\t%1\t%2\t");
             clipboardText3 = clipboardText3
                     .arg(red_rd[0]).arg(red_rd[1]);
             QString clipboardText4("AD\t%1\t%2\t");
             clipboardText4 = clipboardText4
                     .arg(red_ad[0]).arg(red_ad[1]);
             QString clipboardText5("MD\t%1\t%2\t");
             clipboardText5 = clipboardText5
                     .arg(red_md[0]).arg(red_md[1]);
 
             QApplication::clipboard()->setText(clipboardText+clipboardText3+clipboardText4+clipboardText5, QClipboard::Clipboard);
 
             // now paint infos also on renderwindow
             QString plainInfoText("%1        \n");
             plainInfoText = plainInfoText
                     .arg("Red  ", 20);
 
             QString plainInfoText0("FA:%1 ± %2\n");
             plainInfoText0 = plainInfoText0
                     .arg(red_fa[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(red_fa[1], -10, 'g', 2, QLatin1Char( ' ' ));
 
             QString plainInfoText3("RDx10³:%1 ± %2\n");
             plainInfoText3 = plainInfoText3
                     .arg(1000.0 * red_rd[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_rd[1], -10, 'g', 2, QLatin1Char( ' ' ));
 
             QString plainInfoText4("ADx10³:%1 ± %2\n");
             plainInfoText4 = plainInfoText4
                     .arg(1000.0 * red_ad[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_ad[1], -10, 'g', 2, QLatin1Char( ' ' ));
 
             QString plainInfoText5("MDx10³:%1 ± %2");
             plainInfoText5 = plainInfoText5
                     .arg(1000.0 * red_md[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_md[1], -10, 'g', 2, QLatin1Char( ' ' ));
 
             this->SetMeasurementInfoToRenderWindow(plainInfoText+plainInfoText0+plainInfoText3+plainInfoText4+plainInfoText5);
 
         }
         else
         {
             double* quant;
 
             mitk::Image* tmpImg = m_CurrentStatisticsCalculator->GetInternalImage();
             mitk::Image::ConstPointer imgToCluster = tmpImg;
             quant = clusterer->PerformQuantification(imgToCluster, m_CurrentPerformClusteringResults->clusteredImage);
 
             // clipboard
             QString clipboardText("%1\t%2");
             clipboardText = clipboardText.arg(quant[0]).arg(quant[1]);
             QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
 
             // now paint infos also on renderwindow
             QString plainInfoText("Measurement: %1 ± %2");
             plainInfoText = plainInfoText.arg(quant[0]).arg(quant[1]);
 
             this->SetMeasurementInfoToRenderWindow(plainInfoText);
         }
 
         clusteredImage = m_CurrentPerformClusteringResults->displayImage;
 
     }
 
     if(mask.IsNotNull())
     {
         typedef itk::Image<itk::RGBAPixel<unsigned char>,3> RGBImageType;
         typedef mitk::ImageToItk<RGBImageType> ClusterCasterType;
         ClusterCasterType::Pointer clCaster = ClusterCasterType::New();
         clCaster->SetInput(clusteredImage);
         clCaster->Update();
         clCaster->GetOutput();
 
         typedef itk::MaskImageFilter< RGBImageType, MaskImageType, RGBImageType > MaskType;
         MaskType::Pointer masker = MaskType::New();
         masker->SetInput1(clCaster->GetOutput());
         masker->SetInput2(itkmask);
         masker->Update();
 
         clusteredImage = mitk::Image::New();
         clusteredImage->InitializeByItk(masker->GetOutput());
         clusteredImage->SetVolume(masker->GetOutput()->GetBufferPointer());
     }
 
     if(m_ClusteringResult.IsNotNull())
     {
         this->GetDataStorage()->Remove(m_ClusteringResult);
     }
 
     m_ClusteringResult = mitk::DataNode::New();
     m_ClusteringResult->SetBoolProperty("helper object", true);
     m_ClusteringResult->SetIntProperty( "layer", 1000 );
     m_ClusteringResult->SetBoolProperty("texture interpolation", m_TexIsOn);
     m_ClusteringResult->SetData(clusteredImage);
     m_ClusteringResult->SetName("Clusterprobs");
     this->GetDataStorage()->Add(m_ClusteringResult, m_SelectedImageNodes->GetNode());
 
     if(m_SelectedPlanarFigure.IsNotNull() && m_SelectedPlanarFigureNodes->GetNode().IsNotNull())
     {
         m_SelectedPlanarFigureNodes->GetNode()->SetIntProperty( "layer", 1001 );
     }
 
     this->RequestRenderWindowUpdate();
 
 }
 
 
 void QmitkPartialVolumeAnalysisView::UpdateStatistics()
 {
     if(!m_CurrentFigureNodeInitialized && m_SelectedPlanarFigure.IsNotNull())
     {
         MITK_DEBUG << "Selected planar figure not initialized. No stats calculation performed.";
         return;
     }
 
     // Remove any cached images that are no longer referenced elsewhere
     this->RemoveOrphanImages();
 
 
     QmitkStdMultiWidget *multiWidget = 0;
     QmitkStdMultiWidgetEditor * multiWidgetEdit = 0;
 
     multiWidgetEdit = dynamic_cast<QmitkStdMultiWidgetEditor *>(this->GetRenderWindowPart());
     if(multiWidgetEdit){
         multiWidget = multiWidgetEdit->GetStdMultiWidget();
     }
 
     if ( multiWidget == NULL )
     {
         return;
     }
 
     if ( m_SelectedImage.IsNotNull() )
     {
         // Check if a the selected image is a multi-channel image. If yes, statistics
         // cannot be calculated currently.
         if ( !m_IsTensorImage && m_SelectedImage->GetPixelType().GetNumberOfComponents() > 1 )
         {
             QMessageBox::information( NULL, "Warning", "Non-tensor multi-component images not supported.");
 
             m_Controls->m_HistogramWidget->ClearItemModel();
             m_CurrentStatisticsValid = false;
             return;
         }
 
         m_CurrentStatisticsCalculator = NULL;
         if(!m_IsTensorImage)
         {
           // Retrieve HistogramStatisticsCalculator from has map (or create a new one
           // for this image if non-existant)
           PartialVolumeAnalysisMapType::iterator it =
               m_PartialVolumeAnalysisMap.find( m_SelectedImage );
 
           if ( it != m_PartialVolumeAnalysisMap.end() )
           {
             m_CurrentStatisticsCalculator = it->second;
           }
         }
         if(m_CurrentStatisticsCalculator.IsNull())
         {
             m_CurrentStatisticsCalculator = mitk::PartialVolumeAnalysisHistogramCalculator::New();
             m_CurrentStatisticsCalculator->SetPlanarFigureThickness(m_Controls->m_PlanarFiguresThickness->value());
             if(m_IsTensorImage)
             {
                 m_CurrentStatisticsCalculator->SetImage( m_CAImage );
                 m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_FAImage );
                 m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_DirectionComp1Image );
                 m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_DirectionComp2Image );
                 m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_RDImage );
                 m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_ADImage );
                 m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_MDImage );
             }
             else
             {
                 m_CurrentStatisticsCalculator->SetImage( m_SelectedImage );
             }
             m_PartialVolumeAnalysisMap[m_SelectedImage] = m_CurrentStatisticsCalculator;
             MITK_DEBUG << "Creating StatisticsCalculator";
         }
 
         std::string maskName;
         std::string maskType;
         unsigned int maskDimension;
 
         if ( m_SelectedImageMask.IsNotNull() )
         {
 
             mitk::PixelType pixelType = m_SelectedImageMask->GetPixelType();
             MITK_DEBUG << pixelType.GetPixelTypeAsString();
 
 
             if(pixelType.GetComponentTypeAsString() == "char")
             {
                 MITK_DEBUG << "Pixel type is char instead of uchar";
                 return;
             }
 
 
             if(pixelType.GetBitsPerComponent() == 16)
             {
                 //convert from short to uchar
                 typedef itk::Image<short, 3> ShortImageType;
                 typedef itk::Image<unsigned char, 3> CharImageType;
 
                 CharImageType::Pointer charImage;
                 ShortImageType::Pointer shortImage;
                 mitk::CastToItkImage(m_SelectedImageMask, shortImage);
 
                 typedef itk::CastImageFilter<ShortImageType, CharImageType> ImageCasterType;
 
                 ImageCasterType::Pointer caster = ImageCasterType::New();
                 caster->SetInput( shortImage );
                 caster->Update();
                 charImage = caster->GetOutput();
 
 
                 mitk::CastToMitkImage(charImage, m_SelectedImageMask);
             }
 
 
             m_CurrentStatisticsCalculator->SetImageMask( m_SelectedImageMask );
 
 
             m_CurrentStatisticsCalculator->SetMaskingModeToImage();
 
             maskName = m_SelectedMaskNode->GetName();
             maskType = m_SelectedImageMask->GetNameOfClass();
             maskDimension = 3;
 
             std::stringstream maskLabel;
             maskLabel << maskName;
             if ( maskDimension > 0 )
             {
                 maskLabel << "  [" << maskDimension << "D " << maskType << "]";
             }
             m_Controls->m_SelectedMaskLabel->setText( maskLabel.str().c_str() );
         }
         else if ( m_SelectedPlanarFigure.IsNotNull() && m_SelectedPlanarFigureNodes->GetNode().IsNotNull())
         {
             m_CurrentStatisticsCalculator->SetPlanarFigure( m_SelectedPlanarFigure );
             m_CurrentStatisticsCalculator->SetMaskingModeToPlanarFigure();
 
             maskName = m_SelectedPlanarFigureNodes->GetNode()->GetName();
             maskType = m_SelectedPlanarFigure->GetNameOfClass();
             maskDimension = 2;
         }
         else
         {
             m_CurrentStatisticsCalculator->SetMaskingModeToNone();
 
             maskName = "-";
             maskType = "";
             maskDimension = 0;
         }
 
         bool statisticsChanged = false;
         bool statisticsCalculationSuccessful = false;
 
         // Initialize progress bar
         mitk::ProgressBar::GetInstance()->AddStepsToDo( 100 );
 
         // Install listener for progress events and initialize progress bar
         typedef itk::SimpleMemberCommand< QmitkPartialVolumeAnalysisView > ITKCommandType;
         ITKCommandType::Pointer progressListener;
         progressListener = ITKCommandType::New();
         progressListener->SetCallbackFunction( this, &QmitkPartialVolumeAnalysisView::UpdateProgressBar );
         unsigned long progressObserverTag = m_CurrentStatisticsCalculator
                 ->AddObserver( itk::ProgressEvent(), progressListener );
 
         ClusteringType::ParamsType *cparams = 0;
         ClusteringType::ClusterResultType *cresult = 0;
         ClusteringType::HistType *chist = 0;
 
         try
         {
             m_CurrentStatisticsCalculator->SetNumberOfBins(m_Controls->m_NumberBins->text().toInt());
             m_CurrentStatisticsCalculator->SetUpsamplingFactor(m_Controls->m_Upsampling->text().toDouble());
             m_CurrentStatisticsCalculator->SetGaussianSigma(m_Controls->m_GaussianSigma->text().toDouble());
 
             // Compute statistics
             statisticsChanged =
                     m_CurrentStatisticsCalculator->ComputeStatistics( );
 
             mitk::Image* tmpImg = m_CurrentStatisticsCalculator->GetInternalImage();
             mitk::Image::ConstPointer imgToCluster = tmpImg;
             if(imgToCluster.IsNotNull())
             {
 
                 // perform clustering
                 const HistogramType *histogram = m_CurrentStatisticsCalculator->GetHistogram( );
 
                 if(histogram != NULL)
                 {
                     ClusteringType::Pointer clusterer = ClusteringType::New();
                     clusterer->SetStepsNumIntegration(200);
                     clusterer->SetMaxIt(1000);
 
                     mitk::Image::Pointer pFiberImg;
                     if(m_QuantifyClass==3)
                     {
                         if(m_Controls->m_Quantiles->isChecked())
                         {
                             m_CurrentRGBClusteringResults = clusterer->PerformRGBQuantiles(imgToCluster, histogram, m_Controls->m_q1->value(),m_Controls->m_q2->value());
                         }
                         else
                         {
                             m_CurrentRGBClusteringResults = clusterer->PerformRGBClustering(imgToCluster, histogram);
                         }
 
                         pFiberImg = m_CurrentRGBClusteringResults->rgbChannels->r;
                         cparams = m_CurrentRGBClusteringResults->params;
                         cresult = m_CurrentRGBClusteringResults->result;
                         chist = m_CurrentRGBClusteringResults->hist;
                     }
                     else
                     {
                         if(m_Controls->m_Quantiles->isChecked())
                         {
                             m_CurrentPerformClusteringResults =
                                     clusterer->PerformQuantiles(imgToCluster, histogram, m_Controls->m_q1->value(),m_Controls->m_q2->value());
                         }
                         else
                         {
                             m_CurrentPerformClusteringResults =
                                     clusterer->PerformClustering(imgToCluster, histogram, m_QuantifyClass);
                         }
 
                         pFiberImg = m_CurrentPerformClusteringResults->clusteredImage;
                         cparams = m_CurrentPerformClusteringResults->params;
                         cresult = m_CurrentPerformClusteringResults->result;
                         chist = m_CurrentPerformClusteringResults->hist;
                     }
 
                     if(m_IsTensorImage)
                     {
                         m_AngularErrorImage = clusterer->CaculateAngularErrorImage(
                                     m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(1),
                                     m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(2),
                                     pFiberImg);
 
                         //          GetDefaultDataStorage()->Remove(m_newnode2);
                         //          m_newnode2 = mitk::DataNode::New();
                         //          m_newnode2->SetData(m_AngularErrorImage);
                         //          m_newnode2->SetName(("AngularError"));
                         //          m_newnode2->SetIntProperty( "layer", 1003 );
                         //          GetDefaultDataStorage()->Add(m_newnode2, m_SelectedImageNodes->GetNode());
 
                         //          newnode = mitk::DataNode::New();
                         //          newnode->SetData(m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(1));
                         //          newnode->SetName(("Comp1"));
                         //          GetDefaultDataStorage()->Add(newnode, m_SelectedImageNodes->GetNode());
 
                         //          newnode = mitk::DataNode::New();
                         //          newnode->SetData(m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(2));
                         //          newnode->SetName(("Comp2"));
                         //          GetDefaultDataStorage()->Add(newnode, m_SelectedImageNodes->GetNode());
                     }
                     ShowClusteringResults();
                 }
 
             }
 
             statisticsCalculationSuccessful = true;
         }
         catch ( const std::runtime_error &e )
         {
             QMessageBox::information( NULL, "Warning", e.what());
         }
         catch ( const std::exception &e )
         {
             MITK_ERROR << "Caught exception: " << e.what();
 
             QMessageBox::information( NULL, "Warning", e.what());
         }
 
         m_CurrentStatisticsCalculator->RemoveObserver( progressObserverTag );
 
         // Make sure that progress bar closes
         mitk::ProgressBar::GetInstance()->Progress( 100 );
 
         if ( statisticsCalculationSuccessful )
         {
             if ( statisticsChanged )
             {
                 // Do not show any error messages
                 m_CurrentStatisticsValid = true;
             }
 
             //      m_Controls->m_HistogramWidget->SetHistogramModeToDirectHistogram();
             m_Controls->m_HistogramWidget->SetParameters(
                         cparams, cresult, chist );
             //      m_Controls->m_HistogramWidget->UpdateItemModelFromHistogram();
 
         }
         else
         {
             m_Controls->m_SelectedMaskLabel->setText("<font color='red'>mandatory</font>");
 
             // Clear statistics and histogram
             m_Controls->m_HistogramWidget->ClearItemModel();
             m_CurrentStatisticsValid = false;
 
 
             // If a (non-closed) PlanarFigure is selected, display a line profile widget
             if ( m_SelectedPlanarFigure.IsNotNull() )
             {
                 // TODO: enable line profile widget
                 //m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 1 );
                 //m_Controls->m_LineProfileWidget->SetImage( m_SelectedImage );
                 //m_Controls->m_LineProfileWidget->SetPlanarFigure( m_SelectedPlanarFigure );
                 //m_Controls->m_LineProfileWidget->UpdateItemModelFromPath();
             }
         }
     }
 
 }
 
 void QmitkPartialVolumeAnalysisView::SetMeasurementInfoToRenderWindow(const QString& text)
 {
 
     FindRenderWindow(m_SelectedPlanarFigureNodes->GetNode());
 
     if(m_LastRenderWindow != m_SelectedRenderWindow)
     {
 
         if(m_LastRenderWindow)
         {
             QObject::disconnect( m_LastRenderWindow, SIGNAL( destroyed(QObject*) )
                                  , this, SLOT( OnRenderWindowDelete(QObject*) ) );
         }
         m_LastRenderWindow = m_SelectedRenderWindow;
         if(m_LastRenderWindow)
         {
             QObject::connect( m_LastRenderWindow, SIGNAL( destroyed(QObject*) )
                               , this, SLOT( OnRenderWindowDelete(QObject*) ) );
         }
     }
 
     if(m_LastRenderWindow && m_SelectedPlanarFigureNodes->GetNode().IsNotNull())
     {
         if (!text.isEmpty())
         {
             m_MeasurementInfoAnnotation->SetText(1, text.toLatin1().data());
             mitk::VtkLayerController::GetInstance(m_LastRenderWindow->GetRenderWindow())->InsertForegroundRenderer(
                         m_MeasurementInfoRenderer, true);
         }
         else
         {
             if (mitk::VtkLayerController::GetInstance(
                         m_LastRenderWindow->GetRenderWindow()) ->IsRendererInserted(
                         m_MeasurementInfoRenderer))
                 mitk::VtkLayerController::GetInstance(m_LastRenderWindow->GetRenderWindow())->RemoveRenderer(
                             m_MeasurementInfoRenderer);
         }
     }
     else
     {
         QmitkStdMultiWidget *multiWidget = 0;
         QmitkStdMultiWidgetEditor * multiWidgetEdit = 0;
 
         multiWidgetEdit = dynamic_cast<QmitkStdMultiWidgetEditor *>(this->GetRenderWindowPart());
         if(multiWidgetEdit){
             multiWidget = multiWidgetEdit->GetStdMultiWidget();
         }
 
         if ( multiWidget == NULL )
         {
             return;
         }
 
         if (!text.isEmpty())
         {
             m_MeasurementInfoAnnotation->SetText(1, text.toLatin1().data());
             mitk::VtkLayerController::GetInstance(multiWidget->GetRenderWindow1()->GetRenderWindow())->InsertForegroundRenderer(
                         m_MeasurementInfoRenderer, true);
         }
         else
         {
             if (mitk::VtkLayerController::GetInstance(
                         multiWidget->GetRenderWindow1()->GetRenderWindow()) ->IsRendererInserted(
                         m_MeasurementInfoRenderer))
                 mitk::VtkLayerController::GetInstance(multiWidget->GetRenderWindow1()->GetRenderWindow())->RemoveRenderer(
                             m_MeasurementInfoRenderer);
         }
     }
 }
 
 void QmitkPartialVolumeAnalysisView::UpdateProgressBar()
 {
     mitk::ProgressBar::GetInstance()->Progress();
 }
 
 void QmitkPartialVolumeAnalysisView::RequestStatisticsUpdate()
 {
     if ( !m_StatisticsUpdatePending )
     {
         QApplication::postEvent( this, new QmitkRequestStatisticsUpdateEvent );
         m_StatisticsUpdatePending = true;
     }
 }
 
 
 void QmitkPartialVolumeAnalysisView::RemoveOrphanImages()
 {
     PartialVolumeAnalysisMapType::iterator it = m_PartialVolumeAnalysisMap.begin();
 
     while ( it != m_PartialVolumeAnalysisMap.end() )
     {
         mitk::Image *image = it->first;
         mitk::PartialVolumeAnalysisHistogramCalculator *calculator = it->second;
         ++it;
 
         mitk::NodePredicateData::Pointer hasImage = mitk::NodePredicateData::New( image );
         if ( this->GetDataStorage()->GetNode( hasImage ) == NULL )
         {
             if ( m_SelectedImage == image )
             {
                 m_SelectedImage = NULL;
                 m_SelectedImageNodes->RemoveAllNodes();
             }
             if ( m_CurrentStatisticsCalculator == calculator )
             {
                 m_CurrentStatisticsCalculator = NULL;
             }
             m_PartialVolumeAnalysisMap.erase( image );
             it = m_PartialVolumeAnalysisMap.begin();
         }
     }
 }
 
 void QmitkPartialVolumeAnalysisView::ExtractTensorImages(
         mitk::Image::Pointer tensorimage)
 {
     typedef itk::Image< itk::DiffusionTensor3D<float>, 3> TensorImageType;
 
     typedef mitk::ImageToItk<TensorImageType> CastType;
     CastType::Pointer caster = CastType::New();
     caster->SetInput(tensorimage);
     caster->Update();
     TensorImageType::Pointer image = caster->GetOutput();
 
     typedef itk::TensorDerivedMeasurementsFilter<float> MeasurementsType;
     MeasurementsType::Pointer measurementsCalculator = MeasurementsType::New();
     measurementsCalculator->SetInput(image );
     measurementsCalculator->SetMeasure(MeasurementsType::FA);
     measurementsCalculator->Update();
     MeasurementsType::OutputImageType::Pointer fa = measurementsCalculator->GetOutput();
 
     m_FAImage = mitk::Image::New();
     m_FAImage->InitializeByItk(fa.GetPointer());
     m_FAImage->SetVolume(fa->GetBufferPointer());
 
     //  mitk::DataNode::Pointer node = mitk::DataNode::New();
     //  node->SetData(m_FAImage);
     //  GetDefaultDataStorage()->Add(node);
 
     measurementsCalculator = MeasurementsType::New();
     measurementsCalculator->SetInput(image );
     measurementsCalculator->SetMeasure(MeasurementsType::CA);
     measurementsCalculator->Update();
     MeasurementsType::OutputImageType::Pointer ca = measurementsCalculator->GetOutput();
 
     m_CAImage = mitk::Image::New();
     m_CAImage->InitializeByItk(ca.GetPointer());
     m_CAImage->SetVolume(ca->GetBufferPointer());
 
     //  node = mitk::DataNode::New();
     //  node->SetData(m_CAImage);
     //  GetDefaultDataStorage()->Add(node);
 
     measurementsCalculator = MeasurementsType::New();
     measurementsCalculator->SetInput(image );
     measurementsCalculator->SetMeasure(MeasurementsType::RD);
     measurementsCalculator->Update();
     MeasurementsType::OutputImageType::Pointer rd = measurementsCalculator->GetOutput();
 
     m_RDImage = mitk::Image::New();
     m_RDImage->InitializeByItk(rd.GetPointer());
     m_RDImage->SetVolume(rd->GetBufferPointer());
 
     //  node = mitk::DataNode::New();
     //  node->SetData(m_CAImage);
     //  GetDefaultDataStorage()->Add(node);
 
     measurementsCalculator = MeasurementsType::New();
     measurementsCalculator->SetInput(image );
     measurementsCalculator->SetMeasure(MeasurementsType::AD);
     measurementsCalculator->Update();
     MeasurementsType::OutputImageType::Pointer ad = measurementsCalculator->GetOutput();
 
     m_ADImage = mitk::Image::New();
     m_ADImage->InitializeByItk(ad.GetPointer());
     m_ADImage->SetVolume(ad->GetBufferPointer());
 
     //  node = mitk::DataNode::New();
     //  node->SetData(m_CAImage);
     //  GetDefaultDataStorage()->Add(node);
 
     measurementsCalculator = MeasurementsType::New();
     measurementsCalculator->SetInput(image );
     measurementsCalculator->SetMeasure(MeasurementsType::RA);
     measurementsCalculator->Update();
     MeasurementsType::OutputImageType::Pointer md = measurementsCalculator->GetOutput();
 
     m_MDImage = mitk::Image::New();
     m_MDImage->InitializeByItk(md.GetPointer());
     m_MDImage->SetVolume(md->GetBufferPointer());
 
     //  node = mitk::DataNode::New();
     //  node->SetData(m_CAImage);
     //  GetDefaultDataStorage()->Add(node);
 
     typedef DirectionsFilterType::OutputImageType DirImageType;
     DirectionsFilterType::Pointer dirFilter = DirectionsFilterType::New();
     dirFilter->SetInput(image );
     dirFilter->Update();
 
     itk::ImageRegionIterator<DirImageType>
             itd(dirFilter->GetOutput(), dirFilter->GetOutput()->GetLargestPossibleRegion());
     itd = itd.Begin();
     while( !itd.IsAtEnd() )
     {
         DirImageType::PixelType direction = itd.Get();
         direction[0] = fabs(direction[0]);
         direction[1] = fabs(direction[1]);
         direction[2] = fabs(direction[2]);
         itd.Set(direction);
         ++itd;
     }
 
     typedef itk::CartesianToPolarVectorImageFilter<
             DirImageType, DirImageType, true> C2PFilterType;
     C2PFilterType::Pointer cpFilter = C2PFilterType::New();
     cpFilter->SetInput(dirFilter->GetOutput());
     cpFilter->Update();
     DirImageType::Pointer dir = cpFilter->GetOutput();
 
     typedef itk::Image<float, 3> CompImageType;
     CompImageType::Pointer comp1 = CompImageType::New();
     comp1->SetSpacing( dir->GetSpacing() );   // Set the image spacing
     comp1->SetOrigin( dir->GetOrigin() );     // Set the image origin
     comp1->SetDirection( dir->GetDirection() );  // Set the image direction
     comp1->SetRegions( dir->GetLargestPossibleRegion() );
     comp1->Allocate();
 
     CompImageType::Pointer comp2 = CompImageType::New();
     comp2->SetSpacing( dir->GetSpacing() );   // Set the image spacing
     comp2->SetOrigin( dir->GetOrigin() );     // Set the image origin
     comp2->SetDirection( dir->GetDirection() );  // Set the image direction
     comp2->SetRegions( dir->GetLargestPossibleRegion() );
     comp2->Allocate();
 
     itk::ImageRegionConstIterator<DirImageType>
             it(dir, dir->GetLargestPossibleRegion());
 
     itk::ImageRegionIterator<CompImageType>
             it1(comp1, comp1->GetLargestPossibleRegion());
 
     itk::ImageRegionIterator<CompImageType>
             it2(comp2, comp2->GetLargestPossibleRegion());
 
     it = it.Begin();
     it1 = it1.Begin();
     it2 = it2.Begin();
 
     while( !it.IsAtEnd() )
     {
         it1.Set(it.Get()[1]);
         it2.Set(it.Get()[2]);
         ++it;
         ++it1;
         ++it2;
     }
 
     m_DirectionComp1Image = mitk::Image::New();
     m_DirectionComp1Image->InitializeByItk(comp1.GetPointer());
     m_DirectionComp1Image->SetVolume(comp1->GetBufferPointer());
 
     m_DirectionComp2Image = mitk::Image::New();
     m_DirectionComp2Image->InitializeByItk(comp2.GetPointer());
     m_DirectionComp2Image->SetVolume(comp2->GetBufferPointer());
 
 }
 
 void QmitkPartialVolumeAnalysisView::OnRenderWindowDelete(QObject * obj)
 {
     if(obj == m_LastRenderWindow)
         m_LastRenderWindow = 0;
     if(obj == m_SelectedRenderWindow)
         m_SelectedRenderWindow = 0;
 }
 
 bool QmitkPartialVolumeAnalysisView::event( QEvent *event )
 {
     if ( event->type() == (QEvent::Type) QmitkRequestStatisticsUpdateEvent::StatisticsUpdateRequest )
     {
         // Update statistics
 
         m_StatisticsUpdatePending = false;
 
         this->UpdateStatistics();
         return true;
     }
 
     return false;
 }
 
 
 bool QmitkPartialVolumeAnalysisView::IsExclusiveFunctionality() const
 {
     return true;
 }
 
 void QmitkPartialVolumeAnalysisView::Activated()
 {
     mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = this->GetDataStorage()->GetAll();
     mitk::DataNode* node = 0;
     mitk::PlanarFigure* figure = 0;
     mitk::PlanarFigureInteractor::Pointer figureInteractor = 0;
 
     // finally add all nodes to the model
     for(mitk::DataStorage::SetOfObjects::ConstIterator it=_NodeSet->Begin(); it!=_NodeSet->End()
         ; it++)
     {
         node = const_cast<mitk::DataNode*>(it->Value().GetPointer());
         figure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
 
         if(figure)
         {
           figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer());
 
           if(figureInteractor.IsNull())
           {
             figureInteractor = mitk::PlanarFigureInteractor::New();
             us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "MitkPlanarFigure" );
             figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
             figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
             figureInteractor->SetDataNode( node );
           }
         }
     }
 }
 
 void QmitkPartialVolumeAnalysisView::Deactivated()
 {
 
 }
 
 void QmitkPartialVolumeAnalysisView::ActivatedZombieView(berry::IWorkbenchPartReference::Pointer reference)
 {
     this->SetMeasurementInfoToRenderWindow("");
 
     mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = this->GetDataStorage()->GetAll();
     mitk::DataNode* node = 0;
     mitk::PlanarFigure* figure = 0;
     mitk::PlanarFigureInteractor::Pointer figureInteractor = 0;
 
     // finally add all nodes to the model
     for(mitk::DataStorage::SetOfObjects::ConstIterator it=_NodeSet->Begin(); it!=_NodeSet->End()
         ; it++)
     {
         node = const_cast<mitk::DataNode*>(it->Value().GetPointer());
         figure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
 
         if(figure)
         {
             figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer());
 
             if(figureInteractor)
               figureInteractor->SetDataNode( NULL );
         }
     }
 }
 
 void QmitkPartialVolumeAnalysisView::Hidden()
 {
     if (m_ClusteringResult.IsNotNull())
     {
         this->GetDataStorage()->Remove(m_ClusteringResult);
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
     Select(NULL, true, true);
     m_Visible = false;
 }
 
 void QmitkPartialVolumeAnalysisView::Visible()
 {
     m_Visible = true;
     berry::IWorkbenchPart::Pointer bla;
     if (!this->GetCurrentSelection().empty())
     {
         this->OnSelectionChanged(bla, this->GetCurrentSelection());
     }
     else
     {
         this->OnSelectionChanged(bla, this->GetDataManagerSelection());
     }
 }
 
 void QmitkPartialVolumeAnalysisView::SetFocus()
 {
 
 }
 
 
 void QmitkPartialVolumeAnalysisView::GreenRadio(bool checked)
 {
     if(checked)
     {
         m_Controls->m_PartialVolumeRadio->setChecked(false);
         m_Controls->m_BlueRadio->setChecked(false);
         m_Controls->m_AllRadio->setChecked(false);
         m_Controls->m_ExportClusteringResultsButton->setEnabled(true);
     }
 
     m_QuantifyClass = 0;
 
     RequestStatisticsUpdate();
 }
 
 
 void QmitkPartialVolumeAnalysisView::PartialVolumeRadio(bool checked)
 {
     if(checked)
     {
         m_Controls->m_GreenRadio->setChecked(false);
         m_Controls->m_BlueRadio->setChecked(false);
         m_Controls->m_AllRadio->setChecked(false);
         m_Controls->m_ExportClusteringResultsButton->setEnabled(true);
     }
 
     m_QuantifyClass = 1;
 
     RequestStatisticsUpdate();
 }
 
 void QmitkPartialVolumeAnalysisView::BlueRadio(bool checked)
 {
     if(checked)
     {
         m_Controls->m_PartialVolumeRadio->setChecked(false);
         m_Controls->m_GreenRadio->setChecked(false);
         m_Controls->m_AllRadio->setChecked(false);
         m_Controls->m_ExportClusteringResultsButton->setEnabled(true);
     }
 
     m_QuantifyClass = 2;
 
     RequestStatisticsUpdate();
 }
 
 void QmitkPartialVolumeAnalysisView::AllRadio(bool checked)
 {
     if(checked)
     {
         m_Controls->m_BlueRadio->setChecked(false);
         m_Controls->m_PartialVolumeRadio->setChecked(false);
         m_Controls->m_GreenRadio->setChecked(false);
         m_Controls->m_ExportClusteringResultsButton->setEnabled(false);
     }
 
     m_QuantifyClass = 3;
 
     RequestStatisticsUpdate();
 }
 
 void QmitkPartialVolumeAnalysisView::NumberBinsChangedSlider(int v )
 {
     m_Controls->m_NumberBins->setText(QString("%1").arg(m_Controls->m_NumberBinsSlider->value()*5.0));
 }
 
 void QmitkPartialVolumeAnalysisView::UpsamplingChangedSlider( int v)
 {
     m_Controls->m_Upsampling->setText(QString("%1").arg(m_Controls->m_UpsamplingSlider->value()/10.0));
 }
 
 void QmitkPartialVolumeAnalysisView::GaussianSigmaChangedSlider(int v )
 {
     m_Controls->m_GaussianSigma->setText(QString("%1").arg(m_Controls->m_GaussianSigmaSlider->value()/100.0));
 }
 
 void QmitkPartialVolumeAnalysisView::SimilarAnglesChangedSlider(int v )
 {
     m_Controls->m_SimilarAngles->setText(QString("%1°").arg(90-m_Controls->m_SimilarAnglesSlider->value()));
     ShowClusteringResults();
 }
 
 void QmitkPartialVolumeAnalysisView::OpacityChangedSlider(int v )
 {
 
     if(m_SelectedImageNodes->GetNode().IsNotNull())
     {
         float opacImag = 1.0f-(v-5)/5.0f;
         opacImag = opacImag < 0 ? 0 : opacImag;
         m_SelectedImageNodes->GetNode()->SetFloatProperty("opacity", opacImag);
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 
     if(m_ClusteringResult.IsNotNull())
     {
         float opacClust = v/5.0f;
         opacClust = opacClust > 1 ? 1 : opacClust;
         m_ClusteringResult->SetFloatProperty("opacity", opacClust);
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 }
 
 void QmitkPartialVolumeAnalysisView::NumberBinsReleasedSlider( )
 {
     RequestStatisticsUpdate();
 }
 
 void QmitkPartialVolumeAnalysisView::UpsamplingReleasedSlider( )
 {
     RequestStatisticsUpdate();
 }
 
 void QmitkPartialVolumeAnalysisView::GaussianSigmaReleasedSlider( )
 {
     RequestStatisticsUpdate();
 }
 
 void QmitkPartialVolumeAnalysisView::SimilarAnglesReleasedSlider( )
 {
 
 }
 
 void QmitkPartialVolumeAnalysisView::ToClipBoard()
 {
 
     std::vector<std::vector<double>* > vals  = m_Controls->m_HistogramWidget->m_Vals;
     QString clipboardText;
     for (std::vector<std::vector<double>* >::iterator it = vals.begin(); it
          != vals.end(); ++it)
     {
         for (std::vector<double>::iterator it2 = (**it).begin(); it2 != (**it).end(); ++it2)
         {
             clipboardText.append(QString("%1 \t").arg(*it2));
         }
         clipboardText.append(QString("\n"));
     }
 
     QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
 }
 
 void QmitkPartialVolumeAnalysisView::PropertyChanged(const mitk::DataNode* /*node*/, const mitk::BaseProperty* /*prop*/)
 {
 }
 
 void QmitkPartialVolumeAnalysisView::NodeChanged(const mitk::DataNode* /*node*/)
 {
 }
 
 void QmitkPartialVolumeAnalysisView::NodeRemoved(const mitk::DataNode* node)
 {
     if (dynamic_cast<mitk::PlanarFigure*>(node->GetData()))
         this->GetDataStorage()->Remove(m_ClusteringResult);
 
     if(  node == m_SelectedPlanarFigureNodes->GetNode().GetPointer()
          || node == m_SelectedMaskNode.GetPointer() )
     {
         this->Select(NULL,true,false);
         SetMeasurementInfoToRenderWindow("");
     }
 
     if(  node == m_SelectedImageNodes->GetNode().GetPointer() )
     {
         this->Select(NULL,false,true);
         SetMeasurementInfoToRenderWindow("");
     }
 }
 
 void QmitkPartialVolumeAnalysisView::NodeAddedInDataStorage(const mitk::DataNode* node)
 {
     if(!m_Visible)
         return;
 
     mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>(node);
     mitk::PlanarFigure* figure = dynamic_cast<mitk::PlanarFigure*>(nonConstNode->GetData());
 
     if(figure)
     {
 
         // set interactor for new node (if not already set)
         mitk::PlanarFigureInteractor::Pointer figureInteractor
                 = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer());
 
         if(figureInteractor.IsNull())
         {
           figureInteractor = mitk::PlanarFigureInteractor::New();
           us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "MitkPlanarFigure" );
           figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
           figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
           figureInteractor->SetDataNode( nonConstNode );
         }
 
         // remove uninitialized old planars
         if( m_SelectedPlanarFigureNodes->GetNode().IsNotNull() && m_CurrentFigureNodeInitialized == false )
         {
             mitk::Interactor::Pointer oldInteractor = m_SelectedPlanarFigureNodes->GetNode()->GetInteractor();
             if(oldInteractor.IsNotNull())
                 mitk::GlobalInteraction::GetInstance()->RemoveInteractor(oldInteractor);
 
             this->GetDataStorage()->Remove(m_SelectedPlanarFigureNodes->GetNode());
         }
 
     }
 }
 
 void QmitkPartialVolumeAnalysisView::TextIntON()
 {
     if(m_ClusteringResult.IsNotNull())
     {
         if(m_TexIsOn)
         {
             m_Controls->m_TextureIntON->setIcon(*m_IconTexOFF);
         }
         else
         {
             m_Controls->m_TextureIntON->setIcon(*m_IconTexON);
         }
 
         m_ClusteringResult->SetBoolProperty("texture interpolation", !m_TexIsOn);
         m_TexIsOn = !m_TexIsOn;
         this->RequestRenderWindowUpdate();
     }
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.cpp
index f088491113..c4142c284c 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.cpp
@@ -1,1781 +1,1892 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 //#define MBILOG_ENABLE_DEBUG
 
 #include "QmitkPreprocessingView.h"
 #include "mitkDiffusionImagingConfigure.h"
 
 // qt includes
 #include <QMessageBox>
 
 // itk includes
 #include "itkTimeProbe.h"
 #include "itkB0ImageExtractionImageFilter.h"
 #include "itkB0ImageExtractionToSeparateImageFilter.h"
 #include "itkBrainMaskExtractionImageFilter.h"
 #include "itkCastImageFilter.h"
 #include "itkVectorContainer.h"
 #include <itkElectrostaticRepulsionDiffusionGradientReductionFilter.h>
 #include <itkMergeDiffusionImagesFilter.h>
 #include <itkDwiGradientLengthCorrectionFilter.h>
 #include <itkDwiNormilzationFilter.h>
 
 // Multishell includes
 #include <itkRadialMultishellToSingleshellImageFilter.h>
 
 // Multishell Functors
 #include <itkADCAverageFunctor.h>
 #include <itkKurtosisFitFunctor.h>
 #include <itkBiExpFitFunctor.h>
 #include <itkADCFitFunctor.h>
 
 // mitk includes
 #include "QmitkDataStorageComboBox.h"
 #include "QmitkStdMultiWidget.h"
 #include "mitkProgressBar.h"
 #include "mitkStatusBar.h"
 #include "mitkNodePredicateDataType.h"
 #include "mitkProperties.h"
 #include "mitkVtkResliceInterpolationProperty.h"
 #include "mitkLookupTable.h"
 #include "mitkLookupTableProperty.h"
 #include "mitkTransferFunction.h"
 #include "mitkTransferFunctionProperty.h"
 #include "mitkDataNodeObject.h"
 #include "mitkOdfNormalizationMethodProperty.h"
 #include "mitkOdfScaleByProperty.h"
 #include <mitkPointSet.h>
 #include <itkAdcImageFilter.h>
 #include <itkBrainMaskExtractionImageFilter.h>
 #include <mitkImageCast.h>
 #include <mitkRotationOperation.h>
 #include <QTableWidgetItem>
 #include <QTableWidget>
 #include <mitkInteractionConst.h>
 #include <mitkImageAccessByItk.h>
 #include <itkResampleDwiImageFilter.h>
 #include <itkResampleImageFilter.h>
 #include <itkImageDuplicator.h>
 #include <itkMaskImageFilter.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateOr.h>
 #include <itkCropImageFilter.h>
 #include <itkDiffusionTensor3DReconstructionImageFilter.h>
 #include <itkRemoveDwiChannelFilter.h>
 #include <itkExtractDwiChannelFilter.h>
+#include <mitkITKImageImport.h>
+#include <mitkBValueMapProperty.h>
+#include <mitkGradientDirectionsProperty.h>
+#include <mitkMeasurementFrameProperty.h>
 
 const std::string QmitkPreprocessingView::VIEW_ID =
-        "org.mitk.views.preprocessing";
+    "org.mitk.views.preprocessing";
 
 #define DI_INFO MITK_INFO("DiffusionImaging")
 
 
 typedef float TTensorPixelType;
 
 
 QmitkPreprocessingView::QmitkPreprocessingView()
-    : QmitkFunctionality(),
-      m_Controls(NULL),
-      m_MultiWidget(NULL),
-      m_DiffusionImage(NULL)
+  : QmitkFunctionality(),
+    m_Controls(NULL),
+    m_MultiWidget(NULL)
 {
 }
 
 QmitkPreprocessingView::~QmitkPreprocessingView()
 {
 
 }
 
 void QmitkPreprocessingView::CreateQtPartControl(QWidget *parent)
 {
-    if (!m_Controls)
-    {
-        // create GUI widgets
-        m_Controls = new Ui::QmitkPreprocessingViewControls;
-        m_Controls->setupUi(parent);
-        this->CreateConnections();
+  if (!m_Controls)
+  {
+    // create GUI widgets
+    m_Controls = new Ui::QmitkPreprocessingViewControls;
+    m_Controls->setupUi(parent);
+    this->CreateConnections();
 
 #if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
-        m_Controls->m_MeasurementFrameTable->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
-        m_Controls->m_MeasurementFrameTable->verticalHeader()->setResizeMode(QHeaderView::Stretch);
-        m_Controls->m_DirectionMatrixTable->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
-        m_Controls->m_DirectionMatrixTable->verticalHeader()->setResizeMode(QHeaderView::Stretch);
+    m_Controls->m_MeasurementFrameTable->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
+    m_Controls->m_MeasurementFrameTable->verticalHeader()->setResizeMode(QHeaderView::Stretch);
+    m_Controls->m_DirectionMatrixTable->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
+    m_Controls->m_DirectionMatrixTable->verticalHeader()->setResizeMode(QHeaderView::Stretch);
 #else
-        m_Controls->m_MeasurementFrameTable->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
-        m_Controls->m_MeasurementFrameTable->verticalHeader()->setSectionResizeMode(QHeaderView::Stretch);
-        m_Controls->m_DirectionMatrixTable->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
-        m_Controls->m_DirectionMatrixTable->verticalHeader()->setSectionResizeMode(QHeaderView::Stretch);
+    m_Controls->m_MeasurementFrameTable->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
+    m_Controls->m_MeasurementFrameTable->verticalHeader()->setSectionResizeMode(QHeaderView::Stretch);
+    m_Controls->m_DirectionMatrixTable->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
+    m_Controls->m_DirectionMatrixTable->verticalHeader()->setSectionResizeMode(QHeaderView::Stretch);
 #endif
-    }
+  }
 }
 
 void QmitkPreprocessingView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
-    m_MultiWidget = &stdMultiWidget;
+  m_MultiWidget = &stdMultiWidget;
 }
 
 void QmitkPreprocessingView::StdMultiWidgetNotAvailable()
 {
-    m_MultiWidget = NULL;
+  m_MultiWidget = NULL;
 }
 
 void QmitkPreprocessingView::CreateConnections()
 {
-    if ( m_Controls )
-    {
-        m_Controls->m_NormalizationMaskBox->SetDataStorage(this->GetDataStorage());
-        mitk::TNodePredicateDataType<mitk::Image>::Pointer isMitkImage = mitk::TNodePredicateDataType<mitk::Image>::New();
-        mitk::NodePredicateDataType::Pointer isDwi = mitk::NodePredicateDataType::New("DiffusionImage");
-        mitk::NodePredicateDataType::Pointer isDti = mitk::NodePredicateDataType::New("TensorImage");
-        mitk::NodePredicateDataType::Pointer isQbi = mitk::NodePredicateDataType::New("QBallImage");
-        mitk::NodePredicateOr::Pointer isDiffusionImage = mitk::NodePredicateOr::New(isDwi, isDti);
-        isDiffusionImage = mitk::NodePredicateOr::New(isDiffusionImage, isQbi);
-        mitk::NodePredicateNot::Pointer noDiffusionImage = mitk::NodePredicateNot::New(isDiffusionImage);
-        mitk::NodePredicateAnd::Pointer finalPredicate = mitk::NodePredicateAnd::New(isMitkImage, noDiffusionImage);
-        mitk::NodePredicateProperty::Pointer isBinaryPredicate = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
-        finalPredicate = mitk::NodePredicateAnd::New(finalPredicate, isBinaryPredicate);
-        m_Controls->m_NormalizationMaskBox->SetPredicate(finalPredicate);
-
-        m_Controls->m_ExtractBrainMask->setVisible(false);
-        m_Controls->m_BrainMaskIterationsBox->setVisible(false);
-        m_Controls->m_ResampleIntFrame->setVisible(false);
-        connect( (QObject*)(m_Controls->m_ButtonAverageGradients), SIGNAL(clicked()), this, SLOT(AverageGradients()) );
-        connect( (QObject*)(m_Controls->m_ButtonExtractB0), SIGNAL(clicked()), this, SLOT(ExtractB0()) );
-        connect( (QObject*)(m_Controls->m_ModifyMeasurementFrame), SIGNAL(clicked()), this, SLOT(DoApplyMesurementFrame()) );
-        connect( (QObject*)(m_Controls->m_ReduceGradientsButton), SIGNAL(clicked()), this, SLOT(DoReduceGradientDirections()) );
-        connect( (QObject*)(m_Controls->m_ShowGradientsButton), SIGNAL(clicked()), this, SLOT(DoShowGradientDirections()) );
-        connect( (QObject*)(m_Controls->m_MirrorGradientToHalfSphereButton), SIGNAL(clicked()), this, SLOT(DoHalfSphereGradientDirections()) );
-        connect( (QObject*)(m_Controls->m_MergeDwisButton), SIGNAL(clicked()), this, SLOT(MergeDwis()) );
-        connect( (QObject*)(m_Controls->m_ProjectSignalButton), SIGNAL(clicked()), this, SLOT(DoProjectSignal()) );
-        connect( (QObject*)(m_Controls->m_B_ValueMap_Rounder_SpinBox), SIGNAL(valueChanged(int)), this, SLOT(UpdateDwiBValueMapRounder(int)));
-        connect( (QObject*)(m_Controls->m_CreateLengthCorrectedDwi), SIGNAL(clicked()), this, SLOT(DoLengthCorrection()) );
-        connect( (QObject*)(m_Controls->m_CalcAdcButton), SIGNAL(clicked()), this, SLOT(DoAdcCalculation()) );
-        connect( (QObject*)(m_Controls->m_NormalizeImageValuesButton), SIGNAL(clicked()), this, SLOT(DoDwiNormalization()) );
-        connect( (QObject*)(m_Controls->m_ModifyDirection), SIGNAL(clicked()), this, SLOT(DoApplyDirectionMatrix()) );
-        connect( (QObject*)(m_Controls->m_ModifySpacingButton), SIGNAL(clicked()), this, SLOT(DoApplySpacing()) );
-        connect( (QObject*)(m_Controls->m_ModifyOriginButton), SIGNAL(clicked()), this, SLOT(DoApplyOrigin()) );
-        connect( (QObject*)(m_Controls->m_ResampleImageButton), SIGNAL(clicked()), this, SLOT(DoResampleImage()) );
-        connect( (QObject*)(m_Controls->m_ResampleTypeBox), SIGNAL(currentIndexChanged(int)), this, SLOT(DoUpdateInterpolationGui(int)) );
-        connect( (QObject*)(m_Controls->m_CropImageButton), SIGNAL(clicked()), this, SLOT(DoCropImage()) );
-        connect( (QObject*)(m_Controls->m_RemoveGradientButton), SIGNAL(clicked()), this, SLOT(DoRemoveGradient()) );
-        connect( (QObject*)(m_Controls->m_ExtractGradientButton), SIGNAL(clicked()), this, SLOT(DoExtractGradient()) );
-
-
-        //        connect( (QObject*)(m_Controls->m_ExtractBrainMask), SIGNAL(clicked()), this, SLOT(DoExtractBrainMask()) );
-    }
+  if ( m_Controls )
+  {
+    m_Controls->m_NormalizationMaskBox->SetDataStorage(this->GetDataStorage());
+    mitk::TNodePredicateDataType<mitk::Image>::Pointer isMitkImage = mitk::TNodePredicateDataType<mitk::Image>::New();
+    mitk::NodePredicateDataType::Pointer isDwi = mitk::NodePredicateDataType::New("DiffusionImage");
+    mitk::NodePredicateDataType::Pointer isDti = mitk::NodePredicateDataType::New("TensorImage");
+    mitk::NodePredicateDataType::Pointer isQbi = mitk::NodePredicateDataType::New("QBallImage");
+    mitk::NodePredicateOr::Pointer isDiffusionImage = mitk::NodePredicateOr::New(isDwi, isDti);
+    isDiffusionImage = mitk::NodePredicateOr::New(isDiffusionImage, isQbi);
+    mitk::NodePredicateNot::Pointer noDiffusionImage = mitk::NodePredicateNot::New(isDiffusionImage);
+    mitk::NodePredicateAnd::Pointer finalPredicate = mitk::NodePredicateAnd::New(isMitkImage, noDiffusionImage);
+    mitk::NodePredicateProperty::Pointer isBinaryPredicate = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
+    finalPredicate = mitk::NodePredicateAnd::New(finalPredicate, isBinaryPredicate);
+    m_Controls->m_NormalizationMaskBox->SetPredicate(finalPredicate);
+
+    m_Controls->m_ExtractBrainMask->setVisible(false);
+    m_Controls->m_BrainMaskIterationsBox->setVisible(false);
+    m_Controls->m_ResampleIntFrame->setVisible(false);
+    connect( (QObject*)(m_Controls->m_ButtonAverageGradients), SIGNAL(clicked()), this, SLOT(AverageGradients()) );
+    connect( (QObject*)(m_Controls->m_ButtonExtractB0), SIGNAL(clicked()), this, SLOT(ExtractB0()) );
+    connect( (QObject*)(m_Controls->m_ModifyMeasurementFrame), SIGNAL(clicked()), this, SLOT(DoApplyMesurementFrame()) );
+    connect( (QObject*)(m_Controls->m_ReduceGradientsButton), SIGNAL(clicked()), this, SLOT(DoReduceGradientDirections()) );
+    connect( (QObject*)(m_Controls->m_ShowGradientsButton), SIGNAL(clicked()), this, SLOT(DoShowGradientDirections()) );
+    connect( (QObject*)(m_Controls->m_MirrorGradientToHalfSphereButton), SIGNAL(clicked()), this, SLOT(DoHalfSphereGradientDirections()) );
+    connect( (QObject*)(m_Controls->m_MergeDwisButton), SIGNAL(clicked()), this, SLOT(MergeDwis()) );
+    connect( (QObject*)(m_Controls->m_ProjectSignalButton), SIGNAL(clicked()), this, SLOT(DoProjectSignal()) );
+    connect( (QObject*)(m_Controls->m_B_ValueMap_Rounder_SpinBox), SIGNAL(valueChanged(int)), this, SLOT(UpdateDwiBValueMapRounder(int)));
+    connect( (QObject*)(m_Controls->m_CreateLengthCorrectedDwi), SIGNAL(clicked()), this, SLOT(DoLengthCorrection()) );
+    connect( (QObject*)(m_Controls->m_CalcAdcButton), SIGNAL(clicked()), this, SLOT(DoAdcCalculation()) );
+    connect( (QObject*)(m_Controls->m_NormalizeImageValuesButton), SIGNAL(clicked()), this, SLOT(DoDwiNormalization()) );
+    connect( (QObject*)(m_Controls->m_ModifyDirection), SIGNAL(clicked()), this, SLOT(DoApplyDirectionMatrix()) );
+    connect( (QObject*)(m_Controls->m_ModifySpacingButton), SIGNAL(clicked()), this, SLOT(DoApplySpacing()) );
+    connect( (QObject*)(m_Controls->m_ModifyOriginButton), SIGNAL(clicked()), this, SLOT(DoApplyOrigin()) );
+    connect( (QObject*)(m_Controls->m_ResampleImageButton), SIGNAL(clicked()), this, SLOT(DoResampleImage()) );
+    connect( (QObject*)(m_Controls->m_ResampleTypeBox), SIGNAL(currentIndexChanged(int)), this, SLOT(DoUpdateInterpolationGui(int)) );
+    connect( (QObject*)(m_Controls->m_CropImageButton), SIGNAL(clicked()), this, SLOT(DoCropImage()) );
+    connect( (QObject*)(m_Controls->m_RemoveGradientButton), SIGNAL(clicked()), this, SLOT(DoRemoveGradient()) );
+    connect( (QObject*)(m_Controls->m_ExtractGradientButton), SIGNAL(clicked()), this, SLOT(DoExtractGradient()) );
+
+
+    //        connect( (QObject*)(m_Controls->m_ExtractBrainMask), SIGNAL(clicked()), this, SLOT(DoExtractBrainMask()) );
+  }
 }
 
 void QmitkPreprocessingView::DoRemoveGradient()
 {
-    if (m_DiffusionImage.IsNull())
-        return;
-
-    std::vector< unsigned int > channelsToRemove; channelsToRemove.push_back(m_Controls->m_RemoveGradientBox->value());
-    itk::RemoveDwiChannelFilter< short >::Pointer filter = itk::RemoveDwiChannelFilter< short >::New();
-    filter->SetInput(m_DiffusionImage->GetVectorImage());
-    filter->SetChannelIndices(channelsToRemove);
-    filter->SetDirections(m_DiffusionImage->GetDirections());
-    filter->Update();
-
-    MitkDwiType::Pointer image = MitkDwiType::New();
-    image->SetVectorImage( filter->GetOutput() );
-    image->SetReferenceBValue( m_DiffusionImage->GetReferenceBValue() );
-    image->SetDirections( filter->GetNewDirections() );
-    image->InitializeFromVectorImage();
-
-    mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
-    imageNode->SetData( image );
-    QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
-    imageNode->SetName((name+"_removedgradients").toStdString().c_str());
-    GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
-    mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
-    mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+  bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_SelectedImageNode->GetData())) );
+  if ( !isDiffusionImage )
+  {
+    return;
+  }
+
+  std::vector< unsigned int > channelsToRemove; channelsToRemove.push_back(m_Controls->m_RemoveGradientBox->value());
+
+  ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+  mitk::CastToItkImage(m_SelectedImage, itkVectorImagePointer);
+
+  itk::RemoveDwiChannelFilter< short >::Pointer filter = itk::RemoveDwiChannelFilter< short >::New();
+  filter->SetInput(itkVectorImagePointer);
+  filter->SetChannelIndices(channelsToRemove);
+  filter->SetDirections( static_cast<mitk::GradientDirectionsProperty*>( m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() );
+  filter->Update();
+
+  mitk::Image::Pointer image = mitk::GrabItkImageMemory( filter->GetOutput() );
+  image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( filter->GetNewDirections() ) );
+  image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() ) );
+  image->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( static_cast<mitk::MeasurementFrameProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )->GetMeasurementFrame() ) );
+  mitk::DiffusionPropertyHelper propertyHelper( image );
+  propertyHelper.InitializeImage();
+
+  mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+  imageNode->SetData( image );
+  QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
+
+  imageNode->SetName((name+"_removedgradients").toStdString().c_str());
+  GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
+
+  mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+  mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkPreprocessingView::DoExtractGradient()
 {
-    if (m_DiffusionImage.IsNull())
-        return;
-
-    unsigned int channel = m_Controls->m_ExtractGradientBox->value();
-    itk::ExtractDwiChannelFilter< short >::Pointer filter = itk::ExtractDwiChannelFilter< short >::New();
-    filter->SetInput(m_DiffusionImage->GetVectorImage());
-    filter->SetChannelIndex(channel);
-    filter->Update();
-
-    mitk::Image::Pointer mitkImage = mitk::Image::New();
-    mitkImage->InitializeByItk( filter->GetOutput() );
-    mitkImage->SetImportChannel( filter->GetOutput()->GetBufferPointer() );
-
-    mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
-    imageNode->SetData( mitkImage );
-    QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
-    imageNode->SetName((name+"_direction-"+QString::number(channel)).toStdString().c_str());
-    GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
-
-    mitk::RenderingManager::GetInstance()->InitializeViews(imageNode->GetData()->GetTimeGeometry(),mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
+  bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_SelectedImageNode->GetData())) );
+  if ( !isDiffusionImage )
+  {
+    return;
+  }
+
+  ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+  mitk::CastToItkImage(m_SelectedImage, itkVectorImagePointer);
+
+  unsigned int channel = m_Controls->m_ExtractGradientBox->value();
+  itk::ExtractDwiChannelFilter< short >::Pointer filter = itk::ExtractDwiChannelFilter< short >::New();
+  filter->SetInput( itkVectorImagePointer);
+  filter->SetChannelIndex(channel);
+  filter->Update();
+
+  mitk::Image::Pointer mitkImage = mitk::Image::New();
+  mitkImage->InitializeByItk( filter->GetOutput() );
+  mitkImage->SetImportChannel( filter->GetOutput()->GetBufferPointer() );
+
+  mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+  imageNode->SetData( mitkImage );
+  QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
+  imageNode->SetName((name+"_direction-"+QString::number(channel)).toStdString().c_str());
+  GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
+
+  mitk::RenderingManager::GetInstance()->InitializeViews(imageNode->GetData()->GetTimeGeometry(),mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
 }
 
 void QmitkPreprocessingView::DoCropImage()
 {
-    if (m_DiffusionImage.IsNotNull())
-    {
-        ItkDwiType::SizeType lower;
-        ItkDwiType::SizeType upper;
-        lower[0] = m_Controls->m_XstartBox->value();
-        lower[1] = m_Controls->m_YstartBox->value();
-        lower[2] = m_Controls->m_ZstartBox->value();
-        upper[0] = m_Controls->m_XendBox->value();
-        upper[1] = m_Controls->m_YendBox->value();
-        upper[2] = m_Controls->m_ZendBox->value();
-
-        itk::CropImageFilter< ItkDwiType, ItkDwiType >::Pointer cropper = itk::CropImageFilter< ItkDwiType, ItkDwiType >::New();
-        cropper->SetLowerBoundaryCropSize(lower);
-        cropper->SetUpperBoundaryCropSize(upper);
-        cropper->SetInput(m_DiffusionImage->GetVectorImage());
-        cropper->Update();
-
-        MitkDwiType::Pointer image = MitkDwiType::New();
-        image->SetVectorImage( cropper->GetOutput() );
-        image->SetReferenceBValue( m_DiffusionImage->GetReferenceBValue() );
-        image->SetDirections( m_DiffusionImage->GetDirections() );
-        image->InitializeFromVectorImage();
-
-        mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
-        imageNode->SetData( image );
-        QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
-        imageNode->SetName((name+"_cropped").toStdString().c_str());
-        GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
-        mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
-        mitk::RenderingManager::GetInstance()->RequestUpdateAll();
-
-        mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
-        mitk::RenderingManager::GetInstance()->RequestUpdateAll();
-    }
-    else if(m_SelectedImage.IsNotNull())
-    {
-        AccessFixedDimensionByItk(m_SelectedImage, TemplatedCropImage,3);
-    }
-}
+  ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+  mitk::CastToItkImage(m_SelectedImage, itkVectorImagePointer);
 
-template < typename TPixel, unsigned int VImageDimension >
-void QmitkPreprocessingView::TemplatedCropImage( itk::Image<TPixel, VImageDimension>* itkImage)
-{
+  bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_SelectedImageNode->GetData())) );
+  if ( isDiffusionImage )
+  {
     ItkDwiType::SizeType lower;
     ItkDwiType::SizeType upper;
     lower[0] = m_Controls->m_XstartBox->value();
     lower[1] = m_Controls->m_YstartBox->value();
     lower[2] = m_Controls->m_ZstartBox->value();
     upper[0] = m_Controls->m_XendBox->value();
     upper[1] = m_Controls->m_YendBox->value();
     upper[2] = m_Controls->m_ZendBox->value();
 
-    typedef itk::Image<TPixel, VImageDimension> ImageType;
-    typename itk::CropImageFilter< ImageType, ImageType >::Pointer cropper = itk::CropImageFilter< ImageType, ImageType >::New();
+    itk::CropImageFilter< ItkDwiType, ItkDwiType >::Pointer cropper = itk::CropImageFilter< ItkDwiType, ItkDwiType >::New();
     cropper->SetLowerBoundaryCropSize(lower);
     cropper->SetUpperBoundaryCropSize(upper);
-    cropper->SetInput(itkImage);
+    cropper->SetInput( itkVectorImagePointer );
     cropper->Update();
 
-    mitk::Image::Pointer image = mitk::Image::New();
-    image->InitializeByItk( cropper->GetOutput() );
-    image->SetVolume( cropper->GetOutput()->GetBufferPointer() );
+    mitk::Image::Pointer image = mitk::GrabItkImageMemory( cropper->GetOutput() );
+    image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( static_cast<mitk::GradientDirectionsProperty*>( m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() ) );
+    image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() ) );
+    image->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( static_cast<mitk::MeasurementFrameProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )->GetMeasurementFrame() ) );
+    mitk::DiffusionPropertyHelper propertyHelper( image );
+    propertyHelper.InitializeImage();
+
     mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
     imageNode->SetData( image );
-    QString name = m_SelectedImageNode->GetName().c_str();
-
+    QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
     imageNode->SetName((name+"_cropped").toStdString().c_str());
-    GetDefaultDataStorage()->Add(imageNode, m_SelectedImageNode);
+    GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
+    mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+    mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
     mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+  }
+  else if(m_SelectedImage.IsNotNull())
+  {
+    AccessFixedDimensionByItk(m_SelectedImage, TemplatedCropImage,3);
+  }
 }
 
-void QmitkPreprocessingView::DoApplySpacing()
+template < typename TPixel, unsigned int VImageDimension >
+void QmitkPreprocessingView::TemplatedCropImage( itk::Image<TPixel, VImageDimension>* itkImage)
 {
-    if (m_DiffusionImage.IsNotNull())
-    {
-        mitk::Vector3D spacing;
-        spacing[0] = m_Controls->m_HeaderSpacingX->value();
-        spacing[1] = m_Controls->m_HeaderSpacingY->value();
-        spacing[2] = m_Controls->m_HeaderSpacingZ->value();
-
-        MitkDwiType::Pointer image = m_DiffusionImage->Clone();
-        image->GetVectorImage()->SetSpacing(spacing);
-        image->InitializeFromVectorImage();
-
-        mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
-        imageNode->SetData( image );
-        QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
-        imageNode->SetName((name+"_newspacing").toStdString().c_str());
-        GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
-        mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
-        mitk::RenderingManager::GetInstance()->RequestUpdateAll();
-    }
-    else if(m_SelectedImage.IsNotNull())
-    {
-        AccessFixedDimensionByItk(m_SelectedImage, TemplatedSetImageSpacing,3);
-    }
+  ItkDwiType::SizeType lower;
+  ItkDwiType::SizeType upper;
+  lower[0] = m_Controls->m_XstartBox->value();
+  lower[1] = m_Controls->m_YstartBox->value();
+  lower[2] = m_Controls->m_ZstartBox->value();
+  upper[0] = m_Controls->m_XendBox->value();
+  upper[1] = m_Controls->m_YendBox->value();
+  upper[2] = m_Controls->m_ZendBox->value();
+
+  typedef itk::Image<TPixel, VImageDimension> ImageType;
+  typename itk::CropImageFilter< ImageType, ImageType >::Pointer cropper = itk::CropImageFilter< ImageType, ImageType >::New();
+  cropper->SetLowerBoundaryCropSize(lower);
+  cropper->SetUpperBoundaryCropSize(upper);
+  cropper->SetInput(itkImage);
+  cropper->Update();
+
+  mitk::Image::Pointer image = mitk::Image::New();
+  image->InitializeByItk( cropper->GetOutput() );
+  image->SetVolume( cropper->GetOutput()->GetBufferPointer() );
+  mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+  imageNode->SetData( image );
+  QString name = m_SelectedImageNode->GetName().c_str();
+
+  imageNode->SetName((name+"_cropped").toStdString().c_str());
+  GetDefaultDataStorage()->Add(imageNode, m_SelectedImageNode);
+
+  mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+  mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
-template < typename TPixel, unsigned int VImageDimension >
-void QmitkPreprocessingView::TemplatedSetImageSpacing( itk::Image<TPixel, VImageDimension>* itkImage)
+void QmitkPreprocessingView::DoApplySpacing()
 {
+  ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+  mitk::CastToItkImage(m_SelectedImage, itkVectorImagePointer);
+
+  bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_SelectedImageNode->GetData())) );
+  if ( isDiffusionImage )
+  {
     mitk::Vector3D spacing;
     spacing[0] = m_Controls->m_HeaderSpacingX->value();
     spacing[1] = m_Controls->m_HeaderSpacingY->value();
     spacing[2] = m_Controls->m_HeaderSpacingZ->value();
 
-    typedef itk::ImageDuplicator< itk::Image<TPixel, VImageDimension> > DuplicateFilterType;
-    typename DuplicateFilterType::Pointer duplicator = DuplicateFilterType::New();
-    duplicator->SetInputImage( itkImage );
-    duplicator->Update();
-    typename itk::Image<TPixel, VImageDimension>::Pointer newImage = duplicator->GetOutput();
-    newImage->SetSpacing(spacing);
+    mitk::Image::Pointer image = m_SelectedImage->Clone();
+    image->GetGeometry()->SetSpacing( spacing );
+    mitk::DiffusionPropertyHelper propertyHelper( image );
+    propertyHelper.InitializeImage();
 
-    mitk::Image::Pointer image = mitk::Image::New();
-    image->InitializeByItk( newImage.GetPointer() );
-    image->SetVolume( newImage->GetBufferPointer() );
     mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
     imageNode->SetData( image );
-    QString name = m_SelectedImageNode->GetName().c_str();
-
+    QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
     imageNode->SetName((name+"_newspacing").toStdString().c_str());
-    GetDefaultDataStorage()->Add(imageNode, m_SelectedImageNode);
+    GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
     mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+  }
+  else if(m_SelectedImage.IsNotNull())
+  {
+    AccessFixedDimensionByItk(m_SelectedImage, TemplatedSetImageSpacing,3);
+  }
 }
 
-void QmitkPreprocessingView::DoApplyOrigin()
+template < typename TPixel, unsigned int VImageDimension >
+void QmitkPreprocessingView::TemplatedSetImageSpacing( itk::Image<TPixel, VImageDimension>* itkImage)
 {
-    if (m_DiffusionImage.IsNotNull())
-    {
-        mitk::Vector3D origin;
-        origin[0] = m_Controls->m_HeaderOriginX->value();
-        origin[1] = m_Controls->m_HeaderOriginY->value();
-        origin[2] = m_Controls->m_HeaderOriginZ->value();
-
-        MitkDwiType::Pointer image = m_DiffusionImage->Clone();
-        image->GetVectorImage()->SetOrigin(origin);
-        image->InitializeFromVectorImage();
-
-        mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
-        imageNode->SetData( image );
-        QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
-        imageNode->SetName((name+"_neworigin").toStdString().c_str());
-        GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
-        mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
-        mitk::RenderingManager::GetInstance()->RequestUpdateAll();
-    }
-    else if(m_SelectedImage.IsNotNull())
-    {
-        AccessFixedDimensionByItk(m_SelectedImage, TemplatedSetImageOrigin,3);
-    }
+  mitk::Vector3D spacing;
+  spacing[0] = m_Controls->m_HeaderSpacingX->value();
+  spacing[1] = m_Controls->m_HeaderSpacingY->value();
+  spacing[2] = m_Controls->m_HeaderSpacingZ->value();
+
+  typedef itk::ImageDuplicator< itk::Image<TPixel, VImageDimension> > DuplicateFilterType;
+  typename DuplicateFilterType::Pointer duplicator = DuplicateFilterType::New();
+  duplicator->SetInputImage( itkImage );
+  duplicator->Update();
+  typename itk::Image<TPixel, VImageDimension>::Pointer newImage = duplicator->GetOutput();
+  newImage->SetSpacing(spacing);
+
+  mitk::Image::Pointer image = mitk::Image::New();
+  image->InitializeByItk( newImage.GetPointer() );
+  image->SetVolume( newImage->GetBufferPointer() );
+  mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+  imageNode->SetData( image );
+  QString name = m_SelectedImageNode->GetName().c_str();
+
+  imageNode->SetName((name+"_newspacing").toStdString().c_str());
+  GetDefaultDataStorage()->Add(imageNode, m_SelectedImageNode);
+  mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+  mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
-template < typename TPixel, unsigned int VImageDimension >
-void QmitkPreprocessingView::TemplatedSetImageOrigin( itk::Image<TPixel, VImageDimension>* itkImage)
+void QmitkPreprocessingView::DoApplyOrigin()
 {
+  ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+  mitk::CastToItkImage(m_SelectedImage, itkVectorImagePointer);
+
+  bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_SelectedImageNode->GetData())) );
+  if ( isDiffusionImage )
+  {
     mitk::Vector3D origin;
     origin[0] = m_Controls->m_HeaderOriginX->value();
     origin[1] = m_Controls->m_HeaderOriginY->value();
     origin[2] = m_Controls->m_HeaderOriginZ->value();
 
-    typedef itk::ImageDuplicator< itk::Image<TPixel, VImageDimension> > DuplicateFilterType;
-    typename DuplicateFilterType::Pointer duplicator = DuplicateFilterType::New();
-    duplicator->SetInputImage( itkImage );
-    duplicator->Update();
-    typename itk::Image<TPixel, VImageDimension>::Pointer newImage = duplicator->GetOutput();
-    newImage->SetOrigin(origin);
+    mitk::Image::Pointer image = m_SelectedImage->Clone();
+
+    image->GetGeometry()->SetOrigin( origin );
+    mitk::DiffusionPropertyHelper propertyHelper( image );
+    propertyHelper.InitializeImage();
 
-    mitk::Image::Pointer image = mitk::Image::New();
-    image->InitializeByItk( newImage.GetPointer() );
-    image->SetVolume( newImage->GetBufferPointer() );
     mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
     imageNode->SetData( image );
-    QString name = m_SelectedImageNode->GetName().c_str();
-
+    QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
     imageNode->SetName((name+"_neworigin").toStdString().c_str());
-    GetDefaultDataStorage()->Add(imageNode, m_SelectedImageNode);
+    GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
     mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+  }
+  else if(m_SelectedImage.IsNotNull())
+  {
+    AccessFixedDimensionByItk(m_SelectedImage, TemplatedSetImageOrigin,3);
+  }
+}
+
+template < typename TPixel, unsigned int VImageDimension >
+void QmitkPreprocessingView::TemplatedSetImageOrigin( itk::Image<TPixel, VImageDimension>* itkImage)
+{
+  mitk::Vector3D origin;
+  origin[0] = m_Controls->m_HeaderOriginX->value();
+  origin[1] = m_Controls->m_HeaderOriginY->value();
+  origin[2] = m_Controls->m_HeaderOriginZ->value();
+
+  typedef itk::ImageDuplicator< itk::Image<TPixel, VImageDimension> > DuplicateFilterType;
+  typename DuplicateFilterType::Pointer duplicator = DuplicateFilterType::New();
+  duplicator->SetInputImage( itkImage );
+  duplicator->Update();
+  typename itk::Image<TPixel, VImageDimension>::Pointer newImage = duplicator->GetOutput();
+  newImage->SetOrigin(origin);
+
+  mitk::Image::Pointer image = mitk::Image::New();
+  image->InitializeByItk( newImage.GetPointer() );
+  image->SetVolume( newImage->GetBufferPointer() );
+  mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+  imageNode->SetData( image );
+  QString name = m_SelectedImageNode->GetName().c_str();
+
+  imageNode->SetName((name+"_neworigin").toStdString().c_str());
+  GetDefaultDataStorage()->Add(imageNode, m_SelectedImageNode);
+  mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+  mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkPreprocessingView::DoUpdateInterpolationGui(int i)
 {
-    switch (i)
-    {
-    case 0:
+  if( m_SelectedImageNode && m_SelectedImageNode.IsNull() )
+  {
+    return;
+  }
+  switch (i)
+  {
+  case 0:
+  {
+    m_Controls->m_ResampleIntFrame->setVisible(false);
+    m_Controls->m_ResampleDoubleFrame->setVisible(true);
+    break;
+  }
+  case 1:
+  {
+    m_Controls->m_ResampleIntFrame->setVisible(false);
+    m_Controls->m_ResampleDoubleFrame->setVisible(true);
+
+    ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+    mitk::CastToItkImage(m_SelectedImage, itkVectorImagePointer);
+
+    if (itkVectorImagePointer.IsNotNull())
     {
-        m_Controls->m_ResampleIntFrame->setVisible(false);
-        m_Controls->m_ResampleDoubleFrame->setVisible(true);
-        break;
+      m_Controls->m_ResampleDoubleX->setValue(itkVectorImagePointer->GetSpacing()[0]);
+      m_Controls->m_ResampleDoubleY->setValue(itkVectorImagePointer->GetSpacing()[1]);
+      m_Controls->m_ResampleDoubleZ->setValue(itkVectorImagePointer->GetSpacing()[2]);
     }
-    case 1:
+    else if (m_SelectedImage.IsNotNull())
     {
-        m_Controls->m_ResampleIntFrame->setVisible(false);
-        m_Controls->m_ResampleDoubleFrame->setVisible(true);
-
-        if (m_DiffusionImage.IsNotNull())
-        {
-            ItkDwiType::Pointer itkDwi = m_DiffusionImage->GetVectorImage();
-            m_Controls->m_ResampleDoubleX->setValue(itkDwi->GetSpacing()[0]);
-            m_Controls->m_ResampleDoubleY->setValue(itkDwi->GetSpacing()[1]);
-            m_Controls->m_ResampleDoubleZ->setValue(itkDwi->GetSpacing()[2]);
-        }
-        else if (m_SelectedImage.IsNotNull())
-        {
-            mitk::BaseGeometry* geom = m_SelectedImage->GetGeometry();
-            m_Controls->m_ResampleDoubleX->setValue(geom->GetSpacing()[0]);
-            m_Controls->m_ResampleDoubleY->setValue(geom->GetSpacing()[1]);
-            m_Controls->m_ResampleDoubleZ->setValue(geom->GetSpacing()[2]);
-        }
-        break;
+      mitk::BaseGeometry* geom = m_SelectedImage->GetGeometry();
+      m_Controls->m_ResampleDoubleX->setValue(geom->GetSpacing()[0]);
+      m_Controls->m_ResampleDoubleY->setValue(geom->GetSpacing()[1]);
+      m_Controls->m_ResampleDoubleZ->setValue(geom->GetSpacing()[2]);
     }
-    case 2:
-    {
-        m_Controls->m_ResampleIntFrame->setVisible(true);
-        m_Controls->m_ResampleDoubleFrame->setVisible(false);
+    break;
+  }
+  case 2:
+  {
+    m_Controls->m_ResampleIntFrame->setVisible(true);
+    m_Controls->m_ResampleDoubleFrame->setVisible(false);
 
-        if (m_DiffusionImage.IsNotNull())
-        {
-            ItkDwiType::Pointer itkDwi = m_DiffusionImage->GetVectorImage();
-            m_Controls->m_ResampleIntX->setValue(itkDwi->GetLargestPossibleRegion().GetSize(0));
-            m_Controls->m_ResampleIntY->setValue(itkDwi->GetLargestPossibleRegion().GetSize(1));
-            m_Controls->m_ResampleIntZ->setValue(itkDwi->GetLargestPossibleRegion().GetSize(2));
-        }
-        else if (m_SelectedImage.IsNotNull())
-        {
-            mitk::BaseGeometry* geom = m_SelectedImage->GetGeometry();
-            m_Controls->m_ResampleIntX->setValue(geom->GetExtent(0));
-            m_Controls->m_ResampleIntY->setValue(geom->GetExtent(1));
-            m_Controls->m_ResampleIntZ->setValue(geom->GetExtent(2));
-        }
-        break;
-    }
-    default:
+    ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+    mitk::CastToItkImage(m_SelectedImage, itkVectorImagePointer);
+
+    if (itkVectorImagePointer.IsNotNull())
     {
-        m_Controls->m_ResampleIntFrame->setVisible(false);
-        m_Controls->m_ResampleDoubleFrame->setVisible(true);
+      m_Controls->m_ResampleIntX->setValue(itkVectorImagePointer->GetLargestPossibleRegion().GetSize(0));
+      m_Controls->m_ResampleIntY->setValue(itkVectorImagePointer->GetLargestPossibleRegion().GetSize(1));
+      m_Controls->m_ResampleIntZ->setValue(itkVectorImagePointer->GetLargestPossibleRegion().GetSize(2));
     }
+    else if (m_SelectedImage.IsNotNull())
+    {
+      mitk::BaseGeometry* geom = m_SelectedImage->GetGeometry();
+      m_Controls->m_ResampleIntX->setValue(geom->GetExtent(0));
+      m_Controls->m_ResampleIntY->setValue(geom->GetExtent(1));
+      m_Controls->m_ResampleIntZ->setValue(geom->GetExtent(2));
     }
+    break;
+  }
+  default:
+  {
+    m_Controls->m_ResampleIntFrame->setVisible(false);
+    m_Controls->m_ResampleDoubleFrame->setVisible(true);
+  }
+  }
 }
 
 void QmitkPreprocessingView::DoExtractBrainMask()
 {
-    //    if (m_SelectedImage.IsNull())
-    //        return;
-
-    //    typedef itk::Image<unsigned short, 3> ShortImageType;
-    //    ShortImageType::Pointer itkImage = ShortImageType::New();
-    //    mitk::CastToItkImage(m_SelectedImage, itkImage);
-
-    //    typedef itk::BrainMaskExtractionImageFilter< unsigned char > FilterType;
-    //    FilterType::Pointer filter = FilterType::New();
-    //    filter->SetInput(itkImage);
-    //    filter->SetMaxNumIterations(m_Controls->m_BrainMaskIterationsBox->value());
-    //    filter->Update();
-
-    //    mitk::Image::Pointer image = mitk::Image::New();
-    //    image->InitializeByItk( filter->GetOutput() );
-    //    image->SetVolume( filter->GetOutput()->GetBufferPointer() );
-    //    mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
-    //    imageNode->SetData( image );
-    //    imageNode->SetName("BRAINMASK");
-    //    GetDefaultDataStorage()->Add(imageNode);
+  //    if (m_SelectedImage.IsNull())
+  //        return;
+
+  //    typedef itk::Image<unsigned short, 3> ShortImageType;
+  //    ShortImageType::Pointer itkImage = ShortImageType::New();
+  //    mitk::CastToItkImage(m_SelectedImage, itkImage);
+
+  //    typedef itk::BrainMaskExtractionImageFilter< unsigned char > FilterType;
+  //    FilterType::Pointer filter = FilterType::New();
+  //    filter->SetInput(itkImage);
+  //    filter->SetMaxNumIterations(m_Controls->m_BrainMaskIterationsBox->value());
+  //    filter->Update();
+
+  //    mitk::Image::Pointer image = mitk::Image::New();
+  //    image->InitializeByItk( filter->GetOutput() );
+  //    image->SetVolume( filter->GetOutput()->GetBufferPointer() );
+  //    mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+  //    imageNode->SetData( image );
+  //    imageNode->SetName("BRAINMASK");
+  //    GetDefaultDataStorage()->Add(imageNode);
 }
 
 void QmitkPreprocessingView::DoResampleImage()
 {
-    if (m_DiffusionImage.IsNotNull())
-    {
-        typedef itk::ResampleDwiImageFilter< short > ResampleFilter;
-        ResampleFilter::Pointer resampler = ResampleFilter::New();
-        resampler->SetInput(m_DiffusionImage->GetVectorImage());
+  ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+  mitk::CastToItkImage(m_SelectedImage, itkVectorImagePointer);
 
-        switch (m_Controls->m_ResampleTypeBox->currentIndex())
-        {
-        case 0:
-        {
-            itk::Vector< double, 3 > samplingFactor;
-            samplingFactor[0] = m_Controls->m_ResampleDoubleX->value();
-            samplingFactor[1] = m_Controls->m_ResampleDoubleY->value();
-            samplingFactor[2] = m_Controls->m_ResampleDoubleZ->value();
-            resampler->SetSamplingFactor(samplingFactor);
-            break;
-        }
-        case 1:
-        {
-            itk::Vector< double, 3 > newSpacing;
-            newSpacing[0] = m_Controls->m_ResampleDoubleX->value();
-            newSpacing[1] = m_Controls->m_ResampleDoubleY->value();
-            newSpacing[2] = m_Controls->m_ResampleDoubleZ->value();
-            resampler->SetNewSpacing(newSpacing);
-            break;
-        }
-        case 2:
-        {
-            itk::ImageRegion<3> newRegion;
-            newRegion.SetSize(0, m_Controls->m_ResampleIntX->value());
-            newRegion.SetSize(1, m_Controls->m_ResampleIntY->value());
-            newRegion.SetSize(2, m_Controls->m_ResampleIntZ->value());
-            resampler->SetNewImageSize(newRegion);
-            break;
-        }
-        default:
-        {
-            MITK_WARN << "Unknown resampling parameters!";
-            return;
-        }
-        }
-
-        QString outAdd;
-        switch (m_Controls->m_InterpolatorBox->currentIndex())
-        {
-        case 0:
-        {
-            resampler->SetInterpolation(ResampleFilter::Interpolate_NearestNeighbour);
-            outAdd = "NearestNeighbour";
-            break;
-        }
-        case 1:
-        {
-            resampler->SetInterpolation(ResampleFilter::Interpolate_Linear);
-            outAdd = "Linear";
-            break;
-        }
-        case 2:
-        {
-            resampler->SetInterpolation(ResampleFilter::Interpolate_BSpline);
-            outAdd = "BSpline";
-            break;
-        }
-        case 3:
-        {
-            resampler->SetInterpolation(ResampleFilter::Interpolate_WindowedSinc);
-            outAdd = "WindowedSinc";
-            break;
-        }
-        default:
-        {
-            resampler->SetInterpolation(ResampleFilter::Interpolate_NearestNeighbour);
-            outAdd = "NearestNeighbour";
-        }
-        }
-
-        resampler->Update();
-
-        typedef mitk::DiffusionImage<DiffusionPixelType>  DiffusionImageType;
-        DiffusionImageType::Pointer image = DiffusionImageType::New();
-        image->SetVectorImage( resampler->GetOutput() );
-        image->SetReferenceBValue( m_DiffusionImage->GetReferenceBValue() );
-        image->SetDirections( m_DiffusionImage->GetDirections() );
-        image->InitializeFromVectorImage();
-
-        mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
-        imageNode->SetData( image );
-        QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
-
-        imageNode->SetName((name+"_resampled_"+outAdd).toStdString().c_str());
-        GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
-    }
-    else if (m_SelectedImage.IsNotNull())
-    {
-        AccessFixedDimensionByItk(m_SelectedImage, TemplatedResampleImage,3);
-    }
-}
-
-
-template < typename TPixel, unsigned int VImageDimension >
-void QmitkPreprocessingView::TemplatedResampleImage( itk::Image<TPixel, VImageDimension>* itkImage)
-{
-    itk::Vector< double, 3 > newSpacing;
-    itk::ImageRegion<3>   newRegion;
+  bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_SelectedImageNode->GetData())) );
+  if ( isDiffusionImage )
+  {
+    typedef itk::ResampleDwiImageFilter< short > ResampleFilter;
+    ResampleFilter::Pointer resampler = ResampleFilter::New();
+    resampler->SetInput( itkVectorImagePointer );
 
     switch (m_Controls->m_ResampleTypeBox->currentIndex())
     {
     case 0:
     {
-        itk::Vector< double, 3 > sampling;
-        sampling[0] = m_Controls->m_ResampleDoubleX->value();
-        sampling[1] = m_Controls->m_ResampleDoubleY->value();
-        sampling[2] = m_Controls->m_ResampleDoubleZ->value();
-
-        newSpacing = itkImage->GetSpacing();
-        newSpacing[0] /= sampling[0];
-        newSpacing[1] /= sampling[1];
-        newSpacing[2] /= sampling[2];
-        newRegion = itkImage->GetLargestPossibleRegion();
-        newRegion.SetSize(0, newRegion.GetSize(0)*sampling[0]);
-        newRegion.SetSize(1, newRegion.GetSize(1)*sampling[1]);
-        newRegion.SetSize(2, newRegion.GetSize(2)*sampling[2]);
-
-        break;
+      itk::Vector< double, 3 > samplingFactor;
+      samplingFactor[0] = m_Controls->m_ResampleDoubleX->value();
+      samplingFactor[1] = m_Controls->m_ResampleDoubleY->value();
+      samplingFactor[2] = m_Controls->m_ResampleDoubleZ->value();
+      resampler->SetSamplingFactor(samplingFactor);
+      break;
     }
     case 1:
     {
-        newSpacing[0] = m_Controls->m_ResampleDoubleX->value();
-        newSpacing[1] = m_Controls->m_ResampleDoubleY->value();
-        newSpacing[2] = m_Controls->m_ResampleDoubleZ->value();
-
-        itk::Vector< double, 3 > oldSpacing = itkImage->GetSpacing();
-        itk::Vector< double, 3 > sampling;
-        sampling[0] = oldSpacing[0]/newSpacing[0];
-        sampling[1] = oldSpacing[1]/newSpacing[1];
-        sampling[2] = oldSpacing[2]/newSpacing[2];
-        newRegion = itkImage->GetLargestPossibleRegion();
-        newRegion.SetSize(0, newRegion.GetSize(0)*sampling[0]);
-        newRegion.SetSize(1, newRegion.GetSize(1)*sampling[1]);
-        newRegion.SetSize(2, newRegion.GetSize(2)*sampling[2]);
-        break;
+      itk::Vector< double, 3 > newSpacing;
+      newSpacing[0] = m_Controls->m_ResampleDoubleX->value();
+      newSpacing[1] = m_Controls->m_ResampleDoubleY->value();
+      newSpacing[2] = m_Controls->m_ResampleDoubleZ->value();
+      resampler->SetNewSpacing(newSpacing);
+      break;
     }
     case 2:
     {
-        newRegion.SetSize(0, m_Controls->m_ResampleIntX->value());
-        newRegion.SetSize(1, m_Controls->m_ResampleIntY->value());
-        newRegion.SetSize(2, m_Controls->m_ResampleIntZ->value());
-
-        itk::ImageRegion<3> oldRegion = itkImage->GetLargestPossibleRegion();
-        itk::Vector< double, 3 > sampling;
-        sampling[0] = (double)newRegion.GetSize(0)/oldRegion.GetSize(0);
-        sampling[1] = (double)newRegion.GetSize(1)/oldRegion.GetSize(1);
-        sampling[2] = (double)newRegion.GetSize(2)/oldRegion.GetSize(2);
-
-        newSpacing = itkImage->GetSpacing();
-        newSpacing[0] /= sampling[0];
-        newSpacing[1] /= sampling[1];
-        newSpacing[2] /= sampling[2];
-        break;
+      itk::ImageRegion<3> newRegion;
+      newRegion.SetSize(0, m_Controls->m_ResampleIntX->value());
+      newRegion.SetSize(1, m_Controls->m_ResampleIntY->value());
+      newRegion.SetSize(2, m_Controls->m_ResampleIntZ->value());
+      resampler->SetNewImageSize(newRegion);
+      break;
     }
     default:
     {
-        MITK_WARN << "Unknown resampling parameters!";
-        return;
+      MITK_WARN << "Unknown resampling parameters!";
+      return;
     }
     }
 
-    itk::Point<double,3> origin = itkImage->GetOrigin();
-    origin[0] -= itkImage->GetSpacing()[0]/2;
-    origin[1] -= itkImage->GetSpacing()[1]/2;
-    origin[2] -= itkImage->GetSpacing()[2]/2;
-    origin[0] += newSpacing[0]/2;
-    origin[1] += newSpacing[1]/2;
-    origin[2] += newSpacing[2]/2;
-
-    typedef itk::Image<TPixel, VImageDimension> ImageType;
-    typename ImageType::Pointer outImage = ImageType::New();
-    outImage->SetSpacing( newSpacing );
-    outImage->SetOrigin( origin );
-    outImage->SetDirection( itkImage->GetDirection() );
-    outImage->SetLargestPossibleRegion( newRegion );
-    outImage->SetBufferedRegion( newRegion );
-    outImage->SetRequestedRegion( newRegion );
-    outImage->Allocate();
-
-    typedef itk::ResampleImageFilter<ImageType, ImageType> ResampleFilter;
-    typename ResampleFilter::Pointer resampler = ResampleFilter::New();
-    resampler->SetInput(itkImage);
-    resampler->SetOutputParametersFromImage(outImage);
-
     QString outAdd;
     switch (m_Controls->m_InterpolatorBox->currentIndex())
     {
     case 0:
     {
-        typename itk::NearestNeighborInterpolateImageFunction<ImageType>::Pointer interp = itk::NearestNeighborInterpolateImageFunction<ImageType>::New();
-        resampler->SetInterpolator(interp);
-        outAdd = "NearestNeighbour";
-        break;
+      resampler->SetInterpolation(ResampleFilter::Interpolate_NearestNeighbour);
+      outAdd = "NearestNeighbour";
+      break;
     }
     case 1:
     {
-        typename itk::LinearInterpolateImageFunction<ImageType>::Pointer interp = itk::LinearInterpolateImageFunction<ImageType>::New();
-        resampler->SetInterpolator(interp);
-        outAdd = "Linear";
-        break;
+      resampler->SetInterpolation(ResampleFilter::Interpolate_Linear);
+      outAdd = "Linear";
+      break;
     }
     case 2:
     {
-        typename itk::BSplineInterpolateImageFunction<ImageType>::Pointer interp = itk::BSplineInterpolateImageFunction<ImageType>::New();
-        resampler->SetInterpolator(interp);
-        outAdd = "BSpline";
-        break;
+      resampler->SetInterpolation(ResampleFilter::Interpolate_BSpline);
+      outAdd = "BSpline";
+      break;
     }
     case 3:
     {
-        typename itk::WindowedSincInterpolateImageFunction<ImageType, 3>::Pointer interp = itk::WindowedSincInterpolateImageFunction<ImageType, 3>::New();
-        resampler->SetInterpolator(interp);
-        outAdd = "WindowedSinc";
-        break;
+      resampler->SetInterpolation(ResampleFilter::Interpolate_WindowedSinc);
+      outAdd = "WindowedSinc";
+      break;
     }
     default:
     {
-        typename itk::NearestNeighborInterpolateImageFunction<ImageType>::Pointer interp = itk::NearestNeighborInterpolateImageFunction<ImageType>::New();
-        resampler->SetInterpolator(interp);
-        outAdd = "NearestNeighbour";
+      resampler->SetInterpolation(ResampleFilter::Interpolate_NearestNeighbour);
+      outAdd = "NearestNeighbour";
     }
     }
 
     resampler->Update();
 
-    mitk::Image::Pointer image = mitk::Image::New();
-    image->InitializeByItk( resampler->GetOutput() );
-    image->SetVolume( resampler->GetOutput()->GetBufferPointer() );
+    mitk::Image::Pointer image = mitk::GrabItkImageMemory( resampler->GetOutput() );
+    image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( static_cast<mitk::GradientDirectionsProperty*>( m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() ) );
+    image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() ) );
+    image->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( static_cast<mitk::MeasurementFrameProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )->GetMeasurementFrame() ) );
+    mitk::DiffusionPropertyHelper propertyHelper( image );
+    propertyHelper.InitializeImage();
+
     mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
     imageNode->SetData( image );
-    QString name = m_SelectedImageNode->GetName().c_str();
+    QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
 
     imageNode->SetName((name+"_resampled_"+outAdd).toStdString().c_str());
-    GetDefaultDataStorage()->Add(imageNode, m_SelectedImageNode);
+    GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
+  }
+  else if (m_SelectedImage.IsNotNull())
+  {
+    AccessFixedDimensionByItk(m_SelectedImage, TemplatedResampleImage,3);
+  }
 }
 
-void QmitkPreprocessingView::DoApplyDirectionMatrix()
-{
-    if (m_DiffusionImage.IsNotNull())
-    {
-        MitkDwiType::Pointer newDwi = m_DiffusionImage->Clone();
-        ItkDwiType::DirectionType newDirection;
-        for (int r=0; r<3; r++)
-            for (int c=0; c<3; c++)
-            {
-                QTableWidgetItem* item = m_Controls->m_DirectionMatrixTable->item(r,c);
-                if (!item)
-                    return;
-                newDirection[r][c] = item->text().toDouble();
-            }
-
-        ItkDwiType::Pointer itkDwi = newDwi->GetVectorImage();
-
-        typedef mitk::DiffusionImage<DiffusionPixelType>  MitkDwiType;
-        vnl_matrix_fixed< double,3,3 > oldInverseDirection = itkDwi->GetDirection().GetInverse();
-        MitkDwiType::GradientDirectionContainerType::Pointer oldGradients = m_DiffusionImage->GetDirectionsWithoutMeasurementFrame();
-        MitkDwiType::GradientDirectionContainerType::Pointer newGradients = MitkDwiType::GradientDirectionContainerType::New();
-
-        for (unsigned int i=0; i<oldGradients->Size(); i++)
-        {
-            MitkDwiType::GradientDirectionType g = oldGradients->GetElement(i);
-            double mag = g.magnitude();
-            MitkDwiType::GradientDirectionType newG = oldInverseDirection*g;
-            newG = newDirection.GetVnlMatrix()*newG;
-            newG.normalize();
-            newGradients->InsertElement(i, newG*mag);
-        }
-
-        newDwi->SetDirections(newGradients);
-        itkDwi->SetDirection(newDirection);
-        newDwi->InitializeFromVectorImage();
-
-        mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
-        imageNode->SetData( newDwi );
-        QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
-        imageNode->SetName((name+"_newdirection").toStdString().c_str());
-        GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
 
-        mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
-        mitk::RenderingManager::GetInstance()->RequestUpdateAll();
-    }
-    else if (m_SelectedImage.IsNotNull())
-    {
-        AccessFixedDimensionByItk(m_SelectedImage, TemplatedApplyRotation,3);
-    }
+template < typename TPixel, unsigned int VImageDimension >
+void QmitkPreprocessingView::TemplatedResampleImage( itk::Image<TPixel, VImageDimension>* itkImage)
+{
+  itk::Vector< double, 3 > newSpacing;
+  itk::ImageRegion<3>   newRegion;
+
+  switch (m_Controls->m_ResampleTypeBox->currentIndex())
+  {
+  case 0:
+  {
+    itk::Vector< double, 3 > sampling;
+    sampling[0] = m_Controls->m_ResampleDoubleX->value();
+    sampling[1] = m_Controls->m_ResampleDoubleY->value();
+    sampling[2] = m_Controls->m_ResampleDoubleZ->value();
+
+    newSpacing = itkImage->GetSpacing();
+    newSpacing[0] /= sampling[0];
+    newSpacing[1] /= sampling[1];
+    newSpacing[2] /= sampling[2];
+    newRegion = itkImage->GetLargestPossibleRegion();
+    newRegion.SetSize(0, newRegion.GetSize(0)*sampling[0]);
+    newRegion.SetSize(1, newRegion.GetSize(1)*sampling[1]);
+    newRegion.SetSize(2, newRegion.GetSize(2)*sampling[2]);
+
+    break;
+  }
+  case 1:
+  {
+    newSpacing[0] = m_Controls->m_ResampleDoubleX->value();
+    newSpacing[1] = m_Controls->m_ResampleDoubleY->value();
+    newSpacing[2] = m_Controls->m_ResampleDoubleZ->value();
+
+    itk::Vector< double, 3 > oldSpacing = itkImage->GetSpacing();
+    itk::Vector< double, 3 > sampling;
+    sampling[0] = oldSpacing[0]/newSpacing[0];
+    sampling[1] = oldSpacing[1]/newSpacing[1];
+    sampling[2] = oldSpacing[2]/newSpacing[2];
+    newRegion = itkImage->GetLargestPossibleRegion();
+    newRegion.SetSize(0, newRegion.GetSize(0)*sampling[0]);
+    newRegion.SetSize(1, newRegion.GetSize(1)*sampling[1]);
+    newRegion.SetSize(2, newRegion.GetSize(2)*sampling[2]);
+    break;
+  }
+  case 2:
+  {
+    newRegion.SetSize(0, m_Controls->m_ResampleIntX->value());
+    newRegion.SetSize(1, m_Controls->m_ResampleIntY->value());
+    newRegion.SetSize(2, m_Controls->m_ResampleIntZ->value());
+
+    itk::ImageRegion<3> oldRegion = itkImage->GetLargestPossibleRegion();
+    itk::Vector< double, 3 > sampling;
+    sampling[0] = (double)newRegion.GetSize(0)/oldRegion.GetSize(0);
+    sampling[1] = (double)newRegion.GetSize(1)/oldRegion.GetSize(1);
+    sampling[2] = (double)newRegion.GetSize(2)/oldRegion.GetSize(2);
+
+    newSpacing = itkImage->GetSpacing();
+    newSpacing[0] /= sampling[0];
+    newSpacing[1] /= sampling[1];
+    newSpacing[2] /= sampling[2];
+    break;
+  }
+  default:
+  {
+    MITK_WARN << "Unknown resampling parameters!";
+    return;
+  }
+  }
+
+  itk::Point<double,3> origin = itkImage->GetOrigin();
+  origin[0] -= itkImage->GetSpacing()[0]/2;
+  origin[1] -= itkImage->GetSpacing()[1]/2;
+  origin[2] -= itkImage->GetSpacing()[2]/2;
+  origin[0] += newSpacing[0]/2;
+  origin[1] += newSpacing[1]/2;
+  origin[2] += newSpacing[2]/2;
+
+  typedef itk::Image<TPixel, VImageDimension> ImageType;
+  typename ImageType::Pointer outImage = ImageType::New();
+  outImage->SetSpacing( newSpacing );
+  outImage->SetOrigin( origin );
+  outImage->SetDirection( itkImage->GetDirection() );
+  outImage->SetLargestPossibleRegion( newRegion );
+  outImage->SetBufferedRegion( newRegion );
+  outImage->SetRequestedRegion( newRegion );
+  outImage->Allocate();
+
+  typedef itk::ResampleImageFilter<ImageType, ImageType> ResampleFilter;
+  typename ResampleFilter::Pointer resampler = ResampleFilter::New();
+  resampler->SetInput(itkImage);
+  resampler->SetOutputParametersFromImage(outImage);
+
+  QString outAdd;
+  switch (m_Controls->m_InterpolatorBox->currentIndex())
+  {
+  case 0:
+  {
+    typename itk::NearestNeighborInterpolateImageFunction<ImageType>::Pointer interp = itk::NearestNeighborInterpolateImageFunction<ImageType>::New();
+    resampler->SetInterpolator(interp);
+    outAdd = "NearestNeighbour";
+    break;
+  }
+  case 1:
+  {
+    typename itk::LinearInterpolateImageFunction<ImageType>::Pointer interp = itk::LinearInterpolateImageFunction<ImageType>::New();
+    resampler->SetInterpolator(interp);
+    outAdd = "Linear";
+    break;
+  }
+  case 2:
+  {
+    typename itk::BSplineInterpolateImageFunction<ImageType>::Pointer interp = itk::BSplineInterpolateImageFunction<ImageType>::New();
+    resampler->SetInterpolator(interp);
+    outAdd = "BSpline";
+    break;
+  }
+  case 3:
+  {
+    typename itk::WindowedSincInterpolateImageFunction<ImageType, 3>::Pointer interp = itk::WindowedSincInterpolateImageFunction<ImageType, 3>::New();
+    resampler->SetInterpolator(interp);
+    outAdd = "WindowedSinc";
+    break;
+  }
+  default:
+  {
+    typename itk::NearestNeighborInterpolateImageFunction<ImageType>::Pointer interp = itk::NearestNeighborInterpolateImageFunction<ImageType>::New();
+    resampler->SetInterpolator(interp);
+    outAdd = "NearestNeighbour";
+  }
+  }
+
+  resampler->Update();
+
+  mitk::Image::Pointer image = mitk::Image::New();
+  image->InitializeByItk( resampler->GetOutput() );
+  image->SetVolume( resampler->GetOutput()->GetBufferPointer() );
+  mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+  imageNode->SetData( image );
+  QString name = m_SelectedImageNode->GetName().c_str();
+
+  imageNode->SetName((name+"_resampled_"+outAdd).toStdString().c_str());
+  GetDefaultDataStorage()->Add(imageNode, m_SelectedImageNode);
 }
 
-template < typename TPixel, unsigned int VImageDimension >
-void QmitkPreprocessingView::TemplatedApplyRotation( itk::Image<TPixel, VImageDimension>* itkImage)
+void QmitkPreprocessingView::DoApplyDirectionMatrix()
 {
+  bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_SelectedImageNode->GetData())) );
+  if ( isDiffusionImage )
+  {
+    mitk::Image::Pointer newDwi = m_SelectedImage->Clone();
     ItkDwiType::DirectionType newDirection;
     for (int r=0; r<3; r++)
-        for (int c=0; c<3; c++)
-        {
-            QTableWidgetItem* item = m_Controls->m_DirectionMatrixTable->item(r,c);
-            if (!item)
-                return;
-            newDirection[r][c] = item->text().toDouble();
-        }
-    typedef itk::Image<TPixel, VImageDimension> ImageType;
-
-    typename ImageType::Pointer newImage = ImageType::New();
-    newImage->SetSpacing( itkImage->GetSpacing() );
-    newImage->SetOrigin( itkImage->GetOrigin() );
-    newImage->SetDirection( newDirection );
-    newImage->SetLargestPossibleRegion( itkImage->GetLargestPossibleRegion() );
-    newImage->SetBufferedRegion( itkImage->GetLargestPossibleRegion() );
-    newImage->SetRequestedRegion( itkImage->GetLargestPossibleRegion() );
-    newImage->Allocate();
-    newImage->FillBuffer(0);
-
-    itk::ImageRegionIterator< itk::Image<TPixel, VImageDimension> > it(itkImage, itkImage->GetLargestPossibleRegion());
-    while(!it.IsAtEnd())
     {
-        newImage->SetPixel(it.GetIndex(), it.Get());
-        ++it;
+      for (int c=0; c<3; c++)
+      {
+        QTableWidgetItem* item = m_Controls->m_DirectionMatrixTable->item(r,c);
+        if (!item)
+          return;
+        newDirection[r][c] = item->text().toDouble();
+      }
     }
+    ItkDwiType::Pointer itkDwi = ItkDwiType::New();
+    mitk::CastToItkImage(newDwi, itkDwi);
 
-    mitk::Image::Pointer newMitkImage = mitk::Image::New();
-    newMitkImage->InitializeByItk(newImage.GetPointer());
-    newMitkImage->SetVolume(newImage->GetBufferPointer());
+    vnl_matrix_fixed< double,3,3 > oldInverseDirection = itkDwi->GetDirection().GetInverse();
+    mitk::GradientDirectionsProperty::GradientDirectionsContainerType::Pointer oldGradients = static_cast<mitk::GradientDirectionsProperty*>( m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
+    mitk::GradientDirectionsProperty::GradientDirectionsContainerType::Pointer newGradients = mitk::GradientDirectionsProperty::GradientDirectionsContainerType::New();
+
+    for (unsigned int i=0; i<oldGradients->Size(); i++)
+    {
+      mitk::GradientDirectionsProperty::GradientDirectionType g = oldGradients->GetElement(i);
+      double mag = g.magnitude();
+      mitk::GradientDirectionsProperty::GradientDirectionType newG = oldInverseDirection*g;
+      newG = newDirection.GetVnlMatrix()*newG;
+      newG.normalize();
+      newGradients->InsertElement(i, newG*mag);
+    }
+
+    itkDwi->SetDirection(newDirection);
+    newDwi->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( newGradients ) );
+    newDwi->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() ) );
+    newDwi->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( static_cast<mitk::MeasurementFrameProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )->GetMeasurementFrame() ) );
+
+    mitk::DiffusionPropertyHelper propertyHelper( newDwi );
+    propertyHelper.InitializeImage();
 
     mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
-    imageNode->SetData( newMitkImage );
-    QString name = m_SelectedImageNode->GetName().c_str();
+    imageNode->SetData( newDwi );
+    QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
     imageNode->SetName((name+"_newdirection").toStdString().c_str());
-    GetDefaultDataStorage()->Add(imageNode, m_SelectedImageNode);
+    GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
 
     mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+  }
+  else if (m_SelectedImage.IsNotNull())
+  {
+    AccessFixedDimensionByItk(m_SelectedImage, TemplatedApplyRotation,3);
+  }
 }
 
-void QmitkPreprocessingView::DoProjectSignal()
+template < typename TPixel, unsigned int VImageDimension >
+void QmitkPreprocessingView::TemplatedApplyRotation( itk::Image<TPixel, VImageDimension>* itkImage)
 {
-    switch(m_Controls->m_ProjectionMethodBox->currentIndex())
+  ItkDwiType::DirectionType newDirection;
+  for (int r=0; r<3; r++)
+    for (int c=0; c<3; c++)
     {
-    case 0:
-        DoADCAverage();
-        break;
-    case 1:
-        DoAKCFit();
-        break;
-    case 2:
-        DoBiExpFit();
-        break;
-    default:
-        DoADCAverage();
+      QTableWidgetItem* item = m_Controls->m_DirectionMatrixTable->item(r,c);
+      if (!item)
+        return;
+      newDirection[r][c] = item->text().toDouble();
     }
+  typedef itk::Image<TPixel, VImageDimension> ImageType;
+
+  typename ImageType::Pointer newImage = ImageType::New();
+  newImage->SetSpacing( itkImage->GetSpacing() );
+  newImage->SetOrigin( itkImage->GetOrigin() );
+  newImage->SetDirection( newDirection );
+  newImage->SetLargestPossibleRegion( itkImage->GetLargestPossibleRegion() );
+  newImage->SetBufferedRegion( itkImage->GetLargestPossibleRegion() );
+  newImage->SetRequestedRegion( itkImage->GetLargestPossibleRegion() );
+  newImage->Allocate();
+  newImage->FillBuffer(0);
+
+  itk::ImageRegionIterator< itk::Image<TPixel, VImageDimension> > it(itkImage, itkImage->GetLargestPossibleRegion());
+  while(!it.IsAtEnd())
+  {
+    newImage->SetPixel(it.GetIndex(), it.Get());
+    ++it;
+  }
+
+  mitk::Image::Pointer newMitkImage = mitk::Image::New();
+  newMitkImage->InitializeByItk(newImage.GetPointer());
+  newMitkImage->SetVolume(newImage->GetBufferPointer());
+
+  mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+  imageNode->SetData( newMitkImage );
+  QString name = m_SelectedImageNode->GetName().c_str();
+  imageNode->SetName((name+"_newdirection").toStdString().c_str());
+  GetDefaultDataStorage()->Add(imageNode, m_SelectedImageNode);
+
+  mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+  mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
-void QmitkPreprocessingView::DoDwiNormalization()
+void QmitkPreprocessingView::DoProjectSignal()
 {
-    if (m_DiffusionImage.IsNull())
-        return;
-
-    int b0Index = -1;
-    for (unsigned int i=0; i<m_DiffusionImage->GetNumberOfChannels(); i++)
-    {
-        GradientDirectionType g = m_DiffusionImage->GetDirections()->GetElement(i);
-        if (g.magnitude()<0.001)
-        {
-            b0Index = i;
-            break;
-        }
-    }
-    if (b0Index==-1)
-        return;
+  switch(m_Controls->m_ProjectionMethodBox->currentIndex())
+  {
+  case 0:
+    DoADCAverage();
+    break;
+  case 1:
+    DoAKCFit();
+    break;
+  case 2:
+    DoBiExpFit();
+    break;
+  default:
+    DoADCAverage();
+  }
+}
 
-    typedef mitk::DiffusionImage<DiffusionPixelType>  DiffusionImageType;
-    typedef itk::DwiNormilzationFilter<short>  FilterType;
+void QmitkPreprocessingView::DoDwiNormalization()
+{
+  bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_SelectedImageNode->GetData())) );
+  if ( ! isDiffusionImage )
+    return;
 
-    FilterType::Pointer filter = FilterType::New();
-    filter->SetInput(m_DiffusionImage->GetVectorImage());
-    filter->SetGradientDirections(m_DiffusionImage->GetDirections());
+  GradientDirectionContainerType::Pointer gradientContainer = static_cast<mitk::GradientDirectionsProperty*>( m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
 
-    UcharImageType::Pointer itkImage = NULL;
-    if (m_Controls->m_NormalizationMaskBox->GetSelectedNode().IsNotNull())
+  int b0Index = -1;
+  for (unsigned int i=0; i<gradientContainer->size(); i++)
+  {
+    GradientDirectionType g = gradientContainer->GetElement(i);
+    if (g.magnitude()<0.001)
     {
-        itkImage = UcharImageType::New();
-        mitk::CastToItkImage(dynamic_cast<mitk::Image*>(m_Controls->m_NormalizationMaskBox->GetSelectedNode()->GetData()), itkImage);
-        filter->SetMaskImage(itkImage);
+      b0Index = i;
+      break;
     }
-
-    // determin normalization reference
-    switch(m_Controls->m_NormalizationReferenceBox->currentIndex())
+  }
+  if (b0Index==-1)
+    return;
+
+  typedef itk::DwiNormilzationFilter<short>  FilterType;
+
+  ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+  mitk::CastToItkImage(m_SelectedImage, itkVectorImagePointer);
+
+  FilterType::Pointer filter = FilterType::New();
+  filter->SetInput( itkVectorImagePointer );
+  filter->SetGradientDirections( static_cast<mitk::GradientDirectionsProperty*>( m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() );
+
+  UcharImageType::Pointer itkImage = NULL;
+  if (m_Controls->m_NormalizationMaskBox->GetSelectedNode().IsNotNull())
+  {
+    itkImage = UcharImageType::New();
+    mitk::CastToItkImage(dynamic_cast<mitk::Image*>(m_Controls->m_NormalizationMaskBox->GetSelectedNode()->GetData()), itkImage);
+    filter->SetMaskImage(itkImage);
+  }
+
+  // determin normalization reference
+  switch(m_Controls->m_NormalizationReferenceBox->currentIndex())
+  {
+  case 0: // normalize relative to mean white matter signal intensity
+  {
+    typedef itk::DiffusionTensor3DReconstructionImageFilter< short, short, double > TensorReconstructionImageFilterType;
+    TensorReconstructionImageFilterType::Pointer dtFilter = TensorReconstructionImageFilterType::New();
+    dtFilter->SetGradientImage( gradientContainer, itkVectorImagePointer );
+    dtFilter->SetBValue( static_cast<mitk::FloatProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
+    dtFilter->Update();
+    itk::Image< itk::DiffusionTensor3D< double >, 3 >::Pointer tensorImage = dtFilter->GetOutput();
+    itk::ImageRegionIterator< itk::Image< itk::DiffusionTensor3D< double >, 3 > > inIt(tensorImage, tensorImage->GetLargestPossibleRegion());
+    double ref = 0;
+    unsigned int count = 0;
+    while ( !inIt.IsAtEnd() )
     {
-    case 0: // normalize relative to mean white matter signal intensity
-    {
-        typedef itk::DiffusionTensor3DReconstructionImageFilter< short, short, double > TensorReconstructionImageFilterType;
-        TensorReconstructionImageFilterType::Pointer dtFilter = TensorReconstructionImageFilterType::New();
-        dtFilter->SetGradientImage( m_DiffusionImage->GetDirections(), m_DiffusionImage->GetVectorImage() );
-        dtFilter->SetBValue(m_DiffusionImage->GetReferenceBValue());
-        dtFilter->Update();
-        itk::Image< itk::DiffusionTensor3D< double >, 3 >::Pointer tensorImage = dtFilter->GetOutput();
-        itk::ImageRegionIterator< itk::Image< itk::DiffusionTensor3D< double >, 3 > > inIt(tensorImage, tensorImage->GetLargestPossibleRegion());
-        double ref = 0;
-        unsigned int count = 0;
-        while ( !inIt.IsAtEnd() )
-        {
-            if (itkImage.IsNotNull() && itkImage->GetPixel(inIt.GetIndex())<=0)
-            {
-                ++inIt;
-                continue;
-            }
-
-            double FA = inIt.Get().GetFractionalAnisotropy();
-            if (FA>0.4 && FA<0.99)
-            {
-                ref += m_DiffusionImage->GetVectorImage()->GetPixel(inIt.GetIndex())[b0Index];
-                count++;
-            }
-            ++inIt;
-        }
-        if (count>0)
-        {
-            ref /= count;
-            filter->SetUseGlobalReference(true);
-            filter->SetReference(ref);
-        }
-        break;
+      if (itkImage.IsNotNull() && itkImage->GetPixel(inIt.GetIndex())<=0)
+      {
+        ++inIt;
+        continue;
+      }
+
+      double FA = inIt.Get().GetFractionalAnisotropy();
+      if (FA>0.4 && FA<0.99)
+      {
+        ref += itkVectorImagePointer->GetPixel(inIt.GetIndex())[b0Index];
+        count++;
+      }
+      ++inIt;
     }
-    case 1: // normalize relative to mean CSF signal intensity
+    if (count>0)
     {
-        itk::AdcImageFilter< short, double >::Pointer adcFilter = itk::AdcImageFilter< short, double >::New();
-        adcFilter->SetInput(m_DiffusionImage->GetVectorImage());
-        adcFilter->SetGradientDirections(m_DiffusionImage->GetDirections());
-        adcFilter->SetB_value(m_DiffusionImage->GetReferenceBValue());
-        adcFilter->Update();
-        ItkDoubleImageType::Pointer adcImage = adcFilter->GetOutput();
-        itk::ImageRegionIterator<ItkDoubleImageType> inIt(adcImage, adcImage->GetLargestPossibleRegion());
-        double max = 0.0030;
-        double ref = 0;
-        unsigned int count = 0;
-        while ( !inIt.IsAtEnd() )
-        {
-            if (itkImage.IsNotNull() && itkImage->GetPixel(inIt.GetIndex())<=0)
-            {
-                ++inIt;
-                continue;
-            }
-            if (inIt.Get()>max && inIt.Get()<0.004)
-            {
-                ref += m_DiffusionImage->GetVectorImage()->GetPixel(inIt.GetIndex())[b0Index];
-                count++;
-            }
-            ++inIt;
-        }
-        if (count>0)
-        {
-            ref /= count;
-            filter->SetUseGlobalReference(true);
-            filter->SetReference(ref);
-        }
-        break;
+      ref /= count;
+      filter->SetUseGlobalReference(true);
+      filter->SetReference(ref);
     }
-    case 2:
+    break;
+  }
+  case 1: // normalize relative to mean CSF signal intensity
+  {
+    itk::AdcImageFilter< short, double >::Pointer adcFilter = itk::AdcImageFilter< short, double >::New();
+    adcFilter->SetInput( itkVectorImagePointer );
+    adcFilter->SetGradientDirections( gradientContainer);
+    adcFilter->SetB_value( static_cast<mitk::FloatProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
+    adcFilter->Update();
+    ItkDoubleImageType::Pointer adcImage = adcFilter->GetOutput();
+    itk::ImageRegionIterator<ItkDoubleImageType> inIt(adcImage, adcImage->GetLargestPossibleRegion());
+    double max = 0.0030;
+    double ref = 0;
+    unsigned int count = 0;
+    while ( !inIt.IsAtEnd() )
     {
-        filter->SetUseGlobalReference(false);
+      if (itkImage.IsNotNull() && itkImage->GetPixel(inIt.GetIndex())<=0)
+      {
+        ++inIt;
+        continue;
+      }
+      if (inIt.Get()>max && inIt.Get()<0.004)
+      {
+        ref += itkVectorImagePointer->GetPixel(inIt.GetIndex())[b0Index];
+        count++;
+      }
+      ++inIt;
     }
+    if (count>0)
+    {
+      ref /= count;
+      filter->SetUseGlobalReference(true);
+      filter->SetReference(ref);
     }
-    filter->Update();
-
-    DiffusionImageType::Pointer image = DiffusionImageType::New();
-    image->SetVectorImage( filter->GetOutput() );
-    image->SetReferenceBValue( m_DiffusionImage->GetReferenceBValue() );
-    image->SetDirections( m_DiffusionImage->GetDirections() );
-    image->InitializeFromVectorImage();
-
-    mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
-    imageNode->SetData( image );
-    QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
-
-    imageNode->SetName((name+"_normalized").toStdString().c_str());
-    GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
+    break;
+  }
+  case 2:
+  {
+    filter->SetUseGlobalReference(false);
+  }
+  }
+  filter->Update();
+
+  mitk::Image::Pointer image = mitk::GrabItkImageMemory( filter->GetOutput() );
+  image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( static_cast<mitk::GradientDirectionsProperty*>( m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() ) );
+  image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() ) );
+  image->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( static_cast<mitk::MeasurementFrameProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )->GetMeasurementFrame() ) );
+  mitk::DiffusionPropertyHelper propertyHelper( image );
+  propertyHelper.InitializeImage();
+
+  mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+  imageNode->SetData( image );
+  QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
+
+  imageNode->SetName((name+"_normalized").toStdString().c_str());
+  GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
 }
 
 void QmitkPreprocessingView::DoLengthCorrection()
 {
-    if (m_DiffusionImage.IsNull())
-        return;
-
-    typedef mitk::DiffusionImage<DiffusionPixelType>  DiffusionImageType;
-    typedef itk::DwiGradientLengthCorrectionFilter  FilterType;
-
-    FilterType::Pointer filter = FilterType::New();
-    filter->SetRoundingValue( m_Controls->m_B_ValueMap_Rounder_SpinBox->value());
-    filter->SetReferenceBValue(m_DiffusionImage->GetReferenceBValue());
-    filter->SetReferenceGradientDirectionContainer(m_DiffusionImage->GetDirections());
-    filter->Update();
-
-    DiffusionImageType::Pointer image = DiffusionImageType::New();
-    image->SetVectorImage( m_DiffusionImage->GetVectorImage());
-    image->SetReferenceBValue( filter->GetNewBValue() );
-    image->SetDirections( filter->GetOutputGradientDirectionContainer());
-    image->InitializeFromVectorImage();
-
-    mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
-    imageNode->SetData( image );
-    QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
-
-    imageNode->SetName((name+"_rounded").toStdString().c_str());
-    GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
+  bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_SelectedImageNode->GetData())) );
+  if ( ! isDiffusionImage )
+    return;
+
+  typedef itk::DwiGradientLengthCorrectionFilter  FilterType;
+
+  ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+  mitk::CastToItkImage(m_SelectedImage, itkVectorImagePointer);
+
+  FilterType::Pointer filter = FilterType::New();
+  filter->SetRoundingValue( m_Controls->m_B_ValueMap_Rounder_SpinBox->value());
+  filter->SetReferenceBValue( static_cast<mitk::FloatProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
+  filter->SetReferenceGradientDirectionContainer( static_cast<mitk::GradientDirectionsProperty*>( m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() );
+  filter->Update();
+
+  mitk::Image::Pointer image = mitk::ImportItkImage( itkVectorImagePointer );
+  image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( filter->GetOutputGradientDirectionContainer() ) );
+  image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( filter->GetNewBValue() ) );
+  image->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( static_cast<mitk::MeasurementFrameProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )->GetMeasurementFrame() ) );
+  mitk::DiffusionPropertyHelper propertyHelper( image );
+  propertyHelper.InitializeImage();
+
+  mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+  imageNode->SetData( image );
+  QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
+
+  imageNode->SetName((name+"_rounded").toStdString().c_str());
+  GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
 }
 
 void QmitkPreprocessingView::UpdateDwiBValueMapRounder(int i)
 {
-    if (m_DiffusionImage.IsNull())
-        return;
-    //m_DiffusionImage->UpdateBValueMap();
-    UpdateBValueTableWidget(i);
+  bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_SelectedImageNode->GetData())) );
+  if ( ! isDiffusionImage )
+    return;
+  //m_DiffusionImage->UpdateBValueMap();
+  UpdateBValueTableWidget(i);
 }
 
-void QmitkPreprocessingView::CallMultishellToSingleShellFilter(itk::DWIVoxelFunctor * functor, mitk::DiffusionImage<DiffusionPixelType>::Pointer ImPtr, QString imageName, mitk::DataNode* parent)
+void QmitkPreprocessingView::CallMultishellToSingleShellFilter(itk::DWIVoxelFunctor * functor, mitk::Image::Pointer ImPtr, QString imageName, mitk::DataNode* parent)
 {
-    typedef itk::RadialMultishellToSingleshellImageFilter<DiffusionPixelType, DiffusionPixelType> FilterType;
-
-    // filter input parameter
-    const mitk::DiffusionImage<DiffusionPixelType>::BValueMap
-            &originalShellMap  = ImPtr->GetBValueMap();
+  typedef itk::RadialMultishellToSingleshellImageFilter<DiffusionPixelType, DiffusionPixelType> FilterType;
+
+  // filter input parameter
+  const mitk::BValueMapProperty::BValueMap
+      &originalShellMap  = static_cast<mitk::BValueMapProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )->GetBValueMap();
+
+  ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+  mitk::CastToItkImage(m_SelectedImage, itkVectorImagePointer);
+  ItkDwiType
+      *vectorImage       = itkVectorImagePointer.GetPointer();
+
+  const mitk::GradientDirectionsProperty::GradientDirectionsContainerType::Pointer
+      gradientContainer = static_cast<mitk::GradientDirectionsProperty*>( m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
+
+  const unsigned int
+      &bValue            = static_cast<mitk::FloatProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue();
+
+  mitk::DataNode::Pointer imageNode = 0;
+
+  // filter call
+  FilterType::Pointer filter = FilterType::New();
+  filter->SetInput(vectorImage);
+  filter->SetOriginalGradientDirections(gradientContainer);
+  filter->SetOriginalBValueMap(originalShellMap);
+  filter->SetOriginalBValue(bValue);
+  filter->SetFunctor(functor);
+  filter->Update();
+
+  // create new DWI image
+  mitk::Image::Pointer outImage = mitk::GrabItkImageMemory( filter->GetOutput() );
+  outImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( filter->GetTargetGradientDirections() ) );
+  outImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( m_Controls->m_targetBValueSpinBox->value() ) );
+  outImage->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( static_cast<mitk::MeasurementFrameProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )->GetMeasurementFrame() ) );
+  mitk::DiffusionPropertyHelper propertyHelper( outImage );
+  propertyHelper.InitializeImage();
+
+  imageNode = mitk::DataNode::New();
+  imageNode->SetData( outImage );
+  imageNode->SetName(imageName.toStdString().c_str());
+  GetDefaultDataStorage()->Add(imageNode, parent);
+
+  //  if(m_Controls->m_OutputRMSErrorImage->isChecked()){
+  //    // create new Error image
+  //    FilterType::ErrorImageType::Pointer errImage = filter->GetErrorImage();
+  //    mitk::Image::Pointer mitkErrImage = mitk::Image::New();
+  //    mitkErrImage->InitializeByItk<FilterType::ErrorImageType>(errImage);
+  //    mitkErrImage->SetVolume(errImage->GetBufferPointer());
+
+  //    imageNode = mitk::DataNode::New();
+  //    imageNode->SetData( mitkErrImage );
+  //    imageNode->SetName((imageName+"_Error").toStdString().c_str());
+  //    GetDefaultDataStorage()->Add(imageNode);
+  //  }
+}
 
-    const mitk::DiffusionImage<DiffusionPixelType>::ImageType
-            *vectorImage       = ImPtr->GetVectorImage();
+void QmitkPreprocessingView::DoBiExpFit()
+{
+  itk::BiExpFitFunctor::Pointer functor = itk::BiExpFitFunctor::New();
 
-    const mitk::DiffusionImage<DiffusionPixelType>::GradientDirectionContainerType::Pointer
-            gradientContainer = ImPtr->GetDirections();
+  for (unsigned int i=0; i<m_SelectedDiffusionNodes.size(); i++)
+  {
+    mitk::Image::Pointer inImage =
+        dynamic_cast< mitk::Image* >(m_SelectedDiffusionNodes.at(i)->GetData());
 
-    const unsigned int
-            &bValue            = ImPtr->GetReferenceBValue();
+    QString name(m_SelectedDiffusionNodes.at(i)->GetName().c_str());
 
-    mitk::DataNode::Pointer imageNode = 0;
+    const mitk::BValueMapProperty::BValueMap
+        &originalShellMap  = static_cast<mitk::BValueMapProperty*>(inImage->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )->GetBValueMap();
 
-    // filter call
-    FilterType::Pointer filter = FilterType::New();
-    filter->SetInput(vectorImage);
-    filter->SetOriginalGradientDirections(gradientContainer);
-    filter->SetOriginalBValueMap(originalShellMap);
-    filter->SetOriginalBValue(bValue);
-    filter->SetFunctor(functor);
-    filter->Update();
+    mitk::BValueMapProperty::BValueMap::const_iterator it = originalShellMap.begin();
+    ++it;/* skip b=0*/ unsigned int s = 0; /*shell index */
+    vnl_vector<double> bValueList(originalShellMap.size()-1);
+    while(it != originalShellMap.end())
+      bValueList.put(s++,(it++)->first);
 
-    // create new DWI image
-    mitk::DiffusionImage<DiffusionPixelType>::Pointer outImage = mitk::DiffusionImage<DiffusionPixelType>::New();
-    outImage->SetVectorImage( filter->GetOutput() );
-    outImage->SetReferenceBValue( m_Controls->m_targetBValueSpinBox->value() );
-    outImage->SetDirections( filter->GetTargetGradientDirections() );
-    outImage->InitializeFromVectorImage();
-
-    imageNode = mitk::DataNode::New();
-    imageNode->SetData( outImage );
-    imageNode->SetName(imageName.toStdString().c_str());
-    GetDefaultDataStorage()->Add(imageNode, parent);
-
-    //  if(m_Controls->m_OutputRMSErrorImage->isChecked()){
-    //    // create new Error image
-    //    FilterType::ErrorImageType::Pointer errImage = filter->GetErrorImage();
-    //    mitk::Image::Pointer mitkErrImage = mitk::Image::New();
-    //    mitkErrImage->InitializeByItk<FilterType::ErrorImageType>(errImage);
-    //    mitkErrImage->SetVolume(errImage->GetBufferPointer());
-
-    //    imageNode = mitk::DataNode::New();
-    //    imageNode->SetData( mitkErrImage );
-    //    imageNode->SetName((imageName+"_Error").toStdString().c_str());
-    //    GetDefaultDataStorage()->Add(imageNode);
-    //  }
+    const double targetBValue = m_Controls->m_targetBValueSpinBox->value();
+    functor->setListOfBValues(bValueList);
+    functor->setTargetBValue(targetBValue);
+    CallMultishellToSingleShellFilter(functor,inImage,name + "_BiExp", m_SelectedDiffusionNodes.at(i));
+  }
 }
 
-void QmitkPreprocessingView::DoBiExpFit()
+void QmitkPreprocessingView::DoAKCFit()
 {
-    itk::BiExpFitFunctor::Pointer functor = itk::BiExpFitFunctor::New();
+  itk::KurtosisFitFunctor::Pointer functor = itk::KurtosisFitFunctor::New();
 
-    for (unsigned int i=0; i<m_SelectedDiffusionNodes.size(); i++)
-    {
-        mitk::DiffusionImage<DiffusionPixelType>::Pointer inImage =
-                dynamic_cast< mitk::DiffusionImage<DiffusionPixelType>* >(m_SelectedDiffusionNodes.at(i)->GetData());
-
-        QString name(m_SelectedDiffusionNodes.at(i)->GetName().c_str());
-
-        const mitk::DiffusionImage<DiffusionPixelType>::BValueMap & originalShellMap = inImage->GetBValueMap();
-        mitk::DiffusionImage<DiffusionPixelType>::BValueMap::const_iterator it = originalShellMap.begin();
-        ++it;/* skip b=0*/ unsigned int s = 0; /*shell index */
-        vnl_vector<double> bValueList(originalShellMap.size()-1);
-        while(it != originalShellMap.end())
-            bValueList.put(s++,(it++)->first);
-
-        const double targetBValue = m_Controls->m_targetBValueSpinBox->value();
-        functor->setListOfBValues(bValueList);
-        functor->setTargetBValue(targetBValue);
-        CallMultishellToSingleShellFilter(functor,inImage,name + "_BiExp", m_SelectedDiffusionNodes.at(i));
-    }
-}
+  for (unsigned int i=0; i<m_SelectedDiffusionNodes.size(); i++)
+  {
+    mitk::Image::Pointer inImage =
+        dynamic_cast< mitk::Image* >(m_SelectedDiffusionNodes.at(i)->GetData());
 
-void QmitkPreprocessingView::DoAKCFit()
-{
-    itk::KurtosisFitFunctor::Pointer functor = itk::KurtosisFitFunctor::New();
+    QString name(m_SelectedDiffusionNodes.at(i)->GetName().c_str());
 
-    for (unsigned int i=0; i<m_SelectedDiffusionNodes.size(); i++)
-    {
-        mitk::DiffusionImage<DiffusionPixelType>::Pointer inImage =
-                dynamic_cast< mitk::DiffusionImage<DiffusionPixelType>* >(m_SelectedDiffusionNodes.at(i)->GetData());
-
-        QString name(m_SelectedDiffusionNodes.at(i)->GetName().c_str());
-
-        const mitk::DiffusionImage<DiffusionPixelType>::BValueMap & originalShellMap = inImage->GetBValueMap();
-        mitk::DiffusionImage<DiffusionPixelType>::BValueMap::const_iterator it = originalShellMap.begin();
-        ++it;/* skip b=0*/ unsigned int s = 0; /*shell index */
-        vnl_vector<double> bValueList(originalShellMap.size()-1);
-        while(it != originalShellMap.end())
-            bValueList.put(s++,(it++)->first);
-
-        const double targetBValue = m_Controls->m_targetBValueSpinBox->value();
-        functor->setListOfBValues(bValueList);
-        functor->setTargetBValue(targetBValue);
-        CallMultishellToSingleShellFilter(functor,inImage,name + "_AKC", m_SelectedDiffusionNodes.at(i));
-    }
+    const mitk::BValueMapProperty::BValueMap
+        &originalShellMap  = static_cast<mitk::BValueMapProperty*>(inImage->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )->GetBValueMap();
+
+    mitk::BValueMapProperty::BValueMap::const_iterator it = originalShellMap.begin();
+    ++it;/* skip b=0*/ unsigned int s = 0; /*shell index */
+    vnl_vector<double> bValueList(originalShellMap.size()-1);
+    while(it != originalShellMap.end())
+      bValueList.put(s++,(it++)->first);
+
+    const double targetBValue = m_Controls->m_targetBValueSpinBox->value();
+    functor->setListOfBValues(bValueList);
+    functor->setTargetBValue(targetBValue);
+    CallMultishellToSingleShellFilter(functor,inImage,name + "_AKC", m_SelectedDiffusionNodes.at(i));
+  }
 }
 
 void QmitkPreprocessingView::DoADCFit()
 {
-    // later
+  // later
 }
 
 void QmitkPreprocessingView::DoADCAverage()
 {
-    itk::ADCAverageFunctor::Pointer functor = itk::ADCAverageFunctor::New();
+  itk::ADCAverageFunctor::Pointer functor = itk::ADCAverageFunctor::New();
 
-    for (unsigned int i=0; i<m_SelectedDiffusionNodes.size(); i++)
-    {
-        mitk::DiffusionImage<DiffusionPixelType>::Pointer inImage =
-                dynamic_cast< mitk::DiffusionImage<DiffusionPixelType>* >(m_SelectedDiffusionNodes.at(i)->GetData());
-
-        QString name(m_SelectedDiffusionNodes.at(i)->GetName().c_str());
-
-        const mitk::DiffusionImage<DiffusionPixelType>::BValueMap & originalShellMap = inImage->GetBValueMap();
-        mitk::DiffusionImage<DiffusionPixelType>::BValueMap::const_iterator it = originalShellMap.begin();
-        ++it;/* skip b=0*/ unsigned int s = 0; /*shell index */
-        vnl_vector<double> bValueList(originalShellMap.size()-1);
-        while(it != originalShellMap.end())
-            bValueList.put(s++,(it++)->first);
-
-        const double targetBValue = m_Controls->m_targetBValueSpinBox->value();
-        functor->setListOfBValues(bValueList);
-        functor->setTargetBValue(targetBValue);
-        CallMultishellToSingleShellFilter(functor,inImage,name + "_ADC", m_SelectedDiffusionNodes.at(i));
-    }
+  for (unsigned int i=0; i<m_SelectedDiffusionNodes.size(); i++)
+  {
+    mitk::Image::Pointer inImage =
+        dynamic_cast< mitk::Image* >(m_SelectedDiffusionNodes.at(i)->GetData());
+
+    QString name(m_SelectedDiffusionNodes.at(i)->GetName().c_str());
+
+    const mitk::BValueMapProperty::BValueMap
+        &originalShellMap  = static_cast<mitk::BValueMapProperty*>(inImage->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )->GetBValueMap();
+
+    mitk::BValueMapProperty::BValueMap::const_iterator it = originalShellMap.begin();
+    ++it;/* skip b=0*/ unsigned int s = 0; /*shell index */
+    vnl_vector<double> bValueList(originalShellMap.size()-1);
+    while(it != originalShellMap.end())
+      bValueList.put(s++,(it++)->first);
+
+    const double targetBValue = m_Controls->m_targetBValueSpinBox->value();
+    functor->setListOfBValues(bValueList);
+    functor->setTargetBValue(targetBValue);
+    CallMultishellToSingleShellFilter(functor,inImage,name + "_ADC", m_SelectedDiffusionNodes.at(i));
+  }
 }
 
 void QmitkPreprocessingView::DoAdcCalculation()
 {
-    if (m_DiffusionImage.IsNull())
-        return;
+  bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_SelectedImageNode->GetData())) );
+  if ( ! isDiffusionImage )
+    return;
 
-    typedef mitk::DiffusionImage< DiffusionPixelType >            DiffusionImageType;
-    typedef itk::AdcImageFilter< DiffusionPixelType, double >     FilterType;
+  typedef itk::AdcImageFilter< DiffusionPixelType, double >     FilterType;
 
 
-    for (unsigned int i=0; i<m_SelectedDiffusionNodes.size(); i++)
-    {
-        DiffusionImageType::Pointer inImage = dynamic_cast< DiffusionImageType* >(m_SelectedDiffusionNodes.at(i)->GetData());
-        FilterType::Pointer filter = FilterType::New();
-        filter->SetInput(inImage->GetVectorImage());
-        filter->SetGradientDirections(inImage->GetDirections());
-        filter->SetB_value(inImage->GetReferenceBValue());
-        filter->Update();
-
-        mitk::Image::Pointer image = mitk::Image::New();
-        image->InitializeByItk( filter->GetOutput() );
-        image->SetVolume( filter->GetOutput()->GetBufferPointer() );
-        mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
-        imageNode->SetData( image );
-        QString name = m_SelectedDiffusionNodes.at(i)->GetName().c_str();
-
-        imageNode->SetName((name+"_ADC").toStdString().c_str());
-        GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.at(i));
-    }
+  for (unsigned int i=0; i<m_SelectedDiffusionNodes.size(); i++)
+  {
+    mitk::Image::Pointer inImage = dynamic_cast< mitk::Image* >(m_SelectedDiffusionNodes.at(i)->GetData());
+    ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+    mitk::CastToItkImage(inImage, itkVectorImagePointer);
+    FilterType::Pointer filter = FilterType::New();
+    filter->SetInput( itkVectorImagePointer );
+    filter->SetGradientDirections( static_cast<mitk::GradientDirectionsProperty*>( inImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() );
+    filter->SetB_value( static_cast<mitk::FloatProperty*>(inImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
+    filter->Update();
+
+    mitk::Image::Pointer image = mitk::Image::New();
+    image->InitializeByItk( filter->GetOutput() );
+    image->SetVolume( filter->GetOutput()->GetBufferPointer() );
+    mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+    imageNode->SetData( image );
+    QString name = m_SelectedDiffusionNodes.at(i)->GetName().c_str();
+
+    imageNode->SetName((name+"_ADC").toStdString().c_str());
+    GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.at(i));
+  }
 }
 
 
 void QmitkPreprocessingView::UpdateBValueTableWidget(int i)
 {
-    if (m_DiffusionImage.IsNull())
+  bool isDiffusionImage(false);
+  if( m_SelectedImageNode && m_SelectedImageNode.IsNotNull() )
+  {
+    isDiffusionImage = mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_SelectedImageNode->GetData()));
+  }
+
+  if ( ! isDiffusionImage )
+  {
+    m_Controls->m_B_ValueMap_TableWidget->clear();
+    m_Controls->m_B_ValueMap_TableWidget->setRowCount(1);
+    QStringList headerList;
+    headerList << "b-Value" << "Number of gradients";
+    m_Controls->m_B_ValueMap_TableWidget->setHorizontalHeaderLabels(headerList);
+    m_Controls->m_B_ValueMap_TableWidget->setItem(0,0,new QTableWidgetItem("-"));
+    m_Controls->m_B_ValueMap_TableWidget->setItem(0,1,new QTableWidgetItem("-"));
+  }else{
+
+    typedef mitk::BValueMapProperty::BValueMap BValueMap;
+    typedef mitk::BValueMapProperty::BValueMap::iterator BValueMapIterator;
+
+    BValueMapIterator it;
+
+    BValueMap roundedBValueMap = static_cast<mitk::BValueMapProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )->GetBValueMap();
+
+    m_Controls->m_B_ValueMap_TableWidget->clear();
+    m_Controls->m_B_ValueMap_TableWidget->setRowCount(roundedBValueMap.size() );
+    QStringList headerList;
+    headerList << "b-Value" << "Number of gradients";
+    m_Controls->m_B_ValueMap_TableWidget->setHorizontalHeaderLabels(headerList);
+
+    int i = 0 ;
+    for(it = roundedBValueMap.begin() ;it != roundedBValueMap.end(); it++)
     {
-        m_Controls->m_B_ValueMap_TableWidget->clear();
-        m_Controls->m_B_ValueMap_TableWidget->setRowCount(1);
-        QStringList headerList;
-        headerList << "b-Value" << "Number of gradients";
-        m_Controls->m_B_ValueMap_TableWidget->setHorizontalHeaderLabels(headerList);
-        m_Controls->m_B_ValueMap_TableWidget->setItem(0,0,new QTableWidgetItem("-"));
-        m_Controls->m_B_ValueMap_TableWidget->setItem(0,1,new QTableWidgetItem("-"));
-    }else{
-
-        typedef mitk::DiffusionImage<short>::BValueMap BValueMap;
-        typedef mitk::DiffusionImage<short>::BValueMap::iterator BValueMapIterator;
-
-        BValueMapIterator it;
-
-        BValueMap roundedBValueMap = m_DiffusionImage->GetBValueMap();
-
-        m_Controls->m_B_ValueMap_TableWidget->clear();
-        m_Controls->m_B_ValueMap_TableWidget->setRowCount(roundedBValueMap.size() );
-        QStringList headerList;
-        headerList << "b-Value" << "Number of gradients";
-        m_Controls->m_B_ValueMap_TableWidget->setHorizontalHeaderLabels(headerList);
-
-        int i = 0 ;
-        for(it = roundedBValueMap.begin() ;it != roundedBValueMap.end(); it++)
-        {
-            m_Controls->m_B_ValueMap_TableWidget->setItem(i,0,new QTableWidgetItem(QString::number(it->first)));
-            QTableWidgetItem* item = m_Controls->m_B_ValueMap_TableWidget->item(i,0);
-            item->setFlags(item->flags() & ~Qt::ItemIsEditable);
-            m_Controls->m_B_ValueMap_TableWidget->setItem(i,1,new QTableWidgetItem(QString::number(it->second.size())));
-            i++;
-        }
+      m_Controls->m_B_ValueMap_TableWidget->setItem(i,0,new QTableWidgetItem(QString::number(it->first)));
+      QTableWidgetItem* item = m_Controls->m_B_ValueMap_TableWidget->item(i,0);
+      item->setFlags(item->flags() & ~Qt::ItemIsEditable);
+      m_Controls->m_B_ValueMap_TableWidget->setItem(i,1,new QTableWidgetItem(QString::number(it->second.size())));
+      i++;
     }
+  }
 
 }
 
 
 template < typename TPixel, unsigned int VImageDimension >
 void QmitkPreprocessingView::TemplatedUpdateGui( itk::Image<TPixel, VImageDimension>* itkImage)
 {
-    for (int r=0; r<3; r++)
-        for (int c=0; c<3; c++)
-        {
-            QTableWidgetItem* item = m_Controls->m_DirectionMatrixTable->item(r,c);
-            delete item;
-            item = new QTableWidgetItem();
-            item->setTextAlignment(Qt::AlignCenter | Qt::AlignVCenter);
-            item->setText(QString::number(itkImage->GetDirection()[r][c]));
-            m_Controls->m_DirectionMatrixTable->setItem(r,c,item);
-        }
+  for (int r=0; r<3; r++)
+    for (int c=0; c<3; c++)
+    {
+      QTableWidgetItem* item = m_Controls->m_DirectionMatrixTable->item(r,c);
+      delete item;
+      item = new QTableWidgetItem();
+      item->setTextAlignment(Qt::AlignCenter | Qt::AlignVCenter);
+      item->setText(QString::number(itkImage->GetDirection()[r][c]));
+      m_Controls->m_DirectionMatrixTable->setItem(r,c,item);
+    }
 }
 
 void QmitkPreprocessingView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
-    bool foundDwiVolume = false;
-    bool foundImageVolume = false;
-    m_DiffusionImage = NULL;
-    m_SelectedImage = NULL;
-    m_SelectedImageNode = NULL;
-    m_SelectedDiffusionNodes.clear();
-
-    // iterate selection
-    for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
+  bool foundDwiVolume = false;
+  bool foundImageVolume = false;
+  m_SelectedImage = NULL;
+  m_SelectedImageNode = NULL;
+  m_SelectedDiffusionNodes.clear();
+
+  // iterate selection
+  for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
+  {
+    mitk::DataNode::Pointer node = *it;
+
+    if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
     {
-        mitk::DataNode::Pointer node = *it;
+      foundImageVolume = true;
+      m_SelectedImage = dynamic_cast<mitk::Image*>(node->GetData());
+      m_Controls->m_DiffusionImageLabel->setText(node->GetName().c_str());
+      m_SelectedImageNode = node;
+
+      bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_SelectedImageNode->GetData())) );
+      if( isDiffusionImage )
+      {
+        foundDwiVolume = true;
+        m_SelectedDiffusionNodes.push_back(node);
+      }
+    }
+  }
+
+  m_Controls->m_ButtonAverageGradients->setEnabled(foundDwiVolume);
+  m_Controls->m_ButtonExtractB0->setEnabled(foundDwiVolume);
+  m_Controls->m_CheckExtractAll->setEnabled(foundDwiVolume);
+  m_Controls->m_ModifyMeasurementFrame->setEnabled(foundDwiVolume);
+  m_Controls->m_MeasurementFrameTable->setEnabled(foundDwiVolume);
+  m_Controls->m_ReduceGradientsButton->setEnabled(foundDwiVolume);
+  m_Controls->m_ShowGradientsButton->setEnabled(foundDwiVolume);
+  m_Controls->m_MirrorGradientToHalfSphereButton->setEnabled(foundDwiVolume);
+  m_Controls->m_MergeDwisButton->setEnabled(foundDwiVolume);
+  m_Controls->m_B_ValueMap_Rounder_SpinBox->setEnabled(foundDwiVolume);
+  m_Controls->m_ProjectSignalButton->setEnabled(foundDwiVolume);
+  m_Controls->m_CreateLengthCorrectedDwi->setEnabled(foundDwiVolume);
+  m_Controls->m_CalcAdcButton->setEnabled(foundDwiVolume);
+  m_Controls->m_targetBValueSpinBox->setEnabled(foundDwiVolume);
+  m_Controls->m_NormalizeImageValuesButton->setEnabled(foundDwiVolume);
+  m_Controls->m_DirectionMatrixTable->setEnabled(foundImageVolume);
+  m_Controls->m_ModifyDirection->setEnabled(foundImageVolume);
+  m_Controls->m_ExtractBrainMask->setEnabled(foundImageVolume);
+  m_Controls->m_ResampleImageButton->setEnabled(foundImageVolume);
+  m_Controls->m_ModifySpacingButton->setEnabled(foundImageVolume);
+  m_Controls->m_ModifyOriginButton->setEnabled(foundImageVolume);
+  m_Controls->m_CropImageButton->setEnabled(foundImageVolume);
+  m_Controls->m_RemoveGradientButton->setEnabled(foundDwiVolume);
+  m_Controls->m_ExtractGradientButton->setEnabled(foundDwiVolume);
+
+  // reset sampling frame to 1 and update all ealted components
+  m_Controls->m_B_ValueMap_Rounder_SpinBox->setValue(1);
+
+  UpdateBValueTableWidget(m_Controls->m_B_ValueMap_Rounder_SpinBox->value());
+  DoUpdateInterpolationGui(m_Controls->m_ResampleTypeBox->currentIndex());
+
+  if( m_SelectedImageNode.IsNull() )
+  {
+    return;
+  }
+
+  bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_SelectedImageNode->GetData())) );
+
+  if (foundDwiVolume && isDiffusionImage)
+  {
+    m_Controls->m_InputData->setTitle("Input Data");
+    vnl_matrix_fixed< double, 3, 3 > mf = static_cast<mitk::MeasurementFrameProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )->GetMeasurementFrame();
+    for (int r=0; r<3; r++)
+      for (int c=0; c<3; c++)
+      {
+        // Measurement frame
+        {
+          QTableWidgetItem* item = m_Controls->m_MeasurementFrameTable->item(r,c);
+          delete item;
+          item = new QTableWidgetItem();
+          item->setTextAlignment(Qt::AlignCenter | Qt::AlignVCenter);
+          item->setText(QString::number(mf.get(r,c)));
+          m_Controls->m_MeasurementFrameTable->setItem(r,c,item);
+        }
 
-        if( node.IsNotNull() && dynamic_cast<mitk::DiffusionImage<short>*>(node->GetData()) )
+        // Direction matrix
         {
-            foundDwiVolume = true;
-            foundImageVolume = true;
-            m_DiffusionImage = dynamic_cast<mitk::DiffusionImage<DiffusionPixelType>*>(node->GetData());
-            m_Controls->m_DiffusionImageLabel->setText(node->GetName().c_str());
-            m_SelectedDiffusionNodes.push_back(node);
+          ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+          mitk::CastToItkImage(m_SelectedImage, itkVectorImagePointer);
+
+          QTableWidgetItem* item = m_Controls->m_DirectionMatrixTable->item(r,c);
+          delete item;
+          item = new QTableWidgetItem();
+          item->setTextAlignment(Qt::AlignCenter | Qt::AlignVCenter);
+          item->setText(QString::number(itkVectorImagePointer->GetDirection()[r][c]));
+          m_Controls->m_DirectionMatrixTable->setItem(r,c,item);
         }
-        else if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
+      }
+
+    //calculate target bValue for MultishellToSingleShellfilter
+    const mitk::BValueMapProperty::BValueMap & bValMap = static_cast<mitk::BValueMapProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )->GetBValueMap();
+    mitk::BValueMapProperty::BValueMap::const_iterator it = bValMap.begin();
+    unsigned int targetBVal = 0;
+    while(it != bValMap.end())
+      targetBVal += (it++)->first;
+    targetBVal /= (float)bValMap.size()-1;
+    m_Controls->m_targetBValueSpinBox->setValue(targetBVal);
+
+    m_Controls->m_HeaderSpacingX->setValue(m_SelectedImage->GetGeometry()->GetSpacing()[0]);
+    m_Controls->m_HeaderSpacingY->setValue(m_SelectedImage->GetGeometry()->GetSpacing()[1]);
+    m_Controls->m_HeaderSpacingZ->setValue(m_SelectedImage->GetGeometry()->GetSpacing()[2]);
+    m_Controls->m_HeaderOriginX->setValue(m_SelectedImage->GetGeometry()->GetOrigin()[0]);
+    m_Controls->m_HeaderOriginY->setValue(m_SelectedImage->GetGeometry()->GetOrigin()[1]);
+    m_Controls->m_HeaderOriginZ->setValue(m_SelectedImage->GetGeometry()->GetOrigin()[2]);
+    m_Controls->m_XstartBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(0)-1);
+    m_Controls->m_YstartBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(1)-1);
+    m_Controls->m_ZstartBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(2)-1);
+    m_Controls->m_XendBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(0)-1);
+    m_Controls->m_YendBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(1)-1);
+    m_Controls->m_ZendBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(2)-1);
+    m_Controls->m_RemoveGradientBox->setMaximum(static_cast<mitk::GradientDirectionsProperty*>( m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer()->Size()-1);
+    m_Controls->m_ExtractGradientBox->setMaximum(static_cast<mitk::GradientDirectionsProperty*>( m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer()->Size()-1);
+  }
+  else if (foundImageVolume)
+  {
+    for (int r=0; r<3; r++)
+      for (int c=0; c<3; c++)
+      {
+        QTableWidgetItem* item = m_Controls->m_MeasurementFrameTable->item(r,c);
+        delete item;
+        item = new QTableWidgetItem();
+        m_Controls->m_MeasurementFrameTable->setItem(r,c,item);
+      }
+
+    m_Controls->m_HeaderSpacingX->setValue(m_SelectedImage->GetGeometry()->GetSpacing()[0]);
+    m_Controls->m_HeaderSpacingY->setValue(m_SelectedImage->GetGeometry()->GetSpacing()[1]);
+    m_Controls->m_HeaderSpacingZ->setValue(m_SelectedImage->GetGeometry()->GetSpacing()[2]);
+    m_Controls->m_HeaderOriginX->setValue(m_SelectedImage->GetGeometry()->GetOrigin()[0]);
+    m_Controls->m_HeaderOriginY->setValue(m_SelectedImage->GetGeometry()->GetOrigin()[1]);
+    m_Controls->m_HeaderOriginZ->setValue(m_SelectedImage->GetGeometry()->GetOrigin()[2]);
+    m_Controls->m_XstartBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(0)-1);
+    m_Controls->m_YstartBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(1)-1);
+    m_Controls->m_ZstartBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(2)-1);
+    m_Controls->m_XendBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(0)-1);
+    m_Controls->m_YendBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(1)-1);
+    m_Controls->m_ZendBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(2)-1);
+
+    AccessFixedDimensionByItk(m_SelectedImage, TemplatedUpdateGui,3);
+  }
+  else
+  {
+    for (int r=0; r<3; r++)
+      for (int c=0; c<3; c++)
+      {
         {
-            foundImageVolume = true;
-            m_SelectedImage = dynamic_cast<mitk::Image*>(node->GetData());
-            m_Controls->m_DiffusionImageLabel->setText(node->GetName().c_str());
-            m_SelectedImageNode = node;
+          QTableWidgetItem* item = m_Controls->m_MeasurementFrameTable->item(r,c);
+          delete item;
+          item = new QTableWidgetItem();
+          m_Controls->m_MeasurementFrameTable->setItem(r,c,item);
         }
-    }
+        {
+          QTableWidgetItem* item = m_Controls->m_DirectionMatrixTable->item(r,c);
+          delete item;
+          item = new QTableWidgetItem();
+          m_Controls->m_DirectionMatrixTable->setItem(r,c,item);
+        }
+      }
 
-    m_Controls->m_ButtonAverageGradients->setEnabled(foundDwiVolume);
-    m_Controls->m_ButtonExtractB0->setEnabled(foundDwiVolume);
-    m_Controls->m_CheckExtractAll->setEnabled(foundDwiVolume);
-    m_Controls->m_ModifyMeasurementFrame->setEnabled(foundDwiVolume);
-    m_Controls->m_MeasurementFrameTable->setEnabled(foundDwiVolume);
-    m_Controls->m_ReduceGradientsButton->setEnabled(foundDwiVolume);
-    m_Controls->m_ShowGradientsButton->setEnabled(foundDwiVolume);
-    m_Controls->m_MirrorGradientToHalfSphereButton->setEnabled(foundDwiVolume);
-    m_Controls->m_MergeDwisButton->setEnabled(foundDwiVolume);
-    m_Controls->m_B_ValueMap_Rounder_SpinBox->setEnabled(foundDwiVolume);
-    m_Controls->m_ProjectSignalButton->setEnabled(foundDwiVolume);
-    m_Controls->m_CreateLengthCorrectedDwi->setEnabled(foundDwiVolume);
-    m_Controls->m_CalcAdcButton->setEnabled(foundDwiVolume);
-    m_Controls->m_targetBValueSpinBox->setEnabled(foundDwiVolume);
-    m_Controls->m_NormalizeImageValuesButton->setEnabled(foundDwiVolume);
-    m_Controls->m_DirectionMatrixTable->setEnabled(foundImageVolume);
-    m_Controls->m_ModifyDirection->setEnabled(foundImageVolume);
-    m_Controls->m_ExtractBrainMask->setEnabled(foundImageVolume);
-    m_Controls->m_ResampleImageButton->setEnabled(foundImageVolume);
-    m_Controls->m_ModifySpacingButton->setEnabled(foundImageVolume);
-    m_Controls->m_ModifyOriginButton->setEnabled(foundImageVolume);
-    m_Controls->m_CropImageButton->setEnabled(foundImageVolume);
-    m_Controls->m_RemoveGradientButton->setEnabled(foundDwiVolume);
-    m_Controls->m_ExtractGradientButton->setEnabled(foundDwiVolume);
-
-    // reset sampling frame to 1 and update all ealted components
-    m_Controls->m_B_ValueMap_Rounder_SpinBox->setValue(1);
-
-    UpdateBValueTableWidget(m_Controls->m_B_ValueMap_Rounder_SpinBox->value());
-    DoUpdateInterpolationGui(m_Controls->m_ResampleTypeBox->currentIndex());
-
-    if (foundDwiVolume)
-    {
-        m_Controls->m_InputData->setTitle("Input Data");
-        vnl_matrix_fixed< double, 3, 3 > mf = m_DiffusionImage->GetMeasurementFrame();
-        for (int r=0; r<3; r++)
-            for (int c=0; c<3; c++)
-            {
-                // Measurement frame
-                {
-                    QTableWidgetItem* item = m_Controls->m_MeasurementFrameTable->item(r,c);
-                    delete item;
-                    item = new QTableWidgetItem();
-                    item->setTextAlignment(Qt::AlignCenter | Qt::AlignVCenter);
-                    item->setText(QString::number(mf.get(r,c)));
-                    m_Controls->m_MeasurementFrameTable->setItem(r,c,item);
-                }
-
-                // Direction matrix
-                {
-                    QTableWidgetItem* item = m_Controls->m_DirectionMatrixTable->item(r,c);
-                    delete item;
-                    item = new QTableWidgetItem();
-                    item->setTextAlignment(Qt::AlignCenter | Qt::AlignVCenter);
-                    item->setText(QString::number(m_DiffusionImage->GetVectorImage()->GetDirection()[r][c]));
-                    m_Controls->m_DirectionMatrixTable->setItem(r,c,item);
-                }
-            }
-
-        //calculate target bValue for MultishellToSingleShellfilter
-        const mitk::DiffusionImage<DiffusionPixelType>::BValueMap & bValMap = m_DiffusionImage->GetBValueMap();
-        mitk::DiffusionImage<DiffusionPixelType>::BValueMap::const_iterator it = bValMap.begin();
-        unsigned int targetBVal = 0;
-        while(it != bValMap.end())
-            targetBVal += (it++)->first;
-        targetBVal /= (float)bValMap.size()-1;
-        m_Controls->m_targetBValueSpinBox->setValue(targetBVal);
-
-        m_Controls->m_HeaderSpacingX->setValue(m_DiffusionImage->GetGeometry()->GetSpacing()[0]);
-        m_Controls->m_HeaderSpacingY->setValue(m_DiffusionImage->GetGeometry()->GetSpacing()[1]);
-        m_Controls->m_HeaderSpacingZ->setValue(m_DiffusionImage->GetGeometry()->GetSpacing()[2]);
-        m_Controls->m_HeaderOriginX->setValue(m_DiffusionImage->GetGeometry()->GetOrigin()[0]);
-        m_Controls->m_HeaderOriginY->setValue(m_DiffusionImage->GetGeometry()->GetOrigin()[1]);
-        m_Controls->m_HeaderOriginZ->setValue(m_DiffusionImage->GetGeometry()->GetOrigin()[2]);
-        m_Controls->m_XstartBox->setMaximum(m_DiffusionImage->GetGeometry()->GetExtent(0)-1);
-        m_Controls->m_YstartBox->setMaximum(m_DiffusionImage->GetGeometry()->GetExtent(1)-1);
-        m_Controls->m_ZstartBox->setMaximum(m_DiffusionImage->GetGeometry()->GetExtent(2)-1);
-        m_Controls->m_XendBox->setMaximum(m_DiffusionImage->GetGeometry()->GetExtent(0)-1);
-        m_Controls->m_YendBox->setMaximum(m_DiffusionImage->GetGeometry()->GetExtent(1)-1);
-        m_Controls->m_ZendBox->setMaximum(m_DiffusionImage->GetGeometry()->GetExtent(2)-1);
-        m_Controls->m_RemoveGradientBox->setMaximum(m_DiffusionImage->GetDirections()->Size()-1);
-        m_Controls->m_ExtractGradientBox->setMaximum(m_DiffusionImage->GetDirections()->Size()-1);
-    }
-    else if (foundImageVolume)
-    {
-        for (int r=0; r<3; r++)
-            for (int c=0; c<3; c++)
-            {
-                QTableWidgetItem* item = m_Controls->m_MeasurementFrameTable->item(r,c);
-                delete item;
-                item = new QTableWidgetItem();
-                m_Controls->m_MeasurementFrameTable->setItem(r,c,item);
-            }
-
-        m_Controls->m_HeaderSpacingX->setValue(m_SelectedImage->GetGeometry()->GetSpacing()[0]);
-        m_Controls->m_HeaderSpacingY->setValue(m_SelectedImage->GetGeometry()->GetSpacing()[1]);
-        m_Controls->m_HeaderSpacingZ->setValue(m_SelectedImage->GetGeometry()->GetSpacing()[2]);
-        m_Controls->m_HeaderOriginX->setValue(m_SelectedImage->GetGeometry()->GetOrigin()[0]);
-        m_Controls->m_HeaderOriginY->setValue(m_SelectedImage->GetGeometry()->GetOrigin()[1]);
-        m_Controls->m_HeaderOriginZ->setValue(m_SelectedImage->GetGeometry()->GetOrigin()[2]);
-        m_Controls->m_XstartBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(0)-1);
-        m_Controls->m_YstartBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(1)-1);
-        m_Controls->m_ZstartBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(2)-1);
-        m_Controls->m_XendBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(0)-1);
-        m_Controls->m_YendBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(1)-1);
-        m_Controls->m_ZendBox->setMaximum(m_SelectedImage->GetGeometry()->GetExtent(2)-1);
-
-        AccessFixedDimensionByItk(m_SelectedImage, TemplatedUpdateGui,3);
-    }
-    else
-    {
-        for (int r=0; r<3; r++)
-            for (int c=0; c<3; c++)
-            {
-                {
-                    QTableWidgetItem* item = m_Controls->m_MeasurementFrameTable->item(r,c);
-                    delete item;
-                    item = new QTableWidgetItem();
-                    m_Controls->m_MeasurementFrameTable->setItem(r,c,item);
-                }
-                {
-                    QTableWidgetItem* item = m_Controls->m_DirectionMatrixTable->item(r,c);
-                    delete item;
-                    item = new QTableWidgetItem();
-                    m_Controls->m_DirectionMatrixTable->setItem(r,c,item);
-                }
-            }
-
-        m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
-        m_Controls->m_InputData->setTitle("Please Select Input Data");
-    }
+    m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
+    m_Controls->m_InputData->setTitle("Please Select Input Data");
+  }
 }
 
 void QmitkPreprocessingView::Activated()
 {
-    QmitkFunctionality::Activated();
+  QmitkFunctionality::Activated();
 }
 
 void QmitkPreprocessingView::Deactivated()
 {
-    QmitkFunctionality::Deactivated();
+  QmitkFunctionality::Deactivated();
 }
 
 void QmitkPreprocessingView::DoHalfSphereGradientDirections()
 {
 
-    MitkDwiType::Pointer newDwi = m_DiffusionImage->Clone();
-    GradientDirectionContainerType::Pointer gradientContainer = newDwi->GetDirections();
+  mitk::Image::Pointer newDwi = m_SelectedImage->Clone();
+  GradientDirectionContainerType::Pointer gradientContainer =   static_cast<mitk::GradientDirectionsProperty*>( newDwi->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
 
-    for (unsigned int j=0; j<gradientContainer->Size(); j++)
-        if (gradientContainer->at(j)[0]<0)
-            gradientContainer->at(j) = -gradientContainer->at(j);
+  for (unsigned int j=0; j<gradientContainer->Size(); j++)
+    if (gradientContainer->at(j)[0]<0)
+      gradientContainer->at(j) = -gradientContainer->at(j);
 
-    newDwi->SetDirections(gradientContainer);
+  newDwi->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( gradientContainer ) );
+  mitk::DiffusionPropertyHelper propertyHelper( newDwi );
+  propertyHelper.InitializeImage();
 
-    mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
-    imageNode->SetData( newDwi );
-    QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
-    imageNode->SetName((name+"_halfsphere").toStdString().c_str());
-    GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
+  mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+  imageNode->SetData( newDwi );
+  QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
+  imageNode->SetName((name+"_halfsphere").toStdString().c_str());
+  GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
 }
 
 void QmitkPreprocessingView::DoApplyMesurementFrame()
 {
-    if (m_DiffusionImage.IsNull())
-        return;
+  bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_SelectedImageNode->GetData())) );
+  if ( !isDiffusionImage )
+    return;
 
-    vnl_matrix_fixed< double, 3, 3 > mf;
-    for (int r=0; r<3; r++)
-        for (int c=0; c<3; c++)
-        {
-            QTableWidgetItem* item = m_Controls->m_MeasurementFrameTable->item(r,c);
-            if (!item)
-                return;
-            mf[r][c] = item->text().toDouble();
-        }
+  vnl_matrix_fixed< double, 3, 3 > mf;
+  for (int r=0; r<3; r++)
+    for (int c=0; c<3; c++)
+    {
+      QTableWidgetItem* item = m_Controls->m_MeasurementFrameTable->item(r,c);
+      if (!item)
+        return;
+      mf[r][c] = item->text().toDouble();
+    }
 
-    MitkDwiType::Pointer newDwi = m_DiffusionImage->Clone();
-    newDwi->SetMeasurementFrame(mf);
+  mitk::Image::Pointer newDwi = m_SelectedImage->Clone();
+  newDwi->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( mf ) );
+  mitk::DiffusionPropertyHelper propertyHelper( newDwi );
+  propertyHelper.InitializeImage();
 
-    mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
-    imageNode->SetData( newDwi );
-    QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
-    imageNode->SetName((name+"_new-MF").toStdString().c_str());
-    GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
+  mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+  imageNode->SetData( newDwi );
+  QString name = m_SelectedDiffusionNodes.back()->GetName().c_str();
+  imageNode->SetName((name+"_new-MF").toStdString().c_str());
+  GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
 }
 
 void QmitkPreprocessingView::DoShowGradientDirections()
 {
-    if (m_DiffusionImage.IsNull())
-        return;
-
-    int maxIndex = 0;
-    unsigned int maxSize = m_DiffusionImage->GetDimension(0);
-    if (maxSize<m_DiffusionImage->GetDimension(1))
+  bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_SelectedImageNode->GetData())) );
+  if ( !isDiffusionImage )
+    return;
+
+  int maxIndex = 0;
+  unsigned int maxSize = m_SelectedImage->GetDimension(0);
+  if (maxSize<m_SelectedImage->GetDimension(1))
+  {
+    maxSize = m_SelectedImage->GetDimension(1);
+    maxIndex = 1;
+  }
+  if (maxSize<m_SelectedImage->GetDimension(2))
+  {
+    maxSize = m_SelectedImage->GetDimension(2);
+    maxIndex = 2;
+  }
+
+  mitk::Point3D origin = m_SelectedImage->GetGeometry()->GetOrigin();
+  mitk::PointSet::Pointer originSet = mitk::PointSet::New();
+
+  typedef mitk::BValueMapProperty::BValueMap BValueMap;
+  typedef mitk::BValueMapProperty::BValueMap::iterator BValueMapIterator;
+  BValueMap bValMap =  static_cast<mitk::BValueMapProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )->GetBValueMap();
+
+  GradientDirectionContainerType::Pointer gradientContainer = static_cast<mitk::GradientDirectionsProperty*>( m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
+  mitk::BaseGeometry::Pointer geometry = m_SelectedImage->GetGeometry();
+  int shellCount = 1;
+  for(BValueMapIterator it = bValMap.begin(); it!=bValMap.end(); ++it)
+  {
+    mitk::PointSet::Pointer pointset = mitk::PointSet::New();
+    for (unsigned int j=0; j<it->second.size(); j++)
     {
-        maxSize = m_DiffusionImage->GetDimension(1);
-        maxIndex = 1;
-    }
-    if (maxSize<m_DiffusionImage->GetDimension(2))
-    {
-        maxSize = m_DiffusionImage->GetDimension(2);
-        maxIndex = 2;
-    }
-
-    mitk::Point3D origin = m_DiffusionImage->GetGeometry()->GetOrigin();
-    mitk::PointSet::Pointer originSet = mitk::PointSet::New();
-
-    typedef mitk::DiffusionImage<short>::BValueMap BValueMap;
-    typedef mitk::DiffusionImage<short>::BValueMap::iterator BValueMapIterator;
-    BValueMap bValMap =  m_DiffusionImage->GetBValueMap();
-
-    GradientDirectionContainerType::Pointer gradientContainer = m_DiffusionImage->GetDirections();
-    mitk::BaseGeometry::Pointer geometry = m_DiffusionImage->GetGeometry();
-    int shellCount = 1;
-    for(BValueMapIterator it = bValMap.begin(); it!=bValMap.end(); ++it)
-    {
-        mitk::PointSet::Pointer pointset = mitk::PointSet::New();
-        for (unsigned int j=0; j<it->second.size(); j++)
-        {
-            mitk::Point3D ip;
-            vnl_vector_fixed< double, 3 > v = gradientContainer->at(it->second[j]);
-            if (v.magnitude()>mitk::eps)
-            {
-                ip[0] = v[0]*maxSize*geometry->GetSpacing()[maxIndex]/2 + origin[0]-0.5*geometry->GetSpacing()[0] + geometry->GetSpacing()[0]*m_DiffusionImage->GetDimension(0)/2;
-                ip[1] = v[1]*maxSize*geometry->GetSpacing()[maxIndex]/2 + origin[1]-0.5*geometry->GetSpacing()[1] + geometry->GetSpacing()[1]*m_DiffusionImage->GetDimension(1)/2;
-                ip[2] = v[2]*maxSize*geometry->GetSpacing()[maxIndex]/2 + origin[2]-0.5*geometry->GetSpacing()[2] + geometry->GetSpacing()[2]*m_DiffusionImage->GetDimension(2)/2;
-
-                pointset->InsertPoint(j, ip);
-            }
-            else if (originSet->IsEmpty())
-            {
-                ip[0] = v[0]*maxSize*geometry->GetSpacing()[maxIndex]/2 + origin[0]-0.5*geometry->GetSpacing()[0] + geometry->GetSpacing()[0]*m_DiffusionImage->GetDimension(0)/2;
-                ip[1] = v[1]*maxSize*geometry->GetSpacing()[maxIndex]/2 + origin[1]-0.5*geometry->GetSpacing()[1] + geometry->GetSpacing()[1]*m_DiffusionImage->GetDimension(1)/2;
-                ip[2] = v[2]*maxSize*geometry->GetSpacing()[maxIndex]/2 + origin[2]-0.5*geometry->GetSpacing()[2] + geometry->GetSpacing()[2]*m_DiffusionImage->GetDimension(2)/2;
-
-                originSet->InsertPoint(j, ip);
-            }
-        }
-        if (it->first<mitk::eps)
-            continue;
-
-        // add shell to datastorage
-        mitk::DataNode::Pointer node = mitk::DataNode::New();
-        node->SetData(pointset);
-        QString name = m_SelectedDiffusionNodes.front()->GetName().c_str();
-        name += "_Shell_";
-        name += QString::number(it->first);
-        node->SetName(name.toStdString().c_str());
-        node->SetProperty("pointsize", mitk::FloatProperty::New((float)maxSize/50));
-        int b0 = shellCount%2;
-        int b1 = 0;
-        int b2 = 0;
-        if (shellCount>4)
-            b2 = 1;
-        if (shellCount%4 >= 2)
-            b1 = 1;
-
-        node->SetProperty("color", mitk::ColorProperty::New(b2, b1, b0));
-        GetDefaultDataStorage()->Add(node, m_SelectedDiffusionNodes.front());
-        shellCount++;
+      mitk::Point3D ip;
+      vnl_vector_fixed< double, 3 > v = gradientContainer->at(it->second[j]);
+      if (v.magnitude()>mitk::eps)
+      {
+        ip[0] = v[0]*maxSize*geometry->GetSpacing()[maxIndex]/2 + origin[0]-0.5*geometry->GetSpacing()[0] + geometry->GetSpacing()[0]*m_SelectedImage->GetDimension(0)/2;
+        ip[1] = v[1]*maxSize*geometry->GetSpacing()[maxIndex]/2 + origin[1]-0.5*geometry->GetSpacing()[1] + geometry->GetSpacing()[1]*m_SelectedImage->GetDimension(1)/2;
+        ip[2] = v[2]*maxSize*geometry->GetSpacing()[maxIndex]/2 + origin[2]-0.5*geometry->GetSpacing()[2] + geometry->GetSpacing()[2]*m_SelectedImage->GetDimension(2)/2;
+
+        pointset->InsertPoint(j, ip);
+      }
+      else if (originSet->IsEmpty())
+      {
+        ip[0] = v[0]*maxSize*geometry->GetSpacing()[maxIndex]/2 + origin[0]-0.5*geometry->GetSpacing()[0] + geometry->GetSpacing()[0]*m_SelectedImage->GetDimension(0)/2;
+        ip[1] = v[1]*maxSize*geometry->GetSpacing()[maxIndex]/2 + origin[1]-0.5*geometry->GetSpacing()[1] + geometry->GetSpacing()[1]*m_SelectedImage->GetDimension(1)/2;
+        ip[2] = v[2]*maxSize*geometry->GetSpacing()[maxIndex]/2 + origin[2]-0.5*geometry->GetSpacing()[2] + geometry->GetSpacing()[2]*m_SelectedImage->GetDimension(2)/2;
+
+        originSet->InsertPoint(j, ip);
+      }
     }
+    if (it->first<mitk::eps)
+      continue;
 
-    // add origin to datastorage
+    // add shell to datastorage
     mitk::DataNode::Pointer node = mitk::DataNode::New();
-    node->SetData(originSet);
+    node->SetData(pointset);
     QString name = m_SelectedDiffusionNodes.front()->GetName().c_str();
-    name += "_Origin";
+    name += "_Shell_";
+    name += QString::number(it->first);
     node->SetName(name.toStdString().c_str());
     node->SetProperty("pointsize", mitk::FloatProperty::New((float)maxSize/50));
-    node->SetProperty("color", mitk::ColorProperty::New(1,1,1));
+    int b0 = shellCount%2;
+    int b1 = 0;
+    int b2 = 0;
+    if (shellCount>4)
+      b2 = 1;
+    if (shellCount%4 >= 2)
+      b1 = 1;
+
+    node->SetProperty("color", mitk::ColorProperty::New(b2, b1, b0));
     GetDefaultDataStorage()->Add(node, m_SelectedDiffusionNodes.front());
+    shellCount++;
+  }
+
+  // add origin to datastorage
+  mitk::DataNode::Pointer node = mitk::DataNode::New();
+  node->SetData(originSet);
+  QString name = m_SelectedDiffusionNodes.front()->GetName().c_str();
+  name += "_Origin";
+  node->SetName(name.toStdString().c_str());
+  node->SetProperty("pointsize", mitk::FloatProperty::New((float)maxSize/50));
+  node->SetProperty("color", mitk::ColorProperty::New(1,1,1));
+  GetDefaultDataStorage()->Add(node, m_SelectedDiffusionNodes.front());
 }
 
 void QmitkPreprocessingView::DoReduceGradientDirections()
 {
-    if (m_DiffusionImage.IsNull())
-        return;
-
-    typedef mitk::DiffusionImage<DiffusionPixelType>              DiffusionImageType;
-    typedef itk::ElectrostaticRepulsionDiffusionGradientReductionFilter<DiffusionPixelType, DiffusionPixelType> FilterType;
-    typedef DiffusionImageType::BValueMap BValueMap;
-
-    // GetShellSelection from GUI
-    BValueMap shellSlectionMap;
-    BValueMap originalShellMap = m_DiffusionImage->GetBValueMap();
-    std::vector<unsigned int> newNumGradientDirections;
-    int shellCounter = 0;
-
-    QString name = m_SelectedDiffusionNodes.front()->GetName().c_str();
-    for (int i=0; i<m_Controls->m_B_ValueMap_TableWidget->rowCount(); i++)
-    {
-        double BValue = m_Controls->m_B_ValueMap_TableWidget->item(i,0)->text().toDouble();
-        shellSlectionMap[BValue] = originalShellMap[BValue];
-        unsigned int num = m_Controls->m_B_ValueMap_TableWidget->item(i,1)->text().toUInt();
-        newNumGradientDirections.push_back(num);
-        name += "_";
-        name += QString::number(num);
-        shellCounter++;
-    }
-
-    if (newNumGradientDirections.empty())
-        return;
-
-    GradientDirectionContainerType::Pointer gradientContainer = m_DiffusionImage->GetDirections();
-    FilterType::Pointer filter = FilterType::New();
-    filter->SetInput(m_DiffusionImage->GetVectorImage());
-    filter->SetOriginalGradientDirections(gradientContainer);
-    filter->SetNumGradientDirections(newNumGradientDirections);
-    filter->SetOriginalBValueMap(originalShellMap);
-    filter->SetShellSelectionBValueMap(shellSlectionMap);
-    filter->Update();
-
-    DiffusionImageType::Pointer image = DiffusionImageType::New();
-    image->SetVectorImage( filter->GetOutput() );
-    image->SetReferenceBValue(m_DiffusionImage->GetReferenceBValue());
-    image->SetDirections(filter->GetGradientDirections());
-    image->SetMeasurementFrame(m_DiffusionImage->GetMeasurementFrame());
-    image->InitializeFromVectorImage();
-
-    mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
-    imageNode->SetData( image );
-
-    imageNode->SetName(name.toStdString().c_str());
-    GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
+  bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_SelectedImageNode->GetData())) );
+  if ( !isDiffusionImage )
+    return;
+
+  typedef itk::ElectrostaticRepulsionDiffusionGradientReductionFilter<DiffusionPixelType, DiffusionPixelType> FilterType;
+  typedef mitk::BValueMapProperty::BValueMap BValueMap;
+
+  // GetShellSelection from GUI
+  BValueMap shellSlectionMap;
+  BValueMap originalShellMap = static_cast<mitk::BValueMapProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )->GetBValueMap();
+  std::vector<unsigned int> newNumGradientDirections;
+  int shellCounter = 0;
+
+  QString name = m_SelectedDiffusionNodes.front()->GetName().c_str();
+  for (int i=0; i<m_Controls->m_B_ValueMap_TableWidget->rowCount(); i++)
+  {
+    double BValue = m_Controls->m_B_ValueMap_TableWidget->item(i,0)->text().toDouble();
+    shellSlectionMap[BValue] = originalShellMap[BValue];
+    unsigned int num = m_Controls->m_B_ValueMap_TableWidget->item(i,1)->text().toUInt();
+    newNumGradientDirections.push_back(num);
+    name += "_";
+    name += QString::number(num);
+    shellCounter++;
+  }
+
+  if (newNumGradientDirections.empty())
+    return;
+
+  GradientDirectionContainerType::Pointer gradientContainer = static_cast<mitk::GradientDirectionsProperty*>( m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
+
+  ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+  mitk::CastToItkImage(m_SelectedImage, itkVectorImagePointer);
+
+  FilterType::Pointer filter = FilterType::New();
+  filter->SetInput( itkVectorImagePointer );
+  filter->SetOriginalGradientDirections(gradientContainer);
+  filter->SetNumGradientDirections(newNumGradientDirections);
+  filter->SetOriginalBValueMap(originalShellMap);
+  filter->SetShellSelectionBValueMap(shellSlectionMap);
+  filter->Update();
+
+  mitk::Image::Pointer image = mitk::GrabItkImageMemory( filter->GetOutput() );
+  image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( filter->GetGradientDirections() ) );
+  image->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( static_cast<mitk::MeasurementFrameProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )->GetMeasurementFrame() ) );
+  image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>(m_SelectedImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() ) );
+  mitk::DiffusionPropertyHelper propertyHelper( image );
+  propertyHelper.InitializeImage();
+
+
+  mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+  imageNode->SetData( image );
+
+  imageNode->SetName(name.toStdString().c_str());
+  GetDefaultDataStorage()->Add(imageNode, m_SelectedDiffusionNodes.back());
 }
 
 void QmitkPreprocessingView::MergeDwis()
 {
-    typedef mitk::DiffusionImage<DiffusionPixelType>              DiffusionImageType;
-    typedef DiffusionImageType::GradientDirectionContainerType    GradientContainerType;
+  typedef mitk::GradientDirectionsProperty::GradientDirectionsContainerType    GradientContainerType;
 
-    if (m_SelectedDiffusionNodes.size()<2)
-        return;
+  if (m_SelectedDiffusionNodes.size()<2)
+    return;
 
-    typedef itk::VectorImage<DiffusionPixelType,3>                  DwiImageType;
-    typedef DwiImageType::PixelType                        DwiPixelType;
-    typedef DwiImageType::RegionType                       DwiRegionType;
-    typedef std::vector< DwiImageType::Pointer >  DwiImageContainerType;
+  typedef itk::VectorImage<DiffusionPixelType,3>                  DwiImageType;
+  typedef DwiImageType::PixelType                        DwiPixelType;
+  typedef DwiImageType::RegionType                       DwiRegionType;
+  typedef std::vector< DwiImageType::Pointer >  DwiImageContainerType;
 
-    typedef std::vector< GradientContainerType::Pointer >  GradientListContainerType;
+  typedef std::vector< GradientContainerType::Pointer >  GradientListContainerType;
 
-    DwiImageContainerType       imageContainer;
-    GradientListContainerType   gradientListContainer;
-    std::vector< double >       bValueContainer;
+  DwiImageContainerType       imageContainer;
+  GradientListContainerType   gradientListContainer;
+  std::vector< double >       bValueContainer;
 
-    QString name = m_SelectedDiffusionNodes.front()->GetName().c_str();
-    for (unsigned int i=0; i<m_SelectedDiffusionNodes.size(); i++)
+  QString name = m_SelectedDiffusionNodes.front()->GetName().c_str();
+  for (unsigned int i=0; i<m_SelectedDiffusionNodes.size(); i++)
+  {
+    mitk::Image::Pointer dwi = dynamic_cast< mitk::Image* >( m_SelectedDiffusionNodes.at(i)->GetData() );
+    if ( dwi.IsNotNull() )
     {
-        DiffusionImageType::Pointer dwi = dynamic_cast< mitk::DiffusionImage<DiffusionPixelType>* >( m_SelectedDiffusionNodes.at(i)->GetData() );
-        if ( dwi.IsNotNull() )
-        {
-            imageContainer.push_back(dwi->GetVectorImage());
-            gradientListContainer.push_back(dwi->GetDirections());
-            bValueContainer.push_back(dwi->GetReferenceBValue());
-            if (i>0)
-            {
-                name += "+";
-                name += m_SelectedDiffusionNodes.at(i)->GetName().c_str();
-            }
-        }
+      ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+      mitk::CastToItkImage(dwi, itkVectorImagePointer);
+
+      imageContainer.push_back( itkVectorImagePointer );
+      gradientListContainer.push_back( static_cast<mitk::GradientDirectionsProperty*>( dwi->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() );
+      bValueContainer.push_back( static_cast<mitk::FloatProperty*>(dwi->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
+      if (i>0)
+      {
+        name += "+";
+        name += m_SelectedDiffusionNodes.at(i)->GetName().c_str();
+      }
     }
-
-    typedef itk::MergeDiffusionImagesFilter<short> FilterType;
-    FilterType::Pointer filter = FilterType::New();
-    filter->SetImageVolumes(imageContainer);
-    filter->SetGradientLists(gradientListContainer);
-    filter->SetBValues(bValueContainer);
-    filter->Update();
-
-    vnl_matrix_fixed< double, 3, 3 > mf; mf.set_identity();
-    DiffusionImageType::Pointer image = DiffusionImageType::New();
-    image->SetVectorImage( filter->GetOutput() );
-    image->SetReferenceBValue(filter->GetB_Value());
-    image->SetDirections(filter->GetOutputGradients());
-    image->SetMeasurementFrame(mf);
-    image->InitializeFromVectorImage();
-
-    mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
-    imageNode->SetData( image );
-    imageNode->SetName(name.toStdString().c_str());
-    GetDefaultDataStorage()->Add(imageNode);
+  }
+
+  typedef itk::MergeDiffusionImagesFilter<short> FilterType;
+  FilterType::Pointer filter = FilterType::New();
+  filter->SetImageVolumes(imageContainer);
+  filter->SetGradientLists(gradientListContainer);
+  filter->SetBValues(bValueContainer);
+  filter->Update();
+
+  vnl_matrix_fixed< double, 3, 3 > mf; mf.set_identity();
+  mitk::Image::Pointer image = mitk::GrabItkImageMemory( filter->GetOutput() );
+
+  image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( filter->GetOutputGradients() ) );
+  image->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( mf ) );
+  image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( filter->GetB_Value() ) );
+  mitk::DiffusionPropertyHelper propertyHelper( image );
+  propertyHelper.InitializeImage();
+
+  mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+  imageNode->SetData( image );
+  imageNode->SetName(name.toStdString().c_str());
+  GetDefaultDataStorage()->Add(imageNode);
 }
 
 void QmitkPreprocessingView::ExtractB0()
 {
-    typedef mitk::DiffusionImage<DiffusionPixelType>              DiffusionImageType;
-    typedef DiffusionImageType::GradientDirectionContainerType    GradientContainerType;
+  typedef mitk::GradientDirectionsProperty::GradientDirectionsContainerType    GradientContainerType;
 
-    int nrFiles = m_SelectedDiffusionNodes.size();
-    if (!nrFiles) return;
+  int nrFiles = m_SelectedDiffusionNodes.size();
+  if (!nrFiles) return;
 
-    // call the extraction withou averaging if the check-box is checked
-    if( this->m_Controls->m_CheckExtractAll->isChecked() )
-    {
-        DoExtractBOWithoutAveraging();
-        return;
-    }
+  // call the extraction withou averaging if the check-box is checked
+  if( this->m_Controls->m_CheckExtractAll->isChecked() )
+  {
+    DoExtractBOWithoutAveraging();
+    return;
+  }
 
-    mitk::DataStorage::SetOfObjects::const_iterator itemiter( m_SelectedDiffusionNodes.begin() );
-    mitk::DataStorage::SetOfObjects::const_iterator itemiterend( m_SelectedDiffusionNodes.end() );
+  mitk::DataStorage::SetOfObjects::const_iterator itemiter( m_SelectedDiffusionNodes.begin() );
+  mitk::DataStorage::SetOfObjects::const_iterator itemiterend( m_SelectedDiffusionNodes.end() );
 
-    std::vector<mitk::DataNode::Pointer> nodes;
-    while ( itemiter != itemiterend ) // for all items
-    {
+  std::vector<mitk::DataNode::Pointer> nodes;
+  while ( itemiter != itemiterend ) // for all items
+  {
 
-        DiffusionImageType* vols =
-                static_cast<DiffusionImageType*>(
-                    (*itemiter)->GetData());
+    mitk::Image* vols =
+        static_cast<mitk::Image*>(
+          (*itemiter)->GetData());
 
-        std::string nodename;
-        (*itemiter)->GetStringProperty("name", nodename);
+    std::string nodename;
+    (*itemiter)->GetStringProperty("name", nodename);
 
-        // Extract image using found index
-        typedef itk::B0ImageExtractionImageFilter<short, short> FilterType;
-        FilterType::Pointer filter = FilterType::New();
-        filter->SetInput(vols->GetVectorImage());
-        filter->SetDirections(vols->GetDirections());
-        filter->Update();
+    ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+    mitk::CastToItkImage(vols, itkVectorImagePointer);
 
-        mitk::Image::Pointer mitkImage = mitk::Image::New();
-        mitkImage->InitializeByItk( filter->GetOutput() );
-        mitkImage->SetVolume( filter->GetOutput()->GetBufferPointer() );
-        mitk::DataNode::Pointer node=mitk::DataNode::New();
-        node->SetData( mitkImage );
-        node->SetProperty( "name", mitk::StringProperty::New(nodename + "_B0"));
+    // Extract image using found index
+    typedef itk::B0ImageExtractionImageFilter<short, short> FilterType;
+    FilterType::Pointer filter = FilterType::New();
+    filter->SetInput( itkVectorImagePointer );
+    filter->SetDirections( static_cast<mitk::GradientDirectionsProperty*>( vols->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() );
+    filter->Update();
 
-        GetDefaultDataStorage()->Add(node, (*itemiter));
+    mitk::Image::Pointer mitkImage = mitk::Image::New();
+    mitkImage->InitializeByItk( filter->GetOutput() );
+    mitkImage->SetVolume( filter->GetOutput()->GetBufferPointer() );
+    mitk::DataNode::Pointer node=mitk::DataNode::New();
+    node->SetData( mitkImage );
+    node->SetProperty( "name", mitk::StringProperty::New(nodename + "_B0"));
 
-        ++itemiter;
-    }
+    GetDefaultDataStorage()->Add(node, (*itemiter));
+
+    ++itemiter;
+  }
 }
 
 void QmitkPreprocessingView::DoExtractBOWithoutAveraging()
 {
-    // typedefs
-    typedef mitk::DiffusionImage<DiffusionPixelType>              DiffusionImageType;
-    typedef DiffusionImageType::GradientDirectionContainerType    GradientContainerType;
-    typedef itk::B0ImageExtractionToSeparateImageFilter< short, short> FilterType;
-
-    // check number of selected objects, return if empty
-    int nrFiles = m_SelectedDiffusionNodes.size();
-    if (!nrFiles)
-        return;
+  // typedefs
+  typedef mitk::GradientDirectionsProperty::GradientDirectionsContainerType    GradientContainerType;
+  typedef itk::B0ImageExtractionToSeparateImageFilter< short, short> FilterType;
 
-    mitk::DataStorage::SetOfObjects::const_iterator itemiter( m_SelectedDiffusionNodes.begin() );
-    mitk::DataStorage::SetOfObjects::const_iterator itemiterend( m_SelectedDiffusionNodes.end() );
+  // check number of selected objects, return if empty
+  int nrFiles = m_SelectedDiffusionNodes.size();
+  if (!nrFiles)
+    return;
 
-    while ( itemiter != itemiterend ) // for all items
-    {
-        DiffusionImageType* vols =
-                static_cast<DiffusionImageType*>(
-                    (*itemiter)->GetData());
+  mitk::DataStorage::SetOfObjects::const_iterator itemiter( m_SelectedDiffusionNodes.begin() );
+  mitk::DataStorage::SetOfObjects::const_iterator itemiterend( m_SelectedDiffusionNodes.end() );
+
+  while ( itemiter != itemiterend ) // for all items
+  {
+    mitk::Image* vols =
+        static_cast<mitk::Image*>(
+          (*itemiter)->GetData());
+
+    std::string nodename;
+    (*itemiter)->GetStringProperty("name", nodename);
 
-        std::string nodename;
-        (*itemiter)->GetStringProperty("name", nodename);
+    ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
+    mitk::CastToItkImage(vols, itkVectorImagePointer);
 
-        // Extract image using found index
-        FilterType::Pointer filter = FilterType::New();
-        filter->SetInput(vols->GetVectorImage());
-        filter->SetDirections(vols->GetDirections());
-        filter->Update();
+    // Extract image using found index
+    FilterType::Pointer filter = FilterType::New();
+    filter->SetInput( itkVectorImagePointer );
+    filter->SetDirections( static_cast<mitk::GradientDirectionsProperty*>( vols->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() );
+    filter->Update();
 
-        mitk::Image::Pointer mitkImage = mitk::Image::New();
-        mitkImage->InitializeByItk( filter->GetOutput() );
-        mitkImage->SetImportChannel( filter->GetOutput()->GetBufferPointer() );
-        mitk::DataNode::Pointer node=mitk::DataNode::New();
-        node->SetData( mitkImage );
-        node->SetProperty( "name", mitk::StringProperty::New(nodename + "_B0_ALL"));
+    mitk::Image::Pointer mitkImage = mitk::Image::New();
+    mitkImage->InitializeByItk( filter->GetOutput() );
+    mitkImage->SetImportChannel( filter->GetOutput()->GetBufferPointer() );
+    mitk::DataNode::Pointer node=mitk::DataNode::New();
+    node->SetData( mitkImage );
+    node->SetProperty( "name", mitk::StringProperty::New(nodename + "_B0_ALL"));
 
-        GetDefaultDataStorage()->Add(node, (*itemiter));
+    GetDefaultDataStorage()->Add(node, (*itemiter));
 
-        /*A reinitialization is needed to access the time channels via the ImageNavigationController
+    /*A reinitialization is needed to access the time channels via the ImageNavigationController
     The Global-Geometry can not recognize the time channel without a re-init.
     (for a new selection in datamanger a automatically updated of the Global-Geometry should be done - if it contains the time channel)*/
-        mitk::RenderingManager::GetInstance()->InitializeViews(node->GetData()->GetTimeGeometry(),mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
+    mitk::RenderingManager::GetInstance()->InitializeViews(node->GetData()->GetTimeGeometry(),mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
 
-        ++itemiter;
-    }
+    ++itemiter;
+  }
 }
 
 void QmitkPreprocessingView::AverageGradients()
 {
-    int nrFiles = m_SelectedDiffusionNodes.size();
-    if (!nrFiles) return;
+  int nrFiles = m_SelectedDiffusionNodes.size();
+  if (!nrFiles) return;
 
-    mitk::DataStorage::SetOfObjects::const_iterator itemiter( m_SelectedDiffusionNodes.begin() );
-    mitk::DataStorage::SetOfObjects::const_iterator itemiterend( m_SelectedDiffusionNodes.end() );
+  mitk::DataStorage::SetOfObjects::const_iterator itemiter( m_SelectedDiffusionNodes.begin() );
+  mitk::DataStorage::SetOfObjects::const_iterator itemiterend( m_SelectedDiffusionNodes.end() );
 
-    while ( itemiter != itemiterend ) // for all items
-    {
-        mitk::DiffusionImage<DiffusionPixelType>* mitkDwi =
-                static_cast<mitk::DiffusionImage<DiffusionPixelType>*>(
-                    (*itemiter)->GetData());
+  while ( itemiter != itemiterend ) // for all items
+  {
+    mitk::Image* mitkDwi =
+        static_cast<mitk::Image*>(
+          (*itemiter)->GetData());
 
-        MitkDwiType::Pointer newDwi = mitkDwi->Clone();
-        newDwi->AverageRedundantGradients(m_Controls->m_Blur->value());
+    mitk::Image::Pointer newDwi = mitkDwi->Clone();
+    newDwi->SetPropertyList(mitkDwi->GetPropertyList()->Clone());
 
-        mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
-        imageNode->SetData( newDwi );
-        QString name = (*itemiter)->GetName().c_str();
-        imageNode->SetName((name+"_averaged").toStdString().c_str());
-        GetDefaultDataStorage()->Add(imageNode, (*itemiter));
+    mitk::DiffusionPropertyHelper propertyHelper(newDwi);
+    propertyHelper.AverageRedundantGradients(m_Controls->m_Blur->value());
+    propertyHelper.InitializeImage();
 
-        ++itemiter;
-    }
+    mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
+    imageNode->SetData( newDwi );
+    QString name = (*itemiter)->GetName().c_str();
+    imageNode->SetName((name+"_averaged").toStdString().c_str());
+    GetDefaultDataStorage()->Add(imageNode, (*itemiter));
+
+    ++itemiter;
+  }
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.h
index 4c49a9cd63..d2e798d963 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.h
@@ -1,155 +1,159 @@
 /*===================================================================
 
 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 _QMITKPREPROCESSINGVIEW_H_INCLUDED
 #define _QMITKPREPROCESSINGVIEW_H_INCLUDED
 
 #include <QmitkFunctionality.h>
 
+#include "ui_QmitkPreprocessingViewControls.h"
+
+// st includes
 #include <string>
 
-#include "ui_QmitkPreprocessingViewControls.h"
+// itk includes
+#include <itkImage.h>
+#include <itkVectorImage.h>
 
+// mitk includes
+#include <mitkImage.h>
 #include "itkDWIVoxelFunctor.h"
-
-#include "mitkDiffusionImage.h"
+#include <mitkDiffusionPropertyHelper.h>
 
 typedef short DiffusionPixelType;
 
 struct PrpSelListener;
 
 /*!
  * \ingroup org_mitk_gui_qt_preprocessing_internal
  *
  * \brief QmitkPreprocessingView
  *
  * Document your class here.
  *
  * \sa QmitkFunctionality
  */
 class QmitkPreprocessingView : public QmitkFunctionality
 {
 
   friend struct PrpSelListener;
 
   // this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
   Q_OBJECT
 
   public:
 
   static const std::string VIEW_ID;
 
-  typedef vnl_vector_fixed< double, 3 >                                 GradientDirectionType;
-  typedef itk::VectorContainer< unsigned int, GradientDirectionType >   GradientDirectionContainerType;
-  typedef mitk::DiffusionImage<short>                                   MitkDwiType;
-  typedef itk::VectorImage< short, 3 >                                  ItkDwiType;
-  typedef itk::Image< unsigned char, 3 >                                UcharImageType;
-  typedef itk::Image< double, 3 >                                       ItkDoubleImageType;
+  typedef mitk::DiffusionPropertyHelper::GradientDirectionType            GradientDirectionType;
+  typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType  GradientDirectionContainerType;
+  typedef itk::VectorImage< short, 3 >                                    ItkDwiType;
+  typedef itk::Image< unsigned char, 3 >                                  UcharImageType;
+  typedef itk::Image< double, 3 >                                         ItkDoubleImageType;
 
   QmitkPreprocessingView();
   virtual ~QmitkPreprocessingView();
 
   virtual void CreateQtPartControl(QWidget *parent);
 
   /// \brief Creation of the connections of main and control widget
   virtual void CreateConnections();
 
   /// \brief Called when the functionality is activated
   virtual void Activated();
 
   virtual void Deactivated();
 
   virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
   virtual void StdMultiWidgetNotAvailable();
 
   static const int nrconvkernels;
 
 protected slots:
 
   void AverageGradients();
   void ExtractB0();
   void MergeDwis();
   void DoApplySpacing();
   void DoApplyOrigin();
   void DoApplyDirectionMatrix();
   void DoApplyMesurementFrame();
   void DoReduceGradientDirections();
   void DoShowGradientDirections();
   void DoHalfSphereGradientDirections();
   void UpdateDwiBValueMapRounder(int i);
   void DoLengthCorrection();
   void DoAdcCalculation();
   void DoDwiNormalization();
   void DoProjectSignal();
   void DoExtractBrainMask();
   void DoResampleImage();
   void DoCropImage();
   void DoUpdateInterpolationGui(int i);
   void DoRemoveGradient();
   void DoExtractGradient();
 
 protected:
 
   void DoADCFit();
   void DoAKCFit();
   void DoBiExpFit();
   void DoADCAverage();
 
   template < typename TPixel, unsigned int VImageDimension >
   void TemplatedCropImage( itk::Image<TPixel, VImageDimension>* itkImage);
 
   template < typename TPixel, unsigned int VImageDimension >
   void TemplatedApplyRotation( itk::Image<TPixel, VImageDimension>* itkImage);
 
   template < typename TPixel, unsigned int VImageDimension >
   void TemplatedUpdateGui( itk::Image<TPixel, VImageDimension>* itkImage);
 
   template < typename TPixel, unsigned int VImageDimension >
   void TemplatedResampleImage( itk::Image<TPixel, VImageDimension>* itkImage);
 
   template < typename TPixel, unsigned int VImageDimension >
   void TemplatedSetImageSpacing( itk::Image<TPixel, VImageDimension>* itkImage);
 
   template < typename TPixel, unsigned int VImageDimension >
   void TemplatedSetImageOrigin( itk::Image<TPixel, VImageDimension>* itkImage);
 
   /** Called by ExtractB0 if check-box activated, extracts all b0 images without averaging */
   void DoExtractBOWithoutAveraging();
 
   void UpdateBValueTableWidget(int i);
 
   /// \brief called by QmitkFunctionality when DataManager's selection has changed
   virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes );
 
   Ui::QmitkPreprocessingViewControls* m_Controls;
 
   QmitkStdMultiWidget* m_MultiWidget;
 
   void SetDefaultNodeProperties(mitk::DataNode::Pointer node, std::string name);
 
   mitk::DataNode::Pointer                           m_SelectedImageNode;
   mitk::Image::Pointer                              m_SelectedImage;
-  mitk::DiffusionImage<DiffusionPixelType>::Pointer m_DiffusionImage;
   std::vector< mitk::DataNode::Pointer >            m_SelectedDiffusionNodes;
 
-  void CallMultishellToSingleShellFilter(itk::DWIVoxelFunctor * functor, mitk::DiffusionImage<DiffusionPixelType>::Pointer ImPtr, QString imageName, mitk::DataNode* parent);
+  void CallMultishellToSingleShellFilter(itk::DWIVoxelFunctor * functor, mitk::Image::Pointer ImPtr, QString imageName, mitk::DataNode* parent);
 };
 
 
 
 
 #endif // _QMITKPREPROCESSINGVIEW_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.cpp
index 32e86ab070..c116f927ea 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.cpp
@@ -1,1086 +1,1120 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 //#define MBILOG_ENABLE_DEBUG
 
 #include "QmitkQBallReconstructionView.h"
-#include "mitkDiffusionImagingConfigure.h"
 
 // qt includes
 #include <QMessageBox>
 
 // itk includes
 #include "itkTimeProbe.h"
 
 // mitk includes
 #include "mitkProgressBar.h"
 #include "mitkStatusBar.h"
 
 #include "mitkNodePredicateDataType.h"
 #include "QmitkDataStorageComboBox.h"
 #include "QmitkStdMultiWidget.h"
 
 #include "itkDiffusionQballReconstructionImageFilter.h"
 #include "itkAnalyticalDiffusionQballReconstructionImageFilter.h"
 #include "itkDiffusionMultiShellQballReconstructionImageFilter.h"
 #include "itkVectorContainer.h"
 #include "itkB0ImageExtractionImageFilter.h"
 #include <itkBinaryThresholdImageFilter.h>
 
 #include "mitkQBallImage.h"
 #include "mitkProperties.h"
 #include "mitkVtkResliceInterpolationProperty.h"
 #include "mitkLookupTable.h"
 #include "mitkLookupTableProperty.h"
 #include "mitkTransferFunction.h"
 #include "mitkTransferFunctionProperty.h"
 #include "mitkDataNodeObject.h"
 #include "mitkOdfNormalizationMethodProperty.h"
 #include "mitkOdfScaleByProperty.h"
+#include <mitkImageCast.h>
+#include "mitkDiffusionImagingConfigure.h"
 
 #include "berryIStructuredSelection.h"
 #include "berryIWorkbenchWindow.h"
 #include "berryISelectionService.h"
 
 #include <boost/version.hpp>
 
 const std::string QmitkQBallReconstructionView::VIEW_ID = "org.mitk.views.qballreconstruction";
 
 
 typedef float TTensorPixelType;
 
 const int QmitkQBallReconstructionView::nrconvkernels = 252;
 
 
 struct QbrShellSelection
 {
+  typedef mitk::DiffusionPropertyHelper::GradientDirectionType            GradientDirectionType;
+  typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType  GradientDirectionContainerType;
+  typedef mitk::DiffusionPropertyHelper::BValueMapType                    BValueMapType;
+  typedef itk::VectorImage< DiffusionPixelType, 3 >                       ITKDiffusionImageType;
+
   QmitkQBallReconstructionView* m_View;
   mitk::DataNode * m_Node;
   std::string m_NodeName;
 
   std::vector<QCheckBox *> m_CheckBoxes;
   QLabel * m_Label;
 
-  mitk::DiffusionImage<DiffusionPixelType> * m_Image;
-  typedef mitk::DiffusionImage<DiffusionPixelType>::BValueMap  BValueMap;
+  mitk::Image * m_Image;
 
   QbrShellSelection(QmitkQBallReconstructionView* view, mitk::DataNode * node)
     : m_View(view),
       m_Node(node),
       m_NodeName(node->GetName())
   {
-    m_Image = dynamic_cast<mitk::DiffusionImage<DiffusionPixelType> * > (node->GetData());
-    if(!m_Image){MITK_INFO << "QmitkQBallReconstructionView::QbrShellSelection : fail to initialize DiffusionImage "; return;}
+    m_Image = dynamic_cast<mitk::Image * > (node->GetData());
+
+    if(!m_Image)
+    {
+      MITK_ERROR << "QmitkQBallReconstructionView::QbrShellSelection : no image selected";
+      return;
+    }
+    bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_Node->GetData())) );
+
+    if( !isDiffusionImage )
+    {
+      MITK_ERROR <<
+        "QmitkQBallReconstructionView::QbrShellSelection : selected image contains no diffusion information";
+      return;
+    }
 
     GenerateCheckboxes();
 
   }
 
   void GenerateCheckboxes()
   {
-    BValueMap origMap = m_Image->GetBValueMap();
-    BValueMap::iterator itStart = origMap.begin();
+    BValueMapType origMap = static_cast<mitk::BValueMapProperty*>(m_Image->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )->GetBValueMap();
+    BValueMapType::iterator itStart = origMap.begin();
     itStart++;
-    BValueMap::iterator itEnd = origMap.end();
+    BValueMapType::iterator itEnd = origMap.end();
 
     m_Label = new QLabel(m_NodeName.c_str());
     m_Label->setVisible(true);
     m_View->m_Controls->m_QBallSelectionBox->layout()->addWidget(m_Label);
 
-    for(BValueMap::iterator it = itStart ; it!= itEnd; it++)
+    for(BValueMapType::iterator it = itStart ; it!= itEnd; it++)
     {
       QCheckBox * box  = new QCheckBox(QString::number(it->first));
       m_View->m_Controls->m_QBallSelectionBox->layout()->addWidget(box);
 
       box->setChecked(true);
       box->setCheckable(true);
       // box->setVisible(true);
       m_CheckBoxes.push_back(box);
     }
   }
 
   void SetVisible(bool vis)
   {
     foreach(QCheckBox * box, m_CheckBoxes)
     {
       box->setVisible(vis);
     }
   }
 
-  BValueMap GetBValueSelctionMap()
+  BValueMapType GetBValueSelctionMap()
   {
-    BValueMap inputMap = m_Image->GetBValueMap();
-    BValueMap outputMap;
+    BValueMapType inputMap = static_cast<mitk::BValueMapProperty*>(m_Image->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )->GetBValueMap();
+    BValueMapType outputMap;
 
     unsigned int val = 0;
 
     if(inputMap.find(0) == inputMap.end()){
       MITK_INFO << "QbrShellSelection: return empty BValueMap from GUI Selection";
       return outputMap;
     }else{
       outputMap[val] = inputMap[val];
       MITK_INFO << val;
     }
 
     foreach(QCheckBox * box, m_CheckBoxes)
     {
       if(box->isChecked()){
         val = box->text().toDouble();
         outputMap[val] = inputMap[val];
         MITK_INFO << val;
       }
     }
 
     return outputMap;
   }
 
   ~QbrShellSelection()
   {
     m_View->m_Controls->m_QBallSelectionBox->layout()->removeWidget(m_Label);
     delete m_Label;
 
     for(std::vector<QCheckBox *>::iterator it = m_CheckBoxes.begin() ; it!= m_CheckBoxes.end(); it++)
     {
       m_View->m_Controls->m_QBallSelectionBox->layout()->removeWidget((*it));
       delete (*it);
     }
     m_CheckBoxes.clear();
   }
 };
 
 using namespace berry;
 
 struct QbrSelListener : ISelectionListener
 {
 
   berryObjectMacro(QbrSelListener);
 
   QbrSelListener(QmitkQBallReconstructionView* view)
   {
     m_View = view;
   }
 
   void DoSelectionChanged(ISelection::ConstPointer selection)
   {
     // save current selection in member variable
     m_View->m_CurrentSelection = selection.Cast<const IStructuredSelection>();
 
     // do something with the selected items
     if(m_View->m_CurrentSelection)
     {
       bool foundDwiVolume = false;
 
       m_View->m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
       m_View->m_Controls->m_InputData->setTitle("Please Select Input Data");
 
       QString selected_images = "";
 
       mitk::DataStorage::SetOfObjects::Pointer set =
           mitk::DataStorage::SetOfObjects::New();
 
       int at = 0;
 
       // iterate selection
       for (IStructuredSelection::iterator i = m_View->m_CurrentSelection->Begin();
            i != m_View->m_CurrentSelection->End(); ++i)
       {
 
         // extract datatree node
         if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
         {
           mitk::DataNode::Pointer node = nodeObj->GetDataNode();
-          mitk::DiffusionImage<DiffusionPixelType>* diffusionImage = dynamic_cast<mitk::DiffusionImage<DiffusionPixelType> * >(node->GetData());
+          bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData())) );
+          mitk::Image* diffusionImage = dynamic_cast<mitk::Image * >(node->GetData());
           // only look at interesting types
-          if(diffusionImage)
+          if(diffusionImage && isDiffusionImage)
           {
             foundDwiVolume = true;
             selected_images += QString(node->GetName().c_str());
             if(i + 1 != m_View->m_CurrentSelection->End())
               selected_images += "\n";
             set->InsertElement(at++, node);
           }
         }
       }
       m_View->GenerateShellSelectionUI(set);
       m_View->m_Controls->m_DiffusionImageLabel->setText(selected_images);
       m_View->m_Controls->m_ButtonStandard->setEnabled(foundDwiVolume);
       if (foundDwiVolume)
         m_View->m_Controls->m_InputData->setTitle("Input Data");
       else
         m_View->m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
     }
   }
 
   void SelectionChanged(IWorkbenchPart::Pointer part, ISelection::ConstPointer selection)
   {
     // check, if selection comes from datamanager
     if (part)
     {
       QString partname(part->GetPartName().c_str());
       if(partname.compare("Data Manager")==0)
       {
 
         // apply selection
         DoSelectionChanged(selection);
 
       }
     }
   }
 
   QmitkQBallReconstructionView* m_View;
 };
 
 
 // --------------- QmitkQBallReconstructionView----------------- //
 
 
 QmitkQBallReconstructionView::QmitkQBallReconstructionView()
   : QmitkFunctionality(),
     m_Controls(NULL),
     m_MultiWidget(NULL)
 {
 }
 
 QmitkQBallReconstructionView::~QmitkQBallReconstructionView()
 {
   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->RemovePostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
 }
 
 void QmitkQBallReconstructionView::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkQBallReconstructionViewControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
 
     m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
 
     QStringList items;
     items << "2" << "4" << "6" << "8" << "10" << "12";
     m_Controls->m_QBallReconstructionMaxLLevelComboBox->addItems(items);
     m_Controls->m_QBallReconstructionMaxLLevelComboBox->setCurrentIndex(1);
     MethodChoosen(m_Controls->m_QBallReconstructionMethodComboBox->currentIndex());
 
 
 #ifndef DIFFUSION_IMAGING_EXTENDED
     m_Controls->m_QBallReconstructionMethodComboBox->removeItem(3);
 #endif
 
     AdvancedCheckboxClicked();
   }
 
   m_SelListener = berry::ISelectionListener::Pointer(new QbrSelListener(this));
   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddPostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
   berry::ISelection::ConstPointer sel(
         this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
   m_CurrentSelection = sel.Cast<const IStructuredSelection>();
   m_SelListener.Cast<QbrSelListener>()->DoSelectionChanged(sel);
 }
 
 void QmitkQBallReconstructionView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
   m_MultiWidget = &stdMultiWidget;
 }
 
 void QmitkQBallReconstructionView::StdMultiWidgetNotAvailable()
 {
   m_MultiWidget = NULL;
 }
 
 void QmitkQBallReconstructionView::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_ButtonStandard), SIGNAL(clicked()), this, SLOT(ReconstructStandard()) );
     connect( (QObject*)(m_Controls->m_AdvancedCheckbox), SIGNAL(clicked()), this, SLOT(AdvancedCheckboxClicked()) );
     connect( (QObject*)(m_Controls->m_QBallReconstructionMethodComboBox), SIGNAL(currentIndexChanged(int)), this, SLOT(MethodChoosen(int)) );
     connect( (QObject*)(m_Controls->m_QBallReconstructionThreasholdEdit), SIGNAL(valueChanged(int)), this, SLOT(PreviewThreshold(int)) );
   }
 }
 
 void QmitkQBallReconstructionView::OnSelectionChanged( std::vector<mitk::DataNode*> )
 {
 
 }
 
 void QmitkQBallReconstructionView::Activated()
 {
   QmitkFunctionality::Activated();
 
   berry::ISelection::ConstPointer sel(
         this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
   m_CurrentSelection = sel.Cast<const IStructuredSelection>();
   m_SelListener.Cast<QbrSelListener>()->DoSelectionChanged(sel);
 }
 
 void QmitkQBallReconstructionView::Deactivated()
 {
 
   mitk::DataStorage::SetOfObjects::ConstPointer objects =  this->GetDefaultDataStorage()->GetAll();
   mitk::DataStorage::SetOfObjects::const_iterator itemiter( objects->begin() );
   mitk::DataStorage::SetOfObjects::const_iterator itemiterend( objects->end() );
   while ( itemiter != itemiterend ) // for all items
   {
       mitk::DataNode::Pointer node = *itemiter;
       if (node.IsNull())
           continue;
 
       // only look at interesting types
-      if(dynamic_cast<mitk::DiffusionImage<short>*>(node->GetData()))
+      bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData())) );
+      if( isDiffusionImage )
       {
           if (this->GetDefaultDataStorage()->GetNamedDerivedNode("ThresholdOverlay", *itemiter))
           {
               node = this->GetDefaultDataStorage()->GetNamedDerivedNode("ThresholdOverlay", *itemiter);
               this->GetDefaultDataStorage()->Remove(node);
           }
       }
       itemiter++;
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   QmitkFunctionality::Deactivated();
 }
 
 void QmitkQBallReconstructionView::ReconstructStandard()
 {
 
   int index = m_Controls->m_QBallReconstructionMethodComboBox->currentIndex();
 
 #ifndef DIFFUSION_IMAGING_EXTENDED
   if(index>=3)
   {
     index = index + 1;
   }
 #endif
 
   switch(index)
   {
   case 0:
   {
     // Numerical
     Reconstruct(0,0);
     break;
   }
   case 1:
   {
     // Standard
     Reconstruct(1,0);
     break;
   }
   case 2:
   {
     // Solid Angle
     Reconstruct(1,6);
     break;
   }
   case 3:
   {
     // Constrained Solid Angle
     Reconstruct(1,7);
     break;
   }
   case 4:
   {
     // ADC
     Reconstruct(1,4);
     break;
   }
   case 5:
   {
     // Raw Signal
     Reconstruct(1,5);
     break;
   }
   case 6:
   {
     // Q-Ball reconstruction
     Reconstruct(2,0);
     break;
   }
   }
 }
 
 void QmitkQBallReconstructionView::MethodChoosen(int method)
 {
 
 #ifndef DIFFUSION_IMAGING_EXTENDED
   if(method>=3)
   {
     method = method + 1;
   }
 #endif
 
   m_Controls->m_QBallSelectionBox->setHidden(true);
   m_Controls->m_OutputCoeffsImage->setHidden(true);
 
   if (method==0)
     m_Controls->m_ShFrame->setVisible(false);
   else
     m_Controls->m_ShFrame->setVisible(true);
 
   switch(method)
   {
   case 0:
     m_Controls->m_Description->setText("Numerical recon. (Tuch 2004)");
     break;
   case 1:
     m_Controls->m_Description->setText("Spherical harmonics recon. (Descoteaux 2007)");
     m_Controls->m_OutputCoeffsImage->setHidden(false);
     break;
   case 2:
     m_Controls->m_Description->setText("SH recon. with solid angle consideration (Aganj 2009)");
     m_Controls->m_OutputCoeffsImage->setHidden(false);
     break;
   case 3:
     m_Controls->m_Description->setText("SH solid angle with non-neg. constraint (Goh 2009)");
     break;
   case 4:
     m_Controls->m_Description->setText("SH recon. of the plain ADC-profiles");
     break;
   case 5:
     m_Controls->m_Description->setText("SH recon. of the raw diffusion signal");
     break;
   case 6:
     m_Controls->m_Description->setText("SH recon. of the multi shell diffusion signal (Aganj 2010)");
     m_Controls->m_QBallSelectionBox->setHidden(false);
     m_Controls->m_OutputCoeffsImage->setHidden(false);
     break;
   }
 }
 
 
 
 void QmitkQBallReconstructionView::AdvancedCheckboxClicked()
 {
   bool check = m_Controls->m_AdvancedCheckbox->isChecked();
 
   m_Controls->m_QBallReconstructionMaxLLevelTextLabel_2->setVisible(check);
   m_Controls->m_QBallReconstructionMaxLLevelComboBox->setVisible(check);
   m_Controls->m_QBallReconstructionLambdaTextLabel_2->setVisible(check);
   m_Controls->m_QBallReconstructionLambdaLineEdit->setVisible(check);
 
   m_Controls->m_QBallReconstructionThresholdLabel_2->setVisible(check);
   m_Controls->m_QBallReconstructionThreasholdEdit->setVisible(check);
   m_Controls->label_2->setVisible(check);
   m_Controls->frame_2->setVisible(check);
 }
 
 void QmitkQBallReconstructionView::Reconstruct(int method, int normalization)
 {
   if (m_CurrentSelection)
   {
     mitk::DataStorage::SetOfObjects::Pointer set =
         mitk::DataStorage::SetOfObjects::New();
 
     int at = 0;
     for (IStructuredSelection::iterator i = m_CurrentSelection->Begin();
          i != m_CurrentSelection->End();
          ++i)
     {
 
       if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
       {
         mitk::DataNode::Pointer node = nodeObj->GetDataNode();
-        if(QString("DiffusionImage").compare(node->GetData()->GetNameOfClass())==0)
+
+        bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData())) );
+        if ( isDiffusionImage )
         {
           set->InsertElement(at++, node);
         }
       }
     }
 
     if(method == 0)
     {
       NumericalQBallReconstruction(set, normalization);
     }
     else
     {
 #if BOOST_VERSION / 100000 > 0
 #if BOOST_VERSION / 100 % 1000 > 34
       if(method == 1)
       {
         AnalyticalQBallReconstruction(set, normalization);
       }
       if(method == 2)
       {
         MultiQBallReconstruction(set);
       }
 #else
       std::cout << "ERROR: Boost 1.35 minimum required" << std::endl;
       QMessageBox::warning(NULL,"ERROR","Boost 1.35 minimum required");
 #endif
 #else
       std::cout << "ERROR: Boost 1.35 minimum required" << std::endl;
       QMessageBox::warning(NULL,"ERROR","Boost 1.35 minimum required");
 #endif
     }
   }
 }
 
 void QmitkQBallReconstructionView::NumericalQBallReconstruction
 (mitk::DataStorage::SetOfObjects::Pointer inImages, int normalization)
 {
   try
   {
     itk::TimeProbe clock;
 
     int nrFiles = inImages->size();
     if (!nrFiles) return;
 
     QString status;
     mitk::ProgressBar::GetInstance()->AddStepsToDo(nrFiles);
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( inImages->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( inImages->end() );
 
     while ( itemiter != itemiterend ) // for all items
     {
 
-      mitk::DiffusionImage<DiffusionPixelType>* vols =
-          static_cast<mitk::DiffusionImage<DiffusionPixelType>*>(
+      mitk::Image* vols =
+          static_cast<mitk::Image*>(
             (*itemiter)->GetData());
 
       std::string nodename;
       (*itemiter)->GetStringProperty("name", nodename);
 
       // QBALL RECONSTRUCTION
       clock.Start();
       MITK_INFO << "QBall reconstruction ";
       mitk::StatusBar::GetInstance()->DisplayText(status.sprintf(
                                                     "QBall reconstruction for %s", nodename.c_str()).toLatin1());
 
       typedef itk::DiffusionQballReconstructionImageFilter
           <DiffusionPixelType, DiffusionPixelType, TTensorPixelType, QBALL_ODFSIZE>
           QballReconstructionImageFilterType;
 
+      ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
+      mitk::CastToItkImage(vols, itkVectorImagePointer);
+
       QballReconstructionImageFilterType::Pointer filter =
           QballReconstructionImageFilterType::New();
-      filter->SetGradientImage( vols->GetDirections(), vols->GetVectorImage() );
-      filter->SetBValue(vols->GetReferenceBValue());
+      filter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>( vols->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), itkVectorImagePointer );
+      filter->SetBValue( static_cast<mitk::FloatProperty*>(vols->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
       filter->SetThreshold( m_Controls->m_QBallReconstructionThreasholdEdit->value() );
 
       std::string nodePostfix;
       switch(normalization)
       {
       case 0:
       {
         filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_STANDARD);
         nodePostfix = "_Numerical_Qball";
         break;
       }
       case 1:
       {
         filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_B_ZERO_B_VALUE);
         nodePostfix = "_Numerical_ZeroBvalueNormalization_Qball";
         break;
       }
       case 2:
       {
         filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_B_ZERO);
         nodePostfix = "_NumericalQball_ZeroNormalization_Qball";
         break;
       }
       case 3:
       {
         filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_NONE);
         nodePostfix = "_NumericalQball_NoNormalization_Qball";
         break;
       }
       default:
       {
         filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_STANDARD);
         nodePostfix = "_NumericalQball_Qball";
       }
       }
 
       filter->Update();
       clock.Stop();
       MITK_DEBUG << "took " << clock.GetMean() << "s." ;
 
       // ODFs TO DATATREE
       mitk::QBallImage::Pointer image = mitk::QBallImage::New();
       image->InitializeByItk( filter->GetOutput() );
       image->SetVolume( filter->GetOutput()->GetBufferPointer() );
       mitk::DataNode::Pointer node=mitk::DataNode::New();
       node->SetData( image );
       SetDefaultNodeProperties(node, nodename+nodePostfix);
       mitk::ProgressBar::GetInstance()->Progress();
 
       GetDefaultDataStorage()->Add(node, *itemiter);
       ++itemiter;
     }
 
     mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Finished Processing %d Files", nrFiles).toLatin1());
     m_MultiWidget->RequestUpdate();
 
   }
   catch (itk::ExceptionObject &ex)
   {
     MITK_INFO << ex ;
     QMessageBox::information(0, "Reconstruction not possible:", ex.GetDescription());
     return ;
   }
 }
 
 void QmitkQBallReconstructionView::AnalyticalQBallReconstruction(
     mitk::DataStorage::SetOfObjects::Pointer inImages,
     int normalization)
 {
   try
   {
     itk::TimeProbe clock;
 
     int nrFiles = inImages->size();
     if (!nrFiles) return;
 
     std::vector<float> lambdas;
     float minLambda  = m_Controls->m_QBallReconstructionLambdaLineEdit->value();
     lambdas.push_back(minLambda);
     int nLambdas = lambdas.size();
 
 
     QString status;
     mitk::ProgressBar::GetInstance()->AddStepsToDo(nrFiles*nLambdas);
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( inImages->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( inImages->end() );
 
     std::vector<mitk::DataNode::Pointer>* nodes
         = new std::vector<mitk::DataNode::Pointer>();
     while ( itemiter != itemiterend ) // for all items
     {
       // QBALL RECONSTRUCTION
       clock.Start();
       MITK_INFO << "QBall reconstruction ";
       mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("QBall reconstruction for %s", (*itemiter)->GetName().c_str()).toLatin1());
 
       for(int i=0; i<nLambdas; i++)
       {
         float currentLambda = lambdas[i];
         switch(m_Controls->m_QBallReconstructionMaxLLevelComboBox->currentIndex())
         {
         case 0:
         {
           TemplatedAnalyticalQBallReconstruction<2>(*itemiter, currentLambda, normalization);
           break;
         }
         case 1:
         {
           TemplatedAnalyticalQBallReconstruction<4>(*itemiter, currentLambda, normalization);
           break;
         }
         case 2:
         {
           TemplatedAnalyticalQBallReconstruction<6>(*itemiter, currentLambda, normalization);
           break;
         }
         case 3:
         {
           TemplatedAnalyticalQBallReconstruction<8>(*itemiter, currentLambda, normalization);
           break;
         }
         case 4:
         {
           TemplatedAnalyticalQBallReconstruction<10>(*itemiter, currentLambda, normalization);
           break;
         }
         case 5:
         {
           TemplatedAnalyticalQBallReconstruction<12>(*itemiter, currentLambda, normalization);
           break;
         }
         }
         clock.Stop();
         MITK_DEBUG << "took " << clock.GetMean() << "s." ;
         mitk::ProgressBar::GetInstance()->Progress();
         itemiter++;
       }
     }
 
     std::vector<mitk::DataNode::Pointer>::iterator nodeIt;
     for(nodeIt = nodes->begin(); nodeIt != nodes->end(); ++nodeIt)
       GetDefaultDataStorage()->Add(*nodeIt);
 
     m_MultiWidget->RequestUpdate();
 
     mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Finished Processing %d Files", nrFiles).toLatin1());
 
   }
   catch (itk::ExceptionObject &ex)
   {
     MITK_INFO << ex;
     QMessageBox::information(0, "Reconstruction not possible:", ex.GetDescription());
     return;
   }
 }
 
 template<int L>
 void QmitkQBallReconstructionView::TemplatedAnalyticalQBallReconstruction(mitk::DataNode* dataNodePointer, float lambda, int normalization)
 {
   typedef itk::AnalyticalDiffusionQballReconstructionImageFilter
       <DiffusionPixelType,DiffusionPixelType,TTensorPixelType,L,QBALL_ODFSIZE> FilterType;
   typename FilterType::Pointer filter = FilterType::New();
 
-  mitk::DiffusionImage<DiffusionPixelType>* vols = dynamic_cast<mitk::DiffusionImage<DiffusionPixelType>*>(dataNodePointer->GetData());
-  filter->SetGradientImage( vols->GetDirections(), vols->GetVectorImage() );
-  filter->SetBValue(vols->GetReferenceBValue());
+  mitk::Image* vols = dynamic_cast<mitk::Image*>(dataNodePointer->GetData());
+
+    ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
+  mitk::CastToItkImage(vols, itkVectorImagePointer);
+
+  filter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>( vols->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), itkVectorImagePointer );
+  filter->SetBValue( static_cast<mitk::FloatProperty*>(vols->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
   filter->SetThreshold( m_Controls->m_QBallReconstructionThreasholdEdit->value() );
   filter->SetLambda(lambda);
 
   std::string nodePostfix;
   switch(normalization)
   {
   case 0:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
     nodePostfix = "_SphericalHarmonics_Qball";
     break;
   }
   case 1:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_B_ZERO_B_VALUE);
     nodePostfix = "_SphericalHarmonics_1_Qball";
     break;
   }
   case 2:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_B_ZERO);
     nodePostfix = "_SphericalHarmonics_2_Qball";
     break;
   }
   case 3:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_NONE);
     nodePostfix = "_SphericalHarmonics_3_Qball";
     break;
   }
   case 4:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_ADC_ONLY);
     nodePostfix = "_AdcProfile";
     break;
   }
   case 5:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_RAW_SIGNAL);
     nodePostfix = "_RawSignal";
     break;
   }
   case 6:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
     nodePostfix = "_SphericalHarmonics_CSA_Qball";
     break;
   }
   case 7:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_NONNEG_SOLID_ANGLE);
     nodePostfix = "_SphericalHarmonics_NonNegCSA_Qball";
     break;
   }
   default:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
   }
   }
 
   filter->Update();
 
   // ODFs TO DATATREE
   mitk::QBallImage::Pointer image = mitk::QBallImage::New();
   image->InitializeByItk( filter->GetOutput() );
   image->SetVolume( filter->GetOutput()->GetBufferPointer() );
   mitk::DataNode::Pointer node=mitk::DataNode::New();
   node->SetData( image );
   SetDefaultNodeProperties(node, dataNodePointer->GetName()+nodePostfix);
 
   GetDefaultDataStorage()->Add(node, dataNodePointer);
 
   if(m_Controls->m_OutputCoeffsImage->isChecked())
   {
     mitk::Image::Pointer coeffsImage = mitk::Image::New();
     coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
     coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
     mitk::DataNode::Pointer coeffsNode=mitk::DataNode::New();
     coeffsNode->SetData( coeffsImage );
     coeffsNode->SetProperty( "name", mitk::StringProperty::New(dataNodePointer->GetName()+"_SH-Coeffs") );
     coeffsNode->SetVisibility(false);
     GetDefaultDataStorage()->Add(coeffsNode, node);
   }
 }
 
 void QmitkQBallReconstructionView::MultiQBallReconstruction(mitk::DataStorage::SetOfObjects::Pointer inImages)
 {
   try
   {
     itk::TimeProbe clock;
 
     int nrFiles = inImages->size();
     if (!nrFiles) return;
 
     std::vector<float> lambdas;
     float minLambda  = m_Controls->m_QBallReconstructionLambdaLineEdit->value();
     lambdas.push_back(minLambda);
     int nLambdas = lambdas.size();
 
     QString status;
     mitk::ProgressBar::GetInstance()->AddStepsToDo(nrFiles*nLambdas);
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( inImages->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( inImages->end() );
 
     while ( itemiter != itemiterend ) // for all items
     {
       mitk::DataNode* nodePointer = (*itemiter).GetPointer();
       std::string nodename;
       (*itemiter)->GetStringProperty("name",nodename);
 
       itemiter++;
 
       // QBALL RECONSTRUCTION
       clock.Start();
       MITK_INFO << "QBall reconstruction ";
       mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("QBall reconstruction for %s", nodename.c_str()).toLatin1());
 
       for(int i=0; i<nLambdas; i++)
       {
 
         float currentLambda = lambdas[i];
 
         switch(m_Controls->m_QBallReconstructionMaxLLevelComboBox->currentIndex())
         {
         case 0:
         {
           TemplatedMultiQBallReconstruction<2>(currentLambda, nodePointer);
           break;
         }
         case 1:
         {
           TemplatedMultiQBallReconstruction<4>(currentLambda, nodePointer);
           break;
         }
         case 2:
         {
           TemplatedMultiQBallReconstruction<6>(currentLambda, nodePointer);
           break;
         }
         case 3:
         {
           TemplatedMultiQBallReconstruction<8>(currentLambda, nodePointer);
           break;
         }
         case 4:
         {
           TemplatedMultiQBallReconstruction<10>(currentLambda, nodePointer);
           break;
         }
         case 5:
         {
           TemplatedMultiQBallReconstruction<12>(currentLambda, nodePointer);
           break;
         }
         }
 
         clock.Stop();
         MITK_DEBUG << "took " << clock.GetMean() << "s." ;
         mitk::ProgressBar::GetInstance()->Progress();
       }
     }
     m_MultiWidget->RequestUpdate();
     mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Finished Processing %d Files", nrFiles).toLatin1());
   }
   catch (itk::ExceptionObject &ex)
   {
     MITK_INFO << ex ;
     QMessageBox::information(0, "Reconstruction not possible:", ex.GetDescription());
     return ;
   }
 }
 
 template<int L>
 void QmitkQBallReconstructionView::TemplatedMultiQBallReconstruction(float lambda, mitk::DataNode* dataNodePointer)
 {
   typedef itk::DiffusionMultiShellQballReconstructionImageFilter
       <DiffusionPixelType,DiffusionPixelType,TTensorPixelType,L,QBALL_ODFSIZE> FilterType;
   typename FilterType::Pointer filter = FilterType::New();
 
   std::string nodename;
   dataNodePointer->GetStringProperty("name",nodename);
 
-  mitk::DiffusionImage<DiffusionPixelType>* dwi = dynamic_cast<mitk::DiffusionImage<DiffusionPixelType>*>(dataNodePointer->GetData());
-  mitk::DiffusionImage<short>::BValueMap currSelectionMap = m_ShellSelectorMap[dataNodePointer]->GetBValueSelctionMap();
+  mitk::Image* dwi = dynamic_cast<mitk::Image*>(dataNodePointer->GetData());
+  BValueMapType currSelectionMap = m_ShellSelectorMap[dataNodePointer]->GetBValueSelctionMap();
 
   if(currSelectionMap.size() != 4 && currSelectionMap.find(0) != currSelectionMap.end())
   {
     QMessageBox::information(0, "Reconstruction not possible:" ,QString("Only three shells in a equidistant configuration is supported. (ImageName: " + QString(nodename.c_str()) + ")"));
     return;
   }
 
-  mitk::DiffusionImage<short>::BValueMap::reverse_iterator it1 = currSelectionMap.rbegin();
-  mitk::DiffusionImage<short>::BValueMap::reverse_iterator it2 = currSelectionMap.rbegin();
+  BValueMapType::reverse_iterator it1 = currSelectionMap.rbegin();
+  BValueMapType::reverse_iterator it2 = currSelectionMap.rbegin();
   ++it2;
 
   // Get average distance
   int avdistance = 0;
   for(; it2 != currSelectionMap.rend(); ++it1,++it2)
     avdistance += (int)it1->first - (int)it2->first;
   avdistance /= currSelectionMap.size()-1;
 
   // Check if all shells are using the same averae distance
   it1 = currSelectionMap.rbegin();
   it2 = currSelectionMap.rbegin();
   ++it2;
   for(; it2 != currSelectionMap.rend(); ++it1,++it2)
     if(avdistance != (int)it1->first - (int)it2->first)
     {
       QMessageBox::information(0, "Reconstruction not possible:" ,QString("Selected Shells are not in a equidistant configuration. (ImageName: " + QString(nodename.c_str()) + ")"));
       return;
     }
 
+    ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
+    mitk::CastToItkImage(dwi, itkVectorImagePointer);
 
-  filter->SetBValueMap(m_ShellSelectorMap[dataNodePointer]->GetBValueSelctionMap());
-  filter->SetGradientImage( dwi->GetDirections(), dwi->GetVectorImage(), dwi->GetReferenceBValue() );
-  filter->SetThreshold( m_Controls->m_QBallReconstructionThreasholdEdit->value() );
-  filter->SetLambda(lambda);
-  filter->Update();
+    filter->SetBValueMap(m_ShellSelectorMap[dataNodePointer]->GetBValueSelctionMap());
+    filter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>( dwi->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), itkVectorImagePointer, static_cast<mitk::FloatProperty*>(dwi->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
+    filter->SetThreshold( m_Controls->m_QBallReconstructionThreasholdEdit->value() );
+    filter->SetLambda(lambda);
+    filter->Update();
 
 
-  // ODFs TO DATATREE
-  mitk::QBallImage::Pointer image = mitk::QBallImage::New();
-  image->InitializeByItk( filter->GetOutput() );
-  image->SetVolume( filter->GetOutput()->GetBufferPointer() );
-  mitk::DataNode::Pointer node=mitk::DataNode::New();
-  node->SetData( image );
-  SetDefaultNodeProperties(node, nodename+"_SphericalHarmonics_MultiShell_Qball");
+    // ODFs TO DATATREE
+    mitk::QBallImage::Pointer image = mitk::QBallImage::New();
+    image->InitializeByItk( filter->GetOutput() );
+    image->SetVolume( filter->GetOutput()->GetBufferPointer() );
+    mitk::DataNode::Pointer node=mitk::DataNode::New();
+    node->SetData( image );
+    SetDefaultNodeProperties(node, nodename+"_SphericalHarmonics_MultiShell_Qball");
 
-  GetDefaultDataStorage()->Add(node, dataNodePointer);
+    GetDefaultDataStorage()->Add(node, dataNodePointer);
 
-  if(m_Controls->m_OutputCoeffsImage->isChecked())
-  {
-    mitk::Image::Pointer coeffsImage = mitk::Image::New();
-    coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
-    coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
-    mitk::DataNode::Pointer coeffsNode=mitk::DataNode::New();
-    coeffsNode->SetData( coeffsImage );
-    coeffsNode->SetProperty( "name", mitk::StringProperty::New(
-                               QString(nodename.c_str()).append("_SH-Coefficients").toStdString()) );
-    coeffsNode->SetVisibility(false);
-    GetDefaultDataStorage()->Add(coeffsNode, node);
-  }
+    if(m_Controls->m_OutputCoeffsImage->isChecked())
+    {
+      mitk::Image::Pointer coeffsImage = mitk::Image::New();
+      coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
+      coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
+      mitk::DataNode::Pointer coeffsNode=mitk::DataNode::New();
+      coeffsNode->SetData( coeffsImage );
+      coeffsNode->SetProperty( "name", mitk::StringProperty::New(
+        QString(nodename.c_str()).append("_SH-Coefficients").toStdString()) );
+      coeffsNode->SetVisibility(false);
+      GetDefaultDataStorage()->Add(coeffsNode, node);
+    }
 
 }
 
 void QmitkQBallReconstructionView::SetDefaultNodeProperties(mitk::DataNode::Pointer node, std::string name)
 {
   node->SetProperty( "ShowMaxNumber", mitk::IntProperty::New( 500 ) );
   node->SetProperty( "Scaling", mitk::FloatProperty::New( 1.0 ) );
   node->SetProperty( "Normalization", mitk::OdfNormalizationMethodProperty::New());
   node->SetProperty( "ScaleBy", mitk::OdfScaleByProperty::New());
   node->SetProperty( "IndexParam1", mitk::FloatProperty::New(2));
   node->SetProperty( "IndexParam2", mitk::FloatProperty::New(1));
   node->SetProperty( "visible", mitk::BoolProperty::New( true ) );
   node->SetProperty( "VisibleOdfs", mitk::BoolProperty::New( false ) );
   node->SetProperty ("layer", mitk::IntProperty::New(100));
   node->SetProperty( "DoRefresh", mitk::BoolProperty::New( true ) );
   node->SetProperty( "name", mitk::StringProperty::New(name) );
 }
 
 void QmitkQBallReconstructionView::GenerateShellSelectionUI(mitk::DataStorage::SetOfObjects::Pointer set)
 {
   m_DiffusionImages = set;
 
   std::map<const mitk::DataNode * , QbrShellSelection * > tempMap;
 
   const mitk::DataStorage::SetOfObjects::iterator setEnd( set->end() );
   mitk::DataStorage::SetOfObjects::iterator NodeIt( set->begin() );
   while(NodeIt != setEnd)
   {
 
 
     if(m_ShellSelectorMap.find(  (*NodeIt).GetPointer() ) != m_ShellSelectorMap.end())
     {
       tempMap[(*NodeIt).GetPointer()] = m_ShellSelectorMap[(*NodeIt).GetPointer()];
       m_ShellSelectorMap.erase((*NodeIt).GetPointer());
     }else
     {
       tempMap[(*NodeIt).GetPointer()] = new QbrShellSelection(this, (*NodeIt) );
       tempMap[(*NodeIt).GetPointer()]->SetVisible(true);
     }
 
     NodeIt++;
   }
 
   for(std::map<const mitk::DataNode * , QbrShellSelection * >::iterator it = m_ShellSelectorMap.begin(); it != m_ShellSelectorMap.end();it ++)
   {
     delete it->second;
   }
   m_ShellSelectorMap.clear();
   m_ShellSelectorMap = tempMap;
 }
 
 
 
 void QmitkQBallReconstructionView::PreviewThreshold(int threshold)
 {
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( m_DiffusionImages->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( m_DiffusionImages->end() );
     while ( itemiter != itemiterend ) // for all items
     {
-        mitk::DiffusionImage<DiffusionPixelType>* vols =
-                static_cast<mitk::DiffusionImage<DiffusionPixelType>*>(
+        mitk::Image* vols =
+                static_cast<mitk::Image*>(
                     (*itemiter)->GetData());
 
         // Extract b0 image
+        ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
+        mitk::CastToItkImage(vols, itkVectorImagePointer);
+
         typedef itk::B0ImageExtractionImageFilter<short, short> FilterType;
         FilterType::Pointer filterB0 = FilterType::New();
-        filterB0->SetInput(vols->GetVectorImage());
-        filterB0->SetDirections(vols->GetDirections());
+        filterB0->SetInput( itkVectorImagePointer );
+        filterB0->SetDirections( static_cast<mitk::GradientDirectionsProperty*>( vols->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() );
         filterB0->Update();
 
         mitk::Image::Pointer mitkImage = mitk::Image::New();
 
         typedef itk::Image<short, 3> ImageType;
         typedef itk::Image<short, 3> SegmentationType;
         typedef itk::BinaryThresholdImageFilter<ImageType, SegmentationType> ThresholdFilterType;
         // apply threshold
         ThresholdFilterType::Pointer filterThreshold = ThresholdFilterType::New();
         filterThreshold->SetInput(filterB0->GetOutput());
         filterThreshold->SetLowerThreshold(threshold);
         filterThreshold->SetInsideValue(0);
         filterThreshold->SetOutsideValue(1); // mark cut off values red
         filterThreshold->Update();
 
         mitkImage->InitializeByItk( filterThreshold->GetOutput() );
         mitkImage->SetVolume( filterThreshold->GetOutput()->GetBufferPointer() );
         mitk::DataNode::Pointer node;
         if (this->GetDefaultDataStorage()->GetNamedDerivedNode("ThresholdOverlay", *itemiter))
         {
             node = this->GetDefaultDataStorage()->GetNamedDerivedNode("ThresholdOverlay", *itemiter);
         }
         else
         {
             // create a new node, to show thresholded values
             node = mitk::DataNode::New();
             GetDefaultDataStorage()->Add( node, *itemiter );
             node->SetProperty( "name", mitk::StringProperty::New("ThresholdOverlay"));
             node->SetBoolProperty("helper object", true);
         }
         node->SetData( mitkImage );
         itemiter++;
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.h
index 3ac068f4f9..d6cc9382ce 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.h
@@ -1,131 +1,138 @@
 /*===================================================================
 
 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 _QMITKQBALLRECONSTRUCTIONVIEW_H_INCLUDED
 #define _QMITKQBALLRECONSTRUCTIONVIEW_H_INCLUDED
 
 #include <QmitkFunctionality.h>
 
 #include <string>
 
 #include "ui_QmitkQBallReconstructionViewControls.h"
 
-#include "mitkDiffusionImage.h"
-
 #include <berryIPartListener.h>
 #include <berryISelectionListener.h>
 #include <berryIStructuredSelection.h>
 
+#include <mitkImage.h>
+#include <mitkDiffusionPropertyHelper.h>
+#include <itkVectorImage.h>
+
 typedef short DiffusionPixelType;
 
 struct QbrSelListener;
 
 struct QbrShellSelection;
 
 /*!
  * \ingroup org_mitk_gui_qt_qballreconstruction_internal
  *
  * \brief QmitkQBallReconstructionView
  *
  * Document your class here.
  *
  * \sa QmitkFunctionality
  */
 class QmitkQBallReconstructionView : public QmitkFunctionality
 {
 
   friend struct QbrSelListener;
 
   friend struct QbrShellSelection;
 
+  typedef mitk::DiffusionPropertyHelper::GradientDirectionType            GradientDirectionType;
+  typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType  GradientDirectionContainerType;
+  typedef mitk::DiffusionPropertyHelper::BValueMapType                    BValueMapType;
+  typedef itk::VectorImage< DiffusionPixelType, 3 >                       ITKDiffusionImageType;
+
   // this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
   Q_OBJECT
 
   public:
 
   static const std::string VIEW_ID;
 
   QmitkQBallReconstructionView();
   virtual ~QmitkQBallReconstructionView();
 
   virtual void CreateQtPartControl(QWidget *parent);
 
   /// \brief Creation of the connections of main and control widget
   virtual void CreateConnections();
 
   /// \brief Called when the functionality is activated
   virtual void Activated();
 
   virtual void Deactivated();
 
   virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
   virtual void StdMultiWidgetNotAvailable();
 
   static const int nrconvkernels;
 
 protected slots:
 
   void ReconstructStandard();
   void AdvancedCheckboxClicked();
   void MethodChoosen(int method);
   void Reconstruct(int method, int normalization);
 
   void NumericalQBallReconstruction(mitk::DataStorage::SetOfObjects::Pointer inImages, int normalization);
   void AnalyticalQBallReconstruction(mitk::DataStorage::SetOfObjects::Pointer inImages, int normalization);
   void MultiQBallReconstruction(mitk::DataStorage::SetOfObjects::Pointer inImages);
 
 
   /**
    * @brief PreviewThreshold Generates a preview of the values that are cut off by the thresholds
    * @param threshold
    */
   void PreviewThreshold(int threshold);
 
 protected:
 
   /// \brief called by QmitkFunctionality when DataManager's selection has changed
   virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes );
 
   Ui::QmitkQBallReconstructionViewControls* m_Controls;
 
   QmitkStdMultiWidget* m_MultiWidget;
 
   template<int L>
   void TemplatedAnalyticalQBallReconstruction(mitk::DataNode* dataNodePointer, float lambda, int normalization);
 
   template<int L>
   void TemplatedMultiQBallReconstruction(float lambda, mitk::DataNode*);
 
   void SetDefaultNodeProperties(mitk::DataNode::Pointer node, std::string name);
 
   //void Create
 
   berry::ISelectionListener::Pointer m_SelListener;
   berry::IStructuredSelection::ConstPointer m_CurrentSelection;
 
   mitk::DataStorage::SetOfObjects::Pointer m_DiffusionImages;
 
 private:
 
   std::map< const mitk::DataNode *, QbrShellSelection * > m_ShellSelectorMap;
   void GenerateShellSelectionUI(mitk::DataStorage::SetOfObjects::Pointer set);
 };
 
 
 
 
 #endif // _QMITKQBALLRECONSTRUCTIONVIEW_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.cpp
index d2dd9a171d..a5ccce623d 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.cpp
@@ -1,290 +1,295 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 #include <berryIStructuredSelection.h>
 
 // Qmitk
 #include "QmitkStochasticFiberTrackingView.h"
 #include "QmitkStdMultiWidget.h"
 
 // Qt
 #include <QMessageBox>
 
 // MITK
 #include <mitkImageToItk.h>
 #include <mitkFiberBundleX.h>
+#include <mitkImageCast.h>
 
 // VTK
 #include <vtkPolyData.h>
 #include <vtkPoints.h>
 #include <vtkCellArray.h>
 #include <vtkSmartPointer.h>
 #include <vtkPolyLine.h>
 #include <vtkCellData.h>
 
 
 const std::string QmitkStochasticFiberTrackingView::VIEW_ID = "org.mitk.views.stochasticfibertracking";
 const std::string id_DataManager = "org.mitk.views.datamanager";
 using namespace berry;
 
 QmitkStochasticFiberTrackingView::QmitkStochasticFiberTrackingView()
     : QmitkFunctionality()
     , m_Controls( 0 )
     , m_MultiWidget( NULL )
     , m_SeedRoi( NULL )
     , m_DiffusionImage( NULL )
 {
 }
 
 // Destructor
 QmitkStochasticFiberTrackingView::~QmitkStochasticFiberTrackingView()
 {
 
 }
 
 void QmitkStochasticFiberTrackingView::CreateQtPartControl( QWidget *parent )
 {
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkStochasticFiberTrackingViewControls;
         m_Controls->setupUi( parent );
 
         connect( m_Controls->commandLinkButton, SIGNAL(clicked()), this, SLOT(DoFiberTracking()) );
         connect( m_Controls->m_SeedsPerVoxelSlider, SIGNAL(valueChanged(int)), this, SLOT(OnSeedsPerVoxelChanged(int)) );
         connect( m_Controls->m_MaxCacheSizeSlider, SIGNAL(valueChanged(int)), this, SLOT(OnMaxCacheSizeChanged(int)) );
         connect( m_Controls->m_MaxTractLengthSlider, SIGNAL(valueChanged(int)), this, SLOT(OnMaxTractLengthChanged(int)) );
     }
 }
 
 void QmitkStochasticFiberTrackingView::OnSeedsPerVoxelChanged(int value)
 {
     m_Controls->m_SeedsPerVoxelLabel->setText(QString("Seeds per Voxel: ")+QString::number(value));
 }
 
 void QmitkStochasticFiberTrackingView::OnMaxTractLengthChanged(int value)
 {
     m_Controls->m_MaxTractLengthLabel->setText(QString("Max. Tract Length: ")+QString::number(value));
 }
 
 void QmitkStochasticFiberTrackingView::OnMaxCacheSizeChanged(int value)
 {
     m_Controls->m_MaxCacheSizeLabel->setText(QString("Max. Cache Size: ")+QString::number(value)+"GB");
 }
 
 void QmitkStochasticFiberTrackingView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
     m_MultiWidget = &stdMultiWidget;
 }
 
 
 void QmitkStochasticFiberTrackingView::StdMultiWidgetNotAvailable()
 {
     m_MultiWidget = NULL;
 }
 
 void QmitkStochasticFiberTrackingView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
     m_DiffusionImageNode = NULL;
     m_DiffusionImage = NULL;
     m_SeedRoi = NULL;
     m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
     m_Controls->m_RoiImageLabel->setText("<font color='red'>mandatory</font>");
 
     for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
     {
         mitk::DataNode::Pointer node = *it;
 
         if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
         {
-            if( dynamic_cast<mitk::DiffusionImage<short>*>(node->GetData()) )
+          bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData())) );
+          if ( isDiffusionImage )
             {
                 m_DiffusionImageNode = node;
-                m_DiffusionImage = dynamic_cast<mitk::DiffusionImage<short>*>(node->GetData());
+                m_DiffusionImage = dynamic_cast<mitk::Image*>(node->GetData());
                 m_Controls->m_DiffusionImageLabel->setText(node->GetName().c_str());
             }
             else
             {
                 bool isBinary = false;
                 node->GetPropertyValue<bool>("binary", isBinary);
                 if (isBinary)
                 {
                     m_SeedRoi = dynamic_cast<mitk::Image*>(node->GetData());
                     m_Controls->m_RoiImageLabel->setText(node->GetName().c_str());
                 }
             }
         }
     }
 
     if(m_DiffusionImage.IsNotNull() && m_SeedRoi.IsNotNull())
     {
         m_Controls->m_InputData->setTitle("Input Data");
         m_Controls->commandLinkButton->setEnabled(true);
     }
     else
     {
         m_Controls->m_InputData->setTitle("Please Select Input Data");
         m_Controls->commandLinkButton->setEnabled(false);
     }
 }
 
 
 
 void QmitkStochasticFiberTrackingView::DoFiberTracking()
 {
     typedef itk::VectorImage< short int, 3 >    DWIVectorImageType;
     typedef itk::Image< float, 3 >              FloatImageType;
     typedef itk::Image< unsigned int, 3 >       CImageType;
     typedef itk::StochasticTractographyFilter< DWIVectorImageType, FloatImageType, CImageType > TrackingFilterType;
     typedef itk::DTITubeSpatialObject<3>        DTITubeType;
     typedef itk::DTITubeSpatialObjectPoint<3>   DTITubePointType;
     typedef itk::SceneSpatialObject<3>          SceneSpatialObjectType;
 
     /* get Gradients/Direction of dwi */
-    itk::VectorContainer< unsigned int, vnl_vector_fixed<double,3> >::Pointer Pdir = m_DiffusionImage->GetDirections();
+    GradientDirectionContainerType::Pointer Pdir = static_cast<mitk::GradientDirectionsProperty*>( m_DiffusionImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
 
     /* bValueContainer, Container includes b-values according to corresponding gradient-direction*/
     TrackingFilterType::bValueContainerType::Pointer vecCont = TrackingFilterType::bValueContainerType::New();
 
     /* for each gradient set b-Value; for 0-gradient set b-value eq. 0 */
     for ( int i=0; i<(int)Pdir->size(); ++i)
     {
         vnl_vector_fixed<double,3> valsGrad = Pdir->at(i);
         if (valsGrad.get(0) == 0 && valsGrad.get(1) == 0 && valsGrad.get(2) == 0)
         {  //set 0-Gradient to bValue 0
             vecCont->InsertElement(i,0);
         }else{
-            vecCont->InsertElement(i,m_DiffusionImage->GetReferenceBValue());
+            vecCont->InsertElement(i, static_cast<mitk::FloatProperty*>(m_DiffusionImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue());
         }
     }
 
     /* define measurement frame (identity-matrix 3x3) */
-    TrackingFilterType::MeasurementFrameType measurement_frame = m_DiffusionImage->GetMeasurementFrame();
+    TrackingFilterType::MeasurementFrameType measurement_frame =  static_cast<mitk::MeasurementFrameProperty*>(m_DiffusionImage->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )->GetMeasurementFrame();
 
     /* generate white matterImage (dummy?)*/
+    ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
+  mitk::CastToItkImage(m_DiffusionImage, itkVectorImagePointer);
+
     FloatImageType::Pointer wmImage = FloatImageType::New();
-    wmImage->SetSpacing( m_DiffusionImage->GetVectorImage()->GetSpacing() );
-    wmImage->SetOrigin( m_DiffusionImage->GetVectorImage()->GetOrigin() );
-    wmImage->SetDirection( m_DiffusionImage->GetVectorImage()->GetDirection() );
-    wmImage->SetLargestPossibleRegion( m_DiffusionImage->GetVectorImage()->GetLargestPossibleRegion() );
+    wmImage->SetSpacing( itkVectorImagePointer->GetSpacing() );
+    wmImage->SetOrigin( itkVectorImagePointer->GetOrigin() );
+    wmImage->SetDirection( itkVectorImagePointer->GetDirection() );
+    wmImage->SetLargestPossibleRegion( itkVectorImagePointer->GetLargestPossibleRegion() );
     wmImage->SetBufferedRegion( wmImage->GetLargestPossibleRegion() );
     wmImage->SetRequestedRegion( wmImage->GetLargestPossibleRegion() );
     wmImage->Allocate();
 
     itk::ImageRegionIterator<FloatImageType> ot(wmImage, wmImage->GetLargestPossibleRegion() );
     while (!ot.IsAtEnd())
     {
         ot.Set(1);
         ++ot;
     }
 
     /* init TractographyFilter */
     TrackingFilterType::Pointer trackingFilter = TrackingFilterType::New();
-    trackingFilter->SetPrimaryInput(m_DiffusionImage->GetVectorImage().GetPointer());
+    trackingFilter->SetPrimaryInput(itkVectorImagePointer.GetPointer());
     trackingFilter->SetbValues(vecCont);
     trackingFilter->SetGradients(Pdir);
     trackingFilter->SetMeasurementFrame(measurement_frame);
     trackingFilter->SetWhiteMatterProbabilityImage(wmImage);
     trackingFilter->SetTotalTracts(m_Controls->m_SeedsPerVoxelSlider->value());
     trackingFilter->SetMaxLikelihoodCacheSize(m_Controls->m_MaxCacheSizeSlider->value()*1000);
     trackingFilter->SetMaxTractLength(m_Controls->m_MaxTractLengthSlider->value());
 
     //itk::Image< char, 3 >
     mitk::ImageToItk< itk::Image< unsigned char, 3 > >::Pointer binaryImageToItk1 = mitk::ImageToItk< itk::Image< unsigned char, 3 > >::New();
     binaryImageToItk1->SetInput( m_SeedRoi );
     binaryImageToItk1->Update();
 
     vtkSmartPointer<vtkPoints> vPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vCellArray = vtkSmartPointer<vtkCellArray>::New();
 
     itk::ImageRegionConstIterator< BinaryImageType > it(binaryImageToItk1->GetOutput(), binaryImageToItk1->GetOutput()->GetRequestedRegion());
     it.GoToBegin();
     mitk::BaseGeometry* geom = m_DiffusionImage->GetGeometry();
 
     while(!it.IsAtEnd())
     {
         itk::ImageConstIterator<BinaryImageType>::PixelType tmpPxValue = it.Get();
 
         if(tmpPxValue != 0){
             mitk::Point3D point;
             itk::ImageRegionConstIterator< BinaryImageType >::IndexType seedIdx = it.GetIndex();
             trackingFilter->SetSeedIndex(seedIdx);
             trackingFilter->Update();
 
 
             /* get results from Filter */
             /* write each single tract into member container */
             TrackingFilterType::TractContainerType::Pointer container_tmp = trackingFilter->GetOutputTractContainer();
             TrackingFilterType::TractContainerType::Iterator elIt = container_tmp->Begin();
             TrackingFilterType::TractContainerType::Iterator end = container_tmp->End();
             bool addTract = true;
 
             while( elIt != end ){
                 TrackingFilterType::TractContainerType::Element tract = elIt.Value();
                 TrackingFilterType::TractContainerType::Element::ObjectType::VertexListType::ConstPointer vertexlist = tract->GetVertexList();
 
                 vtkSmartPointer<vtkPolyLine> vPolyLine = vtkSmartPointer<vtkPolyLine>::New();
                 for( int j=0; j<(int)vertexlist->Size(); j++)
                 {
                     TrackingFilterType::TractContainerType::Element::ObjectType::VertexListType::Element vertex = vertexlist->GetElement(j);
                     mitk::Point3D index;
                     index[0] = (float)vertex[0];
                     index[1] = (float)vertex[1];
                     index[2] = (float)vertex[2];
 
                     if (geom->IsIndexInside(index))
                     {
                         geom->IndexToWorld(index, point);
                         vtkIdType id = vPoints->InsertNextPoint(point.GetDataPointer());
                         vPolyLine->GetPointIds()->InsertNextId(id);
                     }
                     else
                     {
                         addTract = false;
                         break;
                     }
                 }
 
                 if (addTract)
                     vCellArray->InsertNextCell(vPolyLine);
 
                 ++elIt;
             }
         }
         ++it;
     }
 
     vtkSmartPointer<vtkPolyData> fiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     fiberPolyData->SetPoints(vPoints);
     fiberPolyData->SetLines(vCellArray);
 
     mitk::FiberBundleX::Pointer fib = mitk::FiberBundleX::New(fiberPolyData);
     fib->SetReferenceGeometry(dynamic_cast<mitk::Image*>(m_DiffusionImageNode->GetData())->GetGeometry());
     mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
     fbNode->SetData(fib);
     QString name("FiberBundle_");
     name += m_DiffusionImageNode->GetName().c_str();
     name += "_Probabilistic";
     fbNode->SetName(name.toStdString());
     fbNode->SetVisibility(true);
     GetDataStorage()->Add(fbNode, m_DiffusionImageNode);
 }
 
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.h
index 6134f6670f..26bff1e2af 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.h
@@ -1,83 +1,89 @@
 /*===================================================================
 
 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 QmitkStochasticFiberTrackingView_h
 #define QmitkStochasticFiberTrackingView_h
 
 #include <QmitkFunctionality.h>
 #include "ui_QmitkStochasticFiberTrackingViewControls.h"
-#include <mitkDiffusionImage.h>
 #include <mitkDataStorage.h>
 #include <itkVectorImage.h>
 #include <itkImage.h>
 #include <itkDTITubeSpatialObject.h>
 #include <itkDTITubeSpatialObjectPoint.h>
 #include <itkSceneSpatialObject.h>
 #include <itkStochasticTractographyFilter.h>
+#include <mitkDiffusionPropertyHelper.h>
 
 /*!
 \brief View for probabilistic streamline fiber tracking
 \sa QmitkFunctionality
 \ingroup Functionalities
 */
 class QmitkStochasticFiberTrackingView : public QmitkFunctionality
 {
     // this is needed for all Qt objects that should have a Qt meta-object
     // (everything that derives from QObject and wants to have signal/slots)
     Q_OBJECT
 
 public:
 
+  typedef short                                                           DiffusionPixelType;
+  typedef mitk::DiffusionPropertyHelper::GradientDirectionType            GradientDirectionType;
+  typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType  GradientDirectionContainerType;
+  typedef mitk::DiffusionPropertyHelper::BValueMapType                    BValueMapType;
+  typedef itk::VectorImage< DiffusionPixelType, 3 >                       ITKDiffusionImageType;
+
     typedef itk::Image< unsigned char, 3 >  BinaryImageType;
 
     static const std::string VIEW_ID;
 
     QmitkStochasticFiberTrackingView();
     virtual ~QmitkStochasticFiberTrackingView();
 
     virtual void CreateQtPartControl(QWidget *parent);
     virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
     virtual void StdMultiWidgetNotAvailable();
 
 protected slots:
 
     void DoFiberTracking();   ///< start fiber tracking
 
 protected:
 
     /// \brief called by QmitkFunctionality when DataManager's selection has changed
     virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes );
     Ui::QmitkStochasticFiberTrackingViewControls* m_Controls;
     QmitkStdMultiWidget* m_MultiWidget;
 
 protected slots:
 
     /** update labels if parameters have changed */
     void OnSeedsPerVoxelChanged(int value);
     void OnMaxTractLengthChanged(int value);
     void OnMaxCacheSizeChanged(int value);
 
 private:
 
     mitk::Image::Pointer                  m_SeedRoi;              ///< binary image defining seed voxels for tracking process
-    mitk::DiffusionImage<short>::Pointer  m_DiffusionImage;       ///< input image
+    mitk::Image::Pointer                  m_DiffusionImage;       ///< input image
     mitk::DataNode::Pointer               m_DiffusionImageNode;   ///< data node containing input image
 };
 
 
 
 #endif // _QMITKFIBERTRACKINGVIEW_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTensorReconstructionView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTensorReconstructionView.cpp
index bc98ff91f9..f71eae8d1c 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTensorReconstructionView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTensorReconstructionView.cpp
@@ -1,1054 +1,1068 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include "QmitkTensorReconstructionView.h"
 #include "mitkDiffusionImagingConfigure.h"
 
 // qt includes
 #include <QMessageBox>
 #include <QImage>
 #include <QGraphicsScene>
 #include <QGraphicsPixmapItem>
 #include <QGraphicsLinearLayout>
 
 
 // itk includes
 #include "itkTimeProbe.h"
 //#include "itkTensor.h"
 
 // mitk includes
 #include "mitkProgressBar.h"
 #include "mitkStatusBar.h"
 
 #include "mitkNodePredicateDataType.h"
 #include "QmitkDataStorageComboBox.h"
 #include "QmitkStdMultiWidget.h"
 
 #include "mitkTeemDiffusionTensor3DReconstructionImageFilter.h"
 #include "itkDiffusionTensor3DReconstructionImageFilter.h"
 #include "itkTensorImageToDiffusionImageFilter.h"
 #include "itkPointShell.h"
 #include "itkVector.h"
 #include "itkB0ImageExtractionImageFilter.h"
 #include "itkTensorReconstructionWithEigenvalueCorrectionFilter.h"
 
 #include "mitkImageCast.h"
 #include "mitkImageAccessByItk.h"
 #include <itkBinaryThresholdImageFilter.h>
-
+#include <mitkImageVtkMapper2D.h>
 
 #include "mitkProperties.h"
 #include "mitkDataNodeObject.h"
 #include "mitkOdfNormalizationMethodProperty.h"
 #include "mitkOdfScaleByProperty.h"
-#include "mitkDiffusionImageMapper.h"
 #include "mitkLookupTableProperty.h"
 #include "mitkLookupTable.h"
 #include "mitkImageStatisticsHolder.h"
+#include <mitkITKImageImport.h>
 
 #include <itkTensorImageToQBallImageFilter.h>
 #include <itkResidualImageFilter.h>
 
 #include <berryIWorkbenchWindow.h>
 #include <berryISelectionService.h>
+#include <mitkImageVtkMapper2D.h>
 
 const std::string QmitkTensorReconstructionView::VIEW_ID = "org.mitk.views.tensorreconstruction";
 
 typedef float                                       TTensorPixelType;
 typedef itk::DiffusionTensor3D< TTensorPixelType >  TensorPixelType;
 typedef itk::Image< TensorPixelType, 3 >            TensorImageType;
 
 using namespace berry;
 
 QmitkTensorReconstructionView::QmitkTensorReconstructionView()
     : QmitkFunctionality(),
       m_Controls(NULL),
       m_MultiWidget(NULL)
 {
     m_DiffusionImages = mitk::DataStorage::SetOfObjects::New();
     m_TensorImages = mitk::DataStorage::SetOfObjects::New();
 }
 
 QmitkTensorReconstructionView::~QmitkTensorReconstructionView()
 {
 
 }
 
 void QmitkTensorReconstructionView::CreateQtPartControl(QWidget *parent)
 {
     if (!m_Controls)
     {
         // create GUI widgets
         m_Controls = new Ui::QmitkTensorReconstructionViewControls;
         m_Controls->setupUi(parent);
         this->CreateConnections();
 
         Advanced1CheckboxClicked();
     }
 }
 
 void QmitkTensorReconstructionView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
     m_MultiWidget = &stdMultiWidget;
 }
 
 void QmitkTensorReconstructionView::StdMultiWidgetNotAvailable()
 {
     m_MultiWidget = NULL;
 }
 
 void QmitkTensorReconstructionView::CreateConnections()
 {
     if ( m_Controls )
     {
         connect( (QObject*)(m_Controls->m_StartReconstruction), SIGNAL(clicked()), this, SLOT(Reconstruct()) );
         connect( (QObject*)(m_Controls->m_Advanced1), SIGNAL(clicked()), this, SLOT(Advanced1CheckboxClicked()) );
         connect( (QObject*)(m_Controls->m_TensorsToDWIButton), SIGNAL(clicked()), this, SLOT(TensorsToDWI()) );
         connect( (QObject*)(m_Controls->m_TensorsToQbiButton), SIGNAL(clicked()), this, SLOT(TensorsToQbi()) );
         connect( (QObject*)(m_Controls->m_ResidualButton), SIGNAL(clicked()), this, SLOT(ResidualCalculation()) );
         connect( (QObject*)(m_Controls->m_PerSliceView), SIGNAL(pointSelected(int, int)), this, SLOT(ResidualClicked(int, int)) );
         connect( (QObject*)(m_Controls->m_TensorReconstructionThreshold), SIGNAL(valueChanged(int)), this, SLOT(PreviewThreshold(int)) );
     }
 }
 
 void QmitkTensorReconstructionView::ResidualClicked(int slice, int volume)
 {
     // Use image coord to reset crosshair
 
     // Find currently selected diffusion image
 
     // Update Label
 
 
     // to do: This position should be modified in order to skip B0 volumes that are not taken into account
     // when calculating residuals
 
     // Find the diffusion image
-    mitk::DiffusionImage<DiffusionPixelType>* diffImage;
+    mitk::Image* diffImage;
     mitk::DataNode::Pointer correctNode;
     mitk::BaseGeometry* geometry;
 
+    bool isDiffusionImage(false);
+
     if (m_DiffusionImage.IsNotNull())
     {
-        diffImage = static_cast<mitk::DiffusionImage<DiffusionPixelType>*>(m_DiffusionImage->GetData());
+      isDiffusionImage = mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_DiffusionImage->GetData())) ;
+      diffImage = static_cast<mitk::Image*>(m_DiffusionImage->GetData());
 
-        geometry = diffImage->GetGeometry();
+        geometry = m_DiffusionImage->GetData()->GetGeometry();
 
         // Remember the node whose display index must be updated
         correctNode = mitk::DataNode::New();
         correctNode = m_DiffusionImage;
     }
 
-    if(diffImage != NULL)
+    if( isDiffusionImage )
     {
-        typedef vnl_vector_fixed< double, 3 >       GradientDirectionType;
-        typedef itk::VectorContainer< unsigned int,
-                GradientDirectionType >                   GradientDirectionContainerType;
 
-        GradientDirectionContainerType::Pointer dirs = diffImage->GetDirections();
+        GradientDirectionContainerType::Pointer dirs = static_cast<mitk::GradientDirectionsProperty*>( diffImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
 
         for(unsigned int i=0; i<dirs->Size() && i<=volume; i++)
         {
             GradientDirectionType grad = dirs->ElementAt(i);
 
             // check if image is b0 weighted
             if(fabs(grad[0]) < 0.001 && fabs(grad[1]) < 0.001 && fabs(grad[2]) < 0.001)
             {
                 volume++;
             }
         }
 
         QString pos = "Volume: ";
         pos.append(QString::number(volume));
         pos.append(", Slice: ");
         pos.append(QString::number(slice));
         m_Controls->m_PositionLabel->setText(pos);
 
         if(correctNode)
         {
             int oldDisplayVal;
             correctNode->GetIntProperty("DisplayChannel", oldDisplayVal);
             std::string oldVal = QString::number(oldDisplayVal).toStdString();
             std::string newVal = QString::number(volume).toStdString();
             correctNode->SetIntProperty("DisplayChannel",volume);
             correctNode->SetSelected(true);
             this->FirePropertyChanged("DisplayChannel", oldVal, newVal);
             correctNode->UpdateOutputInformation();
 
 
             mitk::Point3D p3 = m_MultiWidget->GetCrossPosition();
             itk::Index<3> ix;
             geometry->WorldToIndex(p3, ix);
             // ix[2] = slice;
 
             mitk::Vector3D vec;
             vec[0] = ix[0];
             vec[1] = ix[1];
             vec[2] = slice;
 
             mitk::Vector3D v3New;
             geometry->IndexToWorld(vec, v3New);
             mitk::Point3D origin = geometry->GetOrigin();
             mitk::Point3D p3New;
             p3New[0] = v3New[0] + origin[0];
             p3New[1] = v3New[1] + origin[1];
             p3New[2] = v3New[2] + origin[2];
 
             m_MultiWidget->MoveCrossToPosition(p3New);
             m_MultiWidget->RequestUpdate();
         }
     }
 }
 
 void QmitkTensorReconstructionView::Advanced1CheckboxClicked()
 {
     bool check = m_Controls->
             m_Advanced1->isChecked();
 
     m_Controls->frame->setVisible(check);
 }
 
 void QmitkTensorReconstructionView::Activated()
 {
     QmitkFunctionality::Activated();
 
 }
 
 void QmitkTensorReconstructionView::Deactivated()
 {
 
     // Get all current nodes
 
     mitk::DataStorage::SetOfObjects::ConstPointer objects =  this->GetDefaultDataStorage()->GetAll();
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( objects->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( objects->end() );
     while ( itemiter != itemiterend ) // for all items
     {
         mitk::DataNode::Pointer node = *itemiter;
         if (node.IsNull())
             continue;
 
         // only look at interesting types
-        if(dynamic_cast<mitk::DiffusionImage<short>*>(node->GetData()))
+        if( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(dynamic_cast<mitk::Image*>(node->GetData())))
         {
             if (this->GetDefaultDataStorage()->GetNamedDerivedNode("ThresholdOverlay", *itemiter))
             {
                 node = this->GetDefaultDataStorage()->GetNamedDerivedNode("ThresholdOverlay", *itemiter);
                 this->GetDefaultDataStorage()->Remove(node);
             }
         }
         itemiter++;
     }
 
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
     QmitkFunctionality::Deactivated();
 }
 
 void QmitkTensorReconstructionView::ResidualCalculation()
 {
     // Extract dwi and dti from current selection
     // In case of multiple selections, take the first one, since taking all combinations is not meaningful
 
     mitk::DataStorage::SetOfObjects::Pointer set =
             mitk::DataStorage::SetOfObjects::New();
 
-    mitk::DiffusionImage<DiffusionPixelType>::Pointer diffImage
-            = mitk::DiffusionImage<DiffusionPixelType>::New();
+    mitk::Image::Pointer diffImage
+            = mitk::Image::New();
 
     TensorImageType::Pointer tensorImage;
 
     std::string nodename;
 
     if(m_DiffusionImage.IsNotNull())
     {
-        diffImage = static_cast<mitk::DiffusionImage<DiffusionPixelType>*>(m_DiffusionImage->GetData());
+        diffImage = static_cast<mitk::Image*>(m_DiffusionImage->GetData());
     }
     else
         return;
     if(m_TensorImage.IsNotNull())
     {
         mitk::TensorImage* mitkVol;
         mitkVol = static_cast<mitk::TensorImage*>(m_TensorImage->GetData());
         mitk::CastToItkImage(mitkVol, tensorImage);
         m_TensorImage->GetStringProperty("name", nodename);
     }
     else
         return;
 
     typedef itk::TensorImageToDiffusionImageFilter<
             TTensorPixelType, DiffusionPixelType > FilterType;
 
-    mitk::DiffusionImage<DiffusionPixelType>::GradientDirectionContainerType* gradients
-            = diffImage->GetDirections();
+    GradientDirectionContainerType* gradients
+            =  static_cast<mitk::GradientDirectionsProperty*>( diffImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
 
     // Find the min and the max values from a baseline image
     mitk::ImageStatisticsHolder *stats = diffImage->GetStatistics();
 
     //Initialize filter that calculates the modeled diffusion weighted signals
     FilterType::Pointer filter = FilterType::New();
     filter->SetInput( tensorImage );
-    filter->SetBValue(diffImage->GetReferenceBValue());
+    filter->SetBValue( static_cast<mitk::FloatProperty*>(diffImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue());
     filter->SetGradientList(gradients);
     filter->SetMin(stats->GetScalarValueMin());
     filter->SetMax(stats->GetScalarValueMax());
     filter->Update();
 
 
     // TENSORS TO DATATREE
-    mitk::DiffusionImage<DiffusionPixelType>::Pointer image = mitk::DiffusionImage<DiffusionPixelType>::New();
-    image->SetVectorImage( filter->GetOutput() );
-    image->SetReferenceBValue(diffImage->GetReferenceBValue());
-    image->SetDirections(gradients);
-    image->InitializeFromVectorImage();
+    mitk::Image::Pointer image = mitk::GrabItkImageMemory( filter->GetOutput() );
+    image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( gradients ) );
+    image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>(diffImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() ) );
+    image->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( static_cast<mitk::MeasurementFrameProperty*>(diffImage->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )->GetMeasurementFrame() ) );
+    mitk::DiffusionPropertyHelper propertyHelper( image );
+    propertyHelper.InitializeImage();
+
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData( image );
-    mitk::DiffusionImageMapper<short>::SetDefaultProperties(node);
-    node->SetName("Estimated DWI");
+    mitk::ImageVtkMapper2D::SetDefaultProperties(node);
 
     QString newname;
     newname = newname.append(nodename.c_str());
-    newname = newname.append("_DWI");
+    newname = newname.append("_Estimated DWI");
     node->SetName(newname.toLatin1());
 
     GetDefaultDataStorage()->Add(node, m_TensorImage);
 
-    mitk::DiffusionImage<DiffusionPixelType>::BValueMap map =image->GetBValueMap();
-    mitk::DiffusionImage<DiffusionPixelType>::IndicesVector b0Indices = map[0];
+    BValueMapType map = static_cast<mitk::BValueMapProperty*>(image->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )->GetBValueMap();;
+    std::vector< unsigned int > b0Indices = map[0];
 
 
     typedef itk::ResidualImageFilter<DiffusionPixelType, float> ResidualImageFilterType;
 
+    ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
+    mitk::CastToItkImage(diffImage, itkVectorImagePointer);
+    ITKDiffusionImageType::Pointer itkSecondVectorImagePointer = ITKDiffusionImageType::New();
+    mitk::CastToItkImage(image, itkSecondVectorImagePointer);
+
     ResidualImageFilterType::Pointer residualFilter = ResidualImageFilterType::New();
-    residualFilter->SetInput(diffImage->GetVectorImage());
-    residualFilter->SetSecondDiffusionImage(image->GetVectorImage());
+    residualFilter->SetInput( itkVectorImagePointer );
+    residualFilter->SetSecondDiffusionImage( itkSecondVectorImagePointer );
     residualFilter->SetGradients(gradients);
     residualFilter->SetB0Index(b0Indices[0]);
     residualFilter->SetB0Threshold(30);
     residualFilter->Update();
 
     itk::Image<float, 3>::Pointer residualImage = itk::Image<float, 3>::New();
     residualImage = residualFilter->GetOutput();
 
     mitk::Image::Pointer mitkResImg = mitk::Image::New();
 
     mitk::CastToMitkImage(residualImage, mitkResImg);
 
     stats = mitkResImg->GetStatistics();
     float min = stats->GetScalarValueMin();
     float max = stats->GetScalarValueMax();
 
     mitk::LookupTableProperty::Pointer lutProp = mitk::LookupTableProperty::New();
     mitk::LookupTable::Pointer lut = mitk::LookupTable::New();
 
 
     vtkSmartPointer<vtkLookupTable> lookupTable =
             vtkSmartPointer<vtkLookupTable>::New();
 
     lookupTable->SetTableRange(min, max);
 
 
     // If you don't want to use the whole color range, you can use
     // SetValueRange, SetHueRange, and SetSaturationRange
     lookupTable->Build();
 
     vtkSmartPointer<vtkLookupTable> reversedlookupTable =
             vtkSmartPointer<vtkLookupTable>::New();
     reversedlookupTable->SetTableRange(min+1, max);
     reversedlookupTable->Build();
 
     for(int i=0; i<256; i++)
     {
         double* rgba = reversedlookupTable->GetTableValue(255-i);
 
         lookupTable->SetTableValue(i, rgba[0], rgba[1], rgba[2], rgba[3]);
     }
 
     lut->SetVtkLookupTable(lookupTable);
     lutProp->SetLookupTable(lut);
 
     // Create lookuptable
 
     mitk::DataNode::Pointer resNode=mitk::DataNode::New();
     resNode->SetData( mitkResImg );
     resNode->SetName("Residuals");
 
     resNode->SetProperty("LookupTable", lutProp);
 
     bool b;
     resNode->GetBoolProperty("use color", b);
     resNode->SetBoolProperty("use color", false);
 
     GetDefaultDataStorage()->Add(resNode, m_TensorImage);
 
     m_MultiWidget->RequestUpdate();
 
 
 
     // Draw Graph
     std::vector<double> means = residualFilter->GetMeans();
     std::vector<double> q1s = residualFilter->GetQ1();
     std::vector<double> q3s = residualFilter->GetQ3();
     std::vector<double> percentagesOfOUtliers = residualFilter->GetPercentagesOfOutliers();
 
     m_Controls->m_ResidualAnalysis->SetMeans(means);
     m_Controls->m_ResidualAnalysis->SetQ1(q1s);
     m_Controls->m_ResidualAnalysis->SetQ3(q3s);
     m_Controls->m_ResidualAnalysis->SetPercentagesOfOutliers(percentagesOfOUtliers);
 
     if(m_Controls->m_PercentagesOfOutliers->isChecked())
     {
         m_Controls->m_ResidualAnalysis->DrawPercentagesOfOutliers();
     }
     else
     {
         m_Controls->m_ResidualAnalysis->DrawMeans();
     }
 
 
 
     // Draw Graph for volumes per slice in the QGraphicsView
     std::vector< std::vector<double> > outliersPerSlice = residualFilter->GetOutliersPerSlice();
     int xSize = outliersPerSlice.size();
     if(xSize == 0)
     {
         return;
     }
     int ySize = outliersPerSlice[0].size();
 
 
     // Find maximum in outliersPerSlice
     double maxOutlier= 0.0;
     for(int i=0; i<xSize; i++)
     {
         for(int j=0; j<ySize; j++)
         {
             if(outliersPerSlice[i][j]>maxOutlier)
             {
                 maxOutlier = outliersPerSlice[i][j];
             }
         }
     }
 
 
     // Create some QImage
     QImage qImage(xSize, ySize, QImage::Format_RGB32);
     QImage legend(1, 256, QImage::Format_RGB32);
     QRgb value;
 
     vtkSmartPointer<vtkLookupTable> lookup =
             vtkSmartPointer<vtkLookupTable>::New();
 
     lookup->SetTableRange(0.0, maxOutlier);
     lookup->Build();
 
     reversedlookupTable->SetTableRange(0, maxOutlier);
     reversedlookupTable->Build();
 
     for(int i=0; i<256; i++)
     {
         double* rgba = reversedlookupTable->GetTableValue(255-i);
         lookup->SetTableValue(i, rgba[0], rgba[1], rgba[2], rgba[3]);
     }
 
 
     // Fill qImage
     for(int i=0; i<xSize; i++)
     {
         for(int j=0; j<ySize; j++)
         {
             double out = outliersPerSlice[i][j];
 
             unsigned char *_rgba = lookup->MapValue(out);
             int r, g, b;
             r = _rgba[0];
             g = _rgba[1];
             b = _rgba[2];
 
             value = qRgb(r, g, b);
 
             qImage.setPixel(i,j,value);
 
         }
     }
 
     for(int i=0; i<256; i++)
     {
         double* rgba = lookup->GetTableValue(i);
         int r, g, b;
         r = rgba[0]*255;
         g = rgba[1]*255;
         b = rgba[2]*255;
         value = qRgb(r, g, b);
         legend.setPixel(0,255-i,value);
     }
 
     QString upper = QString::number(maxOutlier, 'g', 3);
     upper.append(" %");
     QString lower = QString::number(0.0);
     lower.append(" %");
     m_Controls->m_UpperLabel->setText(upper);
     m_Controls->m_LowerLabel->setText(lower);
 
     QPixmap pixmap(QPixmap::fromImage(qImage));
     QGraphicsPixmapItem *item = new QGraphicsPixmapItem(pixmap);
     item->setTransform(QTransform::fromScale(10.0, 3.0), true);
 
     QPixmap pixmap2(QPixmap::fromImage(legend));
     QGraphicsPixmapItem *item2 = new QGraphicsPixmapItem(pixmap2);
     item2->setTransform(QTransform::fromScale(20.0, 1.0), true);
 
     m_Controls->m_PerSliceView->SetResidualPixmapItem(item);
 
     QGraphicsScene* scene = new QGraphicsScene;
     QGraphicsScene* scene2 = new QGraphicsScene;
 
     scene->addItem(item);
     scene2->addItem(item2);
 
     m_Controls->m_PerSliceView->setScene(scene);
     m_Controls->m_LegendView->setScene(scene2);
     m_Controls->m_PerSliceView->show();
     m_Controls->m_PerSliceView->repaint();
 
     m_Controls->m_LegendView->setHorizontalScrollBarPolicy ( Qt::ScrollBarAlwaysOff );
     m_Controls->m_LegendView->setVerticalScrollBarPolicy ( Qt::ScrollBarAlwaysOff );
     m_Controls->m_LegendView->show();
     m_Controls->m_LegendView->repaint();
 }
 
 void QmitkTensorReconstructionView::Reconstruct()
 {
     int method = m_Controls->m_ReconctructionMethodBox->currentIndex();
 
     switch (method)
     {
     case 0:
         ItkTensorReconstruction(m_DiffusionImages);
         break;
     case 1:
         TensorReconstructionWithCorr(m_DiffusionImages);
         break;
     default:
         ItkTensorReconstruction(m_DiffusionImages);
     }
 }
 
 void QmitkTensorReconstructionView::TensorReconstructionWithCorr
 (mitk::DataStorage::SetOfObjects::Pointer inImages)
 {
     try
     {
         int nrFiles = inImages->size();
         if (!nrFiles) return;
 
         QString status;
         mitk::ProgressBar::GetInstance()->AddStepsToDo(nrFiles);
 
         mitk::DataStorage::SetOfObjects::const_iterator itemiter( inImages->begin() );
         mitk::DataStorage::SetOfObjects::const_iterator itemiterend( inImages->end() );
 
         while ( itemiter != itemiterend ) // for all items
         {
 
-            typedef mitk::DiffusionImage<DiffusionPixelType> DiffusionImageType;
-            typedef DiffusionImageType::GradientDirectionContainerType GradientDirectionContainerType;
-
-            DiffusionImageType* vols = static_cast<DiffusionImageType*>((*itemiter)->GetData());
+            mitk::Image* vols = static_cast<mitk::Image*>((*itemiter)->GetData());
 
             std::string nodename;
             (*itemiter)->GetStringProperty("name", nodename);
 
             // TENSOR RECONSTRUCTION
             MITK_INFO << "Tensor reconstruction with correction for negative eigenvalues";
             mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Tensor reconstruction for %s", nodename.c_str()).toLatin1());
 
             typedef itk::TensorReconstructionWithEigenvalueCorrectionFilter< DiffusionPixelType, TTensorPixelType > ReconstructionFilter;
 
             float b0Threshold = m_Controls->m_TensorReconstructionThreshold->value();
 
             GradientDirectionContainerType::Pointer gradientContainerCopy = GradientDirectionContainerType::New();
-            for(GradientDirectionContainerType::ConstIterator it = vols->GetDirections()->Begin();
-              it != vols->GetDirections()->End(); it++)
+            for(GradientDirectionContainerType::ConstIterator it = static_cast<mitk::GradientDirectionsProperty*>( vols->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer()->Begin();
+              it != static_cast<mitk::GradientDirectionsProperty*>( vols->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer()->End(); it++)
             {
               gradientContainerCopy->push_back(it.Value());
             }
 
+            ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
+            mitk::CastToItkImage(vols, itkVectorImagePointer);
+
             ReconstructionFilter::Pointer reconFilter = ReconstructionFilter::New();
-            reconFilter->SetGradientImage( gradientContainerCopy, vols->GetVectorImage() );
-            reconFilter->SetBValue(vols->GetReferenceBValue());
+            reconFilter->SetGradientImage( gradientContainerCopy, itkVectorImagePointer);
+            reconFilter->SetBValue( static_cast<mitk::FloatProperty*>(vols->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
             reconFilter->SetB0Threshold(b0Threshold);
             reconFilter->Update();
 
             typedef itk::Image<itk::DiffusionTensor3D<TTensorPixelType>, 3> TensorImageType;
             TensorImageType::Pointer outputTensorImg = reconFilter->GetOutput();
 
             typedef itk::ImageRegionIterator<TensorImageType> TensorImageIteratorType;
             TensorImageIteratorType tensorIt(outputTensorImg, outputTensorImg->GetRequestedRegion());
             tensorIt.GoToBegin();
 
             int negatives = 0;
             while(!tensorIt.IsAtEnd())
             {
                 typedef itk::DiffusionTensor3D<TTensorPixelType> TensorType;
                 TensorType tensor = tensorIt.Get();
 
                 TensorType::EigenValuesArrayType ev;
                 tensor.ComputeEigenValues(ev);
 
                 for(unsigned int i=0; i<ev.Size(); i++)
                 {
                     if(ev[i] < 0.0)
                     {
                         tensor.Fill(0.0);
                         tensorIt.Set(tensor);
                         negatives++;
                         break;
                     }
                 }
                 ++tensorIt;
             }
             MITK_INFO << negatives << " tensors with negative eigenvalues" << std::endl;
 
             mitk::TensorImage::Pointer image = mitk::TensorImage::New();
             image->InitializeByItk( outputTensorImg.GetPointer() );
             image->SetVolume( outputTensorImg->GetBufferPointer() );
             mitk::DataNode::Pointer node=mitk::DataNode::New();
             node->SetData( image );
             SetDefaultNodeProperties(node, nodename+"_EigenvalueCorrected_DT");
             GetDefaultDataStorage()->Add(node, *itemiter);
 
             mitk::ProgressBar::GetInstance()->Progress();
             ++itemiter;
         }
 
         mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Finished Processing %d Files", nrFiles).toLatin1());
         m_MultiWidget->RequestUpdate();
     }
     catch (itk::ExceptionObject &ex)
     {
         MITK_INFO << ex ;
         QMessageBox::information(0, "Reconstruction not possible:", ex.GetDescription());
     }
 }
 
 void QmitkTensorReconstructionView::ItkTensorReconstruction(mitk::DataStorage::SetOfObjects::Pointer inImages)
 {
     try
     {
         itk::TimeProbe clock;
 
         int nrFiles = inImages->size();
         if (!nrFiles) return;
 
         QString status;
         mitk::ProgressBar::GetInstance()->AddStepsToDo(nrFiles);
 
         mitk::DataStorage::SetOfObjects::const_iterator itemiter( inImages->begin() );
         mitk::DataStorage::SetOfObjects::const_iterator itemiterend( inImages->end() );
 
         while ( itemiter != itemiterend ) // for all items
         {
 
-            mitk::DiffusionImage<DiffusionPixelType>* vols =
-                    static_cast<mitk::DiffusionImage<DiffusionPixelType>*>(
+            mitk::Image* vols =
+                    static_cast<mitk::Image*>(
                         (*itemiter)->GetData());
 
             std::string nodename;
             (*itemiter)->GetStringProperty("name", nodename);
 
             // TENSOR RECONSTRUCTION
             clock.Start();
             MITK_DEBUG << "Tensor reconstruction ";
             mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Tensor reconstruction for %s", nodename.c_str()).toLatin1());
             typedef itk::DiffusionTensor3DReconstructionImageFilter<
                     DiffusionPixelType, DiffusionPixelType, TTensorPixelType > TensorReconstructionImageFilterType;
             TensorReconstructionImageFilterType::Pointer tensorReconstructionFilter =
                     TensorReconstructionImageFilterType::New();
 
-            typedef mitk::DiffusionImage<DiffusionPixelType> DiffusionImageType;
-            typedef DiffusionImageType::GradientDirectionContainerType GradientDirectionContainerType;
-
             GradientDirectionContainerType::Pointer gradientContainerCopy = GradientDirectionContainerType::New();
-            for(GradientDirectionContainerType::ConstIterator it = vols->GetDirections()->Begin();
-              it != vols->GetDirections()->End(); it++)
+            for(GradientDirectionContainerType::ConstIterator it = static_cast<mitk::GradientDirectionsProperty*>( vols->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer()->Begin();
+              it != static_cast<mitk::GradientDirectionsProperty*>( vols->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer()->End(); it++)
             {
               gradientContainerCopy->push_back(it.Value());
             }
 
-            tensorReconstructionFilter->SetGradientImage( gradientContainerCopy, vols->GetVectorImage() );
-            tensorReconstructionFilter->SetBValue(vols->GetReferenceBValue());
+            ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
+            mitk::CastToItkImage(vols, itkVectorImagePointer);
+
+            tensorReconstructionFilter->SetGradientImage( gradientContainerCopy, itkVectorImagePointer );
+            tensorReconstructionFilter->SetBValue(  static_cast<mitk::FloatProperty*>(vols->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
             tensorReconstructionFilter->SetThreshold( m_Controls->m_TensorReconstructionThreshold->value() );
             tensorReconstructionFilter->Update();
             clock.Stop();
             MITK_DEBUG << "took " << clock.GetMean() << "s.";
 
             // TENSORS TO DATATREE
             mitk::TensorImage::Pointer image = mitk::TensorImage::New();
 
             typedef itk::Image<itk::DiffusionTensor3D<TTensorPixelType>, 3> TensorImageType;
             TensorImageType::Pointer tensorImage;
             tensorImage = tensorReconstructionFilter->GetOutput();
 
             // Check the tensor for negative eigenvalues
             if(m_Controls->m_CheckNegativeEigenvalues->isChecked())
             {
                 typedef itk::ImageRegionIterator<TensorImageType> TensorImageIteratorType;
                 TensorImageIteratorType tensorIt(tensorImage, tensorImage->GetRequestedRegion());
                 tensorIt.GoToBegin();
 
                 while(!tensorIt.IsAtEnd())
                 {
 
                     typedef itk::DiffusionTensor3D<TTensorPixelType> TensorType;
                     //typedef itk::Tensor<TTensorPixelType, 3> TensorType2;
 
                     TensorType tensor = tensorIt.Get();
 
                     TensorType::EigenValuesArrayType ev;
                     tensor.ComputeEigenValues(ev);
                     for(unsigned int i=0; i<ev.Size(); i++)
                     {
                         if(ev[i] < 0.0)
                         {
                             tensor.Fill(0.0);
                             tensorIt.Set(tensor);
                             break;
                         }
                     }
                     ++tensorIt;
                 }
             }
 
-            tensorImage->SetDirection( vols->GetVectorImage()->GetDirection() );
+            tensorImage->SetDirection( itkVectorImagePointer->GetDirection() );
             image->InitializeByItk( tensorImage.GetPointer() );
             image->SetVolume( tensorReconstructionFilter->GetOutput()->GetBufferPointer() );
             mitk::DataNode::Pointer node=mitk::DataNode::New();
             node->SetData( image );
             SetDefaultNodeProperties(node, nodename+"_LinearLeastSquares_DT");
             GetDefaultDataStorage()->Add(node, *itemiter);
             mitk::ProgressBar::GetInstance()->Progress();
             ++itemiter;
         }
 
         mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Finished Processing %d Files", nrFiles).toLatin1());
         m_MultiWidget->RequestUpdate();
     }
     catch (itk::ExceptionObject &ex)
     {
         MITK_INFO << ex ;
         QMessageBox::information(0, "Reconstruction not possible:", ex.GetDescription());
         return;
     }
 }
 
 void QmitkTensorReconstructionView::SetDefaultNodeProperties(mitk::DataNode::Pointer node, std::string name)
 {
     node->SetProperty( "ShowMaxNumber", mitk::IntProperty::New( 500 ) );
     node->SetProperty( "Scaling", mitk::FloatProperty::New( 1.0 ) );
     node->SetProperty( "Normalization", mitk::OdfNormalizationMethodProperty::New());
     node->SetProperty( "ScaleBy", mitk::OdfScaleByProperty::New());
     node->SetProperty( "IndexParam1", mitk::FloatProperty::New(2));
     node->SetProperty( "IndexParam2", mitk::FloatProperty::New(1));
     node->SetProperty( "visible", mitk::BoolProperty::New( true ) );
     node->SetProperty( "VisibleOdfs", mitk::BoolProperty::New( false ) );
     node->SetProperty ("layer", mitk::IntProperty::New(100));
     node->SetProperty( "DoRefresh", mitk::BoolProperty::New( true ) );
 
     node->SetProperty( "name", mitk::StringProperty::New(name) );
 }
 
 void QmitkTensorReconstructionView::TensorsToDWI()
 {
     DoTensorsToDWI(m_TensorImages);
 }
 
 void QmitkTensorReconstructionView::TensorsToQbi()
 {
     for (unsigned int i=0; i<m_TensorImages->size(); i++)
     {
         mitk::DataNode::Pointer tensorImageNode = m_TensorImages->at(i);
         MITK_INFO << "starting Q-Ball estimation";
 
         typedef float                                       TTensorPixelType;
         typedef itk::DiffusionTensor3D< TTensorPixelType >  TensorPixelType;
         typedef itk::Image< TensorPixelType, 3 >            TensorImageType;
 
         TensorImageType::Pointer itkvol = TensorImageType::New();
         mitk::CastToItkImage(dynamic_cast<mitk::TensorImage*>(tensorImageNode->GetData()), itkvol);
 
         typedef itk::TensorImageToQBallImageFilter< TTensorPixelType, TTensorPixelType > FilterType;
         FilterType::Pointer filter = FilterType::New();
         filter->SetInput( itkvol );
         filter->Update();
 
         typedef itk::Vector<TTensorPixelType,QBALL_ODFSIZE>  OutputPixelType;
         typedef itk::Image<OutputPixelType,3>                OutputImageType;
 
         mitk::QBallImage::Pointer image = mitk::QBallImage::New();
         OutputImageType::Pointer outimg = filter->GetOutput();
         image->InitializeByItk( outimg.GetPointer() );
         image->SetVolume( outimg->GetBufferPointer() );
         mitk::DataNode::Pointer node = mitk::DataNode::New();
         node->SetData( image );
         node->SetName(tensorImageNode->GetName()+"_Qball");
         GetDefaultDataStorage()->Add(node, tensorImageNode);
     }
 }
 
 void QmitkTensorReconstructionView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
     m_DiffusionImages = mitk::DataStorage::SetOfObjects::New();
     m_TensorImages = mitk::DataStorage::SetOfObjects::New();
     bool foundDwiVolume = false;
     bool foundTensorVolume = false;
     m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
     m_DiffusionImage = NULL;
     m_TensorImage = NULL;
 
     m_Controls->m_InputData->setTitle("Please Select Input Data");
 
     // iterate selection
     for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
     {
         mitk::DataNode::Pointer node = *it;
         if (node.IsNull())
             continue;
 
         // only look at interesting types
-        if(dynamic_cast<mitk::DiffusionImage<DiffusionPixelType>*>(node->GetData()))
+        bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData())) );
+        if ( isDiffusionImage )
         {
-            foundDwiVolume = true;
-            m_Controls->m_DiffusionImageLabel->setText(node->GetName().c_str());
-            m_DiffusionImages->push_back(node);
-            m_DiffusionImage = node;
+          foundDwiVolume = true;
+          m_Controls->m_DiffusionImageLabel->setText(node->GetName().c_str());
+          m_DiffusionImages->push_back(node);
+          m_DiffusionImage = node;
         }
         else if(dynamic_cast<mitk::TensorImage*>(node->GetData()))
         {
             foundTensorVolume = true;
             m_Controls->m_DiffusionImageLabel->setText(node->GetName().c_str());
             m_TensorImages->push_back(node);
             m_TensorImage = node;
         }
     }
 
     m_Controls->m_StartReconstruction->setEnabled(foundDwiVolume);
 
     m_Controls->m_TensorsToDWIButton->setEnabled(foundTensorVolume);
     m_Controls->m_TensorsToQbiButton->setEnabled(foundTensorVolume);
 
     if (foundDwiVolume || foundTensorVolume)
         m_Controls->m_InputData->setTitle("Input Data");
 
     m_Controls->m_ResidualButton->setEnabled(foundDwiVolume && foundTensorVolume);
     m_Controls->m_PercentagesOfOutliers->setEnabled(foundDwiVolume && foundTensorVolume);
     m_Controls->m_PerSliceView->setEnabled(foundDwiVolume && foundTensorVolume);
 }
 
 template<int ndirs>
 itk::VectorContainer<unsigned int, vnl_vector_fixed<double, 3> >::Pointer
 QmitkTensorReconstructionView::MakeGradientList()
 {
     itk::VectorContainer<unsigned int, vnl_vector_fixed<double,3> >::Pointer retval =
         itk::VectorContainer<unsigned int, vnl_vector_fixed<double,3> >::New();
     vnl_matrix_fixed<double, 3, ndirs>* U =
             itk::PointShell<ndirs, vnl_matrix_fixed<double, 3, ndirs> >::DistributePointShell();
 
     for(int i=0; i<ndirs;i++)
     {
         vnl_vector_fixed<double,3> v;
         v[0] = U->get(0,i); v[1] = U->get(1,i); v[2] = U->get(2,i);
         retval->push_back(v);
     }
     // Add 0 vector for B0
     vnl_vector_fixed<double,3> v;
     v.fill(0.0);
     retval->push_back(v);
 
     return retval;
 }
 
 void QmitkTensorReconstructionView::DoTensorsToDWI(mitk::DataStorage::SetOfObjects::Pointer inImages)
 {
     try
     {
         itk::TimeProbe clock;
 
         int nrFiles = inImages->size();
         if (!nrFiles) return;
 
         QString status;
         mitk::ProgressBar::GetInstance()->AddStepsToDo(nrFiles);
 
         mitk::DataStorage::SetOfObjects::const_iterator itemiter( inImages->begin() );
         mitk::DataStorage::SetOfObjects::const_iterator itemiterend( inImages->end() );
 
         while ( itemiter != itemiterend ) // for all items
         {
 
             std::string nodename;
             (*itemiter)->GetStringProperty("name", nodename);
 
             mitk::TensorImage* vol =
                     static_cast<mitk::TensorImage*>((*itemiter)->GetData());
 
             typedef float                                       TTensorPixelType;
             typedef itk::DiffusionTensor3D< TTensorPixelType >  TensorPixelType;
             typedef itk::Image< TensorPixelType, 3 >            TensorImageType;
 
 
             TensorImageType::Pointer itkvol = TensorImageType::New();
             mitk::CastToItkImage(vol, itkvol);
 
             typedef itk::TensorImageToDiffusionImageFilter<
                     TTensorPixelType, DiffusionPixelType > FilterType;
 
             FilterType::GradientListPointerType gradientList = FilterType::GradientListType::New();
 
             switch(m_Controls->m_TensorsToDWINumDirsSelect->currentIndex())
             {
             case 0:
                 gradientList = MakeGradientList<12>();
                 break;
             case 1:
                 gradientList = MakeGradientList<42>();
                 break;
             case 2:
                 gradientList = MakeGradientList<92>();
                 break;
             case 3:
                 gradientList = MakeGradientList<162>();
                 break;
             case 4:
                 gradientList = MakeGradientList<252>();
                 break;
             case 5:
                 gradientList = MakeGradientList<362>();
                 break;
             case 6:
                 gradientList = MakeGradientList<492>();
                 break;
             case 7:
                 gradientList = MakeGradientList<642>();
                 break;
             case 8:
                 gradientList = MakeGradientList<812>();
                 break;
             case 9:
                 gradientList = MakeGradientList<1002>();
                 break;
             default:
                 gradientList = MakeGradientList<92>();
 
             }
 
             double bVal = m_Controls->m_TensorsToDWIBValueEdit->text().toDouble();
 
             // DWI ESTIMATION
             clock.Start();
             MBI_INFO << "DWI Estimation ";
             mitk::StatusBar::GetInstance()->DisplayText(status.sprintf(
                                                             "DWI Estimation for %s", nodename.c_str()).toLatin1());
             FilterType::Pointer filter = FilterType::New();
             filter->SetInput( itkvol );
             filter->SetBValue(bVal);
             filter->SetGradientList(gradientList);
             //filter->SetNumberOfThreads(1);
             filter->Update();
             clock.Stop();
             MBI_DEBUG << "took " << clock.GetMean() << "s.";
 
             // TENSORS TO DATATREE
-            mitk::DiffusionImage<DiffusionPixelType>::Pointer image = mitk::DiffusionImage<DiffusionPixelType>::New();
-            image->SetVectorImage( filter->GetOutput() );
-            image->SetReferenceBValue(bVal);
-            image->SetDirections(gradientList);
-            image->InitializeFromVectorImage();
+            mitk::Image::Pointer image = mitk::GrabItkImageMemory( filter->GetOutput() );
+
+            image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( gradientList ) );
+            image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( bVal ) );
+            image->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New() );
+            mitk::DiffusionPropertyHelper propertyHelper( image );
+            propertyHelper.InitializeImage();
+
             mitk::DataNode::Pointer node=mitk::DataNode::New();
             node->SetData( image );
-            mitk::DiffusionImageMapper<short>::SetDefaultProperties(node);
+            mitk::ImageVtkMapper2D::SetDefaultProperties(node);
             node->SetName(nodename+"_DWI");
             GetDefaultDataStorage()->Add(node, *itemiter);
 
             mitk::ProgressBar::GetInstance()->Progress();
             ++itemiter;
         }
 
 
         mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Finished Processing %d Files", nrFiles).toLatin1());
         m_MultiWidget->RequestUpdate();
 
     }
     catch (itk::ExceptionObject &ex)
     {
         MITK_INFO << ex ;
         QMessageBox::information(0, "DWI estimation failed:", ex.GetDescription());
         return ;
     }
 }
 
 
 void QmitkTensorReconstructionView::PreviewThreshold(int threshold)
 {
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( m_DiffusionImages->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( m_DiffusionImages->end() );
     while ( itemiter != itemiterend ) // for all items
     {
-        mitk::DiffusionImage<DiffusionPixelType>* vols =
-                static_cast<mitk::DiffusionImage<DiffusionPixelType>*>(
-                    (*itemiter)->GetData());
+        mitk::Image* vols =
+                static_cast<mitk::Image*>(
+             (*itemiter)->GetData());
+
+        ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
+        mitk::CastToItkImage(vols, itkVectorImagePointer);
 
         // Extract b0 image
         typedef itk::B0ImageExtractionImageFilter<short, short> FilterType;
         FilterType::Pointer filterB0 = FilterType::New();
-        filterB0->SetInput(vols->GetVectorImage());
-        filterB0->SetDirections(vols->GetDirections());
+        filterB0->SetInput(itkVectorImagePointer);
+        filterB0->SetDirections(mitk::DiffusionPropertyHelper::GetGradientContainer(vols));
         filterB0->Update();
 
         mitk::Image::Pointer mitkImage = mitk::Image::New();
 
         typedef itk::Image<short, 3> ImageType;
         typedef itk::Image<short, 3> SegmentationType;
         typedef itk::BinaryThresholdImageFilter<ImageType, SegmentationType> ThresholdFilterType;
         // apply threshold
         ThresholdFilterType::Pointer filterThreshold = ThresholdFilterType::New();
         filterThreshold->SetInput(filterB0->GetOutput());
         filterThreshold->SetLowerThreshold(threshold);
         filterThreshold->SetInsideValue(0);
         filterThreshold->SetOutsideValue(1); // mark cut off values red
         filterThreshold->Update();
 
         mitkImage->InitializeByItk( filterThreshold->GetOutput() );
         mitkImage->SetVolume( filterThreshold->GetOutput()->GetBufferPointer() );
         mitk::DataNode::Pointer node;
         if (this->GetDefaultDataStorage()->GetNamedDerivedNode("ThresholdOverlay", *itemiter))
         {
             node = this->GetDefaultDataStorage()->GetNamedDerivedNode("ThresholdOverlay", *itemiter);
         }
         else
         {
             // create a new node, to show thresholded values
             node = mitk::DataNode::New();
             GetDefaultDataStorage()->Add( node, *itemiter );
             node->SetProperty( "name", mitk::StringProperty::New("ThresholdOverlay"));
             node->SetBoolProperty("helper object", true);
         }
         node->SetData( mitkImage );
         itemiter++;
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTensorReconstructionView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTensorReconstructionView.h
index 4fc685b48c..b9879dce2d 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTensorReconstructionView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTensorReconstructionView.h
@@ -1,117 +1,124 @@
 /*===================================================================
 
 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 _QMITKTENSORRECONSTRUCTIONVIEW_H_INCLUDED
 #define _QMITKTENSORRECONSTRUCTIONVIEW_H_INCLUDED
 
 #include <QmitkFunctionality.h>
 
 #include <string>
 
 #include "ui_QmitkTensorReconstructionViewControls.h"
 
-#include <mitkDiffusionImage.h>
 #include <mitkTensorImage.h>
+#include <mitkImage.h>
+#include <mitkDiffusionPropertyHelper.h>
+#include <itkVectorImage.h>
 
 typedef short DiffusionPixelType;
 
 struct TrSelListener;
 
 /*!
  * \ingroup org_mitk_gui_qt_tensorreconstruction_internal
  *
  * \brief QmitkTensorReconstructionView
  *
  * Document your class here.
  *
  * \sa QmitkFunctionality
  */
 class QmitkTensorReconstructionView : public QmitkFunctionality
 {
 
   friend struct TrSelListener;
 
   // this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
   Q_OBJECT
 
   public:
 
+    typedef mitk::DiffusionPropertyHelper::GradientDirectionType            GradientDirectionType;
+    typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType  GradientDirectionContainerType;
+    typedef mitk::DiffusionPropertyHelper::BValueMapType                    BValueMapType;
+    typedef itk::VectorImage< DiffusionPixelType, 3 >                       ITKDiffusionImageType;
+
   static const std::string VIEW_ID;
 
   QmitkTensorReconstructionView();
   virtual ~QmitkTensorReconstructionView();
 
   virtual void CreateQtPartControl(QWidget *parent);
 
   /// \brief Creation of the connections of main and control widget
   virtual void CreateConnections();
 
   /// \brief Called when the functionality is activated
   virtual void Activated();
 
   virtual void Deactivated();
 
   virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
   virtual void StdMultiWidgetNotAvailable();
 
   static const int nrconvkernels;
 
 protected slots:
 
   void TensorsToQbi();
   void TensorsToDWI();
   void DoTensorsToDWI(mitk::DataStorage::SetOfObjects::Pointer inImages);
   void Advanced1CheckboxClicked();
   void Reconstruct();
   void ResidualCalculation();
   void ResidualClicked(int slice, int volume);
   /**
    * @brief PreviewThreshold Generates a preview of the values that are cut off by the thresholds
    * @param threshold
    */
   void PreviewThreshold(int threshold);
 
 protected:
 
   void ItkTensorReconstruction(mitk::DataStorage::SetOfObjects::Pointer inImages);
   void TeemTensorReconstruction(mitk::DataStorage::SetOfObjects::Pointer inImages);
   void TensorReconstructionWithCorr(mitk::DataStorage::SetOfObjects::Pointer inImages);
 
   void OnSelectionChanged( std::vector<mitk::DataNode*> nodes );
 
   Ui::QmitkTensorReconstructionViewControls* m_Controls;
 
   QmitkStdMultiWidget* m_MultiWidget;
 
   template<int ndirs> itk::VectorContainer<unsigned int, vnl_vector_fixed<double,3> >::Pointer MakeGradientList();
 
   template<int L>
-  void TemplatedAnalyticalTensorReconstruction(mitk::DiffusionImage<DiffusionPixelType>* vols,
+  void TemplatedAnalyticalTensorReconstruction(mitk::Image* vols,
     float lambda, std::string nodename, std::vector<mitk::DataNode::Pointer>* nodes, int normalization);
 
   void SetDefaultNodeProperties(mitk::DataNode::Pointer node, std::string name);
 
   mitk::DataNode::Pointer m_DiffusionImage;
   mitk::DataNode::Pointer m_TensorImage;
   mitk::DataStorage::SetOfObjects::Pointer m_DiffusionImages;
   mitk::DataStorage::SetOfObjects::Pointer m_TensorImages;
 };
 
 
 
 
 #endif // _QMITKTENSORRECONSTRUCTIONVIEW_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimagingapp/src/internal/QmitkNavigationButtonsView.cpp b/Plugins/org.mitk.gui.qt.diffusionimagingapp/src/internal/QmitkNavigationButtonsView.cpp
index 90fc60313c..cc4ab8735d 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimagingapp/src/internal/QmitkNavigationButtonsView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimagingapp/src/internal/QmitkNavigationButtonsView.cpp
@@ -1,138 +1,137 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include "QmitkNavigationButtonsView.h"
 
 #include "mitkNodePredicateDataType.h"
 #include "mitkDataNodeObject.h"
 #include "mitkOdfNormalizationMethodProperty.h"
 #include "mitkOdfScaleByProperty.h"
 #include "mitkResliceMethodProperty.h"
 #include "mitkRenderingManager.h"
 
-#include "mitkDiffusionImage.h"
 #include "mitkPlanarFigure.h"
 #include "mitkFiberBundle.h"
 #include "QmitkDataStorageComboBox.h"
 #include "QmitkStdMultiWidget.h"
 #include "mitkFiberBundleInteractor.h"
 #include "mitkPlanarFigureInteractor.h"
 
 #include "mitkGlobalInteraction.h"
 
 #include "mitkGeometry2D.h"
 
 #include "berryIWorkbenchWindow.h"
 #include "berryIWorkbenchPage.h"
 #include "berryISelectionService.h"
 #include "berryConstants.h"
 #include "berryPlatformUI.h"
 
 #include "itkRGBAPixel.h"
 #include "itkTractsToProbabilityImageFilter.h"
 
 #include "qwidgetaction.h"
 #include "qcolordialog.h"
 
 const std::string QmitkNavigationButtonsView::VIEW_ID = "org.mitk.views.NavigationButtonsview";
 
 using namespace berry;
 
 
 QmitkNavigationButtonsView::QmitkNavigationButtonsView()
   : QmitkFunctionality(),
   m_Controls(NULL),
   m_MultiWidget(NULL),
 {
 }
 
 QmitkNavigationButtonsView::QmitkNavigationButtonsView(const QmitkNavigationButtonsView& other)
 {
   Q_UNUSED(other)
   throw std::runtime_error("Copy constructor not implemented");
 }
 
 QmitkNavigationButtonsView::~QmitkNavigationButtonsView()
 {
   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->RemovePostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
 }
 
 
 
 void QmitkNavigationButtonsView::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkNavigationButtonsViewControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
 
   }
 }
 
 
 void QmitkNavigationButtonsView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
   m_MultiWidget = &stdMultiWidget;
 }
 
 void QmitkNavigationButtonsView::StdMultiWidgetNotAvailable()
 {
   m_MultiWidget = NULL;
 }
 
 void QmitkNavigationButtonsView::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_TextureIntON), SIGNAL(clicked()), this, SLOT(TextIntON()) );
   }
 }
 
 void QmitkNavigationButtonsView::Activated()
 {
   QmitkFunctionality::Activated();
 }
 
 void QmitkNavigationButtonsView::Deactivated()
 {
   QmitkFunctionality::Deactivated();
 }
 
 int QmitkNavigationButtonsView::GetSizeFlags(bool width)
 {
   if(!width)
   {
     return berry::Constants::MIN | berry::Constants::MAX | berry::Constants::FILL;
   }
   else
   {
     return 0;
   }
 }
 
 int QmitkNavigationButtonsView::ComputePreferredSize(bool width, int /*availableParallel*/, int /*availablePerpendicular*/, int preferredResult)
 {
   if(width==false)
   {
     return m_FoundSingleOdfImage ? 120 : 80;
   }
   else
   {
     return preferredResult;
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.dtiatlasapp/src/internal/QmitkNavigationButtonsView.cpp b/Plugins/org.mitk.gui.qt.dtiatlasapp/src/internal/QmitkNavigationButtonsView.cpp
index 269a1d88b4..d6a7202954 100644
--- a/Plugins/org.mitk.gui.qt.dtiatlasapp/src/internal/QmitkNavigationButtonsView.cpp
+++ b/Plugins/org.mitk.gui.qt.dtiatlasapp/src/internal/QmitkNavigationButtonsView.cpp
@@ -1,950 +1,949 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include "QmitkNavigationButtonsView.h"
 
 #include "mitkNodePredicateDataType.h"
 #include "mitkDataNodeObject.h"
 #include "mitkOdfNormalizationMethodProperty.h"
 #include "mitkOdfScaleByProperty.h"
 #include "mitkResliceMethodProperty.h"
 #include "mitkRenderingManager.h"
 #include "mitkModuleRegistry.h"
 
-#include "mitkDiffusionImage.h"
 #include "mitkPlanarFigure.h"
 #include "mitkFiberBundle.h"
 #include "QmitkDataStorageComboBox.h"
 #include "QmitkStdMultiWidget.h"
 #include "mitkFiberBundleInteractor.h"
 #include "mitkPlanarFigureInteractor.h"
 
 #include "mitkGlobalInteraction.h"
 
 #include "mitkGeometry2D.h"
 
 #include "berryIWorkbenchWindow.h"
 #include "berryIWorkbenchPage.h"
 #include "berryISelectionService.h"
 #include "berryConstants.h"
 #include "berryPlatformUI.h"
 
 #include "itkRGBAPixel.h"
 #include "itkTractsToProbabilityImageFilter.h"
 
 #include "qwidgetaction.h"
 #include "qcolordialog.h"
 
 const std::string QmitkNavigationButtonsView::VIEW_ID = "org.mitk.views.NavigationButtonsview";
 
 using namespace berry;
 
 
 QmitkNavigationButtonsView::QmitkNavigationButtonsView()
   : QmitkFunctionality(),
   m_Controls(NULL),
   m_MultiWidget(NULL),
 {
 }
 
 QmitkNavigationButtonsView::QmitkNavigationButtonsView(const QmitkNavigationButtonsView& other)
 {
   Q_UNUSED(other)
   throw std::runtime_error("Copy constructor not implemented");
 }
 
 QmitkNavigationButtonsView::~QmitkNavigationButtonsView()
 {
   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->RemovePostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
 }
 
 
 
 void QmitkNavigationButtonsView::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkNavigationButtonsViewControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
 
   }
 }
 
 
 void QmitkNavigationButtonsView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
   m_MultiWidget = &stdMultiWidget;
 }
 
 void QmitkNavigationButtonsView::StdMultiWidgetNotAvailable()
 {
   m_MultiWidget = NULL;
 }
 
 void QmitkNavigationButtonsView::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_TextureIntON), SIGNAL(clicked()), this, SLOT(TextIntON()) );
   }
 }
 
 void QmitkNavigationButtonsView::Activated()
 {
   QmitkFunctionality::Activated();
 }
 
 void QmitkNavigationButtonsView::Deactivated()
 {
   QmitkFunctionality::Deactivated();
 }
 
 int QmitkNavigationButtonsView::GetSizeFlags(bool width)
 {
   if(!width)
   {
     return berry::Constants::MIN | berry::Constants::MAX | berry::Constants::FILL;
   }
   else
   {
     return 0;
   }
 }
 
 int QmitkNavigationButtonsView::ComputePreferredSize(bool width, int /*availableParallel*/, int /*availablePerpendicular*/, int preferredResult)
 {
   if(width==false)
   {
     return m_FoundSingleOdfImage ? 120 : 80;
   }
   else
   {
     return preferredResult;
   }
 }
 
 mitk::DataStorage::SetOfObjects::Pointer
     QmitkNavigationButtonsView::ActiveSet(std::string classname)
 {
   if (m_CurrentSelection)
   {
     mitk::DataStorage::SetOfObjects::Pointer set =
         mitk::DataStorage::SetOfObjects::New();
 
     int at = 0;
     for (IStructuredSelection::iterator i = m_CurrentSelection->Begin();
     i != m_CurrentSelection->End();
     ++i)
     {
 
       if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
       {
         mitk::DataNode::Pointer node = nodeObj->GetDataNode();
         if(QString(classname.c_str()).compare(node->GetData()->GetNameOfClass())==0)
         {
           set->InsertElement(at++, node);
         }
       }
     }
 
     return set;
   }
 
   return 0;
 }
 
 void QmitkNavigationButtonsView::SetBoolProp(
     mitk::DataStorage::SetOfObjects::Pointer set,
     std::string name, bool value)
 {
   if(set.IsNotNull())
   {
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetBoolProperty(name.c_str(), value);
       ++itemiter;
     }
   }
 }
 
 void QmitkNavigationButtonsView::SetIntProp(
     mitk::DataStorage::SetOfObjects::Pointer set,
     std::string name, int value)
 {
   if(set.IsNotNull())
   {
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetIntProperty(name.c_str(), value);
       ++itemiter;
     }
   }
 }
 
 void QmitkNavigationButtonsView::SetFloatProp(
     mitk::DataStorage::SetOfObjects::Pointer set,
     std::string name, float value)
 {
   if(set.IsNotNull())
   {
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetFloatProperty(name.c_str(), value);
       ++itemiter;
     }
   }
 }
 
 void QmitkNavigationButtonsView::SetLevelWindowProp(
     mitk::DataStorage::SetOfObjects::Pointer set,
     std::string name, mitk::LevelWindow value)
 {
   if(set.IsNotNull())
   {
 
     mitk::LevelWindowProperty::Pointer prop = mitk::LevelWindowProperty::New(value);
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetProperty(name.c_str(), prop);
       ++itemiter;
     }
   }
 }
 
 void QmitkNavigationButtonsView::SetEnumProp(
     mitk::DataStorage::SetOfObjects::Pointer set,
     std::string name, mitk::EnumerationProperty::Pointer value)
 {
   if(set.IsNotNull())
   {
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetProperty(name.c_str(), value);
       ++itemiter;
     }
   }
 }
 
 void QmitkNavigationButtonsView::DisplayIndexChanged(int dispIndex)
 {
 
   QString label = "Channel %1";
   label = label.arg(dispIndex);
   m_Controls->label_channel->setText(label);
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("DiffusionImage");
 
   if(set.IsNotNull())
   {
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
     while ( itemiter != itemiterend )
     {
       (*itemiter)->SetIntProperty("DisplayChannel", dispIndex);
       ++itemiter;
     }
 
     //m_MultiWidget->RequestUpdate();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkNavigationButtonsView::Reinit()
 {
   if (m_CurrentSelection)
   {
     mitk::DataNodeObject::Pointer nodeObj =
         m_CurrentSelection->Begin()->Cast<mitk::DataNodeObject>();
     mitk::DataNode::Pointer node = nodeObj->GetDataNode();
     mitk::BaseData::Pointer basedata = node->GetData();
     if (basedata.IsNotNull())
     {
       mitk::RenderingManager::GetInstance()->InitializeViews(
           basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
   }
 }
 
 void QmitkNavigationButtonsView::TextIntON()
 {
   if(m_TexIsOn)
   {
     m_Controls->m_TextureIntON->setIcon(*m_IconTexOFF);
   }
   else
   {
     m_Controls->m_TextureIntON->setIcon(*m_IconTexON);
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("DiffusionImage");
   SetBoolProp(set,"texture interpolation", !m_TexIsOn);
 
   set = ActiveSet("TensorImage");
   SetBoolProp(set,"texture interpolation", !m_TexIsOn);
 
   set = ActiveSet("QBallImage");
   SetBoolProp(set,"texture interpolation", !m_TexIsOn);
 
   set = ActiveSet("Image");
   SetBoolProp(set,"texture interpolation", !m_TexIsOn);
 
   m_TexIsOn = !m_TexIsOn;
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkNavigationButtonsView::VisibleOdfsON_S()
 {
   if(m_GlyIsOn_S)
   {
     m_Controls->m_VisibleOdfsON_S->setIcon(*m_IconGlyOFF_S);
   }
   else
   {
     m_Controls->m_VisibleOdfsON_S->setIcon(*m_IconGlyON_S);
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetBoolProp(set,"VisibleOdfs_S", !m_GlyIsOn_S);
 
   set = ActiveSet("TensorImage");
   SetBoolProp(set,"VisibleOdfs_S", !m_GlyIsOn_S);
 
   m_GlyIsOn_S = !m_GlyIsOn_S;
 
   VisibleOdfsON(0);
 }
 
 void QmitkNavigationButtonsView::VisibleOdfsON_T()
 {
   if(m_GlyIsOn_T)
   {
     m_Controls->m_VisibleOdfsON_T->setIcon(*m_IconGlyOFF_T);
   }
   else
   {
     m_Controls->m_VisibleOdfsON_T->setIcon(*m_IconGlyON_T);
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetBoolProp(set,"VisibleOdfs_T", !m_GlyIsOn_T);
 
   set = ActiveSet("TensorImage");
   SetBoolProp(set,"VisibleOdfs_T", !m_GlyIsOn_T);
 
   m_GlyIsOn_T = !m_GlyIsOn_T;
 
   VisibleOdfsON(1);
 
 }
 
 void QmitkNavigationButtonsView::VisibleOdfsON_C()
 {
   if(m_GlyIsOn_C)
   {
     m_Controls->m_VisibleOdfsON_C->setIcon(*m_IconGlyOFF_C);
   }
   else
   {
     m_Controls->m_VisibleOdfsON_C->setIcon(*m_IconGlyON_C);
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetBoolProp(set,"VisibleOdfs_C", !m_GlyIsOn_C);
 
   set = ActiveSet("TensorImage");
   SetBoolProp(set,"VisibleOdfs_C", !m_GlyIsOn_C);
 
   m_GlyIsOn_C = !m_GlyIsOn_C;
 
   VisibleOdfsON(2);
 
 }
 
 void QmitkNavigationButtonsView::VisibleOdfsON(int view)
 {
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkNavigationButtonsView::ShowMaxNumberChanged()
 {
   int maxNr = m_Controls->m_ShowMaxNumber->value();
   if ( maxNr < 1 )
   {
     m_Controls->m_ShowMaxNumber->setValue( 1 );
     maxNr = 1;
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetIntProp(set,"ShowMaxNumber", maxNr);
 
   set = ActiveSet("TensorImage");
   SetIntProp(set,"ShowMaxNumber", maxNr);
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkNavigationButtonsView::NormalizationDropdownChanged(int normDropdown)
 {
   typedef mitk::OdfNormalizationMethodProperty PropType;
   PropType::Pointer normMeth = PropType::New();
 
   switch(normDropdown)
   {
   case 0:
     normMeth->SetNormalizationToMinMax();
     break;
   case 1:
     normMeth->SetNormalizationToMax();
     break;
   case 2:
     normMeth->SetNormalizationToNone();
     break;
   case 3:
     normMeth->SetNormalizationToGlobalMax();
     break;
   default:
     normMeth->SetNormalizationToMinMax();
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetEnumProp(set,"Normalization", normMeth.GetPointer());
 
   set = ActiveSet("TensorImage");
   SetEnumProp(set,"Normalization", normMeth.GetPointer());
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkNavigationButtonsView::ScalingFactorChanged(double scalingFactor)
 {
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetFloatProp(set,"Scaling", scalingFactor);
 
   set = ActiveSet("TensorImage");
   SetFloatProp(set,"Scaling", scalingFactor);
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkNavigationButtonsView::AdditionalScaling(int additionalScaling)
 {
 
   typedef mitk::OdfScaleByProperty PropType;
   PropType::Pointer scaleBy = PropType::New();
 
   switch(additionalScaling)
   {
   case 0:
     scaleBy->SetScaleByNothing();
     break;
   case 1:
     scaleBy->SetScaleByGFA();
     //m_Controls->params_frame->setVisible(true);
     break;
 #ifdef DIFFUSION_IMAGING_EXTENDED
   case 2:
     scaleBy->SetScaleByPrincipalCurvature();
     // commented in for SPIE paper, Principle curvature scaling
     //m_Controls->params_frame->setVisible(true);
     break;
 #endif
   default:
     scaleBy->SetScaleByNothing();
   }
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetEnumProp(set,"ScaleBy", scaleBy.GetPointer());
 
   set = ActiveSet("TensorImage");
   SetEnumProp(set,"ScaleBy", scaleBy.GetPointer());
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkNavigationButtonsView::IndexParam1Changed(double param1)
 {
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetFloatProp(set,"IndexParam1", param1);
 
   set = ActiveSet("TensorImage");
   SetFloatProp(set,"IndexParam1", param1);
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 }
 
 void QmitkNavigationButtonsView::IndexParam2Changed(double param2)
 {
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetFloatProp(set,"IndexParam2", param2);
 
   set = ActiveSet("TensorImage");
   SetFloatProp(set,"IndexParam2", param2);
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 }
 
 void QmitkNavigationButtonsView::OpacityChanged(double l, double u)
 {
   mitk::LevelWindow olw;
   olw.SetRangeMinMax(l*255, u*255);
 
   mitk::DataStorage::SetOfObjects::Pointer set =
       ActiveSet("QBallImage");
   SetLevelWindowProp(set,"opaclevelwindow", olw);
 
   set = ActiveSet("TensorImage");
   SetLevelWindowProp(set,"opaclevelwindow", olw);
 
   set = ActiveSet("Image");
   SetLevelWindowProp(set,"opaclevelwindow", olw);
 
   m_Controls->m_OpacityMinFaLabel->setText(QString::number(l,'f',2) + " : " + QString::number(u,'f',2));
 
   if(m_MultiWidget)
     m_MultiWidget->RequestUpdate();
 
 }
 
 void QmitkNavigationButtonsView::ScalingCheckbox()
 {
   m_Controls->m_ScalingFrame->setVisible(
       m_Controls->m_ScalingCheckbox->isChecked());
 }
 
 
 void QmitkNavigationButtonsView::BundleRepresentationWire()
 {
   if(m_SelectedNode)
   {
     int width = m_Controls->m_LineWidth->value();
     m_SelectedNode->SetProperty("LineWidth",mitk::IntProperty::New(width));
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(15));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(18));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(1));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(2));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(3));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(4));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(0));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
   }
 }
 
 void QmitkNavigationButtonsView::BundleRepresentationTube()
 {
   if(m_SelectedNode)
   {
     float radius = m_Controls->m_TubeRadius->value() / 100.0;
     m_SelectedNode->SetProperty("TubeRadius",mitk::FloatProperty::New(radius));
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(17));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(13));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(16));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(0));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
   }
 }
 
 void QmitkNavigationButtonsView::BundleRepresentationColor()
 {
   if(m_SelectedNode)
   {
     QColor color = QColorDialog::getColor();
 
     m_Controls->m_Color->setAutoFillBackground(true);
     QString styleSheet = "background-color:rgb(";
     styleSheet.append(QString::number(color.red()));
     styleSheet.append(",");
     styleSheet.append(QString::number(color.green()));
     styleSheet.append(",");
     styleSheet.append(QString::number(color.blue()));
     styleSheet.append(")");
     m_Controls->m_Color->setStyleSheet(styleSheet);
 
     m_SelectedNode->SetProperty("color",mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(14));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(3));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
     m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(0));
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
   }
 }
 
 void QmitkNavigationButtonsView::PlanarFigureFocus()
 {
   if(m_SelectedNode)
   {
     mitk::PlanarFigure* _PlanarFigure = 0;
     _PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (m_SelectedNode->GetData());
 
     if (_PlanarFigure)
     {
 
       QmitkRenderWindow* selectedRenderWindow = 0;
       bool PlanarFigureInitializedWindow = false;
 
       QmitkRenderWindow* RenderWindow1 =
           this->GetActiveStdMultiWidget()->GetRenderWindow1();
 
       if (m_SelectedNode->GetBoolProperty("PlanarFigureInitializedWindow",
         PlanarFigureInitializedWindow, RenderWindow1->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow1;
       }
 
       QmitkRenderWindow* RenderWindow2 =
           this->GetActiveStdMultiWidget()->GetRenderWindow2();
 
       if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
           "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
           RenderWindow2->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow2;
       }
 
       QmitkRenderWindow* RenderWindow3 =
           this->GetActiveStdMultiWidget()->GetRenderWindow3();
 
       if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
           "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
           RenderWindow3->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow3;
       }
 
       QmitkRenderWindow* RenderWindow4 =
           this->GetActiveStdMultiWidget()->GetRenderWindow4();
 
       if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
           "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
           RenderWindow4->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow4;
       }
 
       const mitk::PlaneGeometry
           * _PlaneGeometry =
           dynamic_cast<const mitk::PlaneGeometry*> (_PlanarFigure->GetGeometry2D());
       mitk::VnlVector normal = _PlaneGeometry->GetNormalVnl();
 
       mitk::Geometry2D::ConstPointer worldGeometry1 =
         RenderWindow1->GetRenderer()->GetCurrentWorldGeometry2D();
       mitk::PlaneGeometry::ConstPointer _Plane1 =
         dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry1.GetPointer() );
       mitk::VnlVector normal1 = _Plane1->GetNormalVnl();
 
       mitk::Geometry2D::ConstPointer worldGeometry2 =
         RenderWindow2->GetRenderer()->GetCurrentWorldGeometry2D();
       mitk::PlaneGeometry::ConstPointer _Plane2 =
         dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry2.GetPointer() );
       mitk::VnlVector normal2 = _Plane2->GetNormalVnl();
 
       mitk::Geometry2D::ConstPointer worldGeometry3 =
         RenderWindow3->GetRenderer()->GetCurrentWorldGeometry2D();
       mitk::PlaneGeometry::ConstPointer _Plane3 =
         dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry3.GetPointer() );
       mitk::VnlVector normal3 = _Plane3->GetNormalVnl();
 
       normal[0]  = fabs(normal[0]);  normal[1]  = fabs(normal[1]);  normal[2]  = fabs(normal[2]);
       normal1[0] = fabs(normal1[0]); normal1[1] = fabs(normal1[1]); normal1[2] = fabs(normal1[2]);
       normal2[0] = fabs(normal2[0]); normal2[1] = fabs(normal2[1]); normal2[2] = fabs(normal2[2]);
       normal3[0] = fabs(normal3[0]); normal3[1] = fabs(normal3[1]); normal3[2] = fabs(normal3[2]);
 
       double ang1 = angle(normal, normal1);
       double ang2 = angle(normal, normal2);
       double ang3 = angle(normal, normal3);
 
       if(ang1 < ang2 && ang1 < ang3)
       {
         selectedRenderWindow = RenderWindow1;
       }
       else
       {
         if(ang2 < ang3)
         {
           selectedRenderWindow = RenderWindow2;
         }
         else
         {
           selectedRenderWindow = RenderWindow3;
         }
       }
 
       // make node visible
       if (selectedRenderWindow)
       {
         mitk::Point3D centerP = _PlaneGeometry->GetOrigin();
         selectedRenderWindow->GetSliceNavigationController()->ReorientSlices(
             centerP, _PlaneGeometry->GetNormal());
         selectedRenderWindow->GetSliceNavigationController()->SelectSliceByPoint(
             centerP);
       }
     }
 
     // set interactor for new node (if not already set)
     mitk::PlanarFigureInteractor::Pointer figureInteractor
         = dynamic_cast<mitk::PlanarFigureInteractor*>(m_SelectedNode->GetDataInteractor().GetPointer());
 
     if(figureInteractor.IsNull())
     {
       figureInteractor = mitk::PlanarFigureInteractor::New();
       mitk::Module* planarFigureModule = mitk::ModuleRegistry::GetModule( "MitkPlanarFigure" );
       figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
       figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
       figureInteractor->SetDataNode( m_SelectedNode );
     }
 
     m_SelectedNode->SetProperty("planarfigure.iseditable",mitk::BoolProperty::New(true));
 
   }
 }
 
 void QmitkNavigationButtonsView::SetInteractor()
 {
   typedef std::vector<mitk::DataNode*> Container;
   Container _NodeSet = this->GetDataManagerSelection();
   mitk::DataNode* node = 0;
   mitk::FiberBundle* bundle = 0;
   mitk::FiberBundleInteractor::Pointer bundleInteractor = 0;
 
   // finally add all nodes to the model
   for(Container::const_iterator it=_NodeSet.begin(); it!=_NodeSet.end()
     ; it++)
     {
     node = const_cast<mitk::DataNode*>(*it);
     bundle = dynamic_cast<mitk::FiberBundle*>(node->GetData());
 
     if(bundle)
     {
       bundleInteractor = dynamic_cast<mitk::FiberBundleInteractor*>(node->GetInteractor());
 
       if(bundleInteractor.IsNotNull())
         mitk::GlobalInteraction::GetInstance()->RemoveInteractor(bundleInteractor);
 
       if(!m_Controls->m_Crosshair->isChecked())
       {
         m_Controls->m_Crosshair->setChecked(false);
         this->GetActiveStdMultiWidget()->GetRenderWindow4()->setCursor(Qt::ArrowCursor);
         m_CurrentPickingNode = 0;
       }
       else
       {
         m_Controls->m_Crosshair->setChecked(true);
         bundleInteractor = mitk::FiberBundleInteractor::New("FiberBundleInteractor", node);
         mitk::GlobalInteraction::GetInstance()->AddInteractor(bundleInteractor);
         this->GetActiveStdMultiWidget()->GetRenderWindow4()->setCursor(Qt::CrossCursor);
         m_CurrentPickingNode = node;
       }
 
     }
   }
 
 }
 
 void QmitkNavigationButtonsView::PFWidth(int w)
 {
 
   double width = w/10.0;
   m_SelectedNode->SetProperty("planarfigure.line.width", mitk::FloatProperty::New(width) );
   m_SelectedNode->SetProperty("planarfigure.shadow.widthmodifier", mitk::FloatProperty::New(width) );
   m_SelectedNode->SetProperty("planarfigure.outline.width", mitk::FloatProperty::New(width) );
   m_SelectedNode->SetProperty("planarfigure.helperline.width", mitk::FloatProperty::New(width) );
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   QString label = "Width %1";
   label = label.arg(width);
   m_Controls->label_pfwidth->setText(label);
 
 }
 
 void QmitkNavigationButtonsView::PFColor()
 {
 
   QColor color = QColorDialog::getColor();
 
   m_Controls->m_PFColor->setAutoFillBackground(true);
   QString styleSheet = "background-color:rgb(";
   styleSheet.append(QString::number(color.red()));
   styleSheet.append(",");
   styleSheet.append(QString::number(color.green()));
   styleSheet.append(",");
   styleSheet.append(QString::number(color.blue()));
   styleSheet.append(")");
   m_Controls->m_PFColor->setStyleSheet(styleSheet);
 
   m_SelectedNode->SetProperty( "planarfigure.default.line.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
   m_SelectedNode->SetProperty( "planarfigure.default.outline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
   m_SelectedNode->SetProperty( "planarfigure.default.helperline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
   m_SelectedNode->SetProperty( "planarfigure.default.markerline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
   m_SelectedNode->SetProperty( "planarfigure.default.marker.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
 
   m_SelectedNode->SetProperty( "planarfigure.hover.line.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0)  );
   m_SelectedNode->SetProperty( "planarfigure.hover.outline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0)  );
   m_SelectedNode->SetProperty( "planarfigure.hover.helperline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0)  );
 //  m_SelectedNode->SetProperty( "planarfigure.hover.markerline.color", mitk::ColorProperty::New(0.0,1.0,0.0)  );
 //  m_SelectedNode->SetProperty( "planarfigure.hover.marker.color", mitk::ColorProperty::New(0.0,1.0,0.0)  );
 
 //  m_SelectedNode->SetProperty( "planarfigure.selected.line.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
 //  m_SelectedNode->SetProperty( "planarfigure.selected.outline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
 //  m_SelectedNode->SetProperty( "planarfigure.selected.helperline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
 //  m_SelectedNode->SetProperty( "planarfigure.selected.markerline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
 //  m_SelectedNode->SetProperty( "planarfigure.selected.marker.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkNavigationButtonsView::PFColor3D()
 {
 
   QColor color = QColorDialog::getColor();
 
   m_Controls->m_PFColor3D->setAutoFillBackground(true);
   QString styleSheet = "background-color:rgb(";
   styleSheet.append(QString::number(color.red()));
   styleSheet.append(",");
   styleSheet.append(QString::number(color.green()));
   styleSheet.append(",");
   styleSheet.append(QString::number(color.blue()));
   styleSheet.append(")");
   m_Controls->m_PFColor3D->setStyleSheet(styleSheet);
 
   m_SelectedNode->SetProperty( "color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkNavigationButtonsView::Heatmap()
 {
   if(m_SelectedNode)
   {
     mitk::FiberBundle* bundle = dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData());
     if(!bundle)
       return;
 
     ///////////////////////////////
     // Generate unsigned char Image
     typedef unsigned char OutPixType2;
 
     // run generator
     typedef itk::Image< float, 3 >            WMPImageType;
     typedef itk::TractsToProbabilityImageFilter<WMPImageType,
         OutPixType2> ImageGeneratorType2;
     ImageGeneratorType2::Pointer generator = ImageGeneratorType2::New();
     //generator->SetInput(NULL);
     generator->SetFiberBundle(bundle);
     generator->SetInvertImage(false);
     generator->SetUpsamplingFactor(2);
     generator->SetBinaryEnvelope(false);
     generator->Update();
 
     // get result
     typedef itk::Image<OutPixType2,3> OutType2;
     OutType2::Pointer outImg = generator->GetOutput();
 
     mitk::Image::Pointer img2 = mitk::Image::New();
     img2->InitializeByItk(outImg.GetPointer());
     img2->SetVolume(outImg->GetBufferPointer());
 
     // to datastorage
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData(img2);
     QString name(m_SelectedNode->GetName().c_str());
     name += "_heatmap";
     node->SetName(name.toStdString());
     node->SetVisibility(true);
 
     GetDataStorage()->Add(node);
   }
 }
 
 void QmitkNavigationButtonsView::LineWidthChanged(int w)
 {
   m_SelectedNode->SetIntProperty("LineWidth", w);
 
   QString label = "Width %1";
   label = label.arg(w);
   m_Controls->label_linewidth->setText(label);
 }
 
 void QmitkNavigationButtonsView::TubeRadiusChanged(int r)
 {
   m_SelectedNode->SetFloatProperty("TubeRadius", (float) r / 100.0);
 
   QString label = "Radius %1";
   label = label.arg(r / 100.0);
   m_Controls->label_tuberadius->setText(label);
 }
 
 void QmitkNavigationButtonsView::Welcome()
 {
   berry::PlatformUI::GetWorkbench()->GetIntroManager()->ShowIntro(
    GetSite()->GetWorkbenchWindow(), false);
 }