diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiNormilzationFilter.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiNormilzationFilter.h
new file mode 100644
index 0000000000..98283a6712
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiNormilzationFilter.h
@@ -0,0 +1,85 @@
+/*===================================================================
+
+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>
+
+namespace itk{
+/** \class DwiNormilzationFilter
+ *  \brief Max-Normalizes the data vectors either using the global baseline maximum 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 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;
+
+    itkSetMacro( GradientDirections, GradientContainerType )
+    itkSetMacro( NewMax, TInPixelType )
+    itkSetMacro( UseGlobalMax, bool )
+
+    protected:
+        DwiNormilzationFilter();
+    ~DwiNormilzationFilter() {}
+    void PrintSelf(std::ostream& os, Indent indent) const;
+
+    void BeforeThreadedGenerateData();
+    void ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, ThreadIdType);
+
+    GradientContainerType   m_GradientDirections;
+    int                     m_B0Index;
+    TInPixelType            m_NewMax;
+    bool                    m_UseGlobalMax;
+    double                  m_GlobalMax;
+};
+
+}
+
+#ifndef ITK_MANUAL_INSTANTIATION
+#include "itkDwiNormilzationFilter.txx"
+#endif
+
+#endif //__itkDwiNormilzationFilter_h_
+
diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiNormilzationFilter.txx b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiNormilzationFilter.txx
new file mode 100644
index 0000000000..ad4364059e
--- /dev/null
+++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/itkDwiNormilzationFilter.txx
@@ -0,0 +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.
+
+===================================================================*/
+
+#ifndef __itkDwiNormilzationFilter_txx
+#define __itkDwiNormilzationFilter_txx
+
+#include <time.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define _USE_MATH_DEFINES
+#include <math.h>
+
+#include "itkImageRegionConstIterator.h"
+#include "itkImageRegionConstIteratorWithIndex.h"
+#include "itkImageRegionIterator.h"
+
+namespace itk {
+
+
+template< class TInPixelType >
+DwiNormilzationFilter< TInPixelType>::DwiNormilzationFilter()
+    :m_B0Index(-1)
+    ,m_NewMax(1000)
+    ,m_UseGlobalMax(false)
+{
+    this->SetNumberOfRequiredInputs( 1 );
+}
+
+template< class TInPixelType >
+void DwiNormilzationFilter< TInPixelType>::BeforeThreadedGenerateData()
+{
+    m_B0Index = -1;
+    typename InputImageType::Pointer inputImagePointer = static_cast< InputImageType * >( this->ProcessObject::GetInput(0) );
+
+    for (unsigned int i=0; i<inputImagePointer->GetVectorLength(); i++)
+    {
+        GradientDirectionType g = m_GradientDirections->GetElement(i);
+        if (g.magnitude()<0.001)
+            m_B0Index = i;
+    }
+    if (m_B0Index==-1)
+        itkExceptionMacro(<< "DwiNormilzationFilter: No b-Zero indecies found!");
+
+    m_GlobalMax = 0;
+    if (m_UseGlobalMax)
+    {
+        typedef ImageRegionConstIterator< InputImageType > InputIteratorType;
+        typename InputImageType::Pointer inputImagePointer = static_cast< InputImageType * >( this->ProcessObject::GetInput(0) );
+
+        InputIteratorType git( inputImagePointer, inputImagePointer->GetLargestPossibleRegion() );
+        git.GoToBegin();
+        while( !git.IsAtEnd() )
+        {
+            if (git.Get()[m_B0Index]>m_GlobalMax)
+                m_GlobalMax = git.Get()[m_B0Index];
+            ++git;
+        }
+    }
+}
+
+template< class TInPixelType >
+void DwiNormilzationFilter< TInPixelType>::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, ThreadIdType )
+{
+    typename OutputImageType::Pointer outputImage = static_cast< OutputImageType * >(this->ProcessObject::GetOutput(0));
+
+    ImageRegionIterator< OutputImageType > oit(outputImage, outputRegionForThread);
+    oit.GoToBegin();
+
+    typedef ImageRegionConstIterator< InputImageType > InputIteratorType;
+    typename InputImageType::Pointer inputImagePointer = static_cast< InputImageType * >( this->ProcessObject::GetInput(0) );
+
+    typename OutputImageType::PixelType nullPix;
+    nullPix.SetSize(inputImagePointer->GetVectorLength());
+    nullPix.Fill(0);
+
+    InputIteratorType git( inputImagePointer, outputRegionForThread );
+    git.GoToBegin();
+    while( !git.IsAtEnd() )
+    {
+        typename InputImageType::PixelType pix = git.Get();
+
+        double S0 = pix[m_B0Index];
+        if (m_UseGlobalMax)
+            S0 = m_GlobalMax;
+
+        if (S0>0.1)
+        {
+            for (unsigned int i=0; i<inputImagePointer->GetVectorLength(); i++)
+            {
+                double val = (double)pix[i];
+
+                if (val!=val || val<0)
+                    val = 0;
+                else
+                {
+                    val /= S0;
+                    val *= (double)m_NewMax;
+                }
+                pix[i] = (TInPixelType)val;
+            }
+            oit.Set(pix);
+        }
+        else
+            oit.Set(nullPix);
+
+        ++oit;
+        ++git;
+    }
+
+    std::cout << "One Thread finished calculation" << std::endl;
+}
+
+template< class TInPixelType >
+void
+DwiNormilzationFilter< TInPixelType>
+::PrintSelf(std::ostream& os, Indent indent) const
+{
+    Superclass::PrintSelf(os,indent);
+}
+
+}
+
+#endif // __itkDwiNormilzationFilter_txx
diff --git a/Modules/DiffusionImaging/DiffusionCore/files.cmake b/Modules/DiffusionImaging/DiffusionCore/files.cmake
index ac90de0f2d..c7b3f04aed 100644
--- a/Modules/DiffusionImaging/DiffusionCore/files.cmake
+++ b/Modules/DiffusionImaging/DiffusionCore/files.cmake
@@ -1,129 +1,129 @@
 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
 
   # DataStructures -> DWI
   IODataStructures/DiffusionWeightedImages/mitkDiffusionImageHeaderInformation.cpp
   IODataStructures/DiffusionWeightedImages/mitkDiffusionImageSource.cpp
   IODataStructures/DiffusionWeightedImages/mitkNrrdDiffusionImageWriter.cpp
 
   IODataStructures/DiffusionWeightedImages/mitkImageToDiffusionImageSource.cpp
   IODataStructures/DiffusionWeightedImages/mitkDiffusionImageCorrectionFilter.cpp
 
   # DataStructures -> QBall
   IODataStructures/QBallImages/mitkQBallImageSource.cpp
   IODataStructures/QBallImages/mitkQBallImage.cpp
 
   # DataStructures -> Tensor
   IODataStructures/TensorImages/mitkTensorImage.cpp
 
   #IODataStructures/mitkRegistrationObject.cpp
 
   # Rendering
   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
 
   # Registration Algorithms & Co.
   Algorithms/Registration/mitkRegistrationWrapper.cpp
   Algorithms/Registration/mitkPyramidImageRegistrationMethod.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
 
   # 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/Registration/mitkDWIHeadMotionCorrectionFilter.h
   Algorithms/mitkDiffusionImageToDiffusionImageFilter.h
   Algorithms/itkNonLocalMeansDenoisingFilter.h
   Algorithms/itkVectorImageToImageFilter.h
 
 
 )
 
 set( TOOL_FILES
 )
 
