diff --git a/Modules/DiffusionImaging/Algorithms/itkElectrostaticRepulsionDiffusionGradientReductionFilter.txx b/Modules/DiffusionImaging/Algorithms/itkElectrostaticRepulsionDiffusionGradientReductionFilter.txx
index 5f154bc14d..5be3422111 100644
--- a/Modules/DiffusionImaging/Algorithms/itkElectrostaticRepulsionDiffusionGradientReductionFilter.txx
+++ b/Modules/DiffusionImaging/Algorithms/itkElectrostaticRepulsionDiffusionGradientReductionFilter.txx
@@ -1,254 +1,253 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 /*=========================================================================
 
 Program:   Tensor ToolKit - TTK
 Module:    $URL: svn://scm.gforge.inria.fr/svn/ttk/trunk/Algorithms/itkElectrostaticRepulsionDiffusionGradientReductionFilter.txx $
 Language:  C++
 Date:      $Date: 2010-06-07 13:39:13 +0200 (Mo, 07 Jun 2010) $
 Version:   $Revision: 68 $
 
 Copyright (c) INRIA 2010. All rights reserved.
 See LICENSE.txt for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 #ifndef _itk_ElectrostaticRepulsionDiffusionGradientReductionFilter_txx_
 #define _itk_ElectrostaticRepulsionDiffusionGradientReductionFilter_txx_
 #endif
 
 #define _USE_MATH_DEFINES
 
 #include "itkElectrostaticRepulsionDiffusionGradientReductionFilter.h"
 #include <math.h>
 #include <time.h>
 #include <itkImageRegionIterator.h>
 #include <itkImageRegion.h>
 
 namespace itk
 {
 
 template <class TInputScalarType, class TOutputScalarType>
 ElectrostaticRepulsionDiffusionGradientReductionFilter<TInputScalarType, TOutputScalarType>
 ::ElectrostaticRepulsionDiffusionGradientReductionFilter()
 {
     this->SetNumberOfRequiredInputs( 1 );
 }
 
 template <class TInputScalarType, class TOutputScalarType>
 double
 ElectrostaticRepulsionDiffusionGradientReductionFilter<TInputScalarType, TOutputScalarType>
 ::Costs()
 {
     double costs = 2*M_PI;
     for (IndicesVector::iterator it = m_UsedGradientIndices.begin(); it!=m_UsedGradientIndices.end(); ++it)
     {
         for (IndicesVector::iterator it2 = m_UsedGradientIndices.begin(); it2!=m_UsedGradientIndices.end(); ++it2)
             if (it != it2)
             {
                 vnl_vector_fixed<double,3> v1 = m_OriginalGradientDirections->at(*it);
                 vnl_vector_fixed<double,3> v2 = m_OriginalGradientDirections->at(*it2);
 
                 v1.normalize(); v2.normalize();
                 double temp = dot_product(v1,v2);
                 if (temp>1)
                     temp = 1;
                 else if (temp<-1)
                     temp = -1;
 
                 double angle = acos(temp);
 
                 if (angle<costs)
                     costs = angle;
 
                 temp = dot_product(-v1,v2);
                 if (temp>1)
                     temp = 1;
                 else if (temp<-1)
                     temp = -1;
 
                 angle = acos(temp);
                 if (angle<costs)
                     costs = angle;
             }
     }
 
     return costs;
 }
 
 template <class TInputScalarType, class TOutputScalarType>
 void
 ElectrostaticRepulsionDiffusionGradientReductionFilter<TInputScalarType, TOutputScalarType>
 ::GenerateData()
 {
     unsigned int randSeed = time(NULL);
 
-    if(m_InputBValueMap.empty())
-    {
-        // if no InputMap is set, do the same for each shell
-        m_InputBValueMap = m_OriginalBValueMap;
-    }
+    if(m_InputBValueMap.empty() || m_NumGradientDirections.size()!=m_InputBValueMap.size())
+        return;
 
     if(m_InputBValueMap.find(0) != m_InputBValueMap.end())
     {
         //delete b0 from input BValueMap
         m_InputBValueMap.erase(0);
     }
 
     BValueMap manipulatedMap = m_OriginalBValueMap;
 
     int shellCounter = 0;
     for(BValueMap::iterator it = m_InputBValueMap.begin(); it != m_InputBValueMap.end(); it++ )
     {
         srand(randSeed);
 
         // initialize index vectors
         m_UsedGradientIndices.clear();
         m_UnusedGradientIndices.clear();
 
         if ( it->second.size() <= m_NumGradientDirections[shellCounter] )
         {
             itkWarningMacro( << "current directions: " << it->second.size() << " wanted directions: " << m_NumGradientDirections[shellCounter]);
             m_NumGradientDirections[shellCounter] = it->second.size();
             shellCounter++;
             continue;
         }
         MITK_INFO << "Shell number: " << shellCounter;
 
         int c=0;
 
         for (int i=0; i<it->second.size(); i++)
         {
             if (c<m_NumGradientDirections[shellCounter])
                 m_UsedGradientIndices.push_back(it->second.at(i));
             else
                 m_UnusedGradientIndices.push_back(it->second.at(i));
             c++;
         }
 
         double minAngle = Costs();
         double newMinAngle = 0;
 
         MITK_INFO << "minimum angle: " << 180*minAngle/M_PI;
         int stagnationCount = 0;
         int rejectionCount = 0;
-        int maxRejections = 10000;// m_NumGradientDirections[shellCounter] * 1000;
+        int maxRejections = m_NumGradientDirections[shellCounter] * 1000;
+        if (maxRejections<10000)
+            maxRejections = 10000;
         int iUsed = 0;
         if (m_UsedGradientIndices.size()>0)
             while ( stagnationCount<1000 && rejectionCount<maxRejections )
             {
                 // make proposal for new gradient configuration by randomly removing one of the currently used directions and instead adding one of the unused directions
                 //int iUsed = rand() % m_UsedGradientIndices.size();
                 int iUnUsed = rand() % m_UnusedGradientIndices.size();
                 int vUsed = m_UsedGradientIndices.at(iUsed);
                 int vUnUsed = m_UnusedGradientIndices.at(iUnUsed);
                 m_UsedGradientIndices.at(iUsed) = vUnUsed;
                 m_UnusedGradientIndices.at(iUnUsed) = vUsed;
 
                 newMinAngle = Costs();          // calculate costs of proposed configuration
                 if (newMinAngle > minAngle)     // accept or reject proposal
                 {
                     MITK_INFO << "minimum angle: " << 180*newMinAngle/M_PI;
 
                     if ( (newMinAngle-minAngle)<0.01 )
                         stagnationCount++;
                     else
                         stagnationCount = 0;
 
                     minAngle = newMinAngle;
                     rejectionCount = 0;
                 }
                 else
                 {
                     rejectionCount++;
                     m_UsedGradientIndices.at(iUsed) = vUsed;
                     m_UnusedGradientIndices.at(iUnUsed) = vUnUsed;
                 }
                 iUsed++;
                 iUsed = iUsed % m_UsedGradientIndices.size();
             }
         manipulatedMap[it->first] = m_UsedGradientIndices;
         shellCounter++;
     }
 
     int vecLength = 0 ;
     for(BValueMap::iterator it = manipulatedMap.begin(); it != manipulatedMap.end(); it++)
         vecLength += it->second.size();
 
     // initialize output image
     typename OutputImageType::Pointer outImage = OutputImageType::New();
     outImage->SetSpacing( this->GetInput()->GetSpacing() );   // Set the image spacing
     outImage->SetOrigin( this->GetInput()->GetOrigin() );     // Set the image origin
     outImage->SetDirection( this->GetInput()->GetDirection() );  // Set the image direction
     outImage->SetLargestPossibleRegion( this->GetInput()->GetLargestPossibleRegion());
     outImage->SetBufferedRegion( this->GetInput()->GetLargestPossibleRegion() );
     outImage->SetRequestedRegion( this->GetInput()->GetLargestPossibleRegion() );
     outImage->SetVectorLength( vecLength ); // Set the vector length
     outImage->Allocate();
 
     itk::ImageRegionIterator< OutputImageType > newIt(outImage, outImage->GetLargestPossibleRegion());
     newIt.GoToBegin();
 
     typename InputImageType::Pointer inImage = const_cast<InputImageType*>(this->GetInput(0));
     itk::ImageRegionIterator< InputImageType > oldIt(inImage, inImage->GetLargestPossibleRegion());
     oldIt.GoToBegin();
 
     // initial new value of voxel
     OutputPixelType newVec;
     newVec.SetSize( vecLength );
     newVec.AllocateElements( vecLength );
 
     // generate new pixel values
     while(!newIt.IsAtEnd())
     {
         // init new vector with zeros
         newVec.Fill(0.0);
         InputPixelType oldVec = oldIt.Get();
 
         int index = 0;
         for(BValueMap::iterator it=manipulatedMap.begin(); it!=manipulatedMap.end(); it++)
             for(int j=0; j<it->second.size(); j++)
             {
                 newVec[index] = oldVec[it->second.at(j)];
                 index++;
             }
         newIt.Set(newVec);
 
         ++newIt;
         ++oldIt;
     }
 
     // set new gradient directions
     m_GradientDirections = GradientDirectionContainerType::New();
     int index = 0;
     for(BValueMap::iterator it = manipulatedMap.begin(); it != manipulatedMap.end(); it++)
         for(int j = 0; j < it->second.size(); j++)
         {
             m_GradientDirections->InsertElement(index, m_OriginalGradientDirections->at(it->second.at(j)));
             index++;
         }
 
     this->SetNumberOfRequiredOutputs (1);
     this->SetNthOutput (0, outImage);
     MITK_INFO << "...done";
 }
 
 
 
 } // end of namespace
diff --git a/Modules/DiffusionImaging/IODataStructures/DiffusionWeightedImages/mitkDiffusionImage.h b/Modules/DiffusionImaging/IODataStructures/DiffusionWeightedImages/mitkDiffusionImage.h
index 78aaceab66..897a87a6ee 100644
--- a/Modules/DiffusionImaging/IODataStructures/DiffusionWeightedImages/mitkDiffusionImage.h
+++ b/Modules/DiffusionImaging/IODataStructures/DiffusionWeightedImages/mitkDiffusionImage.h
@@ -1,124 +1,126 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 #ifndef __mitkDiffusionImage__h
 #define __mitkDiffusionImage__h
 
 #include "mitkImage.h"
 #include "itkVectorImage.h"
 #include "itkVectorImageToImageAdaptor.h"
 #include <iomanip>
 #include <itkCommand.h>
 
 namespace mitk
 {
 
 /**
   * \brief this class encapsulates diffusion volumes (vectorimages not
   * yet supported by mitkImage)
   */
 template<class TPixelType>
 class DiffusionImage : public Image
 {
 
 public:
   typedef TPixelType PixelType;
   typedef typename itk::VectorImage<TPixelType, 3>
   ImageType;
   typedef vnl_vector_fixed< double, 3 >       GradientDirectionType;
   typedef itk::VectorContainer< unsigned int,
   GradientDirectionType >                   GradientDirectionContainerType;
   typedef itk::VectorImageToImageAdaptor< TPixelType, 3 >
   AdaptorType;
   typedef vnl_matrix_fixed< double, 3, 3 >      MeasurementFrameType;
 
   // BValue Map
   // key   := b-Value
   // value := indicesVector (containing corresponding gradient directions for a b-Value-Shell
   typedef std::vector< unsigned int > IndicesVector;
   typedef std::map< double , IndicesVector >  BValueMap;
 
   mitkClassMacro( DiffusionImage, Image )
   itkNewMacro(Self)
 
 
   void AverageRedundantGradients(double precision);
 
   GradientDirectionContainerType::Pointer CalcAveragedDirectionSet(double precision, GradientDirectionContainerType::Pointer directions);
 
   void CorrectDKFZBrokenGradientScheme(double precision);
 
   typename ImageType::Pointer GetVectorImage() { return m_VectorImage; }
   void SetVectorImage(typename ImageType::Pointer image ) { this->m_VectorImage = image; }
 
   void InitializeFromVectorImage();
   void SetDisplayIndexForRendering(int displayIndex);
 
   GradientDirectionContainerType::Pointer GetDirections() { return m_OriginalDirections; }
+  GradientDirectionContainerType::Pointer GetDirectionsWithMeasurementFrame() { return m_Directions; }
+
   void SetDirections( GradientDirectionContainerType::Pointer directions )
   {
       this->m_OriginalDirections = directions;
       ApplyMeasurementFrame();
   }
   void SetDirections(const std::vector<itk::Vector<double,3> > directions);
 
   MeasurementFrameType GetMeasurementFrame()  { return m_MeasurementFrame; }
   void SetMeasurementFrame( MeasurementFrameType mFrame )  { this->m_MeasurementFrame = mFrame; this->ApplyMeasurementFrame(); }
 
   bool AreAlike(GradientDirectionType g1, GradientDirectionType g2, double precision);
   int GetNumDirections();
   int GetNumB0();
 
   float GetB_Value(int i);
   bool IsMultiBval();
   void UpdateBValueList();
 
   IndicesVector GetB0Indices();
 
   itkGetMacro(B_Value, float)
   itkSetMacro(B_Value, float)
 
   BValueMap GetB_ValueMap(){ return m_B_ValueMap; }
 
   void AddDirectionsContainerObserver();
   void RemoveDirectionsContainerObserver();
 
 protected:
   DiffusionImage();
   virtual ~DiffusionImage();
 
   void ApplyMeasurementFrame();
 
   typename ImageType::Pointer               m_VectorImage;
   GradientDirectionContainerType::Pointer   m_Directions;
   GradientDirectionContainerType::Pointer   m_OriginalDirections;
   float                                     m_B_Value;
   typename AdaptorType::Pointer             m_VectorImageAdaptor;
   int                                       m_DisplayIndex;
   MeasurementFrameType                      m_MeasurementFrame;
   BValueMap                                 m_B_ValueMap;
 
 
 
   unsigned long    m_DirectionsObserverTag;
 };
 
 } // namespace mitk
 
 #include "mitkDiffusionImage.txx"
 
 #endif /* __mitkDiffusionImage__h */
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 17d080956d..5b8a98a47d 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.cpp
@@ -1,521 +1,580 @@
 /*===================================================================
 
 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>
 
 // 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 <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(const QmitkPreprocessingView& other)
 {
     Q_UNUSED(other)
     throw std::runtime_error("Copy constructor not implemented");
 }
 
 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 )
     {
-        m_Controls->m_ReductionFrame->setLayout(new QGridLayout);
         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_ButtonBrainMask), SIGNAL(clicked()), this, SLOT(BrainMask()) );
         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()) );
     }
 }
 
 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_ButtonBrainMask->setEnabled(foundDwiVolume);
     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);
 
 
     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 (foundDwiVolume)
     {
         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);
             }
 
         typedef mitk::DiffusionImage<short*>::BValueMap BValueMap;
         typedef mitk::DiffusionImage<short*>::BValueMap::iterator BValueMapIterator;
 
         BValueMap bValMap =  m_DiffusionImage->GetB_ValueMap();
         BValueMapIterator it = bValMap.begin();
         m_Controls->m_BvalueTable->clear();
         m_Controls->m_BvalueTable->setRowCount(bValMap.size() );
         QStringList headerList;
         headerList << "b-Value" << "Number of gradients";
         m_Controls->m_BvalueTable->setHorizontalHeaderLabels(headerList);
 
 
         QCheckBox* checkBox;
         QSpinBox* spinBox;
         int i = 0 ;
         for(;it != bValMap.end(); it++)
         {
             m_Controls->m_BvalueTable->setItem(i,0,new QTableWidgetItem(QString::number(it->first)));
             m_Controls->m_BvalueTable->setItem(i,1,new QTableWidgetItem(QString::number(it->second.size())));
 
             // Reduce Gradients GUI adaption
             if(it->first != 0 && bValMap.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->setValue(std::ceil((float)it->second.size()/2));
                 spinBox->setMaximum(it->second.size());
                 spinBox->setMinimum(0);
                 m_ReduceGradientSpinboxes.push_back(spinBox);
                 m_Controls->m_ReductionFrame->layout()->addWidget(spinBox);
             }
             i++;
         }
     }
     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_BvalueTable->clear();
         m_Controls->m_BvalueTable->setRowCount(1);
         QStringList headerList;
         headerList << "b-Value" << "Number of gradients";
         m_Controls->m_BvalueTable->setHorizontalHeaderLabels(headerList);
         m_Controls->m_BvalueTable->setItem(0,0,new QTableWidgetItem("-"));
         m_Controls->m_BvalueTable->setItem(0,1,new QTableWidgetItem("-"));
         m_Controls->m_DiffusionImageLabel->setText("-");
     }
 }
 
 void QmitkPreprocessingView::Activated()
 {
     QmitkFunctionality::Activated();
 }
 
 void QmitkPreprocessingView::Deactivated()
 {
     QmitkFunctionality::Deactivated();
 }
 
 void QmitkPreprocessingView::DoHalfSphereGradientDirections()
 {
     GradientDirectionContainerType::Pointer gradientContainer = m_DiffusionImage->GetDirections();
 
     for (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;
 
-    GradientDirectionContainerType::Pointer gradientContainer = m_DiffusionImage->GetDirections();
+    int maxIndex = 0;
+    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::PointSet::Pointer pointset = mitk::PointSet::New();
-    for (int j=0; j<gradientContainer->Size(); j++)
+    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->GetB_ValueMap();
+
+    GradientDirectionContainerType::Pointer gradientContainer = m_DiffusionImage->GetDirectionsWithMeasurementFrame();
+    mitk::Geometry3D::Pointer geometry = m_DiffusionImage->GetGeometry();
+    int shellCount = 1;
+    for(BValueMapIterator it = bValMap.begin(); it!=bValMap.end(); ++it)
     {
-        mitk::Point3D p;
-        vnl_vector_fixed< double, 3 > v = gradientContainer->at(j);
-        if (v.magnitude()>mitk::eps)
+        mitk::PointSet::Pointer pointset = mitk::PointSet::New();
+        for (int j=0; j<it->second.size(); j++)
         {
-            p[0] = v[0]*100;
-            p[1] = v[1]*100;
-            p[2] = v[2]*100;
-            pointset->InsertPoint(j, p);
+            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(pointset);
+    node->SetData(originSet);
     QString name = m_SelectedDiffusionNodes.front()->GetName().c_str();
-    name += "_GradientDirections";
+    name += "_Origin";
     node->SetName(name.toStdString().c_str());
-    node->SetProperty("pointsize", mitk::FloatProperty::New(2.5));
-    node->SetProperty("color", mitk::ColorProperty::New(1,0,0));
-
-    GetDefaultDataStorage()->Add(node);
+    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->GetB_ValueMap();
     std::vector<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->SetB_Value(m_DiffusionImage->GetB_Value());
     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();
 
     foreach(QSpinBox* box, m_ReduceGradientSpinboxes)
     {
         name += "_";
         name += QString::number(box->value());
     }
 
     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);
 
         ++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;
     }
 }
 
 void QmitkPreprocessingView::BrainMask()
 {
     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
     {
 
         mitk::DiffusionImage<DiffusionPixelType>* vols =
                 static_cast<mitk::DiffusionImage<DiffusionPixelType>*>(
                     (*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());
 
         typedef itk::CastImageFilter<itk::Image<short,3>, itk::Image<unsigned short,3> > CastFilterType;
         CastFilterType::Pointer castfilter = CastFilterType::New();
         castfilter->SetInput(filter->GetOutput());
 
         typedef itk::BrainMaskExtractionImageFilter<unsigned char> MaskFilterType;
         MaskFilterType::Pointer maskfilter = MaskFilterType::New();
         maskfilter->SetInput(castfilter->GetOutput());
         maskfilter->Update();
 
         mitk::Image::Pointer mitkImage = mitk::Image::New();
         mitkImage->InitializeByItk( maskfilter->GetOutput() );
         mitkImage->SetVolume( maskfilter->GetOutput()->GetBufferPointer() );
         mitk::DataNode::Pointer node=mitk::DataNode::New();
         node->SetData( mitkImage );
         node->SetProperty( "name", mitk::StringProperty::New(nodename + "_Mask"));
 
         GetDefaultDataStorage()->Add(node);
 
         ++itemiter;
     }
 }
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 e38818d6bf..bae365a5fd 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingViewControls.ui
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingViewControls.ui
@@ -1,549 +1,549 @@
 <?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>389</width>
-    <height>989</height>
+    <height>992</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="groupBox_6">
      <property name="title">
       <string>Data</string>
      </property>
      <layout class="QGridLayout" name="gridLayout_2">
       <item row="0" column="0">
        <widget class="QLabel" name="label_5">
         <property name="text">
          <string>Diffusion Image:</string>
         </property>
        </widget>
       </item>
       <item row="0" column="1">
        <widget class="QLabel" name="m_DiffusionImageLabel">
         <property name="text">
          <string>-</string>
         </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_BvalueTable">
         <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="0" column="1">
+       <spacer name="horizontalSpacer_2">
+        <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="1" 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.</string>
+         <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="0" column="1">
-       <spacer name="horizontalSpacer_2">
-        <property name="orientation">
-         <enum>Qt::Horizontal</enum>
-        </property>
-        <property name="sizeHint" stdset="0">
-         <size>
-          <width>40</width>
-          <height>20</height>
-         </size>
-        </property>
-       </spacer>
-      </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="m_ReduceSizeLayout">
      <property name="title">
       <string>Reduce size</string>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_4">
       <item>
        <widget class="QLabel" name="label_2">
         <property name="minimumSize">
          <size>
           <width>0</width>
           <height>70</height>
          </size>
         </property>
         <property name="text">
          <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 anyway by taking into account all directions within a certain radius.</string>
         </property>
         <property name="wordWrap">
          <bool>true</bool>
         </property>
        </widget>
       </item>
       <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">
           <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/>
         </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="QCommandLinkButton" name="m_MirrorGradientToHalfSphereButton">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="toolTip">
          <string>Mirror all gradients around one axis.</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="Line" name="line">
         <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">
           <number>9</number>
          </property>
          <property name="spacing">
           <number>9</number>
          </property>
          <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>
          <item row="0" column="1">
           <widget class="QLabel" name="label_6">
            <property name="text">
             <string/>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </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.</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>
      </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/>
         </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 without averaging</string>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="groupBox_3">
      <property name="title">
       <string>Brain mask</string>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_5">
       <item>
        <widget class="QCommandLinkButton" name="m_ButtonBrainMask">
         <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>Estimate binary brain mask</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>10</width>
           <height>10</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="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 mesurement 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>