diff --git a/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingView.cpp b/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingView.cpp
index 24334856a7..f6035585d8 100644
--- a/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingView.cpp
+++ b/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingView.cpp
@@ -1,1315 +1,1355 @@
 /*===================================================================
 
 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 "QmitkBasicImageProcessingView.h"
 
 // QT includes (GUI)
 #include <qlabel.h>
 #include <qspinbox.h>
 #include <qpushbutton.h>
 #include <qcheckbox.h>
 #include <qgroupbox.h>
 #include <qradiobutton.h>
 #include <qmessagebox.h>
 
 // Berry includes (selection service)
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // MITK includes (GUI)
 #include "QmitkStdMultiWidget.h"
 #include "QmitkDataNodeSelectionProvider.h"
 #include "mitkDataNodeObject.h"
 
 // MITK includes (general)
 #include "mitkNodePredicateDataType.h"
 #include "mitkNodePredicateDimension.h"
 #include "mitkNodePredicateAnd.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkVectorImageMapper2D.h"
 #include "mitkProperties.h"
 
 // Includes for image casting between ITK and MITK
 #include "mitkImageCast.h"
 #include "mitkITKImageImport.h"
 
 // ITK includes (general)
 #include <itkVectorImage.h>
 #include <itkImageFileWriter.h>
 
 // Morphological Operations
 #include <itkBinaryBallStructuringElement.h>
 #include <itkGrayscaleDilateImageFilter.h>
 #include <itkGrayscaleErodeImageFilter.h>
 #include <itkGrayscaleMorphologicalOpeningImageFilter.h>
 #include <itkGrayscaleMorphologicalClosingImageFilter.h>
 
 // Smoothing
 #include <itkMedianImageFilter.h>
 #include <itkDiscreteGaussianImageFilter.h>
 #include <itkTotalVariationDenoisingImageFilter.h>
 
 // Threshold
 #include <itkBinaryThresholdImageFilter.h>
 
 // Inversion
 #include <itkInvertIntensityImageFilter.h>
 
 // Derivatives
 #include <itkGradientMagnitudeRecursiveGaussianImageFilter.h>
 #include <itkLaplacianImageFilter.h>
 #include <itkSobelEdgeDetectionImageFilter.h>
 
 // Resampling
 #include <itkResampleImageFilter.h>
 #include <itkNearestNeighborInterpolateImageFunction.h>
 #include <itkCastImageFilter.h>
 #include <itkLinearInterpolateImageFunction.h>
 
 // Image Arithmetics
 #include <itkAddImageFilter.h>
 #include <itkSubtractImageFilter.h>
 #include <itkMultiplyImageFilter.h>
 #include <itkDivideImageFilter.h>
 
 // Boolean operations
 #include <itkOrImageFilter.h>
 #include <itkAndImageFilter.h>
 #include <itkXorImageFilter.h>
 
 // Flip Image
 #include <itkFlipImageFilter.h>
 
+#include <itkRescaleIntensityImageFilter.h>
+
 
 // Convenient Definitions
 typedef itk::Image<short, 3>                                                            ImageType;
 typedef itk::Image<unsigned char, 3>                                                    SegmentationImageType;
 typedef itk::Image<double, 3>                                                           FloatImageType;
 typedef itk::Image<itk::Vector<float,3>, 3>                                             VectorImageType;
 
 typedef itk::BinaryBallStructuringElement<ImageType::PixelType, 3>                      BallType;
 typedef itk::GrayscaleDilateImageFilter<ImageType, ImageType, BallType>                 DilationFilterType;
 typedef itk::GrayscaleErodeImageFilter<ImageType, ImageType, BallType>                  ErosionFilterType;
 typedef itk::GrayscaleMorphologicalOpeningImageFilter<ImageType, ImageType, BallType>   OpeningFilterType;
 typedef itk::GrayscaleMorphologicalClosingImageFilter<ImageType, ImageType, BallType>   ClosingFilterType;
 
 typedef itk::MedianImageFilter< ImageType, ImageType >                                  MedianFilterType;
 typedef itk::DiscreteGaussianImageFilter< ImageType, ImageType>                         GaussianFilterType;
 typedef itk::TotalVariationDenoisingImageFilter<FloatImageType, FloatImageType>         TotalVariationFilterType;
 typedef itk::TotalVariationDenoisingImageFilter<VectorImageType, VectorImageType>       VectorTotalVariationFilterType;
 
 typedef itk::BinaryThresholdImageFilter< ImageType, ImageType >                         ThresholdFilterType;
 typedef itk::InvertIntensityImageFilter< ImageType, ImageType >                         InversionFilterType;
 
 typedef itk::GradientMagnitudeRecursiveGaussianImageFilter< ImageType, ImageType >      GradientFilterType;
 typedef itk::LaplacianImageFilter< FloatImageType, FloatImageType >                     LaplacianFilterType;
 typedef itk::SobelEdgeDetectionImageFilter< FloatImageType, FloatImageType >            SobelFilterType;
 
 typedef itk::ResampleImageFilter< ImageType, ImageType >                                ResampleImageFilterType;
 typedef itk::ResampleImageFilter< ImageType, ImageType >                                ResampleImageFilterType2;
 typedef itk::CastImageFilter< ImageType, FloatImageType >                               ImagePTypeToFloatPTypeCasterType;
 
 typedef itk::AddImageFilter< ImageType, ImageType, ImageType >                          AddFilterType;
 typedef itk::SubtractImageFilter< ImageType, ImageType, ImageType >                     SubtractFilterType;
 typedef itk::MultiplyImageFilter< ImageType, ImageType, ImageType >                     MultiplyFilterType;
 typedef itk::DivideImageFilter< ImageType, ImageType, FloatImageType >                  DivideFilterType;
 
 typedef itk::OrImageFilter< ImageType, ImageType >                                      OrImageFilterType;
 typedef itk::AndImageFilter< ImageType, ImageType >                                     AndImageFilterType;
 typedef itk::XorImageFilter< ImageType, ImageType >                                     XorImageFilterType;
 
 typedef itk::FlipImageFilter< ImageType >                                               FlipImageFilterType;
 
 typedef itk::LinearInterpolateImageFunction< ImageType, double >                        LinearInterpolatorType;
 typedef itk::NearestNeighborInterpolateImageFunction< ImageType, double >               NearestInterpolatorType;
 
 
 QmitkBasicImageProcessing::QmitkBasicImageProcessing()
 : QmitkFunctionality(),
   m_Controls(NULL),
   m_SelectedImageNode(NULL),
   m_TimeStepperAdapter(NULL),
   m_SelectionListener(NULL)
 {
 }
 
 QmitkBasicImageProcessing::~QmitkBasicImageProcessing()
 {
   //berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
   //if(s)
   //  s->RemoveSelectionListener(m_SelectionListener);
 }
 
 void QmitkBasicImageProcessing::CreateQtPartControl(QWidget *parent)
 {
   if (m_Controls == NULL)
   {
     m_Controls = new Ui::QmitkBasicImageProcessingViewControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
 
 
     //setup predictaes for combobox
 
     mitk::NodePredicateDimension::Pointer dimensionPredicate = mitk::NodePredicateDimension::New(3);
     mitk::NodePredicateDataType::Pointer imagePredicate = mitk::NodePredicateDataType::New("Image");
     m_Controls->m_ImageSelector2->SetDataStorage(this->GetDefaultDataStorage());
     m_Controls->m_ImageSelector2->SetPredicate(mitk::NodePredicateAnd::New(dimensionPredicate, imagePredicate));
   }
   m_Controls->gbTwoImageOps->hide();
 
   m_SelectedImageNode = mitk::DataStorageSelection::New(this->GetDefaultDataStorage(), false);
 }
 
 void QmitkBasicImageProcessing::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->cbWhat1), SIGNAL( activated(int) ), this, SLOT( SelectAction(int) ) );
     connect( (QObject*)(m_Controls->btnDoIt), SIGNAL(clicked()),(QObject*) this, SLOT(StartButtonClicked()));
 
     connect( (QObject*)(m_Controls->cbWhat2), SIGNAL( activated(int) ), this, SLOT( SelectAction2(int) ) );
     connect( (QObject*)(m_Controls->btnDoIt2), SIGNAL(clicked()),(QObject*) this, SLOT(StartButton2Clicked()));
 
     connect( (QObject*)(m_Controls->rBOneImOp), SIGNAL( clicked() ), this, SLOT( ChangeGUI() ) );
     connect( (QObject*)(m_Controls->rBTwoImOp), SIGNAL( clicked() ), this, SLOT( ChangeGUI() ) );
 
     connect( (QObject*)(m_Controls->cbParam4), SIGNAL( activated(int) ), this, SLOT( SelectInterpolator(int) ) );
   }
 
   m_TimeStepperAdapter = new QmitkStepperAdapter((QObject*) m_Controls->sliceNavigatorTime,
     GetActiveStdMultiWidget()->GetTimeNavigationController()->GetTime(), "sliceNavigatorTimeFromBIP");
 }
 
 void QmitkBasicImageProcessing::Activated()
 {
   QmitkFunctionality::Activated();
 
   this->m_Controls->cbWhat1->clear();
   this->m_Controls->cbWhat1->insertItem( NOACTIONSELECTED, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Please select operation", 0, QApplication::UnicodeUTF8) ));
   this->m_Controls->cbWhat1->insertItem( CATEGORY_DENOISING, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "--- Denoising ---", 0, QApplication::UnicodeUTF8) ));
   this->m_Controls->cbWhat1->insertItem( GAUSSIAN, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Gaussian", 0, QApplication::UnicodeUTF8) ));
   this->m_Controls->cbWhat1->insertItem( MEDIAN, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Median", 0, QApplication::UnicodeUTF8) ));
   this->m_Controls->cbWhat1->insertItem( TOTALVARIATION, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Total Variation", 0, QApplication::UnicodeUTF8) ));
   this->m_Controls->cbWhat1->insertItem( CATEGORY_MORPHOLOGICAL, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "--- Morphological ---", 0, QApplication::UnicodeUTF8) ));
   this->m_Controls->cbWhat1->insertItem( DILATION, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Dilation", 0, QApplication::UnicodeUTF8) ));
   this->m_Controls->cbWhat1->insertItem( EROSION, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Erosion", 0, QApplication::UnicodeUTF8) ));
   this->m_Controls->cbWhat1->insertItem( OPENING, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Opening", 0, QApplication::UnicodeUTF8) ));
   this->m_Controls->cbWhat1->insertItem( CLOSING, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Closing", 0, QApplication::UnicodeUTF8) ));
   this->m_Controls->cbWhat1->insertItem( CATEGORY_EDGE_DETECTION, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "--- Edge Detection ---", 0, QApplication::UnicodeUTF8) ));
   this->m_Controls->cbWhat1->insertItem( GRADIENT, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Gradient", 0, QApplication::UnicodeUTF8) ));
   this->m_Controls->cbWhat1->insertItem( LAPLACIAN, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Laplacian (2nd Derivative)", 0, QApplication::UnicodeUTF8) ));
   this->m_Controls->cbWhat1->insertItem( SOBEL, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Sobel Operator", 0, QApplication::UnicodeUTF8) ));
   this->m_Controls->cbWhat1->insertItem( CATEGORY_MISC, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "--- Misc ---", 0, QApplication::UnicodeUTF8) ));
   this->m_Controls->cbWhat1->insertItem( THRESHOLD, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Threshold", 0, QApplication::UnicodeUTF8) ));
   this->m_Controls->cbWhat1->insertItem( INVERSION, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Image Inversion", 0, QApplication::UnicodeUTF8) ));
   this->m_Controls->cbWhat1->insertItem( DOWNSAMPLING, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Downsampling", 0, QApplication::UnicodeUTF8) ));
   this->m_Controls->cbWhat1->insertItem( FLIPPING, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Flipping", 0, QApplication::UnicodeUTF8) ));
   this->m_Controls->cbWhat1->insertItem( RESAMPLING, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Resample to", 0, QApplication::UnicodeUTF8) ));
+  this->m_Controls->cbWhat1->insertItem( RESCALE, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Rescale image values", 0, QApplication::UnicodeUTF8) ));
 
   this->m_Controls->cbWhat2->clear();
   this->m_Controls->cbWhat2->insertItem( TWOIMAGESNOACTIONSELECTED, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Please select on operation", 0, QApplication::UnicodeUTF8) ) );
   this->m_Controls->cbWhat2->insertItem( CATEGORY_ARITHMETIC, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "--- Arithmetric operations ---", 0, QApplication::UnicodeUTF8) ) );
   this->m_Controls->cbWhat2->insertItem( ADD, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Add to Image 1:", 0, QApplication::UnicodeUTF8) ) );
   this->m_Controls->cbWhat2->insertItem( SUBTRACT, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Subtract from Image 1:", 0, QApplication::UnicodeUTF8) ) );
   this->m_Controls->cbWhat2->insertItem( MULTIPLY, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Multiply with Image 1:", 0, QApplication::UnicodeUTF8) ) );
   this->m_Controls->cbWhat2->insertItem( RESAMPLE_TO, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Resample Image 1 to fit geometry:", 0, QApplication::UnicodeUTF8) ) );
   this->m_Controls->cbWhat2->insertItem( DIVIDE, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Divide Image 1 by:", 0, QApplication::UnicodeUTF8) ) );
   this->m_Controls->cbWhat2->insertItem( CATEGORY_BOOLEAN, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "--- Boolean operations ---", 0, QApplication::UnicodeUTF8) ) );
   this->m_Controls->cbWhat2->insertItem( AND, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "AND", 0, QApplication::UnicodeUTF8) ) );
   this->m_Controls->cbWhat2->insertItem( OR, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "OR", 0, QApplication::UnicodeUTF8) ) );
   this->m_Controls->cbWhat2->insertItem( XOR, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "XOR", 0, QApplication::UnicodeUTF8) ) );
 
   this->m_Controls->cbParam4->clear();
   this->m_Controls->cbParam4->insertItem( LINEAR, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Linear", 0, QApplication::UnicodeUTF8) ) );
   this->m_Controls->cbParam4->insertItem( NEAREST, QString( QApplication::translate("QmitkBasicImageProcessingViewControls", "Nearest neighbor", 0, QApplication::UnicodeUTF8) ) );
 
   m_Controls->dsbParam1->hide();
   m_Controls->dsbParam2->hide();
   m_Controls->dsbParam3->hide();
   m_Controls->tlParam3->hide();
   m_Controls->tlParam4->hide();
   m_Controls->cbParam4->hide();
 }
 
 //datamanager selection changed
 void QmitkBasicImageProcessing::OnSelectionChanged(std::vector<mitk::DataNode*> nodes)
 {
   //any nodes there?
   if (!nodes.empty())
   {
   // reset GUI
 //  this->ResetOneImageOpPanel();
   m_Controls->sliceNavigatorTime->setEnabled(false);
   m_Controls->leImage1->setText("Select an Image in Data Manager");
   m_Controls->tlWhat1->setEnabled(false);
   m_Controls->cbWhat1->setEnabled(false);
   m_Controls->tlWhat2->setEnabled(false);
   m_Controls->cbWhat2->setEnabled(false);
 
   m_SelectedImageNode->RemoveAllNodes();
   //get the selected Node
   mitk::DataNode* _DataNode = nodes.front();
   *m_SelectedImageNode = _DataNode;
   //try to cast to image
   mitk::Image::Pointer tempImage = dynamic_cast<mitk::Image*>(m_SelectedImageNode->GetNode()->GetData());
 
     //no image
     if( tempImage.IsNull() || (tempImage->IsInitialized() == false) )
     {
       m_Controls->leImage1->setText("Not an image.");
       return;
     }
 
     //2D image
     if( tempImage->GetDimension() < 3)
     {
       m_Controls->leImage1->setText("2D images are not supported.");
       return;
     }
 
     //image
     m_Controls->leImage1->setText(QString(m_SelectedImageNode->GetNode()->GetName().c_str()));
 
     // button coding
     if ( tempImage->GetDimension() > 3 )
     {
       m_Controls->sliceNavigatorTime->setEnabled(true);
       m_Controls->tlTime->setEnabled(true);
     }
     m_Controls->tlWhat1->setEnabled(true);
     m_Controls->cbWhat1->setEnabled(true);
     m_Controls->tlWhat2->setEnabled(true);
     m_Controls->cbWhat2->setEnabled(true);
   }
 }
 
 void QmitkBasicImageProcessing::ChangeGUI()
 {
   if(m_Controls->rBOneImOp->isChecked())
   {
     m_Controls->gbTwoImageOps->hide();
     m_Controls->gbOneImageOps->show();
   }
   else if(m_Controls->rBTwoImOp->isChecked())
   {
     m_Controls->gbOneImageOps->hide();
     m_Controls->gbTwoImageOps->show();
   }
 }
 
 void QmitkBasicImageProcessing::ResetOneImageOpPanel()
 {
   m_Controls->tlParam1->setText("Param1");
   m_Controls->tlParam2->setText("Param2");
 
   m_Controls->cbWhat1->setCurrentIndex(0);
 
   m_Controls->tlTime->setEnabled(false);
 
   this->ResetParameterPanel();
 
   m_Controls->btnDoIt->setEnabled(false);
   m_Controls->cbHideOrig->setEnabled(false);
 }
 
 void QmitkBasicImageProcessing::ResetParameterPanel()
 {
   m_Controls->tlParam->setEnabled(false);
   m_Controls->tlParam1->setEnabled(false);
   m_Controls->tlParam2->setEnabled(false);
   m_Controls->tlParam3->setEnabled(false);
   m_Controls->tlParam4->setEnabled(false);
 
   m_Controls->sbParam1->setEnabled(false);
   m_Controls->sbParam2->setEnabled(false);
   m_Controls->dsbParam1->setEnabled(false);
   m_Controls->dsbParam2->setEnabled(false);
   m_Controls->dsbParam3->setEnabled(false);
   m_Controls->cbParam4->setEnabled(false);
   m_Controls->sbParam1->setValue(0);
   m_Controls->sbParam2->setValue(0);
   m_Controls->dsbParam1->setValue(0);
   m_Controls->dsbParam2->setValue(0);
   m_Controls->dsbParam3->setValue(0);
 
   m_Controls->sbParam1->show();
   m_Controls->sbParam2->show();
   m_Controls->dsbParam1->hide();
   m_Controls->dsbParam2->hide();
   m_Controls->dsbParam3->hide();
   m_Controls->cbParam4->hide();
   m_Controls->tlParam3->hide();
   m_Controls->tlParam4->hide();
 }
 
 void QmitkBasicImageProcessing::ResetTwoImageOpPanel()
 {
   m_Controls->cbWhat2->setCurrentIndex(0);
 
   m_Controls->tlImage2->setEnabled(false);
   m_Controls->m_ImageSelector2->setEnabled(false);
 
   m_Controls->btnDoIt2->setEnabled(false);
 }
 
 void QmitkBasicImageProcessing::SelectAction(int action)
 {
   if ( ! m_SelectedImageNode->GetNode() ) return;
 
   // Prepare GUI
   this->ResetParameterPanel();
   m_Controls->btnDoIt->setEnabled(false);
   m_Controls->cbHideOrig->setEnabled(false);
 
   QString text1 = "No Parameters";
   QString text2 = "No Parameters";
   QString text3 = "No Parameters";
   QString text4 = "No Parameters";
 
   if (action != 19)
   {
     m_Controls->dsbParam1->hide();
     m_Controls->dsbParam2->hide();
     m_Controls->dsbParam3->hide();
     m_Controls->tlParam3->hide();
     m_Controls->tlParam4->hide();
     m_Controls->sbParam1->show();
     m_Controls->sbParam2->show();
     m_Controls->cbParam4->hide();
   }
   // check which operation the user has selected and set parameters and GUI accordingly
   switch (action)
   {
   case 2:
     {
       m_SelectedAction = GAUSSIAN;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->setEnabled(true);
       text1 = "&Variance:";
 
       m_Controls->sbParam1->setMinimum( 0 );
       m_Controls->sbParam1->setMaximum( 200 );
       m_Controls->sbParam1->setValue( 2 );
       break;
     }
 
   case 3:
     {
       m_SelectedAction = MEDIAN;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->setEnabled(true);
       text1 = "&Radius:";
       m_Controls->sbParam1->setMinimum( 0 );
       m_Controls->sbParam1->setMaximum( 200 );
       m_Controls->sbParam1->setValue( 3 );
       break;
     }
 
   case 4:
     {
       m_SelectedAction = TOTALVARIATION;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->setEnabled(true);
       m_Controls->tlParam2->setEnabled(true);
       m_Controls->sbParam2->setEnabled(true);
       text1 = "Number Iterations:";
       text2 = "Regularization\n(Lambda/1000):";
       m_Controls->sbParam1->setMinimum( 1 );
       m_Controls->sbParam1->setMaximum( 1000 );
       m_Controls->sbParam1->setValue( 40 );
       m_Controls->sbParam2->setMinimum( 0 );
       m_Controls->sbParam2->setMaximum( 100000 );
       m_Controls->sbParam2->setValue( 1 );
       break;
     }
 
   case 6:
     {
       m_SelectedAction = DILATION;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->setEnabled(true);
       text1 = "&Radius:";
       m_Controls->sbParam1->setMinimum( 0 );
       m_Controls->sbParam1->setMaximum( 200 );
       m_Controls->sbParam1->setValue( 3 );
       break;
     }
 
   case 7:
     {
       m_SelectedAction = EROSION;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->setEnabled(true);
       text1 = "&Radius:";
       m_Controls->sbParam1->setMinimum( 0 );
       m_Controls->sbParam1->setMaximum( 200 );
       m_Controls->sbParam1->setValue( 3 );
       break;
     }
 
   case 8:
     {
       m_SelectedAction = OPENING;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->setEnabled(true);
       text1 = "&Radius:";
       m_Controls->sbParam1->setMinimum( 0 );
       m_Controls->sbParam1->setMaximum( 200 );
       m_Controls->sbParam1->setValue( 3 );
       break;
     }
 
   case 9:
     {
       m_SelectedAction = CLOSING;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->setEnabled(true);
       text1 = "&Radius:";
       m_Controls->sbParam1->setMinimum( 0 );
       m_Controls->sbParam1->setMaximum( 200 );
       m_Controls->sbParam1->setValue( 3 );
       break;
     }
 
   case 11:
     {
       m_SelectedAction = GRADIENT;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->setEnabled(true);
       text1 = "Sigma of Gaussian Kernel:\n(in Image Spacing Units)";
       m_Controls->sbParam1->setMinimum( 0 );
       m_Controls->sbParam1->setMaximum( 200 );
       m_Controls->sbParam1->setValue( 2 );
       break;
     }
 
   case 12:
     {
       m_SelectedAction = LAPLACIAN;
       break;
     }
 
   case 13:
     {
       m_SelectedAction = SOBEL;
       break;
     }
 
   case 15:
     {
       m_SelectedAction = THRESHOLD;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->setEnabled(true);
       m_Controls->tlParam2->setEnabled(true);
       m_Controls->sbParam2->setEnabled(true);
       text1 = "Lower threshold:";
       text2 = "Upper threshold:";
       m_Controls->sbParam1->setMinimum( -100000 );
       m_Controls->sbParam1->setMaximum( 100000 );
       m_Controls->sbParam1->setValue( 0 );
       m_Controls->sbParam2->setMinimum( -100000 );
       m_Controls->sbParam2->setMaximum( 100000 );
       m_Controls->sbParam2->setValue( 300 );
       break;
     }
 
   case 16:
     {
       m_SelectedAction = INVERSION;
       break;
     }
 
   case 17:
     {
       m_SelectedAction = DOWNSAMPLING;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->setEnabled(true);
       text1 = "Downsampling by Factor:";
       m_Controls->sbParam1->setMinimum( 1 );
       m_Controls->sbParam1->setMaximum( 100 );
       m_Controls->sbParam1->setValue( 2 );
       break;
     }
 
   case 18:
     {
       m_SelectedAction = FLIPPING;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->setEnabled(true);
       text1 = "Flip across axis:";
       m_Controls->sbParam1->setMinimum( 0 );
       m_Controls->sbParam1->setMaximum( 2 );
       m_Controls->sbParam1->setValue( 1 );
       break;
     }
 
   case 19:
     {
       m_SelectedAction = RESAMPLING;
       m_Controls->tlParam1->setEnabled(true);
       m_Controls->sbParam1->setEnabled(false);
       m_Controls->sbParam1->hide();
       m_Controls->dsbParam1->show();
       m_Controls->dsbParam1->setEnabled(true);
       m_Controls->tlParam2->setEnabled(true);
       m_Controls->sbParam2->setEnabled(false);
       m_Controls->sbParam2->hide();
       m_Controls->dsbParam2->show();
       m_Controls->dsbParam2->setEnabled(true);
       m_Controls->tlParam3->show();
       m_Controls->tlParam3->setEnabled(true);
       m_Controls->dsbParam3->show();
       m_Controls->dsbParam3->setEnabled(true);
       m_Controls->tlParam4->show();
       m_Controls->tlParam4->setEnabled(true);
       m_Controls->cbParam4->show();
       m_Controls->cbParam4->setEnabled(true);
 
       m_Controls->dsbParam1->setMinimum(0.01);
       m_Controls->dsbParam1->setMaximum(10.0);
       m_Controls->dsbParam1->setSingleStep(0.1);
       m_Controls->dsbParam1->setValue(0.3);
       m_Controls->dsbParam2->setMinimum(0.01);
       m_Controls->dsbParam2->setMaximum(10.0);
       m_Controls->dsbParam2->setSingleStep(0.1);
       m_Controls->dsbParam2->setValue(0.3);
       m_Controls->dsbParam3->setMinimum(0.01);
       m_Controls->dsbParam3->setMaximum(10.0);
       m_Controls->dsbParam3->setSingleStep(0.1);
       m_Controls->dsbParam3->setValue(1.5);
 
       text1 = "x-spacing:";
       text2 = "y-spacing:";
       text3 = "z-spacing:";
       text4 = "Interplation:";
       break;
     }
 
+  case 20:
+    {
+      m_SelectedAction = RESCALE;
+      m_Controls->dsbParam1->show();
+      m_Controls->tlParam1->show();
+      m_Controls->dsbParam1->setEnabled(true);
+      m_Controls->tlParam1->setEnabled(true);
+      m_Controls->dsbParam2->show();
+      m_Controls->tlParam2->show();
+      m_Controls->dsbParam2->setEnabled(true);
+      m_Controls->tlParam2->setEnabled(true);
+      text1 = "Output minimum:";
+      text2 = "Output maximum:";
+      break;
+    }
+
   default: return;
   }
 
   m_Controls->tlParam->setEnabled(true);
   m_Controls->tlParam1->setText(text1);
   m_Controls->tlParam2->setText(text2);
   m_Controls->tlParam3->setText(text3);
   m_Controls->tlParam4->setText(text4);
 
   m_Controls->btnDoIt->setEnabled(true);
   m_Controls->cbHideOrig->setEnabled(true);
 }
 
 void QmitkBasicImageProcessing::StartButtonClicked()
 {
   if(!m_SelectedImageNode->GetNode()) return;
 
   this->BusyCursorOn();
 
   mitk::Image::Pointer newImage;
 
   try
   {
     newImage = dynamic_cast<mitk::Image*>(m_SelectedImageNode->GetNode()->GetData());
   }
   catch ( std::exception &e )
   {
   QString exceptionString = "An error occured during image loading:\n";
   exceptionString.append( e.what() );
     QMessageBox::warning( NULL, "Basic Image Processing", exceptionString , QMessageBox::Ok, QMessageBox::NoButton );
     this->BusyCursorOff();
     return;
   }
 
   // check if input image is valid, casting does not throw exception when casting from 'NULL-Object'
   if ( (! newImage) || (newImage->IsInitialized() == false) )
   {
     this->BusyCursorOff();
 
     QMessageBox::warning( NULL, "Basic Image Processing", "Input image is broken or not initialized. Returning.", QMessageBox::Ok, QMessageBox::NoButton );
     return;
   }
 
   // check if operation is done on 4D a image time step
   if(newImage->GetDimension() > 3)
   {
     mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
     timeSelector->SetInput(newImage);
     timeSelector->SetTimeNr( ((QmitkSliderNavigatorWidget*)m_Controls->sliceNavigatorTime)->GetPos() );
     timeSelector->Update();
     newImage = timeSelector->GetOutput();
   }
 
 
 
   // check if image or vector image
   ImageType::Pointer itkImage = ImageType::New();
   VectorImageType::Pointer itkVecImage = VectorImageType::New();
 
   int isVectorImage = newImage->GetPixelType().GetNumberOfComponents();
 
   if(isVectorImage > 1)
   {
     CastToItkImage( newImage, itkVecImage );
   }
   else
   {
     CastToItkImage( newImage, itkImage );
   }
 
   std::stringstream nameAddition("");
 
   int param1 = m_Controls->sbParam1->value();
   int param2 = m_Controls->sbParam2->value();
   double dparam1 = m_Controls->dsbParam1->value();
   double dparam2 = m_Controls->dsbParam2->value();
   double dparam3 = m_Controls->dsbParam3->value();
 
   try{
 
   switch (m_SelectedAction)
   {
 
   case GAUSSIAN:
     {
       GaussianFilterType::Pointer gaussianFilter = GaussianFilterType::New();
       gaussianFilter->SetInput( itkImage );
       gaussianFilter->SetVariance( param1 );
       gaussianFilter->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(gaussianFilter->GetOutput())->Clone();
       nameAddition << "_Gaussian_var_" << param1;
       std::cout << "Gaussian filtering successful." << std::endl;
       break;
     }
 
   case MEDIAN:
     {
       MedianFilterType::Pointer medianFilter = MedianFilterType::New();
       MedianFilterType::InputSizeType size;
       size.Fill(param1);
       medianFilter->SetRadius( size );
       medianFilter->SetInput(itkImage);
       medianFilter->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(medianFilter->GetOutput())->Clone();
       nameAddition << "_Median_radius_" << param1;
       std::cout << "Median Filtering successful." << std::endl;
       break;
     }
 
   case TOTALVARIATION:
     {
       if(isVectorImage > 1)
       {
         VectorTotalVariationFilterType::Pointer TVFilter
           = VectorTotalVariationFilterType::New();
         TVFilter->SetInput( itkVecImage.GetPointer() );
         TVFilter->SetNumberIterations(param1);
         TVFilter->SetLambda(double(param2)/1000.);
         TVFilter->UpdateLargestPossibleRegion();
 
         newImage = mitk::ImportItkImage(TVFilter->GetOutput())->Clone();
       }
       else
       {
         ImagePTypeToFloatPTypeCasterType::Pointer floatCaster = ImagePTypeToFloatPTypeCasterType::New();
         floatCaster->SetInput( itkImage );
         floatCaster->Update();
         FloatImageType::Pointer fImage = floatCaster->GetOutput();
 
         TotalVariationFilterType::Pointer TVFilter
           = TotalVariationFilterType::New();
         TVFilter->SetInput( fImage.GetPointer() );
         TVFilter->SetNumberIterations(param1);
         TVFilter->SetLambda(double(param2)/1000.);
         TVFilter->UpdateLargestPossibleRegion();
 
         newImage = mitk::ImportItkImage(TVFilter->GetOutput())->Clone();
       }
 
       nameAddition << "_TV_Iter_" << param1 << "_L_" << param2;
       std::cout << "Total Variation Filtering successful." << std::endl;
       break;
     }
 
   case DILATION:
     {
       BallType binaryBall;
       binaryBall.SetRadius( param1 );
       binaryBall.CreateStructuringElement();
 
       DilationFilterType::Pointer dilationFilter = DilationFilterType::New();
       dilationFilter->SetInput( itkImage );
       dilationFilter->SetKernel( binaryBall );
       dilationFilter->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(dilationFilter->GetOutput())->Clone();
       nameAddition << "_Dilated_by_" << param1;
       std::cout << "Dilation successful." << std::endl;
       break;
     }
 
   case EROSION:
     {
       BallType binaryBall;
       binaryBall.SetRadius( param1 );
       binaryBall.CreateStructuringElement();
 
       ErosionFilterType::Pointer erosionFilter = ErosionFilterType::New();
       erosionFilter->SetInput( itkImage );
       erosionFilter->SetKernel( binaryBall );
       erosionFilter->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(erosionFilter->GetOutput())->Clone();
       nameAddition << "_Eroded_by_" << param1;
       std::cout << "Erosion successful." << std::endl;
       break;
     }
 
   case OPENING:
     {
       BallType binaryBall;
       binaryBall.SetRadius( param1 );
       binaryBall.CreateStructuringElement();
 
       OpeningFilterType::Pointer openFilter = OpeningFilterType::New();
       openFilter->SetInput( itkImage );
       openFilter->SetKernel( binaryBall );
       openFilter->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(openFilter->GetOutput())->Clone();
       nameAddition << "_Opened_by_" << param1;
       std::cout << "Opening successful." << std::endl;
       break;
     }
 
   case CLOSING:
     {
       BallType binaryBall;
       binaryBall.SetRadius( param1 );
       binaryBall.CreateStructuringElement();
 
       ClosingFilterType::Pointer closeFilter = ClosingFilterType::New();
       closeFilter->SetInput( itkImage );
       closeFilter->SetKernel( binaryBall );
       closeFilter->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(closeFilter->GetOutput())->Clone();
       nameAddition << "_Closed_by_" << param1;
       std::cout << "Closing successful." << std::endl;
       break;
     }
 
   case GRADIENT:
     {
       GradientFilterType::Pointer gradientFilter = GradientFilterType::New();
       gradientFilter->SetInput( itkImage );
       gradientFilter->SetSigma( param1 );
       gradientFilter->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(gradientFilter->GetOutput())->Clone();
       nameAddition << "_Gradient_sigma_" << param1;
       std::cout << "Gradient calculation successful." << std::endl;
       break;
     }
 
   case LAPLACIAN:
     {
       // the laplace filter requires a float type image as input, we need to cast the itkImage
       // to correct type
       ImagePTypeToFloatPTypeCasterType::Pointer caster = ImagePTypeToFloatPTypeCasterType::New();
       caster->SetInput( itkImage );
       caster->Update();
       FloatImageType::Pointer fImage = caster->GetOutput();
 
       LaplacianFilterType::Pointer laplacianFilter = LaplacianFilterType::New();
       laplacianFilter->SetInput( fImage );
       laplacianFilter->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(laplacianFilter->GetOutput())->Clone();
       nameAddition << "_Second_Derivative";
       std::cout << "Laplacian filtering successful." << std::endl;
       break;
     }
 
   case SOBEL:
     {
       // the sobel filter requires a float type image as input, we need to cast the itkImage
       // to correct type
       ImagePTypeToFloatPTypeCasterType::Pointer caster = ImagePTypeToFloatPTypeCasterType::New();
       caster->SetInput( itkImage );
       caster->Update();
       FloatImageType::Pointer fImage = caster->GetOutput();
 
       SobelFilterType::Pointer sobelFilter = SobelFilterType::New();
       sobelFilter->SetInput( fImage );
       sobelFilter->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(sobelFilter->GetOutput())->Clone();
       nameAddition << "_Sobel";
       std::cout << "Edge Detection successful." << std::endl;
       break;
     }
 
   case THRESHOLD:
     {
       ThresholdFilterType::Pointer thFilter = ThresholdFilterType::New();
       thFilter->SetLowerThreshold(param1 < param2 ? param1 : param2);
       thFilter->SetUpperThreshold(param2 > param1 ? param2 : param1);
       thFilter->SetInsideValue(1);
       thFilter->SetOutsideValue(0);
       thFilter->SetInput(itkImage);
       thFilter->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(thFilter->GetOutput())->Clone();
       nameAddition << "_Threshold";
       std::cout << "Thresholding successful." << std::endl;
       break;
     }
 
   case INVERSION:
     {
       InversionFilterType::Pointer invFilter = InversionFilterType::New();
       mitk::ScalarType min = newImage->GetScalarValueMin();
       mitk::ScalarType max = newImage->GetScalarValueMax();
       invFilter->SetMaximum( max + min );
       invFilter->SetInput(itkImage);
       invFilter->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(invFilter->GetOutput())->Clone();
       nameAddition << "_Inverted";
       std::cout << "Image inversion successful." << std::endl;
       break;
     }
 
   case DOWNSAMPLING:
     {
       ResampleImageFilterType::Pointer downsampler = ResampleImageFilterType::New();
       downsampler->SetInput( itkImage );
 
       NearestInterpolatorType::Pointer interpolator = NearestInterpolatorType::New();
       downsampler->SetInterpolator( interpolator );
 
       downsampler->SetDefaultPixelValue( 0 );
 
       ResampleImageFilterType::SpacingType spacing = itkImage->GetSpacing();
       spacing *= (double) param1;
       downsampler->SetOutputSpacing( spacing );
 
       downsampler->SetOutputOrigin( itkImage->GetOrigin() );
       downsampler->SetOutputDirection( itkImage->GetDirection() );
 
       ResampleImageFilterType::SizeType size = itkImage->GetLargestPossibleRegion().GetSize();
       for ( int i = 0; i < 3; ++i )
       {
         size[i] /= param1;
       }
       downsampler->SetSize( size );
       downsampler->UpdateLargestPossibleRegion();
 
       newImage = mitk::ImportItkImage(downsampler->GetOutput())->Clone();
       nameAddition << "_Downsampled_by_" << param1;
       std::cout << "Downsampling successful." << std::endl;
       break;
     }
 
   case FLIPPING:
     {
       FlipImageFilterType::Pointer flipper = FlipImageFilterType::New();
       flipper->SetInput( itkImage );
       itk::FixedArray<bool, 3> flipAxes;
       for(int i=0; i<3; ++i)
       {
         if(i == param1)
         {
           flipAxes[i] = true;
         }
         else
         {
           flipAxes[i] = false;
         }
       }
       flipper->SetFlipAxes(flipAxes);
       flipper->UpdateLargestPossibleRegion();
       newImage = mitk::ImportItkImage(flipper->GetOutput())->Clone();
       std::cout << "Image flipping successful." << std::endl;
       break;
     }
 
   case RESAMPLING:
     {
       std::string selectedInterpolator;
       ResampleImageFilterType::Pointer resampler = ResampleImageFilterType::New();
       switch (m_SelectedInterpolation)
       {
       case LINEAR:
         {
           LinearInterpolatorType::Pointer interpolator = LinearInterpolatorType::New();
           resampler->SetInterpolator(interpolator);
           selectedInterpolator = "Linear";
           break;
         }
       case NEAREST:
         {
           NearestInterpolatorType::Pointer interpolator = NearestInterpolatorType::New();
           resampler->SetInterpolator(interpolator);
           selectedInterpolator = "Nearest";
           break;
         }
       default:
         {
           LinearInterpolatorType::Pointer interpolator = LinearInterpolatorType::New();
           resampler->SetInterpolator(interpolator);
           selectedInterpolator = "Linear";
           break;
         }
       }
       resampler->SetInput( itkImage );
       resampler->SetOutputOrigin( itkImage->GetOrigin() );
 
       ImageType::SizeType input_size = itkImage->GetLargestPossibleRegion().GetSize();
       ImageType::SpacingType input_spacing = itkImage->GetSpacing();
 
       ImageType::SizeType output_size;
       ImageType::SpacingType output_spacing;
 
       output_size[0] = input_size[0] * (input_spacing[0] / dparam1);
       output_size[1] = input_size[1] * (input_spacing[1] / dparam2);
       output_size[2] = input_size[2] * (input_spacing[2] / dparam3);
       output_spacing [0] = dparam1;
       output_spacing [1] = dparam2;
       output_spacing [2] = dparam3;
 
       resampler->SetSize( output_size );
       resampler->SetOutputSpacing( output_spacing );
       resampler->SetOutputDirection( itkImage->GetDirection() );
 
       resampler->UpdateLargestPossibleRegion();
 
       ImageType::Pointer resampledImage = resampler->GetOutput();
 
       newImage = mitk::ImportItkImage( resampledImage );
       nameAddition << "_Resampled_" << selectedInterpolator;
       std::cout << "Resampling successful." << std::endl;
       break;
     }
 
+
+  case RESCALE:
+    {
+      FloatImageType::Pointer floatImage = FloatImageType::New();
+      CastToItkImage( newImage, floatImage );
+      itk::RescaleIntensityImageFilter<FloatImageType,FloatImageType>::Pointer filter = itk::RescaleIntensityImageFilter<FloatImageType,FloatImageType>::New();
+      filter->SetInput(0, floatImage);
+      filter->SetOutputMinimum(dparam1);
+      filter->SetOutputMaximum(dparam2);
+      filter->Update();
+      floatImage = filter->GetOutput();
+
+      newImage = mitk::Image::New();
+      newImage->InitializeByItk(floatImage.GetPointer());
+      newImage->SetVolume(floatImage->GetBufferPointer());
+      nameAddition << "_Rescaled";
+      std::cout << "Rescaling successful." << std::endl;
+
+      break;
+    }
+
   default:
     this->BusyCursorOff();
     return;
   }
   }
   catch (...)
   {
     this->BusyCursorOff();
     QMessageBox::warning(NULL, "Warning", "Problem when applying filter operation. Check your input...");
     return;
   }
 
   newImage->DisconnectPipeline();
 
   // adjust level/window to new image
   mitk::LevelWindow levelwindow;
   levelwindow.SetAuto( newImage );
   mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
   levWinProp->SetLevelWindow( levelwindow );
 
   // compose new image name
   std::string name = m_SelectedImageNode->GetNode()->GetName();
   if (name.find(".pic.gz") == name.size() -7 )
   {
     name = name.substr(0,name.size() -7);
   }
   name.append( nameAddition.str() );
 
   // create final result MITK data storage node
   mitk::DataNode::Pointer result = mitk::DataNode::New();
   result->SetProperty( "levelwindow", levWinProp );
   result->SetProperty( "name", mitk::StringProperty::New( name.c_str() ) );
   result->SetData( newImage );
 
   // for vector images, a different mapper is needed
   if(isVectorImage > 1)
   {
     mitk::VectorImageMapper2D::Pointer mapper =
       mitk::VectorImageMapper2D::New();
     result->SetMapper(1,mapper);
   }
 
   // reset GUI to ease further processing
 //  this->ResetOneImageOpPanel();
 
   // add new image to data storage and set as active to ease further processing
   GetDefaultDataStorage()->Add( result, m_SelectedImageNode->GetNode() );
   if ( m_Controls->cbHideOrig->isChecked() == true )
     m_SelectedImageNode->GetNode()->SetProperty( "visible", mitk::BoolProperty::New(false) );
   // TODO!! m_Controls->m_ImageSelector1->SetSelectedNode(result);
 
   // show the results
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   this->BusyCursorOff();
 }
 
 void QmitkBasicImageProcessing::SelectAction2(int operation)
 {
   // check which operation the user has selected and set parameters and GUI accordingly
   switch (operation)
   {
   case 2:
     m_SelectedOperation = ADD;
     break;
   case 3:
     m_SelectedOperation = SUBTRACT;
     break;
   case 4:
     m_SelectedOperation = MULTIPLY;
     break;
   case 5:
     m_SelectedOperation = DIVIDE;
     break;
   case 6:
     m_SelectedOperation = RESAMPLE_TO;
     break;
   case 8:
     m_SelectedOperation = AND;
     break;
   case 9:
     m_SelectedOperation = OR;
     break;
   case 10:
     m_SelectedOperation = XOR;
     break;
   default:
 //    this->ResetTwoImageOpPanel();
     return;
   }
   m_Controls->tlImage2->setEnabled(true);
   m_Controls->m_ImageSelector2->setEnabled(true);
   m_Controls->btnDoIt2->setEnabled(true);
 }
 
 void QmitkBasicImageProcessing::StartButton2Clicked()
 {
   mitk::Image::Pointer newImage1 = dynamic_cast<mitk::Image*>
     (m_SelectedImageNode->GetNode()->GetData());
   mitk::Image::Pointer newImage2 = dynamic_cast<mitk::Image*>
     (m_Controls->m_ImageSelector2->GetSelectedNode()->GetData());
 
   // check if images are valid
   if( (!newImage1) || (!newImage2) || (newImage1->IsInitialized() == false) || (newImage2->IsInitialized() == false) )
   {
     itkGenericExceptionMacro(<< "At least one of the input images are broken or not initialized. Returning");
     return;
   }
 
   this->BusyCursorOn();
 //  this->ResetTwoImageOpPanel();
 
   // check if 4D image and use filter on correct time step
   int time = ((QmitkSliderNavigatorWidget*)m_Controls->sliceNavigatorTime)->GetPos();
   if(time>=0)
   {
     mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
 
     timeSelector->SetInput(newImage1);
     timeSelector->SetTimeNr( time );
     timeSelector->UpdateLargestPossibleRegion();
     newImage1 = timeSelector->GetOutput();
     newImage1->DisconnectPipeline();
 
     timeSelector->SetInput(newImage2);
     timeSelector->SetTimeNr( time );
     timeSelector->UpdateLargestPossibleRegion();
     newImage2 = timeSelector->GetOutput();
     newImage2->DisconnectPipeline();
   }
 
   // reset GUI for better usability
 //  this->ResetTwoImageOpPanel();
 
   ImageType::Pointer itkImage1 = ImageType::New();
   ImageType::Pointer itkImage2 = ImageType::New();
 
   CastToItkImage( newImage1, itkImage1 );
   CastToItkImage( newImage2, itkImage2 );
 
   // Remove temp image
   newImage2 = NULL;
 
   std::string nameAddition = "";
 
   try
   {
   switch (m_SelectedOperation)
   {
   case ADD:
     {
       AddFilterType::Pointer addFilter = AddFilterType::New();
       addFilter->SetInput1( itkImage1 );
       addFilter->SetInput2( itkImage2 );
       addFilter->UpdateLargestPossibleRegion();
       newImage1 = mitk::ImportItkImage(addFilter->GetOutput())->Clone();
       nameAddition = "_Added";
     }
     break;
 
   case SUBTRACT:
     {
       SubtractFilterType::Pointer subFilter = SubtractFilterType::New();
       subFilter->SetInput1( itkImage1 );
       subFilter->SetInput2( itkImage2 );
       subFilter->UpdateLargestPossibleRegion();
       newImage1 = mitk::ImportItkImage(subFilter->GetOutput())->Clone();
       nameAddition = "_Subtracted";
     }
     break;
 
   case MULTIPLY:
     {
       MultiplyFilterType::Pointer multFilter = MultiplyFilterType::New();
       multFilter->SetInput1( itkImage1 );
       multFilter->SetInput2( itkImage2 );
       multFilter->UpdateLargestPossibleRegion();
       newImage1 = mitk::ImportItkImage(multFilter->GetOutput())->Clone();
       nameAddition = "_Multiplied";
     }
     break;
 
   case DIVIDE:
     {
       DivideFilterType::Pointer divFilter = DivideFilterType::New();
       divFilter->SetInput1( itkImage1 );
       divFilter->SetInput2( itkImage2 );
       divFilter->UpdateLargestPossibleRegion();
       newImage1 = mitk::ImportItkImage<FloatImageType>(divFilter->GetOutput())->Clone();
       nameAddition = "_Divided";
     }
     break;
 
   case AND:
     {
       AndImageFilterType::Pointer andFilter = AndImageFilterType::New();
       andFilter->SetInput1( itkImage1 );
       andFilter->SetInput2( itkImage2 );
       andFilter->UpdateLargestPossibleRegion();
       newImage1 = mitk::ImportItkImage(andFilter->GetOutput())->Clone();
       nameAddition = "_AND";
       break;
     }
 
   case OR:
     {
       OrImageFilterType::Pointer orFilter = OrImageFilterType::New();
       orFilter->SetInput1( itkImage1 );
       orFilter->SetInput2( itkImage2 );
       orFilter->UpdateLargestPossibleRegion();
       newImage1 = mitk::ImportItkImage(orFilter->GetOutput())->Clone();
       nameAddition = "_OR";
       break;
     }
 
   case XOR:
     {
       XorImageFilterType::Pointer xorFilter = XorImageFilterType::New();
       xorFilter->SetInput1( itkImage1 );
       xorFilter->SetInput2( itkImage2 );
       xorFilter->UpdateLargestPossibleRegion();
       newImage1 = mitk::ImportItkImage(xorFilter->GetOutput())->Clone();
       nameAddition = "_XOR";
       break;
     }
 
   case RESAMPLE_TO:
     {
 
       itk::NearestNeighborInterpolateImageFunction<ImageType>::Pointer nn_interpolator
         = itk::NearestNeighborInterpolateImageFunction<ImageType>::New();
 
       ResampleImageFilterType2::Pointer resampleFilter = ResampleImageFilterType2::New();
       resampleFilter->SetInput( itkImage1 );
       resampleFilter->SetReferenceImage( itkImage2 );
       resampleFilter->SetUseReferenceImage( true );
       resampleFilter->SetInterpolator( nn_interpolator );
       resampleFilter->SetDefaultPixelValue( 0 );
 
       ImageType::Pointer resampledImage = resampleFilter->GetOutput()->Clone();
 
       try
       {
         resampleFilter->UpdateLargestPossibleRegion();
       }
       catch( const itk::ExceptionObject &e)
       {
         MITK_WARN << "Updating resampling filter failed. ";
         MITK_WARN << "REASON: " << e.what();
       }
 
       newImage1 = mitk::ImportItkImage( resampledImage )->Clone();
       nameAddition = "_Resampled";
       break;
     }
 
   default:
     std::cout << "Something went wrong..." << std::endl;
     this->BusyCursorOff();
     return;
   }
   }
   catch (const itk::ExceptionObject& e )
   {
     this->BusyCursorOff();
     QMessageBox::warning(NULL, "ITK Exception", e.what() );
     QMessageBox::warning(NULL, "Warning", "Problem when applying arithmetic operation to two images. Check dimensions of input images.");
     return;
   }
 
   // disconnect pipeline; images will not be reused
   newImage1->DisconnectPipeline();
   itkImage1 = NULL;
   itkImage2 = NULL;
 
   // adjust level/window to new image and compose new image name
   mitk::LevelWindow levelwindow;
   levelwindow.SetAuto( newImage1 );
   mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
   levWinProp->SetLevelWindow( levelwindow );
   std::string name = m_SelectedImageNode->GetNode()->GetName();
   if (name.find(".pic.gz") == name.size() -7 )
   {
     name = name.substr(0,name.size() -7);
   }
 
   // create final result MITK data storage node
   mitk::DataNode::Pointer result = mitk::DataNode::New();
   result->SetProperty( "levelwindow", levWinProp );
   result->SetProperty( "name", mitk::StringProperty::New( (name + nameAddition ).c_str() ));
   result->SetData( newImage1 );
   GetDefaultDataStorage()->Add( result, m_SelectedImageNode->GetNode() );
 
   // show only the newly created image
   m_SelectedImageNode->GetNode()->SetProperty( "visible", mitk::BoolProperty::New(false) );
   m_Controls->m_ImageSelector2->GetSelectedNode()->SetProperty( "visible", mitk::BoolProperty::New(false) );
 
   // show the newly created image
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   this->BusyCursorOff();
 }
 
 void QmitkBasicImageProcessing::SelectInterpolator(int interpolator)
 {
   switch (interpolator)
   {
   case 0:
     {
       m_SelectedInterpolation = LINEAR;
       break;
     }
   case 1:
     {
       m_SelectedInterpolation = NEAREST;
       break;
     }
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingView.h b/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingView.h
index 846f62d217..e727fb698b 100644
--- a/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingView.h
+++ b/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingView.h
@@ -1,188 +1,189 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #if !defined(QmitkBasicImageProcessingView_H__INCLUDED)
 #define QmitkBasicImageProcessingView_H__INCLUDED
 
 #include "QmitkFunctionality.h"
 #include <org_mitk_gui_qt_basicimageprocessing_Export.h>
 #include "ui_QmitkBasicImageProcessingViewControls.h"
 
 #include "QmitkStepperAdapter.h"
 
 #include <berryISelectionListener.h>
 
 #include <mitkDataStorageSelection.h>
 
 /*!
 \brief This module allows to use some basic image processing filters for preprocessing, image enhancement and testing purposes
 
 Several basic ITK image processing filters, like denoising, morphological and edge detection
 are encapsulated in this module and can be selected via a list and an intuitive parameter input.
 The selected filter will be applied on the image, and a new image showing the output is displayed
 as result.
 Also, some image arithmetic operations are available.
 
 Images can be 3D or 4D.
 In the 4D case, the filters work on the 3D image selected via the
 time slider. The result is also a 3D image.
 
 \sa QmitkFunctionality, QObject
 
 \class QmitkBasicImageProcessing
 \author Tobias Schwarz
 \version 1.0 (3M3)
 \date 2009-05-10
 \ingroup Bundles
 */
 
 class BASICIMAGEPROCESSING_EXPORT QmitkBasicImageProcessing : public QmitkFunctionality
 {
   Q_OBJECT
 
 public:
 
   /*!
   \brief default constructor
   */
   QmitkBasicImageProcessing();
 
   /*!
   \brief default destructor
   */
   virtual ~QmitkBasicImageProcessing();
 
   /*!
   \brief method for creating the widget containing the application controls, like sliders, buttons etc.
   */
   virtual void CreateQtPartControl(QWidget *parent);
 
   /*!
   \brief method for creating the connections of main and control widget
   */
   virtual void CreateConnections();
 
   virtual void Activated();
 
   /*!
   \brief Invoked when the DataManager selection changed
   */
   virtual void OnSelectionChanged(std::vector<mitk::DataNode*> nodes);
 
 
   protected slots:
 
     /*
     * When an action is selected in the "one image ops" list box
     */
     void SelectAction(int action);
 
     /*
     * When an action is selected in the "two image ops" list box
     */
     void SelectAction2(int operation);
 
     /*
     * The "Execute" button in the "one image ops" box was triggered
     */
     void StartButtonClicked();
 
     /*
     * The "Execute" button in the "two image ops" box was triggered
     */
     void StartButton2Clicked();
 
     /*
     *  Switch between the one and the two image operations GUI
     */
     void ChangeGUI();
 
     void SelectInterpolator(int interpolator);
 
 private:
 
   /*
   * After a one image operation, reset the "one image ops" panel
   */
   void ResetOneImageOpPanel();
 
   /*
   * Helper method to reset the parameter set panel
   */
   void ResetParameterPanel();
 
   /*
   * After a two image operation, reset the "two image ops" panel
   */
   void ResetTwoImageOpPanel();
 
   /*!
   * controls containing sliders for scrolling through the slices
   */
   Ui::QmitkBasicImageProcessingViewControls *m_Controls;
 
   //mitk::DataNode*       m_SelectedImageNode;
   mitk::DataStorageSelection::Pointer m_SelectedImageNode;
   QmitkStepperAdapter*      m_TimeStepperAdapter;
 
   berry::ISelectionListener::Pointer m_SelectionListener;
 
   enum ActionType {
     NOACTIONSELECTED,
     CATEGORY_DENOISING,
     GAUSSIAN,
     MEDIAN,
     TOTALVARIATION,
     CATEGORY_MORPHOLOGICAL,
     DILATION,
     EROSION,
     OPENING,
     CLOSING,
     CATEGORY_EDGE_DETECTION,
     GRADIENT,
     LAPLACIAN,
     SOBEL,
     CATEGORY_MISC,
     THRESHOLD,
     INVERSION,
     DOWNSAMPLING,
     FLIPPING,
-    RESAMPLING
+    RESAMPLING,
+    RESCALE
   } m_SelectedAction;
 
   enum OperationType{
     TWOIMAGESNOACTIONSELECTED,
     CATEGORY_ARITHMETIC,
     ADD,
     SUBTRACT,
     MULTIPLY,
     DIVIDE,
     RESAMPLE_TO,
     CATEGORY_BOOLEAN,
     AND,
     OR,
     XOR
   } m_SelectedOperation;
 
   enum InterpolationType{
     LINEAR,
     NEAREST
   } m_SelectedInterpolation;
 };
 
 #endif // !defined(QmitkBasicImageProcessing_H__INCLUDED)
 
 
diff --git a/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingViewControls.ui b/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingViewControls.ui
index f4aeb26160..0febdf1c5a 100644
--- a/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingViewControls.ui
+++ b/Plugins/org.mitk.gui.qt.basicimageprocessing/src/internal/QmitkBasicImageProcessingViewControls.ui
@@ -1,437 +1,443 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkBasicImageProcessingViewControls</class>
  <widget class="QWidget" name="QmitkBasicImageProcessingViewControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>272</width>
+    <width>349</width>
     <height>980</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Form</string>
   </property>
   <layout class="QGridLayout" name="gridLayout_4">
    <item row="0" column="0">
     <widget class="QGroupBox" name="groupBox">
      <property name="title">
       <string/>
      </property>
      <property name="flat">
       <bool>true</bool>
      </property>
      <layout class="QGridLayout" name="gridLayout_3">
       <property name="leftMargin">
        <number>0</number>
       </property>
       <property name="topMargin">
        <number>6</number>
       </property>
       <property name="rightMargin">
        <number>0</number>
       </property>
       <property name="bottomMargin">
        <number>6</number>
       </property>
       <item row="0" column="0">
        <widget class="QRadioButton" name="rBOneImOp">
         <property name="text">
          <string>Filters
 (One Image)</string>
         </property>
         <property name="checked">
          <bool>true</bool>
         </property>
        </widget>
       </item>
       <item row="0" column="1">
        <widget class="QRadioButton" name="rBTwoImOp">
         <property name="text">
          <string>Arithmetic
 (Two Images)</string>
         </property>
        </widget>
       </item>
       <item row="1" column="0" colspan="2">
        <widget class="QLineEdit" name="leImage1">
         <property name="text">
          <string>Select an Image in Data Manager</string>
         </property>
         <property name="readOnly">
          <bool>true</bool>
         </property>
        </widget>
       </item>
       <item row="2" column="0">
        <widget class="QLabel" name="tlTime">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="toolTip">
          <string>Output image will be 3D</string>
         </property>
         <property name="text">
          <string>Choose time step if 4D
 (Slider for both images)</string>
         </property>
         <property name="wordWrap">
          <bool>false</bool>
         </property>
        </widget>
       </item>
       <item row="2" column="1">
        <widget class="QmitkSliderNavigatorWidget" name="sliceNavigatorTime" native="true">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="toolTip">
          <string>Output image will be 3D</string>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item row="2" column="0">
     <widget class="QGroupBox" name="gbTwoImageOps">
      <property name="enabled">
       <bool>true</bool>
      </property>
      <property name="title">
       <string/>
      </property>
      <property name="flat">
       <bool>true</bool>
      </property>
      <property name="checkable">
       <bool>false</bool>
      </property>
      <property name="checked">
       <bool>false</bool>
      </property>
      <layout class="QGridLayout" name="gridLayout_2">
       <property name="leftMargin">
        <number>0</number>
       </property>
       <property name="topMargin">
        <number>6</number>
       </property>
       <property name="rightMargin">
        <number>0</number>
       </property>
       <property name="bottomMargin">
        <number>0</number>
       </property>
       <item row="2" column="0" colspan="2">
        <widget class="QLabel" name="tlImage2">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="text">
          <string>Select second image:</string>
         </property>
         <property name="wordWrap">
          <bool>false</bool>
         </property>
         <property name="buddy">
          <cstring>m_ImageSelector2</cstring>
         </property>
        </widget>
       </item>
       <item row="3" column="0" colspan="3">
        <widget class="QmitkDataStorageComboBox" name="m_ImageSelector2">
         <property name="enabled">
          <bool>false</bool>
         </property>
        </widget>
       </item>
       <item row="6" column="0" colspan="3">
        <widget class="QPushButton" name="btnDoIt2">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="text">
          <string>E&amp;xecute</string>
         </property>
        </widget>
       </item>
       <item row="0" column="0">
        <widget class="QLabel" name="tlWhat2">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="text">
          <string>Select an operation:</string>
         </property>
         <property name="wordWrap">
          <bool>false</bool>
         </property>
         <property name="buddy">
          <cstring>cbWhat2</cstring>
         </property>
        </widget>
       </item>
       <item row="1" column="0" colspan="3">
        <widget class="QComboBox" name="cbWhat2">
         <property name="enabled">
          <bool>false</bool>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item row="3" column="0">
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>254</width>
        <height>403</height>
       </size>
      </property>
     </spacer>
    </item>
    <item row="1" column="0">
     <widget class="QGroupBox" name="gbOneImageOps">
      <property name="title">
       <string/>
      </property>
      <property name="flat">
       <bool>true</bool>
      </property>
      <layout class="QGridLayout" name="gridLayout">
       <property name="leftMargin">
        <number>0</number>
       </property>
       <property name="topMargin">
        <number>6</number>
       </property>
       <property name="rightMargin">
        <number>0</number>
       </property>
       <property name="bottomMargin">
        <number>0</number>
       </property>
       <item row="0" column="0" colspan="3">
        <widget class="QLabel" name="tlWhat1">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="text">
          <string>Select an operation:</string>
         </property>
         <property name="wordWrap">
          <bool>false</bool>
         </property>
         <property name="buddy">
          <cstring>cbWhat1</cstring>
         </property>
        </widget>
       </item>
       <item row="1" column="0" colspan="3">
        <widget class="QComboBox" name="cbWhat1">
         <property name="enabled">
          <bool>false</bool>
         </property>
        </widget>
       </item>
       <item row="2" column="0" colspan="3">
        <widget class="QLabel" name="tlParam">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="text">
          <string>... and parameters:</string>
         </property>
         <property name="wordWrap">
          <bool>false</bool>
         </property>
        </widget>
       </item>
       <item row="3" column="0">
        <widget class="QLabel" name="tlParam1">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="text">
          <string>Parameter 1:</string>
         </property>
         <property name="wordWrap">
          <bool>false</bool>
         </property>
         <property name="buddy">
          <cstring>sbParam1</cstring>
         </property>
        </widget>
       </item>
       <item row="4" column="0">
        <widget class="QLabel" name="tlParam2">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="text">
          <string>Parameter 2:</string>
         </property>
         <property name="wordWrap">
          <bool>false</bool>
         </property>
         <property name="buddy">
          <cstring>sbParam2</cstring>
         </property>
        </widget>
       </item>
       <item row="8" column="0" colspan="3">
        <widget class="QPushButton" name="btnDoIt">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="text">
          <string>&amp;Execute</string>
         </property>
        </widget>
       </item>
       <item row="7" column="0">
        <widget class="QCheckBox" name="cbHideOrig">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="text">
          <string>Hide Original Image</string>
         </property>
         <property name="checked">
          <bool>true</bool>
         </property>
        </widget>
       </item>
       <item row="5" column="0">
        <widget class="QLabel" name="tlParam3">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="text">
          <string>Parameter 3:</string>
         </property>
        </widget>
       </item>
       <item row="6" column="0">
        <widget class="QLabel" name="tlParam4">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="text">
          <string>Parameter 4:</string>
         </property>
        </widget>
       </item>
       <item row="6" column="2">
        <widget class="QComboBox" name="cbParam4">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
        </widget>
       </item>
       <item row="5" column="2">
        <widget class="QDoubleSpinBox" name="dsbParam3">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="layoutDirection">
          <enum>Qt::LeftToRight</enum>
         </property>
         <property name="alignment">
          <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter</set>
         </property>
        </widget>
       </item>
       <item row="4" column="2">
        <widget class="QDoubleSpinBox" name="dsbParam2">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
+        <property name="maximum">
+         <double>999999999.000000000000000</double>
+        </property>
        </widget>
       </item>
       <item row="3" column="2">
        <widget class="QDoubleSpinBox" name="dsbParam1">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="decimals">
          <number>2</number>
         </property>
+        <property name="maximum">
+         <double>999999999.000000000000000</double>
+        </property>
        </widget>
       </item>
       <item row="3" column="1">
        <widget class="QSpinBox" name="sbParam1">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
        </widget>
       </item>
       <item row="4" column="1">
        <widget class="QSpinBox" name="sbParam2">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>QmitkDataStorageComboBox</class>
    <extends>QComboBox</extends>
    <header location="global">QmitkDataStorageComboBox.h</header>
   </customwidget>
   <customwidget>
    <class>QmitkSliderNavigatorWidget</class>
    <extends>QWidget</extends>
    <header location="global">QmitkSliderNavigatorWidget.h</header>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
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 dd47e50ae5..d47d657bf2 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.cpp
@@ -1,859 +1,889 @@
 /*===================================================================
 
 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 <QTableWidgetItem>
 #include <QTableWidget>
 
 const std::string QmitkPreprocessingView::VIEW_ID =
     "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)
 {
 }
 
 QmitkPreprocessingView::~QmitkPreprocessingView()
 {
 
 }
 
 void QmitkPreprocessingView::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkPreprocessingViewControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
 
     m_Controls->m_MeasurementFrameTable->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
     m_Controls->m_MeasurementFrameTable->verticalHeader()->setResizeMode(QHeaderView::Stretch);
   }
 }
 
 void QmitkPreprocessingView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
   m_MultiWidget = &stdMultiWidget;
 }
 
 void QmitkPreprocessingView::StdMultiWidgetNotAvailable()
 {
   m_MultiWidget = NULL;
 }
 
 void QmitkPreprocessingView::CreateConnections()
 {
   if ( m_Controls )
   {
     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_AdcSignalAverage), SIGNAL(clicked()), this, SLOT(DoADCAverage()) );
     //connect( (QObject*)(m_Controls->m_AdcSignalFit), SIGNAL(clicked()), this, SLOT(DoADCFit()) );
     connect( (QObject*)(m_Controls->m_AkcSignalFit), SIGNAL(clicked()), this, SLOT(DoAKCFit()) );
     connect( (QObject*)(m_Controls->m_BiExpSignalFit), SIGNAL(clicked()), this, SLOT(DoBiExpFit()) );
     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()) );
   }
 }
 
+void QmitkPreprocessingView::DoDwiNormalization()
+{
+    if (m_DiffusionImage.IsNull())
+      return;
+
+    typedef mitk::DiffusionImage<DiffusionPixelType>  DiffusionImageType;
+    typedef itk::DwiNormilzationFilter<short>  FilterType;
+
+    FilterType::Pointer filter = FilterType::New();
+    filter->SetInput(m_DiffusionImage->GetVectorImage());
+    filter->SetGradientDirections(m_DiffusionImage->GetDirections());
+    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.front()->GetName().c_str();
+
+    imageNode->SetName((name+"_normalized").toStdString().c_str());
+    GetDefaultDataStorage()->Add(imageNode);
+}
+
 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.front()->GetName().c_str();
 
   imageNode->SetName((name+"_rounded").toStdString().c_str());
   GetDefaultDataStorage()->Add(imageNode);
 }
 
 void QmitkPreprocessingView::UpdateDwiBValueMapRounder(int i)
 {
   if (m_DiffusionImage.IsNull())
     return;
   //m_DiffusionImage->UpdateBValueMap();
   UpdateBValueTableWidget(i);
 }
 
 void QmitkPreprocessingView::CallMultishellToSingleShellFilter(itk::DWIVoxelFunctor * functor, mitk::DiffusionImage<DiffusionPixelType>::Pointer ImPtr, QString imageName)
 {
   typedef itk::RadialMultishellToSingleshellImageFilter<DiffusionPixelType, DiffusionPixelType> FilterType;
 
   // filter input parameter
   const mitk::DiffusionImage<DiffusionPixelType>::BValueMap
       &originalShellMap  = ImPtr->GetBValueMap();
 
   const mitk::DiffusionImage<DiffusionPixelType>::ImageType
       *vectorImage       = ImPtr->GetVectorImage();
 
   const mitk::DiffusionImage<DiffusionPixelType>::GradientDirectionContainerType::Pointer
       gradientContainer = ImPtr->GetDirections();
 
   const unsigned int
       &bValue            = ImPtr->GetReferenceBValue();
 
   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::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);
 
   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);
   }
 }
 
 void QmitkPreprocessingView::DoBiExpFit()
 {
   itk::BiExpFitFunctor::Pointer functor = itk::BiExpFitFunctor::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");
   }
 }
 
 void QmitkPreprocessingView::DoAKCFit()
 {
   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 + "_AKC");
   }
 }
 
 void QmitkPreprocessingView::DoADCFit()
 {
   // later
 }
 
 void QmitkPreprocessingView::DoADCAverage()
 {
   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");
   }
 }
 
 void QmitkPreprocessingView::DoAdcCalculation()
 {
   if (m_DiffusionImage.IsNull())
     return;
 
   typedef mitk::DiffusionImage< DiffusionPixelType >            DiffusionImageType;
   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);
   }
 }
 
 
 void QmitkPreprocessingView::UpdateBValueTableWidget(int i)
 {
 
   foreach(QCheckBox * box, m_ReduceGradientCheckboxes)
   {
     m_Controls->m_ReductionFrame->layout()->removeWidget(box);
     delete box;
   }
   foreach(QSpinBox * box, m_ReduceGradientSpinboxes)
   {
     m_Controls->m_ReductionFrame->layout()->removeWidget(box);
     delete box;
   }
   m_ReduceGradientCheckboxes.clear();
   m_ReduceGradientSpinboxes.clear();
 
   if (m_DiffusionImage.IsNull())
   {
     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);
 
 
     QCheckBox* checkBox;
     QSpinBox* spinBox;
     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)));
       m_Controls->m_B_ValueMap_TableWidget->setItem(i,1,new QTableWidgetItem(QString::number(it->second.size())));
 
       // Reduce Gradients GUI adaption
       if(roundedBValueMap.size() > 1){
         checkBox = new QCheckBox(QString::number(it->first) + " with " + QString::number(it->second.size()) + " directions");
         checkBox->setEnabled(true);
         checkBox->setChecked(true);
         checkBox->setCheckable(true);
         m_ReduceGradientCheckboxes.push_back(checkBox);
         m_Controls->m_ReductionFrame->layout()->addWidget(checkBox);
 
         spinBox = new QSpinBox();
         spinBox->setMaximum(it->second.size());
         spinBox->setValue(std::ceil((float)it->second.size()));
         spinBox->setMinimum(0);
         m_ReduceGradientSpinboxes.push_back(spinBox);
         m_Controls->m_ReductionFrame->layout()->addWidget(spinBox);
       }
       i++;
     }
   }
 
 }
 
 void QmitkPreprocessingView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
   bool foundDwiVolume = false;
   m_DiffusionImage = 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::DiffusionImage<short>*>(node->GetData()) )
     {
       foundDwiVolume = true;
       m_DiffusionImage = dynamic_cast<mitk::DiffusionImage<DiffusionPixelType>*>(node->GetData());
       m_Controls->m_DiffusionImageLabel->setText(node->GetName().c_str());
       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_AdcSignalFit->setEnabled(foundDwiVolume);
   m_Controls->m_AdcSignalAverage->setEnabled(foundDwiVolume);
   m_Controls->m_AkcSignalFit->setEnabled(foundDwiVolume);
   m_Controls->m_BiExpSignalFit->setEnabled(foundDwiVolume);
   m_Controls->m_CreateLengthCorrectedDwi->setEnabled(foundDwiVolume);
   m_Controls->m_CalcAdcButton->setEnabled(foundDwiVolume);
   m_Controls->m_targetBValueSpinBox->setEnabled(foundDwiVolume);
   m_Controls->m_OutputRMSErrorImage->setEnabled(foundDwiVolume);
+  m_Controls->m_NormalizeImageValuesButton->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());
 
   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++)
       {
         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);
       }
     //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);
 
   }
   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);
       }
 
     m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
     m_Controls->m_InputData->setTitle("Please Select Input Data");
   }
 }
 
 void QmitkPreprocessingView::Activated()
 {
   QmitkFunctionality::Activated();
 }
 
 void QmitkPreprocessingView::Deactivated()
 {
   QmitkFunctionality::Deactivated();
 }
 
 void QmitkPreprocessingView::DoHalfSphereGradientDirections()
 {
   GradientDirectionContainerType::Pointer gradientContainer = m_DiffusionImage->GetDirections();
 
   for (unsigned int j=0; j<gradientContainer->Size(); j++)
     if (gradientContainer->at(j)[0]<0)
       gradientContainer->at(j) = -gradientContainer->at(j);
   m_DiffusionImage->SetDirections(gradientContainer);
 }
 
 void QmitkPreprocessingView::DoApplyMesurementFrame()
 {
   if (m_DiffusionImage.IsNull())
     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();
     }
   m_DiffusionImage->SetMeasurementFrame(mf);
 }
 
 void QmitkPreprocessingView::DoShowGradientDirections()
 {
   if (m_DiffusionImage.IsNull())
     return;
 
   int maxIndex = 0;
   unsigned int maxSize = m_DiffusionImage->GetDimension(0);
   if (maxSize<m_DiffusionImage->GetDimension(1))
   {
     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++;
   }
 
   // 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;
 
   foreach(QCheckBox * box , m_ReduceGradientCheckboxes)
   {
     if(box->isChecked())
     {
       double BValue = (box->text().split(' ')).at(0).toDouble();
       shellSlectionMap[BValue] = originalShellMap[BValue];
       newNumGradientDirections.push_back(m_ReduceGradientSpinboxes.at(shellCounter)->value());
     }
     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 );
   QString name = m_SelectedDiffusionNodes.front()->GetName().c_str();
 
 
   QList<QSpinBox*>::iterator itSpinBox = m_ReduceGradientSpinboxes.begin();
   QList<QCheckBox*>::iterator itCheckBox = m_ReduceGradientCheckboxes.begin();
   while(itSpinBox != m_ReduceGradientSpinboxes.end() && itCheckBox != m_ReduceGradientCheckboxes.end())
   {
 
     name += "_";
     if((*itCheckBox)->isChecked()){
       name += QString::number((*itSpinBox)->value());
     }else
     {
       name += QString::number(0);
     }
     ++itSpinBox;
     ++itCheckBox;
   }
   imageNode->SetName(name.toStdString().c_str());
   GetDefaultDataStorage()->Add(imageNode);
 }
 
 void QmitkPreprocessingView::MergeDwis()
 {
   typedef mitk::DiffusionImage<DiffusionPixelType>              DiffusionImageType;
   typedef DiffusionImageType::GradientDirectionContainerType    GradientContainerType;
 
   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 std::vector< GradientContainerType::Pointer >  GradientListContainerType;
 
   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++)
   {
     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();
       }
     }
   }
 
   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);
 }
 
 void QmitkPreprocessingView::ExtractB0()
 {
   typedef mitk::DiffusionImage<DiffusionPixelType>              DiffusionImageType;
   typedef DiffusionImageType::GradientDirectionContainerType    GradientContainerType;
 
   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;
   }
 
   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
   {
 
     DiffusionImageType* vols =
         static_cast<DiffusionImageType*>(
           (*itemiter)->GetData());
 
     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();
 
     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"));
 
     GetDefaultDataStorage()->Add(node);
 
     ++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;
 
   mitk::DataStorage::SetOfObjects::const_iterator itemiter( m_SelectedDiffusionNodes.begin() );
   mitk::DataStorage::SetOfObjects::const_iterator itemiterend( m_SelectedDiffusionNodes.end() );
 
   while ( itemiter != itemiterend ) // for all items
   {
     DiffusionImageType* vols =
         static_cast<DiffusionImageType*>(
           (*itemiter)->GetData());
 
     std::string nodename;
     (*itemiter)->GetStringProperty("name", nodename);
 
     // Extract image using found index
     FilterType::Pointer filter = FilterType::New();
     filter->SetInput(vols->GetVectorImage());
     filter->SetDirections(vols->GetDirections());
     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"));
 
     GetDefaultDataStorage()->Add(node);
 
     /*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);
 
     ++itemiter;
   }
 
 
 
 }
 
 void QmitkPreprocessingView::AverageGradients()
 {
   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() );
 
   std::vector<mitk::DataNode::Pointer> nodes;
   while ( itemiter != itemiterend ) // for all items
   {
 
     mitk::DiffusionImage<DiffusionPixelType>* vols =
         static_cast<mitk::DiffusionImage<DiffusionPixelType>*>(
           (*itemiter)->GetData());
 
     vols->AverageRedundantGradients(m_Controls->m_Blur->value());
 
     ++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 c091b4d9b4..c47116f8e3 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.h
@@ -1,121 +1,122 @@
 /*===================================================================
 
 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 <string>
 
 #include "ui_QmitkPreprocessingViewControls.h"
 
 #include "itkDWIVoxelFunctor.h"
 
 #include "mitkDiffusionImage.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;
 
   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 DoApplyMesurementFrame();
   void DoReduceGradientDirections();
   void DoShowGradientDirections();
   void DoHalfSphereGradientDirections();
   void DoADCAverage();
   void DoADCFit();
   void DoAKCFit();
   void DoBiExpFit();
   void UpdateDwiBValueMapRounder(int i);
   void DoLengthCorrection();
   void DoAdcCalculation();
+  void DoDwiNormalization();
 
 protected:
   /** 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::DiffusionImage<DiffusionPixelType>::Pointer m_DiffusionImage;
   std::vector< mitk::DataNode::Pointer >            m_SelectedDiffusionNodes;
 
   QList<QCheckBox*> m_ReduceGradientCheckboxes;
   QList<QSpinBox*> m_ReduceGradientSpinboxes;
 
   void CallMultishellToSingleShellFilter(itk::DWIVoxelFunctor * functor, mitk::DiffusionImage<DiffusionPixelType>::Pointer ImPtr, QString imageName);
 };
 
 
 
 
 #endif // _QMITKPREPROCESSINGVIEW_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingViewControls.ui b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingViewControls.ui
index 0e01a927db..1385ca7647 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingViewControls.ui
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingViewControls.ui
@@ -1,692 +1,729 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkPreprocessingViewControls</class>
  <widget class="QWidget" name="QmitkPreprocessingViewControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>892</width>
-    <height>1351</height>
+    <height>1355</height>
    </rect>
   </property>
   <property name="minimumSize">
    <size>
     <width>0</width>
     <height>0</height>
    </size>
   </property>
   <property name="acceptDrops">
    <bool>false</bool>
   </property>
   <property name="windowTitle">
    <string>QmitkPreprocessingViewControls</string>
   </property>
   <property name="autoFillBackground">
    <bool>true</bool>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
     <widget class="QGroupBox" name="m_InputData">
      <property name="title">
       <string>Please Select Input Data</string>
      </property>
      <layout class="QGridLayout" name="gridLayout_2">
       <item row="0" column="0">
        <widget class="QLabel" name="label_5">
         <property name="toolTip">
          <string/>
         </property>
         <property name="text">
          <string>Raw DWI:</string>
         </property>
        </widget>
       </item>
       <item row="0" column="1">
        <widget class="QLabel" name="m_DiffusionImageLabel">
         <property name="text">
          <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; color:#ff0000;&quot;&gt;mandatory&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
         </property>
         <property name="wordWrap">
          <bool>true</bool>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="groupBox_5">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="title">
       <string>Info</string>
      </property>
      <layout class="QGridLayout" name="gridLayout_3">
       <item row="0" column="0">
        <widget class="QTableWidget" name="m_B_ValueMap_TableWidget">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="verticalScrollBarPolicy">
          <enum>Qt::ScrollBarAsNeeded</enum>
         </property>
         <property name="horizontalScrollBarPolicy">
          <enum>Qt::ScrollBarAlwaysOff</enum>
         </property>
         <attribute name="horizontalHeaderCascadingSectionResizes">
          <bool>true</bool>
         </attribute>
         <attribute name="horizontalHeaderDefaultSectionSize">
          <number>100</number>
         </attribute>
         <attribute name="horizontalHeaderStretchLastSection">
          <bool>true</bool>
         </attribute>
         <attribute name="verticalHeaderVisible">
          <bool>false</bool>
         </attribute>
         <attribute name="verticalHeaderCascadingSectionResizes">
          <bool>true</bool>
         </attribute>
         <column>
          <property name="text">
           <string>b-Value</string>
          </property>
         </column>
         <column>
          <property name="text">
           <string>Number of gradients</string>
          </property>
         </column>
        </widget>
       </item>
       <item row="5" column="0">
        <widget class="QCommandLinkButton" name="m_CreateLengthCorrectedDwi">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="text">
          <string>Round b-value</string>
         </property>
        </widget>
       </item>
       <item row="6" column="0">
        <widget class="Line" name="line_3">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
        </widget>
       </item>
       <item row="8" column="0">
        <widget class="Line" name="line_5">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
        </widget>
       </item>
       <item row="3" column="0">
        <widget class="Line" name="line_4">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
        </widget>
       </item>
       <item row="10" column="0">
        <widget class="QSpinBox" name="m_targetBValueSpinBox">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="maximum">
          <number>100000</number>
         </property>
        </widget>
       </item>
       <item row="9" column="0">
        <layout class="QHBoxLayout" name="horizontalLayout">
         <item>
          <widget class="QCommandLinkButton" name="m_AdcSignalAverage">
           <property name="enabled">
            <bool>false</bool>
           </property>
           <property name="toolTip">
            <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Create a new Diffusion Weighted Image (DWI) using an ADC average over all q-shells.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
           </property>
           <property name="text">
            <string>ADC Signal Average</string>
           </property>
          </widget>
         </item>
         <item>
          <widget class="QCommandLinkButton" name="m_AkcSignalFit">
           <property name="enabled">
            <bool>false</bool>
           </property>
           <property name="text">
            <string>AKC Signal Fit</string>
           </property>
          </widget>
         </item>
         <item>
          <widget class="QCommandLinkButton" name="m_BiExpSignalFit">
           <property name="enabled">
            <bool>false</bool>
           </property>
           <property name="text">
            <string>Bi-Exponential Signal Fit</string>
           </property>
          </widget>
         </item>
        </layout>
       </item>
       <item row="1" column="0">
        <layout class="QFormLayout" name="formLayout">
         <item row="0" column="0">
          <widget class="QLabel" name="label_2">
           <property name="toolTip">
            <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Define the sampling frame the b-Values are rounded with.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
           </property>
           <property name="text">
            <string>Sampling frame:</string>
           </property>
          </widget>
         </item>
         <item row="0" column="1">
          <widget class="QSpinBox" name="m_B_ValueMap_Rounder_SpinBox">
           <property name="enabled">
            <bool>false</bool>
           </property>
           <property name="toolTip">
            <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Round b-values to nearest multiple of this value (click &amp;quot;Round b-value&amp;quot; to create new image with these values).&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
           </property>
           <property name="correctionMode">
            <enum>QAbstractSpinBox::CorrectToNearestValue</enum>
           </property>
           <property name="minimum">
            <number>1</number>
           </property>
           <property name="maximum">
            <number>10000</number>
           </property>
           <property name="singleStep">
            <number>10</number>
           </property>
          </widget>
         </item>
        </layout>
       </item>
       <item row="7" column="0">
        <widget class="QCommandLinkButton" name="m_ShowGradientsButton">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="toolTip">
          <string>Generate pointset displaying the gradient vectors (applied measurement frame).</string>
         </property>
         <property name="statusTip">
          <string/>
         </property>
         <property name="whatsThis">
          <string notr="true"/>
         </property>
         <property name="text">
          <string>Show gradients</string>
         </property>
        </widget>
       </item>
       <item row="11" column="0">
        <widget class="QCheckBox" name="m_OutputRMSErrorImage">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="text">
          <string>Output RMS-Error Image</string>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="groupBox_2">
      <property name="title">
       <string>Non diffusion weighted image</string>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_3">
       <item>
        <widget class="QLabel" name="label_3">
         <property name="minimumSize">
          <size>
           <width>0</width>
           <height>30</height>
          </size>
         </property>
         <property name="text">
          <string>Average and extract all images that were acquired without diffusion weighting.</string>
         </property>
         <property name="wordWrap">
          <bool>true</bool>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QCommandLinkButton" name="m_ButtonExtractB0">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="toolTip">
          <string>If multiple baseline acquisitions are present, the default behaviour is to output an averaged image.</string>
         </property>
         <property name="statusTip">
          <string/>
         </property>
         <property name="whatsThis">
          <string notr="true"/>
         </property>
         <property name="text">
          <string>Extract B0</string>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QCheckBox" name="m_CheckExtractAll">
         <property name="toolTip">
          <string>Create a 3D+t data set containing all b0 images as timesteps</string>
         </property>
         <property name="text">
          <string>Extract all B0 images without averaging</string>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QCommandLinkButton" name="m_CalcAdcButton">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="toolTip">
          <string>If multiple baseline acquisitions are present, the default behaviour is to output an averaged image.</string>
         </property>
         <property name="statusTip">
          <string/>
         </property>
         <property name="whatsThis">
          <string notr="true"/>
         </property>
         <property name="text">
          <string>Calculate ADC map</string>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="m_ReduceSizeLayout">
      <property name="title">
       <string>Modify DWI</string>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_4">
       <item>
        <widget class="QFrame" name="frame">
         <property name="frameShape">
          <enum>QFrame::NoFrame</enum>
         </property>
         <property name="frameShadow">
          <enum>QFrame::Raised</enum>
         </property>
         <layout class="QFormLayout" name="formLayout_2">
-         <property name="margin">
+         <property name="leftMargin">
+          <number>0</number>
+         </property>
+         <property name="topMargin">
+          <number>0</number>
+         </property>
+         <property name="rightMargin">
+          <number>0</number>
+         </property>
+         <property name="bottomMargin">
           <number>0</number>
          </property>
          <item row="0" column="1">
           <widget class="QDoubleSpinBox" name="m_Blur">
            <property name="toolTip">
             <string comment="Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured." extracomment="Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured.">Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured.</string>
            </property>
            <property name="statusTip">
             <string comment="Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured." extracomment="Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured.">Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured.</string>
            </property>
            <property name="whatsThis">
             <string comment="Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured." extracomment="Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured.">Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured.</string>
            </property>
            <property name="decimals">
             <number>6</number>
            </property>
            <property name="maximum">
             <double>2.000000000000000</double>
            </property>
            <property name="singleStep">
             <double>0.000100000000000</double>
            </property>
            <property name="value">
             <double>0.001000000000000</double>
            </property>
           </widget>
          </item>
          <item row="0" column="0">
           <widget class="QLabel" name="label">
            <property name="toolTip">
             <string comment="Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured." extracomment="Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured.">Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured.</string>
            </property>
            <property name="statusTip">
             <string comment="Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured." extracomment="Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured.">Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured.</string>
            </property>
            <property name="whatsThis">
             <string comment="Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured." extracomment="Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured.">Accumulates the information that was acquired with multiple repetitions for one gradient. Vectors do not have to be precisely equal in order to be merged, if a &quot;Merge radius&quot; &gt; 0 is configured.</string>
            </property>
            <property name="text">
             <string>Merge radius</string>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item>
        <widget class="QCommandLinkButton" name="m_ButtonAverageGradients">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="toolTip">
          <string>Multiple acquistions of one gradient direction can be averaged. Due to rounding errors, similar gradients often differ in the last decimal positions. The Merge radius allows to average them by taking all directions within a certain radius into account.</string>
         </property>
         <property name="statusTip">
          <string/>
         </property>
         <property name="whatsThis">
          <string notr="true"/>
         </property>
         <property name="text">
          <string>Average redundant gradients</string>
         </property>
        </widget>
       </item>
       <item>
        <widget class="Line" name="line_2">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QFrame" name="m_ReductionFrame">
         <property name="frameShape">
          <enum>QFrame::NoFrame</enum>
         </property>
         <property name="frameShadow">
          <enum>QFrame::Raised</enum>
         </property>
         <layout class="QGridLayout" name="gridLayout_4">
-         <property name="margin">
+         <property name="leftMargin">
+          <number>0</number>
+         </property>
+         <property name="topMargin">
+          <number>0</number>
+         </property>
+         <property name="rightMargin">
+          <number>0</number>
+         </property>
+         <property name="bottomMargin">
           <number>0</number>
          </property>
          <property name="spacing">
           <number>9</number>
          </property>
          <item row="0" column="1">
           <widget class="QLabel" name="label_6">
            <property name="text">
             <string/>
            </property>
           </widget>
          </item>
          <item row="0" column="0">
           <widget class="QLabel" name="label_4">
            <property name="text">
             <string>Specify desired number of gradients per shell:</string>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item>
        <spacer name="horizontalSpacer_3">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>40</width>
           <height>20</height>
          </size>
         </property>
        </spacer>
       </item>
       <item>
        <widget class="QCommandLinkButton" name="m_ReduceGradientsButton">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="toolTip">
          <string>Retain only the specified number of gradient directions and according image volumes. The retained directions are spread equally over the half sphere using an iterative energy repulsion strategy.</string>
         </property>
         <property name="statusTip">
          <string/>
         </property>
         <property name="whatsThis">
          <string notr="true"/>
         </property>
         <property name="text">
          <string>Reduce number of gradients</string>
         </property>
        </widget>
       </item>
       <item>
        <widget class="Line" name="line">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QCommandLinkButton" name="m_MirrorGradientToHalfSphereButton">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="toolTip">
          <string>Sometimes the gradient directions are not located on one half sphere.</string>
         </property>
         <property name="statusTip">
          <string/>
         </property>
         <property name="whatsThis">
          <string notr="true"/>
         </property>
         <property name="text">
          <string>Mirror gradients to half sphere</string>
         </property>
        </widget>
       </item>
+      <item>
+       <widget class="QCommandLinkButton" name="m_NormalizeImageValuesButton">
+        <property name="enabled">
+         <bool>false</bool>
+        </property>
+        <property name="toolTip">
+         <string>Each image value is normalized with the corresponding basleine signal value.</string>
+        </property>
+        <property name="statusTip">
+         <string/>
+        </property>
+        <property name="whatsThis">
+         <string notr="true"/>
+        </property>
+        <property name="text">
+         <string>Normalize image values</string>
+        </property>
+       </widget>
+      </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="groupBox_7">
      <property name="title">
       <string>Merge selected images</string>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_6">
       <item>
        <widget class="QCommandLinkButton" name="m_MergeDwisButton">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="toolTip">
          <string>Merges selected DWIs of same dimension. If several b-values are present, the resulting image will contain multiple b-shells.</string>
         </property>
         <property name="statusTip">
          <string/>
         </property>
         <property name="whatsThis">
          <string notr="true"/>
         </property>
         <property name="text">
          <string>Merge selected DWIs</string>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="groupBox_4">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="title">
       <string>Measurment frame</string>
      </property>
      <layout class="QGridLayout" name="gridLayout">
       <item row="0" column="1">
        <spacer name="horizontalSpacer">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>40</width>
           <height>20</height>
          </size>
         </property>
        </spacer>
       </item>
       <item row="0" column="0">
        <widget class="QTableWidget" name="m_MeasurementFrameTable">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="sizePolicy">
          <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="minimumSize">
          <size>
           <width>0</width>
           <height>0</height>
          </size>
         </property>
         <property name="cursor" stdset="0">
          <cursorShape>IBeamCursor</cursorShape>
         </property>
         <property name="autoFillBackground">
          <bool>true</bool>
         </property>
         <property name="verticalScrollBarPolicy">
          <enum>Qt::ScrollBarAlwaysOff</enum>
         </property>
         <property name="horizontalScrollBarPolicy">
          <enum>Qt::ScrollBarAlwaysOff</enum>
         </property>
         <property name="showGrid">
          <bool>true</bool>
         </property>
         <property name="cornerButtonEnabled">
          <bool>false</bool>
         </property>
         <attribute name="horizontalHeaderVisible">
          <bool>false</bool>
         </attribute>
         <attribute name="horizontalHeaderCascadingSectionResizes">
          <bool>true</bool>
         </attribute>
         <attribute name="horizontalHeaderHighlightSections">
          <bool>true</bool>
         </attribute>
         <attribute name="horizontalHeaderMinimumSectionSize">
          <number>0</number>
         </attribute>
         <attribute name="verticalHeaderVisible">
          <bool>false</bool>
         </attribute>
         <attribute name="verticalHeaderCascadingSectionResizes">
          <bool>true</bool>
         </attribute>
         <attribute name="verticalHeaderHighlightSections">
          <bool>true</bool>
         </attribute>
         <row>
          <property name="text">
           <string>New Row</string>
          </property>
         </row>
         <row>
          <property name="text">
           <string>New Row</string>
          </property>
         </row>
         <row>
          <property name="text">
           <string>New Row</string>
          </property>
         </row>
         <column>
          <property name="text">
           <string>New Column</string>
          </property>
         </column>
         <column>
          <property name="text">
           <string>New Column</string>
          </property>
         </column>
         <column>
          <property name="text">
           <string>New Column</string>
          </property>
         </column>
        </widget>
       </item>
       <item row="1" column="0">
        <widget class="QCommandLinkButton" name="m_ModifyMeasurementFrame">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="toolTip">
          <string/>
         </property>
         <property name="statusTip">
          <string/>
         </property>
         <property name="whatsThis">
          <string notr="true"/>
         </property>
         <property name="text">
          <string>Apply new measurement frame</string>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>40</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <resources/>
  <connections/>
 </ui>